diff --git a/.importlinter b/.importlinter index 944b9956f6..7213f54afa 100644 --- a/.importlinter +++ b/.importlinter @@ -3,6 +3,7 @@ root_package = physicsnemo include_external_packages = True contract_types = forbidden_import: test.ci_tests.prevent_untracked_imports.ForbiddenImportContract +exclude_type_checking_imports = true [importlinter:contract:physicsnemo-modules] name = Prevent Upward Imports in the PhysicsNemo Structure diff --git a/examples/minimal/mesh/README.md b/examples/minimal/mesh/README.md new file mode 100644 index 0000000000..b36d8a0384 --- /dev/null +++ b/examples/minimal/mesh/README.md @@ -0,0 +1,167 @@ +# PhysicsNeMo-Mesh Tutorials + +This directory contains a series of progressive tutorials introducing +**PhysicsNeMo-Mesh** - NVIDIA's GPU-accelerated mesh processing library for +physics-AI applications. + +## What is PhysicsNeMo-Mesh? + +PhysicsNeMo-Mesh is a PyTorch-based library for working with simplicial meshes +(point clouds, curves, surfaces, volumes) in a unified, dimensionally-generic +framework. Key features include: + +- **GPU-Accelerated**: All operations vectorized with PyTorch, run natively on CUDA +- **Dimensionally Generic**: Works with n-D manifolds embedded in m-D spaces +- **TensorDict Integration**: Structured data management with automatic device handling +- **Differentiable**: Seamless integration with PyTorch autograd +- **Flexible Data**: Arbitrary-rank tensor fields on points, cells, or globally + +For the complete feature list, see the +[physicsnemo.mesh README](../../../physicsnemo/mesh/README.md). + +## Prerequisites + +- Python 3.10+ +- PyTorch 2.0+ +- CUDA-capable GPU (recommended, not required) + +## Installation + +```bash +pip install nvidia-physicsnemo pyvista[all,trame] matplotlib jupyter +``` + +Or install from the repository: + +```bash +pip install -e ".[mesh]" +``` + +## Tutorial Overview + + +| Tutorial | Topic | What You'll Learn | +|----------|-------|-------------------| +| **1. Getting Started** | Core concepts | Mesh structure, data attachment, GPU acceleration | +| **2. Operations** | Mesh manipulation | Transformations, subdivision, slicing, merging | +| **3. Discrete Calculus** | Mathematical operators | Gradients, divergence, curl, curvature | +| **4. Neighbors & Spatial** | Queries | Adjacency, BVH, sampling, interpolation | +| **5. Quality & Repair** | Mesh health | Validation, quality metrics, repair | +| **6. ML Integration** | Production workflows | Performance, batching, torch.compile | + + +## Running the Tutorials + +### Option 1: Jupyter Notebook + +```bash +cd examples/minimal/mesh +jupyter notebook +``` + +Then open any `tutorial_*.ipynb` file. + +### Option 2: JupyterLab + +```bash +cd examples/minimal/mesh +jupyter lab +``` + +### Option 3: VS Code / Cursor + +Open the `.ipynb` files directly - they work with the built-in notebook support. + +## Tutorial Contents + +### Tutorial 1: Getting Started + +**File**: `tutorial_1_getting_started.ipynb` + +Learn the core concepts - a `Mesh` is just 5 fields: 2 for geometry, 3 for data. + +- The 5-field data structure (points, cells, point_data, cell_data, global_data) +- Creating meshes from scratch +- Loading from PyVista and built-in primitives +- Attaching scalar, vector, and tensor data +- Visualization with `.draw()` +- GPU acceleration with `.to("cuda")` +- Autograd integration + +### Tutorial 2: Operations and Transformations + +**File**: `tutorial_2_operations.ipynb` + +Learn mesh manipulation operations. + +- Geometric transformations (translate, rotate, scale, transform) +- Subdivision schemes (linear, Loop, Butterfly) +- Slicing (slice_cells, slice_points) +- Merging multiple meshes +- Boundary and facet extraction +- Data conversion (cell_data_to_point_data, point_data_to_cell_data) +- Topology checks (is_watertight, is_manifold) + +### Tutorial 3: Discrete Calculus and Differential Geometry + +**File**: `tutorial_3_calculus.ipynb` + +Learn mathematical operations on meshes. + +- Computing gradients (LSQ and DEC methods) +- Divergence and curl +- Gaussian and mean curvature +- Intrinsic vs extrinsic derivatives +- Vector calculus identities +- Physics-informed feature extraction + +### Tutorial 4: Neighbors, Adjacency, and Spatial Queries + +**File**: `tutorial_4_neighbors_spatial.ipynb` + +Learn about mesh queries for GNN-style processing. + +- Topological neighbors (point-to-points, cell-to-cells) +- Sparse adjacency encoding +- BVH construction and queries +- Point containment +- Random point sampling +- Data interpolation at query points + +### Tutorial 5: Quality, Validation, and Repair + +**File**: `tutorial_5_quality_repair.ipynb` + +Learn mesh quality assessment and repair. + +- Quality metrics (aspect ratio, angles, quality score) +- Mesh statistics +- Validation (detect errors) +- Repair operations (clean, remove duplicates, fix orientation) +- Manifold and watertight checking + +### Tutorial 6: Integration with ML Workflows + +**File**: `tutorial_6_ml_integration.ipynb` + +Learn to use PhysicsNeMo-Mesh in production ML pipelines. + +- Performance comparison with PyVista/VTK +- Batching with padding for torch.compile +- Feature extraction for ML models +- Boundary condition handling +- End-to-end CAE preprocessing workflow +- torch.compile compatibility + +## Assets + +The `assets/` directory contains pre-saved meshes for use in tutorials: + +- `bunny.pt` - Stanford bunny mesh (coarse, use `.subdivide()` for detail) + +## Additional Resources + +- [PhysicsNeMo Documentation](https://docs.nvidia.com/deeplearning/physicsnemo) +- [physicsnemo.mesh Module Reference](../../../physicsnemo/mesh/README.md) +- [PyTorch TensorDict](https://github.com/pytorch/tensordict) +- [PyVista](https://pyvista.org/) diff --git a/examples/minimal/mesh/assets/bunny.pt b/examples/minimal/mesh/assets/bunny.pt new file mode 100644 index 0000000000..ee71a7bba5 Binary files /dev/null and b/examples/minimal/mesh/assets/bunny.pt differ diff --git a/examples/minimal/mesh/assets/make_bunny.py b/examples/minimal/mesh/assets/make_bunny.py new file mode 100644 index 0000000000..ed5cf35087 --- /dev/null +++ b/examples/minimal/mesh/assets/make_bunny.py @@ -0,0 +1,31 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Make the Stanford bunny mesh for the tutorials.""" + +from pathlib import Path + +import pyvista as pv +import torch + +from physicsnemo.mesh.io.io_pyvista import from_pyvista +from physicsnemo.mesh.remeshing._remeshing import remesh + +mesh = from_pyvista(pv.examples.download_bunny_coarse()) +mesh = remesh(mesh.clean().subdivide(levels=3, filter="linear"), 400) +mesh = mesh.rotate(axis="x", angle=torch.pi / 2).rotate(axis="z", angle=torch.pi / 2) + +torch.save(mesh, Path(__file__).parent / "bunny.pt") diff --git a/examples/minimal/mesh/benchmarks/__init__.py b/examples/minimal/mesh/benchmarks/__init__.py new file mode 100644 index 0000000000..4934e08786 --- /dev/null +++ b/examples/minimal/mesh/benchmarks/__init__.py @@ -0,0 +1,48 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Benchmark utilities for PhysicsNeMo-Mesh tutorial 6. + +This package provides: +- ``benchmark()`` - a timing harness with CUDA synchronization and warmup +- ``compiled_ops`` - ``@torch.compile`` wrapped mesh operations +- ``raw_ops`` - uncompiled mesh operations (same logic, no ``torch.compile``) +- ``save_benchmark_results`` / ``load_benchmark_results`` - JSON serialization +- ``plot_speedup_chart`` - grouped bar chart of speedup vs. CPU-pyvista +""" + +from . import compiled_ops, raw_ops +from .infrastructure import ( + BENCHMARK_DISPLAY_CONFIGS, + VARIANT_CONFIGS, + benchmark, + collect_system_metadata, + load_benchmark_results, + plot_speedup_chart, + save_benchmark_results, +) + +__all__ = [ + "BENCHMARK_DISPLAY_CONFIGS", + "VARIANT_CONFIGS", + "benchmark", + "collect_system_metadata", + "compiled_ops", + "load_benchmark_results", + "plot_speedup_chart", + "raw_ops", + "save_benchmark_results", +] diff --git a/examples/minimal/mesh/benchmarks/compiled_ops.py b/examples/minimal/mesh/benchmarks/compiled_ops.py new file mode 100644 index 0000000000..cd87b6ace3 --- /dev/null +++ b/examples/minimal/mesh/benchmarks/compiled_ops.py @@ -0,0 +1,37 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""``torch.compile``-wrapped PhysicsNeMo-Mesh operations for benchmarking. + +Each compiled function is a thin wrapper around the corresponding function in +:mod:`raw_ops`, with ``torch.compile`` applied. See ``raw_ops`` for the +actual implementations and docstrings. +""" + +import torch + +from . import raw_ops + +cell_normals = torch.compile(raw_ops.cell_normals) +gaussian_curvature = torch.compile(raw_ops.gaussian_curvature) +gradient = torch.compile(raw_ops.gradient) +subdivide = torch.compile(raw_ops.subdivide) +p2p_neighbors = torch.compile(raw_ops.p2p_neighbors) +c2c_neighbors = torch.compile(raw_ops.c2c_neighbors) +sample_points = torch.compile(raw_ops.sample_points) +sample_points_area_weighted = torch.compile(raw_ops.sample_points_area_weighted) +smooth = torch.compile(raw_ops.smooth) +transforms = torch.compile(raw_ops.transforms) diff --git a/examples/minimal/mesh/benchmarks/infrastructure.py b/examples/minimal/mesh/benchmarks/infrastructure.py new file mode 100644 index 0000000000..d6e56bf21d --- /dev/null +++ b/examples/minimal/mesh/benchmarks/infrastructure.py @@ -0,0 +1,350 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Benchmark timing, result serialization, and plotting utilities.""" + +import json +import platform +import time +from datetime import datetime, timezone +from pathlib import Path + +import matplotlib.pyplot as plt +import numpy as np +import pyvista as pv +import torch + +### Schema version for forward-compatible deserialization ### +_BENCHMARK_SCHEMA_VERSION = 1 + + +def benchmark( + name: str, + func, + n_runs: int = 50, + warmup: int = 2, + target_runtime: float = 3.0, + verbose: bool = True, + setup: callable = None, +): + """Benchmark a function and return the minimum time. + + Using minimum (not mean) is standard practice for benchmarks because it + represents the best achievable performance without system noise. + + The timed loop is **time-budgeted**: it runs up to ``n_runs`` iterations + but stops early once cumulative timed runtime exceeds ``target_runtime``. + This keeps fast operations well-sampled (up to 50 runs) while preventing + slow operations from dominating total benchmark wall time. + + Warmup always runs in full regardless of the time budget. The default + ``warmup=2`` is sufficient for ``torch.compile`` (one tracing call plus + one compiled execution). + + Parameters + ---------- + name : str + Display name for the benchmark. + func : callable + Function to benchmark. + n_runs : int + Maximum number of timed runs (cap). + warmup : int + Number of warmup runs (not timed). The first warmup run triggers + ``torch.compile`` tracing; the second executes compiled code. + target_runtime : float + Target cumulative runtime (seconds) for the timed loop. The loop + exits early once this budget is exceeded, even if fewer than + ``n_runs`` iterations have completed. + verbose : bool + Whether to print results. + setup : callable, optional + Function to call before each run (not included in timing). + Use this to strip caches from meshes to prevent false performance benefits. + """ + ### Warmup runs ### + for _ in range(warmup): + if setup is not None: + setup() + func() + + ### Timed runs with proper CUDA synchronization ### + if torch.cuda.is_available(): + torch.cuda.synchronize() + + times = [] + cumulative = 0.0 + for _ in range(n_runs): + if setup is not None: + setup() + + if torch.cuda.is_available(): + torch.cuda.synchronize() + start = time.perf_counter() + result = func() + if torch.cuda.is_available(): + torch.cuda.synchronize() + dt = time.perf_counter() - start + times.append(dt) + cumulative += dt + + if cumulative >= target_runtime: + break + + min_time = min(times) + if verbose: + print(f"{name}: {min_time * 1000:.3f} ms ({len(times)} runs)") + return min_time, result + + +# --------------------------------------------------------------------------- +# System metadata +# --------------------------------------------------------------------------- + + +def collect_system_metadata() -> dict: + """Gather system information for benchmark reproducibility.""" + meta = { + "python_version": platform.python_version(), + "pytorch_version": torch.__version__, + "pyvista_version": pv.__version__, + "cpu": platform.processor() or platform.machine(), + "gpu": None, + "cuda_version": None, + "gpu_memory_gb": None, + } + if torch.cuda.is_available(): + meta["gpu"] = torch.cuda.get_device_name(0) + meta["cuda_version"] = ".".join( + str(x) for x in torch.cuda.get_device_capability(0) + ) + props = torch.cuda.get_device_properties(0) + meta["gpu_memory_gb"] = round(props.total_memory / 1e9, 1) + return meta + + +# --------------------------------------------------------------------------- +# Result serialization +# --------------------------------------------------------------------------- + + +def save_benchmark_results( + results: dict, + metadata: dict, + config: dict, + path: str | Path, +) -> Path: + """Serialize benchmark results + metadata to a JSON file. + + Parameters + ---------- + results : dict + The ``benchmark_results`` dict produced by the benchmark cells. + Each key maps to a dict of timing lists keyed by variant + (``"pyvista"``, ``"pnm_cpu_raw"``, ``"pnm_cpu_compiled"``, + ``"pnm_gpu_raw"``, ``"pnm_gpu_compiled"``) plus ``"sizes"``. + metadata : dict + System metadata from ``collect_system_metadata()``. + config : dict + Benchmark configuration, e.g. + ``{"mesh_bucket": "small", "mesh_source": "Stanford Bunny"}``. + path : str | Path + Destination file path (should end in ``.json``). + + Returns + ------- + Path + The resolved path that was written. + """ + path = Path(path) + payload = { + "schema_version": _BENCHMARK_SCHEMA_VERSION, + "metadata": { + "timestamp": datetime.now(timezone.utc).isoformat(), + **metadata, + }, + "config": config, + "results": results, + } + path.write_text(json.dumps(payload, indent=2, default=str)) + print(f"Benchmark results saved to {path}") + return path + + +def load_benchmark_results(path: str | Path) -> dict: + """Load benchmark results from a JSON file. + + Parameters + ---------- + path : str | Path + Path to a ``.json`` benchmark file produced by ``save_benchmark_results``. + + Returns + ------- + dict + The full payload including ``schema_version``, ``metadata``, + ``config``, and ``results``. + """ + path = Path(path) + payload = json.loads(path.read_text()) + version = payload.get("schema_version", 0) + if version != _BENCHMARK_SCHEMA_VERSION: + print( + f"Warning: benchmark file has schema version {version}, " + f"expected {_BENCHMARK_SCHEMA_VERSION}. Results may need migration." + ) + return payload + + +# --------------------------------------------------------------------------- +# Plotting +# --------------------------------------------------------------------------- + +### Display configs: (result-dict key, axis label) ### +BENCHMARK_DISPLAY_CONFIGS = [ + ("normals", "Normal\nComputation"), + ("curvature", "Gaussian\nCurvature"), + ("gradient", "Gradient\nComputation"), + ("subdivision", "Subdivision\n(Loop)"), + ("neighbors_p2p", "Point-to-Point\nNeighbors"), + ("neighbors_c2c", "Cell-to-Cell\nNeighbors"), + ("sampling", "Random\nSampling"), + ("smoothing", "Laplacian\nSmoothing"), + ("transforms", "Geometric\nTransforms"), +] + +### Variant configs: (result-dict key, chart label, bar color) ### +### Ordered left-to-right within each group on the chart. ### +VARIANT_CONFIGS = [ + ("pnm_gpu_compiled", "PNM GPU (compiled)", "#76B900"), # NVIDIA green + ("pnm_gpu_raw", "PNM GPU", "#A8D86E"), # light green + ("pnm_cpu_compiled", "PNM CPU (compiled)", "#2C5F9B"), # dark blue + ("pnm_cpu_raw", "PNM CPU", "#7CB3E8"), # light blue +] + + +def plot_speedup_chart( + results: dict, + title_suffix: str = "", + save_path: str | Path | None = "benchmark_results.png", +): + """Plot a grouped bar chart of speedup over CPU-pyvista. + + Automatically includes only those variants that have data in ``results``. + Each bar shows speedup relative to the PyVista (CPU) baseline. + + Parameters + ---------- + results : dict + Either the live ``benchmark_results`` dict, or the ``"results"`` + field from a loaded JSON payload. + title_suffix : str + Optional text appended to the chart title (e.g. hardware name). + save_path : str | Path | None + If not None, save the figure to this path. + """ + ### Determine which variants have data across any operation ### + active_variants = [ + (key, label, color) + for key, label, color in VARIANT_CONFIGS + if any( + results.get(op_key, {}).get(key) for op_key, _ in BENCHMARK_DISPLAY_CONFIGS + ) + ] + + if not active_variants: + print("No benchmark results to plot.") + return + + ### Collect per-operation speedups for each active variant ### + operations: list[str] = [] + # speedups[variant_key] -> list of floats, one per operation + speedups: dict[str, list[float]] = {key: [] for key, _, _ in active_variants} + + for op_key, display_name in BENCHMARK_DISPLAY_CONFIGS: + op_data = results.get(op_key, {}) + pv_times = op_data.get("pyvista", []) + if not pv_times: + continue + + pv_time = pv_times[-1] # largest mesh size + operations.append(display_name) + + for var_key, _, _ in active_variants: + var_times = op_data.get(var_key, []) + sp = pv_time / var_times[-1] if var_times else 0.0 + speedups[var_key].append(sp) + + if not operations: + print("No benchmark results to plot.") + return + + ### Build figure ### + n_variants = len(active_variants) + fig, ax = plt.subplots(figsize=(14, 6)) + + x = np.arange(len(operations)) + total_group_width = 0.8 + bar_width = total_group_width / n_variants + + for i, (var_key, var_label, var_color) in enumerate(active_variants): + offset = (i - (n_variants - 1) / 2) * bar_width + bars = ax.bar( + x + offset, + speedups[var_key], + bar_width, + label=var_label, + color=var_color, + edgecolor="black", + linewidth=0.5, + ) + + ### Annotate speedup values on top of bars ### + for bar, sp in zip(bars, speedups[var_key]): + if sp <= 0: + continue + height = bar.get_height() + text = f"{sp:.0f}x" if sp >= 10 else f"{sp:.1f}x" + ax.annotate( + text, + xy=(bar.get_x() + bar.get_width() / 2, height), + xytext=(0, 3), + textcoords="offset points", + ha="center", + va="bottom", + fontsize=8 if n_variants > 3 else 9, + fontweight="bold", + ) + + ax.set_ylabel("Speedup over PyVista (CPU)", fontsize=12) + ax.set_yscale("log") + chart_title = "Speedup over PyVista (CPU) \u2014 Largest Mesh Size" + if title_suffix: + chart_title += f" [{title_suffix}]" + ax.set_title(chart_title, fontsize=14) + ax.set_xticks(x) + ax.set_xticklabels(operations, fontsize=9) + ax.axhline( + y=1, color="gray", linestyle="--", alpha=0.5, label="PyVista baseline (1x)" + ) + ax.legend(loc="upper left", fontsize=9) + ax.grid(axis="y", alpha=0.3) + + plt.tight_layout() + if save_path is not None: + plt.savefig(str(save_path), dpi=150, bbox_inches="tight") + print(f"\nBenchmark visualization saved to {save_path}") + plt.show() diff --git a/examples/minimal/mesh/benchmarks/raw_ops.py b/examples/minimal/mesh/benchmarks/raw_ops.py new file mode 100644 index 0000000000..e5675cf7c5 --- /dev/null +++ b/examples/minimal/mesh/benchmarks/raw_ops.py @@ -0,0 +1,94 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Uncompiled PhysicsNeMo-Mesh operations for benchmarking. + +Each function takes **raw tensors** (points, cells, and any extra args) and +constructs a fresh :class:`~physicsnemo.mesh.Mesh` internally. This is the +single source of truth for operation logic; ``compiled_ops`` applies +``torch.compile`` to these same functions. +""" + +import torch + +from physicsnemo.mesh import Mesh +from physicsnemo.mesh.calculus import compute_gradient_points_lsq +from physicsnemo.mesh.smoothing import smooth_laplacian + + +def cell_normals(points, cells): + """Compute per-cell normals from raw point/cell tensors.""" + return Mesh(points=points, cells=cells).cell_normals + + +def gaussian_curvature(points, cells): + """Compute per-vertex Gaussian curvature from raw point/cell tensors.""" + return Mesh(points=points, cells=cells).gaussian_curvature_vertices + + +def gradient(points, cells, scalar_field): + """Compute least-squares gradient of a scalar field on vertices.""" + m = Mesh(points=points, cells=cells) + return compute_gradient_points_lsq(m, point_values=scalar_field) + + +def subdivide(points, cells): + """Loop-subdivide once and return (new_points, new_cells).""" + r = Mesh(points=points, cells=cells).subdivide(levels=1, filter="loop") + return r.points, r.cells + + +def p2p_neighbors(points, cells): + """Compute point-to-point adjacency.""" + return Mesh(points=points, cells=cells).get_point_to_points_adjacency() + + +def c2c_neighbors(points, cells): + """Compute cell-to-cell adjacency.""" + return Mesh(points=points, cells=cells).get_cell_to_cells_adjacency() + + +def sample_points(points, cells, cell_indices): + """Sample random points on specified cells.""" + return Mesh(points=points, cells=cells).sample_random_points_on_cells( + cell_indices=cell_indices, + ) + + +def sample_points_area_weighted(points, cells, n_samples): + """Area-weighted random surface sampling (end-to-end).""" + m = Mesh(points=points, cells=cells) + areas = m.cell_areas + cell_indices = torch.multinomial(areas, n_samples, replacement=True) + return m.sample_random_points_on_cells(cell_indices=cell_indices) + + +def smooth(points, cells, n_iter, relaxation_factor): + """Run Laplacian smoothing and return the smoothed point positions.""" + m = Mesh(points=points, cells=cells) + return smooth_laplacian( + m, n_iter=n_iter, relaxation_factor=relaxation_factor + ).points + + +def transforms(points, cells, offset, angle_x, angle_y, scale_factor): + """Apply translate -> rotate_x -> rotate_y -> scale and return points.""" + m = Mesh(points=points, cells=cells) + m = m.translate(offset=offset) + m = m.rotate(axis="x", angle=angle_x) + m = m.rotate(axis="y", angle=angle_y) + m = m.scale(factor=scale_factor) + return m.points diff --git a/examples/minimal/mesh/requirements.txt b/examples/minimal/mesh/requirements.txt new file mode 100644 index 0000000000..47a509373a --- /dev/null +++ b/examples/minimal/mesh/requirements.txt @@ -0,0 +1,7 @@ +nvidia-physicsnemo +pyvista[all,trame] +matplotlib +pyacvd +jupyter +ipykernel +ipywidgets diff --git a/examples/minimal/mesh/tutorial_1_getting_started.ipynb b/examples/minimal/mesh/tutorial_1_getting_started.ipynb new file mode 100644 index 0000000000..50f3a9cdb1 --- /dev/null +++ b/examples/minimal/mesh/tutorial_1_getting_started.ipynb @@ -0,0 +1,878 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mesh Tutorial 1: Getting Started with PhysicsNeMo Mesh\n", + "\n", + "Welcome to PhysicsNeMo-Mesh, NVIDIA's GPU-accelerated mesh processing library.\n", + "\n", + "**The goal of this tutorial is to show you that PhysicsNeMo-Mesh is simple.** At its core,\n", + "a `Mesh` is just a dataclass with 5 fields:\n", + "\n", + "| Field | Purpose | Shape |\n", + "|-------|---------|-------|\n", + "| `points` | Vertex coordinates | `(n_points, n_spatial_dims)` |\n", + "| `cells` | Connectivity (which points form each cell) | `(n_cells, n_manifold_dims + 1)` |\n", + "| `point_data` | Per-vertex data (optional) | `TensorDict` |\n", + "| `cell_data` | Per-cell data (optional) | `TensorDict` |\n", + "| `global_data` | Mesh-level data (optional) | `TensorDict` |\n", + "\n", + "**Two fields define geometry. Three fields hold data. That's it!**\n", + "\n", + "---\n", + "\n", + "## What You'll Learn\n", + "\n", + "1. Create a `Mesh` from scratch (points + cells)\n", + "2. Understand mesh dimensions (spatial, manifold, codimension)\n", + "3. Attach rich tensor data to points, cells, and the mesh itself\n", + "4. Visualize meshes with scalar field coloring\n", + "5. Move meshes between CPU and GPU with a single call" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Why PhysicsNeMo-Mesh?\n", + "\n", + "Before diving in, here's why PhysicsNeMo-Mesh exists and what makes it special:\n", + "\n", + "**GPU-Accelerated**: All operations are fully vectorized with PyTorch and run natively on CUDA.\n", + "No CPU bottlenecks - compute normals, curvature, gradients, and more on the GPU.\n", + "\n", + "**Dimensionally Generic**: Works with n-dimensional manifolds embedded in m-dimensional spaces.\n", + "Point clouds (0D), curves (1D), surface meshes (2D), volume meshes (3D) - all with the same API.\n", + "\n", + "**TensorDict Integration**: Data is stored in [TensorDict](https://github.com/pytorch/tensordict)\n", + "containers that move together with the mesh geometry. Call `.to(\"cuda\")` and everything moves.\n", + "\n", + "**Differentiable**: Most operations integrate seamlessly with PyTorch autograd, enabling\n", + "gradient-based optimization through mesh operations.\n", + "\n", + "**Flexible Data**: Attach scalar, vector, or arbitrary-rank tensor fields to points, cells, or\n", + "globally. Nested data structures are fully supported." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from tensordict import TensorDict\n", + "\n", + "from physicsnemo.mesh import Mesh" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 1: Creating a Mesh from Scratch\n", + "\n", + "A `Mesh` needs just two tensors to define its geometry:\n", + "\n", + "- **`points`**: Vertex coordinates - where each vertex is located in space\n", + "- **`cells`**: Connectivity - which vertices form each cell (triangle, tetrahedron, etc.)\n", + "\n", + "Let's create the simplest possible mesh: two triangles forming a unit square in 2D." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh(manifold_dim=2, spatial_dim=2, n_points=4, n_cells=2)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n" + ] + } + ], + "source": [ + "# The geometry is defined by just 2 tensors!\n", + "\n", + "# 1. Points: where are the vertices?\n", + "points = torch.tensor(\n", + " [\n", + " [0.0, 0.0], # vertex 0: bottom-left\n", + " [1.0, 0.0], # vertex 1: bottom-right\n", + " [1.0, 1.0], # vertex 2: top-right\n", + " [0.0, 1.0], # vertex 3: top-left\n", + " ]\n", + ")\n", + "\n", + "# 2. Cells: which vertices form each triangle?\n", + "cells = torch.tensor(\n", + " [\n", + " [0, 1, 2], # triangle 0: vertices 0, 1, 2\n", + " [0, 2, 3], # triangle 1: vertices 0, 2, 3\n", + " ]\n", + ")\n", + "\n", + "# Create the mesh\n", + "mesh = Mesh(points=points, cells=cells)\n", + "print(mesh)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The output shows the 5 fields:\n", + "- Geometry: 4 points, 2 cells (triangles)\n", + "- Data: all three data containers are empty `{}`\n", + "\n", + "Let's look at the key properties:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of points: 4\n", + "Number of cells: 2\n", + "\n", + "Spatial dimension: 2\n", + "Manifold dimension: 2\n", + "Codimension: 0\n" + ] + } + ], + "source": [ + "print(f\"Number of points: {mesh.n_points}\")\n", + "print(f\"Number of cells: {mesh.n_cells}\")\n", + "print()\n", + "print(f\"Spatial dimension: {mesh.n_spatial_dims}\")\n", + "print(f\"Manifold dimension: {mesh.n_manifold_dims}\")\n", + "print(f\"Codimension: {mesh.codimension}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 2: Understanding Mesh Dimensions\n", + "\n", + "PhysicsNeMo-Mesh is **dimensionally generic**. It handles meshes of any dimension using\n", + "three key concepts:\n", + "\n", + "| Concept | Meaning | Example |\n", + "|---------|---------|----------|\n", + "| **Spatial dimension** | Dimension of the embedding space | 3 for \"real-world\" 3D |\n", + "| **Manifold dimension** | Intrinsic dimension of each cell | 2 for triangles (they're flat) |\n", + "| **Codimension** | Spatial - Manifold | 1 for a surface in 3D |\n", + "\n", + "The codimension tells you what geometric operations are possible:\n", + "- **Codimension 0**: Triangles in 2D, tetrahedra in 3D - no unique normal vector\n", + "- **Codimension 1**: Triangles in 3D, edges in 2D - unique normal vector exists\n", + "- **Codimension 2+**: Edges in 3D - infinitely many normal directions\n", + "\n", + "Let's see some examples:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sphere: manifold=2D, spatial=3D, codim=1\n", + "Square: manifold=2D, spatial=2D, codim=0\n", + "Cube: manifold=3D, spatial=3D, codim=0\n", + "Circle: manifold=1D, spatial=3D, codim=2\n" + ] + } + ], + "source": [ + "from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral\n", + "from physicsnemo.mesh.primitives.planar import unit_square\n", + "from physicsnemo.mesh.primitives.volumes import cube_volume\n", + "from physicsnemo.mesh.primitives.curves import circle_3d\n", + "\n", + "# Surface mesh: triangles in 3D space (codimension 1)\n", + "sphere = sphere_icosahedral.load(subdivisions=2)\n", + "print(\n", + " f\"Sphere: manifold={sphere.n_manifold_dims}D, spatial={sphere.n_spatial_dims}D, codim={sphere.codimension}\"\n", + ")\n", + "\n", + "# Planar mesh: triangles in 2D space (codimension 0)\n", + "square = unit_square.load(subdivisions=5)\n", + "print(\n", + " f\"Square: manifold={square.n_manifold_dims}D, spatial={square.n_spatial_dims}D, codim={square.codimension}\"\n", + ")\n", + "\n", + "# Volume mesh: tetrahedra in 3D space (codimension 0)\n", + "cube = cube_volume.load(subdivisions=3)\n", + "print(\n", + " f\"Cube: manifold={cube.n_manifold_dims}D, spatial={cube.n_spatial_dims}D, codim={cube.codimension}\"\n", + ")\n", + "\n", + "# Curve mesh: edges in 3D space (codimension 2)\n", + "circle = circle_3d.load(n_points=32)\n", + "print(\n", + " f\"Circle: manifold={circle.n_manifold_dims}D, spatial={circle.n_spatial_dims}D, codim={circle.codimension}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 3: Loading Meshes\n", + "\n", + "Besides creating meshes manually, you can:\n", + "\n", + "1. **Load from PyVista** - any format PyVista supports (VTK, STL, OBJ, PLY, etc.)\n", + "2. **Use built-in primitives** - spheres, cubes, tori, and more\n", + "3. **Load saved meshes** - `torch.load()` works directly on Mesh objects" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Airplane: Mesh(manifold_dim=2, spatial_dim=3, n_points=1335, n_cells=2452)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n" + ] + } + ], + "source": [ + "# Load from PyVista\n", + "import pyvista as pv\n", + "from physicsnemo.mesh.io import from_pyvista\n", + "\n", + "pv_mesh = pv.examples.load_airplane()\n", + "airplane = from_pyvista(pv_mesh)\n", + "print(f\"Airplane: {airplane}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bunny (coarse): Mesh(manifold_dim=2, spatial_dim=3, n_points=400, n_cells=796)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n", + "Bunny (refined): Mesh(manifold_dim=2, spatial_dim=3, n_points=6370, n_cells=12736)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n" + ] + } + ], + "source": [ + "# Load a pre-saved mesh (bunny asset included with tutorials)\n", + "bunny = torch.load(\"assets/bunny.pt\", weights_only=False)\n", + "print(f\"Bunny (coarse): {bunny}\")\n", + "\n", + "# Subdivide for higher resolution\n", + "bunny_fine = bunny.subdivide(levels=2, filter=\"loop\")\n", + "print(f\"Bunny (refined): {bunny_fine}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Torus: Mesh(manifold_dim=2, spatial_dim=3, n_points=512, n_cells=1024)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n", + "Lumpy sphere: Mesh(manifold_dim=2, spatial_dim=3, n_points=642, n_cells=1280)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n" + ] + } + ], + "source": [ + "# Built-in primitives are organized by category\n", + "from physicsnemo.mesh.primitives.surfaces import torus\n", + "from physicsnemo.mesh.primitives.procedural import lumpy_sphere\n", + "\n", + "donut = torus.load(major_radius=1.0, minor_radius=0.3, n_major=32, n_minor=16)\n", + "print(f\"Torus: {donut}\")\n", + "\n", + "lumpy = lumpy_sphere.load(noise_amplitude=0.3, subdivisions=3, seed=42)\n", + "print(f\"Lumpy sphere: {lumpy}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 4: Attaching Data to Meshes\n", + "\n", + "This is where PhysicsNeMo-Mesh really shines. You can attach **any tensor data** at three levels:\n", + "\n", + "| Level | Stored In | Shape Prefix | Example |\n", + "|-------|-----------|--------------|----------|\n", + "| Per-vertex | `point_data` | `(n_points, ...)` | Temperature at each node |\n", + "| Per-cell | `cell_data` | `(n_cells, ...)` | Pressure in each element |\n", + "| Mesh-level | `global_data` | `(...)` | Reynolds number, timestep |\n", + "\n", + "The trailing dimensions can be **anything**: scalars, vectors, matrices, or higher-rank tensors." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting mesh: Mesh(manifold_dim=2, spatial_dim=3, n_points=162, n_cells=320)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n" + ] + } + ], + "source": [ + "mesh = sphere_icosahedral.load(subdivisions=2)\n", + "print(f\"Starting mesh: {mesh}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "With data attached: Mesh(manifold_dim=2, spatial_dim=3, n_points=162, n_cells=320)\n", + " point_data : {temperature: (), velocity: (3,)}\n", + " cell_data : {elasticity: (3, 3, 3), stress: (3, 3)}\n", + " global_data: {}\n" + ] + } + ], + "source": [ + "# Scalar field: one value per point\n", + "mesh.point_data[\"temperature\"] = torch.randn(mesh.n_points)\n", + "\n", + "# Vector field: 3 values per point\n", + "mesh.point_data[\"velocity\"] = torch.randn(mesh.n_points, 3)\n", + "\n", + "# Rank-2 tensor field: 3x3 matrix per cell (e.g., stress tensor)\n", + "mesh.cell_data[\"stress\"] = torch.randn(mesh.n_cells, 3, 3)\n", + "\n", + "# Rank-3 tensor: 3x3x3 per cell (e.g., elasticity tensor components)\n", + "mesh.cell_data[\"elasticity\"] = torch.randn(mesh.n_cells, 3, 3, 3)\n", + "\n", + "print(f\"With data attached: {mesh}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice how the `__repr__` shows the trailing dimensions for each field:\n", + "- `temperature: ()` means scalar (no trailing dims)\n", + "- `velocity: (3,)` means 3-vector\n", + "- `stress: (3, 3)` means 3x3 matrix\n", + "- `elasticity: (3, 3, 3)` means 3x3x3 tensor" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "With global data: Mesh(manifold_dim=2, spatial_dim=3, n_points=162, n_cells=320)\n", + " point_data : {temperature: (), velocity: (3,)}\n", + " cell_data : {elasticity: (3, 3, 3), stress: (3, 3)}\n", + " global_data: {\n", + " reynolds_number : (),\n", + " simulation_params: {\n", + " boundary_conditions: {inlet: (), outlet: (), wall: ()},\n", + " dt : (),\n", + " inlet_velocity : (3,)},\n", + " time : ()}\n" + ] + } + ], + "source": [ + "# Global data: mesh-level quantities\n", + "mesh.global_data[\"time\"] = torch.tensor(0.0)\n", + "mesh.global_data[\"reynolds_number\"] = torch.tensor(1e6)\n", + "\n", + "# Nested TensorDict for structured metadata\n", + "mesh.global_data[\"simulation_params\"] = TensorDict(\n", + " {\n", + " \"dt\": torch.tensor(0.001),\n", + " \"inlet_velocity\": torch.tensor([1.0, 0.0, 0.0]),\n", + " \"boundary_conditions\": TensorDict(\n", + " {\n", + " \"inlet\": torch.tensor(1),\n", + " \"outlet\": torch.tensor(2),\n", + " \"wall\": torch.tensor(3),\n", + " },\n", + " batch_size=[],\n", + " ),\n", + " },\n", + " batch_size=[],\n", + ")\n", + "\n", + "print(f\"With global data: {mesh}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Temperature shape: torch.Size([162])\n", + "Stress shape: torch.Size([320, 3, 3])\n", + "Reynolds number: 1e+06\n", + "Inlet velocity: tensor([1., 0., 0.])\n" + ] + } + ], + "source": [ + "# Access data like a dictionary\n", + "print(f\"Temperature shape: {mesh.point_data['temperature'].shape}\")\n", + "print(f\"Stress shape: {mesh.cell_data['stress'].shape}\")\n", + "print(f\"Reynolds number: {mesh.global_data['reynolds_number'].item():.0e}\")\n", + "\n", + "# Access nested data\n", + "print(f\"Inlet velocity: {mesh.global_data['simulation_params', 'inlet_velocity']}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**A note on data and transformations:** Data fields (`point_data`, `cell_data`, `global_data`)\n", + "are **decoupled from geometry** by default. If you rotate or scale a mesh (covered in Tutorial 2),\n", + "only the vertex coordinates in `points` are transformed - attached data like `inlet_velocity` is\n", + "left unchanged. This is the right default for scalar fields (e.g., temperature is invariant under\n", + "rotation) but may surprise you for vector fields.\n", + "\n", + "When you *do* want vector/tensor data to co-rotate with the geometry, the transformation methods\n", + "accept opt-in flags: `transform_point_data=True`, `transform_cell_data=True`, and\n", + "`transform_global_data=True`. See Tutorial 2 for details." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 5: Visualization\n", + "\n", + "The `.draw()` method provides one-line visualization with automatic backend selection:\n", + "- **2D meshes**: Uses matplotlib (static plots)\n", + "- **3D meshes**: Uses PyVista (interactive 3D viewer)\n", + "\n", + "These can be overridden by passing `backend=\"matplotlib\"` or `backend=\"pyvista\"` to the method. Normally, the PyVista backend provides a better experience in 3D, but in order to render these visualizations statically in this Jupyter notebook, we'll use matplotlib.\n", + "\n", + "**Interactive 3D with PyVista:** When running locally with `backend=\"pyvista\"` (the default\n", + "for 3D meshes), you get a fully interactive 3D viewer where you can rotate, zoom, and pan\n", + "the mesh. PyVista also supports Jupyter widgets via `pv.set_jupyter_backend(\"trame\")` for\n", + "in-notebook interactivity. The `.draw()` method returns a `pyvista.Plotter` object that you\n", + "can further customize before displaying.\n", + "\n", + "You can color meshes by any scalar field. Vector fields are automatically converted to\n", + "their L2 norm (magnitude) for coloring." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Basic visualization\n", + "mesh.draw(\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Color by point scalar field - point data automatically gets converted to cell data for visualization\n", + "mesh.draw(point_scalars=\"temperature\", cmap=\"RdBu\", backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Color by velocity magnitude (vector -> L2 norm automatically)\n", + "mesh.draw(point_scalars=\"velocity\", cmap=\"turbo\", backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Visualize the bunny with curvature information\n", + "bunny = torch.load(\"assets/bunny.pt\", weights_only=False).subdivide(2, \"loop\")\n", + "curvature = bunny.mean_curvature_vertices\n", + "\n", + "\n", + "def regularize(x):\n", + " return x.sign() * x.abs().log1p()\n", + "\n", + "\n", + "bunny.point_data[\"curvature\"] = regularize(curvature)\n", + "bunny.draw(point_scalars=\"curvature\", cmap=\"RdBu\", backend=\"matplotlib\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 6: GPU Acceleration\n", + "\n", + "One of PhysicsNeMo-Mesh's key features is seamless GPU acceleration. The entire mesh -\n", + "geometry AND all attached data - moves together with a single `.to()` call.\n", + "\n", + "This is possible because mesh data uses TensorDict, which handles device transfers automatically." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial device: None\n", + " points: cpu\n", + " temperature: cpu\n" + ] + } + ], + "source": [ + "# Create a mesh with data\n", + "mesh = sphere_icosahedral.load(subdivisions=3)\n", + "mesh.point_data[\"temperature\"] = torch.randn(mesh.n_points)\n", + "mesh.cell_data[\"pressure\"] = torch.randn(mesh.n_cells)\n", + "\n", + "print(f\"Initial device: {mesh.device}\")\n", + "print(f\" points: {mesh.points.device}\")\n", + "print(f\" temperature: {mesh.point_data['temperature'].device}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "After .to('cuda'):\n", + " device: cuda:0\n", + " points: cuda:0\n", + " temperature: cuda:0\n", + " pressure: cuda:0\n", + "\n", + "Computed Gaussian curvature on GPU: cuda:0\n", + "Back on CPU: cpu\n" + ] + } + ], + "source": [ + "if torch.cuda.is_available():\n", + " # Move EVERYTHING to GPU with one call\n", + " mesh_gpu = mesh.to(\"cuda\")\n", + "\n", + " print(f\"After .to('cuda'):\")\n", + " print(f\" device: {mesh_gpu.device}\")\n", + " print(f\" points: {mesh_gpu.points.device}\")\n", + " print(f\" temperature: {mesh_gpu.point_data['temperature'].device}\")\n", + " print(f\" pressure: {mesh_gpu.cell_data['pressure'].device}\")\n", + "\n", + " # All computations are now GPU-accelerated!\n", + " curvature = mesh_gpu.gaussian_curvature_vertices\n", + " print(f\"\\nComputed Gaussian curvature on GPU: {curvature.device}\")\n", + "\n", + " # Move back to CPU when needed (e.g., for visualization)\n", + " mesh_cpu = mesh_gpu.to(\"cpu\")\n", + " print(f\"Back on CPU: {mesh_cpu.device}\")\n", + "else:\n", + " print(\"CUDA not available - GPU demo skipped.\")\n", + " print(\"When CUDA is available, use mesh.to('cuda') to move to GPU.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 7: Differentiability (Autograd Integration)\n", + "\n", + "Almost all PhysicsNeMo-Mesh operations are differentiable and integrate with PyTorch's autograd.\n", + "This enables gradient-based optimization through mesh operations - useful for inverse problems,\n", + "physics-informed neural networks, and shape optimization." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Triangle area: 0.5000\n", + "Gradient of area w.r.t. vertices:\n", + "tensor([[-0.5000, -0.2500],\n", + " [ 0.5000, -0.2500],\n", + " [ 0.0000, 0.5000]])\n" + ] + } + ], + "source": [ + "# Create points with gradient tracking\n", + "points = torch.tensor(\n", + " [\n", + " [0.0, 0.0],\n", + " [1.0, 0.0],\n", + " [0.5, 1.0],\n", + " ],\n", + " requires_grad=True,\n", + ")\n", + "\n", + "cells = torch.tensor([[0, 1, 2]])\n", + "mesh = Mesh(points=points, cells=cells)\n", + "\n", + "# Compute area (differentiable!)\n", + "area = mesh.cell_areas.sum()\n", + "print(f\"Triangle area: {area.item():.4f}\")\n", + "\n", + "# Backpropagate through the area computation\n", + "area.backward()\n", + "print(f\"Gradient of area w.r.t. vertices:\\n{points.grad}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The gradients show how moving each vertex affects the triangle's area. This is the foundation\n", + "for mesh-based optimization and physics-informed learning." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also enable gradient tracking on an **existing** mesh by detaching its points into\n", + "a leaf tensor. This is useful when you want to optimize the shape of a mesh that was loaded\n", + "from a file or generated by a primitive:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gradient shape: torch.Size([162, 3])\n", + "Gradient norm: 1.9463\n" + ] + } + ], + "source": [ + "# Start from an existing mesh (not created with requires_grad)\n", + "mesh = sphere_icosahedral.load(subdivisions=2)\n", + "\n", + "# Detach points and make them leaf tensors for gradient tracking\n", + "mesh.points = mesh.points.detach().requires_grad_(True)\n", + "\n", + "# Now compute something differentiable\n", + "total_area = mesh.cell_areas.sum()\n", + "total_area.backward()\n", + "\n", + "print(f\"Gradient shape: {mesh.points.grad.shape}\")\n", + "print(f\"Gradient norm: {mesh.points.grad.norm():.4f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "You've learned the fundamentals of PhysicsNeMo-Mesh:\n", + "\n", + "1. **A Mesh is simple**: Just 5 fields - 2 for geometry (`points`, `cells`), 3 for data\n", + "2. **Dimensionally generic**: Works with any n-manifold in m-space\n", + "3. **Rich data support**: Scalar, vector, tensor, and nested data on points/cells/globally\n", + "4. **Easy visualization**: `.draw()` with automatic backend selection\n", + "5. **GPU-accelerated**: `.to(\"cuda\")` moves everything together\n", + "6. **Differentiable**: Integrates with PyTorch autograd\n", + "\n", + "For the complete feature list, see the [physicsnemo.mesh README](../../../physicsnemo/mesh/README.md)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/minimal/mesh/tutorial_2_operations.ipynb b/examples/minimal/mesh/tutorial_2_operations.ipynb new file mode 100644 index 0000000000..f672aeab8d --- /dev/null +++ b/examples/minimal/mesh/tutorial_2_operations.ipynb @@ -0,0 +1,1489 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mesh Tutorial 2: Operations and Transformations\n", + "\n", + "This tutorial covers mesh manipulation operations in PhysicsNeMo-Mesh:\n", + "\n", + "1. **Geometric Transformations**: translate, rotate, scale, arbitrary linear transforms\n", + "2. **Subdivision**: Refine meshes with different smoothing schemes\n", + "3. **Slicing**: Extract subsets of points or cells\n", + "4. **Merging**: Combine multiple meshes into one\n", + "5. **Boundary & Facet Extraction**: Get boundaries and lower-dimensional elements\n", + "6. **Data Conversion**: Move data between points and cells\n", + "7. **Topology Checks**: Watertight and manifold detection" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import math\n", + "\n", + "from physicsnemo.mesh import Mesh\n", + "from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral\n", + "from physicsnemo.mesh.primitives.volumes import cube_volume" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 1: Geometric Transformations\n", + "\n", + "PhysicsNeMo-Mesh provides standard geometric transformations that operate on the mesh geometry.\n", + "All transformations return a **new mesh** (they don't modify in place)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Translation\n", + "\n", + "Move all points by a fixed offset vector." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original center: tensor([ 7.3586e-10, -1.4717e-09, -1.4717e-09])\n", + "Translated center: tensor([ 5.0000e+00, -1.4717e-09, -1.4717e-09])\n" + ] + } + ], + "source": [ + "sphere = sphere_icosahedral.load(subdivisions=2)\n", + "\n", + "# Translate by a vector\n", + "translated = sphere.translate([5.0, 0.0, 0.0])\n", + "\n", + "print(f\"Original center: {sphere.points.mean(dim=0)}\")\n", + "print(f\"Translated center: {translated.points.mean(dim=0)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Scaling\n", + "\n", + "Scale the mesh uniformly or anisotropically (different factors per axis)." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original extent: tensor([2., 2., 2.])\n", + "Uniform 2x: tensor([4., 4., 4.])\n", + "Anisotropic: tensor([4., 2., 1.])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sphere = sphere_icosahedral.load(subdivisions=2)\n", + "\n", + "# Uniform scaling: double the size\n", + "scaled_uniform = sphere.scale(2.0)\n", + "print(\n", + " f\"Original extent: {sphere.points.max(dim=0).values - sphere.points.min(dim=0).values}\"\n", + ")\n", + "print(\n", + " f\"Uniform 2x: {scaled_uniform.points.max(dim=0).values - scaled_uniform.points.min(dim=0).values}\"\n", + ")\n", + "\n", + "# Anisotropic scaling: stretch into an ellipsoid\n", + "scaled_aniso = sphere.scale([2.0, 1.0, 0.5])\n", + "print(\n", + " f\"Anisotropic: {scaled_aniso.points.max(dim=0).values - scaled_aniso.points.min(dim=0).values}\"\n", + ")\n", + "\n", + "# Visualize the ellipsoid\n", + "scaled_aniso.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Rotation\n", + "\n", + "Rotate around an axis by a specified angle (in radians).\n", + "\n", + "- For **2D meshes**: No axis needed (rotation is in the plane)\n", + "- For **3D meshes**: Specify the rotation axis" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load the bunny for a more interesting example\n", + "bunny = torch.load(\"assets/bunny.pt\", weights_only=False).subdivide(1, \"loop\")\n", + "\n", + "# Rotate 45 degrees around the Z-axis\n", + "rotated_z = bunny.rotate(angle=math.pi / 4, axis=[0, 0, 1])\n", + "\n", + "# Rotate 90 degrees around the Y-axis\n", + "rotated_y = bunny.rotate(angle=math.pi / 2, axis=[0, 1, 0])\n", + "\n", + "# Rotation around an arbitrary axis\n", + "rotated_arbitrary = bunny.rotate(angle=math.pi / 3, axis=[1, 1, 1])\n", + "\n", + "rotated_z.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Higher-dimensional meshes:** `rotate()` only supports 2D and 3D spatial dimensions. In 2D,\n", + "rotation is in the plane (no axis needed). In 3D, rotation is specified by an angle and axis\n", + "(Rodrigues' formula). For meshes with 4 or more spatial dimensions, rotation is not uniquely\n", + "defined by a single angle and axis - construct a rotation matrix directly and use `transform()`\n", + "instead." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Arbitrary Linear Transform\n", + "\n", + "Apply any linear transformation via a matrix. This is the most general transformation,\n", + "encompassing rotation, scaling, shearing, and even projection to different dimensions." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sphere = sphere_icosahedral.load(subdivisions=2)\n", + "\n", + "# Shear transformation\n", + "shear_matrix = torch.tensor(\n", + " [\n", + " [1.0, 0.5, 0.0],\n", + " [0.0, 1.0, 0.0],\n", + " [0.0, 0.0, 1.0],\n", + " ]\n", + ")\n", + "sheared = sphere.transform(shear_matrix)\n", + "sheared.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original: 3D\n", + "Projected: 2D\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Projection to 2D (drop the z coordinate)\n", + "projection_matrix = torch.tensor(\n", + " [\n", + " [1.0, 0.0, 0.0],\n", + " [0.0, 1.0, 0.0],\n", + " ]\n", + ")\n", + "\n", + "# Save the original z-coordinate as a scalar field before projecting.\n", + "# This makes the overlap visible: front (z > 0) and back (z < 0) hemispheres\n", + "# map to the same 2D positions, but the color distinguishes them.\n", + "sphere.point_data[\"original_z\"] = sphere.points[:, 2]\n", + "\n", + "projected = sphere.transform(projection_matrix)\n", + "print(f\"Original: {sphere.n_spatial_dims}D\")\n", + "print(f\"Projected: {projected.n_spatial_dims}D\")\n", + "projected.draw(point_scalars=\"original_z\", cmap=\"RdBu\", backend=\"matplotlib\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `[[1,0,0],[0,1,0]]` projection drops the z-coordinate, so the front hemisphere\n", + "(z > 0, red) and back hemisphere (z < 0, blue) map to identical 2D positions and overlap\n", + "perfectly. The coloring by original z-value reveals this: you can see both colors bleeding\n", + "through where the two hemispheres coincide. This is expected - the icosahedral sphere has\n", + "mirror symmetry about the z-axis, so the x-y projection of the front and back are identical." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 2: Subdivision\n", + "\n", + "Subdivision refines a mesh by splitting each cell into smaller cells. This is useful for:\n", + "- Increasing mesh resolution\n", + "- Smoothing coarse meshes\n", + "- Creating smooth surfaces from control meshes\n", + "\n", + "PhysicsNeMo-Mesh supports three subdivision schemes:\n", + "\n", + "| Scheme | Type | Properties |\n", + "|--------|------|------------|\n", + "| `linear` | Interpolating | Midpoint subdivision, preserves original vertices |\n", + "| `loop` | Approximating | C² smooth, moves original vertices |\n", + "| `butterfly` | Interpolating | Smooth, preserves original vertices |" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coarse: 12 points, 20 cells\n", + "Linear 1 level: 42 points, 80 cells\n", + "Linear 2 levels: 162 points, 320 cells\n", + "Linear 3 levels: 642 points, 1280 cells\n" + ] + } + ], + "source": [ + "# Start with a coarse icosahedron (20 triangles)\n", + "coarse = sphere_icosahedral.load(subdivisions=0)\n", + "print(f\"Coarse: {coarse.n_points} points, {coarse.n_cells} cells\")\n", + "\n", + "# Each level of subdivision multiplies cells by 4 (for triangles)\n", + "linear_1 = coarse.subdivide(levels=1, filter=\"linear\")\n", + "linear_2 = coarse.subdivide(levels=2, filter=\"linear\")\n", + "linear_3 = coarse.subdivide(levels=3, filter=\"linear\")\n", + "\n", + "print(f\"Linear 1 level: {linear_1.n_points} points, {linear_1.n_cells} cells\")\n", + "print(f\"Linear 2 levels: {linear_2.n_points} points, {linear_2.n_cells} cells\")\n", + "print(f\"Linear 3 levels: {linear_3.n_points} points, {linear_3.n_cells} cells\")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Linear subdivision (faceted):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Compare subdivision schemes on a coarse mesh\n", + "coarse = sphere_icosahedral.load(subdivisions=0)\n", + "\n", + "# Linear: just splits cells, doesn't smooth\n", + "linear = coarse.subdivide(levels=2, filter=\"linear\")\n", + "\n", + "# Loop: C² smooth, approximating (moves original vertices)\n", + "loop = coarse.subdivide(levels=2, filter=\"loop\")\n", + "\n", + "# Butterfly: smooth, interpolating (preserves original vertices)\n", + "butterfly = coarse.subdivide(levels=2, filter=\"butterfly\")\n", + "\n", + "print(\"Linear subdivision (faceted):\")\n", + "linear.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loop subdivision (smooth, C²):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Loop subdivision (smooth, C²):\")\n", + "loop.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Butterfly subdivision (smooth, interpolating):\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnwAAAKNCAYAAAC6I7bqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvXd4XNW5t31P0aj33ovVXSTLktXcMbbBFNMhEFogJ4WUwzlvcpL3fEkOJ+dNOwmkkJACoYZqOsYYbNy7rd6sLku2JKuX0fT9/SFmIlltJM2MRva6r4vrwqO911p7yl6//az1PD+ZJEkSAoFAIBAIBIIrFvlCD0AgEAgEAoFAYF+E4BMIBAKBQCC4whGCTyAQCAQCgeAKRwg+gUAgEAgEgiscIfgEAoFAIBAIrnCE4BMIBAKBQCC4whGCTyAQCAQCgeAKRwg+gUAgEAgEgiscIfgEAoFAIBAIrnCE4BMIBAKBQCC4whGCTyAQCAQCgeAKRwg+gUAgEAgEgiscIfgEAoFAIBAIrnCE4BMIBAKBQCC4whGCTyAQCAQCgeAKRwg+gUAgEAgEgiscIfgEAoFAIBAIrnCE4BMIBAKBQCC4whGCTyAQCAQCgeAKRwg+gUAgEAgEgiscIfgEAoFAIBAIrnCE4BMIBAKBQCC4whGCTyAQCAQCgeAKRwg+gUAgEAgEgiscIfgEAoFAIBAIrnCE4BMIBAKBQCC4whGCTyAQCAQCgeAKRwg+gUAgEAgEgiscIfgEAoFAIBAIrnCE4BMIBAKBQCC4whGCTyAQCAQCgeAKRwg+gUAgEAgEgiscIfgEAoFAIBAIrnCE4BMIBAKBQCC4wlEu9AAEAoHzoNfrKS0txdXVlcjISLy9vVEoFMhksoUemkAgEAjmgUySJGmhByEQCBYWSZIYGBjg7NmzDAwM4OLigsFgQKVS4efnR0BAAMHBwUIACgQCwSJFCD6B4CrHaDTS3NxMZWUlUVFRNDc3Ex4eTlJSEv39/fT29tLX18fg4KAQgAKBQLBIEUu6AsFViiRJaLVaSkpK6OnpISMjg5CQEJqbm5EkCaVSSWBgIIGBgQAYDAaLAGxra6O6uloIQIFAIFgkCMEnEFyFSJLEpUuXKCoqwtPTk4KCAtzc3Mb9/XKEABQIBILFixB8AsFVhtFopKamhvr6epKSkoiLixsnyGQy2aSC73KEABQIBILFgxB8AsFVgiRJDA0NUVRUhFarJTc3F19f3ymPnS1CAAoEAoHzIgSfQHAVIEkS58+fp6ysjNDQULKysnBxcbFrn7MRgIGBgQQFBQkBKBAIBHZCCD6B4ApHp9NRVlZGe3s7S5cuJTw8fNrjrV3SnS2XC0C9Xs/AwAA9PT20trZSVVUlBKBAIBDYCSH4BIIrFEmS6OnpoaioCBcXFwoKCvDw8LD6XHvj4uIiBKBAIBA4CCH4BIIrEKPRSF1dHefOnSM+Pp6EhAQUCoVV5y6UmJpJAFZWVqJUKgkKCiIgIEAIQIFAIJgFQvAJBFcQkiQxMjJCUVERQ0NDZGdnExAQMOt2TCaTHUY3Oy4XgFVVVRgMBlxcXMZFAP39/YUAFAgEghkQgk8guEKQJIkLFy5QWlqKv78/BQUFqFSqObflbCgUClxcXEhMTASmXgIWAlAgEAgmIgSfQHAFYDAYqKio4Pz586SmphIVFTVnkWOvpA1bY+0eQLMADA4OxsvLSwhAgUBwVSIEn0CwiJEkif7+fs6ePQtAfn4+Xl5e82rTmcXQdEJUCECBQCCYGiH4BIJFitFopLm5mcrKSqKiokhOTrY6MWMmFkOEbyaEABQIBIJ/IgSfQLDIkCQJrVZLSUkJPT09ZGRkEBISYvM+nI35ijAhAAUCwdWMEHwCwSJCkiQ6Ozs5deoUPj4+FBQU4ObmZtM+rhZxIwSgQCC4mhCCTyBYJBiNRqqrq2loaEAmk5GcnGxzsQfOnbRhz3EJASgQCK5khOATCJwcSZIYGhqiqKgIrVZLbm4uRUVFdu/zamc2TiC+vr6Eh4cLASgQCJwWIfgEAidGkiTOnz9PWVkZoaGhZGVl4eLiYtconLOKlYWOPE4lADs7Ozl37hy1tbUiAigQCJwWIfgEAidFq9VSXl5Oe3s7S5cuJTw83PI3e4sfEeGbGbMAdHd3p729nTVr1tDf309vby/nz5+nsrISV1dXIQAFAoFTIASfQOBkSJJET08PRUVFuLi4UFBQgIeHx7hjZDKZ3ezPFjqSNh3OOi6ZTIaLiwtBQUEEBQUBoxFAIQAFAoGzIASfQOBEGI1G6urqOHfuHPHx8SQkJExaW8/eS7rOKKwWmyiyRgC6ubnh5+cnBKBAILA7QvAJBE6AJEmMjIxQVFTE0NAQ2dnZBAQETHm8vQWBMwq+xY4QgAKBYCERgk8gWGAkSeLChQuUlpbi7+9PQUEBKpVq2nPsvaTrrFxJQlQIQIFA4EiE4BMIFhC9Xk9FRQWtra2kpaURGRlp1WR+NWbpXukIASgQCOyJEHwCwQIgSRL9/f2cPXsWgPz8fLy8vKw+/2rM0nVWUWOv90oIQIFAYEuE4BMIHIzRaKSpqYmqqiqioqJITk6eNDFjOq7GpA1wTiHqKIQAFAgE80EIPoHAQUiShFarpaSkhJ6eHjIzMwkODp5TW3K5XCzpXuVYWwbG3d2diIgIIQAFgqscIfgEAgcgSRKdnZ0UFxfj5eVFQUHBvH1wr7YInzOLFGcY22QCsK2tjebmZhEBFAgEQvAJBPbGYDBQU1NDQ0MDycnJxMbGznuCvVojfM4oRJ0VFxcXfHx8UKlU5OTkiCVggeAqRwg+gcBOSJLE0NAQZ8+eRa/Xk5ubi6+vr03avlr38Almj1m8iT2AAsHVjRB8AoEdkCSJlpYWysvLCQsLIyUlBRcXF5u1L0SZwBqm+44IASgQXF0IwScQ2BitVsuZM2fo6upixYoVhIeH27yPqzHCJ0TG3LD2fRMCUCC4shGCTyCwEZIk0d3dTVFREXK5HJVKZRexB1dv4WVnFKLOOCYz8xmbEIACwZWFEHwCgQ0wGo3U1dVx7tw54uPjCQgIoKyszG79Xa2CTzB7bPV5zkYABgYGEhQUJASgQOBECMEnEMwDSZJQq9UUFxczNDREdnY2AQEB9PX12TXyczUu6Qpmjz0/x+kEYEtLCxUVFUIACgROhBB8AsEckSSJCxcuUFpaSkBAAAUFBahUKsD+oulqFHzOOi5w7qioo8YmBKBA4NwIwScQzAG9Xk9FRQWtra2kpaURGRk5btKSy+WYTCa79e/M4kfgPCzkd8QaAahUKvH39yckJEQIQIHAzgjBJxDMAkmS6O/v5+zZswDk5+fj5eU14bjFGuEzmUwMDw8jSRL19fX4+/vj6+s7a69feyBEwNxwlvdtMgF47NgxZDKZiAAKBA5ACD6BwEqMRiNNTU1UVVURHR1NUlLSlELIEYLP1hHEkZERSkpK0Gq1wGh5maqqKnQ6HT4+Pvj7+1sEoFwut2nfAvvgzFFgFxcXZDIZsbGxeHt7iyVggcDOCMEnEMyAJEloNBpKSkro7e0lMzOT4ODgac+xhyC7vH1bTuYdHR2Ul5cTGhqKm5sb7e3tpKenI0kSIyMj9PX10dvby4ULFzAYDPj6+loEoLe3t8MEoDMLGGdEkiSnFkdjxyf2AAoE9kUIPoFgGiRJoqOjg5KSEry8vCgoKMDNzW3G88wCyF4Trq0Epclkorq6mgsXLrB06VLCw8MpLS0d14+HhwceHh5ERERYspJ7e3stE7EkSfj5+eHv74+fnx/e3t5X1QTs7CLUmT+L6X4fQgAKBLZFCD6BYAoMBgPV1dU0NjaSnJxMbGys1ROJ+ThnFnzDw8OUlJQAUFBQgIeHh6Xt6fr19PTE09OTqKgoi19wb28vfX19NDY2IpPJLALQ398fT09Pm7wHYhKfPc4uRmfz+xACUCCYH0LwCQSXIUkSg4ODFBUVodfryc3NxdfXd1ZtmCcYk8lkl+XO+U5gFy5coKKigqioKFJSUsaNcTZty2QyvL298fb2JiYmBpPJZBGA3d3d1NfXo1AoLOLP398fd3d3MQE7EGd+r+fzQCQEoEAwO4TgEwjGIEkSLS0tlJeXExYWRmpqKkrl7H8mY5d07cFcI3wGg4Gqqio6OzvJyMggJCRk0rZhbpOxXC7Hx8cHHx8fYmNjMZlMDAwM0NvbS0dHB+fOncPFxWWCALQWZ41YOauAcNb3C0bHZsvxCQEoEEyPEHwCwRdotVrKysro6Ohg2bJlhIWFzbmtsaLJHswlaWNwcJCSkhJcXFwoKCiYUmjZcjlaLpfj5+eHn58f8fHxGI1GyyR88eJFampqcHV1HScAXV1dpx2XYHY4+/tmr4QfIQAFgvEIwSe46pEkie7uboqKinB1dR23n22umCcxe2XqzkbwSZJEa2sr1dXVxMXFsWTJkmknWXtOdgqFgoCAAAICAoDRiOPlfqweHh4W8efn52dxLxHMHmeP8IFwAhEIHIUQfIKrGqPRSG1tLbW1tSQkJJCQkGDTiMNCR/gMBgPl5eX09PSQlZVFYGCgVW2DY8SCUqkkMDDQMi69Xm8pAdPY2Mjw8DCenp74+/tjMpkwGo12H9OVhDOXZXG04LscawSgQqEgODhYCEDBFYEQfIKrEkmSGB4epri4mOHhYXJycvD397dZ+zKZbMH9bvv7+ykuLsbDw4PCwsIpl0onaxsWJjrk4uJCcHCwpc6hTqezCMBLly6h1+s5derUuCLQc9ljaUucOYoGzruku9CC73IuF4BDQ0OcPHkSpVIpIoCCKwIh+ARXHebEjNLSUkJCQigoKLDLsqE9/XTlcvmUQkOSJJqbm6mtrWXJkiXEx8fPOvPWWVCpVISEhBASEoKXlxednZ2Eh4fT29tLTU0NWq0WHx8fSxkYZ7GBcxacWYw6m+C7HPODRFJSEjKZTCwBCxY9QvAJrir0ej0VFRW0trZiMplYvny53QSCve3VJmtbp9NRXl7OwMAA2dnZc4paLmSEbybkcjlhYWGWhJqRkRFLEejKykoMBsM4GzgfH5+r3gbOWcWHsws+k8lkidSD2AMoWPwIwSe4KpAkib6+PoqKipDJZGRnZ3PixAm79mlPwTdZhK+3t5eSkhJ8fHzmFbW0d0mZ+XD5mNzd3XF3d7e4gIwVgK2trRiNxnFFoL28vJyyLqK9cMbP0Iwzjw1Gxzfdd0UIQMFiQwg+wRWP0WikqamJqqoqoqOjSUpKskw2JpPJbhE+ey7pjhWTkiTR0NBAQ0MDycnJxMTEzGtCWayT0VgbuMjISMs+TbMAbG5uHmcDZxaAi/V6rcVZr8/ZI3yzTXiZrQAMDg7G09NTCECBwxCCT3DFIkkSGo2GkpISent7WblypeVmbBZi9owyOCJpQ6vVUlpaysjICKtXr561I8hUbYPzRWBm+37KZDK8vLzw8vIiOjp6nA2cOQvYXCfQLAA9PDyuqMnX2T7DsZgFlbO+3+Yl3bkiBKDA2RCCT3BFIkkSHR0dlJSU4OXlNSFLdaz1mb2wt+DT6XQcOXKEwMBAVq5cabNsVWcVfPNlMhu4wcFBSwZwXV0dSqXSUv/vSrCBc/ayLM46Nph5SXe2CAEoWGiE4BNccRgMBqqrq2lsbCQ5OZnY2NgJN0xzZMHegs8e7ZtMJtrb2xkeHmbZsmVERkbadEJwhBh2BuRyOb6+vvj6+hIXF4fJZLJMwO3t7Zw7dw6VSjXOBcTNzW2hh33F4OyCb74RvpkQAlDgaITgE1wxSJLE4OAgRUVF6PV68vLy8PHxmfJ4e2fRTlc6Za6MjIxQUlKCRqPB09OTqKgom7YPzrunyt7jksvlFmEHjLOBa2tro7q6Gjc3t3ECUKVSOXUk1JlFlTOPDWwf4ZsJIQAF9kYIPsEVgbm2Xnl5OWFhYaSmps64xGnPpAqwvaDs7OykrKyM0NBQ4uLiqK+vt1nbY3HmJV1HjmkyGzhzEejm5mYqKirw9PTEw8MDk8mEXq/HxcXFYeNb7Di74LN3hG8mphKAPT09FgHo4uKCr68voaGhQgAKZkQIPsGiR6vVUlZWRmdnJ8uWLbPUaJsJRwg+W7RvMpmoqamhra2NpUuXEh4ezqVLl+wufpxR8C0kSqVywgTc19dHe3s7RqORQ4cO4eXlNc4H2BlcQJx18nf275ejI3wzMZkAPHXqlOVhV0QABTMhBJ9g0SJJEt3d3RQVFeHq6kpBQQHu7u5Wn78YlnSHh4cpKSkBID8/H09PT8D+CSGCmTHbwKlUKkuha3MEsLa2Fo1Gg7e3t0X8+fn5LYgLiLN+ns4sRsH5x+fi4oJcLicqKorAwMBJI4DmLQgBAQFCAAqE4BMsToxGI7W1tdTW1pKQkMCSJUtmfRNz9iXdixcvUlFRQWRkJCkpKeOiDY4QfM4WgXH2ScrV1ZXQ0FBCQ0MB0Gg0lhIw1dXV6HS6cS4gvr6+do8gOdtnOBZnF1QLvaRrDSaTyfIdsmYJWAjAqxsh+ASLCnMx3eLiYtRqNTk5OXOyDwPHRPjmIiiNRiNVVVV0dHSwYsUKQkJCJhxzNQo+cM4xTYWbmxvh4eGEh4dbXEDMEcALFy5gMBjw9fW1CEBvb++rzgXEWccGzrekOxljBd/lCAEouBwh+ASLBkmSaGtro7S0lMDAQPLz8+dsHwbOGeEbHBykpKQEpVI57RK1vQWfuOHblrEuIGYbOLVabYkAnj9/HpPJZKn/5+fnh7e397w/B2cWyM4uqBZDhG8276EQgAIh+ASLAp1OR0VFBW1tbaSlpdmk9pwzCT6zmK2qqiI2NpbExMRpb+RXY4TvSpp0ZDIZnp6eltI6ZhcQcwSwsbERmUw2zgXE09Nz1u+BM0fRnHls4PyCFKaP8M2EEIBXH0LwCZwaSZLo6+ujqKgImUxGfn4+Xl5eNmnbWZZ0DQYDFRUVdHd3j7N/mw57Fo12VsEHV+6YxrqAREdHYzKZLDZw3d3d1NfXo1AoxtUAtNYFxFknZ2cXfIshwjcfwXc5QgBe+QjBJ3BajEYjjY2NVFdXEx0dTVJSkk2zHJ0hwtff309JSQnu7u4T7N9matveOKO4ulqQy+X4+Pjg4+NDbGwsJpOJgYEBent76ejooLa21mIDN1YAXo4ziypn/345e4RPkiS7jlEIwCsPIfgETockSWg0GoqLi+nv77c66jVbFlLwSZJEc3OzJcs4ISFhVjdJR0T4nA1nHZcjkMvlltIu8fHxFheQvr4+Ll68SE1NDa6uruMEoPnhwVnfN2cWo+D8ET7z799RolQIwMWPEHwCp0KSJNrb2zl79ixyuXxWUa/ZYu8l3alEmU6no7y83FK7bS5ZxlfjHj5nxtET2mQuIGYbrvPnz1NZWYmHhwcymQx3d3d0Ot28EpzsgbMLPmcfn/neslBjtFYAuru7ExYWRmhoqBCAC4wQfAKnwWAwUF1dTWNjI8HBwRiNRruJPbB/hG+ywsu9vb2UlJTg7e1NQUHBnCfhq1XwOeOYnAGlUklgYCCBgYHAP11AGhoa6O/v5/Dhw3h6eo5zAVloGzhnF1TOvqTr6AjfTEwmAHt7eykvL0en01FVVSUigAuMEHyCBUeSJAYHBykqKkKv15OXl0d/fz/t7e127dcRET5z+5Ik0dDQQENDA0lJScTGxs7rJmfvsQsWN2YXkO7ublxcXIiOjrZkANfX16NWqy0uIOYi0I62gXN2wbdYlnSddYwuLi6W1Yvs7GxMJpNYAl5ghOATLCjmvWwVFRWEhYWRmpqKUqlkcHDQrtE3cJyXrlarpbS0FLVazerVq/H19Z132+anentMms4a4XPWScDZ3qexmL8fKpWKkJAQSxFvrVZrqQFYU1ODVqudIADtbQPn7IJvMUT45HK5U7+HRqMRGL1fKRSKSb2oe3t7LXOAEID2RQg+wYJhFkKXLl1i+fLlFksqsL8YA/smPsDoNajVao4ePYq/vz8FBQU2X0a7mgQfOOeYFiOurq6EhYURFhYGwMjICL29vfT19VFVVYVOpxvnAuLj42Nz8bMYBNVCeB9bi7O/fzC9KDVHoYODgwEhAB2BEHwChyNJEl1dXRQXF+Pq6jqpo8Rk+99sjT37MJlM9Pb2MjAwQHp6OlFRUTa9SY2N8NkacTO9crD2gcDd3R13d3eLC4hZAPb29tLa2orRaLRkCQcEBODl5TVvseHs4t3ZBZUta/DZC6PROCsnkJkEoLu7O35+fgQGBhIUFCQE4CwRgk/gUIxGI7W1tZZyJEuWLJn0x+qICJ+9+tBoNJSUlKBWqwkJCSE6OtrmfTgiCudsE7K4qTuGsTZwkZGRFv9qswBsaWlBkqRxLiBeXl5XlAsILI49fM4u+ObrBDKVAGxqaqK8vFwIwFkiBJ/AIZgnjeLiYtRqNTk5OdOWI1msS7qdnZ2UlZUREhKCv78/Wq3Wpu2bsafgc+YlXcHssIWokslkeHl54eXlRXR0tMUGziwAzTZwY2sAmkvC2Hts9kRE+OaPrZ1AhACcH0LwCeyO2Se2tLSUoKAgMjMzZ9zL5qgIn3lT8XwxmUzU1NTQ2trK0qVLiYiIoL6+flGWTnHmm6OzilBnfs9szVgbuJiYGEwmE4ODg/T29nLp0iXq6uosLiDmKOBkNnCLQfA58/icPQIJoys69toHKQTg7BGCT2BXdDodFRUVtLW1kZ6eTmRkpFXnOUrw6fX6ebejVqspLi4GoKCgAE9PT0v7i9Hv1lzyxVnFlcB6HCFa5HI5vr6++Pr6EhcXZym/YbaBO3fuHCqValwE0M3NTQiqeXK1RfhmQgjAmXHub4tg0SJJEj09PRw6dIi+vj4KCgqsFnvguCXd+YqaixcvcvToUfz8/MjLy7OIPVu1PxX2FHw6nQ6Arq4uBgcHnUb4XS03ZVvj6PdNLpfj7+9PQkICWVlZrFu3jrS0NFxdXWlra+PYsWMcO3aMS5cuodFoLN83Z0Ms6c6fhcx0NgvA5ORkVq9ezdq1a0lMTEShUNDU1MTOnTuJj4/n1ltv5Tvf+Q7PPPOM1W0fPHiQG2+8kYiICGQyGe++++6M5+zfv5+srCxcXV1JTEzk+eefn3DM008/TVxcHG5ubuTm5nLy5MlZXPHMiAifwOYYjUYaGhqoqakhJibG8iObDfYumQLzE5VGo5Gqqio6OjomlJQxsxgF36VLlygpKQFgeHjYYnE3Njoz2fKco3AW8TkWZxyTGWcY22Q2cH19fTQ1NTE8PGxxARmbBLLQLiAgIny2YDZZuvbm8ghgamoqkiRx4MABXn75ZXp6enjyySfZsGEDGzZsYP369UREREza1vDwMBkZGTz88MPceuutM/bd2NjI9u3b+drXvsYrr7zC3r17eeSRRwgPD2fr1q0AvP766zz++OM888wz5Obm8tRTT7F161Zqamos9TPnixB8ApshSRIajYbi4mL6+/tZuXKlpcjmbHHmLN2hoSGKi4tRKpWTlpQxY2/RaktBKUkSdXV1NDU1kZCQQG1tLdHR0YSFhTEwMDBuec7V1XWcALSn/Z1g/jibaFEqlQQFBdHf34+XlxdLliyxLL01NjZSXl6Ol5fXOBs4R7uAgPNH+Jx9fODcotTHx4c777yTO++8E71ej9Fo5IEHHmD//v385je/4b777iMlJYXS0tIJ37/rrruO6667zuq+nnnmGeLj4/n1r38NQFpaGocPH+bJJ5+0CL7f/OY3PProozz00EOWcz766COee+45/uM//sMm1ywEn8AmSJJEe3s7JSUl+Pj4UFBQMC8hYL5J2POGMVvBZE4+qaqqIiYmhqSkpGnHZu9agrYSfFqtlpKSErRaLXl5ecjlcmpray0Tirn+Wnx8PEaj0TI5nz9/nsrKynEerf7+/nabnJ1NuIzFWcfmDBG+qTDv4bs88qLT6SwZwLW1tWg0GosLiPm76IhlQhHhmz/OXrzazMjICKGhoWzfvp3t27cD0NfXN6nYmwvHjh1j8+bN417bunUr3/3ud4HR7/yZM2f4wQ9+YPm7XC5n8+bNHDt2bN79mxGCTzBvDAYDVVVVNDU1kZKSQkxMzLxvlI4QfLOJ8BkMBioqKuju7rY6culIr9650t3dTUlJCYGBgWRlZaFUKlGr1cDkYkGhUBAYGEhgYCDwT4N0s0fryMiIZXIOCAjAx8dnUdzwr1ScOTFiqrGpVCpCQ0Mt2yQ0Go3lO1ZdXY1Op8PHx2ecDZw97hHOHkFbDILPmZZ0p2NkZGTc/msAPz8/1q1bZ5P229vbJ2z7CQ0NZWBgwFLk3Gg0TnpMdXW1TcYAQvAJ5oEkSQwODnL27FkMBgN5eXn4+PjYpO2xgs9eWCuYBgYGKC4uxs3NjYKCAtzc3Kxu3xnGPxmSJNHQ0EBDQwMpKSlER0dPWjZjJlxcXMZ5tJon556eHioqKjAYDBaLroCAALy9veclQJw5YuWsLDbBdzlubm6Eh4cTHh5u2TZiFoAXLlwY9x3z9/fH29vbJiLDmcUyOH8EEhaHKIXR+5aXl9dCD8PuCMEnmBOSJFnsbsLDw0lJSbHpUp4jBN9MET5JkmhpaeHcuXMkJCSQkJAwqxussy7p6nQ6SktLUavV5ObmThDp80kIuXxyVqvVFgHY0tICYLHnsrZAr2DuOLNAnksETSaTTbCBM3/HzNsMTCaTJQHEz89vzg8Zzi6oFsNy6WIYo9lK0J6CLywsjI6OjnGvdXR04OPjg7u7OwqFAoVCMekxZr9rWyAEn2BWmJ+wS0tL6e7unjJDdb44wu1hOsGn1+spLy+nr6+PVatWWTIMZ4MzLun29vZSXFyMn58f+fn5k2ZD2uq9l8lkeHp64unpSVRUlCUi3NPTM6FAr1kAThc9debJ15lx1vfNVi4gl3/HhoaGxiWByGSycRnAnp6eVvW7GJZ0nfWzNWM0Ghck4WY2mOc0b29vu/WRn5/Prl27xr326aefkp+fD4xuY1i1ahV79+5lx44dwOjnu3fvXh577DGbjcO5PwmBUyFJEl1dXZw5cwa9Xs/atWunzFCdLzKZzO6ZulMJpt7eXkpKSvD29qawsBCVSjXn9u09fmvblySJpqYm6urqSE5Onnafpfl1W49dJpPh4+ODj48PcXFxGI1GBgYG6Onpoa2tjerqatzd3cclgFwuSJ0xYuWMYzLj7GOztWAZ6wISHR2NyWSy2MB1d3dTX1+PQqGwqsyQswuqxRA9WwxLukajEa1WO6sI39DQEHV1dZZ/NzY2UlxcTEBAADExMfzgBz+gra2NF198EYCvfe1r/OEPf+B73/seDz/8MPv27eONN97go48+srTx+OOP88ADD5Cdnc3q1at56qmnGB4etmTt2gIh+ARWYTQaOXfuHHV1dYSHh9PT02M3sWfG3oLv8vYlSaKxsZH6+nqSkpKIjY2d1w3fWZZ0dTodZWVlDA4OkpOTg5+fn1Xt21ssjJ14YTQxZqw/a3l5uSUBxN/f36nFizPjrKLFUS4g5oeM2NhYTCbTuDJDtbW1lijzWAFoHp8zixWTyeQU9QqnYzGIUqPROOsI3+nTp9m4caPl348//jgADzzwAM8//zwXL160bGEBiI+P56OPPuJf//Vf+e1vf0tUVBR/+9vfLCVZAO666y4uXbrEj370I9rb28nMzGT37t02XUETgk8wLZIkMTw8TFFRESMjI+Tk5CCTyejq6rJ7344UfFqtlrKyMoaHh1m9ejW+vr7zbt8ZlnT7+vooLi7G29ubgoICq6KVCyUQlErluPIcWq3WIgBramrQarXA6NO0v78/Pj4+Tj0hOwPOLJIXIilisjJDZgF48eJFampqLHUmDQaDTawX7cViiZ4thjHqdLpZRfg2bNgw7W9rMheNDRs2UFRUNG27jz32mE2XcC9HCD7BlEiSRGtrK2VlZQQFBbFy5UpcXFwYGBiwe1FksL/gMwum7u5uSktL8ff3p6CgwGZPzQuZpWtOqqmtrSUxMZG4uDirJ1d7LenOFldXV8LCwggLC0OSJDo7O6mpqWF4eJjW1tZxm/P9/f3x8vJaMLF6NUfR5oozjG2yKLPZB1iSJIqLi/Hw8BhXBHquWzxsjbNHIGHxiFKNRjOhLMuViBB8gknR6XRUVFRw4cIF0tLSxvngOsIFwxH9yGQydDodZ8+enbI0yXyw95LuVO2PTTjJzs62TGbW4oiEmdkik8lwdXVFoVCwbNkyy+b8sUvAYy3gAgIC7L7lQDA/nEHwXY5SqbTUmTx//jzZ2dloNBqLFdzQ0NC4QuN+fn4Ltqy6GMTUYlnS1Wq1QvAJrj4kSaK3t5eioiLkcjn5+fkTfghXguDTaDRUVlZiNBopLCy0S4aWvZd0YaIoM9cM9PDwmHPCibNNwmbGjmvs5vyYmJhxe7Pa29snWMAFBARM+17odDo+3LWL197aSVt7B5JJwqDTkLQkkaSkRDKXL2PF8uXExcU5/SQ7FmcUVWacfWySJKFSqfD29h7nAmLOAK6vr0etVo/bZ+rr6+uwrNTFIPgWw5KuwWAQET7B1YfRaKShoYGamhpiYmJITEyc9OnMHFmy9w3HXoKvs7OTsrIy/P39LTdse+DICJ8kSZw/f56ampo51QycjIVe0p0N01nAtbS0jLOA8/Dw4PDRYxw8foKB4RFqKspReXgQHptAct5GCqNjAFAPDlJXXkzRuUYOnDzDYG8v7l7ehEdFIZfJkAMKGWAyYNRpWX3iBJkrVrBixYo5lfGxF84sqpx5bDDxvVOpVOMKjU+2z/RyAWivCJezZxHD4hClarUaSZKE4BNcHZjrEBUXF9Pf3z+jdZj5BmbvH7Ot98CZTCbOnTvH+fPnWbp0KT4+Phw9etRm7V+Oo/bwmW3fenp6yMrKstiezRXzZ+pMS7pmrB2T2QLO1dWVk2fOcODocdR6AyhUaLRautov4BsQiLdfADc98k18/CcKNA9vb1bkr7X822DQ01Zfy/m6c6g1GrQaNT7+QaTl5KFydaN9oJ83D57kb+/sQq8dAUlCJkkoAIUcXORy/H19WJqawsqMFaSmplrt2jJXnPEzNOPMgs/8u51pfGP3mcKoRZf5QaOqqgqdTjfOBcSWiUaLQUwthiXdoaEhACH4BFc+kiTR3t5OSUkJPj4+FBQU4OrqOu05jnDBMPdjqz7UajUlJSWYTCYKCgrw9PS0PNnZC0cs6arVao4dO4arq6tVn501OOskPBN9fX28+/77HD9ThNYEJrkCF3dPIpYk4bckjbaTx3B1c8M/OJScTVtxneUeP6XShdiUdGJT0oEvtj90ttNQWc7w4AAatRqZDJIzVxEcETVpGzqtloruXo699QGDvS9iNOiRSSbkSChkMpQycFHIiY6IIGNZOhkZGcTExMxrYnfWz9OZBZ/5dzvb993sAmJ2mjH7pPb29tLa2orRaLREogMCAvDy8przZ7sYBN9iWNIdGhpCJpPh4eGx0EOxO0LwXcUYDAaqqqpoamoiJSVl2mK8Y1lsgq+9vZ3y8nIiIiJISUmxPHGal0TtNfHYO8Kn1+upq6sjPj6exMREm1+Ds0WHxl5fV1cX77z7HqdKy9FJo+JO5eFFVGIKy7buAKDi5FHO19bQ19NNWHQsm265C4UN91fJZDICQsMJCA23vKYZUdNUVUHxoc8ZUQ+j02gIi4knaXkGcqUSlasrASFhBIRMbZckSRKa4WH2VTXy7pFTqAcHwWREJknIkFDKQCmX4e6qImVJAhnLl0+5jOxsn+FYnFnwWRvhmw6ziPDw8CAyMtJS4qq3t5e+vj5aWlqQJGnOmeaLQfAthjGq1Wrc3Nyc9rtoS4TguwoxW1ydPXsWo9FIXl7eBD/V6ZDJZHYXMzD/PXBGo5Hq6mouXrzIsmXLJngSjl26tMeP3V7tG41GKisrGRkZITY2lqSkJJu1PRZnEQsdHR28sfMdisrLURtM/OXN93Dz8iYqMYWM626xvLd6vY5Tn33Cmf2f4eHpRWxqGpvvuNehN3I3dw9Ss3Is/zYajbS3NFFx+gQjw4NoRtS4e3qRvioPzyl+czKZDHcvL9y9vPAPCkE9NIh6aJCR4SFGhoZQj6jRDo+g7eympLKGV3a+h0GnAyRcVCpcXFzQaka4dfv1XLNpo9NOZM4s+KbawzcfZDIZXl5eeHl5ER0dPWmmuUwmG1cEejqvaWcXU+Z93s6+pDs4OCgEn+DKxGyxVVlZSXh4OCkpKXPKKlMoFBiNRjuM8J/MJ8I3NDRESUkJcrmcgoKCScP1Y+vN2ePGOba8ia1uJkNDQxQXF+Pi4oKvr6/dDL8dIegno62tjTfeepuK2joMcgUmmQJ3H1+ik1JZdeOdE97HoYF+ju/Zhcmgx8Pbl6QVKwkIsb23szWYTCY06mEGe3sY7OtlqL+PoYEBRoYG0Gm1KJQKlEoV6sEBDnywk76uTqQvNt5Hxi3Bxc0NuUwGMjlyuQyZXI5CoUTl6obKzQ2Vqyv+wcG4qFxxUalQqlQoFMpJv1uSJFFRXcGb332cLevX8fOf/b8FeEemx5kFnzkhwp7jmyzTfHBwkN7e3gle0+Yo4FgbOGevw2e+fzjzGGE0wne1lHASgu8qQZIki5vEpUuXWL58+bwsWxxRmmWufbS1tVFZWUlMTAxJSUlT3nDsvTRta0F54cIFKioqLNd19uxZp4nCzYWmpibe3PkONU3N6JGBwgUPXz9iktNYmZwx5WTb0XaeogOfoXRR4eMfRM6Ga/GYR6a1waBjqL+fwd5eBvt7GR4YQDM8xMjwMJJkQiZXIFfIkctH/5PJ5MjNrykUX7w++m+Vuwcenl54+PgQGBaBq4cHru7uuKhcLddTffYUNWdPsvaBr6LVjHDys914+vkzMjSIemSEsNhY4lOXzXvfXnzaMuJSl9JcU8WqwnVcd80GfvrEE3Nu09Y4s+BbCDEll8vx9fXF19eXuLg4TCYT/f399PX10dHRwblz51CpVJbon7Pvj1ssgm94eHhKP+UrDSH4rgIkSaKrq4uioiLc3d0pKCiY9xONMwo+g8FAZWUlXV1dZGZmWmpnTYW9CwzbKtvVvDTd3t5ORkaGpSSEvZNCbNl2bW0tr+98m6a2i+iRg1KJp18AMclpZC3NnvH8c6VF1JWcxdXdg6CISNbdeBtGg5HB3m7aW5oY7O9FPTyEdngYrXbkn6JMLh8VZjI5si/EmUGvR6lSoVS6IFcqUCiUuHt64eHlRVBYBFEJSaNCzc3dpnv+1END7HvrH0QlJnPNHfdaXt94610cen8nqzZuwdPLm47WFsqOH0GrHsaERNrKHHwDp86anw6ZTEZcajpxqek0VVeyqnAd165b4xQRP2cXfAs9trGFxM2lhswuIG1tbRgMBkpLSwkMDLREAG2RtGUrzPduZ1/SFRE+wRWD0Wjk3Llz1NXVsWTJEpvUZwPnE3zmgsNubm4UFBRYVe7C3hZithCUw8PDFBcXW5amx96Y7Cn45tN2RUUFb7z9Luc7OlHr9Gi0Olxc3fAPCUXuFwQjanQjIwyeb6alrgYZo8uXcpkcmVyOTC5DkqCtvhatdgSl0gUvXz/CYuNRyOUM9fdTcvQQKjc3PLy8cPf0xjc4GDf3L6Jprm5OF1U4sus91MNDFG6/GRfV+EnZ09uHa+/6MvvfeYOYlDSiEpIIi4kDQKfR0HyuivqKUjQjarz9/ElbmYNyDgW1zcKvuWZU+K3PW81vfv2/tri8OeEMomoqnLHGnUKhICAgwJKcs2/fPuLi4lCr1Zw/f95Sa3JsEshCuYDA6Nxj72VxWzA8PHxVZOiCEHxXLOaMsKKiIkZGRli9ejV+fn42a18ulzvFHr6xBYfj4+NZsmTJrDxj7Slc5ysozdnFkZGRpKSkTBAxjij7Yi2HDh3mv37xS7wCQ3Hz8sRF5YbS3Rtff3dCPTxw8/DE1d0dV7dRQaZydcXF1RUXlavluoYG+ji2+yOMRgPunl54+fqx7YaHCI+Np+zYIdoaagmPW8Ky3IIFvlrraWus58z+T1mWW0hIZPSUxymUSjbdfg/Fh/dTcfIYS1fnA6BycyNpxUrLcb2XOqk4fZyh/n6QJOLTlhIRv2RWYzKXlmmuqSJ7zToKslfxu6eenNsFzgNnFnzOvj/O/LsPCgqyRPX0er2lBmBjYyPl5eV4eXmNs4FzlAsIOH9SiRm1Wi0En2DxIkkSra2tlJWVERQUxMqVK23+pKdQKBwS4ZtOVI71jF21atWc3A3sHSWD2Uf4TCYTNTU1tLW1TZpdPLb9hVzSNZlM/PxXv2b35/uJS1/OrY99D9Usl5RaG+ooPvw5rm7u+AeHsu7GW+jv6ebY7g+56eGv4eE1ujcvc80GMtdsoKm6gs/ffh2FUknB9Tc7dAKbDQaDjk9ffwX/4FA23nKXVcJGJpOxcu1GGirKOPHZx+Ruvm7CMf7BIfgHbwJGIyht9bWcPbQfjXoYFxcXlq4uwMPKRJ7YlDRiU9Joqa0me816Vmcs449PPz2r65wPziz4nDHCN5bJysa4uLgQHBw8zgbOnAFcW1uLRqOxuICYawHac7l1MWTowmixbCH4BIsSnU5HeXk5Fy9eJC0tjcjISLv046glXb1eP+nf+vr6KCkpwcvLa86eseY+7Bnhm60oMxeIliRpyuzise0vxJJua2sr3//Rj6lvbCZ9dQFfevyHKF2se/9NJhPlxw/TUluDh48P4TFxbL//EVy+OP/Yno8Y7Olh+wOPThodiEtdSlzqUnovdXL8kw9RDwyQf92NePv5z/1ibUzxwc+50NzIqo2b8fS2vtyRmYSly/H08+Xzd15n7Y23TSlqFQoFMcmpxCSnAqAeGqSpqoLB/l60I2pCImNIXJ4xY5QlJimVmKRUztfWkL12PSuXpvHXZ56Z9bhnizMLPmeP8FmTEKFSqQgNDbUk52k0GksNwOrqanQ6HT4+PuNs4Gx5zc6eVGJmZGTkqnDZACH4rhgkSaK3t5cTJ06gUCjIz8+365d4ofbwmcvK1NbWkpSURFxc3LwmDXv73c6mvInZ4zcsLIzU1NQZn44dHeF75933eP61N+i81MXy/LU8dM8jViU1aNRqjn/6ESPDQ3j5+LFkWQYr120a97mZTCY+eulvxKctY9X6zTO26R8cwqZb70an1XD2wF4621pJW7Wa2JS02V+ojejrusTet/5B6soc1t1067zaCo2MYcMtd3Hog7dZuXajVYLWw8ub9Jw8YPSz62xrpfTYYTQjw5iMRlIyVxE4pkj05UQnpRCdlML5+nNkr1nPipRknnv2r/O6julwZsG3WCJ8sxFUbm5uhIeHW1xAzAKwt7eXCxcuYDAYxtnAeXt7z0uwLaYlXXuVt3I2hOC7AjAajTQ0NFBdXY2HhwehoaF2f2JZCMGn0+koLS1leHjYZnsS7V1vzhpBaTKZqK2tpaWlhaVLlxIREWFV2/Ycu1lMqtVqfvqLX1FSU4taPUJqVg7XP7JhRjHa3XGRk3s/QaFQ4BMQyKr1m/EPDpn02KH+Pna98nfW33Qb/sGzKxWkcnUjb8t2TCYTlSePsvsfzxMQGs7qa7bOqp35YDKZ+Pzt11G6uLD5zntRKGxzW/Xw8mLznV/i0AfvEB6bQExSitXnymQyQqOiCY0a3Teo12ppPldFU3UlWrUaTx8f0nLyJ42MRy9JJnpJMq31tWSv3UBaQhwv/P05m0/eziz4FkuEb67vn0wms9jARUREWH7rZgF4/vx5TCaTZenXLABn099iWtKdT4myxYQQfIsY81NaUVERAwMDrFq1ivb2dods5HdE4eWxgqa7u5vS0lL8/PwoKCiw2Z5EewvXmaJwGo2G4uJiDAYD+fn5s3rStOdkWVffwJ5DRxjSaDFJsGT5SpbnrZl2EjxXcpaakjN4eHoTHBHFlrvuw9Vt+nIH1UWnqCsr4Yb7H7F6WXgy5HI5y/LWsCxvDW0Ndez+x/PIZHI23nInKisytufKueKz1BSfZuW6jfgFTl8GaC4oFEo27LiDooP7KDt+mOV5a+bUjourK4nLMy3/7u/u4lzxGdRDA+g0WmKTU4lOTB53TtSSJKKWJNFaX8vq9ZtIio3ilRdftJkQcnbB56xjg38KUluNUSaT4enpiaenJ1FRUeNs4Hp7e2lubgYYlwHs6ek5bf+LZUlXo9GIJV2BcyNJEu3t7ZSUlODr60tBQQGurq50dnbaXYiBYyN8dXV1NDY2kpKSQnR0tM3tjhYqwnfp0iVKS0sJCQkhPT191k/Dth67yWTit3/4IyfLqxjW6dGbJBIzVrE0J3/S99yg03Fy3yf0dV3C08eHmOQ0bn7wX5BbeR17d76Kl48/W+76ss2uASAyIZHIhESG+vs4vf8zejoukr/thmmXM2fLyPAwn735CpEJiWy85U6btTsVK9dtoqGyjGN7PiR/yw3zbs83MIgV+WsBMBmNXGiqp+jQaPKHXKlgaXYeXr5+wD+FX1tDHavXbyIhMpzX/vHKvCdzZxZVi2FJ155iajIbOLMLSHd3Nw0NDePqBPr5+U2wgVssS7ojIyNiSVfgvJgLDLe0tEwQQQqFYspEB1viCMFnNBrp6+tjZGSE3NzcWfn9WstC7OGTJIm6ujqamppIS0sjKipqzm3bYuwXL17kv37+K/oNJpSu7gwMq0lYuoLUrJwJk95gXy/H93yEQa/Hw9ub5bmFhETFzKo/vU7L+8/9mZXrryEqIXHe458KL18/Ntx8Owa9nuIj+znx6cfEpy0nbVXOzCdPw5GP30c9OEDh9TehcrVf9PByEtKX4+sfyP733mTNdTfPqRbfZMgVCqKWJBO1ZDTCp1EP01RdwUBvDxr1MIHhEaQsX2kR0m2N9eRuuIao0CB2vv76nCd1ZxZ8i2FJ15Hjk8lk+Pj44OPjQ2xsLCaTiYGBAXp7e+no6KC2ttZiA2f+bzEs6ZpXyYTgEzgdkiQxMDDA2bNnMZlM5OXl4X2ZpZQj6uOZ+7Gn4DN7SZoTUOxVfsPRS7parZaSkhK0Wu2kn9982p4t7334Ia+//xFuAaEofQIYaGogeUUi+VvHR5DO19ZQeuwQrh4eBISEsu6m2+aUfQpwsbmRo7s/4Jo7vmQpuWJvlC4uZG+4llXrN1NfXsJnb/4DV1c3Cm/YMatJ80JTA6f2fsKyvEJCZylybUVgeAQbdtzBwfd3klG4Ad+AQJv34ebhSWrWamD0ntPdfoGyk8fQDA9hNBpJyljJti89yIXGBnI3XEN4UADvvvXmrAWIMwu+xRDhW8jxyeVyy/4+swuIWQBevHiRmpoaFAoFSqWS9vZ2p3MBMWMymdBqtULwCZwLk8lEc3MzFRUVREZGkpycPKkIckR9PHM/9hCWYxMYIiMj6e/vt2utNXtnul6+D7GkpITAwECysrLmfV1zWdLVaDT85P/9nObObqLTluMVGsXFpgZSs1aTuWYjMPoZlBw5QFtjPV4+PoTHLWH7/Y+gnOe+yZN7dzPU38/2+ycvuWJvZDIZicszSVyeSdfFCxz64B1GhgZYd/NteHhNLWANBh2fvvYKfsHBbLrt7gUXAu6eXlx7530c2fUewZHRxCbbLzNZJpMRFB5JUPhoeSeDXkdLbTUttTVo1WpComPxCw0jb8M1hPr78s7Ot6z+Xjuz4BMRvtmhUCgskT0YXYWqqalhaGjI4gLi4eExbgl4rqW0bInRaLTUJ7waEILPyZEkCa1WS2lpKV1dXaxYsWLajCJHRvhsvXRsrkFnMpnIz8+3ZI3ZE3tH+Mzt19fX09DQQGpqKlFRUTaZ6GYjVktKS/n1H/+MydWDjDUb6ThzgqozJ0nPySdzzQY06iE+f/cNNGo1Xj6+JGVkkb3xWpuMc2zJFbOoXGiCwiO49s570aiHOb3/M7outJJRuJ7Iy5aYiw9/zoWmRlZtmFtNPXshVyhYe+OtFB/eT+mxQ5b9ePZG6aIiIX0FCekrgNEl/qaaSvzDwrnYfpGlK1cRFxPFB++8M+OE7syCb6EjaDPhbILvcpRKJW5ubiiVSlJSUtDr9RYf4KamJoaGhvD09BwnABfCBs5oNIoIn8A5kCSJrq4uioqKcHd3p7CwcEaPWEdF+GwtlMw2YhEREaSkpKBQKNBoNHa/FkfUsqurq8NgMNh8H+JM+w9NJhNP//kvHCsuxz8qlrxbv8SxTz7k0EfvsjyvkLjkdE7t/5RzJafxDQgiZ9NW/AKDbDY+mF/JFUfg5uHJmutvxmQ0Un7iCJ+89iLBkVEsSV/OvrffIGXlKtbdOL+aevZk1H2kkmOffED+1hsd3r+3nz/LcwuB0e9be3MjTTWVpC7PJNDfhyMHD04q/MzfW2cVVSLCN3/GZum6uLgQFBREUNDo/UWn01ls4Orr61Gr1RYXEHMRaEe46IgIn8ApMBqN1NTUUF9fz5IlS0hISLDq5rjY9vCZr/PChQsTbMQWqrizrejt7UWtVuPj40N+fr5dnmAnE3ydnZ385Oe/pFdrIDU7n7W338uB997ik1dfwNPXH4NeR03RaUIio9l29/12K1tSXXSKutLieZdcsScmk4kLTfU0VpTR19OFi4uKihNHKTqwl6CwSKrPnqKtvo6EZSsIjohyykk2LjUdn4BAPn/vTdbaMJljtqiHBqkpPoXKzZ3rvvwwxYf2sSQ1jejISD77ZPc41xhnF3wiwjd/TCbTlPc8lUpFSEgIISGjtTm1Wq2lBExNTQ1arXaCALRHAog5wufuPn35qCsFIficDHP9o6KiIkZGRmZdYNiREb75CsuhoSFKSkqQy+WT2ogtVsFndgOpq6vDzc2N2NhYu4i9yyN8u3bv5pW338fVP4jMTdtxcXXj0zdepra0mJDIKILDI4lJTGbdDbfYfbLY+/brePn4suXu++3aj7V0d7RTV17MpbbzyOUKXFxVuLi4onJ3Iygsksy1G/AJCKTkyEG8fH1ZurqAPa+9xJY77mVEPUxbYz3NVRUYDAYMBj0GvQ6/oFCWLFthl8SJ2RIQEso1t97N/nffZEX+WvyCbF8TcCrO19dSV1qEX1AwOddch8sXgrPw+h3o33mDgcF+ctduwFWl4LOPP8bPz8/pBZ8zLzfD4hF81oo0V1dXwsLCLA/8IyMjlghgVVUVOp1unAuIj4+PTa7fHOETS7oChyNJEq2trZSVlREcHMzKlStnLRQcFeGbr7Bsa2ujsrKS6OhokpOTJ/3xOkLw2XpJV6fTUVZWxuDgIDk5OdTU1Nis7cuRyWRotVr+87+eoP7iJaJSl7L2zvvp67rEs//zIxRKBakrs7n7W/9OcIR9PJUvx6DT8e6zfyRz7UZiklId0qcZ9eAAdeUltDXUjkYXVCpcVK64uLriGxhE4rIVrL5m65ST0Jn9exkZHiJr/TUAbLr9bj5961WuvfNekjOyIOOfx0omE33dXVxsauBcyRn0Wi0GnQ6j0UBIZAxLlq3AzcOxxVxd3d259q77OLrrPQJCI4hPW2q3vkwmE6VHDzLQ20NYTCz5226YIJDkcjnrbrqVQx++i4uLCrlCzrU334qLZOTgvr2Acws+ZxZUzj4+mF/hZbMLiNkGbmRkxBIBbG1txWg0WrKEAwIC8PLymlNfOp0OvV4vCi8LHItOp6O8vJyLFy+Snp5utb3W5TjCAQPmLsbMNQQvXbpEZmYmwcFTRyIWW4Svr6+P4uJivL29KSgoQKVS2a2wc2VlJf/9v08i8/QlY+0Ggl3rqTxzkqO7P6S3q5Pt9z8CksSFxgZO7/8UySSRtW4jYTFxNh+LmfbmRva/9xbb7n3IbiVX9DodzTWVNNdUoRkZRi6Xo1S64ObpiYe3D+FxCaTn5M66Pt6Jz3ZjNBjIXLPe8pqntw8bdtzOZ2/+g813fGnchCKTy/EPDplgF2c0GEajiaVFjAwPodPq0Ou0yOVyIhISiUtdate9SXK5nDU33ELZ8cMUH95P5poNNm1fq1Fzct8e5DI5CenLScvOnfZ4pYuKvC3bOfHpLsIj4jhfV0PM8pWs2bSZH/77404r+MSS7vyx1RhlMhkeHh54eHgQGRlpWQUzRwBbWlqQJGmcC4iXl5dVn9/Q0BCAiPAJHIMkSfT09FBUVIRSqSQ/P39eTxvOnLQxODhIcXExKpXKqgSUxSL4JEmiubmZ2tpaEhMTiYuLs9xsbFnY2WQy8ee/PsuhohLc/YMwuHqgHx6i9OghQiJGizd7+PhScP1NLFtdAMCyLzbUa9TDVJ89RXXRadRDA8hlCrI3XktQ+NweLC7nxJ5dDA0OsOPRx+Z9kzeZTFxsaqChqoz+rksov4jUqVxVqNw9CIuOpeD6G22WNXts94fIFQpW5E+0LfP282fN9Tex7+3X2Xz7PTO2pVAqCYmMIiRyfDFtnVbDpbbzlB8/jHZkBL1ei0Grw8XNnfi0pYTFxNl0Al+et4bmc9Uc+fg98rfeOO+2uy5eoOz4Ybx8/ViRvxY3d4+ZT/oCd09PstZt4uzBvSzPW0vl6eNEJKbw3//7G1RubmzbsmVeY7MHzh5Bc3ZBCvbz0h3rAmK2gRsaGrJEABsbG5HJZOOKQF/uAmLGLPhEhE9gd4xGI/X19dTU1BAXF8eSJUvm/QNxxqQNSZI4f/685ToTExOtTkCRJMmu+2nmu6Sr1+spLy+nr6+P7OxsSx0qW7UP0NXVxY//3y+oaWzCYDQSHBGFh0LBmutvxicgkI9f/ju9XZ1EJybj6uZuEXtjcfPwHBftUQ8OUnX2JGUnjqAeGsBF5UrOpi34B4VMOHc6RkuuPEtc6lJWfrEUai09nR3Ul5fQ2XYeuVw+ugTr6oqLypWg8AgyCtfhGxBk14nt0K53cXPzIG3V6imP8QsOIeeaLex753U23XLXnPpRuboRmZBEZELSuNfVQ4NcaGzg7IHP0Gm0o0JQp8MnIIjEZRn4h8w9szk2ORUf/wAOvr+TgutvnlPds+qiU7S3NBMcHkneluutts27HJ+AQNKz86krLyJzzQYaK8tw8/Tif//0Vw4dPsr/PPGTObVrL5zdJWIxRPgc5aUrk8nw9vbG29ubmJgYTCaTxQbOXMBfqVSOiwC6u7sjk8kYGhpCqVQ6RU1ARyAE3wJgtnMpKipiYGCAVatWERhom43fzlZ4eawgysrKmtV1mid6ewq++UT4BgYGKC4uxsPDg8LCwklvGvNZ0t21ezf//fNfYZIriEtbxsoNm0ldmWMpgFx8+ABN1RVs2HEHLbXVDA8OWvafzYSHtzerxhw71NdH5enjFB3az8jQACpXd/K2Xo+3r/+UbQz197Hr5edYd+NtBISGTXqMenCQ+vJiWhvrkaTRrD3zvjqfgEDi05eSvXEzCgeUYLicA+/vxNvXj+TMVTMeGxweSWbhBg5+8LZNy7R4eHmTuDyDsRsEJUlisLeHC40N1JUVo9Nq0Ot0GA0GgiOjSFyeMW2h6LH4B4dwze33sP/dN1m6Op+AkMk/p7EYDAZOf74Hg05HdFIK+Vu3z/XyxhESFY1Oq6GuvJik5Svp7bpEXelZypp92Hrjzfz6Z/9DaGjogtVkG8tiiPA58/hg4cYol8vx9fXF19eXuLi4CTZw586d46c//SnBwcFERkZatt5Yy9NPP82vfvUr2tvbycjI4Pe//z2rV0/+wLhhwwYOHDgw4fXrr7+ejz76CIAHH3yQF154Ydzft27dyu7du2dx1dYhBJ+DkSSJixcvUlpaiq+vLwUFBTa1nDFHxez9Y7NGKPX19VFSUoKnp+ecrtM8fntey1wE2diIZUJCwrQlc+aypPu1x75NVWMz4fFL2PH1707Yd9fT0c4nr71IRuF6bvvat6k6c5LOtlY23/GlWfUzFi8/P1Zv3mb5d393F6XHDtHT0Y5eq8Xbz5/Vm7dZ9uZVnz1FbVkRNzzwKEhQV1Yyuq9OPYRSpUL1RbTOw9uH8Nh40uawr86e7Hv7dQJCQklcnmn1OWExsRj0Oo7sep/C62+y29hkMhk+AYH4XJb9azKZ6Olsp6GinOGBfvQ6LXqdDpCIjE8kLn0pKtXE91jl5sa1d97L0d0f0nepk4SlKybtd7CvlzMHPsPV3YPkjCy8fP1sfm1RS5LQqIdpqa0mJimVrHXXUHHqKJ4+fnzj3/4PX3vgy4SFheHt7U1AQIBdS3JMh7MvmS4WwecMUdLJbOC++93vsnfvXvbs2YNarSYpKYlNmzaxceNGNm7cOK482Fhef/11Hn/8cZ555hlyc3N56qmn2Lp1KzU1NZYSM2N5++230el0ln93d3eTkZHBHXfcMe64bdu28fe//93yb3vZ0Mkke1adFYzDnLDQ0tJCSkoK0dHRNr+p6PV69u7dy+bNm+26Oby/v58zZ86wadOmCX8bW5bk8j1ts8FoNPLpp5+yadMmu4Xcz507h16vZ+lS6zIaDQYDFRUV9PT0sGLFihkjliUlJXh7e5OQkDBj2yaTidvvu5/YzFwy126Y9O+7XnoWn4BA1t54C0qlC801VZSfPMa2Lz1g1fjnSk9nO5WnjtPb2UH5yWO4e3oRl5KGytUVlbsHodExhEbF4Onja9dx2ILP3nyVkKhoEtKXzen8pupKWmqrybv2ehuPbG4Y9Do621ppb2lCox5Gr9Gi0+tQqVTEpi4lKiHRshRbfuIoAz1drFz7z9/t+doa6itK8A0KJjkjyyE1E8tPHMFF5WrxJD5fV0PXxTa8ff244ZoN3HX7bZY9WXq9Hh8fH4sA9Pb2trvYKS8vx8fHh5iYhfFMngmzV21iYuLMBy8QR44cYenSpbMqK+ZoXnrpJX72s5/xzDPP8Pnnn/P5559TXFxMamoqb7/9NikpKeOOz83NJScnhz/84Q/A6D05Ojqab33rW/zHf/zHjP099dRT/OhHP+LixYuWfYMPPvggfX19vPvuuza/vssRET4HIEkSfX19FBUVIUkSeXl5dqvsbX6iMhqNds8GnCwydnlZkvn82MdG+OzFbJZ0zUknrq6uVkcsrd3D19raygPf+DbbH/oagWHhE/5+5sBe2hrq2LDjDktmaEdrC2cPfc6ND37VqvHPBzcPLy42N9LX1UXB1htABu0tTay98VbcPKzfwL/Q7HntJSLilxCXmj7nNuJS0zHo9ZzZ/xmrNmy24ejmhtJFRURcAhFx4x8qNGo1HeebKDr0OTqNxhIR1GpG2PPGSwSFRzLc309YTBx5WyeWVbEny3ILObVvD65uHvgFBRGdmEJAaDiVp46xa/8hikpK+Ptf/oxMJmNkZISenp5xGZljN+R7enrafOyLoQ7fQi97z8RiiEIODw/j6enJ9u3b2b59dOtCT08PBw8eJCrqssQrnY4zZ87wgx/8wPKaXC5n8+bNHDt2zKr+nn32We6+++4JSSL79+8nJCQEf39/Nm3axE9/+lObbfMaixB8dsZoNNLS0kJZWRleXl7k5eXZVYiZb1L23sc32R6+np4eSkpK8PPzo7CwcN43JJlMZreyJmP7sFaQVVVVzSrpBKwTlC//41Xe3LOPe//P/zdhL1vnhVYOvvcWmWs2svqarZbX+7u7OPDeTm756mN2nZj6u7v49PWX8QsKYfPt9/L5O6+zZvvNAIwMD7H3rVdRuChZf/MdTn9z//gfzxObkkZMYsrMB89A4vIMDDotJUcOkFG4fuYTFgA3Dw9iU9KJTfmnuJUkic628xz64G0aK8oIDI/ANyh4QcRN9obNHN39AW4e7rh5eOLp7UP2xi3UnD1FfetFtty4gxf/+gwRERF4eHhYMjLNG/K7u7upr69HqVSOE4C2cE1w9iVdZ99jCM6zpDsdarV6QsH/gIAAduzYMeHYrq4ujEbjBC/70NBQqqurZ+zr5MmTlJeX8+yzz457fdu2bdx6663Ex8dTX1/PD3/4Q6677jqOHTtm8/dPCD47IUkSWq2W0tJSurq6CA0NxcXFxe7+gDKZzCG1+MZm0ALU19fT2Nho86Vqe5dmmal9o9FIZWUlnZ2drFy50uIFaS0zCcpHH/s2LqFR3Pov3x73usFgYNdLz+EfEsLtX//uOCGoHhpi18vPcdvXvmO3m35nawsH399JSFQMOx75BipXN/7x1M+5+eGvW45x9/Tihgcepb2liQ+f/wuxKelkFK6zy3jmy0cvPUfishVEJthuCSx11WqKD++n7PgRlucV2qxde9Jaf47qotNcf9/D1JWXYNDr6TzfTM2Zk7h7ebE0t9BhQkIml5O3ZTuHP3qXpdl5KL/YPJ+6ajWdbedpqa3hnq/8C9969GFuv/WW0XNkMnx8fPDx8SE2NhaTyUR/fz+9vb1cvHiRmpoa3NzcxgnAuWwHcXZB5ezRM0mSHJalOx9GRkYcZqv27LPPsnz58gkJHnfffbfl/5cvX86KFStYsmQJ+/fv55prZlf5YCaE4LMDkiTR2dlJSUmJJYOzra2N4eFhh/TvqPp1MPqDKS8vR6PRkJubi4+PbWqjje1noSJ8Q0NDFBcX4+LiYlXdwKnan2z8fX193H7/w1xzz4NExMWP+9vJz3bT0drCptvummDbpdNqePsvf+C2f/mWXTJbG6srOL13D9GJydz6L99GqRyN0n700t9Ys33HpL67YTFx3PnNx6k+e4p3//ZH8q69jrDY+AnHLRQfvPAXUlfmEG6HMWWu2cDZg/s4V3yW5Mwsm7dvS4oO7kOn1bJ2+w5kMhkpmas48P5OMtdsJCVzFX3dXZQeOYB6eIjEZZmEREXbfUwKpZL8bTdwZNf7ZBSss9xXQiKj8Q8KoeLUMZ780585fOwYT/3qlxPOl8vlFmEHow9K5oK8zc3NVFRU4OXlhb+/PwEBAfj6+lr10O3sEb7FIPgApx4jjEb4rK3BFxQUhEKhoKOjY9zrHR0dUyZ5mBkeHua1117jiSeemLGfhIQEgoKCqKurs7ngc+5PYxFiNBqpqqri5MmTREdHk52djZubm8McMMAxbhvmH/KxY8dwc3OjoKDA5mLP3M9CRPguXLjAsWPHCA4OJicnZ05iDyYXlJ/u28fdX3uMux7/wTix197SzJt/eoqgiCh2PPKNCWLPZDLxxtNPcvPDX5tUeM2HytMnePWpX9DX0cEd3/hXCrbdaBF7pccPExgWMaNgSs3K4c5v/CsXm5v48IW/olGrbTrGufD+s8+QvirXLmLPTNa6TaiH+mmoKrdbH/Nl39uv4+HlTeaa9eOETN6113Nq3ycA+AUGkbVuEwVbb0A9OMCpvbs5s/8zDGOyDO2BytWN1ddspezYoXGvu7i6krlmA97+gRw+fpLtt9xmKZQ7FUqlkqCgIJKSkli9ejVr1qwhNjYWg8FATU0Nhw4d4syZMzQ0NNDX1zflvWUx7OFz9vEBi3JJdypUKhWrVq1i7969ltdMJhN79+4lPz9/2nPffPNNtFot991334z9tLa20t3dTXj4xL3c80VE+GyEudp3UVERWq2W1atXj0tYcFRBZHNf9hRJJpOJuro6AJYsWUJcXJzd+nK04DMajVRXV1tqLE2Waj/b9sd+7j/+n5/ROqTlnu983/Ka2X82In4Jd37jXyctbmsymXjtd79i+/2P4GHDhJ/Tn3/K+doakjOy+NJ3/2PCJDLY10t9eQk33P+IVe3JFQryt25Hox5m/3s7MZmMbNixMPv73vnrH8lcs94hPsKrN1/H4V3voVK5ErUkaeYTHIReq2X3q8+zav3mSZOBXN3dSVqxkqqiU6StzAFGv7MJ6ctISF/G8OAAVadPMNjfR9SSJGKS7eOP7Onjy/LCtZSfOMqy3PGFw+NSlxIQGkZN0RmuvekW/ve/f0JhoXVL6CqVitDQUMu+K7Mna09PD21tbZhMJnx9fS0ZwGZLLmePoDn7+Mz3PGceI4x+H6wVfACPP/44DzzwANnZ2axevZqnnnqK4eFhHnroIQDuv/9+IiMj+dnPfjbuvGeffZYdO3ZMSMQYGhriv/7rv7jtttsICwujvr6e733veyQmJrJ161ZsjRB8NkCSJFpbWykrKyM4OJisrKwJCQtKpfKKiPCNjIxQUlKCwWAAmLcgmglHLOma2x8eHqa4uBi5XE5BQYFN9naY21er1dz/tcdYvnEL61L/WQLm2J5ddJ5v5rr7HsbHP2DKdt7601Nsvv1L0x4zGw5+8Da9nR0sz13D6k1T31jef/7P3PLIN2fdvpuHJ9vuuZ9LF9r45NUXiYhLcNj+PpPJxM4/PUXONdtsZh1nDYXX3cSB995C6epKWNTCl/Pobr/Iic8+Zv1Nt+M6zXc5NjmV87U1qIcGJ3gge3r7kFG4DkmSaGuosxRkzly7ETcP29pRBQSHsWR5BjVFp0lZmT3ubz7+gWStv4bqMyd57N+/zx07buKH3//erPtwd3fH3d2diIgIiyerWQA2NjZaarbpdDr0er3TRvqcXfCZ76nO+N6NRa1Wz2pf9l133cWlS5f40Y9+RHt7O5mZmezevdvyQNHS0jLhc6mpqeHw4cPs2bNnQnsKhYLS0lJeeOEF+vr6iIiIYMuWLfz3f/+3XWrxiTp880Sn01FeXs7FixdJT08nImLyCaa9vZ3GxsYZQ7+24NixY8THx8+4r2C2dHR0UFZWRnh4OKmpqezbt4/8/Hy7Gk8fOXKEpKQkuwnLixcv0tzcTFxcHOXl5URGRpKSkmKzm2ldXR2nTp/hHx98zPaH/gV3z9H36kJTA8d2f8iqjZtZMkUhXDPv/OUP5FyzjfC4+S1LmkwmPnvzFTTDarI3bJ4xEvXec38ie9MWi0/vfDhXcpbiIwfJ3rh5QvkQW2IymXj7z79n9bXbCAieuy3ZXJEkiX1vvUr66gICp3AfcQTVRafpPN/M6mu2IrPiu2zQ6/n8nTdYc/3NMx6r02g4V3KGns52gqNiSMnMnvGc2dBUXUFPZwcJaZPXSbzY3EhjVTkpiUt49cXnbZYIZ7bk6unpobm5GUmSUKlUluifv7+/3QrizpaTJ08SHx9PcHDwQg9lUoaHhzl9+jTr1ztnBruZO+64g7S0NJ588smFHopDEBG+OSJJEj09PRQVFaFUKikoKJg2NLyY9/AZjUZqamq4cOECy5YtswhJRySH2LssC4w+5ZWXl4+7Nlvxwquv09I/zG3ffByZTIZOp2HXi88RHhvP7d/47ozC8qMXnyVjzYZ5iT2DTsfufzyPTCYnb8v1BFsh4M4e2EtUQqJNxB5AckYWicszObn3E87u38vmO+/BzcO2Dwomk4mdz/yWgutumrD/0VHIZDI23nY3n77+MtkbNuNto4jsbDj2yQe4e/qQe+11Vp+jdHFhRcE6io8cIHOGMjMqNzeW5Y4uqXacb+b4Jx9hMhlZmltok/c9LnUpGrWa1sY6ouInZlWHx8bjFxRC+Ykj5K3fyGsv/N0mBYjHWnK1t7eTlJSETCajt7eX8+fPU1lZiaen57gMYHtXXZgKZ88iXgwZugAajcbqpI0rASH45oDRaKS+vp6amhri4uJYsmTJjJtTHSn4bLlf8PJlzrGi1lHZwPbqQ61WU1tbi8FgYM2aNbPayzETBoOBr37n34hYnsWmzaPZm0c+fp/+7i623nO/VbZVe15/mYRlK4hNSZvTGNRDQ+x57QXcPbxYf9Pt+AZat3TRc6mDtsZ6m7t3yOVy8q69Ds2a9Rx4byd6vY5Nt95lk4nBYDDw9jO/Y+2Nt+DtN7X/ryOQy+VsvvNePnn1BQq23oCHt+2TmSbDZDLx6Rsvk5yRNacoamhUNG0NtfR0tlvluQsQGh1LaHQsBr2ec6VFVJ4ctUlblje/8i6pWTkUH/6crottBIVP3IPp7ulJ9sZrqSsr5ubb7+Tx73ybrzz04Jz7uxxJklAqlfj5+Vn2Xen1eov7R319PSMjI3h7e1vEnyMt4JxdUDn7krMZjUZj1xUqZ0MIvlkgSRIjIyMUFxczMDDAqlWrrK6G7egIny1E0oULF6ioqCA6Oprk5OQJP2BHZQPbQ/B1dnZSVlZmSayxpdirqq7m//78f9l05/14+/tzvq6Gk3s/YfU1W4m78Var2jj4/k5ComNIzph9qY/+7i4+e/MV/AJD2HbPgxP2ZU2HyWTi45ef47bL6gLaEjd3D7be/WW62y+w57WXCI2KZeW6DXNuz2AwsPNPv2X9jtvxchJrN4VCwZa7vszuV/7O+pvvmHYPnS1QDw7w+TtvkLfl+nl54K5cs4G9O18jf+sNs5qwlS4upK8arS/W23WJogOfoRkZISljFSGRc4sSZxRu4MSnH+Pq4Yn3JNckk8lIWrGSwLBwfvP7P3Dg8GGe/+tfbCI0JsuCdXFxISQkxLK9RKPRWARgVVUVer0eX19fSwkYb29vu+1hc/YI32IoumwymYTgE0yOJElcvHiR0tJSfH19rbbWMrOYInwGg4Gqqio6OzunzVRdjBE+k8lEbW0tLS0tLF26FFdXVyoqKmzW/t/+/jyHKs5x46PfGs2+/dvTRCYkcfvXZ16+NXPi049x8/Rmee7sivmOFkt+m9CoGG5++OuoXGdfuuWdvz3N5tu/ZJcaf5cTGBbBjq98ndrSIt75yx/I3rSF6MTkWbWh1+l4+8+/Z8Mtd+DpoEiatShdXNhyzwPsfuXvbL79Syjt5AfdVl9LxekTbNhxB8r5utvI5WRv2sLpzz8d5+wyG/yDgsnZtBWTyURDRSkNFcUoVSoyCzbM6j2QyWSs3ryNwx+9S2pm9pSliAJCwsjfegOlxw6Tk1/I7g/fn/feNmsElZubG+Hh4YSHhyNJEmq12iIAW1paAPDz87MIQA8PD5sJQGePoDl7BBL+KfjsZXPqjAjBZwUGg4GKigrOnz8/ZycJs+BzRNbXfCJ8Zr9YlUo1Y7HhxSb4NBoNxcXFGAwGS7JJb2+vTdo3mUw89u/fxzsuiU233cPBD99leKCP6+57eFYRttKjB9HpNBRsu8nqcxqrKzizbw9RiSnc+i/fstTPmy3H9+xiydIVBDg42SBpxUqWLMvg9Od7KD68n0233YOnFTdhnUbDm398ki13f9mSDONsqFxd2XLP/ex59UW23HkfchsL6eLD+9Goh1l34y02u6/4BQYRHBlFa0MdUfNwJpHL5SQuzyRxeSbDgwOUnzjM0MAAMUmpVpd3kcvlFGy7gUMfvjuuMPPlKF1UZK3bRPO5Kgo3buLXP/85N96wfc5jn22dO5lMhqenJ56enhMs4Lq6uiZYwAUEBMy5tudcxudonF2Qwqgo1Wq1IsInGEWSJAYGBjh79iwmk4m8vLw5Pw2Yw9uOCHXPJcJnLi1TXV1t2Zc40w/WUYLPFonkly5dorS0lJCQENLT0y2fgS2uobW1le/+f09QuONOBnq6efsvvyfv2uuJTpqdZ2ttaRGdba1svPUuq46vPH2CqlPHSVi6gtu//q/zusF2Xmilp/Mi1945c2FQeyCXy1l9zTYyCtZz8IO30aiHuOaOe6e8Jo1azXvP/YltX3rQ7sul88XN3YNrbv8Se954mS1332+zifDzd94kLCaGtFWrZz54lqStWs3+d98kLCbOJokJnt4+ZK27ZvQ+U3eOk59+jEkykblmw4zlXZQuKvK2bOfEng9ZUbB+2vcvNjmNwNAIfvDjn7D70095+rdPzWm8830wn84C7sKFC+Ms4AICAvDz85uVBZyzC6rFsKRrMBhEhE8witFopLm5mcrKSiIjI0lOTp7Xjc/84zQajXb/Icx2+Viv11NRUUFvby9ZWVlW70t0RDHp+QoySZKoq6ujqamJtLQ0oqLG7yeayet2Jt7c+Q7vHzzKNfc8yEcv/Y2E9BXc/vXvznqyaK2vpab4DNfd+9CMx57+/DPO11aTsjJ7Tn1djslk4rM3XuG2f/nWvNqxBa7u7lx75710t1/kk3+8QEhUFKs2XDvuGPXQEB88/xeuveNemzuO2AtPHx827LiDT19/mWvvum9ek7VBp+OT119i5Zr1BIbZp86gTCYj99rrObb7Awq23WjTdqOTUohOSkGrGaH67CkG+3oJCo8kOXPVlOe5e3qStX4zxYf3syJ/7bR9ePn6UnDdzZSePk7umnUc+GzPrKNptt4jN9YCLiEhYZwFXGNjI8PDw3h5eVlKwPj5+U05T5g9zJ1Z8C2GJV1zhE9k6V7FSJKEVqulpKSE7u5um7gtwPgIn72Ry+XorLRD6u/vp7i4GA8PjzntS3TmJV3z56jVaqeMzs6n/X//zx8h+YeBQsH+995kxyPfmFMx2ksX2ji59xNuevhr0x43vljyljmNeTJ2PvNbttz95UkdPhaKwLBwbnn0m9SVl/D+358hc81GYpJSGB7oZ9dLz7LlrntxUTlHTTRr8QkIpHD7Tezb+Sqb77h3Tm30dHZwfM9HrN1+M67utks0mgwPLy8Sli6ntqyYpOWZNm/f1c2djILRYtwdrc2c+uxj9Ho9y3LX4BMwsZyNT0Agadl5VJ45TvqqvGnblsvlLF1dQMf5FlblF/L3vzzD6pwcq8blCEFltoAzF/3V6XT09PTQ29tLTU0NWq0WHx8fiwD08fGxjMd8v3JmQeXsEUgYHaMQfFcxkiTR2dlJcXExnp6eM+5hmw0ymcxh9mrWRPgkSaK5uZna2lqWLFlCfHz8rCNFzryHr7u7m5KSEgIDA8nKypoyOjuX9ru7u/nG935IcEIydaeOsfGWO4mc416nwb5ePn/nDW559JuTvv+jxZL/gWZ4eLRY8k22te069OE7pGfnLVjduplIXJbBkqUrOL1vD6988A5DvT3c+JWvLzqxZyYgJIzsTVvZt/N1Nt1m3dK9mXMlZ7jQ2MDGW+502GQan7aMwx+/j0Y9bHNnjbGERsUSGmUu73KGilOdeHpPLO8SHBGJdkRNbVkRSctXztxudAx+QcF87buPc/3ma/jpf/1kxnPMEX9H7pFTqVSEhYVZ6oCOjIxYBGBraysmk8mSAGJ+cHVmQbWYlnSF4LsKMRcXrq+vJykpibi4OJv/4B2VqTuTiNHpdJSVlTE4OEh2djb+/nOrW+aMgk+SJBoaGmhoaCA1NZWoqKhpP0fzkq61e3Y++fQz/vzqW2h1OoIliXsf/8GcvycatZoPX/grt/7LtydE1+ZSLHm2XGhqYGR4iOTM2Zd+cRTlJ45QU3wGdy9v9DotHj4+NFWVM6IexqjXYzToMRgMGA16jAYjru4eBIWHEx6TgH9oqFNOiiGRUawoXMuB93ey/qbbrDrn2Ccf4ubhQf7WuScizJXca7ax/903rXLhmC+j5V1Go3e9XZ1flHdRk5SRbSnvErUkCY16mJbaamKSZk7+cHV3J2fTNo6XlrB52/Xs2fXhtN8LZ7AFc3d3JzIyksjISIsFnFkANjY2AlBVVWWJALq7uztVEsdiWNJVq9WYTCaRtHE1IUkSQ0NDFBUVodVqWb16taU2m61xlOCbrp+enh5KS0vx8fGhoKBgVhuFL8dRgk+v11t1rE6no7S0FLVaTW5uLj4+M5fpMN+UrBF8P/6fn/H50WNEJiSx/cGvzitZwKDTsfOZ33HLVx8bV0pDPTTEnldfwN1zdsWS59L//vff4ravLvy+vbHodBoOvv82g329ePr4smRZBrf+y7c58tF7bLj5DoxGPR3nW8jfMlH4SJKERj1Mf3cXXe1tNFSVYdDpMRj1mAwGtCNqDHo9SpWKgOBQQqJjCYuOXZB9gBFxCRj0eg599C5rt++Y8jizHV7iskwiE5Y4boBjcFGpWJqbb5ULhy3xDwoZLe9iNNJQWUZDeTFK19HyLonLMyk/cYSO1hZCrfAtlslkJC7PpLfrEjmFa/nH88+RkjJ5UpU5wucsgkUmk+Hl5YWXlxcxMTGo1WqOHz+Ol5cXHR0dnDt3DldX13EOIAttAbcYlnSHh4cBRITvakGSJM6fP09ZWRmhoaFkZWXhMs86VtPhSMF3uRAbG/lKTk4mJiZm3k+EzlR4ube3l+LiYvz8/MjPz7f6czS/B9PdoNRqNTfefhcKLx+23//onJdvzZhMJl5/+jfc+PC/WERjf3cXe15/iYDgMLZ9aXbFkufCzr/8jm33POAUN+Wezg6OfPweMmR4+Piwcu3Gce4KQwP99F7qIHvjaPJGfXkp6qHBCe+RTCbD3dMLd08vwmLipuxPr9Mx2NdDb2cHFaeOoRvRYDDoMej1GI0GjAYDJqMBT18/gsOjCI+Lx8cOFmkxSSkYdDqO7dlF/pbrJ/xdPTTE52+/Ru611y24e0hEbALna8/R192Fn50eQqZCrlBYyrsMDfRTfvwwQ4MDxCSn0Xm+GVc3D/yCrBuTb0AgyatyueWuL3H91s387y9+MeEYZ4jwzYRcLic+Pp74+HiMRqMlAcRZLOBMJtOC2c5Zy9DQEGDbovvOjnN/InbGZDJRXFxMeno60dHRdu/PkUu6Y/vRarWUlpYyMjJideTL2n4W2ktXkiSampqoq6ubk5AdG+GbjAMHD/G9nzxB4fU3s3LdJptMAq///tdcd+9DeHr70Nnawr63Xycybgm3PPLNORVLni373n6dzML1k7oXOIqa4rNUnDyKm6cnwRFRXHvnfVPW0vvg73/m+vu+Yvn3hh138uELf2Hblx6cU98uKhUBIWHT2oeZTCbUgwP0dV/i/LkahgcH/ikI9XoMBj1Go/GLtkIJj40nMDxy1pNcwtLl6PU6Tn/+qUXQArQ11lNx4qhNiinbipxNW/jszX9MG5G0N14+vmStHy3vcr7uHEaDnrMHPyMmOQ2T0cjI0CBGk9FSzkkmk6F0cUEmlyOXyZErFLi6e5CSlc3B46fYt28fmzZtGtfHQuzhmw2XP5wqFAoCAwOdygLOaDTOa/XIEQwNDeHq6uoUD72O4qoWfOabgrVlSGzRn6MjfF1dXZSWlhIYGMjKlStt+tQ1m+XW+fQxleAbuxcxJydnTkvxl2e+jeX+hx6m7Fw9yStXoXJ3Z2R4GI957vd4809PsfHWu+jt7GDXS88Sn76MO7/5+JyLJc+WpqoKQCJh6QqH9GfGoNNxfM8uLrW34entS1xqOrc8+s0ZM4NPfPoxS3PyUY1ZolK5urJy7UbO7P+MVRs222W8crkcL18/vHz9iEqYOlFGqxmhv7ub3kvtNFVXYjQYxkUKjQYDIOEbGExodAxhMXEThG1K5ioqdDpKjhwgo3A9JUcPoh4cYN1NtzqV6JDL5WRv3Mypzz8lZ+O1M59gR2QyGTFJKWg0I+g0GlrrzrFkRQYxySlWu8T4BYfwr//xAw7s+WTcvcNc1NiZ3vuxzFR0eToLuMrKSgwGg90t4BbDkq5arXa6vY/25qoWfDKZDKVSueg8bmdCLpdjMBioqamhpaWFtLQ0IiMjbf7FXsikjb6+PoqLi/H29p7XXkTze3J5hO/3f/oTXToT//m3Vxjs66XjfDOVp44zMjSITqdFp9Gg12nR63T4B4cQm5JGbFLqtNZR7/7tTwSEhvHZG6+QujKbe77zfYfeFHVaDcc/+5hbv/qYQ/rr7+nm0EfvYDIY8fbzJz0nn7Ux1nkJw2hSy4XG+kkjefFpy6grK2Z4YABPG0Ws54KrmzshkVHT+sUaDQYG+3vpu3SJmqLTaIbVGA169Hodhi+Wj00GIz2d7VScPEZG4Xqy1m2asr2FJCAkDL+gYC62NBE+zbK5vVEPDXJq3x6iE1MouO4mGirLqC46jUwmJzTKutUauVxOanYeGzZfy9mTJ8ZF+51ZrMxWTFlrAWdOALGFBdxiyNIdHh7G3cmLttuaq1rwgWM9bh3Vl8FgQKvVcunSJYuFmD1YiD18Y8vJJCYmzjub2vwkP7aPdz/4kD///UW+8n//e7Rivn8APv4BJK2YWAbCZDLRe6mD9uYmTu8fzSjUa7XotVp0Wi0GvY7QmFiqTp9EoVSSkL6MjTffuSBPla/9/lfs+Mo37Np3Y1UFxUcOoHJzIzA0nE233IWnj++c2nrv2T+y5a77p/z7xlvu5P3n/sy2ex+c42gdg0KpxC8wGL/AYOJS0yc9RpIk9rz2El0X2+jpbOfgh43IZTKWrs7HP3j+dUBtyfK8QvbtfI3QiCibW8VZw+kDn4FJInfzdZZoXnzaMi40NTDU14tuRG21y42Xrx+B0XHcsONWdr3/LjB/lw17M5/o2VQWcD09PVy6dIm6ujqLBZxZAM6lNNliyNI1Cz5n/qxtjRB8V5jg6+jooKysDID8/Hy7PmU5OsKn1+spLy+nr69vXuVkpuvj+ImT/PL3fyRpeSaxKWlWnRsYGk5gaDhLV+dP+Ltep+X5n/8XSpULwWGRXGxuJC1r9axM5G3B7n+8QP7WG23uOWsymTi17xPaGurw9PEjakkSNz/8NauX1aai6NB+klasxG2aDdVKFxWrNmzm9Od7yN5ou0LUC8Gpz/cQuSSJjML1lB0/xIabbkM7MkJjVTnnis+gUavxCQhgaW4BqgWuQSiTycjbup3jn3xkUxeOmbjQ3EBtSRFp2bn4B40XwTKZjKTlmVw43wQyOXXlJSQuy7Cq3diUNM7u38v//PwX/N//+P5V5VM71gIuLi4Oo9HIwMAAPT09tLW1UV1djZubm0X8+fv7W5UQtxiWdEWE7yrE0Uu69urLZDJRU1NDW1sbiYmJnDt3ziGevY7y0h0YGLA4ghQWFtp0Q7C5Fl9VdTXfePzfSVmZQ87mbTZp+91n/4RWrebB//gJnj6+dF28wMEP36G3s4OMNetIXJZpk36mo7a0GBdXV+KsELDWMDw4wKEP30E7MoKXrx+pq1aTe+31NpskDTod9eUlbP/yV2Y8NjYljbqyYgb7ehc8k3WuVJ05BZJkcbMwGgyYTCZc3d1JzfqnO0TvpU4qTx5neHAAvU5LfGo6sSmTRwztjae3DzHJqTRUlpGQvtyufel0Oo5/uougsAjyt94w5fcsNDqWxuoKkjKyuNR2nsrTJ0jPzp2xfZlMxrL8Ql58+RUK8/NZmZnh1GLFnkvOCoXCIuwAiwVcT08PjY2NlJeXj0sAmcoCbjEs6arV6qsqQxeE4EOhUGAwGBzWlz0E3/DwMCUlJQAUFBQgl8uprq62+9KEo7J0NRoNJ06cICEhgYSEBLvsRWxra+P+r36d6+57mPqK0imX3mbDW398iuW5hei1WsuyZlB4BDc88Ohohvjh/Xz00rNIksTm2780bTRrrmjUas4e3Mstj35zXu20NtRxat8nqFzd8A8OofD6m+1SqgTg3Wf/yIYdd1p9/Pqbb+e95/5klQ+xs3GhuYGLzQ0UXneT5bXMNRs4ue8T8jZfN+5Y/+AQ/INH9/aZjMbRz2TvHkbUw8iVclbkrsHHgY4pSStWcuD9nUQlJNmtlmHF6eP0d3eRtWajVXUvl+bkUXHqOCkrs3FxdaP06KEJbh2T4ermTvLKbL7+2Lf44J2dTh3hc+Ry6eUWcFqt1rL/z2wBZ04AGWsBtxiWdM1JG1cTV73gc2SEz5xMYUsuXLhARUUFUVFRpKSkjPPRtfdTlr2zjg0GAy0tLWi1WrKzs+2WTa1Wq3nose+SnlvI0OAAqy+baOfCzj//nvScPHwDg4hPXTbh73K5nKx1m8hat4mBnm4OfvA2XRfbSM3KmdEcfja8/Zffc9ND/zLrCcxkMlF85ABNVeV4ePsQHpfAjQ9+1e6WZpWnThC9JAVPb+sTMZQuLuRs2sqJz3aTa6PIrCMY7Oul+ODnbLrtnnGv+weHYtTrp10WkysUxCSlEPPFXjWNWk1DRSmVp0+gUQ8TEBJG+up8u9dCy9+6nQPv7bS5C0dfdxclRw6QkL6c5BXWO8F4+wXgolJh0OkICAlF5epmyX6eSYCEREXT3X6Rex/6Ck/+4mfzvQS7sZBJJa6urhYLOEmSGBkZsQjAsRZwOp0OjUbj1PshRYTvKsSRe/iUSiVardYmbRmNRqqqqujo6CAjI8OSgg9YRJ7RaLSr4LNn1vHg4CDFxcXI5XLc3NzsJvY0Gg2/fPrPBIZHcvNXvs6rv/2V1XZXU7Hzz79jWe4aUldm88qTP+f2r3172uN9AgK54YFHkSSJytPHee+5P6HX6dh69/3zWqbc9fLfKbjuBqsdQTRqNYc+fIfhwQG8fH1Jysgiy0a1B63BYDBQfuIINz741VmfG5OUQl1ZMf3dXXZzJ7ElOp2OvTtfZcudX570/c0o3MCpfXusFrBuHh6k54xakkmSRE9nO6VHDzEyNIRer2XJsgyil9jWhxlA5epGatZqKk4dZ+kX/c8Hk8nEic924+bhQd61189YtmcyluUWcnLvJyzLLcDL15f0nHxKDh9gad7M+x9TVq7izIG9/PQXv2TXe+/O8Srsi7Psj5PJZHh4eODh4WGxgBsaGqK3t5eenh5qa2tpaGiwRP8CAgKcKqI2MjJyVblsgBB8Do/w2UIgDQ4OUlJSgouLCwUFBRN+RNPVlrMl9lrSbW1tpaqqiri4OAIDAyktLbV5HzD6/mzZcTtu3j586bvfY/+7b5KzaX71xXb+6bcsL1hHSuYqYHQitjYqJpPJWJqTz9KcfNRDgxzf8xEXWxoJi4olb8v2WQmvilPH8A8OJjJ+eleQjrbzHP/kQxRKF3wDAsm5Zgv+waFW92NL3n/2T6y/+fY5n7/+ptt499k/Ov3Srslk4sPn/sTmO++bMrklICQUg143p8ldJpNZEolgdE/g+boaTu79BI16GIXChYw16/CaY/b05UQnJtHWUMtQfx9e8yjm3VRdyfm6c18Itbm34+rmjn9IKEMD/Xj5+OLm7sGKwnWUHT1IYsZKvHymbluuUJCSuYqaotP85Kc/5Sf/+Z9zHoe9cNakEplMhre3N97e3jQ2NrJy5crRKga9vZNawAUEBCxocWYh+K5CFtMePkmSaG1tpbq6mri4OJYsWTLpZCCTyRxS5NnWgs9oNFJZWUlnZycrV64kKCiI/v5+uwnXh7/xLQLCI9l42914fOF6sWHHHXNu780/Pknmmo0kZ4wuQZUeOzyr5aixeHh5s+nWuwForK5gzxsvMdzfz9obbyV4jO3YZAwN9FNTdHrKSFn5yaOcKz6Du5c3oVGxXHfvw/PyBbYFdeUlBEdGz2tfoEKpJO/a6zm+5yPyJvHadRZ2vfwshTfcgqv79MtJGQXrOPXZbnInsV2bDQqlkrjUpcSlLgVGa9jVlZfQ19mB3qAnJCKStKzV8yqxknPNFva99Rpr5uDCoVGrOb7nIyLiE8mb57WaSctazZGP32d5XiEASqULGWs2UnHyKBFxCQSETu2y4hMQSFBEFB99uo/szJXccINzfZecJcI3HWZrNQ8PD/z8/CZYwLW0tIyzgAsICMDPz8+hdmwjIyMOM11wFq56wadUKu3uFmFmPoLPYDBQXl5OT0+PRQxNx0IWRZ4LQ0NDFBcX4+LiQmFhoaX2k72u4x9vvEmPRs/S1XnEJqdy+MN3WLVh7tG9N59+ksy1/xR7AKVHD3D3t78377HGpy4lPnUpOq2Wk599zLHdH+Ll58+Gm2+f9Mb/1p+e4s5v/qvl3zqdhiMfvU9/dxcePj4sWbaCW776LaeZNEwmE6f37eGmh74277YiExKpLSui91LHgkUqp2PvzldZtroQv8DgGY8NCA1Hb5h+L99c8PDyZkXeGmD0IbLrYhtFRw4w2NsDyEjOzCIiLmFWbSoUSjLXbeTswb1krbvG6vOKDh9Apx1h9ebrcLFhtEehUBCVkEhn23lCIkcLMcvlcpblFnKu5CwjajWR8VNfY1xqOiVHDvL/nvotmZkZREVNXVjb0Ti74JMkCUmSJmwnms4Crra2Fo1Gg7e3t6UEjK+vr12vc2RkxG41ap2Vq17wKRQKNBqNw/qai+Dr7++npKQEd3d3CgsLcXWdeYnQEXsTbbWHz5x4EhMTQ1JS0rgf+UxeunOhpaWFtz7Zh5ePL7lfJGicr6+jYI4bz998+kmy1m8icfk/CzObTCa8/QJsesNSubpaIigXW5rY9/Zr9Hd3kbNpq2Xz/gfP/4XNd3yJwb4+9r/3JkqlCx7ePmSu2UBwxPSRwYXiw+f/wtobbrHZMtXaG27l3b897XRLu8c/3UVYTDzhsfFWn5NRuJ7T+z9l9aatdhmTTCYjOCKK4IhRQWPQ62muqeTEpx+jUQ+jcvMgo3AtHl7eM7YVHB5Ja30tnRdaCYmYXiB1Xmil6vQJUjJXERgWYZNruZz4tGUc+mCnRfDB6PWmZK6iqaqChspyEtInJlSZj0tdlUPVqZN86aGvsO/jjxwafZoOZxd85nlnpjFOZQHX09PDhQsXLBZwZgFoaws4IfiuQpy5Dt9YV4nZliRx1JLufPowGo1UV1fT3t4+IfFkbB+2FHwmk4l//6//h1ar5d5/+yEARz5+n6z1c7OyeuMPv2bVhi0kLh9f5HXfzlfJWrdx3uOdivCYOG566GsYDQbOHPiMD1/8K60N9Rh0WrQaNWGx8Vx/38M2L7Rsa87Xn8PbP4CAkKmX2GaLQqEgf9sNHP34fQrGlDtZSCpOH0ehUFpdDNhMYGg4Oo3GYZO80sWFJcsyWPLFOIcH+i11DrUjakLj4knNzJ5yLJmF69n71qsEhUVMeozBYODEp7vwDQiatqaeLZDJZCRnZtNSU0XMZTUo49KWcqGpgeqzZ0jNWjXp+W7uHoTHxdHf3c3tX7qXd9943W5jnQ3OLvjM9+vZjnEqC7ienh6am5sBLPv/5msBJ0kSGo1G7OG72nBWpw2dTkd5eTkDAwNzcpVwhG+vWYzNJfXeXDtQJpNNmngytg+w3U3u29//IUNaLXd+83HLhvmWc9Xkb71h1m299rv/ZfU1Wy2T41jaW5ote/DsiUKpZPU121APDXK+toagsHAS0lewosB2pV3syeEP3uWmh+e/lHs5EbEJ1JUU0d3RTuA0+7UcQVtDHZ3nW+bsSpFRsI4z+z8jZ5Pj3UQ8fXzJKFwPjE6SHedbOHtgH+qhISTJQNqq3AkRtNzN2zi5dzd5147fj3eu+AyXLraxPG+Nwx5EwmLiaKyumPT+ERGXgMrNjfLjR1mWVzDl+d0d7ahR8L0f/JBf/uz/OWLY07IYvH5h9oJvLJdbwJlMJoaGhiZYwI11AJmNBZzJZEKj0Vx1ET7n/dY4CKVS6XRJG729vRw9ehQYLaQ8FwsxR0X4YPQGNBva29s5duwY/v7+5ObmTpuqb8uM42dffJn6totsuuVO/L4o3XFs94esnINR/Wu/+xWrN2+bVOxp1EMEhYfPe7zW8s7fnsY3MIiI+CXc92//Fzd3D3Y+8zuG+vocNoa5sOvl5yi47ka7TV5rtu/g6K737NK2tQz09lBy9OCcHijMBIZFoB0ZsfsD3EzIZDLCYmJZfc1WNtx8G2uuv4XBnh6O7/mYA++9xcnPdqNRq/H2DyA8Np7mc9XAaBLRgfd3onL3YPU12xwedU7PzuNc8ZlJ/xYUFkFsShrFh/ZP+f6mZmVzqfU8Z6tree2NN+04Uutw9gifueiyLaO3crncYv+2cuVK1q5dS3p6Oq6urrS1tXHs2DGOHz9OTU0NnZ2dM+7LN5lM6HQ6fHysr/d5JXDVR/gcXZZlur4kSaKhoYGGhgaSkpKIjY2d84/GURE+sP4GNNb+bdmyZYSFzRx5sZXgq62t5c2PdrMsbw2JX1hYATTVVM46C/LVp35J3tbtU1pKffjC3yYU07UHJpOJV578GWtv2EFcSjoXGuoAWFGwltRVOex+5e/IlEquveNeu49ltnS2tuDiohoXHbI1coWCdTffzqGP3mXtHLJH54tOo2Hf269NWWtvNqwoWMuZA3vJ2Ti/skG2xEWlIikji6QvEpUG+nqoKT7DUH8fWs0IPR0XudBUj8rVjdzN183bX3mu+AYE4qJyxaDTTeph7RMQSOqq1RQd2k9G/poJxygUShKWLudCYz1PP/t3srNWkpg4fbkje+KsZVnMOEKQKhQKAgICCAgYzeo3GAyWBBBrLOCMRqOI8F2NOHoPn3kJ9HK0Wi2nT5+mra2N1atXExcXN68ftSMifGMLPM+EWq3mxIkT9Pb2UlBQYJXYg7lHEcdiMBh4/Mc/JSgikjXb/5mYceKzj8lcs2FWbb361C/I33bDtP6hI0ODlgiivRgeGOCFX/yEG+5/hLiUdDrONxMQ8s+oosrVjZse/jrZ667h7b/8gfpy+9QynCt7Xn95zkucsyE8Jg4PLy8uXWize19jMZlMfPD3Z9h06902ETpB4ZFo1cMLHuWbDh+/AFau2cDa7Tu45pa7cHX3oL2lGa1GgyQt7LiX5xVSVXRqyr+7e3qRUbCO0mOH0AwPTfi7X1Awbh4e+ASF8ODXvuGwRL/JcHaf2oUYn1KpJDg4mOTkZHJzcyksLCQ6Ohq9Xk91dTUHDx7k7Nmz7Nq1i7179zI8PIxWq5214Hv66aeJi4vDzc2N3NxcTp48OeWxzz//PDKZbNx/ly87S5LEj370I8LDw3F3d2fz5s3U1tbO6T2whqte8Dl6D585ZX0sXV1dHDlyBJVKRUFBAb6+8y+I6ogIn1mQztRPZ2cnx44dw8fHh9zc3FnZ2Vjbx3R849+/j1EmY8cj3xj3en15KSkrs61u5x9P/pyCbTcRnzZ5Zh9A18U2Iu3gaDCW1oZa3v3bH7j3X3+Af/BookvRof0kLJ04rvC4BO759v9hqL+Pt//ye7QjI3YdmzXsee0l8rdun5OLwlwovO5mTn/+qUP6MrPr5WdZe9PtuLrZrr7hivx1nD24z2bt2ZPP3voHeVuuJ2pJIstyCyg/eZTjn+5CM6JekPG4urnjHxzC8ODAlMe4qFRkrt1E9dnT9HV1Tfh7fPpyLjY3EpqQzO33fMmew50WZ4/wOYOPrtkCLi0tjYKCAnJzcwkNDeX48eM88MADpKen09PTw/vvv09paalV88vrr7/O448/zo9//GPOnj1LRkYGW7dupbOzc8pzfHx8uHjxouU/c/KJmV/+8pf87ne/45lnnuHEiRN4enqydetWuz1QXPWCz9ERPvhnRMxkMnHu3DmKiopITk5mxYoVNkv9d0SEz1zgeaofi3kJt6SkhLS0NJYuXTrrJ7+Z+piJP/3tWeqaWrjta99B6fLPpZpTe/eQUbjO6nZe+fXPKLx+B3FpS6c97pNXXyB/y9z3a81E0aHPKTqwj3u++/1xhvXd7RfxC5qY5Qz/3Eh/yyPfZP87b3Dow3fsNr6Z6L3UgWZkmIi4JQ7rUy6Xs/aGHRz84G2H9PfZW/9gee5afANsW9Q1KCKSkeEhp47yAXz+7hssXZ1PQHAoCenLOV93jpVrN7Fq/WZqS85y7JOPGB6YWnjZi/RVeTTMEOlWKBRkrt3IhYY6Os6Pn5xlMhmpWdk0VZUj9w7g24//mz2HOyXOvofP2cZntoCLjIzkiSeeoLm5mZdffhlJkjhz5oxlxenuu+/mr3/9K21tk68G/OY3v+HRRx/loYceIj09nWeeeQYPDw+ee+65afs2ew+HhYURGvrP2qCSJPHUU0/xn//5n9x8882sWLGCF198kQsXLvDuu+/a+m0AhOBzeIQPRgXfyMgIp06dorOzk7y8PKKiomz61OaICB9MXTZFo9Fw8uRJLl26RH5+PhERc6+1NVfBV1FZyatvv8+Wu788IVOztqyItFW5VrXzyq//H2tvvJW41PQZj1UoFHZzrdjz5ssMD/Rz40NfnXBDdXF1nfH74+7pxc1f+TqJyzLZ+cxvudBYb5dxTsdHL/yNTbfYP3v5ckIio/H29aP9sknc1hz/ZBeR8YmExcTapf0V+WspOuS8Ub6DH75D4rIMS12/8Nh4+rpGIyAqNzdWFKxj9eZtNNVUcOTj9+npbHfY2BQKBZEJiVxqa532OJlMxtLcAob6+2iuqRr3N3dPL0Iioxga6KO6pZVnn3/ejiOeHGcTVJfj7EvOCoWCjIwMjEYjL7zwAj09Pbz99tukpaXx0ksv8emnE1cDdDodZ86cYfPmzZbX5HI5mzdv5tixY1P2NTQ0RGxsLNHR0dx8881UVFRY/tbY2Eh7e/u4Nn19fcnNzZ22zfngvN8aB2EWRo4QR+ZoVWdnJ0ePHsXT05P8/Hy8vWcuajpbHCVkJxOWly5d4siRI5brm+/G2LkIPp1Ox2Pf/yGZ6zaSmpUz7m9nDuxleb51ZUte/vX/sO6m24i9rI7XZNQUn2HJmOLLtuTNPz1JVNyScXsQx6Kyohi3mfi0pdzzne/TWl/Le88947As9QPv7yRr/eYF27yfv+1Gig9+brffevmJo7ioVNPu75wvwRFRqIcm7jFzBo7u/pDoxGTCYuLGvR4UHslAb4/l30oXF5blFlKw7UYuXWzj8K73aG9ucsgYE9KX09l23qpjE5evRKF0oba4aNzrEfFLGB7oxzcohBdef4uysjJ7DHVKnF3wOcOS7kwMDg4C4OXlhUqlYs2aNfz4xz/m4MGDPPjggxOO7+rqwmg0jovQAYSGhtLePvlDS0pKCs899xzvvfceL7/8MiaTiYKCAlpbRx84zOfNps354tyfigMwL6E6QhyZJ5qamhrS0tJYtmyZ3Z6EHGGtZu7H/N5JkkRtbS3FxcWkpqayfPlym1zfXK7lK499h8CIaDbecueEv1WfPcXSnLwZ23jpVz9l/c13EJM8s9gDOLX3E1bOMglkJgx6PS/+8gkKr7uR9CnGbDAYcJvFvkgYfU/X3Xgr2+55gN2v/N3ue9yG+vro775E/AxL4vZELpez9qZbOPj+Tpu3fb6uhu6Oiyz7wrvVnizPW8PZA84V5Tu59xNCIiOJSpiYvZqWlUPlqeMTXpcrFKSuzGHN9h2MaIY58vH7NFRXTDjOlshkMhKXZ9BSXTXzwUB0YjK+wcFUnBwfcUlbtZq60mKiklL5+r/+G2q14/YmLoY6fM48PsDyedmz8HJ+fj73338/mZmZrF+/nrfffpvg4GD+/Oc/263PmXDuT8UBOErwqdVqjh8/jiRJLFu2bF5LnNbgqAifWYxptVpOnTpFe3s7eXl5REbazsZrtoLvqaf/RNulLu785uMTljnPHvrcYqg+HS/96qdsvPUuYpJSrerTZDLh6e1t00SE/p4uXvnN/3DLVx+bds/bueLTRCXMLVHENyCQ27/2HQLDInjrT7+lp8M+T5bv/u1pNtw8UXw7muDwKPyDQ7nQ3GizNvu7u6g4ecxi02dvQiKjGR5y/B64qTh78HO8/fyJTZl8y4PSxQV3T88pf8MymYyEtOWs2b4DNzd3Tnz2MdXTZNTOl7DoONRq6/dChkbFELUkiZLDBy3nKJRKYlPSaK6pJDI5nVvutH8ZJjPOLqicfUkXRpdaFQqFVTalAEFBQSgUCjo6Osa93tHRYXXFCRcXF1auXEld3Wj5LPN582lztjjvt8ZBmJdZ7SmOLl68yNGjRy3VwFU2NAmfCkckbZj76e/v58iRI7i6utpliXo2gu9sURGvvfMedz/27+OSGsxUnT7BstzpBd+Lv3yCjbfdQ3RiitVjPLb7A5bnW58EMhONVeV8/MrfuffxH+DtN33h7cpTJ4i2UphORVpWDnd/+9+pOHWMXa88Z9Po8LE9H7GiYC0uDvjeW0PeluspPXLAJteo02jY/96brL/pdodmTi7LLXSKjN2y40dQuaomWAteTmpWDhUnjs7YXmRCInlbthMYHsnJfZ9QcuyQXVYq0rPzOFcyeTHmyfALCiEpI4viw/sxfbEFIjAsHJlMxsjwEG7BoTzyta/bfJyT4eyCbzEs6Q4NDeHm5mb1b1alUrFq1Sr27t1rec1kMrF3717y8/OtasNoNFJWVkb4F0X54+PjCQsLG9fmwMAAJ06csLrN2eLcn4qDsFc0zGg0Ul5eTmVlJcuXLyctLc1hWcGOSNqQJAmdTkd9fT1JSUk2zTIei7WCT6PR8PXH/w/Xf/lhQqJjJvy9+MgBlq2e3ELJzAu/eIJr7riP6FmWVmmuqZrSiH22nPh0F9VFp7jrsX8bl1k8FXqtFncbLE0olS5ce8e9rNt+K+8/9wwVp+a/cVg9NERb/TmSVmTNuy1bIZPJWH/zHRx47615tWMymfjo5WfZdMvdDisxYyY0KobhgX6H9nk51UWnMBp0VpU28g8OQTMybHXbIRFR5G6+jriUdM4e3MuZ/Z9hMtpur6lvQCAuLqPFmK3F08eHZbmFFB85iO6LshnJmatorq7Ew8ub8939/P4Pf7TZGKfC2QWfs48PRq093d3dZ/WQ9vjjj/PXv/6VF154gaqqKr7+9a8zPDzMQw89BMD999/PD37wA8vxTzzxBHv27KGhoYGzZ89y33330dzczCOPPAKM3oe++93v8tOf/pT333+fsrIy7r//fiIiItixY4dNr9eMc38qDsIe9mpDQ0McO3aMoaEhCgoKLBszHbnUas9+zFlLer2ehIQEoqOj7RbhkMlkVgm+O7/8IBlrN7FiioSM8hNHp91j9cIv/ovNd9436T6k6dBpNPgFBc/qnKnY9fKzIJNx3ZcetPr9dHG1beQsKDyCu7/178hl8lGLtnkIi3f+8ns2336fDUdnGwJDwwgMi6CtsW7Obex66VnWbt8xaSTZESzLW8PZg58vSN/15SUM9fWxdIYHqLGEx8bTeWH6DNnL8QsKJmfTVlKzcyk+cpATn32MTmubGmXLcwupLjo9q3Nc3dzJXLOBqjMnGezrQyaTkZ6TR83ZUwRFRPLWrt0cPz5xv6ItcfY6fIthSdcs+GbDXXfdxf/+7//yox/9iMzMTIqLi9m9e7dlbm9paeHixYuW43t7e3n00UdJS0vj+uuvZ2BggKNHj5Ke/s+tD9/73vf41re+xVe/+lVycnIYGhpi9+7ds/IFng1XvbUa2FaESZJEW1sbVVVVxMbGkpiYOO5pZyGzZ21Fb28vxcXF+Pn54efnZ/U+iLliTYTvv3/5K4wqN66798FJ/1567DBLc/KmvFE+//OfsOXuB4iMn319uE9ef3He+7dMJhOv/+F/yd6wmaQVs8v0Vbna5+awcu1G0nPy+PSNV5DL5Wy6bXblVE5/vof0nHy7lamZL7mbt/Hu354mPDZh1hGJT998mRWF6/D2C7DT6GYmNCqG8uOHHd5vS20NnRdayd6weeaDx5C4PJP977xByBclW2aDl48vqzZsRjuipuLkUTRqNRmFG/CYRwUAV3d3/IKCGR4cwNPbek9VhVLJioJ1VJ46Tmh0NEHhkQRFRNLe0kxkYjL/9p8/4qO33sDPz2/OY5sOZ4+gGY1Gpxd8arV6Vku6Zh577DEee+yxSf+2f//+cf9+8sknefLJJ6dtTyaT8cQTT/DEE0/MahxzxXm/NQ7EViLMYDBQWlrKuXPnWLlyJcnJyRN+mIs5widJEo2NjZw+fZqEhAQyMzNRKpUO8eydzlrt6PET7Pp0H/f9+/+d8gdceuwQKwom32P3/M9/wtY5ij0A9cAAQWFzT8LRaTS8+KsnuOa2u2ct9oYHBvCaYY/ffHB1c+eG+x8ho3A9b//5dzRUlVt1nk6noeVcDamzcDJxNOal3c/feX1W5x3d/QHRiamERk7cNuBoluYWUHR4v8P6a29pormmctZiD0Z/x15+/hj01i+jXo6ruwdZ6zeTc802GipLOfThO/R3d8+5vfTsmYsxT4ZcLmfp6nz6LnXRWldLdGIyA73dGPV6olOWcts999ntvujsgs/ZxwejEb7ZOD5dKTj3p+IgbLGvrr+/n6NHj6LT6SgsLCQoaHIvVUclU9g6wqfT6Th79izNzc3k5OQQGxs7bxcMa5muj6GhIR77t//Dvf/2Q9w9J3/aLz95lPTs3EnF4N9/9mO23fMgEXMUe31dlwiOjJ7TuQBdFy/w6u9+wZ3ffJyQObRTfHg/cVNkR9qSyPgl3POd79N/6RLv/OUPlj1MU/He355h/U23231c8yUgJJSw6FhaamusOr702CHc3D2IT1248jJjCYuOY6iv1yF9dbVfoPL0cXKvnXs0Oz07l5Ijh+Y9FheViuV5ayjcvoMLzfUc+fj9WS8Xw5hizHPwWpbJZCRlrMQkmWioKCN91WrOlZxFoVTiExHFA488Ous2Z8JszenMgmoxLOmq1epZL+leCTjvt8aBzCfqJkkSzc3NnDx5ksjISLKzs6dd4nRU0oYthWVfXx9Hj45m2BUWFo5bqnCEgJ1O8N1wx51c/+WvTLvvrvjwATIK1094/bn/+f+4/t6HCY9LmPPY9rz2Iquv2Tqnc6vPnGT/u69z3+M/xMNrbpnNzeeqCIuNm9O5s0Umk5G/dTs3f+Xr7N35Gkc+fn/S48pOHCU2JQ0POxQUtwfZG7dQdfr4jA8uzeeq6e+6NKt9a44gPSefYjtH+fq7uyg5coA11988r/1jXr5+wNTR+tmiUChIz86j8LqbGOzr5ejuD2ips068m0lIX07nPBxYYpPT8PT2obasmJgvSrV4eHlzaVjLz371qzm3Oxnm76gzC77FkKWrVqvtWoPPWXHuT8VBzFWE6XQ6ioqKaGxsJDs7myVLlsx4M1xMET5JkmhqauLUqVPExsaSlZWFi4uLzfuZiakE3+P/8UOi0zLI3rRlynOrzpwkNStnwufy3P/8iO33P0pYbPz8xqZQzEmsHfxgJ21Nddz+9e/Oy3lCLpOjVLrMfKAN8fDy5pZHvkF8ylLe+tNvaW/5Z007g8FA9ekTLJ+h9I0zIZPJ2HTLXezb+dqUx/Rc6qT6zAlyrtnmwJFZR3hs/DgnC1szPDDAyb27R8WeDSby6KRkzlsZUbUWmVxO4rIMCq67CRkyju35iLrSoplPZPTzX7I80+pizJMRFhtPaHQsF5pG7QqHBvoJDAvn488P8vzzz9Pe3o5Wq51z+2bMW1ucWVAthiXdkZERsaR7taJQKGadpdvb28vRo0eRJImCggL8/a3bR+VIj9v5CEu9Xk9xcbFFzMbHx08qZhdqSXfPZ3spq2vglke/Oe25pz//jJVrN457bVTsPTLBAmq2NFVXEmulC8dY3n/uGXz8A7jmtvkXa1Ut4LJEwtLlfOk736O+vIz3v7Boe//ZP7L+Zudfyr0c36BgIuKX0FRdOeFvGo2awx++zToH19qbDUtXF1By7KDN29Wo1Rz+6B3W3nCLzUrPxCanzSs7ejpkMhkxyakUbLsR74BATnz2MeUnjs54jwqPiUOtHpzXvSwwNJyE1GWoBwdprq7AZDIRnZTKn55/kf+fvbMOb+s+2/8tZrDMzOyYIXaYqZA2xRXWlNau3dp10G3v223vOurWFde1K66UNmkaZkbbccyOmZllWxbD0e8PR6ody7bgSFZ+9ee6em2RzznfI1s65z4P3E9FRQUuX76MK1euoLGxEUNDQ3Y5Q9wMEb6bJaX7fYzwLXTpwrYIn6lxweQ9Z6plsxYajQatDd5P9uKIsJTJZCgvLweXy8WSJUtmNYqej5Tu6Ogofv+3v+PHf3l91ptQfVkx4tIzzX8fo9GIT/78O9zyyJPwDXZ8uP2lI/twz49fsHp7giCw442/Ycnm20irAWPNkyWICSqNhjXb7sPo8CA+/L/fQK/T4ezenWBxuOAKhBCIPSCSeEHs6QWBxNMpPo1kkbFiDfZ/9C6ComLM50kQBI598QnW3vWAW99k/UPDUV00t7GxLWi1apzdtwsrbttG6vxjCoUCsbcP1EqlzSMBbcEvJAx+IWGQ9vei+OxJ0JkMpC5ZOePfMSEzFzXFhdNmb9uCwEOChKzFqLh8AQ1lxYjLyEZEUir+8Je/4dyJYxgbG4NUKkVjYyPUajVEIhE8PDwgkUggEAjm/IyZroPu+uAB3BwpXZVK5bQuanfGfa++LoRGo1kVbtdoNKisrIRSqUR2djZEIpFda7myhs9oNFp9cTAajejs7ER9fT0iIiIQERFhVYpap9ORccqzrjFZ8N1+3wO459lfzDmB4urpE7j/Zy8CmLhQ/vevf8Atj/wIvhZMme2BJxCCzrAunaqUj2PX26/itseegsSHnLE5ve2t8HSgO5gsCILA6d1fI235amjVamSt2QCNSgW1Ug6lXA7luAxdLY2QlRQBIGDQG0AYDCAIAwgDMfE5JQwwEAQIAwGjceL7weULwBOIIJRIIJJ4QeTlBZ5A5LSbCYVCwao778Wpb77Exvt/CAA49NkHWHbLnWA42XqIDBKzclFRcAEpJEx8Mej1OP3NV1h+651OmZCSmLkYBScOI9sFKXKJrz9y1vljfESK0gunQRgMSF++epqpuUjiCQaTCb1WC7oD75nN5SFj5VoUnz2BvvY2+IWGwT86DrffdTeOHTwAHx8fABOiQyqVYmRkBJ2dnQAAsVgMiUQCiURi0RjYlC51Z8F3s6R0yRz/ebOwIPgwEeGba/j18PAwKisr4eHhgby8vGm1bNbiSh8+AFYLPr1ej+rqakilUqSnp8PT09PqdVwR4TOt8cSzP0XWhlsQPsdUi8aKUkSnpptNmz/5y+9x2/an4BNkf0ftZK6eOYGEzMVWbdvT1oIze77G/c+/SKonXdnFc8hYsYa049nDyOAADv73fay75wF4BwRh/8fvgUKhgM3lgs3lQuzlY9dxDQY91Eol1AoFlPJxKGRjGOzpgkqpAKGfEIsGgx5apRKG6zcYo5EAQRhBEAYYDQRoDAa4AgH4QjGEnhNRRrGn96x/A5HEE2Gx8WiuqURzVSXSlq2+3mjg/viHRZAyHYUgCJzY9QWWbL7daabSLA4HDKZrRbTAQ4Ks1RuglMtRVXgZapUSactWgc35Lsq4KGcprpw+ZtW87ZmQ9veiq7kRHJ4AHQ11GOzrRmB4FMAV4qc/ewFvvf4aAIDD4SAwMBCBgYEwGo0YHx+HVCrF4OAgmpqawGAwzOLPw8MDTCbT7U2XgZvDh0+lUoHvgIfjzcqC4MPsKV2CINDc3Iy2tjbExcUhKCjIoS+cqwWfNeH18fFxlJeXg8ViIS8vzyYjZVfV8Ol0OuzeuxdjBAVbtmydc5/Ck0fxg5/9ekLs/fX3uP2xp+AdQI7YA4CG8mLc99NfzbldRf4FtNVX4wfPv0j6U+/IYB9pEz7s4crp4+hra8E9z75gbhwhawoCjUYHTyAETyCEJ/ztOoZep4VKoYBKIYdiXAZpfy86Gmqh02hgMExEGQ3mSKMBBr0eWo0aVCoNDZUl8AkMtbt7er6Iz1qM8ssXkLrEvigfQRA4ufNzLF6/mZRxfbMRmbgIDRWliElx7dg9Lp+P9BVroNWoUVtSBPmIFItyl0Eg9gCLw4FIIrHJjHmopxvdrU2gUKhgMBjge0gQnZIGOp2BrpYmDHR1QiUfx/iIFI0VpYiJisSzz0ytPaZQKBAKhRAKhQgLC4PBYMDo6ChGRkbQ3t6O6upq8Pl8c92ZO4uqmyHCp1arFwTf95WZmjbUajUqKiqg1WqxePFiCEiwmXBlSheYuDDMFo3s6upCbW0twsLCEBUVZbOYdZXgG5ZK8e5nO/D0n/455/ZNVRWITkmbqNn76+9x+6NPw9sOd/+Z0Ov1EEq85vxdnf72KzBZLNy+/SnS1p4Mg8mal6d9giCw5z9vITwhGVsefnzKz2g0GjRqFVjs+fe4ojOYEIiZc6b+b+TioT2ISkyFxNcPbbXXIBuRQqNSwaDXIzgqBtGLUkF101rEwLBIXCu8bPf+p3fvQMaqdeALbS9XsRW/kDDUll51+jozwWSxkZK3HAa9HnWlVzEy2I+49GwkZS/BpaP7LY5oJAgCQz1d6GlrBZVKBYPJgMBDgtjUDIt1jgGh4WitqUJkUgp8AoKg1+nw7ocfTxN8N0Kj0eDp6WnOtGi1WoyMjKCvrw8GgwEXL16cVv/nLpE/dxd8RqMRarWalPv5zYZ7XrVcjKUI38DAAKqqquDj44OMjAzSis1dZctiqvOYSYwZDAbU1NRgYGAAaWlpMxpFW7OOKwTfS395Bdt/9xerauYKjh/Gfc/9Ep/85ffY+sQzDk3BsMTpXV/OOWng2/+8hbi0TCRm55K69mScNVJtNob7e3Hk84+w/r6H4ek7PfKWumwVWmuuOVT4Pp8UHD8EFpeHjT/4IQ5++gHW3/uQ+WcGvR69HW0ovXgWaqUcGpUKDBYL8ZmL4e3vPvVASdl5qCq8hEWLl9q03+lvv0Zy7jKIJNaVc5CBl38gxkdHbBblZEKj05GYnQuCINBUVY660iKwuTwM9XRD4ueP/s529LW1gsagg8FkQeTlifj0TKu6lqk0Grz8g9BaU4XY1AzQGQwERcXi17/9X/ztL3+y+hyZTCZ8fX3BYDCgUCiQmpoKqVQKqVSKjo4OADCnfk31f/OFu3fpGgwGaDSahQjf95XJgo8gCDQ0NKCzsxOJiYkICCBXLLjKlgWYWVzK5XKUl5eDwWBgyZIlDg1qdoWA/eX//g5bHnkKHlbUgzVXVyEiKRn//csfsPXJH5Mu9gBgZGhgxi5fvV6PHa/9Bavvun9WM2hH0ev1YHNdaytQePwwBnq7cc8zP5+xazMiPgmHHOx0nC+KTh8HAKRcj+xwbrgh0Oh0BEVETfm7qhRytNfVoLmqHBqVChqNGt5+AYjPXOzUDtTZCIyIQk1xoU37nNu/G3HpmZD4ktNQZC3x6Vm4cHAvFq/f7NJ1LUGlUhGTko7o5DQ0VpahIv8C/IND4eHri4TsHFCp9okY74AAdDTUY3R4CGJPL4gknjh57iz+ZsexjEYjaDQauFwuuFwugoKCQBCEuf6vv78fDQ0NYLFYU+r/7K05t+f83D3CZzAYFiJ832dMaValUomKigqzt54zfHpcldI1rXWjuOzp6UF1dTVCQkIQHR3t8BfT2QL2vfc/gF9CCmLTrZvJevnIfmhUStzx5LNO6WCVy2QWI1sAIBuRYs/7b+HOJ56F0MlRkrqSqwiKjHbqGiYIgsA3/34DMSnp2PzA9jm31yhVLjgrcim7eAYalXLK1BSfwGAM9/fO+PcGAA6Pj7iMbPO/jUYjpP29qCstgmJ8DBq1GkbCgIjEZITGJLjsRhifmYNrhZeRZEXzwcXDexGRkGTXaD9HoTMY4PB4biUSFLIx9LQ1IzA8Akq53OGHRk+/AHQ2N6Kvow1iz4lMiqd/EF5780288NxzNh3L0u+JSqVCJBJBJBIhPDwcer3eXP/X2tqKa9euQSAQmAWgSOS8TvebwSfQFOFb8OH7nkKn06HVapGfn4+AgADExcU57QPrSsE3OfpmMBhQV1eHvr4+pKSkmK0ByFjDWYKvtbUVJ4pK8dAvX7Jq+5aaa+hpa8bjL/0Vnk6KVBzf8THW3fPQtNdba6tx5eRhPPCzX7uk+7Cu5ArW3Tv9PMhmoKsTx7/+DBt/8Ag8vK37zOi0Gre6gc/FtaJ8SPv7sPSGZqCEjByc2PkF1txlvUE2hUKBp1/AlIcNnVaL7pZGFJ89AbVSCa1GDS6Pj8TsPIg87SulmIugiGjUXJ07yldw4jACwyPh7+DEGUeITctEdVGBQ52xZDHU24PakivIWbsRnU0NGJNK0XStElFJyXYfk0KhgMsXQCCWoLu1CYHhURB7+eCLr3aSIvhuhE6nw8vLy1ymo9FoMDIyAqlUiurqauj1erP9i4eHB/h8Pmn1f6Z7gbundBeaNr7HUCgU6PV6pKWlwdfX16lrzUeET6FQoKKiAhQKBXl5eaTWdzhL8BkMBjz2059h61PPo6G8BLIRKeSjY1AqxqCSy6FRq0ClUkGl0EGhUaHVqNFYWYqwuCSnXmwIAzHNpqPo9DEM9/Xg3p/8wmWF01qN1uldlJeO7sfY4BDuffbnNk1ZCI2NR39n+7yKCGtprCxFT0uTxekgTDbbap/F2WAwmQiLS0TYJLNt+dgo2uqqUVNcCI1KBZ1OC/+QcMSlZTrkATeZhMwcXCvKR9IMs3+Lz52El68/gqNiSVnPXiQ+vlAr5fN6DgDQ2dyI7pZGZK+ZGNXoHxKGvvY28IQi9Ha0wd+ByTwBYZHobWuZsBW6Lto8/ALw2Rdf4OEHH7T6OPbYsrBYLPj5+cHPzw9GoxFKpdJc/9faOtF8Mrn+z5ESH9O9zZ0f9kwRvu/jaLUFwQeYJ0mQFfWaDRqN5rI6BxqNhuHhYXR2diIwMBCxsbGkr+msGr7f/fGPiEhOx0BnB3giEXyDQhEexwebywObywOTzZ5y4bt87CAoRuDOH/0ExWdPYqC7Exq1Gks23YoQO8afWaKntRmBEVPTqIc//wiefn7YZEWqk0yYbOdFEfV6PXa/+wYSMhdj8Vrba6syVqzBuf273V7wtdRcQ2NFKdbc9YMZtxF6ejplIgRfJEbSpHnDBGHAQFcnKgouQiUfh0atBpVGRVxaJvxDI+xaIygyBjXFVyz+rPzSOXD5QoTFkzPxxVH8QsIw0NMFHxK76W2hoaIEyvFxpC1dYX6NyWYDlIkHmJriQogknnbb9AjEYrSpVQiJjkNLTRWiklLg6euP199+x2bB58g1nEKhgMfjgcfjITg4GARBQCaTQSqVore3F/X19eBwOGYB6OHhYVPDokmQukvHsCUWmja+55giQq7oLrLFH88RCIKAWq1Ge3s7kpOT4efnnBSns2r4qhpb8MTLr1m1LUEQqC8rhl9wGPgiMVZuvRvARGqx/NI5lF86h/GxUSRm5SF10gXdVs7t34VtP/ouBfPl639D5qo1iE21rr6QTMg0cJ5MX0cbTu7egc0PPGp3tyaTxYZSPk7ymZFLV0sTaosLZhV7AJCUnYvC40ew7NY7nXo+VCrNPArMhEalQkdjHa6cPDLREKJWQeTphaTsPHCt9IiLz8jGteICJGV+1y1eVZQPKo2G6ORUkt+F/UQnp+H07q9cLviMRiMq8i+Aw+UiPmN6o5GpEz4uPRsVl84jKXux3ZY8psk8dAbTbF0k9vHDocOHccuWLVYdg+xAAZVKhVgsNo8Z0+v1GBkZwcjICJqbm6FSqabU/wmFwlnXd/cOXWAixa3X6xcE3/cV0xOMK8wsrfXHcwSVSoXy8nIYDAZERkY6TewBzkvpinysN9vd8fpfEZ+RPc0olcFkIWv1BmSt3gCCIFBXUoT9H74DuWwM/qERWH77XTY9vbI5PDCYLGjVanz11itYf+9D8xLFko+Ngi8Uk37c8we+hVI+jnuf+bnDNxWtyn0bN/o6O1By5jg2/OCROSMRQg9P6LRzj110BiwOB9HJaYhOTgMwIU7GhofQXF2JkYF+6PU66LVahMUnISox2aIQCY6KRW1JEXD9maSuvAQ6jRqLcua/Xm4yVCoVQg8J9DrttJFnzoIwGFB0+hgCI6NmFJocPh9arQZMJgsJWYtx7WohknNts7sxERgZhcbKMoTHJ6GhvARxaVnw8g/E717+87wJvhuh0+nw9vaGt/eEobtarTaPf6uqqgJBEFPGv3G53CnfoZthju74+MTD6ELTxvcU0wdUr9eb07vOXGs2fzxHMfkH+vn5gcFgOL0d3xmC79DhI0iyYHpqicHebgg9vdDZ1IBbbjABngyVSkVC1mIkZE2MQ+tsbsTRLz7C2NAguAIR1t//Q/CFM0dNKgsuITo5HSOD/Tj43/dx11PPgzfL9s6k/PJ5UlNxer0eu975J1JylyM2jZxoJYfPnxCmbjaWbLivF5cP7cHmhx+3Ou3EE4rcogmFQqFA7OWN1KUrza8Z9Hr0trWg5PxpqJRyaNRqsNgcJGbnmruL49KzUV1cCA6XD9nwENKWrbS8wDyTmJ2LskvnXTIuUKfRoODEYSRlLwZvFpNp/9BwtNXWICJxEVgcDsITklBXVoK4tAyb12SxJ2bj0mh0iL18IB0cgMTbB3wPT5y/cAErls89HcXVn0M2m42AgAAEBATAaDRCLpdjZGQEw8PDaG5uBp1On1L/5w7fk7lQKBQAFgTf9xYKhTLreDWycUbjBkEQaGxsREdHB5KSkuDv72+O8jmTiRmm5NYkfvbNHjzwP3+2att9H7yDR//nZex8+1Wb6muCI6MRfN3WZGRwAMWnj2F4oA8GnR4r7rgbvjdYVJSeP43sNetx9MtP8MDPfj2jD50r6GioQ8Zycm6KXS2NOLdvNzY/+CiEHhJSjgkAi9dtRkNF6RRxMt+MDQ/h1Ddf4rbtP7LpsxqblomqgktIsXNcmTOh0ekIiopBUFSM+TWlfBxttdfQUF4CtVIJnVaNnvZWhETHImfNxnk829nhi8SA0fkepYqxMVw9dwJZK9fO2SAj9JgYs2ZC7OkNhWwMXc2NdtkiCT08oRiXwS8kDPWlVyHx9oFvcCh++evfoij/0pz7z6egolAoEAgEEAgECAkJAUEQGBsbg1QqNU9sYrPZ0Ov1GBoaglgsJm1gAZnI5XIwmUy3Tz07A/f7a8wTru6eJXMttVqN8vJy6PV65ObmmmsTXDEFY3L9I1kXIgOdadWxLh87iMUbbwGdwXCops3D2wdr756o5VIrlSi9cBqFRw9AIR9H+op1iElJMw9Ev/+5X817QTKVRiNFcJ7Z8zX0Wh3ueeYF0m8i3gFBuHLqKKnHdAT52CiOfPExbn/0KZs6joGJhgKTKfPNAJcvQELWdzV70v5+HPr0P1DJ5bh4aB94QiGS85a75c04OCoWnU0NCJ4kYMlkwnalEDlrN1r1madQKGBxpnatBoZHoaG8BGPSIYgkttnqBIRF4NrVAsSmZMAvLAKdzY0IjowGSyBCcXExMjNnj7AbjUa3iaBRqVRzY0dkZCR0Oh3a2trQ19eHxsZGqNXqaePf3OHc5XI52Dc0/X1fcL9v/Dxxswq+oaEhVFRUwMfHBwkJCVOeWlzxnkxfYLKEZVlZOeIzcubcjiAINFaUYvtv/g8AwOKQ00XJ5nKRt/FWABPpsuqifPz5iQfBFfCQuWqdW1wkHB2pptdqsfOd15C+fLW5PswZaNykjk+tlOPgf9/Hbdt/ZJdQplAo85a+dxS1UolLR/Zi21M/xdm9u7By610YGRxAxeXzUIzLwBMIkbJkhduIv9DYeJzds9Mpgq+zqR7drc1TzLWtgcXiTHugjU5JR2X+BfDShTbVHNLodDCv+3SKPb0w2NUBgiDgFxqOF178DS6cPjnr/u6cMmUwGBAIBJDJZMjIyIBKpTLX/3V2dgLAlPo/DoczL9dThUIxr6Pn5hP3+Ja7ATdbStdoNKKpqQltbW1ISEhAYOD0WZ6uGHtGtuD7aMfXWP3oT+bcbufbr+K2R58CAAx0d8LLz/omD2uh0emgM5ngi8W476e/QNmlc2ivq8GK27chPD6J9PWsheWA4Guvr8WlI/ux5eHHwZ+ldokMDAY9DHr9vKa/tWo19n7wb9zyw8cd8tQLjoxFe0MtQkmy+HEFBEHg+Ff/xbp7HgCDyTIbgnt4+5hFz+jQICoun4N8bAw8gRCpS1aQ5gNoDxQKBWJvH9KtcBorSjE+NjLFdsVavAICMNjdOWWcIoVCQWJ2LqoKLiE5z7p6YxOevn4Y6uuBl18AgqPj0HytEtHJqdBTaKiuqUFiQsKM+7p7F+zk8+NwOAgMDERgYCCMRqN5/Nvg4CCamprAYDCmjH9zdv28CaVSOW9ic75ZEHzXodFo0Ov1LlnLUSGm0WhQUVEBjUaDxYsXzzgTkEajQafT2b2ONZg8l8gQfKOjo5AqNWDM8cUf6O4EXyQ2F6UXnT6OxWs3Obz+jchGpKjIv4DYtAzwBEKsvet+EASBq2eOo+jUMYTFJSFnnWtrorpbm+Btp3XFyW92AADueeYFl1zs4tOz0dFUh/C4+RHHeq0We95/C1seetThqGhUcioOffrBTSX4jnz+IZbfcqdZ6Ak9JGY7EBNiL29kX6/rGx0eQnn+eSjGxsARCJC+dNW8iL/ErFwUHD+M7LWOf7eMRiMq8y+AzeUi8XrDlq14BwShtbZm2vxsOoOJ6OQ0VF8ttOnY3oHBqMy/BC+/ALC5XDA5bKiVSgSGR+KFX72I44cOzrivO0f4gJm7dCkUCoRCIYRCIcLCwmAwGMz1f+3t7aiurgafzzeLP7FY7DRhaxJ830cWBN91XBnhc2St4eFhVFRUwNPTE+np6bOmYlwR4SNjHaPRiM7OTly+fBk+IXPbnBz4+D1s/+0fzf8e7usmfeg7QRDY9e/X8PAv/xcHP3nfnLahUqnIWbsJOWs3oeZqIXa/+wZ4QjE23P+wSy7EFRfPI3P1epv20arV+ObfryNrzQZEJCxy0plNJzE7D8e/+nReBJ9er8c3772Bjff/kJR0P41GI9182Zmc3PUF0petBv+6vxow0XxSfvH8jA8pYk8v5Fx/cJKNSFFZeBFjUim4fAHSlq92WQSGxeGQIjQJgwFXzxxHQHgkfALt9/ej0emgMSxfZ/liD3gHBKGtttrqznkKhQI2l2sWb8FRsWgoL0ZcWhZkSg1aW1sRHm75Oujugs/a86PRaOboHgBotVrz+Le6ujrodLpp9X9kPaQqFIrv5ZQNYEHwmZmvGbfWYjQa0dLSgpaWFsTFxSEoKGjOL4CzTJHJXMdgMKC6uhrDw8MoqqhC7v0zW6sAQP6xg8has2FKeo7F4ZEesfrqzb9j66NPT/juaTQW04Emm5fejjYc+Pg96LQa3Lr9SbA5zmv3HxkasGn+avO1Slw5fRS3bv+R3VMC7IVKpUKtUrp0TWDiprP73dex/t6HSH3P3gGBGB0ehNjTm7RjOoP8owcQFpsA7xtEjkDsYfXfQ+ghQdbqibSvbESK6qJ8yEdHwGSxkbZijdPFX1RSMhory+yuMdVpNCg8eQSJmTngiRwvXZitjMI/NBxN1yow3NcLTytLS/xCQtHd0oTgqBjQaDR4+PhhuL8XgZHReO7nv8SBPbst7ufugs9eL1smkwlfX1/4+vrCaDROqf/r6OgAgCn2L45E6JRK5YLg+74zHzNurUWr1aKyshJKpRI5OTkQWllA7soInz2CT6FQoKysDAwGA7m5ufjq2JlZb9B6vR5NVRX44Yu/m/I6h0uuwDq58wukLl0BT/8AAIBapZi1/ss/JAzbnvop5GOjOLd3N6T9fVh/30Pwur4/mVCu+zhaw/GvPwODycLdT/9s3upVtGrXmhabxN6aO+8jvUYxMSsXJ7/5Cmu23UfqccmkMv8CuAIBwuIs14Fx+XybRYPQQ4LMlWsBAOOjI6gpysf46AiYbA7Slq6cGEFGMn4hYROG0bBd8ClkYyg+ewKZVtiuWAtfLIZyXDbjhJPIxGRUFV4CTywGmz23GBF5eqG9sc78b9+gENSVFcPT1x/9I2Po6elBQMD064e7Cz4yzo9CoYDL5YLL5SIoKAgEQZjr//r7+9HQ0AAWizWl/s8Wv9kFwbeA2zZtjIyMoLy8HGKxGLm5uTZ9sF0V4bNH8PX396OqqgpBQUGIiYmBUqkEc44b9J7/vIVbH3liymsqhYLUDsr68mKARjUbNAMAlUK1ysqDLxJjy8OPQafV4NKRA+hsrEPWqvWISbXdpHUm2FakJ9VqJXa/8wYWb9iCsNiZC8BdgaefH6QD/ZD4+LpkvT3/eRvLb90GoZ1j4WaDxeGCSnXfQu/2+lqMj0hnrX0Li01AY2U5YlPT7VpDIPZAxnXxJx8bRU3JFYyPSMFgsZG+bBWp4s/LPxDjoyMQiD2s3me4vxfVVwuQbaXtirUEhEXgWlEh4mYwJjc1cVRcOo9FuUutWpvLF0Cv14NOp4NCoSAgLAIdjXUIiozGT3/+C+z+ase0fb4Pgu9GqFQqRCIRRCIRwsPDodfrMTo6ipGREbS2tuLatWtTxr+JRKJZz0GlUi0Ivu877mbLYjQa0dbWhqamJsTExCAkJMTmKI07RvhMBtGdnZ1ISkoyj3176733kLlq5tq0ga4O8IQiSHynpkxKL5xBZGKK/Sc/ifHRERSfPYn7n39xyuu2RNWAiZFuq7beDaPRiNLzp7Hz7VcRFBmNJZtvd+j89Hr9nDNU6ytKUHr+DLY+/mOwSY582kPO2k0oPnfS3BjgTPa8/zZyN2yGh7eP09YQSrygVaudEtVyhJHBAdSVXsGqO+6ddbuA8EhcK8q3W/BNhi8Sm6diyMfGUFtahPERKWgMJtKWrwSb7dhNNT4jGxcOfovF62+xavuulkZ0NTUgx0bbFWvg8PgwzNEAR6PREZeRg+qiQixanDfnMQPDo9BSU4XIxGQAgEjiiYGuDlCMRnT19WNoaAheXlPLN9zJh88SBoMBLBbLqWvQ6XR4eXmZfzcajcZc/1ddXQ29Xm+2f/Hw8ACfz59y/VYqld/LKRsA4L6fHBdDp9Nd1qU7l+DTarUoLS1Fe3s7srKyEBoaaldKzpU1fNYIS41Gg6tXr2JwcBC5ublTZvy29UvNXbeWOPrlJ9j0wPZprzdWlNjleH8jBEFg1zv/xF0/fn7a79redCiFQkHGyrX4wc9+jcDIKHz73ls49N8P7P6c1ZZcmdWf7PDnH6GrsQF3PfWcW4g9YCIiND464vR19n/0LjJXroWX/3R7IjJJys7F1bOze6W5Go1ahUuH92Ll1nvm/KxONAyQ/9ngi0RIX74aK26/C6lLV6C+tBgXD+1DwfHDUCvtq+OkMxhg8/hWXcMaK8sw2N3l1LFx1oh8Lp+PoMhoNFVVzLkth8eDkZh63QyJjkNTdSUCIqLx7PMvTNvn+xjhmwsWiwU/Pz8kJCRgyZIlyMrKgqenJ0ZGRlBaWopLly4hPz8fb7/9Npqbm6FSqWwWfO+88w7CwsLAZrORk5ODoqKiGbf94IMPsGzZMrMp9dq1a6dt/8gjj5gdLkz/bdzo/IfihQjfdVyd0tVqtRZ/Njo6ivLycggEAixZssShWbjuFOEzpaYlEgkyMjKmdBfr9Xow+DOncy8fO4j0lWst+rlRKBSH/NVM7Hz7H7hl+48ctu+YicjEFEQmpmCopwtHPv8IaoUcWx5+wqZ0dE3xFWy6/5Fpr6uVSnz99j+w/LZtCImKJfGsycHZBswH//s+FuUumWab4QzEXt5QK8advo61EASBYzv+i7V33W/1jdY7IAjD/b2zPmA5Al84If4AQDk+jvryYowODYJGZyB9+WpwbLjZxqVlobqoAIsWL7H4c6PRiKqCi2Bx2EjIzCbl/GeCzeVa5Svp5R8A+dgo+jrb4BccNuu2PJEYKqXCXIfM4nDA5vGg02jQ090DmUw2pWZ7QfDNDoVCAY/HA4/HQ3BwMAiCgEwmQ1FREXbs2IGXXnoJbDYb0dHR2L9/P1auXAnRHE09O3fuxAsvvID33nsPOTk5eOONN7BhwwbU19fDx2d6NuHcuXO4//77kZeXBzabjVdeeQXr169HdXX1FL/cjRs34pNPPjH/29mRUWAhwmdmvlO6phTu1atXERoaivT0dIfE3kzrOIPZBJ/pfRUXFyMyMhLJycnTrGQ++3IHEhcvtbi/Xq9HR0MdknMtm5uyHEwbAcCp3V8hKWcJfGbwt6NQyPuaeAUE4Y4nnsHtj/8Yl4/uxxev/RU9ba1W7WvQ6adZg9QUX8GBT/6Du5/+mVuKPWDic6hRO0f0HfnyE8SmZSIwPMopx7cETyhySeTcGo5+8TGW3bLVpgeV6ORUVF/Jd+JZfQdXIEDaslVYdcc9yFq9Do1VZTh/4FtcPnoQKoV8zv0lPr5QKy1vRxgMKDp1FB4+PgiLs84SxRF8g0PR1dpk1bZhcQkYHRyCUj77ewyOjEFHfe3U16ImTL4DwiPxkxuifARBuLVhsLsZQ1OpVIjFYqxfvx4FBQVoaWlBWFgYmEwmXnzxRXh6eiIvLw+/+93vZozavfbaa3jiiSewfft2JCQk4L333gOXy8XHH39scfsvv/wSP/7xj5Gamoq4uDh8+OGHIAgCp0+fnrKdKTJp+s/Dw/paVXtZEHzXcWWE78bIm06nQ3l5OVpbW5GZmYnw8HBSvtTz3bSh1+tRXl6OtrY2ZGVlzViHWFhVPWOq8tv33sTGHzxi8WcEQdgULbBEY2UZDHodkmaIIAD2p3Rng8sXYNMD2/HAz36Nttpr2PH631BVOPtNmMWe+gR46NMPIB3ow51PPuvQLGFnk7psFVprrpF+3BO7vkB4XAJCY+JIP/ZsRCenoba40KVrWuL0NzuQunQFBCLbbhQMJsvmecJkwOHxkbZ0JVbfeS+yVq9HY1U5Lh7ai8tHD8wqjHyDQjDU2zPlNZ1Wi8tHDyAyKQU+gcHOPnUAgMTHB2NDg1ZvH5+Zg8bKMhCz3FfoDMa0DAWVSoWnXwCkgwNoaG2DclJKfL4jaHMxk/GyuyCRSMDj8XDPPfegrq4Ora2teOKJJ9DU1ITPP/982vZarRYlJSVYu3at+TUqlYq1a9eioKDAqjWVSiV0Op3Zc9DEuXPn4OPjg9jYWDz99NMYHh527M1Zgfv+ZVyMq1O6JoEkk8lQUFAAg8GAJUuWkKryXZXStRRJHB8fR0FBAfR6PfLy8iCeZAA7bX+e5ZB6X0c7JD6+M3Z4NlWVI8SByQdKuQxXTh3DunsfnHU7Zz5R0xkMLLv1Djz4i/8BhQrseud1nN33jcVtmdftHpTjMnz2jz9hUe4yLF632WnnRhYR8Uno72wj9Zhn9+6Ef2i4S42kTQRGRKHbykiPs8g/dhAhMbF2ix2BWAKtWk3yWVkPh8dD2tKVWLn1bmSv2YDmaxW4eGgfLh3eD+W4bMq2MSnpqC/7LvqikI0h/+h+pC5bAcEs1xWyoVCoNkVSqVQqErNyca1o9gc5ia8fRoYGprzmExiMkYF++ISE4fmf/8L8ursLvpvh/NRqtbmGLzg4GNu3b8eOHTvw9ttvT9t+aGgIBoMBvr5T70G+vr7o6+uzas0XX3wRAQEBU0Tjxo0b8dlnn+H06dN45ZVXcP78eWzatMnp9+uFGr7ruHK0mmmtjo4O1NfXIyIiAhEREaQLi/mK8PX09KC6uhphYWGIioqa9X0dO34CEUmpFn92fOdneOjn/zPjvhWXz1ts5LAGgiCw482/48EXfmtFobtdS9gEhUJBSt5ypOQtR3tDLfa8/y9QqFTc+vDjoDOZkI1IwReJUVFwEQ1lxbjr6eecVm/oDMg0YL5waA88vH0RY6cpr6NQKJQ5u6WdSVXhZXB4fIfSmLGpGSjPP4/s1eR3tNoKm8tD6vUZt2qlAnVlxRgdHAQoFKQtWwm+UAShxBN6vR5jQ4OoKryEnHXk2q5YC8vG7mwWh4PwuCTUl5UgNs2yPZNfcCgqCy7Bw2tqPVhgRBR6WlswyJio+WYymTeFoHKnlO6NGAwGqNXqGceRks3f/vY3fP311zh37hzYkz479933nZfnokWLkJycjMjISJw7dw5r1qxx2vksCL7ruDLCB0yYDjc3NyM9PR2enuR7hgETQsxoNDr9ImESfARBoK6uDr29vUhJSbFY0Hoje0+cxuanpnejXT6yH9lrNs5aIK1Rq8Cz88a761//xJaHH7cqFUpx8QU2NCYeoTHxGBkcwLGvPoV8bBQe3r5ob6hFdHI67njiWZeeDxloNRpSPocFxw+ByxciPsO5BfpzERgehe6WJgRGuK52EAA6muoxNjyIHAfnzAolnlDNUV82H7C5PKQumRB/GpUSdaXFGBkahFatwplvv4LQQ4LcDfMX1RZ7+2BksB8e3tb7Soq9fSAfH0NXc6NFRwEKlQoWhzPt+yEQe6C3ow2+QSH4+a9exNtvvH5T2LK4+/lpNBqrBZ+XlxdoNBr6+/unvN7f3z/FZcISr776Kv72t7/h1KlTSE5OnnXbiIgIeHl5oampyamCz33/Mi7GVQ0O4+PjqK+vB0EQyMvLc5rYA2B+0nJ2lI9KpUKr1eLKlSsYHR1Fbm6uVWIPAChs3rQLhF6vR1dLExIyc2bd194I19l9uxCflQM/a7s6SWzasAUPbx/c/tjT2PbUczh/4FsQBIHe9lYM9nbPy/k4QmhMPPo72hw6RtGZ46BSqViUM7fHmbOJSUlHtYvr+EaHBlFXfAXZJPnMca20PJkvWBwuUpYsx8rbtyEmJR0qpQI6rcZpDUDW4B8Shp62Fpv3C4qIhlqpxJhUavHnvsGh6Otsn/Z6WGw8OprqUFpVDZ1Od1NE+Nz5/EyCj8/nW7U9k8lERkbGlIYLUwNGbm7ujPv9/e9/x8svv4xjx44hM9OyWfdkurq6MDw8DH9/53TOm3Dfv4yLcUWEr6urC4WFhfD09ASdTnd6G7bpi+fs96XRaNDd3Q2BQICcnByrXcwrKirha6G7crZGjcmwrBhhdCPN1ZVQK5Uzdv1agjrPXXFfvfl3bLj/h8hdvwWbHngE7fU1OPLFx/jm3TeQf/yQy0oRHCFjxRo0VpXbvX/ZxbPQadRIXbqStHNyBDqDMSVF42w0ahUuHtqDFbdtI630IyQ2Hs3XKkk5ljORj42isaIMUYkpSMlbjobyUpReOAOCcF1GxgSDxQJg3+8/JjUDbbXXoNdPt+QSe3lDPjLdr5LJYoMrEIEtEOG3L70EAG4tqG6GlK5Go7HJh++FF17ABx98gE8//RS1tbV4+umnoVAosH37RDnRww8/jN/85jfm7V955RW89NJL+PjjjxEWFoa+vj709fVBfj2iLpfL8ctf/hKFhYVoa2vD6dOncfvttyMqKgobNji3xGIhpXsdU72b0WgkvZbOYDCgpqYGAwMDSEtLA4vFmhYidgamC4OznuKNRiNaWlowMDAAsViMpKQkm/b/8MsdWLV9anqyt6MNnn7+EHvNPqB+uK/X5nFdKoUc+ccO4oEXfjP3xm7Cl6//FUs2346QmDgc3/EpYtMyzVMrjEYjelqbcX7/N5DLxqBVqbB0y1b4h4bP81lPh8liQzk+Zte+VUX5kI0Mu12DisTXH7IRKYQekrk3doApXnsk3kyDwqNw4uoXiE5OJe2YZGPQ63HpyAEsv/VOyMdGUVtShJS85VCMy1B+6QJYHA4SJ41BdAVMtn0P6hQKBYtyl6Ey/4K5ZnHyzzh8Hgi9HtQbyliCo2JQW3wFBfIxbFi71q0F382Q0p3ctGEN9957LwYHB/G73/0OfX19SE1NxbFjx8yNHB0dHVPe87vvvgutVou77rprynF+//vf4w9/+ANoNBoqKyvx6aefYnR0FAEBAVi/fj1efvll508pcerRbyJM3nAGg2GaT5wjyOVylJeXg8FgYMmSJWCz2VAoFC5JH1MoFKelqnU6HSorKyGXyxEUFGTXGloaCwzm1A/4iZ2f46Ff/O+c+149exLpy1bZtN6ON/+OHzz/ou2Cfp7mp+59/20sWrwcYXET83DVKsWUn1MoFARGRJnryDQqJaquXEbZpbNQjsvg5R+EvI23uE1zh1atsXmf+rJiDHZ2YMnm25xwRo6RlJOHs3t3zTnOzFGOfvERlm6+nfS/I4VKdZuJLJYwGo24eGgfstdsAJVKhdBDAo1y4jvAEwiRuXItpAN9uHrmBLz9AxEW73wvPtPa9o7XYzCZiElNR/XVwmlCNSA8Em0NdYiIn/rgTKVS4R0YBKVcjq927sKqVbZd91yFK+rFHUWv19sc4QOAZ599Fs8+a7l2+ty5c1P+3dbWNuuxOBwOjh8/btP6ZLEg+K5jCkObhlmTgalbNSQkBNHR0eYvAo1Gc9mXw5Y5t9YyNjaG8vJy8Pl85OXloaurC2NjtkVvent7IfabOgbr4qF9WLxus1UpgcHuTnj5B1i93s5//RObHtg+zbjYGuYjpXvky08QEBmDuPTv6j+0qtltNFgcLjJXrjP/u6+jDZePHoBMKoVep0XGqnUIc8DGxlF4QhEUsjHwhLM725toqalCe30NVtx+19wbzwMcHh9Go9Gpa5ze/RVSl6x0WhTRyz8A0oF+m6PlrqDs4lkEx8SBy/+uwJ59w41a4uOHnLWb0N3ajCsnjyEicRG8A5w7Xi8gLAJNVZWIWmTfDG+BWAKfwGC01dWYH+aACSFJzDCv1ycwGLXFV1DT2Oy2gsr0XXDnlK5CoYDRaFyYpft9h0qlkuZbZzAYUF1djdraWqSkpCA2NnbKl9RVzRSmtciM8HV1daGoqAhBQUHmaSD2iMq3/vMB0lZ8142k1+vR09aMuPQsq/ZnsdlWR+rOH/gWsWkZ8A8Ns+kczbi4aeP8gW/BEwiRdkO9Gp3FtGo6gQm/kDCs2XY/7njiGWx97McYH5Hi6I5PsPu9t3Bq9w5SrVKsIXfDFjRWllq1bWdTA+pKi7D8tm1OPivHEHpIoJthTKKjFJ44jOCoGPgEOc9YODo5DVWFl5x2fHtpqakCQRgRGBYx5XW/4DD0tk+fTBMYHonF6zdDPjqCKyePQiGzr3zAGvgisU3fQ0v4hYTBaASG+6d6ufFE4hmbUoKiYyFXKPCPf77m0NrOwnSfcVdBCsBcR7cg+BYgRRwplUpcuXIFMpkMeXl5FrtVTYJvvsee2YLBYMC1a9fQ0NCA9PR0REZGmgWXPb+3EZVuiqXK7nffwEYbPPVYVkbq2uqqoZTLkLJkxdwbzwDFhSndknOnoJTLkbvhlmk/S1u6Ei01VXYdl8FiISVvObY89DjueeZnSF+xBldOHsWBT/6D3e++4VBDhbV4BwRhuK93zu36OtpQfuksVt95n1uPkQKAhMzFKDl/ivTjVhflg8XmINzJaUomi+12EZnh/l60N9QhKXt6F2RQZDQ6mxos7kehUBCZlILstRvR2diAojMnnCLGKRSKzX58lohMSkZfR9sUA+ygyGi0N9RZ3F4gEoPBYODAkaMOr+0MTPcZdxd8FAoFHDeeTORM3PcvMw842qnb19eH/Px8eHh4ICcnZ8YPFZVKBYVCmbcpGLZiErHj4+MWrWRsFZVKpRIs8XfH6GlrgXdgEMSeXlbtr1GpwOPP7b+nUshx4eBebLj/h1afmyWoLorw1ZUWo6OhDmu23Wfx52HxSehptd0SwhJefgFYdcc92Pr4j3HnUz+FXqfFsa8+xbf/eRvHvvrvtGkHZCEfG53150O9PSg8cRhr737A7cUeAHj6+UM+Or270hE6mxog7e9DkovsZwRiCbRa2+srnYFWrUbxmRPIXb/F4s+pNNqctXM0Gh0JWYuRvnQVaq4WouzSOdKzKSw22+FjUigUJGbloqakyHwsBpM5qwAPi0/C0PAw/vXuuw6t7QwMBgMoFIpbCz6lUgm2Ddmh/99YqOGbhL3TNgiCQH19Pbq7u5GUlDSnIaNprZshwjcwMIDKykoEBAQgLi7O4pfZ1jXefu8/SFv+XTr31Ddf4kErGjVMlF8+h/DEuUdqffXm33H/c79y+MvtiotDV1MDSs+fwrann59xGyqVCo0T0rB0OgOJWblIzJqIqIwMDqDkwhmMDg5ArVQgMSsPCVmzeyJai9FohEGvt2ioPTo0iAsHdmPTA9vd+qZxI1yhkLR63DHpMGquFmDVHfeQcGbWEZOSjopL55G1er3L1rSEkSBw/sC3yNt0+6zbCT0kUCsVczacMNlspC1bBfnYCMoungVfKEJs2tyeaNbgHRSM/s4O+8tErkOj0xGfkY3qokIsWjwh8MVe3pBJpRBKptdtMphMeHj74rMvd+DZp592aG2ycfeGDWAiwsfhcL63gs+9/zouxh4RplKpcOXKFYyMjCAvL88qsWfvWvZg7zpGoxENDQ2oqKhAQkICEhISZvwy2yr4mnsG4Ok3YTB58dBeLF6/xaa0UlNVBYIjY2bdZte/X8OG+x+eVuRtD86+OEgH+nFy15e486nn5lzLFaazHt4+WHHbNtz+2NO46+nnwWCzcPzrz7Dng3/h0GcfQTZi2TzWGhYtXoqOxukpK/nYKE58/Tk2PrCdVOsRVxCZmIz6ihKHj6NVq3HhwLdYeftdLr0hiTy9nBbRtYWCE4eRmL0EDCZz1u0iE1NQW3rV6uPyRR7IWrUeXgFBuHrmBDoa6x09VXj5B2CojxwDdC5fgKDIKDRVVQAA/EPD0NsxcyQ/ODIasnE5Pv38C1LWJ4ubQfApFIrvbToXWIjwTcHWlO7AwACqqqrg5+eHuLg4m0SLKyN8tq6j1WpRUVEBtVqNxYsXzzmGxpY1CIIAnT/RpanTatHb3mpzYT6NRpv1pnDx8D5ELUpFQHikTcedGefdfOUyGXa/+wYe/MX/WHWxZHG4UMhk4AldM8uVRqcjNjUDsakTc0DHR6SoyL8A6UAfVHI5ohalIWXJcqsv9Ek5S3BsxycIn2Q9oZSP4/DnH+GWhx93u3oyawiJjkPF5fOIT7Ou4cgSBEHg6I5PsHYbuV571sLhCZziQWot1UX5EHl6QWLFhB4Onw/CjkyMt38gvP0D0dFYj8KTRxGTkgaJj3UP6DdCo9FJte/y8g+EfGwM/R3t8A0JBZM1syihUKkIDI/CP19/HT986EHSzsFRDAaD239/TYJvIcK3gNUizJTCNUW/EhMTbf6gk9URPBcmQ2lrGR0dRX5+PhgMBnJzc62aOWjLGp99uQNJi5cAAL568xWbGjVMsDgzN2x0NNZjbHgIaTZ69M2Gs5o2tGo1Pv/Hy/jB878Gnc6wap/0FavRXF3hlPOxBoGHBEu3bMVt25/C3c+8AA9vH5zavQN7P3gHBz5+D9LB2Q3FqVQqlJNmuGpUKhz85D1seegx0BnW/Q7cDSqVOsU6xB6OffHJhNeeC6d3TCYkJg4t1fY1BDlKd2szRgYHEZlovc0Jhy+wu1QlJDoWues3Y6R/AFdOHrO745Zpx6Sf2QiLS8DI0CCUcjm8AwPRb2HUmgkv/wAYQMW3e/aQeg6OcDNE+JRK5fc6wufefx0XY02ET61Wo6ioCIODg8jNzbV79p2tQsxerBWWRqMR7e3tuHr1KsLCwpCSkmL1E6wtKd38sioERcWiq6UJ/qEREElsmyVMEATYM1xo1Uolzu7dic0PPWrTMefCGU0bBEHgoz+/hPuff9Gmm3xoTPysNwJXQqVSEZG4CBvv/yG2PfVTrLv3ITRWluHw5x9i59uv4sqpoxY/F+rr5rlarQZ7P/wXNj/42JxpPHfHPzTc4ixUazj97VdYtGSZ0yd2zEZwZDQpqU5bkY+NouZqITJXrZt740kERUajvb7W7nUpFCqiU9KQtWY9mqoqcPXMSej1lj3wZkIgFkNOsv1LfGYOGitKIfH2xejw4Kzbhick4aU//B+p6zvCzSL4rB39+f8jCyndSczVtDE0NISKigr4+PggISHBofC1K2v45hJjer0e1dXVkEqlyMzMhIeHh01r2CL4aHwhKBQKju/4L7b/z8s2rQNM+HPNlKrd8cbfcN9zvyQ/XO+E8P8Hf/wttj31nF2RIVf751kLTyg0d1cajUZ0NNbh1O4d5s7cpZtvh09gMHwDQzDU241T3+zApge2z1tUi0xi07Jw9ItP4HdvqE37FZ48gqCIKPgFhTjpzKxjYuqGa2+Eep0Ol48cwLJb77R5X9/gUNSWXnXYtoZOZyAlbzlUCgWqCi6DRqchKWeJVcIlMDwSFfmXkJBJTkMTMHEtTcjOxbWiArC5vFlFFE8gBFsgxJtvvYVbb7kFEokEQqFw3kTXzZLSXRB8CwCYOcJnNBrR1NSEtrY2JCQkIDDQcSd3d6nhM41+YzKZyMvLs2uWn7VRxFNnziAsMQXn9n+LJVtut+viUH7pHDbc+9C013e/9ybW3fsgODy+zcecCyrJKd1P/vJ7bH7osTnnBc/EXBM33AEKhYLQmHiEXp/soVIqUJl/AUWnj2GotweXjx3E3T/+mctFhrNgMJk2z1itKS4Ek8VCRMLcHeeuwNMvAKNDAxB7zV1H5yhGoxGXDu9D1pqNdgkUCoVC6meHw+MhY8UajEmHUXL+NMSe3nPOGGZzeSCccA1nc7gIi0tEW10NOhvrERo783Sc8PhF+OjTz7F2zRpUVVWBIAh4eHhAIpFAIpG4tF7tZojwqVSqBcG3wAQ0Gg0azVQ/Ko1Gg4qKCmg0GqsaGGxZa767dPv6+lBVVTVt9Js9axiNxjmLvr89chxrtz+La0X5WHXH3XatpVWpwBeJp7x2+dgBhMYmICgy2q5jzgWFSt5T65ev/RXLbtsGXwciOlyBAOOjIxCIbYvEziccLg85azdBr9fj83+8jKDIaPR3tqGxogQatQo6jRZUOg2RiSkIT0gitSDeVXj4+EExLptiKD4TXS1NGO7txuIZ/Obmg5jkNJw/tAcr7Ii42UrpxbMIiYkHl2//A5qHlw9kI1JSU+EiiSdy1mxEf2c7Ck4cQWhMHAJumPYxGTIMmC3h4e0DhWwMLbXXZhV8dAYDAk9vtLS04JZbboFcLodUKsXg4CAaGxvBYrHM4s/DwwMMJ9bJ3iyC7/s6ZQNYEHxToNPpUCq/S5cNDw+joqICnp6eSE9PJ/Um5MoIn/YGt3mCINDQ0ICuri4kJyfD19exOZqmLzlBELNG7YxsHvZ88DY2P/S43Wuxbii47WppwnBfL2595Em7jzkXZD0h737vLaQuXYmQ6FiHjpO5ej2aqspJbUxxBVq1Gl+9+Qq2PvY09n/0LlKXrpzyu9WoVOhpa0bRqSNQK1XQatTQabTw9A9AUtZiCG2s93Q1STl5OLd/N1bfce+s28lGpKi+ctmlXnvWwGSzQXPBDbu5pgogjLMKKWuISFyEKyeOIGPlWpLO7Dt8g0PhExSCtrpqFJ44gviMHIg8p3/+2Dwe9Dod6Q1HY8NDkEmHYdDrUFtSZDbrnygvoUz8j/G66wGTgRd/+z+49dZbIRAIIBAIEBoaCoPBgNHRUUilUrS2tqK6uhoCgcAsAMlO/851/XcHVCoVaUGbm5EFwTcJkwgzGo1oaWlBS0sL4uLiEBQURHpYfL4ifGq1GhUVFdDr9cjNzSXlaccawXftWjVAZ8I3OMzmRo3JTB6pplWrcWrXl3joV9abNtsDGX/7I59/jLC4BESnpDt8rICwCJRdOOPwcVyJRq3C12/+HVsf+zG4AgFCYuMw0N05JdLJ4nAQHp80xbLFaDRC2t+HlpoqyKTDbh0N5AmEMM7xndaq1Ti/7xusv/dBt7SG4AvF0Go1YDJtL+2whqG+XnQ21GPx+s0OH4vJYoNCc55ApVAoCI9PQmhsPOrLS1BXWoTUZSvBmtQ05h8Shq6WJoTNEoWbizHpMLpbGqHVqCfsXhgM8IQihMbEAUYjCBgREDq7OG4sG532Go1Gg6enp3kyklqthlQqhVQqRXd3NwiCMIs/U/rXEQwGg9tH+JRKpdVeuf8/4h5XSjeBTqdDq9WipKQESqUSOTk5EDrJ78xVtiyTGyqkUinKy8vh5eVll5XMbGsAmLVx4/0vvsSgVIaHf/U7u9eRDvTBw/O7+qIv3/gr7nnmBadeZAwGAygOHv/c/t0QeEiQnLuMpLOa6Ei+WVDK5fjm36/hzh/9BOzrljq567bg+M7P50xtUygUePr5m426TViMBmq18PIPRGJmzrxFAwViD+j1Oos2OyavvTXb7nNbc+mY1AxU5l9A5krbumatQaNSoeTsSay4/S7SjsnlC0EQelCpzruVUak0xKdnQ6fVorq4ADq1BmnLV4JKpUHs7Y3aEutNoGUj0glxp1aDRqeDTmeAw+cjJDp2ipA0QRgJqORz28ZYc41is9kICAhAQEAAjEYjxsfHIZVK0d/fj4aGBrDZ7CnpX1sfpG6GlK5arV5I6S4wgdFoxOjoKHx8fJCbm+vUegd7x7jZu05rayuampoQGxuL4OBgUqML1swGrqiswtYnn3NIZJacO4VFi5cCAHb+659Yfdf94FpRL+UIGpXCIcuQq2dPQKfRIO/2W0k8K0Cncf/GDQCQy0ax5z9v464f/XRKNy6dycS4AzNorY4Gaq9HAxNcEw2Mz8xB2cWzyFo1fUzZsR2fYMmm2yze2N0FsZc3FGPkWo0AE2PTLhzcgyWbbiP1uKGxCWisrDAbgzsTBpOJ1LwVUI6Po+zSebDZHCRm54LBsnx9GB8ZQVdzAzRqFahUKugMBvgiMYKjYqz+DBgMetCsuA/pdLZZylAoFAiFQgiFQoSFhUGv15vTv83NzVCpVBAKhWYBKBAI5hRzN0tKl+9A3ejNzoLgmwSLxQKbzUZqaqrT0y2uSukCwPj4OJRKJbKzsyESiZyyxmzWLN3d3fAOCkV0SppDa/R1tGPNtvtRePIogqNiEBLlWC2cNaiVKjDt6FwGgNqSq+htbcXGBx4h96QACCVeGB0atLvT1xXIpMPY//G7uOupn4JhIUVoNILU+id3iAb6BAaj4Pjhaa+f3bsTi3KWOFTO4Cqc0elecOIwknKWgE6y36LExxdVhZdIPeZccAUCZK1cB+lAP4pOn4BCNorxsRF0NTVCo1JORO4YDHD5wglx50CqlNAbwGAw54yeGQiDQxE2Op0OLy8veHl5AZia/u3s7ASAad2/087BYHBqkMRRjEYjNBrNguBbYAIGgwEKheKS2hpXCL7x8XE0NjaCIAgsW7YMTCea284m+H756/+BlsrA3g/fAZVKhaevP+LSs+DpF2DT75rJZqOvow39XR24bbvzmjQmo1EpQbejnqmzsR6VBRew9fFnnHBWQObqdWiqKkOmhUiSOyAd6MfRLz7CXU89N6Ogy16zHs3VFYhNJWeg/UzYEg2k0emISEh2KBp449i7K6eOwT80HH4hYY68DZcRHB2H5uoqRCaSYxdTc7UQIk9veHiTb/dCoVDAmacUncTHF4vXbcLFw/vQWFGKmOR0h8TdjRAEAYIgIPDwwNjw0Ky/PyqVjrq6OiQkJJCytj3pX3dP6RIEAbVavSD4FpjAlVE3Z6/V3d2Nmpoa+Pj4QCaTOVXsAbMLPplSicf/+pY5Ndrf2Y6rZ05guK8HLDYHTA4XHC4PwTGxCItNnPECTmcwcPzrz/DQL53bpDEZjUppcwG7dKAP5/Z/g7uf+bnTHh58AoNRdOqYU47tKIM9XTi160tse+qnoNFmvsREJiajsuCi0wWfJZwZDQyLS0RjZRmik9NQW3IFdDoNkYnJznorpBMSFYMTuz4nRfB1tzZjdHgI6ctXk3BmlvH2D8RQXw+8/AKctsZMjA0Pgc3lQSknSBV7AKBWyMHm8iDy8kFTZemsgo/OYODchQukCb7JWEr/joyMQCqVoqmpCWq1GkKhEHq9HnQ6fV5nMs+GwWCAWq1e6NJdYAI6ne6SujrAeYKPIAjU1tair68PqampoFKpuHbtGunr3MhsTShagphSB+cbHIrND04df6bX61FXcgV7338bWo0aLDYHLA4HYm8fxKRmwssvADVXC/HcP9526VOkWqUEk2W915ZcJsO+D/6N+59/0ennqXHDiRt9HW04v/8b3Pnks1Y1JijH7Ztj6izmjAaOSKEcl0Gn1YDOYCFqUeq0aGBEfBL2ffgOuAIB+jvbSa9bczYUKhV0huNduuOjI6i5Wohlt9xBwlnNTEhMPC4f2T8vgq+6uBCLFi9FbfEV0iNcspERiL18QKPR5mzKoDPoKC4pIW3tWdei0+Ht7Q1v74lyEpVKZbZ+6enpQV9f35TuX7abTNLR6/ULKd35PgF3wjRpwxVPKM4QfCqVCuXl5TAajcjLywOHw8Ho6KhLZvbONsLNmg46Op2OpJwlSMpZMuV1mXQYpRfO4KM/vwSeQIhLh/dj/X0PuUz0aZQqcKy8QGjVaux4/W/4wfMvguYCqxCNWu1WT9OdzQ0oPH4IWx9/xuq/j0DiAfnY6DQzbXditmhgV0sTCk8cglqhhFajhkGng2dgIECloqrgElbfObsnn7viExiEseEhiDy97Npfr9Ph8tGDWO4CE2c6gwE6w/WzmFtrq+ETFAoqlTox27exDuGx5EXYlHIZfEPCAWDO90ehUCEdJb/Zxho4HA4CAwMxMDAAHx8f8Pl8SKVS9Pb2or6+HhwOxyz+xGLxvNkoEQQBjUZz00f42traEB4ePu31FStW4Ny5c7PuuyD4JmHqMHJFtxHZtiyDg4OorKyEn58f4uPjzTfc+bB/uREKw/6PmVDiiZVb70bztUrEpmciLC4R37zzOnRaDe780bPg8p3cpatWQSiZ28mfIAj895X/wz3P/txls2E9ff0xMjgAiY9jxtlk0FJzDeWXzuD2R5+2SYCuvO0uXD19HFlrNjjx7JwDi8NBZOKiKalPo9GI9vpaVFw6D0/fAJz+9mvwBAKkLVsFNvfmsYOISc3AxYN7sfw22wWb0WjExUN7kW3n2DR74ItETvUPvBG9Tovu1iaz+bnI0wtN1ZUkr6E3//44XD7USuWs4+SU8zxy0WAwgE6nQyQSQSQSITw8fEr6t7GxEWq1GiKRaEr3r6seWE0pXUf9Bueb4OBg9Pb2mv/d19eHtWvXYvny5XPuuyD4JmESea4YAj1bRMwWjEYjmpub0draanHOL1nrzMVsgo9mwZPMFs7t24UVW+9C87VKBIRF4L6f/hKKcRkuHNiNge4urLht26zjhxxBo1SCYUX04JO//A53PPEsuHzXPT1mrVmPmqJC5Kzb5LI1LdFQWYraq1dwy8NP2HzxFnpIMDzQ56Qzcz0jgwMou3gWD77wG5zdswur7rwXshEpakuKIBsdgValgl9YOBLTs0F1E8NoS7DYHMBOsVZ64QxCYxMcGptmK+EJi1BXXISkxXkuWa+q8DISshZPeY0vEM7owWgPhknlRRI/P3Q11iN0lgiiYp69OS2ltG9M/yqVSrMAbG9vB5VKndL968z0r8Fg+P8ipUuj0czm0Wq1Glu3bkVubi7+8Ic/zLmv+15x5oHJgs8Vazm6jlarRWVl5awm0SYh5uzU30yCr6+vDwwHfcd62lqwcus9aKwoNb/GEwix6YFHYdDrceXUUVw+vB9hCUnI23iLQ2vdiEatmjOd8tnf/4T19//Q7vSXvUh8/DA6NODSNW+ktvgKWmoqsemBR+z+fOk07pWatpfBnm7kHzuIzQ9tB5VKA/X6FAihhwTpK9YAmHhA6+/swNVzJ6GUy6HX6xCfluW0OdCOwBeKoNdqbbJSab5WCQooDo9NsxWhhwRqlcIla40MDsBAGKZ56QVHx0106zpoP2XCYPhO8LHYHOhmqS+nUKlQqec3wmdNDSOXywWXy0VgYCAIgsD4+DiGh4fR09ODuro68Hi8KelfMgMvGo0GOp3u/yvj5UcffRTj4+M4efKkVdH0BcE3CQqF4lJDZEcE39jYGMrKyiAUCmc1iXZVmnqm93O5oAACB+qz8o8fQvqKiVmZBv3049PodORtvBV5G29FQ0UpvnnnDdCZdNz6wydJ8fzSaTSz+sR99veXsXjDljknRjgLtUo1L+sCQEXBRfS2NmP9vQ85dJyopDT0trUgIDySpDNzPX3trbh67iQ2/uCH5gsvTyQ2dy6aoFAo8AsJhV9IKICJWrf2uhrkHzsElVIBBoOB1KUrIfSYu4zA2cSmpqM8/wIyrZxVO9Tbg86mBlLGptmDM/wDb8RoNKKm+ApSl66Y9jMun09qNoW44Xo6m8cdlUoFjMZpnzdXYmtmjEqlmtO/ERER0Ol05uhffX09NBoNxGKxWQDy+XyHHgoViokHgps9wmfiT3/6E44fP46ioiKr6xIXBN8NmBo3nI0p1WprZMNoNKKrqwt1dXWIjIxEeHj4rPubbj7OTlPPFOG7WlYxzZfMFlprriFvw0TUTq/VzLptTEo6YlLSIR3ow+HPP8b42Ag2P/ioQzVuE92Yli+03/7nbaQsXYmwuES7j+8o2nmKjpWeP43h/j6s2Xafw8fKWLUWR7/85KYVfJ2N9agsvIQN9z085e8Ql5aByssXkL5iZksSOoOByEUpiFyUAgBQKeRoqirHyOAANEolxN4+SM5bCibT9Z2OHt6+Vk9D0ahUKDl3itSxabbiFxqG7rYWBDoxuthcXYmAsOkF8yaEEglUSgU4DtZr6rTaaV3uDBZ7YvKGBasjCoUKFpeNiooKZGQ4f+qIJRztUmYwGPDx8YGPjw+MRqO5+1cqlaKtrQ1UKnVK9y/LRkP88fFxAP9/CL5vv/0Wf/zjH3H06FFERlp/3VwQfDfgKi++yelja5/IDAYDampqMDg4iPT0dPNQbGvWcXYd30yCT6ZSgyER23XMknOnkJL3XSGqysqUjcTHD1sf/zE0ahUuHd6H7pYmpK9YjcSsXJvPQauznNI6/PlHCItNQHxGts3HJBPfoBAM9XbDOyDIZWsWnjoGlXwMK2/fRsrx6HQ65A6MWZtPWuuq0VBeinX3PDBNdHsHBKPwpG1eiRwe3zw+EACk/X2ozL8ExdgotBo1wuKSEJmU7LJmCGtqUgmCwPkD3867/UxgeBQuHNzjNMGn02rR196KtFk8BUOi41BVcNHh64JifAx8sceU1zy8fTDY3WXRwJtCpYDLF+L8xYs3reCbDIVCMad/g4KCQBAEZDIZpFIpuru7UVtba3P6V6GYiKDPVwSULK5du4aHH34YL774IhITE9HXN1EDzWQyIZmjwfDmfudOwF0Fn0KhQHl5OWg0GvLy8qwubjVNDnH2e5pJ8OkIgGNn51xtSREe/Plvzf/Wa7U27c9ic7Bm2/0wGo0ov3QOX7/5D3j4+mHdPQ9YfWHSazTTavjO7fsGIk9vLMpdOsNeriNr7QaUnT/rMsF3+ehBGPQ6LN10O6nHpdLo0Gk0YNg5xm4+aKgoQ0dTHVbdcfeMEVZHm3gkvn6Q+E4UaBMEga6WRlw5dRTq6+mppMVL4O0fONshHCI4MgattdUIj585il14/DAW5S4lfWyarVBpNIsj/Mii6splJObM3hTCYDKtmn07F+NSKTy8phot80VidLc0WtyeAgqYLBbKK8jtFLYFZ5YNUalUiMViiMXiKenf4eFh1NXVQafTQSQSwdPTExKJBDweb9p3UqFQgM1m3/S1wsXFxVAqlfjTn/6EP/3pT+bXF2xZ7MBVKV1bhFh/fz+qqqoQGBiI2NhYm5+iXNGpO5NQHh0bRUiK7ZMUKgsuIjF7akSOSrXvYkKhUJC2bBXSlq1CV3Mj9r7/DnRaNbY+9jTYc9T96HS6KYK8+OxJaNUa5LmJma5QLIFMOuSStS4c3AM6g4FcJ9RoLdl0KxoqS+2Kws4HNSVFGOhsx4o5fOb8Q8PR294K/9CZ04DWQqVSERIVa54hrdWo0VxdiYbyYqgUSnD5AqQuXUlqd2xITBxO7Pp8RsFXfbUAIm+faeJkvhBJJFDK5aR3CA8P9AFGo1Um7BPNVEMQe9nfxKVWq+B1w0M9hUKZsQOYSqeBMBgwJpufxg1TeZKrIs83pn+VSqU5/dva2goajTal81csFkMul7uNCbQjPPLII3jkkUfs2td9B9/NE66K8FEolDk98giCQH19PSorK5GYmDjFX88WXPGeKBSKRVE5NjoKkae3zceruHwBqUtXTnnNmskNcxEUGY27nn4Otz7yI5zZswuf/+PP6Gq2/NQMAEaCMK9bV1qMjsZ6rLzjbofPg0w0LmjcOLPna7A4HGStWueU4wdFRqO3rdUpxyabqoJLGO7rwZLNc4v+mJR0VF8tcMp5MFlsxKdnY+mWO7DungewKHcp6suLcf7gHpzc9SWqruSDcLABjUqlgjHD1I3uliaMDUsRmUDOzF0yiFyUhvryq6Qe02g0oq7kKmLTrHtwDQyPRHdrk0NrGnQ6i6/TZoii0ukMaLVajI3LHFrXXkzX/vmYpUuhUMDj8RAcHIyUlBQsW7YMiYmJYLFY6OjoQEZGBtLS0vDf//4XFAoFahu6md955x2EhYWBzWYjJycHRUVFs27/zTffIC4uDmw2G4sWLcKRI0em/NxoNOJ3v/sd/P39weFwsHbtWjQ2znz/IZsFwXcDrurSNa01U+RNo9GguLgYAwMDyM3Nhb+/v8XtrMEV5suW3gtBEFApFRB6eMywl2Xqy4oRm545LfR+Y9eaI/BFYmx5+HE88MJv0N5Qhy9f+xsKTxyZtp3pHLqaG1Fy7iS2PPw4aedAFlqNxqkR3BM7v4DQwxPp101mnYVa4V5j1ixRdukcxmWjWGyl9yGdwXCZGbDQQ4L05aux8va7sO7eB+ETGIyr50/h3P5vcOqbHehsbrDruN4BgZBJh6e8JhsZQfXVAqQvd+5nwlY4PN4U/zoyaK6uRFBklNXbU2k0sDgzGyRbw0zvQSASY9RCRJ9Go8Og02Fc7hprmhsxXX+c7V9rDSZvv8jISGRnZ+PSpUv4yU9+grGxMUilUnh6emLTpk14/fXXUV1dDaPRaPE4O3fuxAsvvIDf//73KC0tRUpKCjZs2ICBActWWPn5+bj//vvx2GOPoaysDFu3bsXWrVunjDb9+9//jrfeegvvvfcerly5Ah6Phw0bNtgkQh1hQfDdgKtSusDMkbeRkRHk5+eDyWQiNzfX4a4iV6R0LdXwNTQ0gEqlQyC2zWKi8ORRZK1aP+11Z/xdaHQ6lm6+HQ/+/LeQ+Phh1zuvYd+H/54i+of7e3Fy15fY9vTzbln/ERQRiYGuDqcc++iOT+AdGIiUvGVOOf5kPHz9MDo06PR17OXqmePQqdU2RzmFEgm0LvZIM9m/LF63GavuuBert90HnUaLi4f34dQ3X+L8gW8hG5FadazY1EyU5583/1uv0yH/2AEs3eLcGbn2wuELSLveaTUa9He0w8vGOknfoGD0d9r/nZxJ8Im9fSCdNGXBBI3BgF6nhd6CdZUrMF2b3fH66O/vj0cffRRbt25FUlISSkpKsGHDBpw8eRJZWVkIDQ21KLhee+01PPHEE9i+fTsSEhLw3nvvgcvl4uOPP7a4zptvvomNGzfil7/8JeLj4/Hyyy8jPT0d//rXvwBMRPfeeOMN/O///i9uv/12JCcn47PPPkNPTw/27dvnzF+BmYUavhuYT8FnNBrR3t6OxsZGxMTEICQkhJQvkCsifJbWyC+8Ap5ACJYNo2xaa6sRvSjV4vumUqnQ63Sz+uI5QmxaJmLTMjHU24ND//0ACtkolPJx7H3/HTzwwm/mJV1hDRmr1qPo1FGL3XuOcOizDxEaHYu49CxSjzsTK267ExcP70fu+i0uWc8WCk4cBpPFQvJS24VvXEYOSi+cmTd/OmDiwSYyKRmRSckAAJVCgabKUowMDkCtUkLk5Y3UJcst2r+wOBzAOPF9NI1Ny1m72W2/DyFRsWirr0XELI0m1lJVeGnORg1LeAcGo+T8afgG2+7PaSQIzBB0mqjhs3BLoNHp0Ol0oDHoUKvVLq9VM3XouqPgM6FUKsHj8RAfH4/4+Hg8//zz0Gg0qKiomPb70mq1KCkpwW9+8xvza1QqFWvXrkVBgeUSjYKCArzwwgtTXtuwYYNZzLW2tprHoJkQiUTIyclBQUEB7rvPcYuruVgQfDfgqhq+G9fS6/W4du0aRkZGkJmZCQ8b06BzrePqCJ/RaERBSSmEnl42XQQuHtqDB3/+PxZ/JhCLoRiXQSSZ247GEbz8A3DHE89Ao1LhpYfvRGxKBpqqyhGTmuGWFzSeUGi1X5q17PvoXcQkpyI6mZypAdbA5QsxOuh+Eb5LR/aDLxLZ3VDi4eUNhWx+BtvPBIfHw6Lc78TryEAfyi+dh3J8HDqNGmFxiYhMSjGLOv51E+mKS+cQFpcEjhtPK/AJCkFN8RWHBd9Qb8/1zl/bu48pFAo4XJ5dViVqpRKsWX6/lib/TJQi6cDlC1FSUoIlS5bYfM6O4Ir5846iVCrBvWEWMYvFQnb2dAudoaEhGAwG+PpO9XD19fVFXV2dxeP39fVZ3N5km2L639m2cTYLgu8G6HQ6tDbaf9iLSfDJ5XKUlZWBxWIhLy/PZkPJuXB1DZ9Wq0VFRQXUegIMjvXvpaulCWGxCTNeIIWeEzdOZws+E0e//AQ5qzcgIWsxRoeHsOvtVyH09EL2mo3w9LO/ptIZqEmco7nn/beRmLUYEfNQjG/Qa0n183KUcwe+haePr8NRTq7AfvNxV+Dh44ectRN1iQRBoLu5EYUnjkCllAPGiW7dkzu/gG9QCPxDw+b3ZOeAQqGAzXWshs5oNKK+vHha45gtBEZGo72xHuE2zvkeHxuBeJZGNzaXC61aDeakqBSNRgdh0IPD5+P8xYsuF3wGg8FtvrMzYYrwfZ9ZEHw34OqmDalUipqaGoSGhiI6OtopESRXRvhMI99EIhH4Yg+oDDPkJixwevcOPPjCb2f8uZefv8sMejsa60Fn0LHh/odxcucXWH/vg0hbuhJ6rRYndn0BhUwGv9AwZK3ZMG2m5nygVipAGAwOdzLvfvcNpC5dgdAY225SZJGQtRhdTQ0IiYmbl/Unc2bPTviFhJIS5QyOjkF7fQ1CYxNIODPnQqVSERwdi+Do7+xf8o8ehLS/DzQGHSOD/fDwtn96jSuQ+PhBNiK1e0RdY1UZgq7b39iL2NMLzdW2++LJZWPwDQ6b8ecSX3/0tDYjJPq786PSaDDoDWCy2LhWU2PP6TqEOz2kzYRKpZoW4ZsJLy8v0Gg09Pf3T3m9v78ffn5+Fvfx8/ObdXvT//b3909pwuzv70dqaqq1b8Mh3PsvNA+4qoaPIAgoFAr09vYiJSUFMTExTksXuqqGT61Wo6ioCMHBwUhNTQWVwbL6IjDQ3YngqBjQZjGh9vIPxNgN3YLOgCAInPjqU6y750HQ6XQo5d9ZHdCZTGx+8FHc/ePnkZCRg/0f/hv7Pvw3qovyZ+z2cgURi1LR2+6YrcnOt19Fxoo18yb2ACA5d7ldN0myOfnNDgSGR5KW0o5IWITGyjJSjuVqRgYHJqZ8xCdiyebbMNDThcvHDqLw1FGXN6NYS3jCIjRUlNi1r1atxmBPN7xIiOLzBULo9ZYtVmbCoNPPet1kc7nQaqb+3qk0GgiDHhQKBUND1jXjkMnNkNJVqVRWR/iYTCYyMjJw+vRp82sEQeD06dPIzbVc2pGbmztlewA4efKkefvw8HD4+flN2UYmk+HKlSszHpNsFiJ8N+CKGj61Wo3y8nJotVoEBwfDx8e5pqXOjvARBIGenh4olUpkZGTA23siHUFhMECxMlp6bMenuP+5X826jZd/IK4VOcfTbDI7334Vmx981HzRVSsVFufVevr5495nfw4AqMy/iC9f/ys8vHyQvWYDvAODnX6ek8lcsRqXjxxAYIT19hGT+eqNV7Bk822kGAQ7ApVKhXKevMRMHP/6M0QmJZMqfGk0GphuEAm2FWl/H8ounMHKrXejqaoCw329iEvLBNIA5fg4akoKMT4yComvL+IzctwmysNksUCx81wqCy8hiSQD8ODoODRWlCImxfoHB/0MHnyTYdzQuEalUs2NHtJ5GFN4M6R0bRF8APDCCy/ghz/8ITIzM5GdnY033ngDCoUC27dvBwA8/PDDCAwMxF//+lcAwHPPPYcVK1bgn//8J7Zs2YKvv/4axcXFeP/99wFMlBo8//zz+NOf/oTo6GiEh4fjpZdeQkBAALZu3Ur6+7XEguC7AQaD4VTBNzw8jIqKCnh7e4PH47nkqciZIlatVk/U66nV4HA4ZrGn1WpBZ7EBK0yBRwYH4BcSOmdxNIPJtHm8mq3UXC2Ed0AAvAO/G1XmFxqO/s72Wbtgk/OWITlvGfR6PU59swNj0iH4BYcie+1GsB0cpG4NbC4P8rFRm/cjCAJfvfE3rNx6D3wCXTePdzaYbDbUKiXYDnqZ2cORLz5GfEaOTb5r1uLh7QPluMzt6/lMjEmHUXD8ENbcdT8AICw+AecPfAvfoInOU65AgLTr3owDPV0oPncSaoUCMSnppHeM2wNPIIRer7dpdupATxcYDCZpY+K4fL7ND9sGw9wPyXQWa1oalXK9fVejtS2iSAY3Q0pXrVbbZHF27733YnBwEL/73e/Q19eH1NRUHDt2zNx00dHRMeU95+XlYceOHfjf//1f/Pa3v0V0dDT27duHpKQk8za/+tWvoFAo8OSTT2J0dBRLly7FsWPHXNZVvSD4bsBZ4shoNKK1tRXNzc2Ii4tDUFAQ6uvrXZI+nmnOraOMjIygvLwcnp6eiIiIQM2k2pGSkhL4BodAJZ/bTPfQp+/jnuuRsrkgCOfVV+r1ehSeODxlfi8ALNl4Cy4d3m/VTYxOp2Pj/Q8DAEYG+3Hg4/fAYLEQtSgVidl5Tr0o3pjmmQuCIPDp3/6AjQ9sJyV9RRZLt9yB+rISl3j/Tebgpx8gJW+Z06KcCZk5yD9+GMu2bHXK8clEIZPh4sFvsXrb/ebX6HQGGDOM9vIJCIJPwMSQ+7baahQcPwyCMCBt2SqH5wnbS1hcEhqryhCfZl3DjdFIoKGiFGkONGpYQujhAZVSAY6VD34EMfc9wcPTG4O9XfANnGT7cv3SYu8ISkcwGAw3RUrXVk/bZ599Fs8++6zFn1maW3v33Xfj7rtnnsREoVDwxz/+EX/84x9tOg+ycG9JPg84o4ZPp9OhrKwMnZ2dyM7ORnBwMCgUisssYMhex2g0oqOjA8XFxYiIiMCiRYvAYDCmiMorxSXwCQqd0zNvfHQEXv5BVjc+GJxoLLrj9b/gtkefmpa6ZXP5GB8dtfl4Ht6+uPfZn+POJ54Fg8HAzrf/gcOffoi+jjZyTvgGDDqd1VMG9Ho9Pn/1z9jy8ONuJfYAk2ltm0vX3Pfxe0hbutKpKW2+SAydRuO045OFSqHAmT1fY/Ud9057QOEKRLNG2alUKiISFyFv0y3IWrMeLTWVuHxkH8ovnXN4zJutSHx8MT5ifXqzoaIUoTHkN9WExMSjrbbaqm31Op1VtdwCDwnGbzDONkX46EwGZDLXlkW4e4SPIAibI3z/P7IQ4bsBsrt0ZTIZysvLwePxkJubC+akVIGrBB+ZTRsGgwE1NTUYHBxERkYGJBKJeY3Jgq+pvROpiwwQes4+QHz/x+/irqeet3p9Z900ik4dQ2RiyoyWLyoHx37FZ+QgPiMHer0eZ/fsnEiNBQYjZ91mcEi6CEUkJqO7tREh0bPXnun1eux47S+45aHHIHSRxY2taF0wHxiYuBHs/+hd5K7fDE//AKevxxMK3frmqNWocXLnZ1h9532gWkiFRiYuQk1xIZLzls95LBabg0WLlwIARocGUXrpLJTjMoTEJCDMRqsSe+FY2ZWpViox1NeL1MgY0s+BwWRaXU+oGJeBJ5rbg5VCpYJ2Y7T1ulDkCkQoLi7G6tWrbT5Xe3HnzzQwcX4ajQYCwfxEm90F9/0LzRNkRvi6u7tx5coVBAYGIj09fYrYA1zTPQuQ17ShUqlw5coVyOVy5OXlmcUeMP29GKh09Hd3wtN35uiRUj4Osae3TZ5ZBivSHbaiUshRW1qE7DUbZtxGIPIgZewXnU7HunsewH3P/hzpK9bg8GcfYO/7/0L55fMOzwpOXboSDWWzdyZq1Wp8+c8/49ZHnnRbsQcAvsGhGO6fPkKKTAiCwN4P3sGSzbe5ROwBQHh8ktt26+p1Opzc+SVWbr1nxho2Dx9fjElt7wIVe3kja/V6LL9tG+gMOq6cPIKLh/dhbNi5XffeAcEY6umec7uqwktIynGed52nrx9Gh6fPwL0R2YgUHl7WNfHdmD0xBQY5PD7Onj9vYQ/n4e4pXYPBsBDhw4Lgm4ZJHDlisWEwGHDt2jXU1dUhLS0NkZGRFsP0N1OEb2hoCPn5+eZRMDcWmU77vdEZGOzqgNhrZgPR/R/+G6vuvNem8yB7MDoA7Hjtb7jziWdm3WbZrXfgWlE+qeuKJJ64+8c/w51PPgueQICdb7+KQ/99Hz2tzXYdb6LZYebImEatwldvvoKtj/0YfJHYzrN2DctuuQN1JVeddny9Xo+977+NlbfdCQ9v53bJTyY4KgYdDZad+ucTg16Pk7u+QN6mW6YY+lrCkSYkCoWC4KgYLN6wBXkbt6C3oxmXjx7A1dPHnWJ4Hxobj5baa7Nu09/VARaXa1Nzh60ERcagu6Vpzu00KqXVD8A8oWhqo9b1ewyDyURl5ezvmWzcPcKn1+sXInxYSOlOw/SlNxgMdl0AlEolysvLQaFQkJeXB84sc2RdYYjs6DqTm03i4+MRFGS5k9P0ZTfZl1AZDEgH+mY0PtWq1eAIBODZ2LFoTQebLZzduwtpK1bNeRMTe3ljdHCA1LUnE5OcjpjkdBAEgXP7v8HFw/vg7R+InPWbbfodzeSLppTL8dWbr+CeZ342L92vtsJksyEbmTsiYg96vQ77Pvg31tx1n8uFL5VKdbuxZEaCwOlvv0LW6vXg8OaOgHgHBGCotwdeDkZF6Qwm4jNyAEyYDVdfuQz56Ah8gkIRm5bh0LFN0Oj0WSNPRiOBxsoyc7exs6BaactjS42yxMcXzVUV5s+wKahAoVDQ78RrlSXc3YfPlNJdmLSxwBRMH1pb2/kBYHBwEJWVlfD390dcXNycTzzuHuEzzfcdHR1FdnY2RCLRrGsA3z3pURlMjI+NzWhBsfeDf2HTA9ttPieCIM/ceHR4CH3trVi6+Tartne0js8aqFQqVt8xEfWUj43i6JefgEqhIjw+ESlLVsw5SYMwEtDrdFPSPXLZKPa+/y/c9+zP54zeuBOEgSA9VaTVarH/o39j3T0P2PywQRaefgGQSYcglMxe3+oKjEYjzuzZiaScJVaL3/D4Rbh4eC+W+t9O2nnwhSKkr5ioOevvbEfR6WNQKZWIz8iCT4BjnpYCiee0UWQm6spKEO7gzF1r8Q0ORn9nO3yDQ2fcxmCDSTOdwZySiTI1bQCA0sWG2AaDYVrJkjthSul+3wWf+8Zg5wkqlWqzQDIajWhsbER5eTni4+ORkDDzPNjJuLJL19YIn0KhQGFhIbRaLfLy8mYVe6Y1gAnBJ5PJwOLyQQEsprJ1Wi0YLLZdNWRkNm3sevtV3P7YU1ZvT2MwoZSPk7b+XPBFYtz91HPY9qOfQOTpjZ3/ehUHPvkPOpvqZ9wnLi0THY3fpQxl0mHs++Df2Pajn9xUYg8AUpeuQHuddd2N1qBVq7H/o39j4/0Pz5vYA4CEzGyUXjg7b+ubMBqNuHDgW0SnpEHiY/2oNAaTCRrVebEC3+BQ5KzbhGW3bIVseBj5xw4i/+hBqJUKu44XmZiMuvLp5QEqhQIjA30QW1kz5yg+gSEY6p29LtXWDAadOamOb9KlluJia5abJaX7fRd8CxE+C9gixLRaLSoqKqBSqbB48WKbagTcNcI3MDCAyspKBAUFISYmxqovsknYGQwGFBQWwi8sHB0zCJNv/v26XdE9YOLCQsbF5dBnH2D5rXeCwWRZvU/ehi2oLb6CjJVrHVrbHiITFyEycREIgsDFQ3uRf/QgJN6+yN1065TIzKLFS3F691eISFgE6UA/jn75Mbb96Cdz2uO4I/EZOdj74b8RkZjs8LHUSgUOffYhNj3wyLzPPmZzeTBi/sbwmcg/dhCBkdHwsWMqDFcgsCsLYgs0Gg3RKWmITkmDWqlEfVkxxoaHIJJ4ImnxUquvAQKxBzQWalurCi8h0YmNGjdCoVDAvm7EbOncjUajzfcDFocHnVYDBpMFCmWSCfOC4JuCUqkEQRDf+6aNBcFnAWuF2OjoKMrLyyESiZCXl2fzxc/dInxGoxFNTU1oa2tDUlLSlAHPc0GhUMzWLEWl5QhfextYFmrFDAYDjITB7kJ5Lp8PlULuUISmt6MNWpUSkUm2CYnAiCiUnD8994ZOhEqlYsVt2wAAivFxHN3xCYwGAqFxCUhbvgp05kQUcrCnC6e++RLbfvQT0Gg379ecjDS6XDaG4199is0PbrdJ4DsTvlAEQq+3aH3iCopOH4enjx+C7BzFF5GwCLUlRViUk0fymVmGzeUiZcmEFYx0oA/F505CIRtDVFIqgqPmtlK5sTaxr6MNHL7QqYLVEkGR0WhvqEN43HS/P41KafGaORuefv7o7+xAUGT0lJQuncmEVCqd4qTgTNy9S1d+fQDAQoRvgWnM5cVnNBrR2dmJ+vp6REVFISwszCqzzBtxlS2LNevodDpUVlZCoVDYHKmcvA5BEOgbGkay2AMM1vSb64GP38P6ex+2+dgmhJ5eUMpkDgm+/R/+G9t//Xu79lUp7EsrOQOeQIC7fvRTAEB7fS12vf0aeAIBOpoaoByX4c4nnp2z5s/d4fJ4UCnkVjUTWEI2IsWp3Tuw+cFH3SrKGZ2chmtXC5Gcu9Tla5ddOAM2l4swB2rXJL5+KL/kWusP89o+fshZuxFGgkBbfS0Kjh+CwaBHat5K8MVii/sEhEWgu6URgRHRIAgCTdcqnN6oYQmxpxear1VY/Nn42ChENtZ1cnh8qFXKiX9Mugfx+AKcOXMG27Zts+veZCvuHuEzCb7Zmii/DywIPgvM5sVnMBhQXV2NoaGhKcbD9q5jsjJx5pdyrgjf+Pg4ysrKzObQNw7mtnUdgka/Pklk6seLIAjotZopc2ptReLtC/nYiN3H+Oad17DpgR/aLYQIgwFajQZMC2J2PgmNjUdobDwU4+P4y1MPgi8U4vDnH4PD4yEgPAKRiSlg3YQXuxW33YWKgotIX267iax0oB8XDnyLzQ9sB22eImkz4RcShqtnTwJwreCrKrwEwmhEfEq6Q8ehUCg2+Wc6Awp1opkpPD4ROq0G9eWlGBnoA5vDR+qylVOidwHhUTh/4FsERkSjrvQqIkkoE7CXiRm/OtBvME6Wj43a3KBCoVDMDzKTbyFsHh+7dn8LX19fSCQS838sJ1233F3wKRQKsNlstz5HV+BeV0E3YaZUq0KhQFlZGRgMBvLy8hweeGz68NlrAWPLOgaDwaKw7O3txbVr1xAeHj6jX6Ct64A+0a1Fp08VVUc+/wjLbrnD7uMDgJdfAEaG7TNAbq6uBE8oREBYpN3rpy5biabKUiRk5dp9DGdBEAR2vv0qnvrjq2goL0bOus0AgNbaahz76lMQBAE2mwMOn4/49Gz4BIe45OnfETx8fDHY3WXzfkM9Pcg/fhAbH3jELVNNFArF5TNm60qvQjk+bk6NOoqnnz9GBvvh4W19w4ezYDBZSMqe+E6Oj0hRcfk8FLJRBIRFIWpRCqhUKlhsNpRyOcaGhxDqokkflgiJiUdjRSliUtKmvK7X6uxK8TOYLBAEMaWGj85gYHioH4sWLYJUKkVXVxdqa2vB5/Ph6ekJiUQCkUhEmgByd1sWhUIBDofj9tc7Z7Mg+CxgKcLX39+PqqoqmxoZ5mJyZ6szMa0zWfARBIGGhgZ0dXUhJSUFPj6Od6qZUrr669Ypk6MqRqMRinEZ/BycVeodGIT2RtuNawmCwKldX2D7b/7PofVjUzNw5POP3VLw7Xz7VWz4wcPw9g9C/rGD5tdNURATSrkcpRfO4MLhvWCxOeDw+PALCUN0cqpDprrOQqNS2hQF7+vsQPGZ49hw/8Nu/UTvGxSC4d5eeNpQK2svTVXlGO7vRcaKNaQdMyIxGZePHMCSzbeSdkwyEHhIkLlqLYxGI3rbWnHl5BFoVCow2CyUXTiN5CUr5vX8uHw+CAsTg+w1lRd5ek1MpZncpUuhYEwmg1gshlgsRkREBLRaLaRSKaRSKaqrq2EwGODh4QGJRAJPT0+H0p0Gg8Gtv2umCN/3nQXBZ4HJgo8gCDQ2NqKzsxNJSUnw8/MjbZ3JET5nYhJ8pi+lRqNBRUUFtFotcnNzSStkNQk+4vqNmUb7LmVx/OvPkbfJOr+72eCLxFArlTbv9+U//4Ktjz/j8BMelUp1iR+frZz8ZgcSs/Pg7T+R6tZc70qzdBHm8vnTvAc7mxpw/OsvYDDowObwwBeJELUoFX4hYfN+IQ+JjsNAVyd8g0Pm3LarpQlVBRew/r6H3P5pPjYtEyd3fYHVd97n1HXa62rQ3dKMnHUbST0uk8UCleq+v2MKhYKA8AgEhEfAoNfj3L5vMNjbjYrL58ETiBCekKI9BK4AAQAASURBVATGPHnHCT0kUCkV4Ex6wNIbrPfgm3IsiSf6OlqnHAsAbgwjMJlM+Pn5wc/PD0ajEXK5HFKpFAMDA2hsbASbzTZH/zw8PGyK2N0MKd2FCN+C4LOIKaWr0WhQXl4OnU5HqjAyMVHn5vxO3cnCUqFQoLy8HGKxGOnp6aSmkqlUKrq7u+Hh7QPZiBScSSmr0aEBBEdGk7KOLeakAFBx+TyCo2Js8hqbDY1aBcJgcJuGiJriK6AAiEvPMr8Wl56NtrpqRCQssuoYwVExU7odtWo1yi6cweWjB8Fis8Hm8uAbFIKYlHRwXGxtkLfxFhz7+rM5BV9rXQ0ayoqx5q4f3BQXdiaL5fQ0WHdLE5pqKrFko3OicBy+YF67ja1loLsLbA4X3oHBSM1bAfnYKNrraqBSKqHXasAXiRAW7zoBGBITj6qCi4jPyDa/Zu8sbSqVChqNDgqFarXwolAoEAgEEAgECA0NhV6vx8jICKRSKRoaGqDRaCAWi83RPx6PN+t3yt1TukqlEtx5rjl1B9z7WzpP0Gg0yOVy5OfnQyKRICMjw2k1dq4SfBQKBd3d3WhpaXGos3iuda5cvYrQ2Hj0tbfBw3tiju7ZvbuQs5a86IIt44e0Gg2Kz5zAw796ibT1Y1LS0F5fi/CEJNKOaS+jQ4OoLLiIO5/8yZTXk/OW4egXH1st+G6EyWYjZ/1m5Ex6rbu1Gae+/Qo6jQYsDgd8oQiRi1IREBbh1Kd7OpOJ8dHRWbdprCpDa801rLrznptC7Jngiz2g12pBd4LQ6O9qR01xocN1s7MRHpeI+vISxGfmzL3xPCEbkaK2uBCZK9eZbZX4IjGiFqUCmCg3kctG0VZbA41KAZ1WC75YjLC4RKcJQAaTOaXkxaDXwxFrRvr14+m12u8M1m34TtLpdHh7e8P7+jVbqVRCKpVieHgYra2toNPp5uifRCKZ1th3M6R0v+8dusCC4LOITqdDf38/4uPjERwc7PQOWmcLPlONYGtrK9LT0+HpafuEC2ug0WioaWjC0sXrUHzuJCITUwBM+N6tuuMe0taxVP8yE5/9/f+w7annSFsbANJXrMXJnZ/Pu+AjCAJ73v8X7vvpL6f9jEqlQkHyVJDA8EgEhn/X8KLVqlFx6QIKTxwGg8UCm8uDT0AwYlLSwBPOPpnFVigUTBsZZ6K25Cr6OltJ/Yy5irj0LJTnn0fmynWkHne4vw9lF89h5e13kXrcG/EKCERFwUXMXwvE7Gg1GhSeOILs1RsAwKKwplAoEIg8IEj2ADBZAFZDo1JCq9FA4OGB8LhEUoW5h48fRoeHIPb0gmJc5tB3hssXQCkfh073neCjM5no6elBQIDtM4+5XC64XC6CgoJAEARGR0chlUrR3t6O6upqCIVCc/RPIBDAaDS6dYRPpVItRPiwIPgswufz4eXlhZCQuWuGHMXZgk+tVqOsrAwAkJyc7DSxB0yIDOm4HGweDyODAxCIPXDpyH5kkTyZwtri5ktH9iM5dxn4JIsPOp0O5bjrRqzNxJev/RW3PvLkjP5yHC4P46MjEIg9nLI+k8lG1ur1yFq93vxaf2c7zu7bDY1aBTaHA65AiMjEZARFRDmUAs9avR5NVRWIS8+c8npV4SWMDg1i6Wby5rq6Ei+/AIwNDZF6zLHhIRSePIw1Tq4NBCbEEsdNb6QEQeDiwb3IXL7GHH3i8vjQqFWzTluxKADHRtFaWw21SgmdVgOhhwRhsQkOCcCgiCiUXjgDsacXxkdHIHag21ni64e+jjZwed+V0XD5Qhw7dgyPPvqo3ccFJq7rpsgeAGg0GnP0r6vruw76gYEB+Pj4OM36xREWUroTLAg+C9DpdJeFp51pviyVSlFeXg5vb2+o1Wqnu8pTqVSMKyYaKsZHpOCLxOhoqCX9ZkxYMW9SLhtDS3Ul7rcQ/SIDlUrhdP/E2Tj06YfIXrsRIs+ZjVpXbr0bJedOIW+T67oofYNDseXhx8z/1mu1qCi4hKLTx8FgMsHm8uDp54+4tMwpI+HmIjIxGeWXz08RfGWXzkEll2Px+s1kvgWXwyHRnkU+NoqLh/Zi9Tbniz0TEl+/iZFns3wW54OCY4cQl5Y5RZR5BwShu6UZETZE5ykUCgRiD/OD0zQBqLkuAONsE4BUGs0cjVMrFZD42t+tzWCyQKXRoNdpza+xeTycPH3GYcF3IywWC/7+/vD394fRaIRUKkVFRQX6+/vR1NQELpdrjv6JRCK3iPypVKrv/ZQNYEHwWWQ242WysXbsmS0YjUa0t7ejsbERsbGxCA4OxqVLl5xu/0KlUkExm4lSUHrhDFKXrCR9HWvexxev/hkPvvAb0tc2ERAWgb6ONvg7aDNjD8XnTkHs7Y3w+NlvWgKxB0YGB1x0VpahM5nIWLEaGSu+M04e7O3GhUP7oJKPg83hgiPgIyJhEYKjYmYdA6edNA+15Nwp6PV6ZK0mNxU6HwSEhaO7tXlKutweVAo5zu7dhTV33uvSeqrIxBTkHzuEvE23uGzNuai4fAGefgHTottCiSdqS686dGxLAnB8dAQtNdegVimg02gg9vRGaGz8nALQNygEfR3t0Gu1s25nDSwOF/pJDW10OgNd3e0OH3c2KBSKWUhlZGSYmz+Gh4dRW1sLnU43zfplPh6SlUrlguDDguCzCJ1On3W0GpmQndI1GAy4du0apFIpsrKyIL4+asgVtYI0Gg180cRFkE6no6G8BA84QXQZdLN36R7/6lMs3XybUydL5G3YgouH9rtc8PV1tKGjsQ63PPyEVdu7W0cxAHj7B2LTA4+Y/63X61FVeAlXz54Eg84Ai8uDp68f4tIyIZR8V4LAF3tAPjaKqqICMBkMpC93/WgsZxCdkoajX/zXIcGn1ahxevdXWHXnvS7vmGWy2QDFgY4Dkmm6Vgm9TofwuOnfTSqVSvrUFQqFAqGHBEKPiZTnjQJQr9VCKPFCWHzitCyLT1AISs6eAoUEgc7h8qBVT7Ws0tnQ4GYvpoYNCoUCBoMBHx8f+Pj4THivKhSQSqUYGhpCU1MTWCzWFOsXV80yVqlU5oaU7zMLgs8CrhBHzlhLqVSirKwMdDodeXl5U2opTB55zoYjnJhx29fVgVVbnVNEb5jlfUgH+jA2PIjVd97rlLVNsLl8yEdHnLrGjWjVahz76lPc9xPr09SpecvRWFWO2NQMJ56ZY9DpdKQtXYm0pSvNr0n7+5B//BDkY6NgsbngCgQIjYnDng/ewaLFS8xTFf5/gE5nWJw7bS16nRYnd36B5bfe6bIb6I1weAK38GLr72hHX3sLkhcvm3EbZ1uvWBSAI1K0XKu4XgOohcjLC2GxEwKQzedDIRuz+vgTIyq1UCsVUKuUE40lajWUinGMSaXQ6w1gsFjgcLhQaTTOeptTzsfS351CoYDP54PP5yMkJAQGgwGjo6MYHh5Gc3MzVCoVRCKROfrH5/OdFv1bSOlOsCD4LODqlC4Zaw0ODqKyshIBAQGIjY2d9gV0hYhtbm6GX3AYlPJxjA4NgMPjO6XOzTjL+9j51j/wyK//QOp6M6FSKlyyjokv33gFdzzxjE3RuriMbBz69AO3FnyWkPj6YcP9PzT/myAI7PrXP6GSj2OopwvHv/4MRiMQtSgFEQmL5l1oOIpI4gm1UmnzfFqDXo8TO79A3qZbv7PjmAdCY+PRWFmK2NTMuTd2ErIRKaqvFszZ8cxksVwqTikUCoQST3O0ekIADpsFoGJ8HNKBPhj0uolrJYUCKoUCUKgT83EpFFCuH4dKpYFCpYLOYILBYoLF5oAvEILOZGC4vw80GgP+oWHQ63TQajRQusAk3trfJY1Gg6enp7lxUKVSmZs/2tvbzc0hpgggk0RhrlarwXexf6g7siD4LHAzRfiMRiNaWlrQ0tKCxMTEGVvwXRHhO3PuAsbZAtSXFYPN5UE60IvP//lnSHz8kLfhFkh8yZlSYqTAYqfd7nffwNq7fzBj1yrZCMQSjA4NQOzl+Fi6udjzn7exauvdds1fVZJszzIfFBw/jIiERTDo9Vh26zbQaDTotFp0tzai8PhhqJQKaNUaMDlsLMrJg0+gbUPo55uErMUoPnsKeRutr4MjCAKndu9A9poN4PDm92bmGxSC6qL8eRN8Oq0GhccOIXvtpjm39fDxxVBfD3wCglxwZtOZEIBeEEommlzqyoqh02oQk5Lu0MOxbHgYLBYLdAYTdMZEg5R6TErWac+IwWCwqzGDw+EgMDAQgYGBIAgCY2NjkEql6OzsRE1NDQQCgVkACoVCuwW60WiESqVaEHxYEHwWcWWEz5EuXZ1Oh6qqKoyPjyMnJwfC6+lUS7hCxDY2NSP91ruQuX0t/vrUw/ANDkPOus3QqtU4+Ml/oJTLEBITjyWbbwOTZX80QuLjC+W4bIrg62pqAJ3BQFhc4ix7ksuyW7aiIv+C0y1BLh3eh+CYOATYWeMl8Jho3vDwdr4wdQZFZ46DAiPSl6+GUOKJ5msViElJB4PJRFhsIsJiJ88JHkdbbTXqy0que6ipIfH2xaLcZeDN8v2Yb0QST6gU1gtzo9GIM99+jeS8ZTZ1OzsLCoUCFnt+bC8IgsDFQ/uQvnKdVaLA2y8Q5ZcvzJvgm8zo0CB0GjVYbLZDYs9oNEKjUYN5Q90yywWTQ8iIllKpVHh4eMDDwwORkZHmub/Dw8OoqqoCQRBmaxiJRGKTiTJBENBoNAuCDwuCzyImceQK2w0ajQatHR1acrkcpaWl4HK5yM3NnTP87YoIX0ZGKgKvj0+LTEpGfUUxwuISwGSzse3pCfPj3o42fPHPv4DLFyJl6XLEpWXZ/DsWe/lAPjYGj+u+VQRB4MSuL/DAz35N7hua8zy8nd4F21pzDWPSYayzInIxEytuuxsFxw86deKCsyi/eA6qcTmWXLeWiUpKwd4P/oWYlHSL23P5AiRkLTb/22g0YnRoEPXlJRgfkUKjVkGv0yIoMgbxmdlgMOZnlqolbpyFOhNGoxHn9+9GbFomPFwQXbYWD28fyEalEIolLl33yomjiElOtzoFyGCxbDJvdxYEQaCxsgzJeUtRWXDRoWONDg2CJxBOnd5hMCAqIsLR05wTZ6THb5z7Oz4+DqlUir6+PjQ0NIDD4Zijf2KxeNYIo0nwCQTk2R/drCwIPgvQ6XQYjUaXzAe0J/LW19eHqqoqhIaGIjo62irB5IoIX0pSEup6u+EXHAoKjQbF2PRCZP+QMHONXfG5U/j81T/Dw9sXuRu3wMvPOkd4L78AjI98l6r49r03seG+h+eljkvtxBoZhUyGS0cP4J5nXnDoOFw+HzLpMEln5TquFRViuL8XK27bNuV1tVJp9cMYhUKBh7cPPLy/s4UxGAzo72pHybkzUMnHoVGrQKVSEJOSgZCYuHmrBwyLT0RLdRUiEmcfh3f56AEER8XAOyDQRWdmHZFJKSg6dRSLN2xx2ZqV+Rfh4e1jbpCwFleVfcxGQ3kJIhInrJWoVMfuM6NDgxB5ekKrVptfUysVWHOb/Q+K1mJvStdaKBQKhEIhhEIhwsLCpli/1NfXQ6vVTpn7y+Vyp1wbDAYD1Gr1guDDguCziOnD6+wPsmktayNvRqMRDQ0N6OzsRHJyMnx9rXdmd6bBs4no6GhcPHYOwMRTlXJ8fNYbc+bKtchcuRZajQbHvvwEKoUcgeGRyFm/eVYnfK+AQDRWlAIA6stK4O0fCJ/A+UnPMFjMibFIAnLThQRBYOe/XsU9z/6clCizVqOBQa8n3ZLCWTRUlKK7uR5rtt0/7WehcYno7+yAX0ioXcem0WgICI1AQOh30Q+tRoPOpjrkHztk7nrkcHlYlLcUng4Y4tpCeHwiDn364ayCr/D4YXj6+SMwIsol52QLbC7XJU4AJlpqrkGrUSMsNsHmfZnzPA1iZHAAer3WnI539CHD/P2mfSdkleMyLF+61KHjWoOru7Mnz/01Go3mub9SqRQtLS1gMBiQSCQgCAK+vr5gs9kOp3SlUil+8pOf4ODBg6BSqdi2bRvefPPNGY8plUrx+9//HidOnEBHRwe8vb2xdetWvPzyyxCJvpv8ZOna/tVXX+G++5xjnH5zXP1dzGTB54q1rFlHq9WioqICarUaixcvtvnDS6PRoJvDv85RvLy8vou8EUYERkSip7V5zpsTk8XCbY8+BQAY6O7EN/9+HWwODwmZOYjPzJn2pfDw9sX46Cj0ej0KTxzC/c/9yinvxxpyN9yK2uIryFxFrgHwzrdfxcYfbHeo1nEymSvXoa6sGImT0p3uSmtdNRrKS7BxUpfuZLLXbMDRLz62W/BZgsliITIxxTz/GQAUsjG01laj+mohNEoVdFoNvPwDkZSTB64T6oGoVBpYnJnr4EounAZPJEa4C+tUbYXF4bhEAPR3daC7pQkpuTPbr8wGVyCEUi53yt9xLgiCQGNVGVLyvjt3RyJ8inEZ2BwOCIMBjEnXC61ahbCwMEdO1Srm047HZPzM4/EQHBwMg8GAsbExDA8P41//+hc+/fRTxMXFYWxsDK2trVi2bJldQZwHHngAvb29OHnyJHQ6HbZv344nn3wSO3bssLh9T08Penp68OqrryIhIQHt7e146qmn0NPTg927d0/Z9pNPPsHGjRvN/zZ55zqDBcFnAQqF4rJOXWvWGRsbQ1lZGUQiEXJzc+3y2nJFhI9Go0GjmkgpEEYjcjfcgouH9toUjfAJDMYPnp+oxSu9cBaf/+NP8PDxweL1W+B9vciaTqfDoNfh67f+ji0PPzZv482AiYkbxWdPknrMk7u+RFJOHrz8bR96PhORSck48N//uL3g62ltQuXlC9j84MzjoOh0uks6j3lCEZJy8sz/NhqNGO7vRc3VQsjHRqFVq2AwGBAWG4/o1AxSPPAkvn6Qy8amzX+uKrgEipGC6ORUh9dwJqGxCWiurkT0olSnrTE+NoprhfnIcuAhyzsgCO0NtYhelEbimVlHfdlVRCYlT3mNQrNfMA31dsM/LByDPd1gT/4MGl1jhu2KTJi10Gg0c2PHm2++ieeeew579uzBn/70Jzz//PP45S9/iXXr1mHjxo1Yv349/P3njt7X1tbi2LFjuHr1KjIzJ7rQ3377bWzevBmvvvqqRWeMpKQkfPvtt+Z/R0ZG4s9//jMefPBB6PX6KdcKsVgMPz9yHCzm4uY2r3IirurUnUvwdXd3o6ioCMHBwUhNTbX7puKMEW43QqVSAeP1NYxGMNlsyMdG7T5e+vJVePAX/4P19/0QBccP46s3XsG5/buhUSnRVFWOqKQUiCTzP7+TzPq46qICUGl0xKZlkXZME2q58z25HGGgqwOFx49g84OPziniBSKxQ58te6BQKPDyC0DmqnVYufVurL/vYay/9yEIPDxx9fRxnNmzC8d2fIqTu75EV0uTXWskZuag9PzpKa/VllyBUiFHQlYOGW/DqfiHhKGntdlpx9dptSg8dhgZK9Y4dByB2MNijbGzkQ72wWAwTBP0jkT4tGo1qFQaCIMBNPp3KV3uLNFiMnEHw+2ZiIiIwEMPPQSCIFBSUoIDBw4gJiYG7777LoKCgnDo0KE5j1FQUACxWGwWewCwdu1aUKlUXLlyxepzGRsbg1AonHYPf+aZZ+Dl5YXs7Gx8/PHHMDpRqC9E+GaARqO5ZLzaTJE3giBQV1eH3t5epKWlwcvLMWHjiggflUoFgz5x4TKJS4VM5nC3M4PJxC0/nBglNtTbg2/efQPD/b3w9nePonUanQGtRuNwXdDIYD+qruTjziefJenMpuLh54ehvm54+bnH720yI4P9OLd/N7Y++rRVn5WVd9yDy0cOIGed84vSZ4NGpyMoMhpB17vTAUCjUqK9vhYXD+27bg2jgUAkRnLeUog8Zx/vxBUIoZ9UetFUVQ7pwMCUWcTuDIVKBdtJQsNIELh0aB/Slq50WGBQKBTQXNy4QRgMaK6qQHLe9DS0yUXB1vel1WhAoUzsQxCGKfuLRa5pUnBnwQcA4+MT2QCxWIyoqCjk5eXh//7v/zA8PAy2FWblfX198PGZ2g1Pp9MhkUjQ19dn1TkMDQ3h5ZdfxpNPPjnl9T/+8Y9YvXo1uFwuTpw4gR//+MeQy+X46U9/auW7s40FwTcDrkrpWookqtVqVFRUQK/XIzc3F1wb3fct4aoIn9EwIZKNRiOMRiN8g4PR19FG2sxZL/8AxKVnY6inG80111B44jAiF6UiffnqeUvtpi1fhYaKEiRl58298Qzo9Xrs+eDfuP8568em2cryW+7E+f27sXLr3U5bwx5kI1Ic/+ozm6aIcPkCjA451xLHXlgcLmJSMxAzabqJbESKttprGBm6AI1qoh7QLygUibl5YN/gX8cTCkEQBNob6tDT1ozsNRtvXMKtEXt6QyGTke57WHjyKCKTUkibKOLsEWs3Uld2FVEzpOSZHA60arXNk1YGujoREDbRfGQ0Tm3+4Ftp8+MornCzcASlcmK+8I2j1f7xj3/glVdemXXf2tpah9eXyWTYsmULEhIS8Ic//GHKz1566SXz/09LS4NCocA//vGPBcHnalyV0r0x8jYyMoLy8nJ4enoiMTGRtC+Sq2r4DNejEwwmEzqtBks2b0XBsUOkCT4AuHYlH1HJaYhPz8TK27ehrrQIO17/GwLCI7Fk8+0u78CLS8vEoU8/dEjw7Xj9b7h9+49Apzsv6sBiczA+4tr5v3OhlMtw6NP3cecTPwGNZtvliEKhQqfVgMGc345LaxB6SJCct9z8b4IgMNTTjbIL56AcH4dWrQIARCYmIzwhCZcO74Nep0Xexlvn65TtJio5DcVnjiNn/WbSjllVeAliTy+IPckr4WCy2C6LTkn7+2CEccZJOWwuFyqF3GbBp1bIwWRfb16alArU63QIDneNc4HBYJi3Gc7WIJfLQaPRpsyWB4Cf//zneOSRR2bdNyIiAn5+fhgYmPpwqdfrIZVK56y9Gx8fx8aNGyEQCLB3714w5ogq5+Tk4OWXX4ZGo5l2vmTgvn+lecaVTRsEQcBoNKKzsxP19fWIiYlBSEgIqRErV0X4DJqJGxeTzYZOowFPKIJshLzxPgRBQOjhgZW334Vz+3bBNzgUcenZiEvPxnB/L3a/+wYEHhIs27IVYq/Z02dkonLAj2/vh+8gZ90m86xNZ2IwGNxGJGnVaux5/x3c+cSzdvmiLdlyO+rLipGUs8QJZ+dcqFQqfIKC4RP03Qg4vU6H7pYmXD19An2d7QgMj7wpJ6RweDxSy2Faa69BrVAhNjWetGMCgKefP/o720l9GLUEYTCgudpyKtcEm8PFyEC/TX9rwmCAYdLveXLtl0qpwPKl9nUw24q7p3Tlcjk4HM60+6nJ2mUucnNzMTo6ipKSEmRkTETtz5w5A4IgkJMzc12tTCbDhg0bwGKxcODAAavSx+Xl5fDw8HCK2AMWBN+MuKqGzyQsq6qqMDQ0hIyMDEgk5DvVu6qGz2jQwaDXg8FkQXd9gohKLiNtjbN7vkbqslVgstmQ3RCt8vT1x/3P/Qo6jQaHPv8QRgOB9OWrEZ6QRNr6M6FRq0AYDFanJE0Unz0Jn4BghMc7/xwBIHfjLai5WoiUJStcst5M6LQa7HrnNdzx+I/tjsj6h4Qh/+jBm1LwWYLOYECrUUPo4QmeUITMlWvRWFmO6qIC6HVaJObkuU3d6lyweTxShMBAdye6mpqmWJiQhaevP9rqa5wu+GrLihCdMns3MJPNNkd5rWWwpxs+wZatidRyOZbk5dp0PHtxpy5dSygUCptGsd1IfHw8Nm7ciCeeeALvvfcedDodnn32Wdx3333mDt3u7m6sWbMGn332GbKzsyGTybB+/XoolUp88cUXkMlkkMkm7oPe3t6g0Wg4ePAg+vv7sXjxYrDZbJw8eRJ/+ctf8Itf/IKU922JBcE3A65K6ZrGqikUCuTl5Vn1FGAPzo5YGo1G9PT0QMwXYHxUChabBZ1WAwDw8PXDQHcnKQPt+zrbseL2uwAAep0WWrV6Wk0Pg8XCHY8/AwA4u/cbXDl5FNEp6UhbvsppT6KxaZloratB5BxTEibT096KzuZGbHnoMaeckyWCI6NReuH0vAo+vV6PXW//E7dt/9GsvnPWoNOo3T7CYC3XivIx2NuN5bfdibILZ6DVaJCQORFB0Ot0aLpWgfryEujUGsRnZJPqQ0g2wZGxaKurQYQDD1uKsTFU5V9C1ur1JJ7Zd9AZDFCc7Fwy3NcLCoUCDm92vz/mpAdkaxkfHUFY3He2IlO6O41Gq6JXZODu3z+FQuHwffXLL7/Es88+izVr1piNl9966y3zz3U6Herr6831gqWlpeYO3qioqbZkra2tCAsLA4PBwDvvvIOf/exnMBqNiIqKwmuvvYYnnnjCoXOdjQXBNwOuSOkODQ2hoqICwETBprPEHuDclK7BYEBNTQ0GBwfh6yXB6PAQmBwedJoJwbfsljtQdOoYVt/pmHu4WqmEx6Q0bd6mW1FVeBEZK2f241p1x0SDQkN5Kf4fe28d3saZrv/fGsmybNkyMzMzO3GYGZs0KeO23S7T+Z7dA7tn95zlbbvd0pabtGmoaZjJiZljZmYZxdLM7w9FqkGSBSNZ3Z8/19WrsTQz7yuaued5n+d+jv7t9/ANCsHyrbtoS/xWkZK3Gle/+FRvwScVi3H12Gc48Kr57ua0IVpEexaSJHHstT9g6xPPac1nMoS4zBx0tzQiKJLe5T5LU3b7OqQiEXI2KNuSRaako/jaReRs2AZAKU6iU9IRnZIOhUKOtroa3LtYDYlYhKjkNPiFhC3m9OfhFxKK6yc/N1rwyWVS3L90zmxiTwXTjIUbCoUCbXXVOpdyVTAIAjAghYeiKEgf3lDPeFD9TxuW5QSYtQs+oVCocUnXEFxdXbWaLANAcHDwLMG9atWqBe1VNm3aNMtw2RJY76e0yJgzwkdRFNra2lBRUYHIyEj1Y+bEXEu6YrEYxcXFmJ6eRlZWFvx8fTE2OACuoyOkEqUJs72DIyZHTfequ3T0I6Sv2aj+OzAiGl1NjXrtG5mcisM//AWS81bhxNuv4exH72JsmL4qT0PNgI/89f+w67mXF+VE6RMUgoGuTouPS5IkvnjtD9h06Cl1SylTicvMRVttDS3HWizuXTgDBoOBlBnWK1xHHmQSzREfJpOFiIQULN+yE6t37odULMb9S+dw49QxdDSaXlVIBwyCgA3buJsqiiRx99xXSKbBfmUhzFngVV9aiMjkVL23Jxj6v9aJ0ZFZN7/A7GsIx4IVyP/qS7r/SixF+LTAYrHUy610IpfLUVNTg4mJCWRmZsLJyQkNDQ0WqaClO8Knqih2d3dHbGwsCIKAl5cXauvb4ekfDKnom0bedHRGEAum4eo5u3+wYNIw81QXDy88+v2fQS6V4twn/4RcLkf6qnUIiTG9XZVIKNDLc/D4W3/D6j0HFlzmMRfLNm3HtRNHLb4k+OXf/4x1+x+FE42VlgRBQCQwf9cNc0BRFG5/fRLuvn4Ij0+a9zxHj+8HwWQiNDYBobEJoEgSXc2NuH/pHESCaQRGRpu148VCOHt4GNW+rOj6ZYTFJsLWjCseKhx4TpieGKftBkTFcH8vmCwmOAZYoxhivjw2PDSvgxGFbwSfnZ353zsV1h7hE4lEtFib/StgvZ/SImOOog2BQIDCwkLIZDLk5uaqmyhbrKCComgTfd3d3SgtLUVoaCji4+PBZDLBYDBga2sLuVQKOwcHSGYkIfPcXDE60Gf0eOOjI/Dwm28z4BcWjv6ONoOPx2Kzseu5l7HvO99Dd3Mjvnj9jyi7dd2k98cvNBz9ne06t7l5+kuExiSovbMWAxabjWkDhbKpHH/zr8jbvgeungu3MjIUT78AjA70035cc0KSJK5++RkCwiM1ij0A8A0OQa8BHTsYBIGgqBgs27wDa/c+CnsHRxRcPo+bp75EQ3mJ2av05xKRmIIHRfcM2udBcQF4zi4Wq7D39AtEb7txXVG0oVDI0dFQi9C4xIU3noEh7dVkEsl8kfVQ71EUBUeuZTz4AOsXfAKBYEnwPcR6P6VFhu4l3aGhIRQUFMDd3R3p6elgzwi5W8IyRRVyN3UckiRRV1eHpqYmpKamIigoaFZEiyAIUKQcdg4OEAsF6sdXbNuLmkLDTv4zuXT0Q2Ss3Tjv8ZU79qHahOMCQN723Tjw6k/g6OKKo3/9Pa6f/AJSsXjhHeeQs3EragrytT7fXvcAwukpJOQsN2W69EABEpFhVYHGcvKdN5C1fjO8aCja0cTybbvRUF5ilmObA4VcjotHPkBc5jKdfaZDYuLRXFNh1BgMBgP+oRHI3bQdq/ccgLOHJ4qvXcLN01+ipuieRcSfvYOjQb+jjoY6iKam4B8asfDGNGHv6AjBJH0uAgBQX1aMyCT9l3JV6CuahNNTsNEY/VQqPplUiqgIy72H1r6kKxKJ5pku//+VpSVdLdBVtEFRFFpaWtDR0YH4+HiNzZotUSCiOpmYYpIpkUhQWVkJuVyO3NxcjXkRTCYTpFwOe64DRIJvBJ+DszMmRoeNmzyU89eU5M9iszE9QY+ZcERiMiISkzE+MowT77wOB54T8rbt1tsbi2NnD5FQc0GEYHIS96+cx77vfJ+WuZpK3rZdeFB0D2mr1pl1nDPvv4XUvFVmjWiy2baYHKOvn7E5kUokuHjkAyzbvBMOzs46t2WyWLCxMT0Xi8FgwCcwBD6BSvuR4d5ulFy/AqFgCi7uHkjMXg7CTMa5dnpeaIf7etDZUIeUvNVmmYc2GAwGrR03hvt6wLJhGWygDDws3NBrjF74arCSUeXwiYXTWL3KclX41h7hEwqFS4LvIUuCTws2NjYmizCZTIbq6moIBAJkZ2fD0VFzVaIlBZ+xd/YTExOoqKhQN5HWdkdHEARImRR2XAdIxMJZzwmmjMu16mlpgl+Y9jtWUkFCLBLS1sPT2d0Dj37vp8o8v0/fh0IuQ+qKtXpVHIpmRDXV8yNJfPmPv2D/yz9ctPZvc/EKCELhlQtmHeP8J+8hNi0LAeFRZh0HANgcO4gE04uWF6kPwukpXP78E6zec0BvQcB1coZcLqe1k4GHXwA8HkZbRwf7UXr7OoRTU3Bwdkby8lW0juUXEo7OxnoERWmvohZOTqLq3l1kmrkiVxs2NBVuKORydDTWIjHHOM9AfaNkUrEITA2fkapmQyIUIjMz06g5GIO1Cz6RSGQWb9tvI9b7KS0ypoqwqakpFBQUAFA6dWsTe3SMpQ8MBsPoXMG+vj4UFxcjKCgISUlJOk9MBEGAksvB5nCgkM3OgXTg8YyqjL115gTSVmhvHp+3fTeq7981+LgLwWKzsevZl7D3xe+ht60ZX7z+J5TevKpTNDu5umNseHDWY8fe+BM2HXoabFvLJVLrg0g4bbbq8EtHP0JIbIJFTK8BYPXuR1BfVmyRsYxhaoyPy59/jPUHHzco+hOekIzakvtmm5eblw+y1m3G6t2PIDw+GRV3buD6iS9QdO3SfNsPI/APj0SnjsphuUyGe5fOIt3MkWZd2NrZ0ZKvXVdWhMiUdKP310c0yXR8JqrfMgGGxXLWVHnhS0u63w6WBJ8WTBFh/f39KCwshK+vL1JTUxfsn2fpNm76QpIkGhoaUFdXh+TkZISEhCwYoVIJPgCgqNlj5W3fg5pC7Tlu2uBwuWDpWNryDQ7FwALFEqayfOsuHHj1x3By98DRv/4e1058rjEHbsX23XhQ9M0F+sqxT5GQkwc3L909FxeDoMgY9LY20X7ca8ePwi8kHJGJhucxGYuzmztGTCgKMiejA/24fuoYNh56yuDomZu3D8aGBhfekAZcPDyRuXYT1u0/hNj0LNQU5OP2mRO4f/kcxHOi9fpCEITWaluKJJF//isk565c1AiRu48f+jsNL/yayVBvN9i2tuBwjLf/IPQoFBzq7YGvFs9FilReQ2xsLCe+VNcTa4/wORhYKf6vytKSrhZYLJbBd30kSaKpqQk9PT1ISkqCp6d+uV+WEnyGRPikUimqqqogkUiQk5Oj9x0SQRAAKdMYOXJyczf44lVTeA8RCZqrGGcimJ7SyxLFVMLjkxAen4TxkWGcfOd1cOy5WLlzL9y8lLmZygjfkHruNmyOUQncliBr/RZcOvoR/Glccr399Um4efkgJs1yS0oqFDIpFHK5xuWuxaK/sx1lt65h06EnjdqfwWAYZO1BFzwXN6Q/NDSfnphAXXERpsb4YLFtkLpijUFL544urhALhfMimyU3riA4Oh62i+yR5urhhbYH1QgIizRqf7lchs6meiSaWIzFsbOHRCAA66F7gyZE09Pw8g/U/OTDU64t2/C+1MbybRB8EolkSfA9xHrOjFaGoSJMIpGgqqoKUqnUIIEEWMaWBdA/wjc1NYXy8nI4OjoiOzvboKgEk8mEg50dxEKBRvFlqB9f5d2bOPC9hbtRBIZHoae1GQHhxp20DcXZ3UPt53f+0/chk0qQunItwuISIRJMY2x4EA3lJdj57EsWmY8xEAQB4RR9FYr3Lp6FvT0XCdmL09s2c+0mtNRUIsqEZTU66WisR0N5MdY9ctik47h6eWOSPwqeqxtNMzMMBycnpK1cCwAQCabRUF6CSf4owABSV66FA0+7QAGUy9JV9+/M6ppRV1IIewceXPUsiDInTBYLIIy/UawrLUI0Dd85DtcBk6Oj4GoRfKRCAYVcpnV/lQ8fm2UDmUy24MoSHaiuJ9a6pEtR1FKEbwZLgk8LLBYLJEnqFTUaHx9HZWUlnJ2dkZqaavCyjTVF+AYGBlBTU4OQkBCEhYUZHDEjCAJ+Xp6Y4I8CmL+vrZ0dJvijcNLj4kWSJBycnfS6e8zZvB1XvvjEYoJPBYvNVou6/AtnUHTtEvq7OnDq3b/j0R/83KJzMQYmywai6WnYmXhCLL5+GQSDgRQduZbmJiQmHtUF+VYh+Joqy9Hd2ohVu/abfKzIpFTknz+D5Vt20jAz07DjOqgracVCIRorSzE+MgxSIUfqyjXgucz/XTs4OUMi+mZJuLOpHtPj44hOzbDYvBfC2GrowZ4u2NrZ0dKq0dbOTmuVPwCMDPbDw1e3tRFFUWASDOTn54PH48HNzQ1ubm5wcHAwy+qHQqEAg8GwmmK0uSgUCkgkEp059P9/YknwaUEl2hayMenu7kZDQwPCw8MRHBxs1BffGnL4VPYxnZ2dSExMhJeXl8btFoIgCAQHBqB1eGheDh+gLLCouH0dq3Y/suCx7p3/Cgl6VryxWCxMT4wbOl1aUV2Q//5vP8T46AgufvYBPP0CkZibZ7XVoyt27EFN0T1kavA41JfKuzchFkwjd9N2GmdmHCILLe3roqboHsaGh7CMJoHGseda3DRZHzj29kjKXQFA2Ru6sbIU/KFBkAoFkpatmGVnZGev/P6PDvSho74WKcsta7+yEDZswyt15TIZuprrja7KnQvblgOpRHtRxvTYGAIjo3UeQyIWYevKFcjJyQGfz8fo6Cg6OzvBZDLh6uoKNzc3uLq60hb9s/YKXZIkIRaLlwTfQ5YEnxZUIWptlggqA+LBwUGkpqbCzc345RYmkwmZTHuoni60CUu5XI6qqiq1fYwp4W+CIBAcHIySgkpQ5Pw8PjcvHwz2dOl1rM6meuRs2mbA6AwIp6c0+vVZir72VkSlpGN0sB/bnnweI/19uHTkQ4BBgOfigoTs5fDUloOzCLh5+WC0v9fo/WsK8zHS30dLJIsOQmITMNDZDp9F6mRSeusqFHKFSQJaE3YODlZ9cWVzOEjIVuawyaQSNFdX4EHRPchlMsRnLYNPcAhaH1Sjve4B7e8NHfBc3TAxOgwnN/07fNSVFiI6hb4oJcvGBgoteeMURelVNS0WCrBq5UpwOBz4+vrC19cXJEliYmJCLf7q6urA4/HUAtDR0dHoGyRrr9CVy+WQSCRLnTYesiT4tEAQhNYlULFYjIqKClAUpdWA2BCYTCbERnR2MBRNr2d6ehoVFRWws7NDTk6OyXd+TCYTPB4PoqlJkFosP/TJ45NJpQadfAFg5a59qLp/Fzkbthi0H51c+fIIDr76E5x+7+8QCwVw9/HFrudfAQDIpVLcvXAGo1+fBJfnhKDIaESnZi56kYFIoF8P4Lk0VZajv6MNa/YcNNPMDCdjzQZcOPLhogi+exe/hr2TM+Kz6F9SDgyPRGdjHUJiLGNzYwo2bFvEpmcDUEbBWmoq0dfRhs7meqzcvneRZ6cZTz9/1JeV6H3OGejqBMfBgZalXBUq6yxNTPJHwXPR7SVHAZCKREhKml3kRhAEXFxc4OLiAkCZbz46OorR0VF0dXWBIAh15M/Nzc2ga4BCobDamxBgaUl3LkuCTweaImJ8Ph+VlZXw8PBAbGwsLXc3i7WkOzw8jKqqKgQEBCAyMpKWZTCCIECSJBRyGSgty1B29lxMjY/B0dlF63Euff4RMtasN2hsL78A3L/wtUH70Mndc18hY/V6EEwm1ux9FGW3b2DZ5m+WOVlsNlbPiIQ1VpTh2N//BK6jE9x8fJGyfDW4PJ7F5x2RlIbOxnoER8fqvU97Qy2aq8ux8eATZpyZ4RAEAaGF+wRTFIWbX30J3+Awg95DQwiIiMblzz/+Vgi+mbBsbBAam4D2+gfw8PFHe0MtJEIh7LhcBEVEw3EBEWMp7LgOkIr1azUol0nR3dpoclWuJrSJJ/7QoM42fBRFARTAJIgFc8htbW3nRf/4fD66urpQX18PR0dHde7fQtE/a446A0rBJxaLlyJ8D1kSfDqYKcQoikJnZyeam5sRFRWFgIAA2vKELFWlqxqHoii0tbWhra1Na7s3U8YgSRKUQq4xhw8AVu95BA+K7iFno/bl2ukxPtx9/AweXzi1ODlccrkcPW3NyFq/GYDS02ykr0fnPlEpaYhKSQMATIyO4Orxz6CQy+Ho5Iy4rFz4BhteNGMMKXmrcPHIh3qLlb72FlTfu4Mtjz1j5pkZh6OzMybH+AtGROiAJBW4cuwzRKdmwDsw2GzjKP3sFte+xBhEAgFufnUMWes2ofzOTSQ+XPaVy+VoqiyDYHIctnZcBIRHwMV9cSt2WXramdSVFCLaTLZD2tqrySQSncKKokgwGATYNoZd0mdG/8LCwmZF/7q7u8FgMGbl/rHntKGz9j66qgjfUpWukiXBpwOV4FMoFHjw4AH4fD4yMjLgvEAPTENhsVgWi/Cp8vXGx8eRlZUFHs0RJZXgA0lqTTT38AtA4dVLWo8xNT4GJ3fDlnNVhMbGGxytooOTb72GdfsOzX6QQUA4NQV7PZYTnNzcsfOZ7wBQXgwLr15A/vkzcOA5ISAiCrHp2WCZyWaBIAhM8kf02naopwuFly9g+9MvWm1l3qpdjyD/whlkrdts1nHkchkuHvkI6avX691v2RQcnV0gFYtpXUY0J8LpKdz66jiyNmwBi8UCk/nN5YbFYiE2PQuAUjS3VFeipboSbI4d/ELC4ObtY/Hv18z5aaO/qx12jrx5wocuNIk6kWAaLFvd45EKEgSTATsT28TNjf5NTk6ql341Rf+sPcInFouhUCiWBN9DlgSfDlgsFoRCIRobG8FisZCbmwtbmvouzsRSET6SJNHT0wNHR0fk5uaa5aTFZDIhkUhAyeU623aJdPi/XTryIdYffNyo8bM2bMHFzz6wqOAb6OqAk7sHnNzcZz2+bt+jKLtzHXlbdxl0PBaLheWbd6j/bq+vxal3X4eNrR1cPb2Qmrea9qUwDtcB0xMTcNBh+jo2PIjbX5/EzmdeslqxByiX5yb5o2YdQyoW48KRD7Bi+x7YO1pmGT4iKRXVhfmL2oZMX6YnxnHn7EnkbNwK4qGQYmmJPhEEE5HJykg3SZJor3+A1rpqcOzs4R0QBE//QIt83+wdeZBKxWCzNQtqmVSKntZmsyzlqiCI+dGyob4e+AVr7q6hgiQVIJhMcO3piwITBAFnZ2c4Ozuro3+qyl9V9M/uYVs6qVRqNhFsClMP+7cvtVZTsiT4dECSJBobG+Hv74+oqCiz3ckY2vLMGEZHRzEwMAB7e3ukp6eb7bWoI3wKGShoD/UzmEwIpibB1XCxpChqQTNXXeMLLJzDdenzT3Dguz+e9zjP1Q2j/aa3+wqJiUNITBwAYHpyHLdOn4BELIQDzxkx6VkIjIg2+YK4ds9BlN+5gdzNmq1VJsf4uPLFp9j13MtWfUevgqJISCUSsM1wgyaYmsSVLz7B2n2HLBptc3b3WHTrIX2YHOMj//xXyNm0fdZ3hW1rC7lMpjNSTRAEwuISERaXCADoam5AyY0rYHM48PT1h3dQiNm+fx6+fuhra9N6s1hXWohYM3eQIZjzX5tUJF6wsItUKJd03Vy150Wbiq2tLXx8fODj46OO/rW3t0MgEKh9/1TLvzwezypuCgUCAYAlwadiSfDpgMViwcvLCzExMWYdx5xFGzNzD93c3MBms816wZ65pEtpMF5Wkbt5O2qL7iNz3aZZj/d3dcDXxApLgmWjVUzSzf1LZ5GyYrXWEzLLho3piXE4ODnTMp4DzxnbnnwOgPKGpPTmVRRcPg8ujwe/kDAkZC2HjREih+fqBr6WtnfC6Umc+edb2P/yD/Ra9rIGVmzfi8aKErVVCF1MjI7g+qkvsPHgE4tSXW1n5Reu8ZFhFFw+h5xN2+adZxxd3cEf7DfIligwIhqBEUrvuf7OdpTcvAJbWw7cvH3hFxIGgsb8MWd3TzRVlQOYL/j62lvB5TmBZeYo1lzBJ5NK1R00dEGSCigUcmRnZZlrarNQRf9Unn4RERHq6F9PT486908lABcr+jc9PW32a963iW/H2XuR4HA4FinnNpfgUygUqK2txejoKDIyMsDn89UhbnOhEnw2BEDKtL8mv5AwVNy5Me/xGye/wO6HNibGsnr3flTm38KyGcui5kAul6OjoQ77XvqB1m3W7z+MgqvnsWrnPtrHJwgCmWs3qn3NetpacOaDt8C0YcHJ1QMpeavg4qG/gbZELAKpUMy6iEpEInz13pvY99L3zJZDaA48/QJw/+I5Wo853NeL+5fOYtOhpxbtAuLpF4DRgX64edNXaEUXY0ODKLx6Htkb54s9AHB2dUdrbbXRPpQ+QSHwCQoBAAz19qD09jWwbNhw9fBEQHiUyQKcIAiNAlImlaK3s1VdcGJOGIzZ4w/39eh1A0ySJORSCVbm0WMCrS+qHL650b+pqSm1+Jub+2fJ6J9AIICdnZ1VRButgSXBpwNLFlPQPY5YLEZ5eTkIgkBOTg44HA7Gx8fN/npU+Yj+3t7oa2zVua1Qg/i05XBMXoZz8/LBcJ/xZsL6curdN7Buv+4+qfY8HsaGhsw+FwDwDw2H/3e+B0BZHXnn6xOYHh+HPc8JkclpCI1N0ClUErKWobW2GhGJKQAAqVSME2/9DbuefcmoTgSLjVg0TVtSeW97Kyrzb2Hjo4trQxOWkISbp49j5fY9izqPuYz096Hs9jXk6rjJsnd0xPTkOC3jefr5w9PPH4Ayt7Ts9nWwWDZwcndHYEQ0bIyMKGlqsVZbUoDYdPMu5arHt2VDKhGDbatMFRBOTcPTT3c7NQBQyOWgFBTCwnTn+tGNpipdgiDg5OQEJycnhIaGQiqVYnR0FHw+H1VVVQCgjvyZO/qnEnxLKFkSfDqwpD+eyi6FjjuRsbExVFRUwNPTE7GxseoLniVejyofMSI0GLfLq3RvzFBWoKnajjVUlCAklh6fMdH0lFkryIb7euHg5AJnPaqJbTkcvfsH04Udl4uNjz4JQHkXXn3/Lr5888+wd3CEp18AUvJWw9ZutjdVfFYuzn78LiISUyCXy3H873/Bjqe/M2+7bwuJ2XnoaKhFaGyCScdpr3+ApuoKrN33KE0zMx62LcfqlqeGe3tQce8mshcwPCeYTB1JHsbj4uGlTg2ZGh9D5f3bIBgEHF1cERwVa9ANpI2t7azzRm97K3jOzmCxLLMkybHnQjQtANuWo/QzVUj12o9UKGDDtrH4d0OfcyybzVZH/yiKUlf+WiL6txThm82S4NMBi8WCREdvQ7pQ3SHR0aamq6sLjY2NGr0CLVEcolrSjYqMhGhaeyNwAMjZsBW1JQVIX6U0WC65fllj8YMxRKWko62uBuHxSQtvbATnP30fj3z3R3ptu+6Rx3DvwldYrUf/YHNAEASSl69E8vKVAIDB3m6c/fg9EAwGHF3dkLJsJdx9ldESlVA+9vqfsPXx56y2B7A+xGZk46v3/2GS4GsoL0V/ZytW7rCeDhH2VtRmbaCrAw+K7+ttgUOYOQfU0dkFGas3AACEU5OoKcwHRVHgOjoiJDYBnAVuXpzdPTE2PAg3Lx9IJRL0d7QhIWeZWec8E46dPYbHeuDk5qZcutfTi1ShUIDDsXyeHEmSBnXmYDAY86J/qty/6upqUBRFa/RPKBQuRfhmsCT4dKCyZTE3qhO3KSaWJEmivr4eg4ODSEtLg6vrfNsOS9i/qARfeHg4RELdgi8gIgrVBfnqvx2cnGlLwk5duRYXP/vALIKv6NpFJC1bARZLvxOdHZeL8RHLLOvqg5dfAPa++CoAQCoR487XpzE2PAiuIw9T4+P47E+/xdYnnqOt0GQxkYj0656giap7dzA1OYacTZorlxeLkJh4NFWXIzqZ/hZuhtDb3oqG8mJkrNmg9z6WLHSxd+Qh7aGFjVgoRH1ZIeQyObiOjgiOitPoj+nh64eaontw8/JBXWkhYjLo65WrD7Z2dpA8bLM5OT6GoIgovfYjFXI42Fm+oEcpNI2vVGez2fD29oa3t/es6F9vb686+jez8tfQmxyBQLDUZWMGS4JPB5Zc0gVgdPRNIpGgsrISCoUCOTk5Wu9oLBnhY7PZUMg0NwKfifChH1/hlQvq/pt0zcMcFhYkSaKluhL7X9EvuqfC3oGHseEhixj0GgLbloN1+79ZqnzrP36G6fEx3D5zAmyOHey4XASER8I/NOJbY/g7E6+AIIz09xrctaXgynkwWUx19Nma8AkKQdX9O4sq+LpbGtFSU4n01Ya9P/reJNENx94eKXlrAABSqQT1JYWQiMWwd3BAUFQsHB/e3Nhy7CCXytDb3gKeq6vFlnJV2NhyIJWIQVEUZBL9+6sr5HI4mdGSRRt0Rpp1Rf9qamrU0T+VANTHE1coFC4JvhksCT4dWErwqZpmy+ULC6S5TExMoLy8HK6uroiPj9cZIbREhG/me0YqFn49JKmARCRCc00lDr5Kz3KuChtbW0yN8Wk1KT797htG5XKt2f8o7pw5ibV7D9I2F7pprChDYtYydLU0YttTzwNQViK3VFXg0ucfgSQpMAkCXCcnePoHIiQ6Dlwj/RItxfLNO3Dl+BEs11PwURSF/PNn4OTmjsjkVDPPzjgYBAHOIl7EOhrr0NlQh9SVaw3edzGsbObCZtsiaZkyvUEul6GhrATC6Ulw7LgIjIwCwWSiv7ONdksffWAymQBFYXKMr7PX+FxIkoS/v68ZZ6Z9XHOlFsyN/qkqf/v6+tDQ0AAHB4dZuX+a5rG0pDubxf/1WTE2NjYWEXyAcdG33t5e1NXVITw8HMHBwQsmploywgcoE4nn2nzMJXPdJjwougdnV1faE2vX7n0Ulfm3kLdtNy3HGx3sB8feAa5ehlticDj2GB8ZpmUe5kAul6P87g3sffF7kMsV6G1rgV9oOFgsFqLTMhCdNntpq7etBbfPnYZYIADb1hYce3vwXN0QGpsANy/Lt8XSBovNhmBSe1eXmVAUhesnP0dg5Dfeb9YKz8VtVsGTpWirq0FPWzOS81YZtb+tnT3EQgE49tbhJ8hi2SA+KxeA8uazsbwMQ309cPXwRGNlOZhMJtgcDhycnMHlOYFta2v27zaDIMAfHIBfaLje+1AkiVUrVphxVpqxVC9dBoMBHo8HHo+HkJAQyGQydeWvKvrn4uKiFoCq6J9IJFoyXZ7BkuDTgaUifIaOpeoA0tfXh5SUFLi7uy+8EyybwwcATCYBmVQKWx13WCEx8fi/15/CEz//D9rn4uTmjtHBAdqOd/aj9/CIgUu5M+G5uFmth9rJt1/DxoNPgsFgIHvjFlz49H2dFxy/0PB5z0+MjqC64C5G+vvAZtvC1s4O9o48BEfHwicwZNGiO2w2G8LpKdg7aPfUVCgUuPLFJ4jLzDHaJ86SRKWko+TGFeRs2GqxMZtrKjHQ3YGkXOOFhbO7O0YG+uAfGkHjzOiBwSAwPTkGV3dPxGXkqB8XC4UYGx7EcG8PJGIRCIKp9OxjMcFkMsFksmDPc4KjkxPsuA605CFLxWLDImcUheXLLFdcomKxiodsbGy0Rv+Ki4vx3//938jLy0NHRwd8fY2PfPL5fLz66qs4e/YsCILA3r178dprr+nszbtq1Srcvn171mMvvvgi3n77bfXfXV1deOmll3Dz5k04ODjgySefxP/+7/+CZeZz5JLg0wGTyTRqmdXYsfQRY1KpFFVVVZBIJMjJyTEoP8HSET4Oxw4yqUSn4Kspuge5XGa2L7pwemrBKKM+lN66hoTsZSaZD6/ZcwA3Tx/Duv2HTJoL3ZTfuYHw+GQ4OjsDUH6GQsE0FHK5QSLNyc19XjRVIhKhtqQAxTeugMlgwtbODrb29vAPDUdgRJRFLF9W734Epbeuac03k0mluHT0I2St3wyeBa1zTMHByRlSsfEFKYbSWFmG0YE+k82HHV1c0dPaYnWCj6IoVNy9iYDwaPS2Nc96jmNvP8v0eS4kSWJybBSDfb0QTIwDJAUwKDBZNmCyWEpjYo4dHJxd9IoSMsAAa4H8NJlUiqlxPqbGxyEViyASCODjY/kbSWuoFp8b/YuIiMDo6CiuXr2K+/fvA1D60m7evBmbN2+Gn5/++byHDx9Gf38/rl69CplMhqeffhovvPACjh49qnO/559/Hr/+9a/Vf8+8TisUCmzduhXe3t64f/8++vv78cQTT8DGxga/+93vDHz1hrEk+HRgKeNlQD/BNzU1hfLycvB4PKSkpBgsklRijC6/P02oRCVFUbCz40Am1Wxr0/qgCvcvnEVMehZiM3Jw4ZP3EZWWobe9g77EZ+SgsbIMMSb0wCRJEvVlxSZbxrA5HEzwR0w6Bt2IhUK01dZg57MvzXo8Z+NWPCi6p851MhZbOzukrliD1BVr1I+RJInWB9W4cuwzyOUysDl24NjZwd3HD6GxCQblLukDz9VN63K6RCTExSMfYcXOfbDXcddujdhxzd8FCADqy4owOTqKuMychTdeADt7LkRC83b7MYaaonvw8PWHi4cnelqbDNqXIAg4u3nA2U27J+f8KCEBBkGAyWSCYDLBZLHA5TnBwckZcrkcru6e6GlrgUQoBAVKGVEkCBAEU7kfiwV7B0d4BwaBbWuLrvoHpr4FRkGHlRjdODk54dlnn8Wzzz6LPXv2wNvbG1FRUfjwww/xne98B7GxsXjppZfw0ksv6TxOfX09Ll26hJKSEqSnKwuk3njjDWzZsgV/+tOfdEYO7e3t4e3trfG5K1euoK6uDteuXYOXlxeSk5Pxm9/8Bj//+c/xX//1X2Y1ol4SfDqwpOBbaLl1YGAANTU1CA0NRWhoqFGCjU6/P22o7vZIkgTX3g6yOT6Gfe2tuPrlEYTHJ+HA934CBoOBqJQ03Dt/Bmw2B8fe+DN2PPMibblJictW4PzH75kk+E7/802s3n2Alvm4evpgqKfLapYNT77zOnY88515jweERaL0xlWTBZ8mCIJARGIyIhKTZz0+2N2JgsvnMD05AbYtB2yOHZxcXRESmwB3b1+TIgkyqeRhJPmbCO305ASuHPsU6/YfUnc2+DbhHRSM/s52rZEnOqgtvg/B9CSiaeo0wSAIEAzrEgj1ZcXgOjrp1dHCWPSNEvZ3dmCCPwJXT0+4e/uAzbFb8HvPHxpEQszi5JwqFIpFj/DpQiwWIywsDL/85S/xy1/+Enw+H1evXtWrwregoADOzs5qsQcA69atA0EQKCoqwu7d2nPDjxw5gs8++wze3t7Yvn07fvWrX6mjfAUFBUhISICX1zdtLzdu3IiXXnoJtbW1SElJMeEV62ZJ8OmA7g4Y+ow1F4qi0NzcjK6uLiQlJcHT03hbDzr8/vQdgyRJuDq7QPpQ8PGHBnHuk/fg4e2HA9/98aylQo49F2OjI1iz9yAiklNw/B9/Q/b6zYhMTqNlPgIT+gePjwyDzbZVt3EylVW7H8GVLz7BxoOP03I8U7h77iskL1up1YyWZWODqfEx2iNu2vAKCIJXQNCsx6bGx1BdeA93z50G28YWNnYccB0dERgZA7/gML2X2HM2bEVzVYVa+I8ND+H21yew6eATIKygctQYQmMTcO3LI2YTfNUFdyGVShBFs/0L08zmy4bQUlMJgsmE/4x8VIqiLD4PgiDg5OqOzsZ6uLh7GtQDe7i3G6c++cCMs9OONSzp6kIsFsNxht+iq6srDhzQ7+Z9YGBg3vWWxWLB1dUVAwPac8MPHTqEoKAg+Pr6orq6Gj//+c/R2NiIU6dOqY87U+wBUP+t67h0YD2/PCuExWKBoqhFE3wymQzV1dUQCATIzs7WmSiq7xiA8X5/+jBT8AX7+2J8ZBi3z5yAh68/9r34fa09Lm1t2ZgYHYGTmzsOff9nuHXmBBrKS7D1iedMTva343LVxzaUMx++jX3f+YFJ48+ExWJhenyMtuMZyySfj7GhQZ3tsNY/8hjyz5/GikXsMuHo7IJlm7bNekzpo1aE8tvXwWAQsOXYwtaOC9+QUARFxsJOQ1VeYGQ0KvJvIiYtE4PdXSi6fhEbDj5h1RerhWDZ2JitEKbi7k0AQERCMu3HtgZrFgDoaKiFRCyeZ86+GIIPUKa5+IWGo6upXu99RAIBFDIJPDwWbvFoDixVpWsMJElCLBbPq9L9xS9+gd///vc6962v1/8zmMsLL7yg/ndCQgJ8fHywdu1atLa2WrzX8Vys45dnpai+yHK53Kzr6qqxZgqx6elplJeXg8vlIicnx6D2NdpgMBhgMBhmXaZWCWOFQoGggAB8dOJzPPPvv16wpdHa/Y/h7tmT2HBAGflatXMfhvp68Omf/gebDj8N7zmRH0NYu/dRFF+/hFW79hu0X0X+LcSkZRndiF0bnv6BZl+KW4gzH7yNvd/5ns5tOPb2GBu2ng4hKpQ+aiuQtOybalGSJNHZWI8bJz+HVCIBm2MLWzt7uHp5Iyw2ETxXN4gEAnQ1N+JB0X319+zbjj2PB7lcTmvRU9nta2DZsBEcHUvbMWfCtFn8y05PazMm+XxEpSxutxIVw73dAIMBroMjCEL/92ewuxO52abnVhoDRVFWHeFTKBSQSCSzInwA8OMf/xhPPfWUzn1DQ0Ph7e2NoaHZ5z+5XA4+n681P08TWVlZAICWlhaEhYXB29sbxcXFs7YZHBwEAIOOawyL/8uzYlSCz1LdNlTjDA0Nobq6GoGBgYiIiKA1umjuSl2ViXRXVxd8fHzAIBV6uevbOzhganx81mOevv547Ef/D2c+eAvegcHI3bzDqPfCwdkZ/OFBg/YhSRIPCu/hwKs/MXi8hVixYy8uHflw0QTflWOfIXfTNr2EbGBUDLqaGxGoZ4unxYIgCITExCEkJm7W4yP9fSi9eRXj/BHwB/px5cvPsGzzdoMrkK2ViIQU1JcVISGLHkuOkhuXYcd1QIAZP28my2ZRhcJAdycGe7oQn5mreQMLR/hEgmn0dbYhLiMH48ND4Drx9NpPoZBjcoyP//jlv5t5hppRRUKtOcKnSfB5eHjoFRHNycnB+Pg4ysrKkJamTC+6ceMGSJJUizh9qKysBAB1FXVOTg5++9vfYmhoSL1kfPXqVfB4PMTGmucmS4V1SnMrgcFgWLS9mlwuR2trK6qqqhAXF4fIyEjal5LN/XpUOY99fX3IzMzEs48+givHPtVrX5uHOWNz2fnMS3Bydccnf/g1picmjJqXRCSCwgCLnbMfvoPVe+gp1JgLQRAaX6clGOzpgkIhR2CkfkneWWs3ob60yMyzMh/uPr5YvfcAVu7cB1cvbwRHRoMgCNw49QVunjqGwivn0d/ZDsrMdkXmwsPPHyN9PSYfh6IoFF45D3snZ7OKPQDgOvIgmDTud2wqowP96G5u0C72YNklXZIk0VBegpg0pYCYHOfrrPadyWB3F9w9PBZtmVB1HbHWCJ9cLodYLDY6FSomJgabNm3C888/j+LiYty7dw/f/e53cfDgQXWFbm9vL6Kjo9URu9bWVvzmN79BWVkZOjo68PXXX+OJJ57AihUrkJiYCADYsGEDYmNj8fjjj6OqqgqXL1/GL3/5S7zyyit6FZOYgnV+UlaEJc2Xh4aG0NPTg6ysLLN5KpnTfFksFqu/+PHx8XBycsKhgwfQUHQfowP9C+6/9pHDKLt9TeNz0akZ2P/SD3Hirb/hQdF9g+eWtHwlGivL9Np2cowPklSYtWrPPywCPS2G2T/QwZVjn2KNgRXHYpEQcpnMTDMyP1KxGFe++ARbn3weIqEAQRHR2PDIY1iz5wCy1mwEf2gQ1748gttfnUDpjasYMzAavJgwGAyTK9opisL9S2fh7OEN/xDziwdnd3eM9PeZfZy5TIwMo7m6Aok5lu9IoY3GylKExSepRZNMItEr8k5RFASTkwgNWrxqf9VKkbUKPtWSrimdNo4cOYLo6GisXbsWW7ZswfLly/Huu++qn5fJZGhsbIRQKASgNHm/du0aNmzYgOjoaPz4xz/G3r17cfbsWfU+TCYT586dA5PJRE5ODh577DE88cQTs3z7zMW3f03DzLBYLLObLwuFQvT3KwXR8uXLzZovaK4lXVVPXzc3N0gkklk5Rb/44ffx1j//gWd/+Rudx3DgOYE/qP1iy+Zw8NiP/g33LnyN0++9ie1PvaB3lWZ8Rg6+/uBtxKYvHIr/6p9vYs8LuvPbTCVn03Zc/PR9+IdHmnWcmZx5/22s2X3AYBPqZZt3oKbgLlJmeOl9W6AoCuc+ehcbDz4JgiAQn5GL9vpahMYlAAAIFgvxGdmIz8gGAEglYlTdu42x4WHY2tnDyc0NEYkpsHfUb5ltMXDx9MLkGB88I3pGUxSFu+dOwSc41Kw3ODNxcHJB64Nqi4ylYnpiHA9KCpG+at2C21KUZaK9fe2t4DryZvk/ymX6XWvGh4fAIAj89EfGd/4xFZIk1Sk81ohCodBYtGEIrq6uOk2Wg4ODZ0WEAwIC5nXZ0ERQUBAuXLhg9LyMxTo/KSvC3BG+kZERFBQUgMvlwtnZ2ezFIeaI8PX396O4uBjBwcFISEiY51+4Y/tWCMdGUF2Qv/D8mExMT4zr3GbZlh1YvmUHPvnDr9Hd0qj3PAVTC/dUrSnMR1RyBtgc8/qyEQSB6YkJiy0ftdU9AM/NzSj/P9/gUPS1t5lhVubn2vGjSFmxBpyHHljhicnomdNJYSZsWw4y1mzEhgOPYeWOPQiPS0LZ7eu4dvwI8s99hYbyEkglYktNXy8ik9NQU3DX4P0oksTtr0/ALyzCYmIPUN64WfI9FAkFqLh7c5b5t04s8JOcGh/D2PAgfINDZz2ukOsXSR8bGQLP0RHp6aZbVxmLtXvwyWQykyN8/2pY76dlJZhL8FEUhfb2dlRUVCA6Oho+Pj4WufjTGeGjKApNTU2ora1FcnIyQkJC1Hd8c8f46fdexe0zxyGTSnUec93+Qyi7fX3BsV08vPDET3+F4muXcf3E53q9dw5OLuAP6fY5qrp3BykrVi94LDoIiY1HZ2Od2cchSRIFl85h2eYdRh/D1s4Ok/xRGmdlfspuX4ezmzu8A4NnPS6ViPXO53RwdsaKbbuxfv9h5G3bBXcvb+Sf+wrXT36O+xe/RkdDnUG5oebAjutg8DmKJEncOnMcwdFxcPc2vteoMShzoy2zuCSTSFB26xrSV2/QW5xQZlZ8CrkczTUVGiuE9fkcRUIBGAwCXu6L2wbQmit0AUAgEADAkuCbgfV+WlaCObptKBQK1NTUoKOjA5mZmfDz87NYriBdET65XI6KigoMDAwgOzt7VtWTJsG3bcsmuLu64vqJz3Ue19HZBaODC+f7qdj5zHfgFxKGT/7wG0yO8XVuu3bfQVTlaw+3n/v4PeRZ0HMufc0G1JUWL7yhiZx46zVsOPi4SQVA6/YfRvmdGzTOyry01T3ASH8f4jVUr6av2ah3PudcPPwCsHbvQazb++hDAU0qC0BOKwtABjo7FsXHzd5B/zZrpEKBm6ePISwhGS4exhu5WztymQzFNy4jJW+NYcLEzB9ffVkRojWIPVKh0Gs5eai7C47Oznjp+efMMT29sXbBNz09DWBJ8M1kKYdvAegWYiKRCBUVFSAIArm5ueqqHEtWA5sa4RMKhSgvL4etrS2ys7PnLUNrEnwA8OyhR/Dndz7Qo7UYA4KpSXD1zJsKT0hGcEw8jv/jr0jKXYHE3DyN29k7OGJMS0/V6YkJyOVy+MyJBpkTgiAwPjJkVmPvmqL7CIyIhrO7acasbA4H4yMjFjEhNxX+0CAqbl/Hlsef1fi8b1AIKu/c0CufcyFCouMREh0PACDlctSWFaO68C5sOXbg8pwQlpAEF3fziyq/sHB0NtYhKEq3rYNCIceNU8cQm54FBydns89LGywzp66QCgVKrl9GYnaewR6F5hTsHQ11cPf21djKTyiYBmeBAhyFQgGpRAJbiQQbN24w1zT1wppNlwHldYogCHDMnJ7zbcJ65bmVQGfRBp/PR0FBAXg8HjIzM2eVYH9bInyq1+Dq6oq0tDSNOYfaxtiycSN8vL1x49QxnWOs3XsQ5Xos686ExWLh0e/9FBP8UZx69w3IpBKN20lEIo0Vp6ff+zvW7nvUoDHpIC5zmdkS2KUSMepKCpC2ai0txwuLT0JHfS0txzIXqorcTYef1r0hgwGpmN48MoLFQkJWLjYeeByrdu5DUk4eWirLcfXYZ7hz9hSq7t+BcNr4Nn+6CIqMQdsCn41cJsP1E58jPjNnUcUeAL2LrYyBokiU3LiC6LRMs+fiGgJ/aBBikQDuvn4an58a48PZVfcy7VB3J3yCQuDu4mSOKRrEtyHCx+FwrP4G1ZJY76dlJdAhxCiKQldXF8rKyhAeHo74+Ph5P5RvQ4Svu7sbZWVliIyMRGxsrNYfu64xHtu1DWy2rbp1kyac3T2Mtm3I2bAFq3btx5E//y+6mhrmPa9cRi2c9VhdaRHC4pNgy7EzakxTSF2xGk1Vxi0vLsSJt1/HxkefpO14aSvXoLGylLbj0c3cilxd5G7egToz+wuyORxkrtukLADZvgehMXEovXEV148fxZ2vT6KhvBgyieYbE0MhmEywdXh4yaRSXD/5OZKWrbSKimOWjS1I0jy50eW3ryM0LtGgZe45R6F1TgAgEYvR2VQ/r43bTETTuiN8FEVhenICcpkUj+5bvHaHKr4Ngs/Ozm5J8M3Aej8tK8HUHD6SJFFbW4uWlhakp6cjMFDzUqYlBZ8xCd51dXVoampCWloaAgJ0V/RpW9IFgE0b1oNJylFXUqgzwkJRJEQPczAMhefsisd+/P9Qde82rp84OmuJJio5dZ4QLLt9DWl62DWYC8HkJO1WOYXXLiI2PUvvZXF9kYrFWqOni83cilxdOLu5G9x9xVR4Lm5YuWMP1u0/hJU79sLV0xt3zp7C9ROf496FM+horANpwjnAwdkFUg2fjVQiwfWTnyM5b5Ve740l4Lm4YGxYc3qFKVTdvw3fkHCjLGpUUCS9go+iKNSXFSE2LVPndnK5XKeAGh8ZhqOLGwQTY8jLy1N7vy0W1r6kKxAIYGdn+Zt4a2ZJ8C2AKYJPZUQ8OTmJnJwcuLi4aN3WnIbIc8cxRFxIpVKUlZWBz+cjJycHrq4Ln0gXGuOx3dsREhOHq18e0brNmr0H9arW1cXmw08jOCoOn/7xfzA+I3dvpsv/hc8+RN7W3Yt6FxifmYvmqgrajiecmkRvWyviMujvsblyx15U3btD+3FNRVtFri7YtrYQ6mHVYy68/AOxbt+jWLfvUeRu2g5KrsC1E0dx89QXKLxyAYPdnQblk0UkJONB4b1Zj0lEIlw/eRRpq9Yu2M/akji5uRtUnKUPtcX34eLuBVdP0/qR0h3fa62pREB45IKt/BayZBkbHIC7tw+cuFzw+XwUFRWhsLAQzc3N4PP5Zm2ZqQlrj/CpBN9ShO8bloo2FsDYyNv4+DgqKirg5uaGuLi4Be+EVMug5k6KZzKZkOi5jDQ9PY3y8nI4ODggOztb7+TnhcTrxnVr8dnpr8HkOqGvo22eFxWgtF0Z7je9ZVRQVAz8wyNx8u3XEJWagbSVa+Hs4Ynhvl5weTyIRUL4WqC7gC7is5fh7IfvICqFHk+t0+++iV3Pv0LLsebi4ReAu+e/MsuxjUVVkbti226D9luxfS8Kr5xH5tqNZpqZ/hAEgdC4BLUhNCmX40FJAaru3QabYwcHJ2eEJ6bA2c1d6zFcvbwxOfaNdY5IIMCtM18ic+1GsGzMWyRhKA5Ozpjkj9B2vKbKMnDsuQYJfq3QePod7OkCwSTgtEBuHgDIdUTOxUIhQBAQTk9j+6YNSElJgVwux9jYGEZHR1FfXw+5XA4XFxe4ubnBzc3N7MUK1i74hELhUoRvDkuCbwGMKdro7e1FXV0dIiIiEBQUpJeAYzKZoCjK7IJP3wjf8PAwqqqqEBgYiIiICIPmpM8YT+7diZuNXbj11XE8+v2faTy+XC6HWCgAx960snomk4lHXvkRSm5dw/F//BUbDz2JwkvnMdDdgR1Pv2TSselCMDUJUqEwuAvGXG6e/hJpa9abNVnd3sER4yPDJlf+0sFCFbm64NjbL1pP44UgWCwk5uQhMUdZcS4WClGZfwuTY3zY2tnBydUdkclpsJvTJ1TVZk04PYXbZ04gc/1mg6tULQHLxoY2/8K22mpQJAn/MNO71ijPwfREykSCaQx2dSI2Y+FqcIqidJ4zB7ra4R8WgZG+bnzv1VcBKK9NHh4e8PDwULZaEwgwMjKCgYEBNDU1gcvlqsUfj8ejXZxZ+5LukuCbj/WdCawMQyJ8JEmisbERfX19SE1NhZub/saYqh+Oud3LF3o9FEWho6MDLS0tiI+PN6qnL5PJhGyB3qvr1qzBxye/j8ScPJTevIKMNfOjLGt2H0D5nZvI3bTN4DloImPVOsSmZuL0O2+APzSkXOaykpym5OWr0FBRapJVCH9oEILJSYTFJdI4s/ms2XcQN04ew5o9hvXkpRtVRe72p140+hhObh4YGx6Ei4cXjTOjH469PbI3bFH/PckfRfH1S5CKxeBwufD0C0BoXCLcffzQ09qMmsK7yN6wBYSFDI6NgckyvVK3q6kewikBIpKSTZ8QlN1HGDSE+EiSREN5CeIy9UurkIpFsNFSdEMqFJCKJSAIAk5crkYBz2Aw4ODgAAcHBwQHB0Mmk4HP52N0dBQ1NTWgKAqurq5qAUhHR6dvQ4RvyYNvNtb7aVkJ+ubwSaVSlJaWYnR0FDk5OQaJPWC24DMnupZb5xpCGyP2VGPoE0V8et8uSMUiNFdVQiwUzHve3ccXg92dRs1BG1weD4d/+G8Y7utCW90DlN26tuidEgAgOjUD7XUPTDrG2Y/exbr9h2iakXbYbA4m+SOLYjCswpCKXF3kbt6KhnLrrTzWBs/VDat27sOGA49hxbbdcHJzx+2vjqOtthrXT32O+OzlVi32AJgceextbwV/aIg2sQc8FDE0REQbyooRnpCk93dzemIcjs6a86MHe7vgExwKiUiE7Az90j5sbGzg5eWF2NhYLF++HElJSbC3t0dPTw/u3buH0tJStLe3Y3Jy0ujfsbULPpFIBHsruaG3Fqz307IS9BF8k5OTuH//PthsNrKzs436kqlakplb8GmzTFEVmAgEAuTk5MDJyXifJ30F35rVq9FdW4WtTzyHK8c+07iNQiaDWERvNdrN01/i0A9+ARs2G87uHjj+j7/i/MfvoaethdZxDGV6Ysxo8Xnhsw+wcse+BRPD6SI6NRNttVUWGUsThlTk6oLFYs8q4vm24hMYDK+AINg7OMLLPxDt9Q9QdPUi6koKIaH590MXpkT4hnq7MdDZgZgFKl8NhSQVIAjTlil721rg6OysXl7Xh6nxca2VxdMTE7DjcjExOoxf/OxnBs+HwWDAyckJoaGhyMjIQG5uLvz8/DA9PY2Kigrcu3cP9fX1GBoaMih96duwpLsk+GazJPgWYKEl0P7+fhQVFSEgIABJSUkm3bVawppFk6icmJhAQUEBuFwuMjMzTU72NaQS+LmDe9FSUwE22xYdjfXznl+5ez8q7t4yaT4zkcvlGO7vRUhMPBx4TrBh22LPC69i7f7DaKosxfE3/4rbZ05AJDDOEsYUMtdtRl1J4cIbzqGnrQU2trbwC7Vc8UliTh6aqyotNt5MjKnI1YVfaDj6OztoOdZiIJNKcfXLIyAIBrI3bAGDQSBl+WrkbNyG8IQU1BTcQ/G1y2iuqtBoOr5YsGyMO1fyBwfQ0VCL+KxcmmekXD5lMo2/LE6Oj2F8dBg+GgrRdCGXyTTerI2PjoDLU958O9hx4OCgv4jUhq2tLXx8fJCQkIC8vDzExcXBxsYG7e3tuHv3LsrLy9HZ2Ynp6Wmd0b9vQ4RvaUl3Ntb7aVkJ2iJ8FEWhsbERtbW1SEpKQlhYmMnFFosR4evv70dxcTGCgoKQkJBAyx2bIcJ1ZV4eeuuqsWbvQeSfPz3vBOPpF4DBrg6T56Tiyzf/glW79gMA1u0/hKJrFwEo3/vlW3Zh57MvIS4zF+c+fg9fvf8PPCi8ZzG7g/CEZI2iVxckSeLW6S+xYrvljVilUgmkNBkH60t7fa3WHrnGkrJiDVoeVNJ2PEsy0N2JS0c/RuqKNQiJiQcoalYGGsfeHpnrNiF7wxZ4Bwaj7NY1lN68is6meovbeMzFxtYWcqnUoH0mx/horCxDUu5Ks8yJJEmjl8LlchlaayoRlWx4tb1ciyULf3AAnr7+kEmliI+ONmpeuiAIAi4uLggPD0dWVhays7Ph6emJ8fFxlJaWoqCgAI2NjRgZGZl3TidJ0qojfCKRiBaB/K+EdSd5WAFMJnNemFsmk6GqqgoikQjZ2dm0faksGeGjKAotLS3o7OxEUlISPD3p6/dpqNffswf34mLBXaSvWo/8c6eRt33PrOdFQgGkYrHJladjw4NwcfeYZZHgHRiM9voHyovlQ3gurtj5jLJ6t6GiBJ/9+bdw9/VH5pqNcPfxNWkOCyEWCiCXy8DSc7nrzPtvYd3+w4typ71m1wFU3L2JrHWbLDIef2gQ5beuGVWRqwuCICAWCr4VfYJnUnbrGib4o1iz5xH1YxRFgaHlu+Dk5o6cjcoCqIHuThRduQBbOzv4hoTDKyDQ4q/dydUdo0MD8NLZV/sbBJOTqL5/FxlrzNdDljRymZKiKNSXFiEqNd2ocTV58IlFIvW/x4eH8B9vvW7UsQ3Bzs4O/v7+8Pf3h0KhwPj4OEZHR9HU1ASpVApnZ2e4u7vDzc3N7AWGprIU4ZuP9X5aVgKLxVL74wFKb7qCggIwGAxaxR5gWtszQ8ZQKBSorKxEf3+/+o6OTgwVfCvz8tBXX43Q2AR0NtZDODW73+jq3QdQka+9FZu+nP/0fazYMTsSlrtpm842b9EpGTj46k+xavteFF29gBNv/Q33L52lrSXWXLI3bEXNHPNcbTRVlsPd1w9u3sYV15iKq7c3hnq6LDKW3j1yjSQ6NROdjXVmOTbdSMViXDn2KewcHeeJbaVoXfi07h0QhGVbdiJ99QaIpqdRePk8Ku7emmVQbm6cXN3BHxzQa1uxSGlLY+6OOCSpMCoPtrOxDh5+/mCztbe304WmG/3B7k74h4YDADg2THh4WNYGiclkws3NDZGRkcjJyUFGRgZcXV0xPDyMwsJCjI2NYXh4eFFMn/VhSfDNZ0nwLcDM6tnBwUEUFhbC29sbqampsKG5AbglInxSqRQSiQQymYx2warCUMEHAM8/uh9V9+5g5/Mv4+xH78x6zico2OSLcX1ZMSISUjQ2bY9MSUN9me6+qiw2G+sfeQw7nv4OgqJicfKd13Hmg7fQWltFa7VqcHQsulsaF9xOLpej9NY1ZK3bTNvYxuDo5AL+AL0dE+ZCV0WuLqKS09DVvPD7vtj0dbTjypefIWP1BgRFzF/ioyjKYOPgsPhELNuyEynLVqK3vRWFVy6gpvAeBGbuQmLv6IipifEFt5NJJSi7eRXJeavNHlEiFaTBgo8/OACpWAx3b+Oi/3K5fN5HRpIKSMUiEEwmFHI5wkKCjDo2XTAYDHC5XAQGBiIlJQV5eXngcDigKAp1dXW4e/cuampq0NfXp7exvzmhKAoSiQSOjsb2U/7XZGlJdwFURRgtLS3o7u5GQkICvL1Na92jDXMLPj6fj5qaGjAYDKSnp5vt5GlMLmLe8uV49/PjSFq2As7uHmivr0VITJz6eblMDqlEorNBvC4q7t7Anhe/p/G5pJw8HPv7nxGdmqnXspaHjx/2vKA0Py29dQ0l16/AzdsXWes3m9TDU4WyX60UNjq8sk69/To2HXpy0Zcg1+w5gKvHj2DtvkfNNgZdFbkLIRGLoZDLLVbpbAgURaHs9nUIJiew+mEOqrbtCD0ifJogWCwkPMyNlErEqCnIh1QqgZOrG0LjEo3+7Wkdj8kEscDXVyGXo/jGZSQvW2URA2m5XG5Q9bBELEJXc4NJBSSCyQnYz+l5PdTTA+9ApcgbGx7EW79/z+jjmwMWiwWCIBAQEAB3d3dMT09jdHQU/f39aGxsnGX67OTkZPHzFEmSEIvFSzl8c7C+M5uVoRJFAwMDyM7ONusdgzkFX3d3NxoaGhASEoKWlhazt28zJsT/4uEDOHvvNtbsOYjP/vI7BEX9p/r9X7VrP8puXUPOxq0GH/f6ic+RuW6zztecvmYDKu7eQOqKtQYdO33VOqSvWgexUIhrx48CFIXg6FgkLVtptHBYtmUXqu7fQbqW5avyW9cREhsPR2ftvZktBYvNxtT4mNny3+iuyNVF+ur1aKqqQExahtnHMgSJSIibp48jLD4BMam650ZRJBZUUXrAtuWol08FkxOovHMDDIKAq7cPgqNiaRPFDB35ciSpQMmNy4jPXAYWDUbB+kAq5Hrn8FEUhfqyYsSaaA0zNcaH05yWedMT4+p8YSYohISEmDSGOVBV6TIYDDg6OsLR0VFt+jw6OjrL9Fkl/lxdXWkxfV4IhUKxFOHTwNKSrh4wmUwkJCSY/ctjjipdkiRRV1eHpqYmpKWlISAgAADMapprzJIuACzPzUV/4wNQFIW8bXtw78IZ9XN+oeEY6O4w+JhyqRRjI0MICNfddiksNgFttTVQKIzzwePY22PbE89h25PPw9HZFcff/AvOffwe+jpaDT6Wf2g4+to07ycWCtFa/wDJy1cZNU9zEJ+Zi4byEtqPa46KXF34hYRh0IjvmDnpbm3GtROfI2fDFvgGL2y7Q5EUCJqFN5fnhOyN25C1fgtcPLxQfO0SSm9eRU9bCygTc7dYWipiKYpE6c1riEpOB8fOcl5qCoVc74KplppKBEZEmWzULBGLZr3GCf4ouDxlxI8kSfh5W2cXGG22LDY2NvD29kZcXJza9NnOzg7d3d2zTJ+npqbMdh2Sy+VLET4NLEX49MDGxsYi1Uh0R/hkMhkqKyshkUiQk5MDe3t7dcWxOSusjBV8APDy44/iVP4tpOStRtGVC5haPqaOZEnFYshlUoMawZ/+55tYtfuRhTcEsHLnXhRdvYjcTduNmruKoKgYBEXFgCRJ5J//CjdOHoNfaDiyN2yFnZ5JxFKpFFKJGGzb2ZXJp959A9ufesGk+dFNbEY2zrz/Fq0muOaqyF0IiqIgk0i0trmy5DxKblyGVCzGqp37DNiPBIxc0tUHd29fuG/ZCQDobmlCwcNK36CIaLj7+hl8PKYGLz6KolBx5yaCo2PnLXWaG4VcAbbtwueXwZ4uECwWLSkccyt0Rwf6ERgRBQAYGxrEf//f/5g8hjnQx3hZZfqsMn6WSCTq6F9XV5e6MEQV/aNr2Z4kSUgkkiXBN4elCJ8eWKKYgu5xVNXETCZzVvcPlcgz5+sxRfBlZ2ejt165DLDruZdxdUYHjpyN21B9P1/vY/EHB+Do6qb3Sdk7MBh9Ha2QSelJOiYIAiu278Ejr/wICdnLcfbDt/HVe2+irqRwwTvbVbv2o/Lu7VmP3bvwNRJzV4Bjb32VZwqFHBKxaOEN9cDcFbm6WLZlJ+rLiy0+7kyEU1O4eORDuPv4ISVvtUH7WtJaJiA8Esu37ETaynXgDw+h4PI5VObfxtT4mN7HYLHmi6uagnx4BQTBydVdwx7mRbmkq1t0CKcnMdDViaCHosxU5LJvVhUkYhEw49ygkIqRlma4r58lMMZ42dbWFr6+vvNMn9va2tSmz11dXRAIBCZF/xQKBcRi8VKnjTksCT490LefrqnQZcuiKpv39vZGSkrKrLsmVc6FOcvoVcLVmB/swMAAchKiUXH3JtgcDlw8vNBSUwlAGTnrbmvS+1gXjnyAvG27DBp/86GnkX/+zMIbGgjPxRW7nnsFWx5/FlKJGF+89ntcPPIhRgf6NG7v5R+A/q529d+TY3yMDvQbZepqCdbsOYiKOzdMPo4lKnJ14ezugVE9rULMQUdjHW6e+RLLtuzU259uJrp8+MwFQRCITknHss07kZi7Au31tcpK34J8iIW627rZ2tnN6qNdV1oER1c3uPsYHi2kA8UCRRskqUBjRSmteZ6k/Jtry2BXl9qKhaIoONrbLXphljZM7bQx0/Q5OztbbRE2NjaGkpISnabPC6HK4VuK8M1maUlXDywZ4ZMa6Dw/E4qi0NHRgZaWFsTFxcHXV7NNgLk7eqhOAoZEGyiKQltbG9ra2rB/3z789Ne/A5W3Gsu37sSxv/8ZobEJIJhMiAX6GRM/KLqPyOR0vfNxVPBcXTHc3wPR9DTszHSyiE3PRmx6NuRSKW6c/gJioRB+oeFIX71hVmWuQiaHRCSCrZ0dzn70LnY//12zzIcOnN09MNjdafJxrnzxqUUqcnVhY2Nj1s9fExRJovDqRVAUhVU79F/CnXecRTaPZrFYSF6m7IIhFglRdf8OSLkczh6eCItNmFd84ezugZH+PviHRaC5ugI2bDZ8gxavQIFUKMBia78sNpSXIiIxhbabEYokoSCV52KSJCEWCdU5gROjw9i9Yb1VmhurvGnp7LShyfR5ZGREbfrs4uKiXv61s7PTeSyxWAy5XL7kwzeHJcGnB5q6bZhrHGOFGEmSePDgAUZHR5GZmQknJyed45gzwqc6Qel7B6iaO5/PR1ZWFng8Hr771GM4fucGUleuRd623bhz9hRW7dqPrPWb8aDw3oJFC9UFd7H3O5ptWBZi93Ov4PLnH2Pbk+bNlWOx2dhw4AkAymbwJ99+DfYOjojPWY7QmHis2XcQZXeUVhxZ6zbrtGmxBpzdvDDc1wsPI3K5AGXnCBcPT4tU5Opi+bbdKLlxBRmr11tkvOnJCdw+cwLxWblGe7mpoEjr6RbCsbNH1lqlMfQkfxSlt66CYLLg6eePwIhoEEwmHF1c0dPaDJlUArlUhtC4hEWds0IhB0Foviz2tDXDwdmF1pQKkVAI24fiZai3G14B30R1BRPjSE83rnOHuVFdP8wlRmfm9lEUBaFQiNHRUQwPD6O5uRl2dnbq552dnefNQyBQRo2XInyzsb5bByvEkku6xowjkUhQXFwMgUCAnJwcnWIPMH+ET3XXp4+olEql6rlnZ2eD97A6LTMjA4Mtyn6fvsGhGOzpxgR/FCEx8Qsa5F758jNkb9hi9Pw59vYgSdKiXQc8/QKw54VXsenQU+hrb8UXr/8JFXduoKmyDKRcgaCoGIvNxVhW7z2AqvxbRu3bUV+L0YF+JGQvp3dSRmDv4IhJ/qhFxmqtq8Gds6ewYusuk8UeoCzasMaIEM/VDbmbdiB7/RZwHZ1QePUiSm9exfjoMIZ6uzE1Pr7oYg9QRtw0vX+TY3xMjI7ANyiY1vGmx8fg5OL28N/j4D4sUqEoCl7u7lb5WQLmF3wz0WT6HBoaCrlcPs/0eXp6GgDU/zdW8PH5fBw+fBg8Hg/Ozs549tln1cfUREdHBxgMhsb/jh8/Puu1zP3viy++MGqOxrAU4dMDaxZ8ExMTqKiogIuLC+Lj4/UKsZs7wqeKMCz0WqamplBeXg4nJyckJCTMm/v3nnkCX9y+gbRV67Dj6Rdx/pP3sO+lH0AkmNZqkCsVizE5xoffwzwYY9n+9Iv4+oO31T11LUnmmo3IXLMRwulp3D3/FRgMAle++BQefv6ISkmHvYN1ekuxWCxMTYwbnNvDHxpE2e1r2PKYZStydcFzccX46Aic3cxTOECSJO5f/Bo2thysnNM72hRMMV62FF4BQfAKUJoK3zl3GoLJKfBcRagvL4arpzfcvX0Xz/xaQ3RULpeh9UEVErLptwcSTE3AzdsXk2N82M2w/ZqeGMfju3dareBTndsXY34sFguenp7w9PQERVFq0+e+vj489thjGB8f1/taqI3Dhw+jv78fV69ehUwmw9NPP40XXngBR48e1bh9QEAA+vtndxx699138cc//hGbN8/uhvThhx9i06ZvWiI6OzsbPU9DWRJ8emCtVbr9/f148OABwsLCEBISovdSjrkjfAwGY8FK3eHhYVRVVSEoKAjh4eEa556elobXP/gE5Io1YLFY8A4MRkNFCdJWrUdtSQESc/Lm7XPyndex4eDjJr8GFosFLs8Jg92d6ouTpWmuLMWOp19ETcE9rNixF8O9Pbh2/CgUchnsuI5wdndHdGomnN0t22NTFynLV6GxvAQx6Vl6ba+qyN3+1ItmnplhLNu6A7fPnETOBsONvhdigj+K/HOnkbRsJVw86O1jDYqixXjZ3JAKhXoJn81mIy4jByRJYqi3GzVFykp8Gxs2OFwuPP0C4eDkbJGl6rl1ZhRFob6kEFELGF4bi1wmA0EQGOnvR2DEN16h/MEB7NmzG42N1tnub6bp8mIy1/T5yJEjOHv2LI4dOwaFQgEfHx9s2rQJW7ZswcaNG+Hm5rbgMevr63Hp0iWUlJSol9TfeOMNbNmyBX/605805sYzmcx5HbhOnz6NRx55ZF6U0dnZ2WzduhbCOm8frAxLCT59hRhFUWhubkZtbS2SkpIQGhpq0A/P3BE+QLs1i6qwpLKyEnFxcYiIiNA59x889xTKb10DAGSt24ySG1cRGhuPzsb6edsO9/fCzccXDk7OtLyG9Y8cRtHVi7QcyxiaqysQnZKBZVt3ouDyeXgFBGLTo09i6+PPYc2eA4hITEXR1Ys49safcP6T93Hn65Po7+owq6n2QkQmp6G9vlavbSmKwtlFrMjVBYvFxvTEBO3Hba6uQMHlc1ixYy/9Yg/fjgifcHoad8+dRlhcIuy5XHXOJkEQ8A4IQmreGqTmrUFC9nIERcRgqLsTFXdvorrgLurLitHXTp910jyo2eesjoZaePoHma07hEIuh0QsBkXNPu/bPSwcsbbfhQpTK3TNhY+PD1544QW8/PLL8PDwwJkzZxAcHIw//elP8PLywrJlyyBcoHK8oKAAzs7Os/In161bB4IgUFSku+e6irKyMlRWVuLZZ+evWrzyyitwd3dHZmYmPvjgA4uer5cifHrAYrEgEtHjMaYLfYSYXC5HTU0NJicnkZWVZVT3D3NH+FRjzH0tJEmivr4eg4ODyMjI0CuUnZqSgr/982OQpPIHt2bXI7j11XEIpiZBKhQgZoTtr3zxKXY9/zKtr8Hd1w+dzQ0aG9Wbk5tffYn0tRsBAL5BIai8cwOjA/1w8/ZRb+Po7ILVM0ylpWIxyu/cQP650+DYc2Hv4IjQuAQERkYv6C1GJyRJQiwULJjcfv34UaQuckWuLrwDgjDY02WUPcpcSIUC+RfOwN7BEXlbd5k+OW3jkPS0VjMXg90daKwqR+a6jSAIJjoaaxEWn6x1ezaHg4ik1FmPjQ72o76sWFlRa2MDGzYbnv5BcHb3MDniNPPaOzrQD5lEArdw80Vj5HI5Brs74RcaoX5MOD2Fg/v3KcW7FYoqQD/T5cVEIBDA3t4eubm5WLZsGf7nf/4HfX19yM/PX9Cbb2BgAJ6es2/GWCwWXF1dMTCgn2XT+++/j5iYGOTmzu6x/Otf/xpr1qyBvb09rly5gpdffhnT09P43veMKzA0lCXBpwfWksMnEolQXl4OGxsb5OTkGH3XaakI38zXour6IZVKkZOTs2BZ/Ux+9MLT+PDSRWSv3wpP/wAUXDmP8PhE1JUWqttuVd2/g/CEJINtWBYib9sunHzrNYsKPrlcjvGRYfiFfNNKa9Php3Hq3Tew69mXtV7U2BzOrGIVkiRRW1KA0pvXwOZwYM91gF9YBMITkuZ18KCTdfsPofz2deRu1t6xpOz2dfDcPBa9IlcXGWs34uqXn5ks+MZGhnHv/FdIW70OPGfTOzPowppFQkNFCQQTE+rKXQCQSWUGz9fNywduXt/c+MjlcnS3NKCj4QGYTBZYbDa4PCd4BwTB1tC2bA8Vn0QkQndrE+Izcwzb30BIuQxShWKWV+rY0AC+/73vgc/nW+1naa0RPhVCoRB2drM9DF9//XX8/ve/x4EDB7TuV18/f+XIUEQiEY4ePYpf/epX856b+VhKSgoEAgH++Mc/Lgk+a8IacvjGxsZQUVEBb29vREdHm/Rjs8TrmSkqBQIBysrKwOVykZWVZXD7nOSkJIy9+776JLP9qRfw1fv/gD3XQS346kqLsOcF8/jUhcQloKmyDJEWMj2+8Mk/50WBCIJA6oo1KLt1Del62oUQBIGErGVImNGLtr2+Fuc+/icIBgN2Dg5w9/VHdGqGujqQDngurhjp79X6fEd9LUb7+5C3bTdtY5oDgiAgmJgwyduuobwEXU0NWLlzn0UukMq5WteFWKFQoPTGZbj7+iE+a3bEQy4z3ndUBYvFQkh0PEKi49WPTU2MoaWmChKREDa2trCxtYW7ly9cvLx1RqZISukvV19ehNhU+loFakIqkUAwPYWA8NkdO5gUBRaLBZIkFz1HThskSX4rInwz+fGPf4ynnnpK536hoaHw9vbG0NDQrMflcjn4fL5euXcnTpyAUCjEE088seC2WVlZ+M1vfgOJRAJbC7RzXBJ8erDYEb6enh7U19cjKioKgYGmLy+Z0vrM0DFGR0dRWVkJf39/REZGGn0C+/GLz+G9s2exbLOyci0wMgalNy6DJElcOWaaDctCpK5YgyN/+V9EJKWa/QQsnJ4Ey5YNJw3VoaGxCaguuIup8W/6CxtKSEwcQmLi1H8P9/fi+vHPIZNKYOfgAGc3D0SnZcLV07SG7e4+/hjs7prlKwYA/KEBq6vI1UV0Wia6mhsRFGlYhFchl+PWmRNw9vDEsi07zDQ7DVAkCCta0hVMTKDk1hUk5a7QWF0+t48sXTg6ucyqqiVJEv0dbaguuAOCQYBlYwM7B0d4+geC68ib9bturq5AUGSM2gDZXAgmJ0DK5HDgKW20KIrCBH8UMZER6jlbaxTNnL3Y6UAoFM4TfB4eHvDwWLjALScnB+Pj4ygrK1O3tbtx4wZIkkRW1sLFaO+//z527Nih11iVlZVwcXGxiNgDlgSfXlhS8FEUpf6hkySJxsZG9PX1ITU1Va8KI33HsUQO3/DwMPr6+hATEwN/f3+TjpeUmIixN99R5+2lr1yLgotn8aDwHkTTk/ANDqVp5prJWLMRVffvqLsImIvzn76PzYee0vr8tidfwNkP38GOp+mpavXw8cOmQ0+q/56eGEfpjStKmwguF1yeEyKT0uATrH8VOACs2LEHFz79ABsOPqZ+TCoW4+KnH2CXFXcMmUtsehYuHf3IIME3OtiPgkvnkLF2o/pibimUrdWsI/LS19GGttoqZK3brFEcSMQiMG3oTcHQBkEQ8AsNn2XXJBYK0N5QB8HUBFgsG9iwbTE+MgQbti3kUinGhofU33n1/x++DobyQQCMb5xcGAwwVM8yAMbD/8/aBgz1sfhDA2Db2aO3rQVyuRykQg7R9CSufVUNwLoFnzXPDdAs+PQlJiYGmzZtwvPPP4+3334bMpkM3/3ud3Hw4EF1hW5vby/Wrl2LTz75BJmZ30SCW1pacOfOHVy4cGHecc+ePYvBwUFkZ2eDw+Hg6tWr+N3vfoef/OQnxr1II1gSfHpgySVdQHn3pFAoUFlZCYlEgpycHFqbQJu7aIOiKIjFYkxPTyMtLQ2urvTkLf3slRfx9ukzWPHQt+zwj/4f/vmbf8N3fvNHWo6vi8jkVBx7489IzF4+q1CEToZ6uuDpF6Az74jFYiEiORU1hffM4gvm4OSMVbv2q/+WSiUov30Dd8+dgh3XAfaOPITExiM4OlZnIQhBEBBOTagFOkVROPfxe9jy+HNWfaHQhEQsnlcgpI3a4vvo7+iYVUxjSazlQlxbfB8SiQQZazZq3WZscBCefqavWBgLx56LmBl2K10tjejtaIFvSNjDzkoUKIpSpvVRJChA/TdFkep8P+phmzE8fB7Uw/0YDKUApyj1vni4ZKyQy9Hf2YHwxCQ4Oimj9UO93fjvX/4/dX6ztXyWmrD2JV1TBB8AHDlyBN/97nexdu1aEASBvXv34vXXX1c/L5PJ0NjYOK/i94MPPoC/vz82bNgw75g2NjZ488038cMf/hAURSE8PBx/+ctf8Pzzzxs9T0NZEnx6wGKxLNJaTfXjnpycRG1tLbhcLrKzsw3OeVsIJpMJmcw8SylyuRxVVVWQy+UICQmhTewByihf7//+EeSWnSCYTPBcXaGQK3DqnTewZu/BWUUO5mDZ1p0ovnEZ2evNs3x84/Qx7Hpu4Srj+IwcnHrndUQkJtPa5kkTbLYtstd/YxxKkiTqy4pw6p2/w4bNhr2DI3xCQhGVlAY2Z3YhSNqaDagrLUJ8Vi6un/gcKXmrrbYiVxcpeavQXFOJKB05nHKZFLe/PgkP3wDkbKLfu09ftHWKsBQKuRyFVy/ANygE4QnJOrflDw8gJGbxu2sAQMuDKsikEji5usPTL8CsYynkclTcvQnvwCC12JNKJHC152D/3r3q7axZ8Fn7kq5IJDKpj66rq6tWk2UACA4O1min8rvf/Q6/+93vNO6zadOmWYbLi4H1fmJWhCV9+ACgvLwc3t7eSE1NpV3sqcYxx+sRiUQoLCwESZJwcXGBjRmWa3777z9H/vkzAIAbJz/Hkz//DzBZLDwoyMe5j9/D1PgY7WOq8A8NR09rE2RS0xPN51JfXoKIhBS97VO2PfkCbpw6Rvs8FoIgCMRl5GDnM9/Blseewapd+2Fnx8W5T97D6Xf/jktHP0LpzauYnphAWGwCOpvqUXb7Bniu7lZdkauLwIho9He0aX1+qK8bl45+jKTcFQhb5PZgJEWplx0tzdT4GPLPf4X4zBz46nHzJZVIFj1KRFEUaksLwLJhKW9egkPMOh5JKlBbXAAmkwmfoG/GGuxsw5lTJ+dsa72Cz5rnBpgu+P5VWYrw6YEqh8+Uar2FUBkSA8pKobAw80WrzGHLMreKuLq62iyFIQnx8ej8r9+A3LoTU+NjcPfxxdYnnsOtr45j/f7DuPT5x3Dx9ELe1l1gmUFwrn/kMdy/dBYrd+xdeGMDqC64g93PvaL39mwOB95BwWiuKp/nU2ZpAiOjETgjx210oB83Th+DTCxCV0szelqaEJGQjPLbN+Dg5AwHJyfYO/Jg5+AAti3HaisRZyKTySCTSmEzxwqp6v5djPT3LtoS7lyoRars7G1rQUdjHTLXbdJbCMjNcONkCCRJour+bXgHhcDd2xd1JYVm7edLURTqSorg5OYGmeybFaPRgX78249/NM9my5pFlTXPDVgSfNpYEnx6oCqmMJfgI0kStbW1GBkZgY2NDW3FGdqgO8LX19eH2tpaREZGIigoSD2GuSqB/+8//h3/+94/4R0QDABw4DnBLyQc9WXF2P7kC+APDuCL1/6ImLQMpK5aR+tn5urphdGBPr2MhfXl/sWzSFm+2uB5ZqzegBNv/Q1B0XFgW6jKSx/cvH2w6eAToCgKJ995HVKRCIm5K6CQyzE2MoThvl5MjFZBND0FqVQCgiBAEEwQTAIEk/nw30wwWSzl/5ks2Dk4KMUi76FY5DrME1/mZPmWnagrK0LSw3Z+UokYt8+chF9I2Kwl78VG6cNnuagZRVGoLboPhUKO9FXrDNpXoTB/mozWseVylN+5gbCEJHXFu0RsPnN9iqLQUF4C35BQdDU1qivl5TIZPHhcHHhkv8Z9rFVUWbvxslgsntfSbIklwacXqmVVuVxOe4sdiUSCiooKUBSFnJwcFBcXW9QjzxQoikJLSws6OzuRnJw8qwzdnIUhiYmJqC++j+f/+/fqx1LyVuHkO28gMDIGrl7eOPDqT9BYWYovXv8DsjdsRUhMvI4jGsbWJ57DnTMnsf7AYwtvvAAkSaK/qx0Za+cn+erDpsPP4PaZ41j/iOlzoZuawnzEpGYiIDxSWX18+Gn4BYfBL9iw6DVJkpieGMf4yBD62tswNcaHcHoScplcLRIZBAEmkwmCyXr4fyaYLCaYTBtweU7qyKKdgyPs7LlgGpgq4ebtg+EL3QCA/q52lN28hpzN28DhWFdOIqlQWGxJVy6TofjaJQSER8DTQHNqmVS6aH6BEpEIFfk3kZC9XJ13KhYKaDdtn0lLdQXcvHwhmJyAy4zz5GBXO/7vv/4DtbW18PLygrOzs/p6Q5KkWVJ66MDaizZEItGS4NOAdX6brIyZ1bN0Mjk5ifLycri4uCA+Ph5MJtNilimmjqFQKFBdXY3JyUlkZ2fP+3GZu5vHR+/8Az/+z9/g8E9/qc572/38Kzjx1mvY88KrIAgCUcnpiEpOx+0zx1F26xrWH3gcTq6mR0/tHRwgFgkwOcYHz8W0opQLn75vkoegA48HLs8JnU31CIqMMWkudKJQyNFUVYZtTygr0FbvOYAbp77Aun2HDI5kEgQBnosreC6uCIxYePuZyOVyTI3xMTYyiI76XkxPjGF6YgIkpbyYfhNRJJRikWCCYCmjizY27IdC0RlcnhPAYKDg8jlIRCKrWcKdC2WhHL4J/igq795EyorVsOXo3zVHxfjwENx95jehNzfTE+N4UHIfyctXzRL9ve1tCIwyTzedtroacHlOcHJzQ31pC0JilTefY8NDOLxvD5ycnDA4OKg2+3V0dIS3tzekUqlZ8qDpgCRJq57bUoRPM0uCTw8YDAbtQmxgYAA1NTUICwtDSMg3HmeW6HNrqhgTi8UoLy8Hk8nU2uLN3K/DxcUFLz9xCB+983fsfen7YDAYIAgCuZu24d7Fr2d1qli5cz/kcjnOf/IuHHjOWLv/kMnLgdueeA4XjnyErY8bbyAslYgBUCZXBeZt243j//gr/EMjDI5cmYuCS+eRs3Gb+m9nN3fEZy1DweVzyN2kveUa3bBYLLh4eMLFw3PhjecglUoxMTqM8eEh9LW3YHKMj4HOdkSnZihz5axwuY2iSBBmjpx1NTeip7XJoHy9uYwO9iNwTocJc8MfHkRrTSVS8tbMm7doehK2HPq9PLuaG8Fi2cDdxw+97a1w91X6kSrkcjjbsfGzn/4UgPK7Njw8jIGBAYyPj6OpqQmAMjdaLpfDy8sLPB7PavJdrXlJlyRJSCSSJcGnAes7Y1kpdAk+iqLQ3NyMmpoaJCUlITQ0dNaP2NojfBMTEygoKICjoyMyMjK0LnGbu5sHQRAICgrCCwf34dqxz9SP+4dFQCGTobuladb2LBYLO595GelrNuLY639E6a1rGsvq9YXFZoNlw9LZQmwhzn70Hm3txdbuO4S7507TcixTEQsFGOrtntXvFAACI6Lg6umF6oL8RZqZYbDZbHj4+CEiMQXpqzfA2c0d+17+Adx8/XDrzEk0lJeAMnPHGkNRJtObr7Cs+v5dTIwOI23lWpPyyyRiEVgWzMEc6OpEZ2MdkvNWz5s3RVGQisW0j9nX0Qa5TAbvwGCQCgXGh4fg6OwMABjp7cLxo0fU27LZbPj5+SEtLQ0rV66El5eX+ia2p6cHZWVluHPnDqqrqzE4OGg2Wy19seaiDYVCAbFYDEfH+Z1d/v+OdX5iVggdQkwul6OyshJ9fX3Izs6Gp+f8qIOl+twaM8bAwACKi4sRFBSE+Ph4nT94Swg+kiSxfetmpIcFoPj6ZfVza/YeQOGV8w8jaLNxcnXDgVd/CnsHR3z55l/QXl9r9Bw2HXoK9y+dNWrf8ZFhOLm6wp6mHraunl6gKAoDXR20HM8U7nx9Emv2am5QnpCTB5FQgLbaGgvPyjRG+vtg+9BD0CcwGOseOQQ3H1/c+voEGipKrUb4mWtJVyaV4v6Fr+Hm44NIGqrCLVmh29VUj5GBXnXf7bmMDQ9pbGVoCkO9XRBMTsL/YWePnrYWtVXNxOgwnnv8sMYIFEVRaG1txfj4OHJycrBy5UosW7YMERER4HK5GBkZQV1dHe7evYvi4mJ0dnZCIBDQOnd9sGbBJ5fLIZFIlgSfBqzzE7NCTDVfFolEKCoqgkwmQ05OjtYvo7lz34wZg6IotLW1oaamBomJifOiktrGMKdwnSkof/C9V8EcH0RTZZn6+e1PP48rMyJ/c4lISMGe519FV2MDTr/3JsaGh7Ruq2sOrh5e6GltNnjfy198gtzN9PZYXbf/EO5fOmv2748uRgcHIJfLwdHRLWT5lh3oaKrHQHeXBWdmGlX3byMlb/Wsx7wDg7Fu/2G4eHnj1tcn0VhVZlLUmA6Uxsv0LuuPDw/h/sWvkbh8Bdy96cm7M4eXpSaaqysgEYkQlZKudZuhni740NiakT84AP7AoLodn0Iux+TYKDj29lDI5eAyGXjpO9+Ztx9FUWhsbMTQ0BDS09PVtiL29vYIDg5GVlYWVq1ahYSEBHh6ekIkEqG1tRVFRUXIz89HfX09+Hy+RX7/34Yl3SVblvlYR8LPtwBTBIzKo87LywsxMTE674ysbUmXJEk8ePAAfD4fWVlZ4PH0i0hZKsKn4vU//RGPPP4kHF1c4RMUAnsHHgIjIlFTmI+E7OVaj5O7eTtIksSlox+B48DF6l37wbblaN1+Lit37cPJt1+Hf5j+1QSdjfUIjIw2i63Isi07UXjlvEXz5GZy78IZrNt/aMHtNh58HGfefwt523arbTGsFYlIBJFQoPV36xsUAt+gEPS1t+LW1yfgFxyGiMSURcm3okgKDBqXdDsa6jDQ1W5SYdFcFAq5ui2ZuaAoCrUlBXB0cYPvAmbKErGItmjVxOgI+rs6EDGjy0hnUz0CIpTib6S3C9fPz18VoCgKDQ0NGBkZQXp6urq92lxsbGzg5eUFLy9lRH9qagoDAwMYGhpCf38/+vv7QRAEnJyc4OXlBTc3N9iawbLJmiN8CoViSfBpwTo/MStEZb5sKD09PSgtLUV4eDji4uIW/JFYaklXHzEmlUpRXFwMgUCA7OxsvcUeYHnBBwBffvoxbnz+sbrbRvLyVehoqMX4yPCCx9ry2DPIXL0Rp9/7B4quXTQoUhMQHoWWmkq9ty+8ch5pK9fqvb0h+AaHYnJsFGNDg2Y5vi46Guvg4uGp94Vg+9Mv4taZ42bJn6KTirs3kL56/YLb+YaEYd2+Q+C5uuHWmRNoqqqweMSPpOi5EFMUhfLb1yGYmpgX2TSViZERuHp50XrMmZAkiYr8m/DwC1hQ7MnlMijk9OTDTU9MoKu5YZbYk0klEAsFYLPZmOSP4vD+fXB+mMengqIo1NfXY3R0VKfYmwuDwQCPx0NkZCSWL1+OvLw8REdHg8fjYXx8HA0NDbh37x4KCgrQ2tqKqakp2r6P1iz45HI5xGLxkuDTgHV+YlaIoUKMJEnU19ejsbERqampCAzUz6fKUhE+iqJ0CrKpqSkUFBSAw+EgMzMTHI7+US/VGJYWfBKJBP/2g+/iy9f/CJlUAkApKq6dOKrXXBycnLHn+e/CzdMXX775FzRXV+o1l8x1G1F177ZeJ9PyOzcQn5Vr1ujP5sPP4NbXJy0qNiiKQtmta8hYo7+fIEEQ2PL4s7h6/AhI0vytC42BJEkM9/fC3kH/fCC/0HCs238IDs7OuHXmBJprKi33WdBQPSyViHHvwhn4BIcgPD6Jpol9w8hAP7xpXEKdiVwmQ+mtqwiNS4Kr58KicrCrE34hBnr9aEAsFKCttgpRybOXjjsbldE9UqEAm5LjRz/4/qznKYpCXV0dxsbGDBJ7muBwOAgICEBGRgZWrVqFlJQUeHt7Qy6Xo7OzEyUlJbh79y4ePHiAkZERk1KUrHlJVygUgqKopSpdDSwJPj0xJMInk8lQVlaG0dFR5OTkGNQ5w1IRPgBaRdDw8DCKiorg6+uLpKQko37YlszhA5QCNT8/HxKJBH/77X/j2Bt/Ut+FLtuyA/nnv9L72EFRMdjz/KsY6evGqXf/jtGBvgX3ic/OxYPCewtu11ZXg8jkNL3nYgwEQSBl+UqU375h1nFmUlOYj+iUDIP349jZY8WOPbhx6tii579porGiFGFGip6A8Eis238IXJ4Tbp05jpYHVWZ/jSRJgmAaf1rnDw2g8Mp5pOSthqunN40z+waxcNoshtVioRClt64iLisHXD0T9seGB+FkYmcjqViMhopSRM4Re2KhEHK5DCwWC8M9XTj22aeznld1WJqYmEBaWprBN9W6YLFYcHd3R0JCAlatWoWcnByEhobC1tYWQ0NDqKmpwd27d1FaWoru7m6IRIZ1GbHmCN/U1BQAZe7jErOxzk/MCmEymXrdEU1PT6OgoAAEQSA7O9vgL52lInzAfCNpVT/fyspKxMXFISIiwuhIlCUjfMPDwygoKIBcLkdqaiqSkpLw5//8d3z9wVsAAL+QMJCUAp1NDQaNkb56I7Y+/hwKLl/ApSMfQSwUat02Nj0bjVWlOl/zjVNfIHPtRoPmYCxh8Uno62xVL2+bE5XJclh8olH7u3p6Izo1AwVGVjybk46GWoPyMzWhFH6HweFycfvMCbQ8qDab8KMo0ujWau11NWiurkTWus1m6UOtQi6l31JkaoyvLKxZsQZstv7CSSaRmDSuXC5DfVkRopPS5gmg7pZGBIRHYWp8DPt3bp/ViUiVGz05OUm72NOEg4MDwsLCkJubi5UrVyI2Nhaurq6Ynp5Gc3MzCgoKcO/ePTQ1NWF8fHzB76c1C77p6WkwGIwlwacB6/zErBB9hNjw8DAKCwvh5eWF1NRUo9riWMJ4WfVDnSlOSJJEXV0d2trakJGRAR8fH2276z2GJQRfV1cXysrKwGQykZ2drY6mxsXG4vHtW3Dz1DEAwJrdB1By47LB+WIEQWDjwSeQs3kHvv7wbdy/eE7r68pevwVlt65pfE4ul2NyjA+fIN05RXSy7ckXcPVL7ZXKdDHXZNkYQmLiwXPzQNW92zTNynSGerthR5NtDgAERcZg7f5D4Njb49aZE2itpV/4kaTh/VcpkkT5nRsQS8RIXraC1vloQi6jt0J3dLAfDRUlGj32dCGcnoKNCQUNpEKBuuJCRCSkgJhzrhdMTQJQfrZMmQS/+NlPv9mPJFFTUwOBQID09HSzFFXogs1mw9fXF6mpqVi1ahXS09Ph7680hO7p6UF5eTnu3LmDqqoqDAwMQKqhotqal3QFAgE4HI7VmFRbE0uCT09sbGy0CrGZkbHY2FhERUUZ/WWzhC2LytBT9XpUS9Aq76e5ScXGYG7BByhFVF1dHbhcLnJycublbOzcvhUxPm6ouHsTALDtyedx9bhxAsie64Ddz30XfiFhOP6Pv6KhomTeNkFRMehsrINCQyT4/CfvYfmM7h+WgMViISo1A5X5t8w2hjaTZWNIyVuFqckJdDQY741IJ9UF+UhevpL24wZFxWDd/kNg23Jw+8xJtNXV0Cb8lFW6+p/WxUIh8i+cgV9oOEKj42iZgy5IkqT1vNDf2Y6u5gaDxR4A9He0ITDSuHZqFEmirqQQIbHxGg2ke1qb4RsSjuHuThz9+EP14yRJorq6GiKRCGlpabT3ZjcUJpMJFxcXxMTEYMWKFbM8/0ZHR1FfX4/8/HwUFRWho6MDAoEAFEWBogy/sbAUS4JPO9b5iVkh2iJ8qtB8e3s7MjIy4Otrmk+VvkvHpqISlgKBQL0EnZWVZVLS8EzMGalUCT1AKcT9/Py0XjB/8v3vQdLbjvb6B7B3cEBQVAyqC+4aPbZvSBj2PP8qJvl8nHj7NQz2zPaSW7vv0XlmzNOTE7C1s6Olj6+hJGYvR1tdjc7laFO48/UprSbLxrB61340VZZhuLeHtmMag1gohEQkNOtFLTgmDmv3PwoW2xa3z5xAW90Dk4UfRelftDHS34viaxeRunItnGk2HtbG1Dgfjq6m9Z9W0dFYB/7woFZD5YUQTk8bZMGkgqIo1JcXwy8sQmMf4Qn+KGzYbAinJrFt4zr1NYEkSVRVVUEsFluF2NPEXM+/xMREeHp6QiwWo62tTe35Byh7wS+m56c2BAIBbdexfzWWfPj0RFPRhkQiQUVFBUiSRE5ODi15GJaI8AFKQTY2NoaWlhb4+/sjMjKS1jsic70OsViM4uJiCIVC+Pj4wMHBAUNDQ2huboajoyM8PT3h4eEBLperfj1//8ufsPfwE+C5uCExJw9nPngbAeFRRvVXVZGyfDWSclfi5qljIEkFVu95BHZcB7j7+GKotxsSkQi2D086Fz97H1seM77nrqnsePo7uHLsU2x57Blaj6s0WZbpNFk2hq1PPo/T/3wTq3buhwPPidZj60v53RvIsFC+ZUhMHEJi4tBWV4PbZ04iKCoGwdGxRv0eST176bY8qMTY0CCy1m82ZspGM9LfB18a0hoaq8pAMFlGd/2gKAoyDZ149KG5qhwevv7galnu7+9sQ2B4FKaH+/Hf//EfAJRLoFVVVZDL5UhLS4ONGXMk6cLGxgaenp7w9PRUe/4NDg6ip0d5M/bgwQMwGAy155+7u7vFl6c1IRQKYWdntxTh08BShE9P5kb4JicnUVBQADs7O2RlZdGWdGuJog3gG1f3qKgok5agtWGOJd2pqSncu3cPQqEQMTExiI+PR3BwMDIyMrBixQr4+/tjYmICRUVFuH///qwE5OOffoTzH7wFkWAa2596AddPfm7y/AiCwNp9j2Lljn04//E/cff8VyAVCmx5/GncfVgVPNDVAa+AILDNnJStC1s7O3gFBs3qREIH9y6ewapd+2k9portT72IGye/UNvrWBKSJDHa3weOhZO+Q2MTsHb/o2AQDNz++iTa6x8YfpAFkulJkkTpzatQyBVIzMkzYbbGIZyaBNfReBFPURRqCvNh7+CI4KgYo4/DHxww6oavrbYGji6ucHLVHBHlDw3AjuuIoZ4uHPnwAwBKsVdZWakuKvs2iL25qDz/CIIAQRBITU1FTEwMnJ2dMTExgcbGRrXnX0tLCyYnJxet6l4gECwVbGhhSfDpyczWagMDAygqKkJAQAASExNpTV41t+BTObpLpVKEhYWpk3XpRuX1R9ePfnh4GPfv31efNOfOW9V8PDk5GatWrUJERASkUikqKytx584dNDQ04P03/opjr/0BFElixfbduHvuFC1zY3M42PnsywiJjsfxf/wNHQ11EEyOY3piHNdPfo6sdZaNomgic81GPCi+T5uAUpose5ltyZPFYik9+o59ZvFlo/qyYkQkm94v1ljC4pOwdt+jIAHc+uo4Ohrr9d6XoigQWs5HIsE08s9/pYwgmiCWTMGUlmqkQoHyOzfgHRQK78Bgk+Yx3NcDLwOP0dXUADabrTVflaIoDHZ3gevoiPUrlyMwMBAKhUK9CmRsIZ+10Nraiu7ubqSlpcHNzQ3+/v5IT09Xe/75+PhAoVCgq6sLpaWlas+/oaEhyGT0V2ZrQ5XDt8R8lgSfnqgEX3NzM2pqapCUlISwsDDaI2PmFHxyuRzl5eUYHh6Gg4ODWZ3INVUCG0tnZyfKysrAYrH08jVkMpnw9PREfHw8VqxYgYSEBDCZTHR0dOCFwwfw5d//DK+AIDAYDHQ26X8xXQgv/0DseeFVyMQSSCUSfP76HxCVnKb1AmxpNh9+GjdPHzf5OBRFoejqRWTo0X3CFOy4XCzbugu3vjJ9zobQ1dQAXzMZAxtCZGIK1u4/BFKhwK2vTqDLQFuhmQz1dKP0xhVkrFkPngs9OXTGIDfywi+TSlF66yoiklLg7G56vqGh+Zl97a2QK+TwDAjSus1wfw8cXVwhn57E//32t+rzLYBvvdhra2tDd3c30tPT5xXHqTz/4uPjsXLlSuTm5iI0NBQcDgdDQ0Oora1Ffn4+SkpK0NXVZbDnn6GIRKKlLhta+PZ+Ay0Mg8GASCRCX18fsrOz4ainsaehmKvYQSQSoaysDLa2tsjOzkZ5eblZI4mqqKcp5fuqbiXd3d1wcHBAamqqwTkiBEHA1dUVrq6uiIyMxPT0NFg2Nvjy439i21PP48s3/wLvgGB1vh0dxGctQ3RaFv7ywxdRU3QfI/19SFy2Ah4+frSNYQwOTs7g8hzR2VCHoOhYo49TU5iPuMxcGmemHXcfX4TFJ6H4+iVkrt1k9vEGujvhQEOVOp1EJKUgIikFTVXluPXVCYTGJSAwIkrjtpoi6k2VZZgc5yNznfnfP11QFKXso2sgIoEA1fdvIyF3BS39p+UyGUiF/jeigz1dEExNIihSe1SUoiiM9PWC6+CIzz54Ty32mEwmkpOTrdbCRB/a2trQ1dWlUexpgsvlIiwsDGFhYZBKpRgdHUV/f786Z7ylpQW2trZwd3eHl5cXnJycaA2cCIXCpSVdLSwJPj1hsVhgMBjIyckxa3UVk8lUtz2ja7lsbGwMFRUV8Pb2RnR0NAiCsEgnDMD4CJ/qhDk2NgZ3d3dals4ZDAYcHR2xZ9cuiCVS3Dn/FbY/9SKuHPsU2598waRjz+Xcx+/g2V/+BvcvnUNgZDRqCvIxyR8Bl+eMiKQUBEXGLEpS8Yrte3H8H3+Ff0QkmEzDf/4KhRxNleXY9uRzZpidZsITkjDBH0ZdaRFi07PMOtaDovtIX2PeyKWxRCalIjIpFQ0V5bh15gRCY7ULP0B5s1V26xpcPb2QYGQlK50IpiZhzzXsRnlybBT1ZcVIXrGGtvPhQGc7/MP1M9Me6e/D+PAgQmISdB+zqwNcnhNWZKYjODgYZWVlsLGxMbpTkbXQ3t6Orq4upKWlGdWqjM1mw8fHR73cOzk5icHBQQwNDaG3txe9vb0gCALOzs7w8vKCm5ubyddXkUi0JPi0sCT49ESVaGvuUvqZbc/oOMH19fWhtrYWkZGRCAr6ZjnC3NXADAYDDAbDqDFmVuIGBgbSXkEMAIcOPIK23/8RbXXVCI1LROW920heRo/nWmX+LQRHx4Hn4opNjz6Bk++8gRXb98LV00tpulp0D+W3r4PryINfWCRiUjPAtOByz5q9B3Hn7Cms3vWIwfsWXD6PnE1bzTAr3aStXIfbZ46js6kBQUZ6py2ESCCARCyyWn8xFdEpqYhOSUV9eQlunTmBsLhEBIRHAvgmwiecmkLJzStIzF4GexrNo01hdKDfoKXykf5edDbVI3XlWlrnMTE2ijDfhaPt4yPDGOzuRERiis7tSJIEf2gQrk48/P53v1WvpNCd321p2tvb0dnZibS0NFpWtFSefy4uLoiOjoZIJMLQ0BAGBgbA5/MxNjYGiqLA5XLVbgvGiEyRSLTUR1cL1n1msyJUtizmrjyauRRqChRFobm5GXV1dUhOTp4l9gDLdfQwVPCpeuIKhUKTTawX4pc//ylGG2vg4u6B7pZGjA0PmnxM4fQkupobEJeRrX5s9/Ov4OqxTyGcngJBEEjKycP2J1/Amj0HweHY4cwHb+PCZx+g5MYViIUCk+ewEG5ePiBJEv2d7QbtJxYKMNRDj8myMazcuR+NlaUY7jOPR1/5nevIWLvBLMc2BzGpGVi771GIhALcOnMCPa3NAKWMNpXfuYbMtRutRuwBwPT4GJz09PvrbW9Fb3srEnPp7/wh1SOHbHpiHF1NDQuKPQDobW+BDYuFN1/7K8rKysDhcP4lInt0ij1N2NnZISgoCFlZWVi9ejUSExPh5eUFiUSC9vZ2FBcX4+7du6irq8Po6Kje15KlHD7tLEX49GSmEDNn8i1BEGAwGCaJMYVCgZqaGkxMTCA7O1vj3Y4l/P4MFZXDw8MoLy8Hg8FAWloaXGkyaNXFu6//DbsPPY61jz+Py59/gr0vvGpSkcWpd/+O3c+9POsxgiDwyCs/xIl33sDu514Gy+abKHFQVAyCHlZM8ocGcPnYp2AyCDi5eyAhezmc3T1gDjY88hiOv/lX7Hr+Fb0jWnSbLBvD1sefxal33sCavQe1+qAZA0kqwB8aoN1T0BLEpGUiOjUD9y58jY6GWthy7JCzcavVRSplerZUa6t/ALFIgNgZN010IZicXNAiSSSYRuuDasSkZS54PIVCjrGhASTGxmKMz4e9vT0iIyOt7r03hI6ODrOLvbmwWCyNnn+qCODgoPJmnMfjwdvbG25ublorcZcEn3aWBJ+eqESeuQUfYFqlrlgsVicL68o3tESEzxBR2dHRgYYGpe1Benq6RX+wxz/5EFsfOYRV+x7FnXOnsGqncd5yN7/6Ejkbt2q8oLDYbGx74llc+OxDbHvyeY0XBFdPb2w59DQAQCycxr2L5yERC2BrZ4/EnDzaK0dzN29HwaWzWLZl54Lbmstk2Rh2PPsSzvzzTWw+/AwtSfwAUFtShKjUDFqOZSkkYhFaa6owOjgAsVAI76AguHv7IjF3OR4UFUAuk8LWzh6+IaFw8/JddCNafXro1pcVgc3hICJh4ciaMfR3tiFAR/GFRCxCY0UZovX8LnS3NMGRy8X3v/sKbGxswGQycf/+fTg4OMDd3R0eHh7g8XiL/t7rS0dHBzo6OpCammoxsTcXlecfj8dDREQEJBIJhoeHMTAwgImJCUxMTAAAOByOWiQ6Ojqq3+MlwaedJcGnJ3RE3vTFWME3MTGB8vJyuLu7Iy4uTuddpiUMnvVZ0iVJEnV1dejp6YGDg8OitBxisVg49sG7OPTid+EdHIqO+loExxjWV3SgpwukQqEzid7ByRk5G7fi+snPsX7/YZ3H49g7YO3DaJpcLkfZ7WsovHIBDjwnhMTGIyw+yeQogl9oOCrzb2F0aABunt46t7134QzW7T9k0nh0wWKxsPnw07j65WfYdOgpWqIp3S2NWL51YeG7mFAUhdHBfrTX1kAwNQmKpBCXmYOw+CQAQEd9LXxDQmHvwEPmwy4hJEmivf4B2uuuwsbWFjwXVwSERcJmEToiKGTaK3SVhsr34ObjA0+/ALPNQTg9rfX8IpfJUF9ajOiUdL2+U3KZFKN9vfiP//cLuLi4qM+5MpkMIyMj6hULgiDU4s/Nzc1ql3o7OjrQ3t6OtLQ08HjWkwpga2sLf39/+Pv7Qy6XY2JiAgMDAxgZGUFXVxe6urpQV1eHGzdu4JFHHoFQKDRarP72t7/F+fPnUVlZCTabjfHx8QX3oSgK//mf/4n33nsP4+PjWLZsGd566y1ERHxTGMTn8/Hqq6/i7NmzIAgCe/fuxWuvvWbxXMMlwWcAluqCYUz0bXBwENXV1QgLC0NISMiCd5QEQUBqggmqPiwk+MxRiWsszs7O+PN//xK/+vPrKLp2Ed7BIXpHs0iSxJ0zx7Hzme8suK13YBBCx+Jx/9I55G7aptfxWSwWsmZYkjRUlOL0u3+HvaMjvINCEJ+ZAxu2cRfwzY89g1PvvI5dz72i9TvT0VgHVy/zmSwbg70jD1kbtuDmqWNYu+9Rk47V19EG3iL0OdYHuUyGtroaDPd2QyQQwtnDE7GZuRpXGbpbm5G+anaBA0EQCItLRFhcIgBgcoyPB8X3QVEkbO3s4RccBid3D7NHoMRCAdga+s4CDztR5N9EUHScWftNkySp1XhcoVCgtqQQkUmpeqd0dDTWIyEuDllZWYiN/aYVno2NjboylSRJjI+PY3h4GE1NTZBIJHB1dVULQGsxCO7s7LRKsTcXFosFNzc3tRerQCDA4OAgLly4gBs3buDmzZtQKBQYGhoCm83Gzp07DWouIJVKsX//fuTk5OD999/Xa58//OEPeP311/Hxxx8jJCQEv/rVr7Bx40bU1dWpP9/Dhw+jv78fV69ehUwmw9NPP40XXngBR48eNfxNMAEGtVj9T76FXL58GUlJSXBxcTHrOPn5+YiMjISn58KtfyiKQnt7O1pbW9VJr/rQ1taGqakpJCUlmTpdrdy/fx+hoaHw9p4fPZpZiRsUFISIiAirWPa4cvUaPr1wDYLJCex67hW99jn78bvIXLsRrp76vfcAUHrzGggmE0kmJqX3d3Wg7NY12Njaws3LB0m5eQYn6jdXV2B0oA8Za+b3jqUoCqfefQNbH1+8XsC6aKwow+hgHzJWG19sce34UWSuX1yPuplM8EfRUl2B6YlxyGUyRCanLRj14g8NorWmEvFZ+vsjkqQcTdWVGBsYgI0tB84eHvALCQfLDK2/ettbQDAIuHn7znpcJpGgIv8WYtKzzN7Kbri/F9MT4/CZ02GDIkk8KC5ASHSc3i0QJSIRagrv4vxXpxEXF6f3uUsgEGB4eBjDw8OYmJiwiqXfzs5OtLW1Wb3YW4jBwUE8+uijKC0tBZvNhlQqBUmS8Pf3x969e/Hyyy/Pirrp4qOPPsIPfvCDBSN8FEXB19cXP/7xj/GTn/wEgHKlzcvLCx999BEOHjyI+vp6xMbGoqSkBOnp6QCAS5cuYcuWLejp6YGvr6+uIWhlKcJnAJaK8Omb+0aSJB48eAA+n4+srCyDfqyLmcM3OTmJ4uJiKBQKxMbGws9vcQ2JZ7Jh/Tp09vTg3J0ClN+5jtQVui0h6suL4RUQaJDYA4D01etw68xJtDyoRHh8stHz9QkMxrYnlJ54U+NjuH7qGChSAZ6zKxJy8uDmvXBFbURiCmqL72NqfAyOzrNvZmoK8xGdYr25bVEpaSi+PoKG8hK9865mIpyeglgkNMPM9IdUKNDZ3ID+jjaIpgWwd3REfGauQf2XGytKDO6NSxAsRCenq/8eHexH1f07YDAYsLPnwi8sgrauHBMjIwh9GGVUIZyeQk1hPhKXrbRIF4rRvl4EzmkpR1EU6suK4R8WadD73dlYi9/+938ZJPYApSkxl8tFcHCwVSz9dnV1oa2tDampqd9qsSeVSvHLX/4Sra2tqKmpQXR0NCoqKnD8+HEcP34cr732GgICAvCjH/2I1nHb29sxMDCAdevWqR9zcnJCVlYWCgoKcPDgQRQUFMDZ2Vkt9gBg3bp1IAgCRUVF2L17N61z0sWS4DMAlTWLudFHWEqlUpSXl4OiKGRnZxu8NLBYOXxDQ0OoqKgAg8FAamqqRSpxDeX5p59CV18/7ubfRlBkrFbRJJWIUV9WjO1GmhCv2rkXF498CHsHHi0FGY7OLth08Anl3KRSFF4+h6lxPrg8J0QmpyMwQrvFzbYnnsfXH72Dnc+8pH5MabJchm1PPm/y3MxJ5tqNuHHyC3CdnBEQpt8dvIryOzeQvWGLmWamHeHUFJoqyzDBH4FMKkVwTBzSVq5beEcNSERCyCQSk5fc3bx84LZe+V2Xy6VoKCtFU2UZ2BwOXDy84BcSZnQFu0wqnTW/idERNFWXIzlvtcVSBTR5LDZXlcPTLxBcA3K+hFNTcHHg4vChQyZF5LQt/arad7q4uMDDw8NsS79dXV1obW1FamoqnJycaD++pZDJZPjRj36Eixcv4vbt24iJUYr61NRUpKam4n//938xMDBglpW5gYEBAJi3subl5aV+bmBgYN5qHYvFgqurq3obS7Ek+AzAkhE+XeNMTU2hvLwcTk5O6j6xxoxhCVuWmWO0t7ejsbFxUSpxDeU3//5veO7V7+PsR+/giZ/+SuOF7usP38aGg4+bNM7mw0/jyzf/grV7H4Wz+8JL+PrCZrOxYvseAMpIcPX9uyi7eQVcnhMCwqMQlZo+q9MGi81GRGIyqgvuqiNFhZfPI3uj5U2WjWHN3oM4+9G74Do6wnWBAhQVCoUCY0ODBkV2jIUiSfR3daC7pRGCyUmwbGyQkJ0HexqStmuLC5C0nF6/OhaLPWt5eKC7E+V3roNg2sDewQEBEVEG2eLMrNAd7utBd2szkpevonPKOpFJpSDnZC+11laD5+IGnh43nSRJYqinG/yhAUgFU2isq6V1+XVmC8ioqCj10u/g4CAaGxtpX/r9VxJ7P/vZz3Dq1CncvHkTCQnzO6L84he/wO9//3udx6mvr0d0tHkM3a2JJcFnAEwmE3K54b0gjRlHm+AbHh5GVVUVgoKCEB4ebvQP35LGy6pK3N7e3kWrxDWGd1/7Kzbt2ovLX3yCzYefnvVcwaVziM/MhZ296aJ130s/wIl//A1bn3gOHBqONxeCIJC8fCWSlys7ibTXP8CZf74FW3suPP39kZi9HLZ29kjIzsOJt/6GyKQ0ABQGe7qRtsq4qNNisPWJ53D6vTexbt8hvYRUbUkBYjLM16pNIhKipaYK/MEBiEUC+IWEIzFnBa0RLVKhwAR/BGy2eUWrd0AQvAOU5u1SsRi1pYUQCwRgczjw9A2AZ0Cgztcll8kAAD1tLRgbHkRCtmVbvfV3tqm7kQBAZ1M92Bw7uHppvzmgKAoTI8MY6e+FQi6HrT0XmalJ+Oif/zR7rp05l367u7v/JcSeXC7Hr371Kxw9ehRXr15FSopmK58f//jHeOqpp3QeKzTUuBUWVX764OAgfHy+WQkaHBxEcnKyepuhoaF5c+fz+Rrz283JkuAzgMVc0qUoCp2dnWhubkZ8fPysL5exY5g7wsdkMiGTyVBSUoLx8XG4u7sbHZFcDAiCwNdffo7sVWsQnpCsdt0fHxnCxNgo0tfQI4YIgsCuF17BV+/9AzufecksSfMzCYmJR0hMPABlu6uLRz4Ck8WCs4cnVuzch2snjoLFYi26ybKhEASBnc+8iK8/eBubH3sGLJbu97GnpQnLt+2ibXyKojDS34eO+loIp6cAUIjNyEF4QjJtY8ylsbIUUTPy8CwBm8NByozoXHdLE8puXQXLhg0uzwmBEdGzCjCkYjGYLBu01dVAJpUalWtpKpP8UXXhS09rMyiSgleg5kIY4fQUBjrbIZWI4ebpg6jUDHQ11mH35g342U9+YvHCCjqXfru7u9HS0oKUlJRvtdhTKBT49a9/jQ8++AAXLlxAdrZ2k27Ve2MOQkJC4O3tjevXr6sF3uTkJIqKivDSS8r0mJycHIyPj6OsrAxpaWkAgBs3boAkSWRlmbc3+FyWBJ8BLNaSLkmSqK+vx+DgIDIyMuDs7GzyGJaI8JEkic7OTsjlcquqxDUEDuf/Y++845u47///kmzLe1uWBzZe4L0Xe28ImJUdIGmzGpIvGb+sZjQJIUmTtGSTNoMAIYyUTdh7BbDlvfe2hmVZ1h53vz/oXW3jJVuyJEfPxyOPFvl0+ugk3b3uPV5vB5w8dAD33PcggiImwsHJGaf27BiSBYs+sFj2WPzQBhzd/i9k/fkvo3acvP386Q5chUyKayeOoKm6AoROBzuWPVw9PcEOGAcvXw7szcB0eTBs7VhYcP96nN2/GwvvX9fvcWyuqYKnno02faFRq1FbWoj21lYo5FJ4sf0QlzEZzFGajcxrakBIZMyovFZ/BEVMpKNncqkUpdm/Q61Ww97BAX7BIdBptZBJxHDz8kRY7N0pt9FA818LKl5TA5Ry+V1+mVqNGs011VDIpXBwckZEXCKYtrbQatSoKcjFu2+8hiWLF5ti6T0YLPXr7OxMC5zeqd/uYs8Q1xBTodPp8OGHH+Lrr7/G0aNHMWOG4coZGhoaIBKJ0NDQcMcuKC8PABAREUF75kVFReGDDz7AypUrwWAwsGnTJmzevBkTJkygbVkCAgKQlZUFAIiOjsaiRYvw+OOPY9u2bdBoNNi4cSPuv//+Ue3QBayCTy9GK8LXXYxpNBrk5eVBrVZj8uTJcHTs28tKX4wd4ZNIJODxeCBJEj4+PiOOSJoSNpuNTU/8CTv/9QVcPDwxZfE9sDHCBd3VwxNTFi/D6T07sPCB9Qbf/2A4Ortg7uoHIBV3gB0YBGmnGH7BoWiqrkTBjSvQqNSwtbOFja0dbO1YsLNnwdHJGT4BgfDm+MPZzd0sBL2LuztSZ8/H5WMHMPOe1X1uU5JzE5nzh3cBF7cLUVNUAFlXJ7QaDSKT0zB+4uiLrqbqCnACg0f9dQfCycWFLgMgCAI5l86iqaoSzm7ukIhEkHZmg8m0gS2LBWc3Nzi7usHB2blHPamhkXaKYe/khPa2VnQKhQiJiqHXJ2hpQqdQAJIEwuMTenhvSiWdEDfX46d/fYPYWP2M2EeLvlK/QqHwrtSvQqFATU3NmBB7n376Kf7xj3/g4MGDmDt3YBcFfXnrrbfw008/0f+m0sQXLlzArFmzAADl5eX0tA8AePnllyGTyfDEE09ALBZj2rRpOHnyZI9o688//4yNGzdi7ty5tPHy559/btC1DwWrD58eFBUVQaPRICbGuCf3yspKKJVKhIWFgcvlwsnJCYmJiQa1LqCsUbq3kxuK7p24wcHBkMvlaG9vB4vFApvNhq+vLzw8PMxCHAwGJbhJksT1m7fx868H8NDzr8LViF6MpdzbaG9rxeQFo98wkX3xLFw8PTB+QhQaqypQ9Ps1zF3zYL9pZoVMiqaaKrTV10Im6YSNrS1s7ViwtbODHYtF+wN6+wXA3dtnVNP5xTk3IRWJkDJjTo/HpZJOXD1+EFMWLx/SfnQ6LRoqysBrbIBCJoWTqxvi0ifD1sR1qFePH0LqTMNe8AwBSRKoLS1GW0M9PLx90CEU0PWjFGqlEuJ2IcRCAWQSMUgdAYYNEwwmE0ymzZ3JRkwm7FgsuHh4wtnFFQ5OzsPqEq4qyIOjqyv4TQ0Ii4mHpF2Idn4bNCo1AsMi4OHjc9dzhC3NcLEFPvvkY4SEhAz3UJgMKvUrFArR2toKtVoNd3d3+Pv7w8fHx2CBg9GEJEl8/vnnePfdd7Fnzx6sWGHek3HMEavg04OysjJ0dXUhISFh8I1HQE1NDQQCAaRSKcaNG4eJEycaXBzJZDJcu3YNCxYM37C2L2pqalBRUXFXJ65Op4NIJAKfz4dAIACDwaBTD97e3mY1xYFCLpcjNzcXLi4uiIuLg42NDf7x2ef47qediIhPwqT5i8EJMk6E5fb507C1s0fC5GlG2X9fdIk7cP7Anh6dx1KJBOf278asrLV3efQNBa1Wjba6OrTU10Is5AFgwtbOFiBJ2Nnbw97BCe7ePmAHBMKTzTF4x+yN08fh5uH530aUO1w5fhDR6ZPAGmA6iUzSiarCfHSJO6BWKhEaHYuA0HCDrm0kiNuFKM+5hYQp+nnvGROtVoOKXC46hDyExsSBHTAOeVcuYmJy2rBvVpUKOcQCATrbhZBJOkGCBJPBBMPmf8LQxsYWLAcHOLm5wdnFDfZOTj3OJ7lXLkClUMDJxRVqpQIebN9+bZBIkkRTVTky4mPx/P89h/Hjxw9r3eZCU1MTKioqEBMTA6VSCaFQCLFYPGDq1xwhSRLbtm3DX//6V+zYsQP33nuvqZdkkVgFnx5UVVVBKBT22w1kKPLy8tDW1oa4uDi9xsLog0KhwKVLl7Bw4UKD/NgJgkBxcTFaWlrg4uKClJSUfjtxqbtPSvxpNBr4+PjA19cXPj4+o2LCOhidnZ3Iy8sDh8NBZGRP/7rrv/+Ot/7+T3hx/KBVqxGTnkk3QRiSC4f2IzB0AsJHqe7pyPZ/YfaqtXc1OxAEgRO7fkDC5BkIDIsw6GsSBIEOAQ+NlRUQtjZDq9XA1vZO2tjO3h52LDs4ubiBHRAIL44/nFxc9f6+ntm3GxPikxAYFg6dVovffv4RM1f0TPWSBIHmuho0V1dCKZfC1s4ecZlTjT79Ybj8fvo3xE+aahY3Sgq5DOXcbMikEsSmT4Kz251mgK6ODlQW5Oo1/WO4yKVSiIUCSEQCyLu6QOK/4yNVSrTz2uA3bjxCo2IGrK3UabVoLC/GhvvvxdKlSxEcbF7pcn2hxF5ycnIPD7ruqV+hUNgj9evl5WUW59/ukCSJH374Af/v//0/fPfdd3j44YdNvSSLxSr49KC2thYtLS09HLMNCUmSKC8vR2NjI5ydnTFlivFOlGq1GufPn8f8+fNHnGbTaDTgcrnD6sQlSRJdXV3g8/ng8/mQy+Xw9vamU7+msG/h8/koKipCeHh4v3f41dXVeOy5F7DmLy+g+OZ1tNTXICwmDrEZkw16ET6+43skTpt11zgoQ1OS/TuUcjmi0zL63ebSoV/h7R+AmLT+O+KMgUwiQWN1OXiN9ZBLpbC1tYWtnR2dOmY5OMLHLwA+/gFw8/Tq2zPxh22YtHAZGipK4erhBZ+AACjlclQV5UPSLoBSLkdAaATGR0abhYgaCLVSiRunjiFj7t2j8EaTO+bJuSB0WsRPng67Xr/Vm2dOIHHqTJMcz64O0Z2Rgbw2pM2eP+ga5F1d6GxtxEvPbURKSorRbrRHi+bmZpSXl98l9nrTPfUrEAigVCrprl9zSP2SJIldu3Zh06ZN+PLLL/HYY4+ZfTTSnLEKPj1obGxEbW2tUVqptVot8vPzIZfLERQUhLa2tgFbzQ3xemfPnsWcOXNGJKoUCgVu3boFhUKBkJCQEXkDAv+bNcnn8yGRSODu7g5fX1/4+vqOysmnsbERlZWViI2NHXQusUgkwooHHsHKp/4PTi6uqCsvQfHNa/AbH4rUWXNhZ2cYsXrg2y8wa+V9Rhssr1IocHzn91j88IZBt82/dhmSDhGmLLrHbE68arUarXXVaK2rgVgoBECCyWSC5egIO7s7dYTu3mwU3LgMBoMJT7YvFNIugMFAbPpkuLh7mPot6EXulYsIiYw2WfSR11iPuvJSsBwcEJM+qU8xJWhpgqC5yaiWNH2hUatQzs0GQRL0Zz1YKYKI1wZPexs88dijiI6ONqtRj8NhqGKvL2QyGS3+TJ36JUkS+/btwzPPPINPPvkETz/9tNmccywVq+DTg9bWVpSVlRk88qZQKJCTkwN7e3skJSWho6MDlZWVmDrVeOakJEni1KlTmDVr1rDH9nR2duL27dvQ6XRGOVEqlUpa/HV0dMDZ2ZkWfy4uLgb98ZMkicrKSrS0tCApKWnInWxqtRoLVqzCwof/TNt8iPhtuHHyGDx8fJAxbxGcXIY+tqkvCILAr998hqWP/NkoF/lTe3YgY96iIe+7ubYa+VcvYe6aB2A3QB2cuUAQBNpbm3Hj1HE01dYgJCoKMamZdOrRkiAIApcO/4pJw+wwHi4kSaK+rAStDXXw4vgNaq9y8+zJHl59xoYgCNQUF0Is5CMmNRPtgjZ0CHgYPyF6wOc111RhzuQMzJo+DVFRUaNuk2FoWlpaUFZWhqSkpBGPrTR16vfgwYN44okn8N577+H555+3ij0DYBV8esDn81FQUIDp0w1XKN3R0YHc3Fz4+fkhKioKTCYTQqEQJSUlBvUX6otTp05h2rRpwxpxxuPxkJeXBwaDgeTkZKPPxKVOPnw+H0KhEPb29rT4c3cfmR2ITqdDcXExJBIJkpOT9T4eBEFg6ep7kbZ4BQJD/1fjppTLcfHwfrDs7ZE2ez68B3D1Hwy1UonDP2zDiseeNqglTG1pEZprq5E6S79uT7lUijN7d2Hm8tVwM1Lk0ZDotFoc2/Edpi/LglajQfaFM9DptAiNijNa440xqMjLgaOLC3z8RkeY6HRaVObfSY2Oj4wCJ2jwJobGqgpo1WqD13v2R2t9HZqqyxESFQt3Lx8oZDKU3L6BmPT+MySEToeG8mK8uuk5uLu5ITo62qKtowDDir3ejHbq99ixY3jsscfw17/+Fa+++qpV7BkIq+DTA5FIhFu3bmH27NkG2V9LSwuKi4sxceLEHrViHR0dyMvLM9jr9MfZs2eRmZkJVz0GhwP9d+KOFjqdDu3t7bT4ozp+fX194eXlpVfNkFqtRn5+PkiSRFJS0ojS2w9s+BMC4lIxIbFnU49Op8OVo/+BRq1C/KRpPUY86YNE1I7zB/dh2brHDXIC1Gm1OPT911jyyGPDej5BEDj583bEZk5BUPjw3tNo8fvpY/AbHwY3z54XwpLbv0PY1gLOuPEIj40Hw8zr9y4fPYD02fON/joqpQJl3NuQSToRlZox5A5tkiRw8/QJpIyCXQxVp+fhzca4//6mSJJE7uXziExJ7/c8oJDLIGqoxb++/Bytra2IjY0d9RFXhsaYYq8vjJn6PX36NNavX4/nn38eb7/9tlXsGRCr4NODzs5OXL16dcTedSRJoqqqCvX19UhMTLxr7ItEIsHt27cNbirZmwsXLuhlxKlPJ+5o0b3jl8/nQ6fT0R2/3t7eA6Yd+rJdGSnPvfT/oHb26ncwfPbFMxC2NCEiPhFRKRl6n8yaa6tRfOsG5q5+YMRrPbv/Z8RNmgp377t9yPThytGDcPf2QVzm6M5HHSpScQcuHfkPJi9a1u82bY31KOPegrunN6JSM8GyN79UdWt9LdpbmxEel2i01+gSi1Cex4VGo0bCpGl62+RUFebBxd0LXr6+Rlphzzq9iYmpPYRdRV4OPNgcuPZzTusQ8AG5BB++9y5EIhHi4uKsYm+EaDQatLe3QyAQjDj1e+HCBTz88MN44okn8OGHH1rFnoGxCj49kMlkOHfuHBYuHH53nE6nQ2FhITo7O5GamkqPa+n9OsbwyOvNpUuXEBcXB2/vwVNyI+nEHS1IkoREIqHr/hQKBby8vODr6ws2m91DnFK2K35+fgb3Ofzwk3+gqImHaUuz+t2msiAPFXnZCAyLQMqM2XqlaUuzb6ND0IbM+UuGvUZeQz0Kbl7FtKWGMS8t+v0a2nk8TF2y3Oy6XE/v2YGUGXOGNO5MLpUi58IZ2LLsEJmcbrRGmeFw/cQRJE83TtSf39yIutIS2NjZIW7SZDCZ+v+2tVoNss+dNlp0r3edXm/ja15TAySidowLn9Dn81vrajAtLRkbHn4I9fX1tBCh0pLmYgmlD62trSgtLUViYuKQzuPGhiAIdHZ2QiAQQCAQ0OfgoaR+r169igceeAAPP/ww/vnPf5rdeWQsYBV8eqBUKnHq1CksWLBgWF9GpVIJLpcLGxsbJCcn9xsdUyqVuHjxosE88vrj6tWriIyMHHSwtKE7cUcLmUxGR/66urrojl8bGxtUVFQMaLsyUnb9sge/njqPhQ9uGPBY8ZubcOvcCXhz/JExd+GQGydunj0JB0fnYXmcEQSBQ99/hcUPPar3cweiraEet86exIL715lNhKyxqgJ15SWIHaCeqy/ujAU7B5VcjqCIiQgMM+13vkvcgaKb15A0debgGw8RkiTRUFGG1vpauHv7ICIhaUT7K7n1OwLCIuDUx03sSOldp9cbhUyKstzbiEpOv+tvBEGgsbwErz3/f8jMSEdxcTESEhLg4+PTQ5zI5XK6Lo3NZpvckmQwzE3s9UV/qV8fHx+4urrSQYObN2/i3nvvxerVq/H1119bxZ6RsAo+PdBqtTh+/Djmzp0Lu35GTfWHRCJBTk4OvL29ERcXN+AXWqPR4Ny5c5g3b55R7zivX7+OsLCwAVMa3TtxY2JiLLaLjer4bWhogFwuh4ODAwIDA+Hr6wtnZ2ejXMyvXLuGd//xBVY+vnHQkVDyLgkuHf4Vji4uSJ+7EB5DSLOe/89eBE2IQliMfqbPv5/5DZxxwfAbH6LX84aCUi7HyV9+woxlK+HhY7y03lAgSRLHdnyHqYvvGdF+qory0FxdBR//QExITDFJZPvW2ZOIzcgEkzny8wGh06GiIBeCliaMj4yG//jQEe9TKZej8PoVJE4znCAF+q7T6w1JEMi9ehGRyWl3nVdVCgX4dVXYt/Mn2NjYoLS0lBZ7vZHL5bQ4oVwBzHUahSWIvd50T/0WFhbipZdewvTp05GUlIRvv/0WS5YswQ8//GAVe0bEsuLXJoY60Wu1Wr0EH4/HQ0FBAcLDwxEaGjroiYN6HZ1OZ1TBZ2NjA4Ig+v17907c1NRUvT2dzAl7e3soFApoNBokJydDrVZDIBCgtrbWoB2/3Zk+dSq2+flhw8ZNuHfjS3cZ03bHydUNix9+DFq1GpeO/AcEqUPStFkIGOBiPGf1fTj203dwdnUdUvckAIiFAghampE41Tgd4A5OTlj+6JM4ufsnRKdkYHzkwLYYxiT/6iWEx418DGJEXBIi4pIg4rfh+omjcHZ1Q3RaBhydDR/J6guNWg25TDpisadWKVGWmw1pRwcmJKUa5NhQlOXcQqwBJ2p0r9OLSR/YzLw8PwfBEyLv2qazXQg7jRKXz5wCn88fVCA5OTkhODgYwcHBPSxJuFwumEwmLf68vLxMWs7S1tZmcWIPAOzs7ODn5wc/Pz9ERkbC09MTu3btwocffgiCINDS0oKvv/4a99xzj8WPtDNXrFJaDxgMBphMJnQ63ZC2J0kSNTU1KCgoQEJCAsLCwoYkJqhthvo6w2Wg91JdXY3c3FzY2dlh8uTJFi32qLpJPp+P9PR0+Pj4ICAgAImJiZg1axYmTpwItVqN3NxcXL58GSUlJRAKhQOK4aESHh6OQ7u2Y/c/tkAu7Rp0e1sWC3PXPID5ax9GdVEBjv30HSryuegvEL9s/Z9x/dQxSDrah7SeS0d+xZzV9+n1HvSFyWRiycOPorm2CvnXLxv1tfpDpVSgsbocfkMUwkPBy9cPs7LWIHH6LORfu4Srxw9D2NpssP33R2nOTcSPQExJJZ3gXj4H7qXzCIuNR/q8hfDoI8I1XLo6OkCSJGz1zHr0BUEQqCrMR/61ywiLiUdUcv/dtsCdMgIbW7u7PBV5jfWICQ7E0QO/oq2tjW5qGKpAsrOzg7+/P+Lj4zFz5ky6Zrm8vBwXL15EXl4empuboVKpRvR+9aWtrQ0lJSVISEiwKLHXGxaLhdDQUOTk5GD58uUoLi7G4sWLceDAAURERCAhIQE7duwY0WtcvnwZ99xzDwICAsBgMHDo0KFBn3Px4kWkpKTA3t4eERER2L59+13bfPXVVwgJCYGDgwMyMzNx69atEa1zNLGmdPXkxIkTSE1Nhbv7wKatBEGgqKgIIpEIKSkpcHNz0+t1zpw5g0mTJultmaIPXC4X3t7ePe6mqHW3traaTSfuSNDHdoUgCHR0dNBNH/p0/A5lHbMWLcU9j2+Ep56pzhLuLdQVFyJowkQkTZ15V3qYIAjs/3or7ln/BOwHqDvKv34FTDsbRMQaLrIzGKW3b6KtsR7T71k1qqmai4f2Y2JKKhwcjDeNgiAIFN64is52AfzHhyE0Js7gaT/yv0bLmcMwWm5va0FNSRFIAIlTpw+rEWMoZJ8/gzgDzPUdrE6vN3KpFBV52YhM/t+oS5Ik0Vhegmf+/BgefvABenLOcKZO9AVJkvQ0IIFAAIlEAjc3Nzr6Z6zyEKCn2OsrJW1JVFVVISsrC7GxsThw4ECPjJlYLMapU6fg7e09IkeMEydO4Nq1a0hNTcWqVatw8OBBZGVl9bt9bW0t4uLi8NRTT+HPf/4zzp07h02bNuH48eN0o+bevXuxbt06bNu2DZmZmdi6dSv279+P8vJy+BqxM91QWAWfnpw+fRrx8fEDtr9T0SKCIJCcnDysSRbnz58fkrAcCXl5eXBzc0NYWBiAOzUWOTk56OzsBJvNNphViakYie0K1fHL5/N7dJv11fE7VAiCwNwl92D6qgcQEBqu9/Nb6mqQfeEMvDgcTF10Tw/LjMGMmRVSKU7t+QkLH1yv9+uOFEFLE34/9Rvm3fsQ7B2MXwgvaG1C/pVLSNHTTHokNFVXorIgF54+vohKzRgwfa8PVUV5sLW1A2fc0MyhSZJEc00Vmmur4OzhicjEFIOsoz8Erc0QNDaOqOFjKHV6vSEIAnlXLiIy5X91exq1Gq1VZdj+r28ROXECGhoaUF1drZf1lL6oVCq67q+9vR329vZ0U4Knp6fBbnJ4PB6KioqQmJho8WKvrq4OK1asQGhoKI4dOzYqAQUGgzGo4HvllVdw/PhxFBUV0Y/df//9EIvFOHnyJAAgMzMT6enp+PLLLwHc+R4GBQXh2WefxauvvmrU92AIrDV8emJraztgqrWrqwtcLhfu7u4jsi6xsbExekq3ew2fQqHAzZs3oVQqERoaivDwcLMqUtaXzs5O5Obmwt/ff1i2KwwGA+7u7nB3d8eECRPojt+mpiaUlpbCw8ODFn9D7eZjMpm4cPI47llzL+STZyEiIXnwJ3UjICQMyx99EpIOEY5s/xfcvX0waf5iuHp4guXggPn3PYwTu7dj6SN/uuv9Xji8D7PXjNy7bziwA8ZhwQOP4PhP/8b0Zavh7WfciQa3z51GxrxFRn2N3owLn4Bx4RMglYhx88xvsHd0RFTK0A2L+6O1tgZpQzBaJggdqosKIGxtgX9I6KgYHwNATXHhsEeoadQqlHGzQQ6hTq83FXk5CI6Mpp/T1SmGTtKBCyd/g4ODA+rr61FTU4OUlBSj3jTb29sjMDAQgYGB0Ol0EIlEEAgEKCoqAkEQ8Pb2pgWgvo1+FDwer0dnsSXT2NiI1atXIzAwEEeOHDGr7NGNGzfuiiguXLgQmzZtAnAnkJOTk4PXXnuN/juTycS8efNw48aN0VzqsLEKPj0ZSIgJBALk5+dj/PjxI7YuGQ3BR9XwicViZGdnQ6fTIS4uzuJHDPH5fBQVFRnUdsXZ2RmhoaEIDQ2FUqmkI38VFRVwcXGhmz6GktI5+us+bHj8Sci6JEgchs2Gm6cXVjz2NNRqNS4c2Asmk4HUWfPAGReElJlzcOHgPsxZ9b86vYqCXHhx/E16crV3cETW4xtxes9OTIhPRqiencVDpTw3G5ygYJN1+rm4eWDmijUgtFrcPn8aao0aIZExCAgJ03tfvKYGuA7iA6hRq1CacwsSUTsmJqchJDp2uEvXm8aqCvgGjNP7eYP56Q1GW0MtbFksOP+33EXQ3ITIIH988/N2AHdSc3V1dUhNTdW7lGYk2NjY0Knd7p6gdXV1KC4uhoeHB/13pyHaL1GRvYSEhEHts8yd1tZWrFmzBl5eXjhx4sSwZ7gbi7a2NnA4nB6PcTgcSCQSKBQKdHR0QKfT9blNWVnZaC512FgFn57Y2NhAq9X2eIwkSdTX16OyshKxsbEGsS4ZrQhfV1cX6urqxkQnLgC6Zic2NvauH6ahcHBwoLv51Go1PeO3trYWDg4OdORvoI7f7f/+Fq++8Rau/XYYU5cMz/yYxWJh4f2PgCAIXP3tMG6dO4nY9EnwDw3DzbMnkTlvETRqNQp/v4olDxvWc284MJlMLHpwPa6fPAZxu8DgJsJarQbledkDGl6PFkxbW2QuuGOMXca9javHDoI9LggT4pMHteihqCrIRcqMOX3+TdYlQXluNlRKBeIyp8DBaXTHG5IkgebqSr0jid3r9IInROr9urIuCXiNDZiYlAqSJNFUVY51a1fjqSceB3Bn7GNDQwPS0tKMWv88GN0zBBEREVAoFPQkisrKSjg5OdHir7/zBHXjOhbEHp/Px5o1a+Dg4IBTp06ZvcfhWMUq+PSkd0qXIAiUlpaCx+MhPT3dYLUioyH4JBIJRCIRWCwW0tPTh3zXaY6QJInKykq0tLQgJSXFaDU7vWGxWAgICEBAQECPGb+5ubn0Hb+vr2+f9Twfbn4XX2/7Fid//nFQg+aBYDKZmLFsJQAg//plNFVXQCGTwsXNHa0NtZixfPWI36chmbJoGcrzcnDh4D7MXLHaYM0Et8+dGlbE1NhEpaQjKiUd/JYmXP3tEFw9vBCTNmnABhuZpLPPzmwRn4eakgIAQGzmVJNNhqguKkBIdPyQt+9ep5c4ZXifEUEQKM+906Sh1WjQXFGKbz//JxITE2lHhMbGRqSmpppU7PWFo6MjfZOo1WppPzrK9ooaRebt7Q0bGxvw+XwUFhaOCbEnFAqxdu1akCSJs2fP9jldyhzw8/MDj8fr8RiPx4ObmxscHR1hY2MDGxubPrexlPF8VsGnJ90Fn0ajQV5eHtRqNSZPnmzQuxZjCj6dTofi4mKIRCIwmUxoNBqUlZXRkSl7M5mSMFSo9yORSJCeng5n59GNdlDY2NjQqV2q45fP56O4uBg6nY6+o/fx8aFrO//y1JMYP/4E/rntM6x64tkhR3/6I3HKDCROmYH68lIc3/U97B0c4OrhieCJUXD39jGbuszIpFT4+AXit10/YN6ah4Y8YaQ/JB0iCFube3Rsmhu+AePgu/I+KJVy3Dx1AkwbJqKS0+HFuftiUZJ9kxavJEmipa4azTXVcHRxRfzk6SY1p9VqNRC2NCN4QtSg246kTq835dzbCImKgVzaBYWQh7PHj8DFxQUkSaK6uhrNzc1IS0szW0FBYWtrCw6HAw6H02MUWWVlJQoLC+Hs7AypVIro6GiLF3sdHR24//77oVAocOXKFaPWU46UyZMn47fffuvx2JkzZzB58mQAd27uU1NTce7cObr5gyAInDt3Dhs3bhzt5Q4La5eunlDedAEBAeByuXByckJiYqLB77Rzc3Ph4eGB0NCRu+B3p69OXLVaTY8g6+zspEeQ+fr6mn3oXR/bFVPRveOXz+dDqVTC29sbvr6+8PHxAYvFQmFhIZ568RXc/3+vGKTDszz3NgStzXD18ETJ7d/h4c2GUqkAy8Ee9g6OcHbzQPDESHhz/E0qAtVqNU7s/AGTFy2Fj1/gsPdzeu9OpEyfPaR5ueYCQRDIu3oRUrEY48InIHhiFBgMBrQaDa7+dhjps+ejtrQI/OYm+AYFIThC/xSoMRjKCDWSJFFVkAtxuxCxaZP0rtPrTUtdDRTSLtixWAhie+Gn7/5Nv05lZSVaW1uRlpZmsps9Q9HQ0ICKigo4OTlBLpfD1dWVvlF0cXExmxu2odDZ2Yn7778fbW1tuHr16qiLV6lUiqqqKgBAcnIy/vGPf2D27Nnw8vJCcHAwXnvtNTQ3N9N+f5QtyzPPPIPHHnsM58+fx3PPPXeXLcv69evx7bffIiMjA1u3bsW+fftQVlZmtBIiQ2IVfHpSUFAAuVwOkUiEwMBAREZGGuVHWFBQACcnJ0RERBhsn0PpxFWpVLQw6ejogIuLCzgcDt2QYE6MxHbFVFA+XlTTR1dXFzw8PODj44Pq6mq88rfNePCF1+DkMvyUVEtdDYpuXsOMe+6kebVaNc7u+wXjIiYiOjUDACCTSFDKvQ1RWwvsWCwwbZhw9fDC+KgYsAMCjebZ1h+n9uxEWEwcwmMT9X5uQ2UZGirLEJOm37xcc6KutBi1ZcXw5vhDq1Gjq7MDarkCIbHx8DFyV7M+KOVyFFy7jKTps/rdpq2hDvUVZQiLiRuSn95gyCSdqCjIhb29Pe7Lugcv/rdrkiRJVFRUgMfjITU11ezOT/oiEAhQUFCA+Ph4+Pr60vXBlOWLnZ0dLf4MafliDLq6uvDQQw+htrYW165dM0nK8+LFi5g9++464fXr12P79u3YsGED6urqcPHixR7Pef7551FSUoJx48bhzTffxIYNG3o8/8svv8THH3+MtrY2JCUl4fPPP0dmZqaR341hsAo+PcnJyUFzczNiY2Mxbpz+HWpDpbi4GLa2toiMNMxdvVgsxu3bt0EQBGJjY4fUiavRaGgT4vb2djg6OtKRP1dXV5PebY7UdsVcUCqVaG1tRV1dHbRaLVgsFl54/U2s2fgSPH30vyPuFAlx6fCvmH/vQ3cdk4r8HNSUFGHKouVw7qN7USmXozwvG7yGetixWGA5OMDB2QXjwifAL2h8n/5+huT3Mydgw2QiddbgNiQUBEHg+I7vMHXJciOuzPCQBAFppxjtvDaIhXxo1Gpo1Gp0dYjAb2wAOygITi6ucHB0hE9AINy92WZxgc+7chETE1P6jNhRdXru3mwEDdFPbzAInQ45l86CAeCbz/6J6dOmAbgj9srLyyEQCJCammrR9cfA/8ReXFxcn5EinU5Hm8ILBAJotdoeli/mlNmQyWRYt24dSkpKcP36dQQGDj9yb8WwWAWfnpSXl0MoFCItzbi1QmVlZSBJEtHRI59F2traioKCAjCZzGE7zlOFxlRkys7OjhZ/Hh4eoyq4jGG7YiqUSiVyc3Ph4OCA6OhoiEQitLW14YlnN2HphqfgHzL0lL5SLsfhH77GsnV/7lecUdE+v5BQxGdOHXSfGrUaFflctNRUwcbWFiwHB9g7OiEwNBz+IWEGMximqCzMQ11JMWatvHdIEdvcy+fh6OIK33FBBl2HIdBqNBC3C9De2gKZpBNajQYajRo6rQY6rQ5unl7wCw4F2z+ATkVfPX4IiZOn04JKrVSivqIUIl4bGDY2sLOzgx3LHl5+fvDi+MHWduTjzIZKl7gDVQV5iM2Y3OPx7nNvJyamGlSYFv5+FQpJJ66cP0uPEiNJEqWlpRCJREhNTTX7spPBEAgEKCwsHLKzAEmS6OrqosWfVCqFu7t7j2kfpkKhUOCxxx5DdnY2rl27hpCQEJOtxcrdWAWfnlRXV4PP5yMlxbgO9pWVlVCpVIiLG75fGdW5VllZCXt7e6SlpRnkTpggiB7ij8FggM1mg8PhGD3VMBq2K6OFVCpFbm4uvLy8EB0d3eO46XQ6zFm0BOlLViIibvA0p06nw8F/fYEF9z3cYwJHf1Tmc1FVmI8pS5bDxd1Dr3VrtVrUFBeioaIUDAbjjgh0cITf+BAEhkWMeJqGWCjApcP/wdw1Dw5YJ6ZSKHB6745h29oYAqVchg4+D+1trVAqFdCq1dBpNNBqNQCDAS+OHwJDI+Dm2f9kHoryvBwwmEwEhQ1cxqHTadFcU422hjqQJAkbW1swbWzg7esHn4DAAbt/R0L2hbOIy5xCf09JkkRNSSE6+Lxh+ekNhEatRmNVOWSCNtz+/UaP1ywpKUFHRwfS0tLMzstNXwaL7A0FpVJJiz+RSARHR0da/I3mzbhSqcQTTzyBa9eu4cqVKwYtR7JiGKyCT0/q6+vR2NiI9PR0o75OTU0Nurq6kJiof00TcEcAFBUVoa2tDa6urkhJSRm20/tAEAQBsVhM1/1R3ajU/FlD1dV1t11JSkoaNdsVY9HR0YG8vDwEBwcjLCys35PyyrX3wS82BYlTZwy4v4P//hLTl66Aix6THbRaLc7u/xkBIWGIzZii1/p7QxAE6ivKUFNcAJIgwHJwAMvBAb6BQQiKmAhHZ/06J7VaNY7v+BGT5i0CO7Dv6N2Fg/sQnZoxJIE7XKjUq7CtBSJeG3Q6LXRaLXQaLbRaDewdHMEODIJ/SOiIhK5EJETBjatIHeaEDIIg0N7WgobKcmjUKtja2cHWjgVnN3f4jruTHh7JhV/Y2gx+UxMi4u+cj3iN9WisKsf4yJhh1emRBAGFTApJhwjSTvGdY6rTQatRQ9IuBAMk1mRl4YMPtvzvOSSJ4uJidHZ2IjU11eLFnlAoRH5+/ojEXm+0Wi097UMgEABAD8sXY9n4qFQqbNy4EadPn8bly5cNkpmyYnisgk9PmpubUVlZSbdqG4u6ujqIRKJhRRI1Gg2ys7MhkUjg6+uL2NjYUWlo6N6NyuPxoFKp4OPjQ3ejDldwdrddSUlJsfh6HWpU0sSJE4dUB/rE089A4eDabyTr+M7vkTRtBrw5wyvuryrKR0UeF1OWLIerntG+gSAIAm0NdajIzYFGrfpvOtgRnj4cjI+OgYvb4BYNZ/b+jOCJUZjQawydoLkRBTeuInnGyM2btVoNOoVCtLe1QCrphFajhlajgU5zJ/Xq4uEJ//E9U6+GhCAIXDr8KzLmLjR4dFzSIUJdWTHkEgls7Oxgx2LB3skJ7IBxcPf2BoMxtNe7dfYkkqbNQpe4AxV5OfDwYSNokK5hjVoNqUQMiUgEjUoJnU4LQqeDTkeAJAi4uLvBixMAT7YvOoUCCFsaEODthQ83v3dXqQZBECguLkZXVxdSU1MtzjqqN0KhEAUFBYiJiTFaQwNJkrTli0AggFwuh5eXFx39M5Rg1mg02LRpEw4fPoxLly4hPn7o/oxWRher4NOTtrY2lJSUYOrUweufRkJjYyPa2tr0jiTK5XLcunXL5DNxSZKEVCqlI38ymQxeXl503d9Qi4wtwXZFH6iUdFxcHHx9fYf8vHc2b0ZudSMWPrC+x+d5/j+/YHxkNAIHSQMOhlarxblff4FfUAhiMycb9TvDb25EafZNKGQyODg5wd7REe5ePgiJioGrp9ddr33r/CkQWgIZcxfSj/2283tMWrh0yK+plMvQIeBDxGuDSqGAVquGUiYDQRBg2jDh6euPwJAwuA0yyswYcC+fh//4UHh4j86cVKVcjvryEogEPNjY2MKWZQcWywHe/gHw8uXcVf/ZWFUJpawLnaJ2kASJyOQ0MJlMkCQJhVQKiVgEmaQTxH+jdJSws7FjwdOHDXZAYJ+TQLQaDZqrK2BHEli2YC6WLF4MgUCAzs5OuLq69phVXVxcDJlMhpSUFKvYGyYymYzu+hWLxXBxcaHF33Cb8DQaDV5++WXs3bsXFy5cQHKyfvPBrYwuVsGnJ0KhEFwuFzNnGtfRv6WlBQ0NDZg0aehWEx0dHcjOzgZBEIiLizMr92+5XE6LP4lEAg8PD1r89XenaYm2K/1BmcM2NTUNOyX9086d2HXoOFY+vhFMGxtcP3UM7p5eCI9LMNg6a0oKUca9jSmLl8NVj/TwSBHx+SjLuYkucQdY9vawd3SEq6cXxkdGw5PNQV1pESoL8jB75X2oLOBCLpMhJPJ/aSOSICCVdEL0365XrUbz3//U0Gq0YNmz4BMYhICQsBHXGBqS1vpatNRWIybNtLYOWq0aTVVV4DXVA2CAaWMDWztbeHH8UJZzCxq1Bj7+gWAwGCB0OmjVKhAECRcPD/j4B8CTzRlydFIs4KO9tQlBvmxsefdvd0W51Wo1HZVqb28Hg8EAk8lETEwMfHx8zKJbebi0t7cjPz9/1MVebzQaTQ/LF2oqkI+PD7y8vIZ0rtVqtXjjjTfw448/4uzZsxZjTfJHxir49KSjowO///475szpe8aloeDxeKiursaUKUOrrTJEJ+5oQRUZU15/1N18d6+/sWK7Avxv/B6Voh9JF93ly5fx2uYPETtpGtRKOZKMMEpMq9Xi/H9+ge+4YMRlTjXZse8Sd6A05xY6+G1g2TvcqU/it4HQ6eA/PhQajRpatea/Xa9auLh73NX1as5o1CpcPXYIk/47c9dckEk6UV9RCmlnJxqrKxEwPhQTEpJGNK9Xq9WguaoStqQWKxYvwhN//tOgwo0gCOTn50Mmk8Hd3R3t7e0ARqcmzRhQYi86OnpItlijBTUViBLZGo1mUMsXrVaLd999F9u2bcOJEycwffp0E6zcir5YBZ+edHV14dKlS5g/f+heYcNBKBSitLR00B8SFTmqqqqCvb090tPTLcqmgLqbp7z+nJ2d4ezsDIFAgIiICIu3XdFqtSgoKIBKpUJycrJB6maqq6ux6v4HERwVi5j0SfALDjGKKKstLUZpzk1MXnTPkLpMjQ1Jkjj+03fQ6nSwsWHCydUN4bEJencZmwvXTxxBbMZksOxN23xAEATa6uvAb26ASqGAnb09QqJiUXTzGmLSJo1o7J24XYD25kYEsn2w5Z23ERwcPKTn6XQ6FBQUQK1W0w1n3WvSqIk13WvSzDnVa65irzdUKQ4l/rq6uuDm5gYnJyf6HEaSJLZs2YLPPvsMx44dM3rww4rhsAo+PZHL5Thz5gwWLlxo1MhHR0cH8vPzMWvWrH630el0KCwsBI/HM2on7mih1WpRVlaGtrY2MBgM2Nvb05E/d3d3i4vyqdVq5ObmwtbWFgkJCQb/bOrr6/H0/20Cv70DAWERCI2Jx/iJUQZNeREEgbP7fwE7IBDxk6eZ9DO4eeYEXNw9EBASBuC/9Z1XLkKtVsLZ1Q1hsQlwHkIjiDlQVZgHnVYzpHm0xkApl6GurAQySSfUKiX8gkPoOlCZRIKCG1eQOHXmsCJoOq0WTdUVsNFpsGzBfPzlqSf1+k7qdDrk5+dDq9UiOTm539+NTCajhUnvuj9nZ2ezOV9YitjrC5VKBYFAgNOnT+PFF1+Et7c3AgMDkZ+fj4MHD2Lp0qHX0VoxPVbBpydqtRonTpzAvHnzjJpOkEgkuH37NubO7dumwVSduMait+2Kq6srRCIRXffHZDJp8WfuY4WAOzcGXC4Xbm5uiIuLM+p6tVotPvr0H/jtzFloCAIBIeEIGB+G8LgEg03HqCsrRuHv1zBt2UqTRPsq8rgQtjYhOrXvOiG1UoncqxehVavh7O6O8LjEEY2nMyZdnWLkXT6PtNnGzRJ0hyQJ8Jua0FpfC7VKAaaNLSYkJN1ll9Mh4KOyIBcJk6fr/Z3tbBdC2NSAALY33v/bW8My3dXpdMjLywNBEEhOTh7yObZ33Z+9vX0PLzpTnS9EIhHy8vIQFRWFgIAAk6zBUEgkEjz//PPYt28f3NzcwGAwsGTJEixfvhwLFy6Eu7thbra++uorenRZYmIivvjiC2RkZPS57axZs3Dp0qW7Hl+yZAmOHz8OANiwYQN++umnHn9fuHAhTp48aZD1WhJWwacnOp0Ox44dw+zZs42aQpBKpbh+/ToWLFhw19+6d+KGhYUN6ONmCQxmu0LVmFDijyRJ2utvqAXGo4kp6w/PnT+Pf+/cjfbOLhAg4eruAS8/f0QlpY3Yr44gCJzaswM+fgFInjFn1N4Xr6kR+VcvIn3O3b+FvlApFci7egkquRwuHp6YmJSitw+gsSD/a8GSbgQLlt6olUrUlZdAKu6ASqkEOyAQ4yIm9vu6vMYGNNdUIS5z6J6MOq0WzdWVYOrUWDx3Np595plhvy+tVou8vDyQJKmX2LtrTTod2tvbR92LrjdjSeyRJIlvvvkGb7zxBnbu3InVq1fj9u3bOHLkCI4cOYLy8nJ8+umnePbZZ0f0Onv37sW6deuwbds2ZGZmYuvWrdi/fz/Ky8v7dDUQiURQq9X0v9vb25GYmIjvvvuOnoG7YcMG8Hg8/Pjjj/R29vb2Zl3nbiysgk9PSJLE0aNHMX36dKP6wSkUCly6dOmu1LE5d+IOB31tV6g6Hkr8qdXqHl5/pi7ipiwXTD32TSgU4s333ge/SwYv/yA0VVfClmUHD282otMyRhT9qq8oQ9HNa5i0cJnRrUTk0i6c3f8zpi9dOaznK+Vy5F29AK1WA1cPL0TEj6z5YKTkX70En4BAePkafkoMSZJob2tFc20VVAoFAGBCQnKfc5N7U19RBomoHZFJqUN6LUmHCIKGOvj5eOL9t99CWFjYiNau1WqRm5sLJpOJpKQkgxq2m6Lub6yJve+//x4vv/wyvvvuOzz88MN3bVNTUwMmkzniUWqZmZlIT0/Hl19+CeDOTWZQUBCeffZZvPrqq4M+f+vWrXjrrbfQ2tpKN8dt2LABYrEYhw4dGtHaxgJWwTcMjh8/jszMTLi6Gi9lpFarcf78+R6p45aWFhQWFoLJZCIlJcXip02M1Halu9cfj8eDQqGgvf7YbPaoe/a1tLSgtLQUMTExZlOrQxAEvvj6G1zNyYWLbwACw8KRd+UiQJJw8fREdEoG3Ich2giCwPn/7IEnxw+JU2YYJdqn0+nu+O0tWGoQIa+US8G9fBEEQcDN0xPhcUkjakjQl7bGejSUlSB+8jSD7VOjVqGhogydonaoFAp4+nIQEhWjV5StMp8LkiQREhU74HY6ne5ONE+rwoJZM7DpuecMEqXUaDTIzc2FjY2NQcVeX4xG3R8l9iIjIxEYGGiAVZsOkiSxa9cubNq0CV9++SUee+wxo0X21Wo1nJyc8OuvvyIrK4t+fP369RCLxTh8+PCg+4iPj8fkyZPxr3/9i35sw4YNOHToEFgsFjw9PTFnzhxs3ryZns38R8Iq+IbByZMnkZSUZNSQsE6nw5kzZzBnzhzY2dmhqqoK1dXVFtmJ2xfGSHvKZDI68tfV1QVPT0/6ZG7MMUwkSaKurg51dXVISEgw2xNJdk4O/vnNt9DYsBCdNhk2drbIvXweKqUSzm7umJCQDN/AwSd/dKexshwFv1/D5IVLhyUcB+Ls/p8xMTHVKH6AcqkUeVcvgCRIuHl5Izwu0WgzaAFAq1HjyrGDmDR/ZBYsJElCLBSgsaoCKoUchE6HsLgEuA/DMJokSRTdvA43T2/4jw/pdzsqmsfx8sB7b72BCRMmjOAd9ESj0YDL5cLOzg6JiYmjWp5hjLq/jo4O5Obmjhmxt3fvXmzcuBGffPIJnn76aaOWcbS0tCAwMBDXr1/vMcnq5ZdfxqVLl3Dz5s0Bn3/r1i1kZmbi5s2bPWr+9uzZAycnJ4SGhqK6uhqvv/46XFxccOPGDbMrBzI2VsE3DM6ePYvo6Gj4+BgvnUWSJE6dOoVp06ahqqoKPB4Pbm5uA3atWQp8Ph9FRUWIiIgYsk2DvigUCjqNIxaL4ebmRjd9GDIVT5IkysvLwePxkJKSYtSor6GQSqV4893NaBSIEBgZA//xoSC0WhTcvAaxkA8nF1eMj4xG8ISoIZ3gCYLA+QN74eHji6RpMw1yUci9fB5MG1sETxh4fJchkEo6kX/tTuG3m5cPwuMSDG7O/Pup44hMTYODg/7fPa1Gg8aqcogFAqgUcrh6eiE0Nn5EUU9Cp0PulYsYFz4Bnuy7a6N0Oh1aaioBjQpzp03FSy88b/CaQ41Gg5ycHNjb2yMxMdGkjViGqPsbS2IPAA4cOIAnn3wSmzdvxqZNm4xesztSwffkk0/ixo0bKCgoGHC7mpoahIeH4+zZs/02RY5VLMe10oywsbGBTqcz6mtQ7vJ5eXmQyWRjohMXABoaGlBVVaX3aDF9cXR0RHBwMIKDg6FWq+nIX1VVFZydneHr6wsOhzOiNI5Op0NRURGkUikyMjIsJurq4uKCf/79QwB3pnccP30U9p4+iM+cChtbWxAEgYqCXBT9/j1YDo4YHxmN8Lj+oy9MJhPz1jyApupKnPzlJ0yevwQefYiIoVJbUoQusRjxk4w7vpDCxc0dUxcvBwBIO8XIvXQeYDDg7u2D8LhEsEZY51VbUgQ3Lx+9xJ5E1I76yjIo5TLotFqERseOeHwehUatBvfSOUQmp91Vy9kl7gC/vha+nu7Y+u5biI6O7mcvI0OtViMnJwdOTk6Ij483ede9jY0NfUPYve6vqqoKRUVFg9b9UWJv4sSJY0LsHT16FE899RTeeOONURF7wB2BbWNjAx6P1+NxHo83aK26TCbDnj178O677w76OmFhYfDx8UFVVdUfTvBZI3zD4MqVKxg3bpxRi3HlcjkuX74MACadiWsoetuumKr+kBopxOfzIRQK4eDgQJ/oKauBoe6H6igcCzN+s7OzseXTrWA4uyIqNbNHGrW+sgzlObfg4uEJ33FBiExKg10/75cgCFw4uA9uXt5Inj5b7+9se1sLrp88hmlLVozo/RgCiViEgmuXwWDawMOHjfC4BNix9BN/sk4xbp0/NWgqV6fToqmqEoKWJqiUCrh4eGJCfBJsDRzNl0ulyL92CfGTp9PfWUKnQ3NtFaBSYtbkSXjl5ZeMKsAosefs7Gx0yyJDQNX9UWMhe9f9dXZ2gsvlYuLEiXeNibNETp06hQ0bNuD555/H22+/ParXnczMTGRkZOCLL74AcOd8EhwcjI0bNw7YtLF9+3Y89dRTaG5uHrSkpqmpCcHBwTh06BCWL19u0PWbO1bBNwyuX78OX19fBAUFGWX/VCeuTqcDi8WCVquFt7c3fZKxtJTuYLYrpoJK4/D5fAgEgh53+QPV8CiVSnC5XDo6YelRV5FIhPz8fISGhsLf3x/vfvAhyuub4RsShqBeaV1BazOKbl4Dy94BnmxfxKRl9tn12lJbDe6Vi5i0YDE82UPrSFUpFDj1y0+Yvmx4HbnGpFPUjvxrl8BgMOHly0F4fFK/opeCJElcPvIfpM2eBybz7u+IVNKJ+rISyKUSaLVaBE2IhG+A8QSDpF2I4pybSJ42G0wmE12dYvDra8F2d8Xbr7+K2NiBmzYMgUqlQk5ODlxdXREbG2v2Yq83vev+7OzsoFarERQUhAkTJljc++nNhQsX8PDDD+PJJ5/EBx98MOpBhr1792L9+vX49ttvkZGRga1bt2Lfvn0oKysDh8PBunXrEBgYiA8++KDH86ZPn47AwEDs2bOnx+NSqRTvvPMOVq9eDT8/P1RXV+Pll19GV1cXCgsLzXo6izGwCr5hcOvWLbi5uSE0NNTg++6rE1cmk4HH44HP50MqldKdqL6+vmYfWdLXdsVUUF5/PB4PAoGgh9eft7c3fSKXSqXgcrnw8fFBVJRhp1qYAqqesq+6o8NHjmD3wSOwdfVAVGrmXQJHIhYh9/IFMJlMuHl5Izo1o4cpM0EQuHhoP1w9PAf17SMIAid3b0fqrPlm+x2hEAuFKLx5FTY2NvDy9UNoTBxs7e5ec+HvV+HhzYaP/51MAEHowGuoR1tDHRRyGRycnDExMWXE/ohDgd/ShLqSIiRMmYGWmioQKgWmZ6ThtVdeHjUrI6VSiZycHLi7uyM2NtaiMxbAHc+3vLw8uLq6Qi6XA7DcOb8AcPXqVTzwwAN45JFH8M9//tNkn8+XX35JGy8nJSXh888/R2bmHcP1WbNmISQkBNu3b6e3Ly8vR1RUFE6fPn3XyFOFQoGsrCzk5uZCLBYjICAACxYswHvvvQcOx/DWSOaOVfANg5ycHDg4OCAiwjA1NcD/Up41NTVwcHBAWlpanzVhcrmcrkeTSCTw8PAAh8MxeifqcBip7YqpIEkSYrGYPs4ajQZsNhtOTk6or6/H+PHjLd7sGgCam5tRXl4+aD1lU1MT/rblI3QoNYhISu2zyF8pl4N76Tw0GhVc3D0QlZIGb84da5qWulpwL59D5rzF8OL0XYtz5ehBBIaFDzkaaC50CHgounkdtnZ28OT4ITQqDrZ2dhC2NKOmpAAR8UlorCyHVNIJhUyKwLAIejTcaNFYVYHmmko4OjnDmWWL9Q/cjylTpozqCDKlUons7Gx4enoiJibG4n87YrEYubm5iIiIQFBQkEXP+QWAmzdv4t5778Xq1avx9ddfW/yNrJW+sQq+YZCfnw8Gg4HISMN0EHafiatPJ65SqaQ96Do7O+Hu7k5H/kzdQGDKaROGhCRJdHV1oba2Fnw+HwwGgzZ6tsT0OtDTRkYfeyGCIPDhJ/8At7QcngHBCIuN7/Nz1Wq1yLt6EVJxx50Zt3EJ8B8fiouHf4WLmweSZ8zucUEp/P0q1EoVwmLiDPYejQVJENBqNNBo1NCo1dCq1VCplNColBC0NKGhogxuXj6QiNrBZNpArVLAN3AcWPYOYDCZYDCYAOPOZ8BAH78Jxp2GLQYYuPNnBhi9/pfa5r8bgMG8sycSDDBIEuT/NkNnezvaGmrx8AP3443XXgNBEHQNK2VFYux51QqFAjk5OfDy8kJ0dLTFngsoeou9vuhd9+fm5kaLP3Oa8wsAXC4Xa9aswaJFi/DDDz9Yxd4Yxir4hkFRURE0Gg1iYmJGvC+1Wk3PxPXz80NMTMywImEqlYqOSHV0dNCFxb6+vrTj+GgxGrYrownVWRwfHw9HR0cIBALweDxIpVLa68/X19fs7+KBO0KjoqICbW1tI7KRuXTpCrb9tAOEgxNi0ibB3rHvukyCIFCWcwttDXVwdnODo4sr+E2NyJi/CN4cf9SVl6AyPxdps+aN5G3R6HQ6aNVqaNQqaDVqqFUqqFUqaFRKqJQKaFQqEDodSJIEQRAgSQIkQf1/8s6/SRIk8d/HSQIg//d3kICtnR3s7O1hx7KHvaMD7B2d4ejkBDsHB9SVFkPeJUHi1OlgMvVL6fV4/f++FkgSBEiAIEGCBEmQAEgQ//1fkCR0Oi06hAJ08HmATgc7GwYcWSwkxcViZdYKpKb2PT2jtxUJg8GgRYmhRhbK5XLk5OTQJRDmJHSGA9WgMZDY601/fn+UyDalwCosLMSqVaswY8YM7Nq1y2KyMFaGh1XwDYOysjJIpVLEx8ePaD8ymQy3bt2CSqVCeHg4QkNDDXJCpE4w1F28oWxIhsJo2a6MBiRJoqqqCs3NzX12FisUClpkm1uEtS8IgkBJSQnEYrHBmmdEIhHeePd9NAnaEZ6UAs64gcfJ1RQXorKAC35LM0KjY8FvbkRUSjrUCiXUaiW0ajUtuAjyjtChhdl/xdn//t5TjN0RQ4CNnS1Y9vZgOTrDwdER9o5OcHBygqOTMxwcncA0Qm1VU3UlaksKMTExFW5eXoM/YZjIpV0QtrZAKe2CDQNwtLOFt4cbFi+Yj4ULFgz7MyUIAmKxmD5vaDQaulHMx8dnWJFsuVyO7OxscDgci47yU1BiLzw8fNg3suYy5xcASktLsXLlSqSnp2Pfvn1WsfcHwCr4hkFlZSVEIhGSkpKGvQ+RSIScnBwQBIH4+HijFZD2ZUPC4XDg6+sLV1dXg52EzcV2xVBQ4qijowMpKSmDRklVKhV9sRSJRHBxcekRYTX1xU6n0yE/Px9qtRrJyckGj0YSBIFv/vVv/OfYbwiIiERM2qQ74qStFcLWJqjkCmi1GhA6HTRqNQidDgSpg1qpgkapBMvBAY6urnBx84DvuCB4eLPBtIALkLRTjIIbV+DhzUZotOG6XHU6LcRCATp4bSB1WrBsmHB2sEfMxAlYu3oVoqKiDPZavek+slAgENCRbCoqNZRaYZlMhpycHPj5+WHChAkm//6PFEOIvd50nwsuEAhGte6vqqoKK1asQFxcHA4cOGCRpSlW9Mcq+IZBbW0tWlpakJaWNqznd+/ETU1Nhbu7u4FX2Dc6nQ5CoRA8Hg9CoRAsFssg9TvdDYiTk5PNxnZluGi1WhQUFAxbHBnK689QULNKmUwmEhMTjX5yv3b9Ol54+VUolEq4e3jCg80B084Otix7uHv7wM3LG04ufd9sKOVS1JaWQNjWAhumDWxYLNjaseDh7QN2wDg4urgYde1DRafVovjWdcgkEiRMmT6itJxCJoWwtRkyiRh2TCYcWXbwcnPDwrlzsGTJYpP/nqipNQKBAB0dHfTNDJvNhouLy12fo1QqRU5ODgICAhAREWEVe0NktOr+amtrkZWVhdDQUBw7dszsu+KtGA6r4BsGjY2NqK2tpVvFh8pQO3FHg4E86Dw9PYd8crEU25WholKpkJubS8/2HGmKhRLZlPiztbXt4fVn7IuhOXkGisViZGdn4/fsbNTU1kGp0UGjI6AlSBAMBhgMBpw9POHhzYaLhwdsbe8IU4Ig0N7WirryEihlMtjasWDLsgPLwQHsgHHw8vWDzSimwuorylBXWoyY9Ey4uA39Zo3Q6dAhFEDEawV0WrBsbWBvawN3Z2esXL4MS5YsMXtxpNFoaPEnFAp71KNRFlLZ2dkICgoaE53sEokEOTk5CAsLw/jxA5crGBKVSgWhUGjwur/GxkZkZWWBw+Hg5MmTZufsYMW4WAXfMGhpaUF5eTmmTJky5OfodDoUFBSAz+eb3UxcgiAgEonoejSqeJvD4cDT07Pfk4ul2q70h0wmQ25uLu0TZuhi6t7HGQAt/ry8vAz+ejKZDFwul+6ONPfuO61Wi7KyMvx+6xbyCgrR2SWDWqeDliChA0CAAZa9AzzYvnDz9IKNHQsN5SVoa6wHg8GArZ09bO1s4eLuAd9xwXB2M2zXqaRDhMLrV+Dl54+QyIFHjilkMgjbmiGXdMKWATjY2cHT1QUL5s7G0iVL4OLiYvGRMJ1OR3+fKe9KnU4HDocz7OYzc8JUYq83hqr7a2lpQVZWFtzd3XH27FmzrDO2Ylysgm8Y8Pl8FBQUYPr06UPavnsnrr+/P6Kjo832ZEgVb1N2L/0ZEI8V2xUK6v0EBASMSs0RSZLo6OigxZ9Op6PtXqiZkiOBej+BgYEWKSZ6Q70fqkv6FpeLhqYWqLRaaHQkdAQJAgwwbGwABgPidj60Gi3sWPawY91JJ3v7BcDHz1/v8WhajQYFN65AKZchccqMHsKZ0OkgbhdAxGsDqdXAzoYJZ3sWJoaFYe3qlf02dkkkEnC5XAQHBxusWcuUdHZ20hM0VCoVVCoVLUp8fHwsLvJPib3Q0FCEhISYejk0w6374/F4WLlyJezs7HDhwgW4mElphJXRxSr4hoFIJMLt27cxa9asQbft3okbERFhlOkcxoI6uVBTPrRaLXx8fGBvb4/GxkZMmDBhTNiuCIVCFBQUIDw83CR38iRJQiKR0OJPqVT2EH/6RoLb29uRn59vsvdjaKjRb0OJtKjVahQWFuL3m7dQWFoKqVwBtY6ARqtDW3MzxB3tYDk4wsXDE86ubnB2dQM7MAjuXt5g9BEBrSkuRENFCeInzwCTyUB7WytknR2w+W/UzsPFGfNmz8SypUvh5uY2pPdD+biZOnJkKKgaN0ockSQJmUxGi5Kuri54eHjQdX/mHlmixHhISIhZib2+6K/uz8bGBuPGjQOTyYRQKMTq1auh1Wpx8eLFUasZt2J+WAXfMOjs7MTVq1cxb97A3mGj1Yk7GlCipKqqCiKRCEwms4cBsaWNEaJoaWlBaWkpYmNj4efX9xSI0aT7xXI4o/Ta2tpQXFyMmJgY+Pv7j9KqjYdAIEBhYWGfo9+GS2NjI27dvo0bN2+hoqoGTc1N0Gg0cHRxhZ29A+wdneDB9kVNcQF0Gg1CwsLh5GCHiPEhuHfNKsTHxw87PS4SiZCXl4cJEyYYbRb3aEKJ14EaGpRKJS1KqKYPKmvQV9OHKenq6kJOTo5FiL3edK/7e+SRR6BUKjFjxgwUFhaCJElcvXp1yCbrVsYmVsE3DKRSKc6fP4+FCxf2u01zczOKiopgY2ODlJQUi7+r6m67QjUzUGlfhUIBLy8vesSbudQmDgRJkqitrUV9fT0SExPhZUTvtJHQe5Seu7s7fZx7R0oaGxtRWVmJ+Ph4sNlsE63YcLS2tqKkpARxcXFGv1nqbqvT3NyMnJwcrFixAhEREQYTJVQkOSoqCgEBAQZYtWnp6OhAXl6eXibEVAc71fRhZ2dH3zR6eHiYtM6UEnvjx4+3qExMX3R1dWHfvn3YvHkz2tvb4e7ujmXLlmHFihVYsGCBQVO6X331FT37NjExEV988QUyMjL63Hb79u149NFHezxmb28PpVJJ/5skSbz99tv497//DbFYjKlTp+Kbb77BhAkTDLbmPypWwTcMlEolTp06hQULFtx1gqImGdTW1pq8E9dQDGa7QkWkqOkT+kSkTAFJkigrK4NAIEBycvKwp02MNr0jJdQ0FTabDR6Ph4aGBiQnJ1u8ByLwP/GakJAAHx+fUX3t7rY67e3tYLFYPTpRhyP+eDweiouLERsba9GRfgoqUjlx4kSMGzduWPugmj6oZgSSJOmsgbe396jWOY8lsQfceT8PPvgg6urqcPnyZdTV1eHw4cM4fPgw6uvrMW/ePOzZs2fEwm/v3r1Yt24dtm3bhszMTGzduhX79+9HeXl5n8b727dvx//93/+hvLycfozBYPT4TXz00Uf44IMP8NNPPyE0NBRvvvkmCgsLUVJSYu0qHiFWwTcMNBoNfvvtN8ydO7dHNIsytxUIBHB3d0dSUpJFRLsGQq1WIy8vDwCGZLuiUCjomj+JRELX7gzVsNXYUOJVJpMhOTnZYsW4Wq3u4anIYDAQEBCAcePGGdRQ2xTU1tairq7OLMRr707U7uPHujcxDURraytKS0vHTOSVqhE1ZJqdqhembmiUSiW8vb3pY23MG8exJvZkMhnWrVuHkpISXL9+/a7PqLy8HOfPn8fTTz894tfKzMxEeno6vvzySwB3mv6CgoLw7LPP4tVXX71r++3bt2PTpk0Qi8V97o8kSQQEBODFF1/ESy+9BOBOCRWHw8H27dtx//33j3jNf2Qss/DKxFD1ajqdjhZ0arUat2/fRldXF/z9/RETE2P2NhiDMRzbFUdHR7r+RalU0unIiooKuLm50SPeTCG0NBoN8vLyQJIk0tPTLVqMs1gs+Pn5QSgUwtHREePHj0dHRweys7PpNBmHwxmRofZoQ42yo0zNzSHyamNjQ4uO7uPHysrKoNFoejTX9FXH2tTUhIqKCiQmJsLb29sE78CwGCstzWAw4OHhAQ8PD0RERNDNCE1NTSgtLaXHFrLZbIMaUVNij+qWtnQUCgX+9Kc/obCwENeuXetTkEdGRiIyMnLEr6VWq5GTk4PXXnuNfozJZGLevHm4ceNGv8+TSqUYP348CIJASkoKtmzZgtjYO1Nqamtr0dbW1qM+3t3dHZmZmbhx44ZV8I0Qq+AbBgwGA0wmE1qtFoBld+L2hyFsVxwcHBAcHIzg4GC6RorH46GqqgouLi70iLfBxpYZAoVCgdzcXLMwIDYEWq0W+fn50Gq1yMjIAIvFQlBQUI+IVF5eHhgMRg9DbXO9CSFJEqWlpWhvb0daWtqofCf0hclkwsvLC15eXpg4cSK6urrA5/NRU1ODoqIiOiJFlTI0NDSguroaycnJY6JYXiAQoKCgwOgNQQwGAy4uLnBxcUFoaChdyiAQCFBZWQlnZ2f6OI8kmk35IAYHByMsLMzA72L0USqVePLJJ3H79m1cvXrV6B3gQqGQ9l3sDofDQVlZWZ/PiYyMxA8//ICEhAR0dnbik08+wZQpU1BcXIxx48ahra2N3kfvfVJ/szJ8rIJvmNja2tKGmDk5OSBJEomJiX3WLVgafD4fRUVFiIiIMJjtir29PcaNG4dx48bRbv08Hg/V1dVwdnamI1LGmDvb1dWF3NxcsNlsREVFWUzEqz/UajVyc3Nha2uL1NTUHpGlviJSfD4fxcXF0Ol0PTwVzUX0EgSBoqIidHV1IT093SxS/4PBYDDg5uYGNze3HhGplpYWlJWVwd7eHmq1GvHx8WNK7I1GA01vHBwcEBQUhKCgIGg0GnpCEBXNpr7v+tzQSKXSHhNBLB2VSoWNGzfi0qVLuHz5MsLDw029pD6ZPHkyJk+eTP97ypQpiI6Oxrfffov33nvPhCv7Y2AVfMPExsYGjY2N+PHHH7Fo0SKkp6cP2YfLnGloaEBVVRXi4uKMJl7t7OwQEBCAgIAAaLVaum6nrq6OnjvL4XAMUotGebhR9TmWLvYUCgW4XC5cXV0RFxc34AWue0QqMjKSNmytqKiAWq2Gt7e3yW11qAk0KpUK6enpZtnkMxScnZ3h7OyM8ePHo7y8HC0tLXB1dUVBQQF9Q2OONiRDgc/no7Cw0CRirzd2dnbw8/ODn58fPblGIBCgqKgIBEH0qK/s7ztNRfaCgoLMVhjpg0ajwQsvvIBTp07h4sWLiI4eeAqMoaAM4nk8Xo/HeTzekC2u7OzskJycjKqqKgCgn8fj8XpEkXk8HpKSkgyz8D8wVsE3TKqqqvDiiy9CoVDghRdesHiOo46zAABdBUlEQVSxR3UXt7a2IiUlZdSK5W1tbeHv7w9/f/8ec2cNUYtGedJFRUUZrLjclEilUnC53GFFKrvXSE2YMAFSqZQW2cXFxT3E32iJLqqmEgBSU1MtuqYS+N9viM/nIzMzE87Ozj06fuvq6mBvb0+LP0uor+TxeCgqKkJ8fLzZZS8oL1AfHx9ERUXR5uXV1dUoKirqcwIFJfbGjRs3ZsTeyy+/jIMHD+LChQv9TnYxBiwWC6mpqTh37hyysrIA3InWnzt3Dhs3bhzSPnQ6HQoLC7FkyRIAQGhoKPz8/HDu3Dla4EkkEty8edMgTSZ/dKxdusOgrKwMsbGxsLOzQ1ZWFu6//37MmDHDIlJRfTGY7Yqp1iQSicDj8SAQCGBjY9OjFm2wCyUVqRwrnZGUwS1Vb2RIodDbrX80OqvVajW4XC5YLBYSExPNJr08XLrXIKampvb5G+o9E5Xq+DXWLOWRYsndxb2/0+7u7nB3d0dLSwst9sxdbA+GVqvFX//6V2zfvh1nz55FZmbmqK9h7969WL9+Pb799ltkZGRg69at2LdvH8rKysDhcLBu3ToEBgbigw8+AAC8++67mDRpEiIiIiAWi/Hxxx/j0KFDyMnJQUxMDIA7tiwffvhhD1uWgoICqy2LAbBG+PTk+vXrWLFiBZ566imkp6dj3759eOCBB+Dh4YE5c+Zg1apVmD17tsV8MbvbrphTSq13LVpHRwd4PB4KCgoAgI789a7b6W4QnZqaavGG18D/pk0YazoDlY4cqLOazWYbrJFCqVSCy+XS3d/mJnT0hSAIlJSUoLOzc8AaxO43Ld3rK0tLS6HVaukoa38dv6MJVYtoqd3F3b/TKpUKTU1NqK2tBUmS4PP5AAA2mw03NzeLFH5arRbvvPMOfvzxR5w8edIkYg8A7rvvPggEArz11ltoa2tDUlISTp48Saf+Gxoaevy+Ozo68Pjjj6OtrQ2enp5ITU3F9evXabEHAC+//DJkMhmeeOIJiMViTJs2DSdPnrSYa6o5Y43w6cGePXvw5z//GX//+9/xl7/8hX5cJpPh0KFD2LNnD86fPw8XFxfMnj0bq1atwty5c83W6204tiumhiRJdHR00KKEakTgcDjw8PBAWVkZOjs7kZycbJadnvpiytFvarWajpK0t7cbpBZNJpOBy+XC29sb0dHRFnmx7Q5BECgsLIRcLkdKSkq/w+sHgiRJuuOXz+fTk2tGO8VO0dzcjPLycosVe72RyWTIzs5GYGAgxo8fT3exC4VC+sbS3LvYu6PT6bBlyxZ8/vnnOHr0KObMmWPqJVmxEKyCb4ioVCpMmTIFmzdvxuLFi/vdTi6X4+jRo/jll19w9uxZODk5YebMmVi1ahXmzZtnNiLEELYrpoYya6WmfCiVStja2mLChAnw9/e3CAE7EPX19aiurjaLC69Wq6Vr0YRCIVgslt61aF1dXeByufD398eECRMs8jvXne4NJykpKQYTZtTkGoFAQKcjqWNt7JtHyjcwKSnJbMcN6gMl9gICAhAREdHjO0dlDqhjrdPp4OPjAzabbRZR1r7Q6XT49NNP8dFHH+HQoUMDjve0YqU3VsGnBwRB6HUHqFAocPz4cfzyyy84ffo07O3tMXPmTGRlZWHRokUmE3/GsF0xJSqVClwuFzY2NnB3d4dQKIRSqaRNcU3ZhTocKAPi5uZmJCcnm11amqpFoy6U3VOV/c1DpWoQKVNuSxd7lA8iQRBGnajTe5yei4sLfawNbWHU2NiIqqoqJCUljQkrmYHEXm9IkoREIqGPtVwu7xFlHU7k1tAQBIHPP/8c7733Hvbu3Yvly5ebeklWLAyr4BsllEolTpw4gd27d+P06dOwsbHBjBkzkJWVhcWLF4/aVIHRsF0ZTWQyGXJzc+Hh4UFPNyFJEjKZjB7xJpPJ4O3tDQ6HAzabbdbdoARBoLS0FCKRCCkpKWYTEe6P7lESPp8PkiR7NCLY2NjQo7iMVYM42mg0GuTm5sLGxgZJSUmjFkmm/CsFAgGEQqFBO367m0SbepydIZDJZMjJyYG/v/+gYq+/51PHurOzE25ubvT32hS/SZIk8c033+DNN9/Ejh07sHbt2lFfgxXLxyr4TIBarcapU6fw888/4+TJk2AwGJgxYwZWrFiBxYsXGyWi0912JSkpaUyc1Km0dGBg4IAndSpFxuPxIJVK4enpSYs/c7hzp6AsCqh6MEsrUu6dYtdoNHBxcYFEIkFUVBTGjRtn6iWOGKq72N7eHgkJCSYrG+gdZWUymcPu+K2rq0NtbS1SUlLMLpo8HORyObKzs+Hn52eQ0gGVSkWXM4hEIjg6OtLHejSaPkiSxPfff4+XX34Z33//PR566CGjvp6VsYtV8JkYjUaDM2fO0OJPp9Nh2rRpWL58OZYtW2YQYWaOtisjhepc1TctrVAoaEEyWhYkQ0Gj0dApwuTkZLOOQg4FkiRRXV1Ne8+p1Wp4eXmBw+HAx8fHbLrB9YEqHaDG85lLgX/3jl+qkYkqZxjIgBi4M7u0vr4eKSkpFu8lChhe7PVGq9X2sNYZidAeCiRJYteuXdi0aRO++uorPProoxZfDmHFdFgFnxmh1Wpx/vx57Nq1C7/99hvUajWmTZuGe+65B8uXLx9WXU1325WkpCSLvND2prm5GWVlZSN2/u9uQSIWi2kLEg6HM6qd1ZSQcHBwMGnUyJBQDSdU8T8VZeXz+ejq6oKnpyddH2UJkUylUomcnBy4u7vTpQPmCFWLRkX+Bur4ra6uRmNjI1JTU0etpMSYUGKPw+GMSiNad6EtEAig0Wh6NH2M9KaNJEns3bsXGzduxKeffoqnnnrKKvasjAir4DNTdDodLl68iF27duH48eNQKBSYMmUKLf58fHwG3Ycl2q4MBEmSqKmpQUNDAxITEw3aRahWq2lBIhKJ4OLiAg6HY/SaHblcDi6X26MG0ZKhPqPGxsZ+G04UCgU9S5mqj6KirOYYfZbL5cjJybFIK5neQtvDwwNsNhsKhQI8Hg+pqalwcXEx9TJHDPUZ+fr6msR1gLLWoZo+ZDJZj0kfw7mpOXDgAJ588kls3rwZmzZtsqjvnRXzxCr4LACdTocrV65g165dOHbsGKRSKSZPnoxly5ZhxYoVYLPZd50MBAIBiouLERAQMCYsMAiCQFlZGYRCIVJSUox6kaKK43k8Hl2zQ4k/Q85CpWxK/Pz8LNYapzskSaK8vFwvIaFSqeiLpEgkor3+OByOwbtQhwNV/D9aUSNjQkW06+vroVQq4ezsDD8/P6N0/I4mCoUC2dnZJhN7fSGXy+nvdWdnJ1xdXXsYmA+2xqNHj+JPf/oT3njjDbzyyitm8Z6sWD5WwWdhEASBa9euYdeuXTh69CjEYjEmTZqEZcuWISsrCxwOBz///DP+9re/4dixY4iKijL1kkeMKZsZKP85Ho8HoVAIBwcHOho1koJtkUiE/Pz8MWNTQk2bEIvFSElJGVakrvvcWUMe6+HS1dXVY+6qpX9G1BSatrY2JCQkQC6X06ba1LFms9kWMeOXghJ7bDYbkZGRZrluysBcIBDQx5qq++vrWJ86dQobNmzACy+8gLfeesss35MVy8Qq+CwYgiBw8+ZN7Ny5E0eOHEF7ezsCAwPR0NCALVu24Omnn7b4kwVVg8hgMIzqdzYUdDodLUgEAgHs7OzoaJQ+F0nKBzEyMhKBgYFGXrXxIQgCBQUFkMvlSE1NNUjn80Bef0OZpTxSOjs7weVyERISgtDQUKO+1mhAdenz+fy7Zv321fHb/Viba5mBJYi93nQ/1kKhEAwGAzdv3sT48eOxbNky3Lp1Cw8//DCeeuopbNmyxSLekxXLwSr4xgharRbr16/HwYMH4erqSs/1XLp0KVavXo2AgACLO3koFArk5ubC2dnZ7GoQCYKgT9x8Pn9I5sPA/8ZWjRUfRMqAWKvVIjk52ShNQQRB0OOwBAIBSJKkj7UxOiM7OjqQl5eH8PDwMWFMTpIkXQ6RlpY2YEMS5atIpSO7d/z6+PiYzW/QEsVeb6imj/fffx8HDx6EWCwGQRCYM2cOdu/ePSYmnVgxL6yCbwygUCjwyCOPoKCgACdOnEBoaChyc3Oxc+dOHD58GC0tLUhLS8OSJUuwevVqBAUFmf0Jkqpv43A4Zn9Cpy6SPB6vX0FCkiTq6upQV1dn8IYTU9HdgDgxMXFUppmQJNnDgkSr1RpUkFAm0RMnThwTvoEkSdJG3qmpqXp1n3fv+OXz+VAqlfD29qaPtak6/imx5+Pjg6ioKLM+NwyV69evY+3atQgPD6fnM8+aNQsrVqzAihUrDGZY/tVXX+Hjjz9GW1sbEhMT8cUXXyAjI6PPbf/9739jx44dKCoqAgCkpqZiy5YtPbbfsGEDfvrppx7PW7hwIU6ePGmQ9VoxLFbBZ+EolUrMnTsXAHD48OG7undJkkR+fj4t/hoaGpCamorFixdjzZo1CA4ONruUjSXXt1GChJryodPpwGazodFo0NnZOWYsMCgrGUdHR8THx5sk8kN1RnafpUwJkuFMVKG8HaOjo+Hv72+kVY8eJEmipKQEHR0dSEtLG3Htq1QqpSN/VMfvaHtYKhQKumN6rIi9nJwcrF27FosXL8b3338PJpOJ+vp6HD58GIcOHcKVK1dQU1MzYtG3d+9erFu3Dtu2bUNmZia2bt2K/fv3o7y8vM9sw0MPPYSpU6diypQpcHBwwEcffYSDBw+iuLiYLkXZsGEDeDwefvzxR/p59vb2Y2I031jEKvjGAD///DNWrVo16N07SZIoKirCzp07cejQIdTW1iI5OZkWf6GhoSYXf21tbSgpKUFUVBQCAgJMupaRQom/0tJSyOVyMBgMsNls2nzYXNJj+kJddM3NSkYqldLRKKlUqtcsVB6Ph6KiohF7O5oLJEmiuLiYvskwtCDr7WHZvQvVWB30SqUS2dnZY0rsFRQUYPXq1Zg1axZ27NjR5zlBLBYbxIA/MzMT6enp+PLLLwHcyUwEBQXh2Wefxauvvjro83U6HTw9PfHll19i3bp1AO4IPrFYjEOHDo14fVaMj1Xw/UGh7v537dqFQ4cOoaqqComJiVi8eDHWrl2L0NDQURcklFlvQkLCkHwGzR2dToeCggIolUokJyfTXn9UNKp7KtJSJmtIpVJwuVz4+vqadaqdmqhC2WK4u7vT0ajeN0YtLS0oKytDfHw82Gy2iVZsOAiCoCfrGKqJZiDUajXdzNS949eQ3dWU2PPy8rI4L8T+KCkpwapVq5Ceno59+/YZ9XyrVqvh5OSEX3/9FVlZWfTj69evh1gsxuHDhwfdR1dXF3x9fbF//34sW7YMwB3Bd+jQIbBYLHh6emLOnDnYvHkzvL29jfVWrIwAq+CzQnfw7dy5EwcPHkR5eTkSEhLoyF9ERIRRT0bd5/z2Z9ZraVD1bX11F5MkCZlMRqd9ZTJZj1SkuU5DoWYXW5pNSW+vPxcXF1qQdHR0oLKykp4IYulQ9V9Ux/Rof5eoTnbKhsTGxoa2IBlux+9YFHtVVVVYsWIF4uLicODAAaPf8LW0tCAwMBDXr1/H5MmT6cdffvllXLp0CTdv3hx0H3/5y19w6tQpFBcX0xHjPXv2wMnJCaGhoaiursbrr78OFxcX3Lhxw2IzGGMZq+Cz0gNqBuquXbtw4MABlJSUIDY2lhZ/kZGRBv0hEwRBp56G699mbiiVyh4zVwc7Xv2NHfP19TV6dGaoUHWVYWFhGD9+vKmXM2woU23KFoMkSfj7+yM4OBiurq4WLSYosadQKJCSkmLyGweqmYn6bhMEQYs/b2/vIZ1HxqLYq62tRVZWFsLCwnD06NFR+ZxGKvg+/PBD/P3vf8fFixeRkJDQ73Y1NTUIDw/H2bNn6dpyK+aDVfBZ6ReSJFFbW4uff/4ZBw4cQEFBAWJiYrBo0SKsXbsW0dHRIxJ/o2HpMdrIZDJwuVz6AqVvRKOvVCQ15cNUM2epZoax4htIfa/r6+sRGhpKj8SifBUpax1LEhcEQSA/Px8qlQqpqalmVyJAkiQ6OztpsT2UBhtqfjFVK2pJn0d/NDY2YsWKFfD398fJkydH7YZuJCndTz75BJs3b8bZs2eRlpY26Gux2Wxs3rwZTz75pCGWbsWAWAWflSFBkiQaGhrw888/4z//+Q/y8vIQFRWFhQsXYs2aNYiLi9PLloPq8rS3t0dCQsKoWHoYGyrlGRgYiIiIiBFfoFQqFV3zJxaLTTJztrW1FSUlJWOqmaGqqgotLS09xr9191UUCAR0g42xvP4MiU6nQ35+PjQaDVJSUsxO7PWGKmno3mDj6elJH28HB4cxKfZaWlqQlZUFd3d3nD17Vi+LHEOQmZmJjIwMfPHFFwDufOeDg4OxcePGfps2/v73v+P999/HqVOnMGnSpEFfo6mpCcHBwTh06BCWL19u0PVbGTlWwWdFb0iSRFNTE3bv3o3//Oc/yMnJwcSJE7FgwQKsXbt2UAFHRcE8PT3NqstzJFD+beHh4UZJeVINH73r0KiZs8agsbERlZWVY6aJhpr1S02b6O+4UYa41PGmrHX0SUWOFpTYo6Lk5i72+kKhUNCRP7FYDGdnZ6hUKnh4eCAxMXFMiL22tjasWrUKLBYL58+fN+os8P7Yu3cv1q9fj2+//RYZGRnYunUr9u3bh7KyMnA4HKxbtw6BgYH44IMPAAAfffQR3nrrLezevRtTp06l9+Pi4gIXFxdIpVK88847WL16Nfz8/FBdXY2XX34ZXV1dKCwsNJtyFCv/wyr4rIwIkiTR0tKCX375Bb/++iuys7MRERGB+fPnY/Xq1UhJSekh/i5dugSZTIaJEydaVOH/QLS1taG4uBjR0dGjYiXTvQ6tvb0djo6OtPhzcXExyDGtra1FXV0dkpOTDWIJYWq6e9LpY0Dc3XyYx+NBpVKZTXe1TqdDXl4eCIJAcnLymIiSS6VS5OTkgMFgQKPRwNHRkRbbppinbAiEQiFWr14NrVaLS5cuwc3NzWRr+fLLL2nj5aSkJHz++efIzMwEAMyaNQshISHYvn07ACAkJAT19fV37ePtt9/G3/72NygUCmRlZSE3NxdisRgBAQFYsGAB3nvvvTGRDRiLWAWfFYNBkiTa2tqwZ88e7N+/H7du3UJoaCjmz5+PNWvWoLKyEps2bcKnn36KDRs2mHq5BoGKgpnK0kOr1faY72tvb0/X/A3nAkmlPJubm8eMSTTVGNTV1YWUlJRh10L21V1Nef35+vqOag2qVqvt0QU+FsSeSqVCTk4O3NzcEBsbe9fc2aGOLzQnOjo6sGbNGnR1deHKlStWQ2IrJsUq+KwYBZIkIRAIsHfvXuzbtw/Xr18HSZKYPXs2Xn31VWRkZFhk+omCJEnU1NSgoaHBbKJg1AWSx+NBKBTC1tZWryYEagxXe3s7UlJSjJYqHk0IgkBBQQEUCoXBbUrkcjmd9pVIJKM2eYISe0wmE0lJSWaVYh4uvcVe7+9q745fkiTpSKu5pdkpOjs7ce+990IgEODq1atjoizCimXzhxR877//Po4fP468vDywWCyIxeJBn0OSJN5++238+9//hlgsxtSpU/HNN99gwoQJ9DYikQjPPvssjh49CiaTidWrV+Ozzz4zSb2GuUAdt88//xyPPfYYuFwurl+/jsDAQMybNw+rVq3C5MmTLapDlxpGLxAIkJKSYpafb19NCFTat6/oCGXWS0XBRrug3BiMZjODUqmk0+wdHR305AlfX1+DCmfK39HW1haJiYlmKXT0ZTCx1xuq45cSf1Sanc1mD2uknjHo6urCgw8+iPr6ely9ehV+fn6mXpIVK39Mwff222/Dw8MDTU1N+P7774ck+D766CN88MEH+OmnnxAaGoo333wThYWFKCkpoe/mFy9ejNbWVnz77bfQaDR49NFHkZ6ejt27dxv5HZknWq0WTz/9NE6ePImTJ08iNjaWHje2f/9+7N27F1euXIG/vz/mzp2LVatWYerUqWZd7GuJwqiv6Ag14s3LywskSaKgoAAqlcos/NsMgVarRV5eHkiSHPX6NmryBI/Hg0gkMliNpUajAZfLBYvFQkJCwpgSe66uroiLixtWCUJfHb+U3YsprIxkMhnWrVuHkpIS+ubWihVz4A8p+Ci2b9+OTZs2DSr4SJJEQEAAXnzxRbz00ksA7oTrORwOtm/fjvvvvx+lpaWIiYnB7du3aa+ikydPYsmSJWhqarL4ubDD4cMPP8TPP/+MEydOYNy4cX1u09nZiV9//RV79uzB5cuX4evrizlz5mD16tWYNm2aybzn+mIs+AZSgptqQtDpdGAwGGCxWCOqbzMnqCiYjY2NyVOe3WsshUIhWCwWHflzd3cfssBRq9XgcrlwcHBAQkKCRdSvDYZarUZ2djZcXV0RGxtrkPfU28fSzc2NbvoYjRIFhUKBRx99FFwuF9euXbNok3IrYw+r4BuC4KPcw3Nzc5GUlEQ/PnPmTCQlJeGzzz7DDz/8gBdffBEdHR3037VaLRwcHLB//36sXLnSSO/CfJHL5VCr1UOub5NIJDh48CB++eUXXLp0CV5eXpg9ezZWr16NmTNnmlSMqNXqHqm0sVIkn52dDYIgANwRSt07UC3xPVLCiPJ3NKcomE6ng0gkuivNPtjYMbVajZycHHpyy1gRezk5OXB2dkZcXJxR3pNare4xUo+KtLLZbKN0/CqVSjz++OO4fv06rl69ivDwcIPu34qVkWJ5Z3QT0NbWBgB3tZpzOBz6b21tbfD19e3xd1tbW3h5edHb/NFwcnLSyyDYzc0N69evx/r16yGVSnHw4EHs2bMHDz74IDw8PDB79mysWrUKs2fPHtVUqkKhAJfLpdNOY+GCS41/655Kk0ql4PF4qKmpQXFxMby9vcHhcExuPzJUqPSgi4uLWX5O1FxZNpvdw+uvqKio37Fj5v6ehsNoiD0AYLFYCAwMRGBgILRaLV3TyuVyYWtrSx9vQ3T8qlQqPPPMM7h8+bJV7FkxW8aM4Hv11Vfx0UcfDbhNaWkpoqKiRmlFVkaCi4sLHnnkETzyyCOQyWQ4fPgw9uzZg/Xr18PFxQWzZs3CypUrMX/+fKOKP6lUCi6XCzabjaioKIv0AesNZXzt7e3dYz6pq6srXF1dERERAalUCj6fj7q6OhQXF8PLywscDgdsNtssU9kKhQI5OTm0mbe5f05MJhNeXl7w8vJCZGQk3YRQUVEBtVoNHx8feHp6oqGhgW5msIq94WNrawsOhwMOhwOCIOhIa2FhIV3Tymazh9Xxq1ar8cILL+D06dO4dOkSIiMjjfQurFgZGWNG8L344ouDeruFhYUNa99UhxWPx4O/vz/9OI/Ho1O8fn5+4PP5PZ6n1WohEomsHVojxNnZGQ8++CAefPBByOVyHDt2DL/88gv+/Oc/w9HREbNmzUJWVhYWLFhg0DodsViMvLw8BAUFISwszOxFxFDo6uoCl8uFv78/JkyY0O97otz0w8LCaPuRpqYmlJaW0kXxvr6+ZtFgI5fLkZOTAx8fH4sU5QwGAx4eHvDw8MCECRMglUrR0tKC8vJykCQJJycntLa2mq3YHiqmEnu9YTKZ8PHxgY+PT4+O34qKCr2NtTUaDV555RUcPHgQFy5cQFxc3Ci9CytW9Mdaw6dH08ZLL72EF198EcCdejNfX9+7mjays7ORmpoKADh9+jQWLVr0h23aMDZKpRLHjx/HL7/8gtOnT8POzg4zZ87EypUrsWDBghGZBguFQhQUFGDChAkICgoy4KpNh1gsRm5uLkJCQhASEjIsYdS7KN7d3Z0Wf6boWKYmMwwmYC2J7tHK8ePH03VoXV1do+b1Z2gsoQ6RJEk6si0QCHp0/PZ1c6PVavH6669jx44dOHPmDD2xwooVc+UPKfgaGhogEolw5MgRfPzxx7hy5QoAICIigvZUi4qKwgcffEA3W3z00Uf48MMPe9iyFBQU3GXLwuPxsG3bNtqWJS0t7Q9ryzKaqNVq/Pbbb9i9ezdOnz4NJpOJ6dOnIysrC0uWLNFL/LW2tqKkpASxsbFjJjpLzfo1pIBVqVS0+KO856gpH/rUbg4XiUQCLpc7piKwCoUC2dnZfUYrlUolfbzFYjHc3NxoMTIax3u4UI00jo6OZiv2+qL3zQ2LxcKZM2ewdu1axMTE4J133sG3336LU6dO9Zg1a8WKufKHFHwbNmzATz/9dNfjFy5cwKxZswDcSbP8+OOPdJqYMhD+17/+BbFYjGnTpuHrr7/GxIkT6eeLRCJs3Lixh/Hy559/bpbGvGMZtVqN06dP4+eff8bJkydBkiSmT5+OFStWYOnSpXB3d+/3uQ0NDaiqqkJiYiK8vb1HcdXGg8fjoaioCDExMT1KEgwJ1RFJec85OzvT4s8Y3//Ozk5wuVyEhoYiJCTE4Ps3BVRqms1mIzIyckAB270Dtb29Hc7OzrT4M9Q8ZUOg0WiQk5NjcWKvN2q1Gnl5eXj99ddx+/ZtuLm5QSKR4IsvvsCTTz5pNsfbipWB+EMKPit/HDQaDc6dO4ddu3bhxIkT0Gg0mDZtGlasWIFly5bRsy0JgsC7776LlJQUzJw5c0BRaEm0tLSgtLQU8fHxd3WRGwuNRkMbD7e3txvMeJhCJBIhLy9vTKXbZTIZcnJywOFwMHHiRL2OEXW8Ka+/kc5TNhSU2BtL3oE6nQ6bN2/GP//5T0yZMgVcLheenp7IysrCypUrMW3aNIPaGX311Vf4+OOP0dbWhsTERHzxxRfIyMjod/v9+/fjzTffRF1dHSZMmICPPvoIS5Ysof8+lIlRVsYuVsFn5Q+DVqvFhQsXsGvXLvz2229QKpWYOnUqlixZgtOnT+P27ds4cuQI4uPjTb1Ug0BFK5OSkuDl5WWSNfRlPDwSMULVVkZGRo6ZCQYymQzZ2dkICAhARETEiAQaNU+ZqkOzsbHpMU95tETXWBR7BEHgs88+w+bNm7F3714sX74cKpUK58+fx8GDB3H48GFERkbi8uXLBnm9vXv3Yt26ddi2bRsyMzOxdetW7N+/H+Xl5X3evF2/fh0zZszABx98gGXLlmH37t346KOPwOVy6WaSoUyMsjJ2sQo+M0LfWbx1dXUIDQ3t82/79u3D2rVrAaDPC8gvv/yC+++/33CLtzB0Oh0uXbqE7du3Y9++fVCr1Zg2bRrWrl2LFStWwNvb22LTNCRJoqamBo2NjUhOTjabaGVvMWJra9tDjAx2vCnPupiYmDFTW0k1nQQGBiI8PNyg37n+RupRXn/GEmFjUeyRJImvv/4ab731Fnbs2EGfW7uj0+nQ2tra71QhfcnMzER6ejq+/PJLAHc+z6CgIDz77LN49dVX79r+vvvug0wmw7Fjx+jHJk2ahKSkJGzbtm1IE6OsjG2sgs+M0HcWr06ng0Ag6PHYv/71L3z88cdobW2lhSJVj7ho0SJ6Ow8Pjz/8HV1nZydWrFgBpVKJ119/HUePHsWxY8cgkUgwefJkLF26FCtXrgSbzbYY8UeSJCoqKtDW1obU1FSzrR+lvNB4PN6Qpk60tbWhpKQEcXFxo5aaNjZdXV3IyckZlaYTyn6Ex+OBz+fTU1U4HA68vb0NlobsPu83MTFxzIi977//Hi+//DK+//57PPTQQ0Z/TbVaDScnJ/z666/IysqiH1+/fj3EYjEOHz5813OCg4PxwgsvYNOmTfRjb7/9Ng4dOoT8/PwhTYyyMrYZMz58lk5paSlOnjzZYxbvF198gSVLluCTTz7p09bFxsbmrkjHwYMHce+99951offw8BgzURFDwOPxsGjRIvj5+eH48eNwdnbG8uXLQRAErl+/jl27duGTTz7BX//6V2RmZmLZsmVYuXIlOByO2Yo/giBQWlqKjo4OpKenm3XnZncvNGrqBNVc0jsS1draivLyciQkJMDHx8fUSzcIlNgLDg4etj+oPnT3+ps4cSK6urrA5/NRXV2NoqIieHt702PHhjtVZayKvR07duCVV17B119/jQcffHBUXlcoFEKn0/U53amsrKzP57S1tQ06DYp6rL9trIxtLP8XOUa4ceMGPDw8aLEHAPPmzQOTycTNmzeHtI+cnBzk5eXhT3/6011/e+aZZ+Dj44OMjAz88MMP+KMHdj/55BPExsbiyJEjPcyamUwmpk2bhm3btqGxsRHnz59HTEwMtm7ditjYWCxZsgRffvklWlpazOoYEgSBwsJCdHZ2Ii0tzazFXm+oqRPR0dGYMWMGPau4rKwMFy5cQGlpKUJCQugGG0tHIpEgOzsbISEhoyL2esNgMODm5oaIiAhMmTIFmZmZcHd3R0NDAy5duoScnBw0NjZCpVINeZ9jVezt2bMHL774Iv7xj3/g0UcfNdubPStWhoI1wmcmGGIW7/fff4/o6GhMmTKlx+Pvvvsu5syZAycnJ5w+fRp/+ctfIJVK8dxzzxls/ZbGli1bYGNjM+CFiclkYtKkSZg0aRK++OIL5OTkYNeuXfj666/x5ptvIj09HUuXLsWaNWsQEBBgsouBVqtFfn4+tFot0tLSLHoaA4PBgKenJzw9PcFisVBbWwsOh4OWlhbU1dX1mIJgyG7I0YKykwkLC8P48eNNvRwA/5uqEhoaSnvPtbW1oby8fEhefxqNBrm5uWNO7B04cADPPfcc3n//fTz11FOj+vv28fGBjY0NeDxej8d5PF6/mRo/P78Btx/KxCgrYxvL/2WaOa+++ioYDMaA//UXotcHhUKB3bt39xnde/PNNzF16lQkJyfjlVdewcsvv4yPP/54xK9pydjZ2el1YWIymUhPT8dnn32Gmpoa3LhxAxkZGfj3v/+NuLg4zJ8/H//4xz/Q0NAAgiCMuPKeUJEVkiSRmppq0WKPgiRJVFdXo76+Hunp6YiLi8PUqVPpNHVNTQ0uXbqEvLw8tLS0QKPRmHrJQ0IsFoPL5SI8PNxsxF5vHB0dMX78eKSnp2P69OkICAiASCTC9evX8fvvv6OmpgZSqZSObmu1WuTm5sLW1nbMNGgAwLFjx/CXv/wFb775JjZt2jTqN3MsFgupqak4d+4c/RhBEDh37hwmT57c53MmT57cY3sAOHPmDL19aGgo/Pz8emwjkUhw8+bNfvdpZWxhbdowMgKBAO3t7QNuExYWhl27duHFF19ER0cH/bhWq4WDgwP2799PT/zoj507d+JPf/oTmpubwWazB9z2+PHjWLZsGZRKpVnMQrVkSJJEQUEBdu7cicOHD6Ourg6pqalYvHgx1qxZg/HjxxvtIqhSqXpMMNB36Ls5QpIkKisr0draOmDTiUwmoxsQpFIpvLy86EiUOYrejo4O5ObmWqx3YG+vPwcHB/j4+KC9vR329vZISkoaE98/ADh58iQeffRRvPDCC3jrrbdMFrnfu3cv1q9fj2+//RYZGRnYunUr9u3bh7KyMnA4HKxbtw6BgYH44IMPANyxZZk5cyY+/PBDLF26FHv27MGWLVvusmUZbGKUlbGLVfCZCSOdxTtr1iz4+Pjg119/HfS13n//fXz66acQiUQGWbuVO5AkieLiYuzcuROHDh1CTU0NkpOTsWjRIqxduxYhISEGuyhS81Y9PDwQExMzJiIrJEmirKwMQqEQqampQ65DlMvltPWIRCIZcP6pKaCMoidOnGgwyw5TotPpwOfzUV5eDq1WCxaL1aPD2pLr3M6dO4dHHnkETz/9NLZs2WLy9/Lll1/SxstJSUn4/PPP6Zm9s2bNQkhICLZv305vv3//frzxxhu08fLf//73Po2XB5oYZWXsYhV8ZsRgs3ibm5sxd+5c7Nixo4fbelVVFSZOnIjffvuth/UKABw9ehQ8Hg+TJk2Cg4MDzpw5g5deegkvvfQS3nnnnVF9f38kKPFCib/KykokJCTQ4i88PHzY4k8qlYLL5cLX13fQEVyWAkmSKCkpQUdHB1JTU+Ho6Dis/VDzZnk8Hjo7O+Hu7k6LkeHucyRQM4yjoqIGvWmzFLRaLbhcLmxsbJCQkIDOzk5acAOgj7eXl5dF3YhcuXIFDz74INavX49PP/10TPyurFjpjlXwmRGDzeKljJa7z/wFgNdffx27du1CXV3dXSfYkydP4rXXXkNVVRVIkkRERASefvppPP744xZ1MrZkSJJEVVUVdu7ciQMHDqCsrAzx8fG0+JswYcKQxZ9EIgGXy8W4ceMMbtRrKgiCQFFREaRSKVJTUw0WlVOpVLQQ6ejogKurKz3ibTS6mKmpINHR0UabYTzaUDV7TCbzrjQuSZIQi8X0MddqtT2abMw55fv777/jvvvuw5o1a/DVV19Zz41WxiRWwWfFyihCTcHYtWsXDhw4gKKiIsTFxWHRokVYs2YNoqKi+r0wdnR0IC8vD6GhoQgJCRndhRsJnU6HgoICqFQqpKSkGK3+Tq1WQyAQgM/no729Hc7Ozj3m+xoagUCAwsLCMTUVZCCx1xuSJCGRSGjxp1Qqe4i/4Xr9GYOcnBysXbsWS5YswXfffWcVe1bGLFbBZ8WKiSBJEnV1dfj555/xn//8BwUFBYiJicHChQuxZs0axMTE0NYj+/btQ01NDR5++OExUQcG3BF7eXl50Ol0SE5OHjUR0LsBwdHRkU5Durq6jjhqyufzUVhYiLi4uLtMbi0VfcReb0iShEwmo8Vf9yYbNptt0jrLgoICrF69GrNmzcKOHTvMOgppxcpIsQo+K1bMAJIk0djYSIu/3NxcREZGYuHChWCxWPjss8/w6aef4tFHHzX1Ug0CJSAYDAaSkpJM5qmn0+kgFArB4/EgFArpBgQOhwM3Nze9xR81LSQ+Pn7MjIDT6XTgcrlgMBhITk4esSiivP74fL5J6yxLSkqwatUqZGZmYs+ePVaxZ2XMYxV8VgZFJBLh2Wef7VFb+Nlnnw2YCps1axYuXbrU47Enn3wS27Zto//d0NCAp59+GhcuXICLiwvWr1+PDz74wCINdQ0JSZJobm7G7t278c0336Curg7jxo3DypUrsXbtWnoShaVCeQfa2dkhMTHRbC60Op0O7e3t4PP5EAgEsLGxocWfh4fHoOKvra0NxcXFSEhIGNQayVLQ6XTIzc0FAIOIvd70rrN0cXEBh8OBr69vjwk4hqayshJZWVmIj4/HgQMHLPr3ZMXKULF+y60MykMPPYTW1lacOXOG7h5+4okn6O7h/nj88cfx7rvv0v/uXiiv0+mwdOlS+Pn54fr162htbcW6detgZ2eHLVu2GO29WAIMBgPjxo2ji+APHTqE6upq7N+/H19//TXCwsIwf/58rFmzBikpKWZVDzUYarUaOTk5cHJyQnx8vFnVS1ECz9fXFwRBQCQSgc/nIz8/HwwGA2w2GxwOB56ennetu7W1FaWlpUhMTBwz836NLfYAwN7eHkFBQQgKCoJGo6HrLGtqagyeaqeoqanBmjVrMHHiRPz6669WsWflD4M1wmdlQCh/wNu3b9Nzfk+ePIklS5YM6A84a9YsJCUlYevWrX3+/cSJE1i2bBlaWlroOqdt27bhlVdegUAgMEvz3NGCJEm8/vrr+P7773H69Gl67BFJkuDz+dizZw/27duHmzdvIiQkhBZ/aWlpZi3+lEoluFwuXF1dERsba1ZibyAIgqC7T3k8HkiSBJvNhq+vL7y9vdHW1oaysjIkJibC29vb1Ms1CJTYI0kSKSkpox6F1Wq1PaKtdnZ2tPgbSrS1PxoaGpCVlYWAgACcOHHCLHwarVgZLayCz8qA/PDDD8OaADJr1iwUFxeDJEn4+fnhnnvuwZtvvklH+d566y0cOXIEeXl59HNqa2sRFhYGLpeL5ORko74vcyY/Px+rVq3Cb7/9hsjIyD63IUkS7e3ttPi7ceMGgoKCMG/ePKxevRqTJk0yK/FHGUV7enoiJibGYu1kSJJEZ2cnPeVDrVaDJEm6c9pc0tMjgWqmIQgCycnJJo+A6XQ6OtoqEAgGjbb2R0tLC7KysuDh4YEzZ86YxJfRnNmxYweef/55tLS09BDCWVlZcHV1xc6dO024OiuGwBrLtjIgbW1tdxWf29rawsvLC21tbf0+78EHH8T48eMREBCAgoICvPLKKygvL8eBAwfo/fbuYKT+PdB+/wgkJiaipKRkwOgDg8GAj48PNm7ciGeeeQYdHR3Yt28f9u7di3vuuQcBAQGYO3cu1qxZg8mTJ5s0YiqTyZCTkzMmjKIZDAY8PDzg4eEBR0dHVFZWgsPhoK2tDXV1dfDx8QGHw4GPj4/JhdJwMDexB9xJtbPZbLDZ7B7R1uLiYuh0uh7R1v4Ed1tbG9asWQMnJyecPHnSKvb6YO3atXjuuedw5MgRrF27FsCdjvPjx4/j9OnTJl6dFUNg+l+zFZPw6quv4qOPPhpwm9LS0mHv/4knnqD/f3x8PPz9/TF37lxUV1cjPDx82Pv9o6BPqonBYMDLywtPPfUUnnzySXR2dmL//v3Yu3cvVqxYAT8/P8ydOxerV6/GlClTRnVmplQqRU5ODgICAhAREWHRYq87DQ0NqK6uRmpqKjw8PECSJKRSKV1/VlxcDC8vL3A4HLDZbLOKtvaHOYq93jCZTHh5ecHLywuRkZG0119FRQVUKhXt9efq6ko3lQkEAtx7771gMBg4e/asUXwXxwKOjo548MEH8eOPP9KCb9euXQgODu5h9G/FcjG/X7SVUeHFF1/Ehg0bBtwmLCwMfn5+9MgkCq1WC5FIpJehLDX/saqqCuHh4fDz88OtW7d6bMPj8QBgzBjVmgIqAvX444/j8ccfR2dnJw4cOIBffvkFa9asgY+PD+bMmYPVq1dj+vTpRhV/1FSQ4OBghIaGjhmxV19fj5qaGqSkpMDd3R3AnePu6uoKV1dXhIeH075zDQ0NKCkpoX3nfH19zbI+1RLEXm8YDAbc3d3h7u6OiIgIWnCXl5fj3nvvRXx8PObNm4cTJ05ApVLh8uXLcHNzM/WyzZrHH38c6enpaG5uRmBgILZv344NGzaMmd/uHx3LqJq2YnDYbDaioqIG/I/FYmHy5MkQi8XIycmhn3v+/HkQBEGLuKFA1epRI6YmT56MwsLCHmLyzJkzcHNzQ0xMjGHepBW4u7vj0UcfxenTpyEQCLBlyxYIBALcf//9iIuLwxNPPIETJ05AoVAY9HWp70xoaCjCwsLGzAWjrq7uLrHXF87OzggNDcWkSZMwdepUeHl5oaWlBZcvX0Z2djYaGxuhVCpHceX9o9PpkJ+fTxtgW4LY6w0luMPDwzFr1iycP38eGRkZ+Oyzz5CTkwM3Nzfs3LkTjY2No7IekUiEhx56CG5ubvDw8MCf/vQnSKXSAbd/9tlnERkZCUdHRwQHB+O5555DZ2dnj+0YDMZd/+3Zs8dg605OTkZiYiJ27NiBnJwcFBcXDxoYsGI5WJs2rAzK4sWLwePxsG3bNtqWJS0tjbZlaW5uxty5c7Fjxw5kZGSguroau3fvxpIlS+Dt7Y2CggI8//zzGDduHO3Np9PpkJSUhICAAPz9739HW1sbHnnkEfz5z3/+w9uyjAZSqRSHDx/GL7/8gvPnz8PNzQ2zZ8/GypUrMXfu3BHVOIlEIuTl5WHChAkICgoy4KpNS01NDRoaGpCSkjLsSJFSqaR958RiMdzc3GjfOVPUlVFiT6vVIiUlxSLFXl90dXXhwQcfRH19Pfbv34/r16/jwIEDuHz5MpKTk7Fq1Sps2rTJaBHuxYsXo7W1Fd9++y19zkxPT+/XyqqoqAhvv/02NmzYgJiYGNTX1+Opp55CQkICfv31V3o7BoOBH3/8EYsWLaIf8/DwMOj7+Oabb7B161bMnz8flZWVOHXqlMH2bcW0WAWflUERiUTYuHFjD+Plzz//nK6FqaurQ2hoKC5cuIBZs2ahsbERDz/8MIqKiiCTyRAUFISVK1fijTfe6HGhrK+vx9NPP42LFy/C2dkZ69evx4cffjhmLjqWglwux9GjR7F7926cO3cOTk5OmDVrFlatWoW5c+fqZYArFApRUFCAqKiofi17LA1q/nFjYyNSU1Ph6upqkP2qVCoIBALweLxRNR2mGKtiTyaT4ZFHHkFZWRmuXbuGwMBA+m9CoRBHjx7FhQsXsH37dqNYAw3Xyqo3+/fvx8MPPwyZTEZ/NgwGAwcPHkRWVpbB103R2dmJgIAAaLVa7NixA/fdd5/RXsvK6GIVfFasWKFRKBQ4fvw4du/ejTNnzsDe3h4zZ87EypUrsXDhwgGFCI/HQ3FxMWJjY8fMDFmSJFFdXY3m5makpqYareCfMh3m8Xhob2+Hs7MzPeXD2dnZ4ClxgiCQl5cHrVY7qnOMjY1CocCjjz4KLpeLa9euYfz48aO+huFaWfXmu+++w2uvvQaBQEA/xmAwEBAQAJVKhbCwMDz11FN49NFHDf79WLduHY4fP36XRYsVy2Zs3NJZsWLFIDg6OmLNmjVYs2YNlEolTpw4gd27d+OZZ56BjY0NZs6ciaysLCxatKhHpOuHH36As7Mz5syZM2bGipEkiaqqKrS0tCAtLc2oUTc7OzsEBATQkRVq4kRdXR0cHBzoyJ8hJk4QBIH8/HxoNBqLm9QyEEqlEk888QRu376Nq1evmkTsAcO3suqOUCjEe++918PtAADeffddzJkzB05OTjh9+jT+8pe/QCqV4rnnnjPY+oE7ZToPPfSQVeyNMayCz4oVK33i4OCAlStXYuXKlVCr1Th58iR2796N//u//wODwcCMGTOwYsUK1NbW4tNPP8X27dvHlNirqKgAj8czutjrja2tLfz9/eHv7w+dTgehUAg+n4/s7GzY2dnR4s/d3V1v8UeJPbVaPebE3jPPPIPLly/j6tWrRrF+MraVFYVEIsHSpUsRExODv/3tbz3+9uabb9L/Pzk5GTKZDB9//LHBBF9HRwcuXryIixcv4uuvvzbIPq2YD1bBZ8WiobrbutcXfvbZZ/2m3kQiEd5++22cPn0aDQ0NYLPZyMrKwnvvvdej67KvC+kvv/yC+++/32jvxZxhsVhYvnw5li9fDo1Gg9OnT2P37t3YuHEjFAoFJk2ahM7OTojFYnh4eJh6uSOCJEmUl5dDIBAgLS2txwzo0cbGxgYcDgccDoeeOMHj8ZCbm9tj9q+np+eg4m+sij21Wo0XXngBp0+fxqVLl/qdTjNSRsPKqquri46eHzx4cNDPKDMzE++99x5UKpVBonHJycno6OjARx99ZLTjaMV0WAWfFYvmoYceQmtrK86cOUN3wz3xxBP9dsO1tLSgpaUFn3zySY9uuJaWlh7dcAD67Iazcif9uHTpUuTn5+PEiRP48MMPkZ2djddeew0vvvgipk2bhuXLl+Oee+6Bp6enqZerFyRJoqysDEKhEGlpaWY1kaH3xImOjg7weDwUFBQMOm6MEnsqlQqpqaljRuxpNBq8/PLLOHToEC5cuIC4uDijvRZ17Aeju5VVamoqgKFZWUkkEixcuBD29vY4cuTIkDpv8/Ly4OnpabDUa11dnUH2Y8U8sTZtWLFYLL0bzlIhSRJvvPEGvvvuO5w5cwYJCQkA7kQxLl68iF27duH48eNQKpWYOnUq7rnnHixfvhxeXl5m7cdHkiRKS0shEomQmppqVmJvIEiSREdHB233otPp6Mift7c3AKCgoABKpXJMiT2tVovXX38dO3bswNmzZ5GRkWHqJdHoa2UlkUiwYMECyOVyHDx4sEcJAZvNho2NDY4ePQoej4dJkybBwcEBZ86cwUsvvYSXXnoJ77zzjqneqhULwir4rFgsY6EbzhI5cOAAnn32WZw7dw5RUVF9bqPT6XD58mVa/EmlUkyePJkWf2w226yOJUmSKC4uRmdnJ1JTU0d1/JwhIUkSnZ2d4PP54PF40Gg0sLW1BYPBQHp6usW+r95otVq88847+Pbbb3Hq1ClMnTrV1Evqgb5WVhcvXsTs2bP73FdtbS1CQkJw8uRJvPbaa6iqqgJJkoiIiMDTTz+Nxx9/3Cj2MlbGHlbBZ8Vi2bJlC3766SeUl5f3eNzX1xfvvPMOnn766UH3IRQKkZqaiocffhjvv/8+/fh7773Xoxvu7bffxt///neDd8NZIgRBgM/nD3kEnk6nw7Vr17Br1y4cPXoUnZ2dmDx5MpYtW4YVK1aAw+GYVPwRBIHi4mJ0dXUhNTV1zHQm6nQ65ObmQiaTwcbGpsesWTabbbG+ezqdDlu2bMHnn3+OY8eO9SuUrFix0hOr4LNidgy1G+7AgQMjEnwSiQTz58+Hl5cXjhw5MmCq66233sKPP/44aqOZxioEQeD333/Hzp07cfToUYhEImRkZGDZsmVYuXIl/Pz8RlX8EQSBoqIiSKXSMSX2CIJAYWEhFAoFUlNTYWtrC5lMBh6PBz6fD5lMBm9vb3A4HLDZbItJ8+p0OnzyySf4+OOPcejQISxYsMDUS7JixWKwCj4rZodAIEB7e/uA24SFhWHXrl3DTul2dXVh4cKFcHJywrFjxwZNdR0/fhzLli2DUqkcM6LA1BAEgdu3b2Pnzp04cuQI+Hw+MjIysGTJEqxevRoBAQFGFX+UKJLL5UhNTQWLxTLaa40mQ3lfMpmMTvtKpVJ4eXnRdX/mehwIgsBnn32GzZs3Y9++fbjnnntMvSQrViwKq+CzYrFQTRvZ2dl0N9zp06exaNGiAZs2unfD/fbbb0Oy3Xj//7d371FRVv3fx98DiaiEeOSg3IFHtFAUZNKo8IZbQLJQNC0NNQ9laSkmoSVmWqZp+bMoTC1ExFMZltmUoigGaWkkClqSRSozojiSSAIz1/OHi3maUEQFgfH7WmuWsmfva/YW1uLjde3DG2+wZMkSCgsLa3QM4gqj0cjBgwdJTExky5Yt5Ofn4+PjYwp/7du3r9HwZzQaTQsZevfuXW9Dzo26mRBbUlJiCn9FRUU4ODiYwl99mfOnKAoffPABMTExrFmzhqFDh9Z1l4RocCTwiQZNVsNZnoowlpCQwJYtW0xn2FaEv//85z+3NEndUrcoqXg8XVxcfNN3LP/++2/Tal+9Xo+9vb3piLe6WrWsKAorV64kOjqaVatW8eSTT9ZJP4Ro6CTwiQZNVsNZNkVRyMrKYs2aNWzZsoUTJ07Qu3dvQkJCGDp0KG5ubjf0PTEYDPz8888Wd4ZsTYS9fystLTWFv8LCQuzs7EynfNyuk0cURSEhIYHIyEg+/PBDRo8eXa9WdwvRkEjgE0I0CIqikJ2dzZo1a0hOTiY3NxcvLy+Cg4N5/PHHcXNzw9ra+prtDQYDmZmZGAwGevfu3WBXqf5bbYS9fysrK6OgoACdTkdhYSFNmzY1Pfa1s7OrlRCmKArr169nypQpvPPOOzzzzDMS9oS4BRL4hBANTsVZtwkJCSQnJ3Ps2DF69uxJUFAQjz/+OB07djQLf0VFRaSlpdG2bVt69eplUWGvYksZHx+f2zIXsby8nLNnz6LT6Th79iy2tramx7533313jYQyRVHYvHkzzz77LPPnz2fq1KkS9oS4RRL4hBANmqIo5ObmsmbNGjZv3kxOTg733XcfwcHBDBs2jDZt2jBo0CBcXFzYuHFjlXcBG5K6CHv/ZjAYOHv2LGfOnKGgoIBGjRqZwl/z5s1vOqR9+eWXjB8/nldffZWoqCgJe0LUAJmQJEQNio2Nxc3NDVtbW9RqNfv376+y/qZNm/Dw8MDW1hZPT0+2bdtm9r6iKMTExODs7EyTJk0IDAzk119/rc0hNDgqlYpOnToxd+5cDh06xC+//MKQIUPQaDT06dOHbt26UVhYSFRUVF13tcZUnAxSsVl0Xa0ytra2xtHREU9PT/z9/fHw8KC8vJyffvqJtLQ0jh49SmFhITdyX0Gj0TBhwgRmzJghYU+IGiR3+ISoIRs2bCAiIoK4uDjUajVLly5l06ZNHDt2jLZt21aqn56ezkMPPcSCBQt45JFHSEpKYuHChRw8eNB0CPzChQtZsGABq1evxt3dndmzZ5OVlUV2dna92TKjvjp//jz9+/enuLiYZs2akZWVRbdu3QgKCmLo0KHce++9DfLRbkXYKyoqqrebRRuNRs6fP49Op6OgoABFUUxz/lq2bHnNhTYpKSk89dRTPPfcc7zxxhsS9oSoQRL4hKgharWaPn368P777wNXfum5uroyZcoUoqOjK9UfPnw4xcXFbN261VR2//334+XlRVxcHIqi4OLiwvTp03nppZcAuHDhAo6OjsTHxzNixIjbM7AGqLCwkAEDBuDs7Mynn36KjY0NJ0+eZO3atXz22WccPHiQrl27MmDAAIYOHUqPHj0aRPhrCGHv3xRFQa/Xm075MBgMtGnThpYtW9K8eXPTit+0tDSefPJJRo8ezZIlSyTsCVHD5JGuEDWgtLSUAwcOEBgYaCqzsrIiMDCQjIyMq7bJyMgwqw8QFBRkqn/ixAm0Wq1ZnebNm6NWq695TXHlFJWAgABcXV357LPPaNy4MSqVCldXV6Kjo9m/fz95eXmMHTuW77//Hn9/f3x9fXn55Zf54YcfKC8vr+shXFVF2Ltw4UKDCXtw5ZF7ixYt8PDw4MEHH6RXr17Y2Niwbt067rnnHsLCwpg7dy4jR45k+PDhLF68+LaGvcLCQkaOHIm9vT0ODg6MGzeOixcvVtnG398flUpl9nr22WfN6uTl5REaGmpa0Txjxox6+7Ml7gwS+ISoAWfPnsVgMODo6GhW7ujoiFarvWobrVZbZf2KP2/kmgLs7Ox48cUX2bhx41XntqlUKtq1a8eMGTPIyMjgzz//5JlnnuHAgQMEBATg7e3NjBkz+P777ykrK6uDEVRWsSXNhQsX8PHxaTBh799UKhUODg506dKFadOmkZyczN13382SJUvQ6/Xk5+ezbt06Lly4cNv6NHLkSI4cOcL27dvZunUre/bsYeLEiddtN2HCBPLz802vRYsWmd4zGAyEhoZSWlpKeno6q1evJj4+npiYmNocihBVksAnhLAoKpWKMWPGVGtTZZVKhbOzM9OmTeO7774jPz+fKVOm8PPPPxMUFETv3r2JjIwkPT29zsJfRdjT6/UN6s7e9VhZWWFvb8/333/P8OHD+emnn/Dy8mLhwoW0bduWRx55hHXr1tVqH3JyctBoNKxcuRK1Wo2fnx/vvfce69ev5/Tp01W2bdq0KU5OTqaXvb296b1vv/2W7OxsEhMT8fLyIiQkhHnz5hEbG0tpaWmtjkmIa5HAJ0QNaN26NdbW1uh0OrNynU6Hk5PTVds4OTlVWb/izxu5prh5KpWKNm3a8MILL5CWloZWq2X69Onk5OQwcOBAvLy8ePHFF9mzZ89t+6X977BnSQt1jhw5wuOPP06/fv1ISEjA09OTOXPmcOjQIQ4fPoyfnx/Z2dm12oeMjAwcHBzw8fExlQUGBmJlZcW+ffuqbLt27Vpat27Nfffdx8yZM7l06ZLZdT09Pc3uzgcFBVFUVMSRI0dqfiBCVIMEPiFqgI2NDd7e3qSkpJjKjEYjKSkp9O3b96pt+vbta1YfYPv27ab67u7uODk5mdUpKipi375917ymqBkqlYpWrVrx3HPPkZqaik6nIzo6mtzcXB599FF69uzJlClT2LVrV62Fv4qwd/78eYsLe7/88gvDhg3Dy8uLdevWVdobsXPnzkRHRzNv3rxa7YdWq620gv6uu+6iZcuWVU6bePLJJ0lMTGTXrl3MnDmTNWvWMGrUKLPrXm0qRsV7QtSF+r8sTYgGIjIyktGjR+Pj44Ovry9Lly6luLiYsWPHAhAREUG7du1YsGABAC+++CIPP/wwS5YsITQ0lPXr1/Pjjz/y0UcfAVdCx9SpU5k/fz6dO3c2bcvi4uJCWFhYXQ3zjlOx6OCZZ57hmWeeQa/X8+mnn7JhwwaGDBlC27ZtCQgIYMiQIfj5+dVIMFMUhZycHM6fP4+Pj49Fhb3ffvuNYcOG4eHhwaefflorq6Ojo6NZuHBhlXVycnJu+vr/nOPn6emJs7MzAQEB5Obm0rFjx5u+rhC1SQKfEDVk+PDhFBQUEBMTg1arxcvLC41GY/qffV5entn+Y/369SMpKYlXX32VWbNm0blzZ5KTk0178AFERUVRXFzMxIkT0ev1+Pn5odFoLCoANDQODg6MHz+e8ePHU1RUxObNm1m3bh2PP/44rVq14r///S+DBw/G39//pr5PFWGvsLDQ4sJeXl4eQ4cOxdXVlS1bttTahtHTp09nzJgxVdbp0KEDTk5OnDlzxqy8vLycwsLCG5o2oVarATh+/DgdO3bEycmp0qbrFVMzZDqGqCuyD58QQtSAv/76i+TkZNatW8euXbtwcHCgf//+DBkyhP79+9OkSZPrXsOSw96pU6cYPHgwDg4ObN++vVr/HrUtJyeH7t278+OPP+Lt7Q1cWXARHBzMyZMncXFxqdZ1vvvuO/z8/Pj555/p0aMHX3/9NY888gj5+fmmR8YfffQRM2bM4MyZMxaz8EY0LBL4hBCihhUXF/PFF1+QlJTEzp07sbOzo3///gwePJjAwMCrhh1FUTh69Cjnzp3D29u7XgSimqLVahk8eDC2trakpKRgZ2dX110yCQkJQafTERcXR1lZGWPHjsXHx4ekpCTgSlANCAggISEBX19fcnNzSUpKYuDAgbRq1YpDhw4xbdo02rdvz+7du4Er27J4eXnh4uLCokWL0Gq1PPXUU4wfP54333yzLocr7mAS+IQQohZdunSJrVu3kpSUxI4dO2jatCkPP/wwgwcP5n//+x/NmjXDaDQyfvx4OnbsSGRkpEWFvYKCAsLDwzEajaSmppptX1IfFBYWMnnyZL788kusrKwIDw9n2bJlplD6+++/4+7uzq5du/D39+fPP/9k1KhRHD58mOLiYlxdXRk8eDCvvvqq2dj++OMPJk2aRGpqKs2aNWP06NG89dZbDeJEF2GZJPAJIcRtUlJSwrZt20hKSuLbb7+lcePGPPTQQ5w9e5ZffvkFjUZDly5d6rqbNaawsJBhw4Zx8eJF9uzZQ4sWLeq6S0LcsWRbFiHuELGxsbi5uWFra4tara40qfyfVqxYwYMPPkiLFi1o0aIFgYGBleqPGTOm0vFSwcHBtT2MBq1JkyaEh4fz2WefUVBQwIoVK8jKymLv3r2UlJTw2muvsXHjRoqKiuq6q7dMr9fzxBNPoNfrSU1NlbAnRB2TwCfEHWDDhg1ERkYyZ84cDh48SM+ePQkKCqq0QrFCamoqTzzxBLt27SIjIwNXV1cGDBjAqVOnzOoFBwebHS9V2ycjWJLGjRuTmppKaWkpR48eJTExEVtbW6ZOnYqHhwfDhw+/7ceM1ZSioiJGjRpFfn4+qamptGrVqq67JMQdTx7pCnEHUKvV9OnTh/fffx+4sim0q6srU6ZMITo6+rrtDQYDLVq04P333yciIgK4codPr9eTnJxcm123SIqiMG3aNDZv3szu3btxd3c3vVdWVsaOHTtITExEo9FQXl6On58fjz32GKGhofX+TllxcTFPPfUUR48eJT09vdorXYUQtUvu8Alh4UpLSzlw4ACBgYGmMisrKwIDA8nIyKjWNS5dukRZWRktW7Y0K09NTaVt27Z07dqVSZMmce7cuRrtu6X69ddf0Wg0pKammoU9gEaNGhESEsLatWvR6XRs2rSJVq1aMWvWLLp160Z4eDirV6+ul//WJSUljBs3jsOHD7N7924Je0LUI3KHTwgLd/r0adq1a0d6errZkWxRUVHs3r37umeGAjz33HN88803HDlyxLQ33Pr162natCnu7u7k5uYya9Ys7OzsyMjIqHRUlqisvLz8hlZsGgwGUlNTSUxM5KuvvuLSpUs88MADDBo0iEcffZRWrVqhUqlqscdVKykpYeLEiaSnp7N37145cUKIekbWhwshqvTWW2+xfv16UlNTzTYCHjFihOnvnp6e9OjRg44dO5KamkpAQEBddLVBudHtOaytrQkICCAgIACDwUBaWhqJiYnMnz+f6Oho+vbtS2hoKGFhYbRp0+a2hr+///6byZMnk5aWRlpamoQ9IeoheaQrhIVr3bo11tbWpqOdKuh0uuse87R48WLeeustvv32W3r06FFl3Q4dOtC6dWuOHz9+y30WVbO2tsbf35+VK1dy+vRpNBoNHTp0YNGiRXTv3p1BgwYRFxeHVqulth/ilJaWEhkZybfffsvOnTvp2rVrrX6eEOLmSOATwsLZ2Njg7e1NSkqKqcxoNJKSkmL2iPffFi1axLx589BoNPj4+Fz3c06ePMm5c+dwdnaukX6L6rGyssLPz4/ly5dz8uRJUlJS8PDw4N133+Xee+8lNDSU2NhYTp8+XePhr6ysjKioKLZs2UJKSorZOdBCiPpF5vAJcQfYsGEDo0ePZvny5fj6+rJ06VI2btzI0aNHcXR0JCIignbt2rFgwQIAFi5cSExMDElJSTzwwAOm69jZ2WFnZ8fFixeZO3cu4eHhODk5kZubS1RUFH/99RdZWVlyVmg9YDQa+fHHH0lMTGTLli3odDr69OlDaGgoQ4YMoV27drf02LesrIxXXnmFhIQEduzYga+vbw32XghR0yTwCXGHeP/993n77bfRarV4eXmxbNky1Go1AP7+/ri5uREfHw+Am5sbf/zxR6VrzJkzh9dee42SkhLCwsL46aef0Ov1uLi4MGDAAObNm4ejo+PtHJaoBqPRSGZmJmvWrCE5OZnTp0/j4+PDwIEDCQ8Px9XV9YbCX3l5Oa+99horVqxAo9GY/adACFE/SeAT4hYVFBTg6enJCy+8wKxZswBIT0/H39+fr7/+WhYwiHpFURQOHTpEQkICW7ZsIS8vD29vb0JCQggPD+eee+7Byuras33Ky8t58803ee+999i6dSv9+/e/jb0XQtwsCXxC1IBt27YRFhZGeno6Xbt2xcvLi8cee4x33nmnrrsmxDUpisLhw4dNd/5OnDhBr169CAkJYejQobi5uZltsVNSUsK8efP46KOPSE5OZsCAAXXYeyHEjZDAJ0QNef7559mxYwc+Pj5kZWXxww8/yFw20WAoikJOTo4p/B0/fpwePXpgZWXFuHHjCAsLIyAggKNHj5KcnMygQYPqustCiBsgq3SFqCGLFy+mvLycTZs2sXbtWgl7NyE2NhY3NzdsbW1Rq9Xs37//mnXj4+NRqVRmr3/uEwhXQkxMTAzOzs40adKEwMBAfv3119oeRoOkUqno3r07CxYsIDs7myNHjtC/f39+++03Jk2ahLOzM9nZ2bz44osEBQXd1r4VFhYycuRI7O3tcXBwYNy4cVy8ePGa9X///fdKPxsVr02bNpnqXe399evX344hCXHbSeAToobk5uZy+vRpjEYjv//+e113p8HZsGEDkZGRzJkzh4MHD9KzZ0+CgoI4c+bMNdvY29uTn59vev17ocmiRYtYtmwZcXFx7Nu3j2bNmhEUFMTff/9d28Np0FQqFV26dGHx4sWcOXOGwYMH06RJE+677z42bdqEo6MjY8aM4auvvuLy5cu13p+RI0dy5MgRtm/fztatW9mzZw8TJ068Zn1XV1ezn4v8/Hzmzp2LnZ0dISEhZnU/+eQTs3phYWG1PBoh6ogihLhlly9fVnr27KmMHj1aefPNN5W2bdsqOp2urrvVoPj6+irPP/+86WuDwaC4uLgoCxYsuGr9Tz75RGnevPk1r2c0GhUnJyfl7bffNpXp9XqlcePGyrp162qs35bMaDQqEydOVDp16qScOnVKUZQr35eMjAxl+vTpyj333KM4ODgoer2+1vqQnZ2tAMoPP/xgKvv6668VlUpl6lN1eHl5KU8//bRZGaB8/vnnNdVVIeo1ucMnRA145ZVXuHDhAsuWLePll1+mS5cuPP3003XdrQajtLSUAwcOEBgYaCqzsrIiMDCQjIyMa7a7ePEi99xzD66urjz22GMcOXLE9N6JEyfQarVm12zevDlqtbrKa4orFEVh6tSpphM0XFxcgCvfl/vvv5/Fixdz4sQJ9u7dS/PmzWutHxkZGTg4OJht/h0YGIiVlVW1zoEGOHDgAJmZmYwbN67Se88//zytW7fG19eXjz/+uNZPJhGirkjgE+IWpaamsnTpUtasWYO9vT1WVlasWbOGtLQ0Pvzww7ruXoNw9uxZDAZDpT38HB0d0Wq1V23TtWtXPv74Y7Zs2UJiYiJGo5F+/fpx8uRJAFO7G7mmMPef//yHnTt34urqetX3VSoV9957b632QavV0rZtW7Oyu+66i5YtW1b7+7hq1Sq6detGv379zMpff/11Nm7cyPbt2wkPD+e5557jvffeq7G+C1Gf3Njp3UKISvz9/SkrKzMrc3Nz48KFC3XUoztD3759zY6G69evH926dWP58uXMmzevDntmGVQqFdOnT6+160dHR7Nw4cIq6+Tk5Nzy55SUlJCUlMTs2bMrvffPsl69elFcXMzbb7/NCy+8cMufK0R9I4FPCFHnWrdujbW1NTqdzqxcp9Ph5ORUrWs0atSIXr16cfz4cQBTO51OZ3a+r06nw8vLq2Y6Lm7a9OnTGTNmTJV1OnTogJOTU6WFO+Xl5RQWFlbrZ+PTTz/l0qVLREREXLeuWq1m3rx5XL58WVbZC4sjj3SFEHXOxsYGb29vUlJSTGVGo5GUlBSzu3hVMRgMZGVlmcKdu7s7Tk5OZtcsKipi37591b6mqD1t2rTBw8OjypeNjQ19+/ZFr9dz4MABU9udO3diNBpNRwNWZdWqVTz66KO0adPmunUzMzNp0aKFhD1hkeQOnxCiXoiMjGT06NH4+Pjg6+vL0qVLKS4uZuzYsQBERETQrl07FixYAFyZf3X//ffTqVMn9Ho9b7/9Nn/88Qfjx48HrjySnDp1KvPnz6dz5864u7sze/ZsXFxcZOuNBqRbt24EBwczYcIE4uLiKCsrY/LkyYwYMcK0kOTUqVMEBASQkJCAr6+vqe3x48fZs2cP27Ztq3TdL7/8Ep1Ox/3334+trS3bt2/nzTff5KWXXrptYxPidpLAJ4SoF4YPH05BQQExMTFotVq8vLzQaDSmRRd5eXlmZ7yeP3+eCRMmoNVqadGiBd7e3qSnp9O9e3dTnaioKIqLi5k4cSJ6vR4/Pz80Gk2lDZpF/bZ27VomT55MQEAAVlZWhIeHs2zZMtP7ZWVlHDt2jEuXLpm1+/jjj2nfvv1Vj4Br1KgRsbGxTJs2DUVR6NSpE++88w4TJkyo9fEIURfkaDUhhBBCCAsnc/iEEEIIISycBD4hhBBCCAsngU8IIYQQwsJJ4BNCiBsQGxuLm5sbtra2qNVq9u/ff826/v7+qFSqSq/Q0FBTnTFjxlR6Pzg4+HYMRQhxB5FVukIIUU0bNmwgMjKSuLg41Go1S5cuJSgoiGPHjlU6/gtg8+bNlJaWmr4+d+4cPXv2ZNiwYWb1goOD+eSTT0xfyz5wQoiaJnf4hBCimiq27Rg7dizdu3cnLi6Opk2b8vHHH1+1fsuWLXFycjK9tm/fTtOmTSsFvsaNG5vVa9Gixe0YjhDiDiKBTwghqqG0tJQDBw4QGBhoKrOysiIwMJCMjIxqXWPVqlWMGDGCZs2amZWnpqbStm1bunbtyqRJkzh37lyN9l0IISTwCSFENZw9exaDwWDaCLqCo6MjWq32uu3379/P4cOHTSeBVAgODiYhIYGUlBQWLlzI7t27CQkJwWAw1Gj/hRB3NpnDJ4QQt8GqVavw9PQ0O/oLYMSIEaa/e3p60qNHDzp27EhqaioBAQG3u5tCCAsld/iEEKIaWrdujbW1NTqdzqxcp9Ph5ORUZdvi4mLWr1/PuHHjrvs5HTp0oHXr1hw/fvyW+iuEEP8kgU8IIarBxsYGb29vUlJSTGVGo5GUlBT69u1bZdtNmzZx+fJlRo0add3POXnyJOfOncPZ2fmW+yyEEBUk8AkhRDVFRkayYsUKVq9eTU5ODpMmTaK4uJixY8cCEBERwcyZMyu1W7VqFWFhYbRq1cqs/OLFi8yYMYPvv/+e33//nZSUFB577DE6depEUFDQbRmTEOLOIIFPCCGqafjw4SxevJiYmBi8vLzIzMxEo9GYFnLk5eWRn59v1ubYsWPs3bv3qo9zra2tOXToEI8++ihdunRh3LhxeHt7k5aW1iD34nvjjTfo168fTZs2xcHBoVptFEUhJiYGZ2dnmjRpQmBgIL/++qtZncLCQkaOHIm9vT0ODg6MGzeOixcv1sIIhLBcKkVRlLruhBBCiIZvzpw5ODg4cPLkSVatWoVer79um4ULF7JgwQJWr16Nu7s7s2fPJisri+zsbGxtbQEICQkhPz+f5cuXU1ZWxtixY+nTpw9JSUm1PCIhLIcEPiGEEDUqPj6eqVOnXjfwKYqCi4sL06dP56WXXgLgwoULODo6Eh8fz4gRI8jJyaF79+788MMP+Pj4AKDRaBg4cCAnT57ExcWltocjhEWQR7pCCCHqxIkTJ9BqtWabWTdv3hy1Wm3azDojIwMHBwdT2AMIDAzEysqKffv23fY+C9FQSeATQggLsmfPHgYNGoSLiwsqlYrk5OTrtklNTaV37940btyYTp06ER8fX6lObGwsbm5u2Nraolar2b9//y33tWLD6qo2s9ZqtZXOKb7rrrto2bJltTa8FkJcIYFPCCEsSHFxMT179iQ2NrZa9U+cOEFoaCj9+/cnMzOTqVOnMn78eL755hsAoqOjUalUTJ48mT/++IPLly+zf/9+1Go1KpUKlUrF0aNHa3NIQogaICdtCCGEBQkJCSEkJKTa9ePi4nB3d2fJkiUAdOvWjb179/Luu+8SFBTE9OnT2bZtG56ensyePRu4sv+gv78/o0aNYuLEiXTo0OGm+lqxYbVOpzPbd1Cn0+Hl5WWqc+bMGbN25eXlFBYWXnfDayHE/yd3+IQQ4g6WkZFhNocOICgoyDSHrnnz5mRnZzNs2DA8PDzw8PCge/fuhISEkJubi4eHBzY2Njf12e7u7jg5OZltZl1UVMS+fftMm1n37dsXvV7PgQMHTHV27tyJ0WhErVbf1OcKcSeSwCeEEHcwrVZ71Tl0RUVFlJSUcPbsWQwGQ5Xz7Crk5eWRmZlJXl4eBoOBzMxMMjMzzfbM8/Dw4PPPPwdApVIxdepU5s+fzxdffEFWVhYRERG4uLgQFhYGXLnjGBwczIQJE9i/fz/fffcdkydPZsSIEbJCV4gbII90hRBC1IiYmBhWr15t+rpXr14A7Nq1C39/f+DKRtQXLlww1YmKiqK4uJiJEyei1+vx8/NDo9GY9uADWLt2LZMnTyYgIAArKyvCw8NZtmzZ7RmUEBZCAp8QQtzBnJyc0Ol0ZmU6nQ57e3uaNGmCtbU11tbWV63z7zl08fHxV13h+0//3vpVpVLx+uuv8/rrr1+zTcuWLWWTZSFukTzSFUKIO1jfvn3N5tABbN++3TSHzsbGBm9vb7M6RqORlJQUUx0hRP0ngU8IISzIxYsXTXPn4Mq2KxXz6gBmzpxJRESEqf6zzz7Lb7/9RlRUFEePHuWDDz5g48aNTJs2zVQnMjKSFStWsHr1anJycpg0aRLFxcWMHTv2to5NCHHz5JGuEEJYkB9//JH+/fubvo6MjARg9OjRxMfHk5+fbwp/cGWl7FdffcW0adP4v//7P9q3b8/KlSsJCgoy1Rk+fDgFBQXExMSg1Wrx8vJCo9FUWsghhKi/5CxdIYQQQggLJ490hRBCCCEsnAQ+IYQQQggLJ4FPCCGEEMLCSeATQgghhLBwEviEEEIIISycBD4hhBBCCAsngU8IIYQQwsJJ4BNCCCGEsHAS+IQQQgghLJwEPiGEEEIICyeBTwghhBDCwkngE0IIIYSwcP8PvEj44UqsIuoAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Butterfly subdivision (smooth, interpolating):\")\n", + "butterfly.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data Interpolation During Subdivision\n", + "\n", + "When you subdivide a mesh with attached data, the data is automatically interpolated\n", + "to the new vertices and cells." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Before: 42 points\n", + "After: 642 points\n", + "Data keys preserved: ['height']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a mesh with data\n", + "mesh = sphere_icosahedral.load(subdivisions=1)\n", + "\n", + "# Add a scalar field based on z-coordinate\n", + "mesh.point_data[\"height\"] = mesh.points[:, 2]\n", + "print(f\"Before: {mesh.n_points} points\")\n", + "\n", + "# Subdivide - data is interpolated automatically\n", + "refined = mesh.subdivide(levels=2, filter=\"loop\")\n", + "print(f\"After: {refined.n_points} points\")\n", + "print(f\"Data keys preserved: {list(refined.point_data.keys())}\")\n", + "\n", + "refined.draw(point_scalars=\"height\", cmap=\"viridis\", backend=\"matplotlib\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 3: Slicing\n", + "\n", + "Slicing extracts a subset of points or cells from a mesh. You can slice by:\n", + "- Integer indices\n", + "- Boolean masks\n", + "- Index arrays" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Slicing Cells\n", + "\n", + "`slice_cells()` keeps only the specified cells. Points are preserved (even unused ones)." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original: 320 cells\n", + "X > 0: 152 cells\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sphere = sphere_icosahedral.load(subdivisions=2)\n", + "print(f\"Original: {sphere.n_cells} cells\")\n", + "\n", + "# Slice using a boolean mask: keep cells with positive x-centroid\n", + "mask = sphere.cell_centroids[:, 0] < 0\n", + "hemisphere_x = sphere.slice_cells(mask)\n", + "print(f\"X > 0: {hemisphere_x.n_cells} cells\")\n", + "\n", + "hemisphere_x.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calling `.clean()` will remove unused points and make cell indices contiguous." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X > 0 and Z > 0: 72 cells\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnwAAAKMCAYAAABxf2VPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvXd8LGd99n1t0RZpq3TUeztqp+l0Se7dGIMxxUDABlMDJgHDCzh5qOEJ7/OQgHkTEifBYCAEgwklicEGGx+f7na0q957L7uSVtt3Zt4/jmc8u1pJW2Z2b0n39xN/gnSke27tzs5c8yvXT8FxHAcKhUKhUCgUyq5Fme4NUCgUCoVCoVDkhQo+CoVCoVAolF0OFXwUCoVCoVAouxwq+CgUCoVCoVB2OVTwUSgUCoVCoexyqOCjUCgUCoVC2eVQwUehUCgUCoWyy6GCj0KhUCgUCmWXQwUfhUKhUCgUyi6HCj4KhUKhUCiUXQ4VfBQKhUKhUCi7HCr4KBQKhUKhUHY5VPBRKBQKhUKh7HKo4KNQKBQKhULZ5VDBR6FQKBQKhbLLoYKPQqFQKBQKZZdDBR+FQqFQKBTKLocKPgqFQqFQKJRdDhV8FAqFQqFQKLscKvgoFAqFQqFQdjlU8FEoFAqFQqHscqjgo1AoFAqFQtnlUMFHoVAoFAqFssuhgo9CoVAoFApll0MFH4VCoVAoFMouhwo+CoVCoVAolF0OFXwUCoVCoVAouxwq+CgUCoVCoVB2OVTwUSgUCoVCoexyqOCjUCgUCoVC2eVQwUehUCgUCoWyy6GCj0KhUCgUCmWXQwUfhUKhUCgUyi6HCj4KhUKhUCiUXY463RugUCjkwLIsfD4fWJZFRkYGVCoVVCoVFApFurdGoVAolCRQcBzHpXsTFAolvXAcB4ZhEAwGEQgEEAqFoFAoMDk5ifz8fBgMBioAKRQKZQdDI3wUyh6HZVmEQiHY7XZkZmaivLwcAKBQKDA3Nwez2QytVotAIACFQgGlUgmVSkUFIIVCoewgqOCjUPYoHMeBZVkEg0HwgX6GYTAwMACFQgGr1QoAUCqVUKvVws/wv0MFIIVCoewcaEqXQtmDcByHUCiEUCgE4Go078qVK3A6nTCZTNBoNFhZWYHP50NmZiZyc3NhsVhgNpuhVquFNYCrApDjOHAcRwUghUKhEAoVfBTKHoOP0DEMA4VCAYVCgeHhYQwPDyM7OxuHDx8Gy7JQKpW4ePEi8vLyEAgEsLKyAr/fD6PRCKvVSgUghUKh7CBoSpdC2SPwjRmhUEgQdD6fDx0dHQgEAsjLy0NmZiaUSiVYlgUAqFQqWK1W5OTkAAC8Xi9WVlbgdDrR39+/QQBaLBaoVCrheABNAVMoFAoJUMFHoewBOI4TonrA1bq8+fl5dHd3Iz8/H8eOHcPAwIDws5G/y6PX66HX61FYWAggXAD29fUhEAjAZDLBYrHAarXCbDZTAUihUCgEQAUfhbLL4e1W+Kgey7Lo6enB3NwcDhw4gIKCAgBX6/gixd52wmsrAdjb20sFIIVCoRACFXwUyi4lsjFDqVTC5XLBbrdDo9Ggra0Ner1+w++IiSYCtyKaAHQ6nVhZWaECkEKhUNIIFXwUyi6EF018LR4AjI+PY3BwEJWVlaiqqoJSGT5ZUaFQhP08TzJ9XbwALCoqAsdx8Pl8SQvAQCAApVIJk8lEBSCFQqHECBV8FMouQuytx6dwg8EgOjs74XK5cPz4ccFfL5JooklKIaVQKGIWgOIu4EgBOD09jVAohJqaGhoBpFAolBihgo9C2SVEa8xYXl5GZ2cnLBYL2trakJGRsenvb1bDJ5dzU6ICUKlUQqFQCHYwNAVMoVAo20MFH4WyC2BZFoFAQIjqcRyHgYEBTExMoL6+HiUlJduKns3EXaqsOqMJQHETyOzsLAKBADQaDTIyMuB0OmkNIIVCocQIFXwUyg6G99bjx6MplUp4PB7Y7XZwHIeWlhYYDIa41hOLITkjfNuhUCiQmZmJzMzMMAE4MDAAr9e7IQJotVqFuj7+bwGoAKRQKBSACj4KZcfCsixCoVBYCndmZgY9PT0oKSlBXV3dhsaMrUjEliWV8ALQZDJBq9Wivr4+LAI4MzODYDAIs9ksNIFQAUihUChXoYKPQtlhiBsz+IgcwzDo7u7G8vIyjhw5gtzc3LjX3UzkkDp9cbMIIBWAFAqFshEq+CiUHURkY4ZCocDq6irsdjsyMzPR1tYGrVab0Np8hI+UlG68bCYA+SaQmZkZhEKhMBsYKgApFMpegQo+CmWHwLIsXC4XOjs7cfz4cQDAyMgIRkZGUFNTg4qKiqSECOkp3XgRC8Di4uItBSDfBUwFIIVC2a1QwUehEA7fmBEKhRAMBuFwOOD3+9HR0QGfz4eTJ0/CbDZLdqxYvpdOEo06bicAeX8/KgApFMpuhAo+CoVgIlO4KpUKHMfhwoULyM3NxdGjRwU/umTZzHiZNMEnFVsJQKfTGVUAbmUD09vbi+zsbOzbt48KQAqFQhxU8FEohMLbrfDeeizLYmhoCADQ0NCAoqIiSY/Hizv+P/57e4VoAtDj8QhNINsJQLfbDbPZLIh0GgGkUCgkQQUfhUIYHMchFAohFAoBuGq3sr6+DrvdLtisFBQUSH7cdBsvk4ZCoUBWVhaysrK2FIB8F3AoFALHcTQFTKFQiIQKPgqFIMRzcHkmJyfR39+P8vJylJWV4cyZM7KIsJ3StJGuNPN2AtDj8aC/vx/z8/O0C5hCoRAHFXwUCgGIvfX4FG4wGERXVxdWV1dx9OhR5OTkIBgMCj8v1z7E7OYavmSJFICvvvoqcnNzoVKpsLKygqmpKTAMQ30AKRQKEVDBR6GkmcjGDKVSCYfDgY6ODpjNZrS1tUGj0QB4I+ImV4Rvs/1RtkehUECr1aKgoAAlJSVCBJDvAqYCkEKhpBMq+CiUNMKyLAKBgBDV4zgOg4ODGB8fR11dHUpLSzcYIQPyCT4a4ZMOcQRwOwFIbWAoFIrcUMFHoaQB3luPH4+mVCrh9Xpht9vBMAxOnz4No9G44ffSIfhIY6eK0O0E4OTkZJgAtFqtMBqNVABSKBRJoIKPQkkxLMsiFAqFpXBnZ2fR09ODoqIi1NXVCTf5SFIh+CLFwk4UV+kg2mu3FdEEoNvtFppAqACkUChSQgUfhZIixI0ZvDhgGAY9PT1YXFzEoUOHkJeXt+Uacgq+aOvu1GjaTkShUMBgMMBgMEgqAAOBAFQqlfCzVABSKHsTKvgolBQQ2ZihUCiwtrYGu90OnU6HtrY26HS6mNaSS4RtNmmDNEjckxzEKgAtFovQBBJNAE5NTYFlWVRXV9MIIIWyh6GCj0KRGT7iwjCMYJw8NjaGoaEhVFVVoaqqKu5UoNinTyqipXRJjfCRuCe5iUUAsiwb1gVsNBqhUCigUqmEEXw0BUyh7E2o4KNQZIJvzAiFQkIXrt/vR2dnJzweD06cOAGLxRL3unJG+OikjZ3DZgJQ3ATCsizUajV0Oh3W1tZoDSCFsoehgo9CkYFo3npLS0vo7OxETk4OmpubhYhLvPBRQqkRCz7+Bk9v9PGRztdLLABLS0sFATgwMAC/3w+73Q6O48JsYGIVgGq1Gmq1mgpACmUHQwUfhSIxwWAQq6uryMzMFLz1+vr6MDU1hcbGRhQXFye1vlwp3c0gLcJHxUZs8AIwKysLJpMJ1dXVYRHA8fHxmAVgIBCA3++nApBC2cFQwUehSATHcQiFQlhfX8eFCxdw2223we12w263Q6lUorW1FVlZWUkfJ5Up3VSLy1ghTYSSjkKh2DQC6HQ64XQ6BQEobgIxGAxUAFIouwQq+CgUCRDPweVvdlNTU+jv70dZWRlqa2slS8WmWvBRYoNUEbrZvqIJwPX1daEJhApACmV3QQUfhZIE0Roz+IjY0NAQmpubsW/fPkmPudebNqh4iI9YDaEVCgWMRiOMRiMVgBTKLoQKPgolQaI1ZqysrMBmswEATp06JUkKN5JUR/hIE3yU+ElEYFEBSKHsLqjgo1ASgL+J8VE9juMwNDSEsbEx1NTUoL+/HxkZGbIcW04RtlNSulSExo5Ur9VmAjCyCYQXfxaLZVsBODk5iYKCAhgMBioAKRSZoYKPQokDvjEjFAqB4zgolUr4fD7Y7XYEg0GcPn0aWVlZ6O/vl63ZIZWTNgAqruKBVKEix77EArCsrGyDABwbG9sgACO7gGdmZmC1WqHRaGgEkEKRGSr4KJQYYVkWoVAoLIU7Pz+Prq4uFBQUoKGhASqVShBIcgmlvZ7SpTf/+EjV+5eIAOSNodVqNU0BUygyQwUfhbINHMcJXbh8ATzDMOjr68P8/DwOHDiAgoIC4ed5C4ydKPhYlsXU1BQWFxdhtVqFv5k0SNwTyaRDIMUiAEOhEAYHB7Fv3z5aA0ihyAwVfBTKFkQ2ZigUCrhcLtjtdmg0GrS2tkKv12/4PTn96+QSfAzDgGEYDA0NoaCgAIuLi1hZWYFCoUB3d7cQmdHr9fQGGwVSRWisXbpyE00AvvjiizCZTHA6nRgdHYVCoaBNIBSKTFDBR6FsAh/VYxhG8NAbHx/H4OAgKisrUV1dvemNZadF+FZXV4XRWy0tLcKNdHx8HEtLS9Dr9Zibm8PAwAA0Gg2sVqvwn06nk3QvlL0B/9kpKipCZmYmOI6Dy+USuoCpAKRQpIUKPgolgmjeeoFAAJ2dnVhfX8fx48dhtVq3XIPv3JUDKQUfx3GCiC0pKcHk5CS0Wi0CgQCAq3+HRqNBVVUVgKtRwNXVVTidTkxPT6Ovrw86nS5MAGo0Gkn2thkk1hWSDCkRvmiI96ZQKGAymWAymVBWVgaWZcNsYKgApFCSgwo+CkVENG+95eVldHR0IDs7G21tbTHZreyElG4gEEBXVxfW1tZw/PhxaDQaTE5ObnkslUqF7OxsZGdnAwBCoVCYL1t3dzeysrIE8WexWGSzp6HsbDiO21KMKpVKKgApFAmhgo9CeR2GYYTxaHyErr+/H5OTk2hoaEBxcXHMNwbSU7pOpxN2ux0mkwmtra3QaDTweDxxT9pQq9XYt2+fME0kGAwKs1mHh4fh8XhgMBjCBKBavXsvOyQKB5IjfEDsr9lmApA/38QCMFYfQCoAKXuJ3XvlpVBiROytB1y9sXg8HtjtdgBAS0sLDAZDXGvKmdIVj2+LF47jMDIygpGREdTW1qK8vDzs5pas8XJGRgby8vKQl5cHAPD7/UJX5uDgIHw+H4xGoyAAzWazcEOmyAOp6W9+X4mKK7EALC8vDxOADocDIyMjVABSKCKo4KPsafjGDF5AKRQKTE9Po7e3F6Wlpdi/f7/QsBEPcqZ0gcRu4n6/Hx0dHfB6vTh58iTMZnPYv/M3NfHayUYTtVotCgoKBNsan88nRGR6e3sRCARgNpsFAWgymbZ9vWkNX/yQKFiSFXyRSC0AOzs7UVBQAKvVSgUgZVdABR9lTxKtMSMUCqG7uxsOhwNHjhxBbm5uwuvLHeGLd+3l5WXY7XZkZ2ejubk5alo1FZM2dDodCgsLUVhYCI7j4PV6BQE4NTUFhmHCBKDRaExIcKcDUkUo6fuSSzxtJQCXl5cFAciLP6vViqysLEEArq+vg2VZcBxHI4CUXQEVfJQ9B8dxWFlZAcMwyMrKglKpxMrKCjo6OpCVlYW2tjZotdqkjkFKDR/LshgeHsbY2Bjq6+tRUlKypZUMIG2EbysUCgUyMzORmZmJ4uJicBwHt9stFOVPTEyETWbgi/Ip8UOiIJFb8EUSTQDyNjDRBCDDMFAoFDQFTNk1UMFH2VPwF+uJiQkwDIPGxsYta9oShYQu3cgZv0ajcdt1gfRFhBQKBQwGAwwGA0pKSsImM4iL8vV6PUKhENxuNzIzM+nNdRv2aoRvO5RKJcxmM8xmc5gA5COAPp8P3d3dyM7OjhoBpAKQstOggo+yJxA3ZnAcB6VSCZ/Ph5dffhl+vz9qTVsypDvCt7CwgM7OTuTl5aGhoSGuzthURfi2I3IyA39DnpiYgNPpxCuvvAK1Wh2WkqNTQDZCapduugVfJGIBCADnz59HZWUlgsGgEAFUKpVhNjBUAFJ2ElTwUXY9LMsiFAqFeet5PB7Mz8+jqKgIx44dk9wqJF3GyyzLYmBgAJOTk2hqakJRUVFc68byvXTB35Bzc3MRCATQ3NwsmECTMgWEpNdLDIn7IjXyKMZoNMJkMgHAhgjg8PAwVCpVWBMIFYAUkqGCj7Jr4ThO6MLloxwsy6K3txcLCwswm804ePCgLMdOR0qXt5JhWRatra3IysqKe12AnAjfdiiVSkHYAWRMASERUt8//jNJqtiJjIxGRgDFAnBpaQlDQ0NUAFKIhgo+yq4kcmKGQqHA+vo67HY71Go1Kioq4Ha7ZTt+qlO6c3Nz6OrqQlFREerq6hLythMLvq28+UiFTgHZHBIFBKmpZh6WZbfc31YCcHFxkQpACnFQwUfZdfBRPYZhBEuPiYkJDAwMoKKiAtXV1ZicnMT6+rpse0hVSpdhGPT19WF2dhYHDhwQ/O4SXRfYGOEjjVjF9FZTQEZGRuB2uyWdAkKqMCZ5XySeXzx8rW+siAVgRUXFtgLQarUiMzOTCkBKyqCCj7JriOatFwwG0dnZCZfLhWPHjgnRH7mNkVOR0uUjlkqlEq2trcjMzJTtWLuBvTwFhESBQLrg2y7Ctx3RBODa2hpWVlbCBKC46YgKQIqcUMFH2RVEpnCVSiUcDgc6OjpgsViEebE8ckbg5F5foVDA5XLh0qVLKCsrQ21trSTmxDs9pRsvckwBIRFShRWp+wLeOOelfL/FHb7JCsClpSWMjo7i8OHDVABSYoYKPsqOh2EYYTwaL7QGBgYwMTGxqdlwMvNoY0GuyFgoFMLS0hI8Hg+am5uTmgYSyU5K6crBbp4CQiIkP0iIRy3KxWYCMDIFHE0A8g+4KpWKRgApMUMFH2XHIvbWA65eQL1er9Cp2tLSsulkhlQIPqnXd7lcsNlsYBgGBQUFkoo9nkihSmpKV+49JTIFhNSIFd1X/MgR4dsOsQAEsKUAFDcb0RQwJVao4KPsSPjGDF5UKZVKzMzMoKenB8XFxdi/f/+W9VdyCxkpU7ocx2FychL9/f2orKwULuipgkTBl2pimQLCMAxGR0fh8XiEaAwJN1ZS37+dIPjSub+tBODCwgI8Hg8uXLgQ1gVMawApW0EFH2VHEa0xg2EYdHV1YXFxEYcOHRKK8rdip0T4gsEguru74XQ6cfToUeTk5GBoaEjWhpDIr0kVDOkk2hSQS5cuITMzU4jGkDQFhMQbOsmCLxUp3XgRC0C9Xo/p6WlUV1cLAnBwcBBqtZoKQMqmUMFH2TFEa8xYW1uD3W6HXq9HW1tbzJMVUtGlm6xQWl1dhc1mQ1ZWFlpbW6HVaiVbezP4tfkLPokXfhL3pFQqoVQqkZ+fj+zsbLAsS8wUEFIFe7y2J6mEhAjfVvAPu+IIIMMwQhPI/Pw8FYCUDVDBR9kRRDZmAMDo6CiGh4dRXV2NysrKuC5KcnfpJiPKOI7D2NgYhoaGUFNTg4qKig2O/6k0dSZRMJC4JzGkTQEh8YZNeoSP5Ckg4usgD1/fZ7VaUVlZuakAjIw6UwG4d6CCj0I04sYMPiLg9/vR2dkJr9eLkydPCk738SB3SpdPNcdLIBAQfANPnDghPL2LSeUUD5rSlYZ0TgEh9f0jWfCRHH0Eogu+SKgApERCBR+FWKI1ZiwuLqKzsxO5ublobm5OeDICicbLDocDdrsdFosFbW1tW97wU3UTJ/FCTuKe4iWVU0BIFVakClEgedNluYlF8EWymQB0Op2Yn5/HwMAAMjIyqADcxVDBRyEOjuPCOlF58dTX14eZmRk0NjaiqKgoqWOQZLzMcRxGRkYwMjKC/fv3o6ysbNsZnns9pUsqid7ook0B4SOAUkwBIfEGTKoQBXZHhG87xAIQABWAewAq+ChEwTdmjIyMYGVlBUeOHIHb7ZZ8hBgpTRt+vx8dHR3wer04deoUTCaTZGsnwk5J6e72PWm1WuTn5yM/Px9AclNASHytAPIFH6l7A+QRpLEIQI1GE9YEspkAXF5exvDwMI4cOUIFIEFQwUchBj6FyzCMUAPH+8+Vl5ejpqZGsotcKpo2thOUS0tL6OjoQE5OTlzp6VQLPkr6SXYKCInvI8miajemdONlKwE4NzeH/v7+TQUgnQRCJlTwUdJONG893mTU5XIJ/nNSwgs+uW46WwlKlmUxNDSE8fFxNDQ0oLi4OK49pFLwAeRFiPb6zSHeKSAMwxD3HgJkC76dkNKNJ6UvBVsJwNnZ2TABmJGRIby3NAVMDlTwUdJKNG89vnAdAK655hpZ7Cr4C4pcF87NRBk/+i0UCuH06dMwGo2SrS0H9MJLPttNAQmFQrDb7cjOzhZu2CRMASFZ8O2ECJ9UXdyJEk0Arq6uYmVlRZgEcvHixbDxgzqdjgrANEIFHyUt8I0ZYm89juMwNDSEsbExFBQUwOVyyeZNxj+9yxkpi0zpLiwsoLOzE/n5+WhoaEhYaNIaPvKijiQROQXk7NmzqK2thd/vJ2oKCMlRNJL3BqQmpRsvYushvV6PmZkZVFZWYmVlJSwCKD7vqABMLVTwUVKO2FsPuCq+vF4vOjo6hMiXx+OBy+WSbQ/8xVKuxg1xSpdlWfT392N6ehpNTU0oLCxMau29ntKlxAcfASwsLERFRUXYFBBxMX6qp4CQfF6RHH0EyBR8YliWhVqtDvOeFEcAqQBMD1TwUVKKuDGD//DOzs6iu7sbhYWFqK+vh0qlgs/nk72Llt+PXOuzLAuPxwObzQYAaGlpQVZWliRr7+WmDRL3xEPi3iLFCylTQEgWVaSndHdiBDLSfFx83lEBmBqo4KOkhGiNGQzDoLu7GwsLCzh48KBgQQHIPwmDvyDIKZz8fj8uXryI4uJi1NXVSXaBTtUsXfH/Jw26J+lI1xQQ0gUfyYKKdzIglVj2F48A3M4GhgrA2KCCjyI70Roz1tbWYLfbodPp0NbWtiGFlArBJ5cXH8MwmJ6ehtfrxZEjR8KErBSko2mD5JszZWvife82mwKysrIi6RQQks8pkvcG7MwI33ZsJQBnZmbQ19cHrVYbkw8gFYDRoYKPIisMw4Q1ZgDA2NgYhoaGUFVVhaqqqqgfPrkFH38MqYXT+vo6bDYbOI5DVlaW5GIPSH0NH0D+DZCyOcmeK3JNASH5nNqNgiqVSOF+QAWg9FDBR5EFcWMGf/EMBALo7OyE2+3GiRMnYLFYNv39VAk+qY7BcRymp6fR29uL8vJymM1mDA4OSrJ2JLSGj8w0M8lI+T5KNQWEZMFHeg0f6ftjGEZyu6topQd8EwhfexqPAOzt7YXVasW+ffvw2muvYXl5Ge985zsl3TNpUMFHkRyx3QpwVVgtLS2hs7MTOTk5aG1t3bYGSO7RZ/y+pDhGKBRCT08PlpaWcOTIEeTm5mJpaUk2USKnGObFlMvlglarlb3WcbdB4k1Y7vcu0SkgJAs+GuFLjlT4BKrVauTk5Aim/JsJwM2aQFwuF8xmMziOw3PPPYexsTEq+CiUWBF764kL/vv6+jA1NYXGxkYUFRXFdJFPRYRPikjR2toabDYbdDodWltbhVpEuaNQcq49MTGBtbU1sCwLg8EAAFheXkZOTk7K3f0p0pAqYRVtCojH4xEEoHgKCG/dQaLwIz2CthMEX6qvFfEKwEAgIKR1PR6PJA4KpEPuGUPZUfCNGYFAQLiAu91uXL58GU6nE62trXGNEJPbJ48/RqLrcxyH8fFxvPTSSygqKsKJEyfCGk/kjFDKNQd4fX0da2trCAQCaGlpQWtrK0pKSgAAg4ODOHv2LK5cuYLR0VGsrq7KLsgp0pDO6KxCoUBWVhZKSkpw8OBBXHvttTh69CisViu8Xi+WlpZw7tw5dHZ2YmpqCm63m4hoMokiVAzpgo+ELmJeAFZXV+P48eO49tprUVdXh4yMDExPT+PKlStobW3Fn/3Zn+Hll18Wmgpj4ezZs7j77ruFAMZvfvObLX/+zJkzQqOg+L+5ubmwn/ve976HiooK6HQ6nDp1Ci+//HIif/qm0AgfJWnE3nr8h5yvZysrK0NtbW3cH36x4JPrwpGoKAsGg+jq6sLKygqOHTsm1JSIkUuUAfJED2dmZtDd3Q2NRoPKykpotVpwHIe8vDz09fXhxIkTCIVCYak6lmVhsViEkV1ZWVkpuUmSWsNH8p5IES/iKSB+vx8sy6KgoABOp5NOAYkD0vdHoiCNjAA6nU589atfxeXLl3Hu3DlcvnwZL774Im644Qbhv9LS0qhrud1uHD58GA8++CDuvffemPfQ398Pk8kkfM03QgHAz3/+czz88MN47LHHcOrUKTz66KO4/fbb0d/fH/ZzyUAFHyVheG89PoWrVCoRCoXQ3d0Nh8OB5uZmwdohXlIV4Yv3Jr2ysgK73Q6DwYC2trZNDWnljPBJKXgYhkFfXx/m5uZw+PBhjI+PbzgWT2Sqjp/X6nA4MDIyIhj68gJQr9dLskdK8pAi+MTw1wyz2Qyz2UzUFBCa0k0O0vcHABqNBm95y1vw3ve+F2tra2hqakJrayteeOEF/OM//iM++MEPorW1FWfPnt3wu3feeSfuvPPOuI+Zl5e3abPit7/9bXzkIx/BBz/4QQDAY489hqeffho/+MEP8MUvfjHuY0WDCj5KQkTz1uPFkNFoRFtbG7RabcLrk5bS5ThOsJOpqalBRUXFljeEnRDhc7vdsNlsUCqVaG1thV6vF2qsxMfabA/iea0sy2JtbS3MNFWr1QriT65pDZStITHqyBMtSkXSFBCSBQvpgkqOLl0p4YMV/B49Hg+ys7Nxxx134I477gBwtT57dHRU0uMeOXIEfr8fBw4cwFe/+lW0tbUBAAKBAF577TU88sgjws8qlUrccsstuHTpkmTHp4KPEhd8Y8bk5CTMZrMQxRkeHsbo6Chqa2tRXl6e9NNxKrpDY43CBQIBdHR0xGQnI16bZME3NzeHrq6uDVNAxO+b+BjbHU+pVMJiscBisaCyslIomHY4HMK0BinMeiP3SIkNEl+zWOrk0jUFJB1NB7HCcRwVpEnCX/f599jtdm9o2jCZTDh8+LAkxyssLMRjjz2G48ePw+/34/vf/z5uuOEGvPTSSzh69CiWlpbAMMwG39b8/Hz09fVJsgeACj5KHIi99YaHh7F//34oFAp0dHQgEAjg1KlTYfUJycAbZKY7petwOGC322GxWGKyk+EhNaXLsiz6+/sxPT2NAwcOoKCgYMPPRIvwxXu8yHqZQCCAlZUVOBwOwazXZDKFmfXGc4MgNXJFmrAi9XUCEmuMSOUUEFIFC39dIe1cE7NTBB+/R7m7dOvq6lBXVyd83draiuHhYXznO9/BT37yE9mOGwkVfJSYEDdm8GLM4XCgs7MT+fn5OHbsWMIRm81IxXi1zdbnOE6IWtbV1aG0tDSuCyyJET6v1ytMAWltbUVmZua2a0t1U9FoNGHTGsRebTMzMwiFQkKRfnZ2NgwGA9E3tJ0Gia+lFJ2wck0BIbmGL1KskAjpKV2+FEmc0o12PZSTkydP4vz58wCAffv2QaVSYX5+Puxn5ufnoz6UJwoVfJQt4WsdQqGQ8NTGsix8Ph8mJydx8OBBSU9IMemK8Pl8PnR0dMDn8yUcteQvxnLYOyQy33ZhYQGdnZ0oKChAfX39phfjaGJSDvGq1+uh1+tRVFQEjuPgdrsFATg2NgaFQrGhAYTUGzDJkNalK0aOz4aUU0BIFVQ7QfCRHuHjHSX4a5vH4xE8R1OFzWZDYWEhgKsPxMeOHcPzzz+Pe+65B8DV1/D555/HQw89JNkxqeCjbEq0xgyXywW73Q6WZVFdXS2b2OOPl+qmjcXFRXR2dmLfvn04evRo0nVm6RZ8LMticHAQExMTaGpqQlFRUUxrRyJ3LaXBYIDBYEBpaSlYloXL5YraqZmdnS15JFkqSE6fkkgqvO524xQQmtJNnsgIpNfrjSulu76+jqGhIeHr0dFR2Gw2ZGdno6ysDI888gimp6fx4x//GADw6KOPorKyEk1NTfD5fPj+97+PP/3pT/jDH/4grPHwww/jgQcewPHjx3Hy5Ek8+uijcLvdQteuFJB55aSkHd5uRfzBHR8fx+DgICorK7GysiL7jTeVKV2xMGpsbERxcXHSa/PrSn3hi7WuzufzwW63IxgMoqWlJeYn2GgRvlQSadUh7tScnJyEy+UCAAwMDEhaqL8b2WsRvq2IZwqI1+uFXq8nUvjx0UfS9sXDN/aRnNKNvC7HW8P36quv4sYbbxS+fvjhhwEADzzwAJ544gnMzs5iYmJC+PdAIIDPfvazmJ6eRmZmJg4dOoTnnnsubI377rsPi4uL+PKXv4y5uTkcOXIEzzzzzIZGjmSggo8Shrgxg7+wBINBdHZ2wuVy4fjx47BarWhvb98xs263Wp9/6rfb7QiFQnEJo+3WBuSJ+sQi+JaWlmC325GXl4fGxsaYL76pSunGg7hTs7q6Wqgd5essvV5vQnVaewGSo47pFlP8FBB+EojYW3JtbQ1TU1OYmZkJs4DJzMxMu9AiPXq2E1LO4ggfX1ISj+C74YYbtvxsPfHEE2Fff/7zn8fnP//5bdd96KGHJE3hRkIFH0WAb8wQf2CXl5fR2dkJi8WCtrY2IZKiUqniGkWTCKkQfC6XCxcvXty2ti1exBE+qdlK8HEch6GhIYyNjaGhoUEYjRbP2putSwpqtRpKpVLoevP7/XA4HEKdVjAYFNJ02dnZMBqNab9JpxsS//50C75IxN6SS0tLKCgoQFZWFnFTQEhuKAF2nuDzer3gOC7lNXzpgAo+ihCCF6dwOY7DwMAAJiYmUF9fj5KSkrCLjNxiDJDX2oRlWaysrMDtduPQoUNC8axUyBnh22xtv98Pu90Ov9+P06dPw2g0xr02/x6L32vSbi6R+9FqtRvqtHgByKdVxB3AckZpSHutSBLqkZAm+MSQPgWEZDEV6XFHIpGmywBS3qWbDqjg2+NEa8zweDyw2+3gOG7TFGcqBJ9cx3C73bDb7QgEAigqKpJc7ImR84Yrfm2Wl5fR0dGB7OzspJtNSEvpRmOz/YjrtPg0Hd8Asry8jOHhYSFKwwvAVNyk0w2JwopkwRdNVJEyBYR0wcdbd5H63gLhxtput1u4bux2qODbw4i99fgLyMzMDHp6elBSUhI2gSGSnSr4ZmZm0N3dLaQ65fTKkytCKU7pchyHkZERjIyMJOQXGA3SU7rxoFAoYDKZYDKZUF5eHhalmZmZQX9/P3Q6XdgIuN3UAELy+0ay4IvFliWdU0BIFnyk7w9A2D2P9+Aj9VyUEir49iC8t14wGBQubAzDoLu7G8vLyzhy5Ahyc3O3XEOpVCIQCMi6Tynn0TIMg97eXszPz+Pw4cPIy8vDwMAAgsGgJOtHQ655uryYDAQC6O7uhtvtxsmTJ2E2myVZO91dutuRzH7EUZqqqqqwm/To6Ci6urpgMBgEAWixWGJOTZEormiXbmJINQWEP7f2yhQQgOyxdDyRKV0q+Ci7EpZlEQqFwlK4q6ursNvtyMzMRFtbG7Ra7bbrqFSqHRPh470D1Wo1Wltbhfm/qbB9kVMEvPbaa7BarXGNfNuOaBc9ElO6UhF5kw4EAkL9X39/P/x+f0xGvSRD6o2MZMEnRWNERkYGcnNzhYdnqaaAiKNTJEL6/oDogm8vQAXfHkHcmCG+0PLpwJqaGlRUVMR8kdsJKV2O4zA9PY3e3l6Ul5ejpqYm7EIkZ1OIXOtzHIexsTFwHIfi4mJhnrFU8OIuck3SBJ9c+9FoNCgoKBAMxcUNIFNTU2BZVmgAsVqtxI+AI+19E0Oy4JMjirYXpoAAOyOlG1nDl5WVRey5KCVU8O0BxN56wNWbut/vF8aHJZIOJF3whUIhIUXd3NwsRHAi15fzhij1+rwf4traGlQqFYqKimS5SO2Epo1UodfrUVxcLBj1ut1uQQCOjo6GpYhJfY1IvZGRLPhSYX2y1RSQ6elphEKhqFNASBdUOyWly6fTaYSPsmsQN2YoFAoolUrMz8+jq6sLeXl5CXd0kiz4+BS1Xq/fMkWdigifVCJgdXUVNpsNBoMBra2tOHfunGz1gSzLEitegPQJGPEIuLKyMrAsi7W1NcGmg2EY2O125OTkCB3AcnRpxgPJ7yPJgi/VUbR4poAoFAowDEPs67fTUrput5sKPsrOhm/MCIVCwhMhy7Lo6enBzMwMmpqakrIjIdF4meM4TExMYGBgAFVVVaiqqtrygih3hE8KQSn+m6qrq1FZWSk0bcg5xSPyeyQLh3ShVCphsVhgsVhQWVmJF198ERUVFfD5fJiYmEBPTw+ysrLCGkDSMQeYRFEAkC/4SJ0CMjMzA6/Xi3PnzhE3BQTYGSldWsNH2TVE89ZbX1+H3W6HSqVCa2tr0id4qiJ8sYpKcbqTH/8Wy/qpGN2WKKFQCF1dXXA6nTh27Jhg/wDIJ8J2QpcuQGbkSqFQwGKxCL6VwWBQiNCIi/R5AWg2m2W/MaZbuGwFyXsjbZqFeAoIwzDweDwoKSkhbgoIsHNSumLBF89YtZ0MFXy7DIZhMD09DZ1OB5PJBACYnJxEf39/1MaFREmV4IvFNsXpdMJut8NoNKK1tTXmNBrJXbpra2uw2WzQ6/VobW3dkJZOteAjUWCRRuRrlJGRgby8POTl5QF4o0jf4XBgZmYGoVAorAFkr42AI1nwkdwYwQuqaFNAVlZW0joFhN8fqa8dj3iPVPBRdhzixoyJiQnk5+dDr9ejq6sLq6urOHr0KHJyciQ7Hgk1fBzHYXR0FMPDw6itrUV5eXlcNxASu3TFncWVlZWorq5OeZqVdONlUkXCdkQW6Xs8HqEBZHx8HAAkT9GRLqpI3BtvaE7i3oDoYlTcPFRZWZm2KSDAzqvho4KPsqMQz8EFrtbXuVwuDA8Pw2w2o62tTfIPdzzp1mSOsZlg8vv96OzsTMp0mLQu3VAohJ6eHiwtLW0r0Pd6SnenI67RKi0tBcuyWF9fh8PhEFJ0GRkZYSPgYvHH3EmQKqr4859U0RJLBC1dU0D4/e2klK7b7ZY0GEIyVPDtYMTeevxFgLeOWFxcRENDgySjtqKRCuPlzSJk/NzYZE2HSerSXV9fh81mQ0ZGBlpbW7dNv8jdtCE+Z0hM6ZK2n2RRKpXCCLiKiooNEZre3l5kZmYK4i/WGzSpogogd2/8NYHEvQFX9xdv80+qpoDw+yNVLPNERvjKysrSvKPUQAXfDiVaY4bX64Xdboff70dJSYmsJ3E6Urocx2FoaAhjY2OSzI0lpUuXn+8bT41lKiN8wO4TWHIhlUiIjNCIb9DDw8PweDwbGkCiRVVIft9IFXw7IcJH6hQQ4KqYIn0edWQNHz99abdDBd8OhGVZBAIB4aRVKBSYmZlBT08PioqKYDQaZbd/SJXg4y++Pp8PdrsdgUAAp0+fhtFoTHp9uSN82wlK8XzfWOYXi9nLKV3S9pMKot2g+QaQ3t5eBINBmEwmQQDyJr0Aua8X6YKPxL0B8kTQpJoCItf+pIS3LKM1fBSi4U9UfjwaX0fX09ODxcVFHDp0CHl5eejr60tZfZ2cF23+GIuLi+jo6EBeXh6OHTsmmZhNZ4TP7XbDZrNBqVSGzfeNZ+1UNW2QmNLd62i1WmEEnHhKg8PhEEx6+c5MuT+niULinoCdkdKVW1AlOgWE3x/JNXziWnfg6vhEKvgoRMGyLEKhUFgKd21tDXa7HTqdDm1tbULdl0qlEsaoyQX/YZHzoq1QKARh1NjYiOLiYknXT5cty9zcHLq6ulBSUoL9+/cndPFOZQ0fQF5qkLT9AOnbU7QpDeIGkGAwiAsXLoR1aJKQwiJV8PH7InFvQOojaPFMAbFarfD7/cS+dsBGwcfXL+4FqOAjHHFjhvgCOTY2hqGhobDpCzyp6qAF5GvB93g8GBwcRCgUQmtrqywfyFQbL7Msi76+PszMzODgwYNC+iTRteXYO/Xh2/mITXpNJhN6enrQ2NgIp9OJ2dlZ9Pf3CxYdfANIOkbAkSr4SDNdjiTdKdOtpoA4nU6srq7C5XJhZWWFuCkgAMKCJgCdtEEhhMjGDIVCIdiReDwenDhxAhaLZcPvpaKDVhy+lxo+AsZPy5Dr6UtuISNe3+PxwG63g+M4SSadAPJElGgN3+6CL/3gb7xAuEXH2NgY1tfXhQ7N7OxsmM1m2WuASa6TI9l0GSBvf+IHjLKyMrz66qvIzs6GUqkkbgoI8EaQgr/WeTweGuGjpBc+qic+ORcXF9HZ2Yl9+/ahubl504tyKiJ8/IdVSsHHMAz6+/sxMzODAwcOQKPRoLOzU7L1I0lFSpdlWSwsLKCzsxOFhYWoq6uTpL5FrvpD/iLI/8dDYoSP1AgRaUS+RpEWHYFAQIjO9Pf3w+/3w2QyCQJwqwL9RCFZ8NEIX3KwLAuj0Yjc3FxhCsja2hqcTmfap4AA4ZYsAI3wUdII35gRCoXCvPX6+vowNTUVUy1bqjzypBSWkU0MmZmZWFlZSUmNnVzCgRfpIyMjOHDgAAoLCyVdmzZtkAdpQiGW902j0YR1aIobQKanp8GybNgIOIPBIMkEEIC81wsgL4IWyU4QfOL9KZVKWCwWWCyWtE8BAaILPtq0QUk50bz13G437Ha7IIRiOTFTEeEDpBOWvA9daWlpWBNDKmrsAHkiRT6fD0tLSwCAlpYWyVMGcjdtbPe9dELafkgn3tdLr9dDr9ejqKhIMHLnBeDo6GhYijjR9BzJgm8nRPhI399WgjSdU0D4/fGCj2EY+P1+KvgoqYW3WxF/WKamptDX14eysjLU1tbG/FSXiggfkLwgC4VC6O3txcLCAg4fPiwMmZdq/e0Q1yFK+cTM28hoNBrs27dPlvoQarxMU7qxkOz7plAoYDAYYDAYhBFwLpcLDodDSM9ptdowARjLCDiSBR+N8CVHvLYsqZwCAoQ3GrrdbgDy1YmTBhV8aYbjOIRCIcFGRalUIhQKoaurCysrK9vOVI1GqiJ8yQgyl8sFm80GjUYTZikj1fqxIHUdongSSGNjI9bW1mS1rJFT8Pl8Png8HpjNZprSjRFSXyMpz0GlUgmz2Qyz2Syk5/ib8+TkJHp6esKiM1arNerNmXTBR+K+eEgXfMk6N8g5BYTfn9h0GQCN8FHkRzwHF7h68VtZWYHdbofRaERbW1tCtQwkR/g4jhMilxUVFaiurt704sDXL8p1ARandJPF7/cLY+34SSAul0s2ESCn4PP7/bh06ZLwtUqlglKpxL59+4jwb6PEjtziRaVSIScnR3goDQaDQgPI8PAwvF6vcHPmG0BUKhXRgm+np0zTjdT7k3IKCLBR8GVkZKTFligdUMGXBsTeeuLGDD46tH//fpSVlSV80SG1ho+PXDqdzpgil/zfL2dTBZB8hG95eRl2ux05OTk4evSoENFQKBSyvQ9yCD6WZTE9PQ2Px4NDhw7BYrHA7Xajt7cXa2truHz5cph/m9VqTcvMTJJvxnudjIwM5OXlCeUZ4ptzd3e3MKFBitGIckF6Spfk/fEP6HJO2khmCggQnnJ2u91EeQTKDRV8KSZaYwY/JzYYDEoyJzaVEb5YBc3q6ipsNhsyMzPR2toaU52PXDV2PLybfqLCieM4jIyMYGRkBPX19SgpKdlggL1TInw+nw82mw0+nw8GgwF5eXkIBoMwm80wGAwwmUwoKioSUiujo6Po6uqC0WgUCrDNZnNKb0SkplBJIt3pycibMz+hYXFxEQBw/vz5sPQvCTdfkiN8fLCAVMEXaWosN/FOAbFarQiFQmE1fHvFkgWggi+lMAwDj8cjpMgUCoVgMlxYWIj6+nrJPNoYhpH9Yh9LSpfjOIyPj2NwcDDqVJDt1gfkMXcWHyOR9QOBADo6OuDxeHDq1CmYTKYNP7PVLN1kkVLw8RHKffv2oby8HKOjo2HvEX+syOJqv98Ph8MRFr2xWCyCAMzKyiL2xikXpP29JIli8YSG7OxsXL58GUeOHBFGwPEGvXz0ONX+bDzpFslbwb+fpAo+/nqXrv1tNwVkdHQUHMfhX/7lX3DkyBFYLJa4ylTOnj2Lb33rW3jttdcwOzuLX//617jnnns2/flf/epX+Od//mfYbDb4/X40NTXhq1/9Km6//XbhZ7761a/ia1/7Wtjv1dXVoa+vL+6/fzuo4EsBvLfeysoKLl26hFtvvRUMw6Cvrw/z8/M4cOAACgoKJDteKubcAtuLpUAggK6uLqytreH48eOC03886wPyCr5ERJnT6YTNZoPFYkFLS8umaU05mx2kWJvjOGFEHx+hXFxcjLlLV6vVhkVvotl38Dfv7OzstNy8KeSJUOCNtKTJZILJZEJFRUVUfza9Xh8WAUxFCQHJETRxvTeJpFvwRRI5BYRlWXR0dKCwsBDPPvssbDYbOI7De9/7Xtx000248cYbUV1dvenr63a7cfjwYTz44IO49957tz3+2bNnceutt+Jv//ZvYbFY8MMf/hB33303XnrpJTQ3Nws/19TUhOeee074Wq5JN1TwyQzLsgiFQkKhKO86ztt2tLa2Sl4IL/YYkvODt1VK1+l0wm63w2QyobW1NaGiWD7lmsp5t1shFkix1FmSnNINBoPo7OzE2toaTp48CbPZvOm6sRwrmn3H2toaHA4HZmZm0N/fD71eHxa9SfSiRurNjkRIivCJifYwGs2fTRyZ4UsIxPYcctSKkRzhI01QRSKeDEUiSqUSGo0Gn/rUp1BZWYmf/OQn+N73vof6+nr8+7//Ox566CHk5+fjpptuwt///d9vqDO/8847ceedd8Z8vEcffTTs67/927/Fb3/7W/z3f/93mOBTq9WSBn02gwo+mRA3ZvAXEP7i9NJLL6G6uhpVVVWydp8yDCPrE3G0CJ+4rq22thbl5eVJ/Y2p8OKLZX2xQNpshnEkpEb4XC4X2tvbhXrKSDEeecNL5P0Tu+tXVVUJN2+HwyF0byY7vos0MUPafnhIvPnGIqrUavUGew5eAPb19YV1Z2ZnZ28ozk9mb6QKKtIFH8nRUR7xHoPBIAoKCvCVr3wFX/nKV+DxeHDx4kW8+OKLUct0pDi2y+USHmp4BgcHUVRUBJ1Oh5aWFnzzm99EWVmZ5Mengk8GIhszFAqFUPMFAM3NzcJFTA74Jyy5Gzcim0P8fj86Ojrg9XrDokbJkKp5t1vBN5wYDIa4opVy1/Alsvb09DR6enpQWVkZNXUhl/Fy5M3b5/PB4XBsGN/FR3hIKN7fDZAqQhOJomm1WhQUFKCgoGBDd+bU1FTYOWS1WhOuISW5aYPfG8n7k7NDVwoibVnEHnyZmZm45ZZbcMstt8hy7L/7u7/D+vo63vWudwnfO3XqFJ544gnU1dVhdnYWX/va13DttdcKEW0poYJPYvionji0vbS0hI6ODkHVp8LVOxXWLGIxtry8jI6ODlitVjQ3N0tWg5CKCN9mN0WO4zAxMYGBgQHU1NSgoqIirgut3CndeF4XlmXR29uLubk5HDlyZNMHjmiRPTkilTqdDkVFRcL4rvX1dTgcDiwvL2N4eBgZGRlh9i+xdHVTNkJqejLZfUXrzuSL8/lziE8Ri0fAxbo3UqNUJO8NkL+MSAq2Enxy8h//8R/42te+ht/+9rdhU6XEKeJDhw7h1KlTKC8vxy9+8Qt86EMfknQPVPBJBN+YEQqFwrz1+vv7MTk5iYaGBhQXF2NxcZFIj7xE4EXl4OAgxsbGolqTSHGMdET4xJ6BiTSc8GuTkNL1er1CcfJ2NaOb1fDJibiwury8PKx4Xzy9gY/+7ZUxSFKxGwVfJNGK8/ka0tnZWfT390Or1YYJwM0i9aRH+EgWVKTvD9go+FJhy/Lkk0/iwx/+MJ566qlto4cWiwX79+/H0NCQ5Puggk8ConnreTwe2O12AEBra6vwFKFSqVI29kzu47Asi4WFBWRkZEjiHxiNdET41tbWYLPZoNfrE552wq8t195jjR7yc30LCgrQ0NCw7cU40aYNKREX71dXVwvTGxwOB/r7++H3+wEA4+Pj2LdvH0wmEzE3aFL2wbObUrrxIK4hBa4+wPEekuPj4+ju7t50PivJUTTSBdVOSOmKX0O32y17hO9nP/sZHnzwQTz55JO46667tv359fV1DA8P4/3vf7/ke6GCL0kYhgmbmAFcrZPq7e1FaWkp9u/fH/YBJXUKRrwsLCxgenoaOp0Op0+flq2NPJVNG+Kxb5vVuMVDOiN8HMdheHgYo6OjaGxsRHFxccxry1HDlwyR0xtcLhdeeeUVrK+vY3p6GgCEG3d2djb0ej1xwiudkPhapDrVHOkhGQgEhPo/fj4r30Tk9XrTMkEmFkiOPgI7M6UbSwMez/r6eljkbXR0FDabDdnZ2SgrK8MjjzyC6elp/PjHPwZwNY37wAMP4Lvf/S5OnTqFubk5AIBerxdq3D/3uc/h7rvvRnl5OWZmZvCVr3wFKpUK73nPeyT6i9+ACr4E4TgOoVAIoVAIwFXhEAqF0N3dDYfDsWmd1E6P8LEsi4GBAUxOTiIvLw8KhUI2sQekLqUbCoXQ09ODpaWlmMa+xbO2HGwl+MSm0PFGXqPdTEi7wfApmMbGRqjVarhcLjgcDiwsLGBwcBBarTas/m+vzMmMxl6N8G2HRqMJm88qbgBZWloSmkL4c8hgMBDxOdgJET6S9weECz6v1xtXhO/VV1/FjTfeKHz98MMPAwAeeOABPPHEE5idncXExITw7//6r/+KUCiET37yk/jkJz8pfJ//eQCYmprCe97zHiwvLyM3NxfXXHMNLl++LEtjJxV8CSCegwtcvSGurKygo6MDWVlZaGtr27TIPFWCT44IH5+m5mvBFhcX4XQ6JT1GJKnw4fN6vbh06ZLgiyiVQXA6fPhWV1fR3t4Ok8m0pSl0vOuSKhwUCsUG896VlRU4HI6w1J14/Jtc3m2kQoJQiSTdgi8SvV4PvV6PoqIi9PX1geM4GAwGwQOQTxHzAjBdUWTSBdVOSekm2rRxww03bPlZ50Ucz5kzZ7Zd88knn4z5+MlCBV8cRGvMABCX7xyJc25jgR8BV1RUhPr6eiiVSiwvL6ekMUTOYwQCAYyMjKCiogI1NTWSXkxTmdIVp6PjHWG31br891JxzsZLtNdWpVIhJydHiNAGAgFh/Ftvb68wH1jcAEKS8JAa0oQVD6n7Aq7uTavVorS0VDARd7lccDqdmJ+fx8DAADQaTVq6yEkXfKSndPl7eCpr+EiCCr4YidaY4ff7YbfbEQgENp2nGslOi/DxI+BmZ2c3jIBLtfWLlDAMg97eXqyvr6O4uBj79++X/BipSukyDIOenh4sLi4mnY5OR5eunGg0mjDvNn6wusPhwNjYGJRKZdiNO9mpNzv5tUolpAu+yLprs9kMs9kcNgLO4XCEdZGLR8DJVeZCuuDbCfsDkBZbFhKggi8GWJZFIBAQTmaFQoH5+Xl0dXUhPz8fx44di/kDvpNq+NbX12G326FUKtHa2rqhfT1V1i9SH8PtdsNms0GlUmHfvn2yfeBTEeHzeDxob2+HSqWSLB1Neko3UaEQOVidj9yIrTt0Ol2YdQepxfuxQrKwInVf2zVGRI6A47vInU6nMEVGPAJOyjICkjuIAfIFH39PTLUtCylQwbcFfPiXH4/Giw8+4tXU1ITCwsK41twpXbr8RIaysjLU1tZG/RDLnW7ljyGl2JidnUV3dzdKSkqwf/9+dHV1pd06JREUCgV8Ph8uXryI4uJi1NXVSXKh3axpgyTBJxXiyE1lZaVg3eFwOITZreLxb2azmeibWTRIfd9I7jaNV1RFdpH7fD5BAIrLCMQj4BL920kXVKTX8IkzdPwD817y9aSCbxP4zk3xCcJHvNRqNdra2hJK/5Ae4eO7VRcXF7ecyMAfY6dE+HihPjMzg4MHDwrdeenqpE0G3v/Q5XLh0KFDcT90bMVOSulK/dpGWnf4/X5h/Ft3dzdCoVCY/Yt4dBepwgog8/0jOfKY7N50Oh0KCwtRWFgYVkbgdDqFDk5xA0g8YwRJF3wMw8jq2pAsvCAVZ0hoSncPw3Gc0IUr/uDzI7YqKipQXV2d8IculTV88R7H5XLBZrNBq9Wira1t2/TgThF8Ho8HNpsNADakpuWMwsnx+vB1o263GyaTSVKxB+y8Ll050Wq1YTdut9stNICMjIxArVYL4i8eL69UQur7RrLgkzL6GFlGwHGc0ACyuLiIoaGhsPPIarVued0lOTIK7AxBKt4fFXx7mMjGDIVCgWAwiM7OTrhcLhw7dkyo20gUlUqFYDAoxXa3hPcFjAWO4zA5OYn+/v64DIdTIV6TFU3z8/Po7OwM6y4Ws5MifE6nEzabDVarFQUFBYKJp9Ske9LGdqTjhqdQKGAwGGAwGITRXfz4N95oHbjasZ+bmxs2uSHdkCgQSBZ8ctbJiW2EysvLN5xHfX19W9aRki6odkJKl98fjfDtYfioHv8EoFAosLy8jI6ODlgsFrS1tUlSwK1SqeDz+STY8fbH4UdQbUUwGER3dzecTmfcHZ4kR/h4g+ipqakN3cWR68tZZyfF68NxHMbHxzE4OIj9+/ejrKwMs7Ozsuw7WoqS1BtzOuG7e61WK6qqquD3+3HhwgVwHBc2uYEv7jcajWm5UZMk1MWQLPhSGUWLPI+i1ZGKG0BCoRDxgo/k/YkFn9/vB8MwtIZvL8FxHAKBAGZnZ5GXlycIgIGBAUxMTKC+vh4lJSWSXQBIsmVZXV2FzWYTzKLjnUiQKsEXb0TU6/XCbreDYRi0tLRs+QSXyPqxIoWYDIVC6OrqgtPpxPHjx2G1WgHIF5ncSU0bJO2JfxisqamBRqMRJjc4HA5MTU2BZdmw+r946raSgVRhReq+gPR2wkYbAceXEfT398Pn80Gr1UKj0aT1QWIzSPfhizRdBkAjfHsFPoXLC4Rbb71V+N8sy6KlpUVy9Z+qLt2tjsNxHMbGxjA0NISamhpUVFQkdPElMcK3uLiIjo4O5Ofno6GhYdv0QipSuone3NbX19He3g6tVovW1tYwc1e5RNhmTQgkiStShYIY8eQGjuOwvr4Oh8OBpaUlDA8PIyMjQxB/2dnZe3L8G6nvI0l1cpE+kj09PQgGg3C73cKDhMViidpIlA52QkpXbLoMgNqy7BX4myZfazM9PY2BgQHBiFeOEzfdEb5AICDUJJ44cSKpYnM+giVnGD9WQcayLIaGhjA+Po7GxkYUFxfHtL7cKV0gsWjG7Owsurq6UF5eHnUCiJyvN0BTulKiUChgNBphNBpRXl4e1bjXYDCENYBI6dtG4vtH6r4AcvemUCgEK6HKykrhQYLvAOZHwIkjyckaicfLTkrpejwe6PV6ovcrNXta8AHhN87BwUEcOnRI8FOSg3TasjgcDnR0dMBsNktSk8h/cOT8kMcS4fP5fOjo6IDf7487KitnlJJ/TeIRlCzLor+/H9PT0zh06JBgHxOJ3OPOIgUfSRE+HpL2FM9eIo17A4GAkP7t7++H3+8PG/+WjG8bQKZgJymKFgnJ5sbi1038IME3Eq2trcHpdGJubg4DAwPQarVhHcByR5JJT+mKBZ/b7U5ZaQUp7HnBt7q6iitXrgAAjh49KtRIyUWqZumKj8NxnDDvly/6l+Ik5z/Ycv492wmy5eVl2O127Nu3D0ePHo27M1LuaRhA7GLA5/PBZrPFVHsYz7rxsNl5QZK42m1oNBrk5+cjPz8fHMfB6/UKdVu8b5v4ph1PCorU943UKBpAthjd6uFaqVTCYrHAYrGgsrISDMNgZWUFTqcT4+Pj6O7uRlZWlnAeydFJvhNSunt1ygZABR/m5+dRVlaG4eHhlDyZpDrC5/f70dHRAa/XG/O833iOAaRH8HEch+HhYYyOjibVWCNnhI/fTyzri4VrU1PTthdNuVLROyWlS+KepEChUCAzMxOZmZlhvm0OhwPz8/NC1IaP/sUy/o3E14pkwUd6hC/WvalUKuTk5AjOC4FAQOgAFneSi0fAJft3k57SFe+Pt2Qh9TyUgz0v+Orq6sAwDMbHx4k1RE70OMFgEBcuXEBOTg6am5slf5pTKBSypxajCbJAIAC73S6JiJVz/7GkdDmOw+joKIaHh+MSrqls2qAp3fQh9m2rqKgQojaRth28+Iuc20rqa0Sy4NupEb7t0Gg0G0bA8ZHkmZkZhEKhsAYQg8EQ9+uwk1K6NMK3B+FPaLVavWsEH8uymJqaQiAQwIEDB1BcXCzbBUzuvydS8InNh6UQsalq2ogGb+q9traGkydPwmw2x7W23IJPfM6QKhxIQ26hEBm18fv9Qv1fT08PQqFQWP0fqcKK1H0BuyfCtx06nQ5FRUVCJ7nb7RYaQMbGxqBQKDY0gGz1nsndwCcFDMMIdYxut3tPWbIAVPAJpDrVKtcFj7eVCQQCUKlUKCkpkfwYYuS2ZuEFmdhKRuo6xHSkdF0uF9rb25GZmYnW1ta4i6lTGXUjNcJHuTr+TWzb4fF4hKjN2NgYOI6DTqcTare2G5eYSkgWfKTuTS5BJZ4kU1paCpZlN4yA462EeAEotokC3ngo3Ek1fKnuYk43VPC9TipTrYA8xa0LCwvo7OxEfn4+ysrKcOnSJUnXj0YqBB/DMLhy5QrW19fjjoRtRypS0pFiaXp6Gj09PXGNsYskFRE+OaOfyULqDTmdiOe28jft7u5u+P1+zM7Oor+/H3q9Psz+RYrpQYlAuqgidW+pij7y9i9ms1koJeBHwE1NTaG3txeZmZlhDSDi3yUVsWCmEb49TKoFn/hJI1nEVh5NTU0oLCyEz+dLyvQ3VuQWfB6PRyiubW1tlfwGJbeoEQszlmXR29uLubk5HDlyBLm5uZKsKyViwcefO6RG+EjaE0l74VEqldBoNMjMzER1dTVCoZCQshseHobX691Q/5eqmzWpaVP+vCdxb0D6miLEVkLV1dUIBoNCB/Dw8DA8Ho9gh7WysgKr1UpkpC8ywkcF3x6Dv8GlI8InBR6PBzabDQDCrDz4iwLDMLIOcZdrcgg/P3ZgYAAqlQrNzc2yCFe5I3z8+l6vF+3t7VAoFGhtbU06lSC3nQzpXbqU2BC/j2q1Grm5ucKDhs/nE+r/pqenhakNvACUs4OR1Agf/3qRuDeAnOhjRkZG2Lnk9/sxPz+PoaEh9Pf3IxgMCrOkrVYrMSPgqOCjALgqxEKhkOzH4d3SpRBJs7Oz6O7uRnFxMerq6sI+UFILy82Qw1cwGAyiq6sLq6uraGxsxMDAgGwXObkjfEqlEk6nE0NDQygoKEBDQ4MkFz65o247oUuXEhubfXZ0Oh0KCwtRWFgoFO07HA4sLy9jeHgYarVauGFHq9lKBlKESyT8eU6COIkGqU0RvFWQSqVCa2vrBi9JjuOE+j+5Hya2InKWrpTlQTsBKvheJ1VdukDy0USGYdDb24v5+XkcPHgw6jQGcYRPTqRO6a6trcFmswnNDH6/P63GzsnAcRwYhkF/fz+amppiHvcWC6kwjBZDmuAjUSyQSKzvm7hon5/awI9/42u2srKywur/kskckBrh468FJO4NIFfwAW/sbTMvSafTGfYwIW4ASVUzkdg2xuPxoKioKCXHJYU9L/jEKd1gMJiSYyYj+NbX12Gz2aBWq7dMDUoZSdwKqQQTx3GYnJxEf38/qqqqUFVVBYVCgUAgsCMFXyAQQEdHB1iWlVzsATSlC5AnQgEyX6tEDcn5GzJfs8XX/4lNe8Xj3+IRIqQKPhrhS5zNGhHFXpLl5eXCw4TT6RSaiXQ6XdjDhFwj4KgPHwXAVRHm8/lScqxEhBjHcZienkZvby/Ky8tRU1Oz7Qc/FWPcpBBMoVAI3d3dcDgcOHr0qOAxJtX6WyGHcFpdXUV7eztMJhN0Op0srf/8vuW4cSoUCjgcDszOzsJkMkGtVqdkHCBFeqQ6tzMyMsJMe8Upu8nJSSFlxwvA7TzbADLFMek1fCQ3lMRquix+mACuXv/5BpDR0VG43W4YDIawDmCpGkBoDR8FQOqaNhI5VigUQk9PD5aWltDc3Ix9+/bF9HupiPAl+7q5XC7YbDZotVq0trZuqBMSj2+T40InpaDkOA5TU1Po6+tDdXU1Kisrcf78eVnEkpzF9CzLYnBwEOXl5fB6vZibm0MwGER7eztycnKQnZ2950YS7VTkiqTp9XoUFxejuLg4bPyb2LNNXP8XGbEhNcLH1xaSujeSBV+i12i1Wo19+/YJ97VAICA0E/X398Pv94c1gJhMpoSOw1/baISPkrKmDf5YsYokvqZNp9OhtbU1rloH0iN8vB9dRUUFampqol5k5RZ8UnXpMgyD7u5uLC0thUUpUz0RIxmCwaCQhj506JDwNywvL2NwcBD79u0TRnqJbRqi3dDlhrQbMonpZR65X6to49/4+r+JiQn09PRsiNiQKvhI3Rewd9LNGo0G+fn5Qm26OJo8NTUldJPzUcJYR8Dx13mx4OOtZPYKe17wpdqWhT/WdiKD4zhMTExgYGAgrKYtHkit4WMYBj09PVhYWNjWj04s+ORAPMkj0Qu92+2GzWYTOtTEolyuLmDxFA8pLrIulwtXrlyBwWBARkZGWBqaL8QuLS0VDH35G/rk5GTYDT07O3vDPFe5IFlkkUI6XiPxwwAQHrHp6+tDMBiESqUCx3Ewm80wGo3EiCxSu4eBN66BpAo+Kb1lxURGk/lucj4FLE4RW63WTcsJ+HuhuGmDRvj2IAqFgqguXd6WZGVlBceOHRMunIkch7QIn7jppK2tbduIJf/hTMW820Qu9PPz8+js7IxqjcOvL8fepXxdZmZm0N3dLUz+OHPmzIafER8nsqBffEPv7e1FMBgU/Nxo+jf9pPu1F0dsOI6D1+tFZ2cnfD6f4CEaWf+XLkhPmQLpfz83IxUNJdG6yflygvn5eQwMDECr1YZ1APPZB7Hg48cQ0gjfHiWVEb6tIm8rKyuw2+0wGAxoa2tLKlWWqghfrMeYnZ1FV1cXysrKUFtbG9PFYat5tFKQqHDi69wmJiZw4MABFBYWRv05uYydxUI1UcQTWsSR1mhdulsdJ/KGzs9zdTgcGBkZEfzcpEz/knrTIw3SoqC8ZQd/zhQUFES9YfPnitVqTen4NxrhS5x0dBCLR8BVVlaCYRihAYTPPvB2Qnzkj7+e7cWmDTLPnDSQSsEXLZrIcRxGR0fxyiuvoKysDEePHk36xpiKCF8sx+Dr23p6enD48OGokbDN4O1l5BZ88azv9/vx6quvYmFhAS0tLZuKPX59uWv4EsHv9+OVV17B8vIyWlpawtLqydiy8PNcS0tLcfjwYVx33XVobGyERqPBxMQEzp8/j1deeQXDw8NwOp27rvuXRLFA4p6ANz7b/M366NGjuPbaa7F//36oVCqMjo7i3LlzKT1fSI/wkbo3QL6UbjyoVCrk5OSgpqYGJ06cwLXXXovKykqhROqxxx7D6dOn8dnPfhZra2sxP0ycPXsWd999N4qKiqBQKPCb3/xm2985c+YMjh49Cq1Wi5qaGjzxxBMbfuZ73/seKioqoNPpcOrUKbz88stx/sXxQSN8r5POCB/v2eZ2u3HixImwQdRSHkcOthNj/Og3hUKBlpaWhGomSBJ8TqcTNpsNVqsVR48e3dZ8NhVNG/GysrICm80Gi8WCY8eORf0bItdN9G9QKpUb6rn46F93dzcYhglL/2ZmZsYsUEiLXpEIqU0Im+0rsmPT7/cL9Vrd3d0IhUJh499iLdiPFdIjfCQLPhL3J7YTysvLw3ve8x5MT0/jzJkzCAaDaG1txbXXXoubb74ZN998M5qbm6OKVrfbjcOHD+PBBx/Evffeu+1xR0dHcdddd+HjH/84fvrTn+L555/Hhz/8YRQWFuL2228HAPz85z/Hww8/jMceewynTp3Co48+ittvvx39/f2C/ZHUUMGHqzdPvks3FRdIsbh0OByw2+2wWCxobW2VNH2R7hq+7erbpDhGssQqnPjZvoODg9i/fz/KyspiOk/k9hGMV/RMTk6ir68PtbW1KC8vj/o3RH5PStGq0WhQUFCAgoKCqOO8eDsP/r9UpvMoqSPW66xWqw0b/yYuF+AL9sX2L8lObCA5wkfy3gAyBZ8YhmFQWFiIe+65B+9///tRUlKCP/7xj2hvb8fzzz+Pb37zm1AqlXjiiSfwlre8Jex377zzTtx5550xH+uxxx5DZWUl/v7v/x4A0NDQgPPnz+M73/mOIPi+/e1v4yMf+Qg++MEPCr/z9NNP4wc/+AG++MUvSvRXh0MF3+vwUY7N3MKlRKVSwe/3Y2hoCKOjo6irq0NpaankQjNdNXzi2rADBw6goKAg6WPIKfi2q7MLhULo6uqC0+nE8ePHBcPQWNeXK8IXz9osywqd0ZHm1tHWTsWkjcgCbLGdx/j4OLq7u2E0GsO6f/kbCmlRGFKjjTstwrcVfLkAXzLAsizW1tbgcDgwMzOD/v5+6PV6QQBarda4x7+R+noB5AsqlmWTGrcnN5GmywBw9OhRXHPNNfjUpz6FUCiEK1euoKSkJOljXbp0CbfcckvY926//XZ8+tOfBnA10/Haa6/hkUceEf5dqVTilltuwaVLl5I+/maQ++6kGP5ESEUdAsdxWFpaglqtxqlTp2AymWQ5Tjpq+LxeL2w2G1iWRUtLiyRFsamYtrHZ+uvr62hvb9/UGDqZtZMlVsHn8/nQ3t4OAGhpadm2CzLauqkQNJF2Hnw6T5z+5SM5vJUOZWtIfY2kEFZKpRIWiwUWiwVVVVUIhUJCt/jw8DC8Xm/YA0Mshr00pZs4DMOk3I8zHiIFn0qlCrueq9VqnDx5UpJjzc3NbZhxn5+fj7W1NXi9XjidTjAME/Vn+vr6JNlDNKjgwxvFwwBkj4gtLi5ibGxMmIUr5xNRqmv4FhcX0dHRgfz8fDQ0NEgmnOUWfJs1VvBdxeXl5aitrU3oRpDKmbfRcDgcsNlsyMvLi/k9ibdLVy4i03nr6+vCNIdgMIjOzk7s27cvLd2cOwkSBYwckTS1Wo3c3FyhAcnn8wn1f52dnYJh71b1oiSnTUkXfDtpf7wHH4mfDTmhgu91+Do+uQSS2MajoKAAXq9X9vB3KqaH8KKyv78fExMTaGpqQlFRkeTHkFvwidcXp6QPHz6cVAGtXF26wNZCTFxzWF9fj9LS0qSOk24UCgWMRiOMRiPKy8tx7tw5lJWVwe/3Y3R0FF1dXcL4pVijOXuB3Rzh2w6dToeioiIUFRUJDwxOp1OoFxXbBVmtVmi1WuIjfKTuDUhNOVQyiCN8brdbVn/QgoICzM/Ph31vfn4eJpMJer0eKpUKKpUq6s8kWwK1FVTwiZBL8Hm9XtjtdoRCIbS0tMDlcmFsbEzy40SSighfKBSC2+0WUrhyGFnKmRaNXJ83g2UYBq2trUk7sacjpRsKhdDd3Q2Hw5FQ1ze/rnh90oSD2H8LCE//8tEcsZlvqhz1Sbwhk7inVNfKiR8YxPWikX5tGo0GoVCICIuRSEiPoDEMQ/z+UjVHt6WlBb/73e/CvvfHP/4RLS0tAK42rx07dgzPP/887rnnHgBX39/nn38eDz30kGz7ooJPhBwRsfn5eXR1daGgoAD19fVQqVTweDwpsYCRu4ZvaWlJqDc4ffq0bBHLVKV0l5eXYbfbkZubi8bGRkku+KlO6Xo8HrS3twslA/HWHEZbN10p3XjYKv07ODgIrVaLnJwcZGdnw2Kx7Jn0L6nvW7qbI8T1otXV1QgGg4L483g8OHv2LMxms/DQYDQa0y5mSBd8pO8vMsK32Qi2aKyvr2NoaEj4enR0FDabDdnZ2SgrK8MjjzyC6elp/PjHPwYAfPzjH8c//uM/4vOf/zwefPBB/OlPf8IvfvELPP3008IaDz/8MB544AEcP34cJ0+exKOPPgq32y107coBFXyQZ54uy7Lo6+vDzMzMhk7VVDRTAPJF+DiOw/DwMEZHR1FWVoaZmRnZaxHlvnFNT09jbm4O9fX1KCkpkexmlMqULl9DWVRUlJQNTqq6dJNls9c1Mv3Lu+/zkz88Hk9Y+peEm7lcpFtYbQZp++L92vx+PzIyMlBbWytEjCcnJwEgbFxXPGJBKkgXVKSndMX7i3fKxquvvoobb7xR+Prhhx8GADzwwAN44oknMDs7i4mJCeHfKysr8fTTT+Mzn/kMvvvd76KkpATf//73BUsWALjvvvuwuLiIL3/5y5ibm8ORI0fwzDPPbGjkkBIq+ERINU/X7XbDbrcDQNS0YKpMnuU4jt/vR0dHB7xeL06fPg2WZTE9PS3pMSKRM8IXDAYRCASwuLiIkydPCilCqUhFSpfjOIyMjGBkZESSGsp0denKBe++z1vR8MX8kTfzZGa57uTXJx2QJvh4+KYNvV6P4uJiFBcXg+M4YfzbwsKCEDHmzxmr1ZqS7lSSG0oA8gWpuIuYr+GLlRtuuGHLz3i0KRo33HCD4I6wGQ899JCsKdxIqOATIYVA4gfRl5SUbBplSZXgk1oo8SbRVqsVzc3NUKvVcLlcaTV3TgaXy4X29nYoFArU1dVJLvYAeesoFQoFAoEA2tvb4XK5ZLP4IfHGnMyeIov5I2e56nS6sGJ+kr3FtoNkYUXivqI1RigUCphMJphMJlRUVITNa+X9Ig0GQ5hfpByRrp0gqEjfH/++eL3elNX1ksTOvZJJiBQpXYZh0Nvbi/n5+W07O3dahI+f8zs8PLzBJJqE8W2JMD09jZ6eHlRWVmJhYUG2C5Wc9W8cx6GnpwdGoxEtLS2SRRl2Sg2fFHuKvJmHQiEh/ct7ufHp35ycHBiNRiKFylaQuF9SBV8sUbTIiDE/LtDpdKK3txfBYBBms1kQgFKNf6NdusmRTEp3t0AFn4hEmzZcLhfsdjsyMjLQ2tq6bUqIr+uS+4lNCqEUCATQ2dmJ9fX1qClPlUolpBXluhhJKfhYlkVvb69QM5Gbm4vl5eW0euUlwtzcHHw+HwoKCnD48GFJX/vNavhIvUlLSeQsV94kVZz+FUf/Ekn/phIShTpA7rmUiKiKHBfo8XiEc2ZsbAxKpXJD/V+ieyM5gkb6/sQRyHhTursFKvhExBsR4zgO09PT6O3tRUVFBaqrq2M64cVTPeT8gCQb4VtZWYHNZoPJZNp0zi+/fzmf7qQSfF6vV0jhioW5nDWCUq/NcRwGBgYwOTkppCalvnFuJlJJvUnLiV6vh16vD0v/Li8vY3Z2NmyUl9FoBEBmNI3EPZF6LiVbJyce/1ZSUgKWZYWSgbm5ubCSAV4ExtoxvpMEFYmk0paFVKjgExGPQOK9zpaXl9Hc3CxEBGI9DnD1BJTTHiJRsSE27a2trUV5efmmF+edIvj4DtaCggI0NDSEXZhIGH8WC4FAAHa7HT6fD6dPn0ZHR4dsc3q3+poE0rEncfq3srIybJTX6OgoAKC9vT2s+zfdrx2N8MWH1PsS+0Xy5wxfMiA2DOejf+J50ZGQnDLlszyk7g/YKPiSMdTfqVDBhzduHmq1Gn6/f9ufX11dhd1uh16vR1tbW9xeZ0qlUnYzYSCxCF8wGERXVxdWV1dx/PhxWK3WLX9eLPjkIpk6QbGFTGNjI4qLi6OuL2dKV4rXZnV1Fe3t7TCbzWhpaYFarZa9PpBHnNIliXTvRzzKy+/348KFC8jLy4PT6cTExAQUCkVY969Op0vLPveCsJIKuUVVZMlA5LzoUCgUNv5NPA2CZVli/SP5a9xOifC53W5ZhgSQDhV8IrYTSBzHYWJiAgMDA6iqqkJVVVXCF61UNG7wkbFYL66rq6uw2WzIyspCa2trTE0A/Lpy/i1KpRLBYDDu3wsEAujo6IDH48Hp06eFtFskpEf4+AaT6upqVFZWCq+5XIJvswkb6RZYJMO/NsXFxRtSeZHpXz6dl4poCInCSu6a32RItfVJpGG42+0WGkBGR0ehUqmEh4ZgMEhszSh//SdZ8InFPO3SpWwpwvhh7WtrazFFvpI5llTwJ/d2T60cx2FychL9/f1xC1l+BnEqZ93GAh8RM5lMaGlp2fLJWM4IXzJr8+bds7OzUcsGUiH4+K9Jg8Q9iYlM5QWDQSGVNzAwAL/fHxbJkaqTcydB4t+bzk5YhUIBg8EAg8GAsrIysCwrjH+bnp7G2toaVldXEQgEhIkxpFgG7ZQIH78/2qW7h9nOlsXpdMJut8NoNMYc+doOUgSfeO7qsWPHkJ2dHfdxUjH6LNb1OY7D1NQU+vr6UFNTg4qKim0v4HLuP9HoIT/Tl59RHO1pVE7BFw0a4duezV67jIwMIf0LXL3h8Kk8vpOTF3/Z2dkJjcSLBomRNP48Im1fAFnmxuLu3qqqKthsNmi1WnAch8HBQfh8PsEyyGq1wmQypW3vfEMJie8pAMEVg9qyUAQibVnE/nPbNS/ES6r864DNm0N442G9Xp/w3FX+OHIKvlhFE8Mw6O7uxtLSEo4ePSr4ZEm1fiIkIsqcTidsNhtycnLQ1NS0qVinNXxk7SceMjMzkZmZKaR/19bW4HA4MD09jb6+PmRmZgriz2KxJJz+JfE1Ilnwke51ZzKZhDpksWXQ1NQUWJYNs3/JzMxM2d+yEzp0AVDBl+4NkIJCoQgbreb3+9HZ2Qm32y3LyK1U1fBtJmampqYEO5mampqkLgxyi9dY0qJutxs2mw0qlQqtra1xFciTktIVp9b379+PsrKyLd+XvZzS3U0olUpYLBZYLBZUVVUhGAwKN/L+/n4EAoGkjHxJe/9IFnwkRfgiibRlibQMWl9fh8PhwNLSEoaHh5GRkRHWNCTn+DfSLWP4eyDvG0sFH0UQYcvLy+jo6IDVat3Uf06qY8lNpBhjGAY9PT1YXFyM205mM9Jdwzc/P4/Ozk4UFxdvOs5uK+SO8MUanezp6cHS0lLMNaKpEnw8JEWLSBMLUr42GRkZyMvLQ15eHjiOg9frDUv/igv5t0v/kvSe8ZAu+EjcF7C1qFIoFDAajTAajSgvLwfDMFhdXRUMw3t6emAwGITzJpmocbx7IwGGYaBQKIT3lhovU6BUKuH3+3HlyhXU19ejpKREtg+/3CIp2nHW19dhs9mEiSBS2USkq4aPZVkMDg5iYmICBw8eREFBQcLryyW+Y4nw8YbQSqUSLS0tMb8vqY7wkSYeSNuPHCgUig3pX/5Gzkfpt5vjSpqAIVnwkZzSjUdUqVQq4ZwArjoWOJ1OOJ1O9Pf3w+/3h0WNk/WMFFuekAifcuavbdR4eY/j9/vR09MDlmXR1ta2qYWHVKQ6wjczM4Pu7m6UlZWhtrZW0qexdAg+v98Pu90Ov9+PlpaWpDyVErV9iYXtRNnS0hLsdjsKCwtRX18f1/tCU7p7D3Ehf3V1NYLBoBD94+e4irt/SRQwJAs+klO6yexNo9EgPz8f+fn5QtSYLxuYmJgAACH6x48MjOf92QkRPrEg9Xg81Idvr8JxHF577TXo9Xqsra2l5ERIpeAbGRnB6uoqDh8+LIu7eKoFH9/UYLVacfTo0aStCdLRpStuCGpoaEBJSUlCa6cqypXKY1FiJyMjI+xGLu7+HRkZAcuyGBsbQ35+vux1XLFC8nlEokDmkUpUiaPGxcXFwshAh8OB+fl5DAwMQKvVCuIvOzt727KmnST4gsEgQqEQFXx7FYVCgRMnToBlWczPz4NhGNn9jVIh+DweD3w+HwCEzY6VmlQ0bfAG0vzIt1iaGmJFzhq+aCndUCiEzs5OrK6uJtUQJHeEL/K1JelGTeJNOd17Es9xLS0tBcuyOH/+PDIyMsLquMTdv+m4SfPnVrpfr2iQHOGTS1SJRwZWVFSAYRjBM3J8fBzd3d0wGo1h498i07ekp3TFr936+joA0Bq+vYxGoxEsWVIh+OQWSXNzc+jq6kJGRgaqqqpkdWhPRdMGwzCw2+1wOp2SGF9Hri/naDXx2m63G+3t7dBqtUl7OqbSh4/UmzNlc/iapZKSEphMJgQCASH619PTg1AoFNb8kSobD9IbI0jeWyrEqEqlQk5OjmBr5ff7hfQvXzYQ2TW+kyJ8Ho8HABV8exr+iVOhUKQk1Rrp+ScVLMuiv78f09PTOHDggFCfISdyp3T9fj/8fj8CgUBSfoGbkaou3YWFBXR0dKC0tFSSOkq59h1NSNKU7s6FFzAajQYFBQUoKCgIG+O1vLws2HiIR7/Jlf4lWfCRvLd0iVGtVht23vBlA06nUzAN12q1UCgU8Pl8aZsZvRWRgk+n0xEdkZQLKvhE8GPCdqrg83q9sNls4DgOra2tyMzMxPT0dMpm9srB7Owsurq6hLS7HBc8uX34+G7isbGxpLqJI0mV8fJW30sXpN2USXptxGy2r8gxXmIbD3EaT9z9K1UEh3RRRWqkioS9RSsbWFtbw8jICNxuNy5dugSdThdWNiCHrVm8iAWf2+2Ouyllt0AFXwSpFHxSiqSFhQV0dnaioKAA9fX1wsktd/SNP4bUr5k4Url//34MDAzI9gGV8zViGAahUAizs7M4ffq0pN3fcgnVaJHDvXhx3C3E8t5Fs/Hg07/d3d1gGCas+zeZ9C/Jgo/UvXEcR2R9IW8abjKZkJWVherqaqH+b3h4GF6vV3hwsFqtkj44xINYLLvd7j1pyQJQwScgnqcrR6o1EqmEpdiLrqmpCUVFRRuOkwrBJ+Ux+DmyDMOgtbUVANDX1yfZ+pHIFSlzuVzo6OgAx3FoaWmR/ElXzho+hmHQ1dUFAEItD2lRLNL2QyKJvkaxpn9zcnJgtVrjOrdJFVUAuU0b/PWVxL0BbwgqtVqNffv2CYb+Pp9PqP+bmZkJe3CwWq3IyspKybkgjvB5vd6UHZc0qOCLQDxeTU6kiIr5fD7Y7XYEg8FNvehSMbNXpVJJ5mO3vLwMu92O3NxcNDY2QqVSwefzCU+4cqV0pRbFvO9hSUkJJiYmZElryCX4AoEA5ubmkJ2dDb1ej8nJSYRCIXR3dyM3N1fyFB9FXpL9zGyV/h0dHUVXVxdMJpMQ/fN6vfjpT3+K++67D6WlpRvWI1nwkdq0wX/OSf3MsSwbteZTp9OhsLAQhYWFUR8c1Gp1zFNjkiGyho9G+CgAUpfSTVZYLi0toaOjI0wYRSNVM3uTFUxiX7rIKSfiSQ+kCz5xKvrIkSPIysqSrXFGjqaN2dlZzMzMwGg04uDBg8KT+7lz55Cfnw+Px4Ouri5hUHtOTo4gDFMJiTdlEvckx2dGpVLB7/fjlddew8uvtmNiegrjY+PQZGYi02iG0WJBYUUVHvpfX8PizDSci/PIyy9ARUUlsnQaNNbtR37uPiJq0iKhEb7E4CdZbEXkg4N4asz09DR6e3uRlZUVNv5NKrcMlmWFtfbqWDWACr4NpGvGbaxwHIehoSGMjY3FZNirVCplT1EnK5iCwSA6Ozvhcrmi+tLxFxI5faikiJT5/X7YbDYh4pqVlQWv1ytbdFLKCB/HcRgYGMDk5CTy8/OhUqnC9qtUKpGdnY3KykphUPvy8rJg1KrX64UUn9RzOimJk8z5MT4+jhfPnsOrdjvc/hAYAEGGwcTICLweN6x5+TBbs2Etr8HhW9+MTEN4fWpV40EAQCgYwHB3B+bGxzC9sIC+sXHkl1TgqedeBFgWKo6DWgVkZmSgsW4/brz+Ohw4cCCtHoGkwV9fSdwbkNi1WTw1Brh6H+DHvw0ODsLn84VFjo1GY8LnBMMwQgTS4/FQwbfXEdfwkdq04ff70dHRAZ/PF3MDAP80LifJCD6Xy4X29nZkZmaipaUlalpALPjkQIoI38rKCmw2GywWC44dOyY8TfJ7J1nwBYNB2O12eL1enD59GnNzc4JXlRjxSCx+UHtFRQVCoZBQp9Pf349AIACz2SxE/+Sql6E1fLGx2WvPsiyGh4dx5uxZ2Lp64AsxYKAAq1ACKhWyTBao1GpMLq2ACQah0emg1Wfi1G1vQl5xacw3X3WGBnVHjqPuyHEAwJrTgX7bq3CtrsDv9aG0phbVB45AAWB6dQXf/dmv4HL8G8CEoFQAGQpAo1KiuqIcN153LY4dOyabZQypKV1+XyTuDbi6v2Qf8jIyMpCXlydMg/J6vYL9y9TUlJBV4Ov/4mkciuzSpSldCoDUCr54juNwOGC322G1WtHc3BxzqDtVTRuJvGbT09Po6elBZWUlqqurN/3wyi34kk2NTk5Ooq+vD7W1tSgvLw/7O8TpaKmRQvDxgjsrKwunT59GRkbGpsbLmx1LrVYjNzcXubm5wpzO5eVlYbxXMgX+OwVSxSfDMOjp6cGll19Gd98A/AyLEJTgFEooVCoYsnOQV1yKmutvB8Mw6Hv1JcyMjSBDo4HX7YElNxfHr78FegnHUJms2Thx420AAI5lMT02gtfOPAev2wVAgYOn21BZ3xT2O1fHf63hiaefx6M/+hlYJggVB6hVCmgUCpQU5uO6a9pw+tSphEdmkVwnR2L6W0wsKd140ev1KC4uFsa/ra+vw+FwYHFxEUNDQ8J1hReBWz0E0Bq+q1DBFwFpXbocx2FkZAQjIyOoq6tDaWlpXE95qWraiEcwMQyDvr4+zM3Nobm5Wejo2gz+yTaV489igWVZ9PT0YGFhAUePHhW6WSPX5n9W6jRnsoJvfn4eHR0dqKioQE1NTVjNZKLriud0lpaWCgX+y8vLGB0dFfzd+OifyWRKKGpBaqQjHYRCIdhsNrx44QIGhkYR5Lirok6pBBRKWPLykVtUgrqb7oRS+cY5uDgzhc7LFzEx0IsMrQ76zEwUV9Vi/5FjKRMXCqUSJVU1KKmqAQD4vV4MddjQd+UV+LwemHNycehUG9QaDbJMZmSZzCitrduwjs/jxq/Ov4rv/+d/gwkGoOQ4qBVAhkqBfVYLrjl9Cte0tW15rSE5bUq64JN7f+KsQnl5eVjj0MTERNjYQKvVuqGsJDLCR1O6e5x0pXS3SvUFAgF0dHTA7XYnPHOVNFsWj8cDm80GhUIR13xfOb3yElnb5/Ohvb0dANDS0rLp30FihE9cBxrNCFrKSRuR/m4+n0/wd5ucnAQA4d9zcnLi6tIjNaomB4FAAK+99hpevHARI+MTCEEB5nVRp1CpBVHXeGtT1OtJIBBA5+ULmBkbgUajhUargzU3D8euvwn6LHKGyGv1ejSdakETWgAAjoV5dL1yEesrKwgG/Kg6cBjltfUbfk+XmYWiiioUVVRt+LeA34fnu4bw1HPnEPB7oWRZqBSARqWAKTMTp44dw3XXXYPCwkIAZEb4SG0m4ZHjgXYrovlG8mUlfX19QlkJ/zPRbFn2IlTwRaBWq+H1emU/Dv/h3Wxur9PphN1uh9lsRmtra8JpsFRE+GIVTIuLi+jo6EBBQQEaGhriuoDJKfjijR46HA7YbDbk5eWhoaFhywsdaYIvFAqho6MDLpdryzrQyAcRqeoFdTodioqKUFRUBJZl4XK5sLy8jJmZGfT19SErK0uI/lksFqJvclLj8/lw+fJlnL14CePTs3D7fHC7PfB6vfAH/NBnGqB9vW6Jv4EplEoolUqsr65iZngICpUKSqUSSpUSzqVFLExOgGUY5BQUwbE4j/2Hjl59LwGsrTjR/fJlcBwL4Z3lOIDjrn79erNRMOAHyzBQZ2gAhQIAd/X/OA4c/5uv/yyu/uvr6wAcXv/+Gwd4vYmJ/8nX//fra3EcB6VCCaVKBaVK+frfokam0QjAhAHbq3jluWfAsizM2TloPHH6qrl5MIiQ3w+GFV3rhMNywtdK9dXrKMMBXnBYWljGq4//AP/y+PfxyP/zOWFEGGnIkTKVknRHIDUaDfLz85Gfny+UlfD1fxMTExgaGsLXv/513HTTTZiZmcHhw4fjWv973/sevvWtb2Fubg6HDx/GP/zDP+DkyZNRf/aGG27Aiy++uOH7b3rTm/D0008DAD7wgQ/gRz/6Udi/33777XjmmWfi2le8UMEXQSojfMBGwcdxHMbHxzE4OBi1JiyR46S7ho/jOAwPD2N0dBSNjY0oLi5O6BjpTumK35v6+vqoHmOR8O9dqmbeboXb7caVK1eg0+k2bZDZbF257HDMZjPMZjOqqqoQDAaF6F9PTw9CodAG6xcSb8Y8ieztV7/6NR597F+RXVQCpUqFDI0WGRoN1HoDLDn5KMwyINNohD7LCK1eB41OD61OD3WUB0CWZWE7dwbTo0PIMlnQeOwU9FkG1B5sRnXTISzOTOGl536P4qr9qDtyVIK/WHquikEWLMOCZVmwLAOOZcEyzOtfs2BCQdgvvIiA34fZsVH4XKswmIzQG80ortr/ujiMTigYgGN6EsYMFQpyrGg5eRynTpwQmtsuXLhApLAiPcJHkiAVl5WUlJSAZVksLy+jsbERv/71r9HR0YGLFy9iaWkJt9xyC2666aao5Tg8P//5z/Hwww/jsccew6lTp/Doo4/i9ttvR39/v9BgIuZXv/oVAoGA8PXy8jIOHz6Md77znWE/d8cdd+CHP/yh8LVcHoRiqOCLIJW2LADCjsXbk6ytreHEiROwWCySHCedNXx8Wtrj8SQ1WizdET7eeNjhcMT13vD1h+mO8C0uLsJut6OkpAT79+/f8uK8mXCRO4WakZER9pTOm7QuLi5icHAQWq1WEH87nX/7/uP4z98/i8qDzXj/F7+asJB1u9Zw4en/gt/nQZbZjPrmkzhx89UGjKf+8e/Rdtc9KCgtBwDkFpXgzfd/BN2vXMLTP3kcbW96Cyw5uVL+WUlz9fOiCqs1FDM5PIiJ/h7UHzmBTKMRCtF57Fl3oe/VywATgi4zE1mWbORXVMGzvg6/YxF5VjNqigpw11/+OfLz8zesTWv4EifVKd14UCqVyMnJwZe+9CUYjUbcc889qK2tRWZmJr7+9a/j3e9+N44ePYoPfvCD+MQnPrHh97/97W/jIx/5CD74wQ8CAB577DE8/fTT+MEPfoAvfvGLG34+8vr05JNPIjMzc4Pg02q1ks1VjxUq+F4n1aPVFApFmFBaXV2FzWaDwWBAa2urZLYD6azhW11dRXt7O8xmc9KjxeSO8AGbW6d4PB60t7dDrVajtbU17icxuRpOYhF8YkPraKP3tlo3Wrdxqog23YGv0RkaGoLX60UwGITP50NOTg4MBgORN+pIvvl/voUXLr+MhpMtePsnP5vQnieH+mG/eB5a3dU6vGvvfhuMFqvw764VJ37/0x/ijvd+AFmmjXW/TSdaUN98Apf/+DusLC7i2rfcK5nBrVysr67g0rP/A9/aGnRZenRePPN6KpgFlIo3sravp4a9Pi9mJiZw+bnf47prrsXf/b9/u23dFslRNFLtYnh2kiANBAI4fvw4PvzhDwMA5ubm8Nxzz0W9P/G1s4888ojwPaVSiVtuuQWXLl2K6diPP/443v3ud284/86cOYO8vDxYrVbcdNNN+MY3vrFlpFEKyP6UpxhehKUiwge8IS4nJibQ39+P6upqVFZWSvrBTkcNH8dxmJycRH9/P2pqalBRUZH035QKwRftKZWPjBUXF6Ouri6hi5qcEb6tXpNQKISuri6srKzE3fQjVdOGVKhUqrAZna+88gqysrKwtraG8fHxsCLu7Swa5GCr14ZlWXzhr/8XbL2DONByLd75qc/F9XkIhUJoP/cnzE9MIMtkRlFlFe66/0PIyNj4N04MDeDKi8/hzfd/JGral0elVqPtzrdg1bGMs//1S1jzCtB8zQ0x7ylVsCyDzssX4PO4caj1urg+f92XzqLqYDOUZhM++pnP4a6brsdtt9yy6QQHUk2XAbIFFcdxRKV0I+E4LuzaHmm8XFBQgPe9731Rf3dpaQkMw2yICOfn58c03/3ll19GV1cXHn/88bDv33HHHbj33ntRWVmJ4eFh/NVf/RXuvPNOXLp0SdZIKRV8EaRS8CmVSgwMDMDtduPYsWOypKpSHeFjGAbd3d1YWlqS9G+S25YFCBd8YjucWCNjW62f6pSuOCrZ0tISV1Rys3VJ6opVqVSwWq0oLCwMG9HEWzREWr+k42YUCATw0Gcexsj0HA5fewPe9RdvjVlQuFaduPTs78AyDLJMZtQdOYbTt9615e/bzp/B8vwc7nzvB2M+jjk7B2++/yMYH+jFM//xBA61Xhe10zUdTA4PYLyvB2X76+PuJB7vtkNvssCSezVlnVtdjz++0oFzl17Cm2+7BYWFhWETHPjrCxV88UOyfyHwRtkUv79U+vA9/vjjOHjw4IYGj3e/+93C/z548CAOHTqE6upqnDlzBjfffLNs+6GCL4JkZ9zGisvlgt/vR0ZGRkJpwlhJVYSPYRisr6/DbrcLqU+dTifpMeSs4QPeuHCJR72dOnUKJpMp6fXlEEubCcnl5WXYbDYUFhaivr4+7gtxqpo2kiFy7Bs/oqm6uhp+v19o/ujs7ATHcWED2uWe+7u2toaPfeovsLi6jqM33IJ3v+P+mH5vtK8H3S9dgC4zC9a8fFz35rfBYLbE9LtnfvMUDGYLrr3rnoT2XL6/AaU1dbjy4vPoeukirn/r26HVpXY+Ms/62io6Lp6FOXsf6pqPx/3786NXU/6ldY1h3zfn5YNlGPzq2edx7fFmHGs+gvHxceH8iWdyQ6ohWfDx12VSa/j4+59KpRI6eGM15963bx9UKhXm5+fDvj8/P79t/Z3b7caTTz6Jr3/969sep6qqCvv27cPQ0BAVfKlE7ggfx3HCoGiNRoOqqipZu3P4k1zOdAX/Qb98+XJMTQGJkKqU7vr6Oq5cubLlqLd4SVUNXyJdxFuty/8X7VgksNl+tFotCgsLUVhY+PqEBhccDgfm5uaEub9i6xepblQOhxNvfed9cIdYHL/xNtx8cGvrh1AohNdefA6L01MwmMworqrF3R/4GFRx1tP9zxP/itrDx1DZ0LT9D2+BUqnE8RtvxYHTbTj/9G8AKNB6x5uTWjMexOnb6gOHE7qGOOdmsDA9iarDx6L+u1KlgrG4HBd6h9E9MIhPf+LjMGRlYXl5GYuLiwgGg3jppZeEhwNS5kKTXF8YGUEjDYZhoFAohAfkeGbpajQaHDt2DM8//zzuueceAFfvE88//zweeuihLX/3qaeegt/v3zRdLGZqagrLy8uCF6RcUMEnQu4avlAohJ6eHiwtLeHo0aMYGhpKSboV2NzvL1lYlsXIyAgAoKGhISHLlVhIRYRvfn4eAwMDKC8vR21trWQCORUpXX6E1tLSEo4fPy4MJE903WiQJvhiQaFQwGQywWQyCXN/+ehfX18fgsEgLBaLYPycSJRncHAQn/zMZ8FkaHH6ljtR2Xhg059dczpw6Q9PAyyHLJMF9UePo/X2uxM610KBAH71r/+Atje9FblFJXH//mbo9Jm45R3vxfzUBJ775X+goq4JNduI12RJJn3Ls77ixEi3HfUn27b92SyLFQGOxZf/73dw7fEjeODP3gur1SqMeuTnQvv9fuH8yM7OTltz0E6I8O2U6Gg8gg8AHn74YTzwwAM4fvw4Tp48iUcffRRut1vo2r3//vtRXFyMb37zm2G/9/jjj+Oee+7Z0Iixvr6Or33ta3j729+OgoICDA8P4/Of/zxqampw++23J/GXbg8VfBHEMgEjEdbX12Gz2YQUrk6nw+joaEosUwB5fOD8fj/sdjv8fj8AIDdXPosHOQUfL2QGBgZw6NChqJYNySC3LUvk1I9kU+lSTtogDbVaLQxo55/2HQ4HlpeX4577+9LLL+MLX/oKMgwmnLrrXlTUN0b9ueHuTvS++hJ0mVnIzs/HDW99J7KMyZUJrCwv4Xc/eRxvet+DyDQkZnW0HfklZXjLBz6Gnlcu4dmf/Qgtd9wNk1XaOuNk07c8fq8HvS+dR/3pa2P+HYVCCWNhCS71j6L9C3+FP3vH26BSqcLOD97A1+FwYGxsDEqlMqw5KBXeaQDZXbp87TOp+xNP2Yg3wgcA9913HxYXF/HlL38Zc3NzOHLkCJ555hnhPjExMbFBjPf39+P8+fP4wx/+sGE9lUqFjo4O/OhHP8LKygqKiopw22234W/+5m9kP5+o4ItgM0PkZJiZmUF3dzfKy8tRU1MjnBypaqgAILmwdDqdsNlsyM7ORnNzM55//nlZxatcUbJAIAC73Q4Asog9QD6xqlAoEAqFcPHiReTm5qKxsVGy9NNOquFLZo2srCxkZWUJc39XVlbgcDiEub8mk0kQgHxx/zPP/gF/83+/hSxrDq5/+3s3zHYNBQJ49cxzWJqbgVarQ2XTIdz9wY9CpZLmejLS04muly7ibR/+ZNzp30RoPNGC/UeO4+Iz/w3XihPX3p28jYsU6VseJhRCx7k/Yf/JtoTW0RuMgMGIf/rpL5Bn0OH48eNQq9VRDXzX1tbgcDiEspysrKyUpH9J9rkjuUMXCBd8Ho8HHMfFXMPH89BDD22awj1z5syG79XV1W16v9Lr9Xj22WfjOr5UUMEngk/pAlfTr8le1BiGQW9vL+bn53HkyJENEbBUdATztQtSHUdcJ7Z//36UlZUJx5BTvMqxvtgnUK1Wy1bML1d0bGlpCR6PBw0NDcL7IAU7oUsXkH4/KpUKOTk5QgqGn/u7vLyMyclJ/OnFs3jmuT/Bkl+IW9/zAEqq9wu/u7K0iJeee+aqf6DZjLojJ3BNgg0UW/Hqmeew7nTg9nffn1IRrs7IwHV334tVxxLO/8+vYM0rxOHW2KNpYqRI3/JwHIfO8y+g6vCxpK/XlqJSuHxefOrzj+CD73kXTp44EfbvSqUSFosFFotFmAzjdDqxvLwslAeYzWahPjQrK0uy94j0CN9OEnwAUtalSxpU8EWgfH02ZbICye12w2azQalUorW1NaqYSOUYNynEEu/r5nQ6N9SJ7TTBNz09jZ6eHsH78MyZM8TM6t0OlmXR29uL2dlZ6HQ6lJeXS7Y2ED16tltSuvGg0+lQUFCAp379Gzz5y18hu7AYb/rARwXbksEOG/ptryIzy4jsggLc+LZ3yZZeBYDnfvkzZOflo/XOt8h2jO0wZ+/Dm973IYz0duLZn/0Yh6+5XpjksR1SpW/FDLxyEbnlldBlxp6i2wqtTg/oSvAvv/g1/vCnM/jMQ5/YNP2XkZERtTyAjxBL6Q3JsmxSxvVyQnL0EQgXpG63GwqFQvZOfVKhgi8KyQqxubk5dHV1bduxmgrLFKmOs76+jvb2dmi12qg2MjtF8LEsi76+PszOzqK5uVkw8pXT509KseT3+2Gz2RAKhdDY2IihoSFJ1hWz02xZ5CAUCuFv/s+38Mwfn0N+WQXu+sBHkVNQhJeffxa28y/CYDKjtLYOb/nAx6CU+WbHsiz+64eP4cDJNpRFpI/TRVXDQVTUNeHVF/6IjkvncMNb3gHNJrWjLMvAdv4sJvq6UFpdg31F0jR2jXfboc7MgmXfxnmmyWLcl4+5UBCf+euv4O1vuh2333brlj8fWR4g9oacnJxET08PDAaDIP7MZnNcIonkKBrJewPCI3xer1fSyOtOgwq+KCQq+FiWRX9/P6anp3Hw4MFt68FUKlXYkGW5SDbCNzs7i66uri27V3eC4PP5fLDZbGBZFi0tLWFhfblqBKVcm09BW61WHDhwAKurq7I2g0S+z3shwufxePClb/wtzl28hKLKatxwz7sw3NOJjkvnYbRY0Xj8NHIlEiyxEPD58Jvv/xOuf8vbYc2Tvr40GZRKJU7efDu8bjfOPf1rqDIy0HLrm8J+ZnJ4EBODvaisP4DKxiYszUyj/cwfkJ2Xj/KGQwmL5fmxYXg9bpTWb94RnSxqdQbUhaV46k/n8OLFS/jspz4Z8+irSG/IQCAgjAbs7e0N6w6PJf1LsqjaSTV8brebaL9FuaGCT0Qy83Q9Hg/sdjs4jkNra2tMNQKpSukmGuETC9jDhw8jL2/zJ2m5o5VKpRLBYDDh3+ebTHJyctDU1LTh6Vpu25dk1+Ybf8Sj6uRMs+6ELl0p9+NwOPC/vvFNvNbeDpVGA8u+XGQajPC413HzO94DvUQpw7j2tDCHP/3yZ7jjzz4AnZ7cmiN9VhZue9f7MDsxhj8+9VNUNx1BXkkJOi+fhzU3D43HTws/u6+oGPuKiuFcnEfnuT/BtG8fyuoPxtV84pyfwfzUBKo38dqTGoM1B+ssi8//zTdxS+spvPud74hbMGg0GuTn5yM/P39D+ndkZARqtXrL9C/JPnwki1FgYw3fXq3fA6jgi0q8QmxhYQGdnZ0oLCxEXV1dzKH6VHTpJnocPhrGMExMAlbuvyVR0cRxHCYmJjAwMBDWZBJtfbkETTJrsyyLgYEBTE1NbWj8kdvuJfJ7u5GxsTF8/e++g8sXziOnoAhVTYdQc/AwKusPyJ6q3YqhLhv6rryKux74KNH1UQDgca1hoKMdM2PDUKszcPkP/4P8sgocueb6TYWANTcfx267C6uOZXRdeAFGSzbKGg9CHWU+sJj1FSdGu+2oO7G9156UKJVKGAtL8UJHH16+8tf4y49/FBUVFQmtFUv612g0hqV/SRZVO62Gj0b4KGHEKvhYlsXg4CAmJiZw4MCBuF2ySY3wLS8vw263x2X1QWJKl5/ru7y8vK0ZsdyTPBIRZrxljN/vR0tLy4bicTkFn/j/85AU4Uv2gm3v6MD//vtHMTA4CHAsbnzbu+B2rWF9dRVLs7Mor2tCum6vL/3x9/B7vbjtXds79KcKlmUxNTyAkZ5OuJxOZGi1yNBooNHqkGUyo6iiCgdPXwPHwhz621/d0nxajDk7B8duvQvra6vovvgiDCYLypoOIUOz0Y8sEa89qck0msByRvzNd/8JJ5rq8NEHP5i0EIuW/uWjf93d3QiFQlAqlVCpVLBYLMQJlp2U0qURPooA/yGKZZ4uHwELhUJoaWmJ29cHIK9Ll+M4jI6OYnh4GPX19SgpKYn5wkKa4PN6vWhvb4dSqYzJjJi0lK7L5cKVK1dgNBpx+vTpqJYTqY7wkST4gMQE6Itnz+J//913EOA4sAyL0qoa7D9yDCduvl1Yc3Z8FC/98XdYczqgzlCj9fa3ICvJecqx8odf/DvyikvRfO2NKTleJGsrDgx1tGN2fAwKhQIZGg0ytFpodHrkFZfgxE23wWC2Rr0uuFac6Lx8PqEOXIPJjGO33gWfex3dF88i02BEWdMhYZ4vEwqh8/wLCXvtSYlCoYCxoBj2yXn8xecfwUfufx8OHzoo2foajQYFBQUoKCgAx3Fwu93o6OiA2+3GK6+8IpiD8/+lu3uX5OgjcFXw8a+R2+2Oy3R5t0EFXxS2E2JLS0uw2+3Iz89HQ0NDwuFskrp0g8EgOjs74XK5cPLkSZjNZsmPkQzxCDL+/SksLER9fX1MFyM5u3TjjfDNzc2hs7MTlZWVqK6u3lR0p2JG72bRvp3GU7/6Nf7+//sH5BSVor7lWkwODuDkTbej8+ULgtgDrv6dRRVVgvWKa8UJ2/kzWJqegt/vw/EbbkVJda3k+2NZFr99/J9xuO06lFRJv76YUCiEiYE+jPV1we1aez1ap4VGq4PBbEFJ9X4cueZGqOMQEgG/Dxef+W80HDuZ1N50WQYcu/VN8Ps86L5wFjq9HqUNh9D/ykVUHjoqy3jIRNFmZgGZWfjuj36K+uJ8/OUnPyH5pASFQgGDwYCMjAyUl5cjJydHSP+Oj4+ju7t7Q/o31eKL9JQuwzDCAz+N8FE2sJng4zgOQ0NDGBsbQ2NjY9JzY0mJ8K2trcFmsyErKwstLS0J+UXJXcMXi+ATRygbGhpQUhL7fFE5u3RjjY5xHIfBwUGMj4/HNPVDThFGuvFyrH/7//e9f8KT//kblNY14L2f/Wv0vvYyvG437vvU5/Dk//d/8faP/+WWv2+0WHHtm98GAAj6/eh66QKeffLHcK+uoOrAIRxquS7pG6zP48Fvf/DPuOne+2DO3pfUWmJWlpcw2NGO+alxMMEQMo1GaDRaaPSZyC8txenb3wyDKb4Hu2iwDIMzv/0l9jcfgyLJ14JlWawtL2F1aR4GswUBnwfP/PRxZBlM0Gg0V68DCgV0WQboDEZkmSxxCVM5MOUVYtztx1988a/x3nvfiuuvlT7lzEfRxN5+wFWbJr77t7u7GwzDwGq1Cj+j1+tlf1gjPaUrFqS8LctehQq+KETr0hXPjT19+jSMxuQNVkmo4eMNiLeLJsVyjHQKvlAohM7OTqyuriYUoUy3D18wGBTSNrGWCMgZ4Yv2PZIE31awLItHvvRlvNLRhdojx/HRv/kWggE/fv/vP0TrnXejor4Jv/zn7+Cme+9DRhwPNxlaLZqvuwnN1910deJMfy/O/c+vsb66gkxDFlpufwt0cUYPFmamcPa//hNvet+DQvoyHkKBAMb6ezDW3wO/14sMrQYZGVpkaLUwWbNRWd+E4zfcItsINo7jcPZ/fo3Khiao1bELr1AggJWlBawtziMU8IMJBhEMBOD3+aAzmVFYUY3Cihr4vV6419agMxiQodFiX2kFWJaFy+nA/OQEAu5uqFRKZKg1UGsyoFSpoVAqoMrQQmc0I8tkgkYnv+jJ0GiRUVCKn/z3s/jTi+fw8Kc+Gfc1aCs2S5tqtdoN6V+Hw4HFxUUMDQ1Bo9EI4m+72dDJ7I30CJ+4aYMKPgqAzW1ZlpeX0dHRgezsbBw9Kl1aIZ1duuKxb2ID4kRJheDbTHC43e4wU+hEIpRy+/Bt9drwptZ6vR4tLS0xX5T3epdu5B79fj8+9tBfYNnrx4HT1+LD974fSqUSF57+LZyLC3jnJx9GhkaDS394GlWNB5FXUpbwsRUKBSrqG1FR3wgAcCzMw37xRawsLSAYDOLULXcit3DrDEDflZcx2tuNN9//kW0jJI6FOQx2tGNxZgoqdQY0Wi3UGg10+kzkl1bgmrvukXXKx2a8/KdnkVtUsumkC5/bjZXFObiWl8AyITDBADxuNxiWgyU3H8VVtZsaNgPAWHc7qg4dhVqjwdRQPxbGhpFXUQ1zzj6Ycza/ZnnW1+GYn8Hc6CBYhoFWq4U6Q31VECqUUKjU0BtN0BvNyDQaoFBIE6Ey5OTCyTD47Je/jrtuvh5ve4s0U1FiqZPj078GgwFlZWUbZkN3dXUJs6Gzs7NhMpkkicyxLJvUFBG5oU0bb0AFXxTUajX8fj84jsPIyAhGRkbibmKIhXRF+DweD2w2GxQKxaZj3xI5RjoifAsLC+jo6EBpaSlqa2sTvoDJ3bSxmTAT73///v1xnV/83xrNJDkZdsosXZ7Z2Vm8/8MfRWZOLq5/6ztRXFUD4PVU6eP/hOM33o7r73knAGBxZgqOuVnc/p77Jd1Ddl4+rn/rOwAAfq8XHZfOwX7hRXhca6g9dAwNx8Lnsp5/+rcIhQK4+e3vEb4X8Psx0tOJiYE+hAIBqDUZV2vrdDqYsnNQc7AZJ2+5k5hoStdLF5Ch0cJotWLN6cDq4jy8ayvgQiGEggF4fT4olCpkF5agdH8jlHE+KLtXV+D3+aB+XUyU1NRhZmQIM4N9KKqt3/J3Mw0GZBr2b/rvoUAAywtzWJyZQsjvg0ajuRoZVGVAo9GAUyqgzTRCZzQhy2SKK3qpVKlgKCrD7y5fwcWXX8VnPvnnKIrTwSGSRHz4ImdD+/1+ofu3s7MTLMuGpX8TFUKkp3QjjZeTDW7sZKjgi4JKpUIwGMRrr70Gj8eDU6dOwSRDlx4v+KS+YUc7Dh+xXFxcREdHBwoKCtDQ0CDZBzXVTRviesqDBw+ioKAgqfXlTulGri1+mEjE0odfl19LbsFHWkqX/3tfe+01fOEb/y/e+4WvIVNUZnHl7AuYGRnC2z/+aSHNyrIs/vDkT/DOT3xa1r1p9XqcuOm2q8dkGAx12XHmt09hfXUV5pwczE9MIuD3QpeVhWd+9iOoM67WpukyM1FcVYPr3/p26LPi7/pPJYMdNgy89hJ0Oi3GOtuhycxCflkl8psqJDvGWFc7Kg82h32vqKoG85PjmOztREn9gYTPe7VGg/ySMuRvEuVlWRarjiXMj4/C73ZBrVZBk6GFKkMNlUoNKBRQaXXQGa/WEUZLx2eZrQhwLL70f/4ebc2H8cH735fwfqXohNVqtSgsLERhYSE4jsP6+rqQ/h0cHIRWq0VOTg6ys7NhsVhizjSQ3qUrTjl7PB6a0qVchf8w+v1+LC8vIzc3N64UW7zwJ6HcNRBKpRKhUAiDg4OSNZxEIne0Uiz4gsEg7HY7PB6PZPWUqWzaENcbJvMwIRZ8UrMTUrr/+dv/wku9g3jwf31DuOGEAgH89gePofFEC+75yCfDf/6fH8Udf/aBlBoqK1Uq7D98FDUHj+C5p36GrpcuwGzNQdn+epy8+Y60mjsnytzkOKaG+nH4uptlO4ZjbgZKrS6qkMgvLceyOgPjXTaUHzgiy7mpVCph3ZcH6xZzet0uFxxzM5gdHgLHMdBqtFBnZEClfiNtrDOakGm04KXBcdi+8Ff4xIc+gPq6+Ochsywr+UOd0WiE0WhEeXl5WPp3ZGQEHo8nLP1rNBo3FXU7oYaPpnSvQgWfCL7Lc2xsDDqdDkeOyHMx4eE/QOITUi4cDgfW1tYkE0iRJDv6LJb1WZYV/OkMBoOkYlxu42VeDHs8Hly5cgUajSbhekMeuQTfTmja+IfH/g2awjLc85GHhO91v3oZg7Z23HX/R2CIKJh/8be/xIHTbTBnxzYLVSr8Pi+e/Y8fQaVW49j1t8C7voY33/9htJ97AX/4+U9w27vvJzo6Esma04GOCy+i+sBh2Y7BcRym+ntQffTEpj+TU1gEVYYaI/bXUHnoaFpewyyjEVnGzcVbIBCAY24Wi9MTCPn80Gg1+MCHP4pv/59vorW1NebjcBwnexQtMv3r8/mE9O/U1BQ4jtvQ/cuzE1K6/P5ohI8iwDAMlpaWUFtbi7m5OdmjGrzIkzMytrq6irGxqyaqckYrU1HDFwwGcfny5aQ7iqORipQu7w9YVFSEurq6pC+Scgo+kmv43vvgh1F3zc2CwS/LsvivHzyGioYmvOPPN9qsjPf3IhgMoPZQ84Z/k4vV5SU894ufwpSdg1ve8V4YLVY89c+P4ua3vxsA0HztjSjf34D/+dG/4vStdyGvpDRle0sUv8+LC7//LWoPyvs6zo0OwZC7tSURAFj25UGpUmO4/RVUHzlOXLRUo9GgoKwcQDmAq+dpg38dLS0tca3Df+5SKap0Oh2KiopQVFQEjuPgcrngcDgwPz+PgYEB6HQ6QfztBMFHbVmuQgWfCLVajZMnT2JxcRFTU1OyH0+hUMhW+8ZxHCYnJ9Hf34/c3Fz4fD5ZHdnlrOFjWRbj4+NgGAbHjh0LmycrFXLuX6FQYG1tDbOzs3H7A263LiCf4AuFQlhfX4fRaCQipevxePCOBx7EnQ98DLnFV1/D4e4O2M6dwe3v/QAsUbo2A76rhsDRhKAcTA724/IffofCsgrc8+FPQKO92oE6Mz6CfYVFMJgtws9m5xfgnX/+aZz57S8x2NWOtjuk6eiUA5Zh8MKvf4HqxkOyngssw2B+fAS1x0/H9PMmazbUTYcweOVl1DSfkM1+Rgr8S/P4xte+FPfrxz+IpktUKRQKmEwmmEwmVFRUIBQKCenf4eFheDwejI6Owu12C92/JFwvgKuvHcdxtIbvdcj9dKSRWEarSYUc1iz8DNmlpSUcO3YMgUAAo6Ojkh4jErksZvx+P2w2G/x+PxQKhSxiD5AvwscwDBYWFuB2u3Hy5ElYLBbJ1pa7hu+ll16Cx+NBRkYG1Go1dDodgsFgWkY5jYyM4KFHvoR3ffqL0GVmgWVZPP3j7yO/pBzveuizm95gfvnYo3jzAx+R/QbUefk8BtpfQ0VDE971ic9siDad+c1TuFeUfuZRqlS46d77MNrbjd/+4DHc/u774/bykxuO43Dmt0+hrKZOdkE10deF/OrNu2ujkWk0ofrIcQy+dhk1R09CnUGeRYh71Yl3vfnOhDpE0xHh2wq1Wo19+/YJf8uFCxeQnZ0Nt9uNyclJANg0/Ztq+Gu6SqUCx3FU8KV7A6ShUChSZpcCSN/s4Ha7YbPZoFar0draCp1Oh4WFBdn/HjlSuisrK2hvb4fVakVjYyMuXLgg6fpi5Gja4Of5BoNB5OTkSCr2APkE38rKCgAgJycHR48exfr6OoaHh7G2tobz58/DaDQK9T6piP799+9+j5/819N43//zJShVKsyMjeCFX/8cb3rfh5BbtHm09JmfPYHTt90lqz/d2f/5NRyzM2g8dgrv/MRnor4WF599Gofbrt8y5VjZ0ISiiio887Mfoay2HvVb1K+lmpee+z2y8wuhlfnGHfD74ZifRV1ZRdy/q8vMxP6Tbeh/6QKqm48LkVUSYEIhlFuNuOvOOxL6/XRH+LaD4zjk5eXBbDYL6d/l5WXMzc1hYGAAer1eEH8WiyWl4/H4+57YeDmRufckMTY2hsrKyg3fv/7663HmzJktf5cKviikyi5FfCwpmJ+fR2dnJ0pKSrB//37hJE+FwbPUgm9ychJ9fX2ora1FeXk5/H4/APksAKTev8PhgM1mQ15eHjIzM7G6uirZ2jxSCz6O4zAxMYH+/n4AQF1dHYLBIKxWK6xWK4xGIyoqKrC8vIzl5WVMTExAqVQKVg45OTmSR/+++XffxrjLh3s/djUl+4ef/zsyMjLw/s99acvzoPe1l2EwW1BWG39H5HaEQiH88cmfIBQM4NgNt6L0Le/Y8menRwZx/IbtO1q1ej3e+uDH0X7uBTz7sx/h1vven/abfOel81AqVTCKUtFyMd5lQ0US9YEajQYNLdei9/I5VB08Ci0hkVJmdQlf+Ob/Tvj3+Q5dUtKkkYivyeL0b2VlJUKhkDD6bXBwED6fD2azOaz7V86/i2EYoXSKj/ClM+IoBaWlpZidnRW+npubwy233ILrrrtu29+lgi8KfPh3pwg+lmUxODiIiYmJqJ50cnvk8ceQQjCxLIuenh4sLCzg6NGjQtcYf0GRS/BJldIV107W1dWhrKwM4+PjaZ/Tux3i1/3IkSO4cuXKhnU5joNWqxWKuVmWFQa5T0xMoLe3V9Lo34c++SkUHTqOG25uxdLMDP706ydx/VvejuKq2i1/z+NaQ88rl/DWD/15wseOuu76Op79jyegyzKg9Y67kZ23fWPBf//wXwRD5ljhGzqe/tG/4lQaGzqGuzuw5lxGQQIRt3jxrK3B43ahaIupG7GgVqvR1Ho9ei6+iIoDR6BLs5+h27GIP3/fe5NKI+4kn7tI1Go1cnNzhVIcr9crdP9OTExAoVCEpX91Sb7/kUQ6YHg8nh0f4VOpVMI93ufz4Z577kFLSwu++tWvbvu7VPBFgT9BQqGQ7CNjkhVj/IzfQCCw6QzWVEX4khWVPp8P7e3tAICWlpawJzHxVAk5kCKlKxZNx44dEwacp3tO73YEAgG0t7eDYRi0tLQI57943WjHUSqVQvSvurpa8K90OByYnJyEQqEQIn/Z2dkxf5Z8Ph/ecf8Hcct7H0RBeQXO/OaX4FgW9z30uZhqyH71b9/D2z+6sV4uUZZmZ/DCr3+OnPxCvOl9D8acIl6en0WWyRS1mWQ7svML8I7XGzoGOq7gmje9Ne41kmFuYgwTA32yREijMdbdjqrDxyRZS6lUorH1evRePoey+gPQG6U3zY8Fv8+LQ1XlOH3yZFLrSO3BJyXxWsbo9XoUFxejuLhYsNlyOByYnZ1Ff39/WPrXarUmbVcm3lsoFEIgENhVNXwPPvggXC4X/vjHP8b0HlDBFwFfwwfIa5fCk0yEz+l0wmazbTvjNxURvmRF5fLyMux2O/Ly8tDQ0LDhgy6O8MlBsqLM5/PBZrOBZdmoYpXUCB/va2g2m3HgwAGo1WoEAgEAGwXfdkRG/9bW1oTUb09Pj2DkmpOTs2kn3/j4OD72uS/ivr/8PELBIJ76p++g5Y43o6KuKaa/57c/+Gfc+LZ3IkOrjfEV2Jzh7g60n30B+SVleMfH/hLqONPVz/7sx3hbhPlzPPANHcPdnfivHz6G2+5LTUPHmtOBzkvnUNV0SPZjAcDq4jygVEkaxVIqlWhqvR69l8+jqHo/sixWydaOFY1vHZ9+6MtJr0NyhC+Z+kKlUgmz2Qyz2bwh/TswMAC/3y+kf3NycmAwGOIWvpFj1QDs+Agfzze+8Q08++yzePnll2P21qWCLwqpbNxI5Dgcx2F8fByDg4PYv38/ysrKtvwg8GJMzhR1oild8d9SX1+P0tLo6St+33KaIycqnPjmkpycHDQ1NW0Qq3KaFiez9vz8PDo6Ojb4Gm52jsRzHKVSCYvFAovFIkT/HA4HlpeXMTU1JUT/+Iu5RqPB8y+8gH/+j6dw/xe+gpeeewauFQfe8eefQUaMkcHXXvgjSqpqNx2XFStXXnwe4/29qG46jHf++acTupldOfcCGo+fkqSrtbrpIIqrqvHMfzyB8tpG1B+Tr6HD7/Piwu9+m1LPwqGOK6g/GbsRcTw0nL4G/a9cQn5ZJQwpNN32LC/gr//iE5IY6u8EwSfF3xmZ/vV4PEL6d3x8HEqlUrhmZGdnQxvDQ13klA1gdwi+//zP/8TXv/51/P73v0d1dXXMv0cF3yakUvDFI2JCoRC6urrgdDpx/PhxWK3bP7mKo2NyTfRIRPCFQiF0d3fD4XDgxIkTW3ax8oW3cgq+RNaemppCb2+v0Fyy2ZQKkiKT4jm+0Wo+ozWDJCtaxXM8+VQOL/56e3vxp3MXsBAA3nT/R/Crf/kHHL3hFlz75rfFvP7y/Cymx4bxpvc9mND+WJbFmV8/hfVVJw6ebsOJG29LaB1+rUH7laSie5Ho9Jm450OfwJUX/4RnfvYj3CZDQwfDMHjh1z9HdZO8XntiFsZHYI6hFjIZ6k60YPDKy2BZBqYtRqVJhW/dhRtONKO2pkaS9XaC4JNjf5mZmcjMzERJSYmQMXA4HJienkZfXx8yMzPDun+j3dsiBZ9Go0lpl7AcdHV14f7778cXvvAFNDU1YW5uDsDVpiW+jGgzdvZfLgP8hY7ECN/6+jra29uh0+nQ1tYWc01UKmb2xps29ng8aG9vF+xjYnlaI0nwsSyL/v5+zMzMoLm5eUt/LTlTuvGuzTAMOjs7sbKysukc380En1SIUzlVVVX49Bf/ClllNTAHAnjhVz/HPR95KK7UJcuyePpH/4b7PvW5uPcS8Pvw7M9+DKVSiZM33S5Jg8LT//44rnnzPUmvE42j19+E8roG/PcT/4rWO968pS1NPHAch9//5HHotNqUTazgWBYzI4MxmywnQ+3RkxixvQaWZWDJK5TtOBzHwaxk8cD73ifpmqQKPr4LVu4HBHHGoKqqCsFgUEj/9vf3IxAIhHX/8ulfsVh2u93IzMwkth4yVl599VV4PB584xvfwDe+8Q3h+9SWJQlIE3yzs7Po6upCeXk5amtr4zppxTN75TLNjSdSubi4CLvdjuLi4rhGjMkp+OKJYAUCAdhsNqFRZrth3KSkdH0+H65cuQKVSoWWlpZNRbZY8InTvFL/DYFAAPf/+UNovvXNePVPf0TTqZaEOmuf/O7/xZ3vfzCu9Oma04HnnvopDCYLbrznXZLN2HWtOKFUKpFbWCzJetHIKSjEuz7xabzwm19gsMOG1jvenPSaLz33e5Q3NMG3vo7Oc8+jtK4R1vwiCXa7OVMDPcgt3+gnJhdVR45htMsONsQgWyKhHIlvaQ5f/8r/klRUkB7hk3sOfDQyMjKQl5eHvLw8cBwX1v07NjYGlUolZL+8Xi+ANwTfTucDH/gAPvCBDyT0u2SeRQSQKsG3XWSMZVn09vaiu7sbhw8fxv79++O+mCiVSlnTivwxeCubzeA4DkNDQ7DZbGhsbERDQ0NcFzISInxra2u4ePEiNBoNTp8+HdMFRO7XPhYhtrKygosXL8JkMuHEiRMxRVSj2bJIxdTUFN71oY+huPEwbOfP4K4HPoIDp9riXufMr3+BQ63XwRpjqm5mbAS//Kfvwn7uDN7ywMdw53s/IJnYA4D/+dG/4fq3vF2y9TZDqVLh5re/B1WNjfjPx74L3+v1SYnQcekcMjRaGC1W5JaUovnmO7GysICeS2fhda9LuOs3CAUDWJqdhiWGmblSUnngMHweN5YnxyVf27PqxL133ib5NCCSu3RJEKMKhUJI/R46dAjXXnstDhw4AJ1OB6fTife///04cuQIvvWtbwniMFa+973voaKiAjqdDqdOncLLL7+86c8+8cQTQrST/y/SZobjOHz5y19GYWEh9Ho9brnlFgwODib8t8cLjfBtglqtRigUkv04KpVKMBWOhO/8ZBgGra2tST2dyN2pu12dYDAYRGdnJ1wu16apxFiOkc5aOD7KWlVVhaqqqpgvwulO6U5PT6OnpyemBh8gevpWyhvOmbNn8U8//QUUGi00Wh3e/vHE5txODQ8g4Peh/ujxbX+297WX0fPyJZTXNeAdH/8LWUaE9b32MqoPHErplIfKhoMorKjG73/6Q1Tsb4q7oWO42w732ioKK6rCvl9z9MTVGtvzL8BgNqOs4ZCkqd6xThvKGlPTBRxJWcMBTA30YWFsGHkVsRe8bwUTCqHEbMDdd90lyXpiSBBVm8EwDHF7E6d/AeDf//3f0d/fj5/85CdYWlpCTk7O/8/edYY3Up7bo2JbliXZsuXee/e6ly20XXaX3nvdkCX0AOm5CcmF9BBYCCFAEhJIaKGXwC5LWVh2vc2We++9SHJTs8rM/WFmkGzJajPycKPzPDyspZnv+yRNOXPe9z0vTjvtNOzcuRM7d+5EUVGRw+vbK6+8gvvvvx9PPfUUampqsG/fPuzatQvd3d2IiXH8gCmTyWjjemDtdfN3v/sdHn/8cTz33HNIT0/HT3/6U+zatQsdHR2MexA6Ard+KQ6AKzl8arUaR48eRVhYmNtKkqt52Fb4AMdVtFqtFvX19bRliTdkj5pjI6p0SZJEd3c3rbLaVrS6g40K6ZIkia6uLnR1daGsrMxpUYmjMan93ZnHEzzz93/g0Wf/CbPJhPNu3IuKM3Z4NY7FZMLn776JMy+9at3tju5/D2/99UmABK644z7U7DiHtX6wTUc+w6Ytp7My9noQhYpxyTfvBEFY8MGL/3D7HJkaGcT4QP8askdBKBRi0xlnQ5GSgdYvPsHM6BAj6zXotFhanN/QnsFJOXngCYSY7Ot2vbEbsM6r8KPv3s/IWKvBZcK3USFdd0EQBBQKBW6++Wbs3bsXFRUVaGpqwvnnn49Dhw6hrq4OKSkpMBqNa/Z95JFHsHfvXuzZswcFBQV46qmnIBaL8eyzzzqdj8fjIS4ujv4vNvYrBZskSezbtw8/+clPcNFFF6GkpATPP/88JiYm8NZbb7Hx8dcgoPA5wUZV6ZIkicHBQfT39yM/Px9JSczkmvhL4VudJzg1NYXW1lavcg8dzeHvkK7ZbEZzczMMBgNqa2u9KunfCOPl1ev21GyUGtf29/KV8P3w5w/heIMSm7achi3nXezTsfDvJx/BeTd80+EYBEHg4L//BZPBiLJtZ2KbH0yLP3zln6jbdd6Ght4qztiBtLxCvPPsU9hy7oXrFnQsaNRoO16PrJJSl+OGRylQvuNcDHW2ou2LT5FWVAqJD752PQ3HGTNZ9gXxGVmYGRnCWHc7EnMKvP7t9Bo1br3uGtYMfblO+Li6NsD+fqTT6RAWFobc3Fzk5ubi7rvvxvLyMlpbW9eoayaTCQ0NDfjRj35Ev8bn87Fjxw7U19c7nU+r1SI1NRUEQaC8vBy/+tWvUFi44iE6ODhIt0GjEB4ejpqaGtTX1+Pqq69m8qM7RIDwOcFGKHy2Yc/q6mqEh4ezMg8bWJ0nSJIkenp6MDo6ipKSErsnHW/hb+K0tLQEpVJJq6zeFrz423hZp9OhsbERoaGhPq3bNifTFyJjsVhw+fU3wmAFrrz7Oz5Xln74yj9RvX03wlYpxUa9Hgdefg7BwSLU7jwXijh2iw5s59Vrl5wqZf5EVFw8rrrrfnzyxivobVZi8zkXrNlm2WBA/YH3kFvmOhRui7T8YhC5heisPwyBQID0kjIIgzzrRLSoVoHk8ThjjRGTkobZiXGMtDcjpXCTx8e5yWhEYXoSNtfWsLRCbpMqLoZ0bWG1Wmkyp9fr15DykJAQVFauPQ9UKhWsVuua+1ZsbCy6uroczpWbm4tnn30WJSUlWFhYwMMPP4zNmzejvb0dSUlJtH2KozGp99gGN846DsE2pOuvHD6r1YrFxUU0NTUhLCwMdXV1jLd081d7NYIgYDKZ0NzcDKPR6LUq5mx8NnPhbL8fypQ4LS0NWVlZPhEef4Z0VSqVXQW0t+tevZ+3n2FqagoXX30tSraehR1XXufzzaG7uQEicRjS8gro1+Zmp/HJa69AHh2DXVfdiDA/t9J67al9uHDPt/w653rgCwTYccW16G9vwVt/exLnXLsHIV92frFarTj09qvI3lTu1bHB5/NRuOV06LVatB/9HNGJSYjPdP84G+loQXbpxqt7tohOSIRAKEDPqWPIqaz16HsRGhZx310/YXF13CZ8XF4bsNaHj822anV1dairq6P/3rx5M/Lz8/H000/joYceYm1eTxAgfE4gEAjoFlNsz2M0GnH8+HGPiwE8gT/aq/H5fCwuLqKnpwfh4eGoq6tj9EneH0UbVCXx0NCQQ1Nib+APOxnbjiUFBQVITPTNFsQRwfOU8O0/+BF+/8RTuPq+HyMpM9un9QCAXqtFy5HPcfE37wAADHd34uTHB5CQloFLvnkHI+3UPMVAZzvScgsgEnOvP2dmYQkSM7Lwwb/+jrT8QuSWVuLzd15DWv7abjCeQiyRoHzHOZgaHkTr4Y+Rml+McBcVt7NjIwjeoL62rhAZEweBMAhdJ44it6rOLRKjU83gx3ffxrpayWUfPq7n8K0mfO7mwisUCggEAkxPT9u9Pj097fY9ISgoCGVlZejr6wMAer/p6WnEx3/lBTk9PY3S0lK3xvQV3DyKOAB/hHStVitGRkawvLyMsrIyj4sBPIE/FD6SJNHW1oaUlBSUlpYyfiH0Rw6fUqnExMQEamtrGSF7APsKn9VqRXt7OwYGBlBZWekz2aPG9aVo48Ff/QoPP/k05DGxqD/wHg689A80H/0cixq112t645nHce4N30Dz0c/xxtOPY25mClfccR+2nX/JhpA9ADh24D1Ubd+1IXO7A1GoGJfsvROz46P4x+/+F4qEJISIQl3v6CbiUtNRtv0czEyMofPYYRgNju1hSJLEeF8XEhkg/mwhPDIKGSXl6DlZD6uL6I5Rp8VpFZuQm5PD+rq4rKJxPaS72njZXYUvODgYFRUV+Pjjj+3G+vjjj+1UvPVAmdxT5C49PR1xcXF2Yy4uLuL48eNuj+krAgqfEwiFQlYJn16vpy1XgoOD1+3UwATYVPgIgkBXVxcsFgtycnKQkcFOLhObhI+q0rJarYyH1NkkfFSbNMpMOTSUmZu5L2t+4eVX8NnxRnz74SfocRbnNFBPTaC3pRG6xUWYl5dhNi/DYrLAbF6GeXkZUnkkUrJzkZpXAIkswm7Mt599CqJQMfa/8A8UVtXiitvvY+BT+oZD77yGyu07OemRRhAElIc/wWBnB8RSKfg8PjIKSiD1odhiPeRV1sJiMqH1yCGEyyORnF9sRwTG+7oQmeC4TzaXECaTIau8Gr2Nx5FVVg2hg/xXkiQRsqzD9dewn2QPcFtF4zIZBdYqfK5aj9ni/vvvx0033YTKykpUV1dj37590Ol02LNnDwDgxhtvRGJiIn79618DAB588EHU1tYiKysL8/Pz+P3vf4/h4WF885vfBLByTb333nvxi1/8AtnZ2bQtS0JCAi6++GJmP7gTBAjfKvjDlmV2dhYtLS2Ij49HYmIiTp48yco8tmBL4aO8AgmCgFgshlQqZXwOCmwRPqrzBwCUlZUxrkyyVWyyuLiIpaUlSKVSVFdXs3pTcJcAvvOf9/HbRx7Fjd/7qV2XjvDIqBUFpaDY4X4EQWBRo4ZqYhydJ49haX4OywYjlg169LQ2wWpaxjXf/gFSc/IY/VzewmIyQT01ic27fO9ywRR0Swv4/N03sazXI0wWjpyyCpSfvlIR+P6//oaMPHZ974TBwSg7cyfmZqbQevgTJGblQpGYDKvFgtmRYeRU+0fF8BUisRg5FbXoPlWPzNIqBK9SjxcnR3H9xRfgyJEjkEqliIyMRFRUFGQyGSvkhyAI1jok+Qouk1HAnvAZDAaPcviuuuoqzM7O4oEHHsDU1BRKS0uxf/9+uuhiZGTE7veem5vD3r17MTU1BblcjoqKChw9ehQFBV/lG3//+9+HTqfDrbfeivn5eWzduhX79+/3iwcfECB8DsHj8VghfLb5YYWFhUhISIBer4fVal1jgcE02FD45ubm0NTUhKioKBQWFuL48eOse/0xOb6tBU5eXh7a29sZG9sW1EWByd+YKioJCQlBUlIS4xddb0K6Bw5+jF89sg955dUeV4Dy+XxEKKIRoYi2swrZ/9JzkMpkuPa+H+LIB++g6fCn2H3dzYyGJb3Bm397Etsv84/Csx6GujvQeOhjBIWKIFfEYsu5F0Emt1cxmr74DIp4dlqJOYI8Jg7yHedgsK0ZbUcOwUoQiM/OZf0axySCRSLk125D57HDyCwpR3DoSu6XfnEeV55/Ls455xyYTCao1WpoNBq0traCIAi6l2tkZCRjajuXVTSuh3R9Ldq46667cNdddzl8b3Xf2kcffRSPPvrouuPxeDw8+OCDePDBBz1aB1MIED4nYLpK12QyoaWlBXq9HrW1tbQSJhAI6KR7Ni+GTCp8JEliZGQEPT09dt0b/OH1x9RnoPIr5ufnUV1dDYlEgvb2dlYIq6PetN6CJEn09/djcHAQJSUlGB0dZSVcbKvO2f7fGT765FM88MtfIyEjC+dcdzMja3j96cdRWL0ZRp0OirhEXLTndmgX5vH5u29gQa3CzquuZy1EuR4mhgcRFZcASXiE3+e2WCw49uH7mB4dglgajqSsbFx4y+0OQ4/Aim3I+GCfU2WVDZAEAdXEGMwGPUiSQHdzExY0agSHBIPPX3mQDgkJgUDAB5/HB4/PB4/HB4//VUsqgIeV/638m8TKsS8QCiEICoJQGAS+MAg8gQDCoKCV/4RBEAQFMUZAhEIhCjefjo6jnyGtuAxBISIkysS46IIVVTc4OBjx8fGIj48HSZJYWlqCRqPB1NQUenp6EBoaiqioKERGRiIiIsLrhzIuEz4uq4+AvQLpSQ7f/1cECJ8TMKnwLSwsQKlU0pWrticIdTCy/aTEFBmjCgTUajUqKyvpBtXUHF8HhU+v10OpVEIoFKKurg4hISH0uGwSPl8v3LYklXpoGBsbY43wuVul+9Gnh/Dgw49i+5XXQj05AUW8b0UjBEHgxX2/wRkXXwGL2YyU7K/CuJLwCJx7/TdgNOjxxX/ewvToMLZdcCniklJ8mtMTfPrmK7js1rv9Nt+8ahaH//MWCIKAJDwC+eVV2HLuhW49PBx5/227748tmIxGTA72wri4AL1Wi4jYeKQWlWK8twObz78QYx1tyCqt8qnLCUEQsFgsMBn0WDYaYV5ahGnZCMJiAWm1grBYYLWawcPKwyefLwBfwPvSI3SFUPJ5X/6bB4D+/8qxbrFYaF9BmlQGCRGXmYuOY0eQkJiIPzzzZ4dr4/F4kMlkkMlkSEtLg8ViwdzcHNRqNbq7u2EymRAREUGHf8VisdsPf4EqXe9he1/V6/WMWYR9XREgfE7ARNEGSZIYHR1Fd3c3srKykJaWtuYkd9ahgmkIBAKYzWafxjAYDFAqleDz+airq1uTd+CP9m2+/iZqtRpNTU2Ij49HXl4e/f07aifGFGxDut6C+u4FAgE2b95MF5Ww6U24OqTrCAcOHsTjz/4ThVV16G1R4so7fCumMBmNePGx3+Hib9yGyLh4vPDIr3HZt+5Zs50oVIwdl18Li8WMYwf+gy/eexNlp52FTJaVrPqD76N0y+mM9pV1hO6mBrQdPwpRWBgUcQnYfvk1EEs8y4+dGhkCQRJO1T9fsahRYWZoACaDHsblZaQWlCAhw75qdWF2BumbKhBaUYPBlkZklFZ6rXLz+XwEBwcjODgYEuY86ddgxUvUCJPBCJPRAJNxCUGiUMxOTbgdphUKhYiOjkZ0dDRIkoRer4dGo4FarcbAwACCgoJo8ieXy9e99nM5bMrltVE2W7YhXabC7F9XBAifAzCRw0cpYSqVChUVFU6rg6gOFf7wyPNlDsrQdzVRWj0H24TPW9Jq61OXl5eH5GT7ikEqlMR2SNcbzM3NQalUIiYmBgUFBWu+e38ofI4UP6WyCU+99DpCpTJs2no6+tuaffKjW9Co8NZfn8TV93yXJjchIvG63RyEwiBsPe9iEASBxs8/xutPP47skjKU1G3zeh3OYLFYMNrTRfsAMgmTyYgj77+LBdUsxFIZUnPzccneO70mliRJovGzj5HOIAEmrFbMjAxhUTUNg04HYWgoMoqcFzmpJ8cQ8qXvXrBIhJi0TEz0diIxp8Dh9lwBn8+HSCSGSLSSt0cQBJZmpxFXUII//vkp3HvXnR6Nx+PxEBYWhrCwMCQnJ8NqtWJ+fh4ajQaDg4Nob2+HTCajCaBUKl3T0pDLpIrLawO+SpsKKHwBwucUFOHzJu9Kp9NBqVQiKCgImzdvdlmB4w+PPG/n8KS3L1dDularFR0dHVCpVGvC0KvHZ1Ph82btY2Nj6OzstMuVtAVbli+OjnnbeUwmE37y24cRIpHi2nt/gH//6Q+45p7vez3f2EAfDr/3Jm747v/QBG92fAwxSe5ZefD5fFSecTYqTt+BzobjeOtvTyImMQWbdzNXRfv2s0/i9IsuZ2y82fFRHDnwHgR8IaRyOYprt/gcDqfQWv8FohhoLWfQ6TA90Aujbgl6nRbRKRlIL3GvU8bsyBCSbQinPCYW+sUFzIwMIiYl3ee1+QvTA72ITExBcIgIx5pa0dnVhfw878PkAoEAUVFRiIqKArDidECpf6Ojo+DxeJDL5XT+H9dJFVfXRgkctiHdQA5fAA5BycCe5ihMT0+jtbUVSUlJyMnJcetk8IfJszcKn8ViQWtrKxYWFtzq7cvFog2j0QilUgkADsPQvo7vCTwhZiRJoru7G+Pj4ygrK3Pq08gWSXWk8Nli773fQVCoGBd+4za0nTiKkrrTvFajWo59gaHOdlzz7e/bnS+fvPEyzr3+Fo/XXVBZi4LKWgx1tePdfzyDkDAxdlx2rU83JvX0FCThcsijY7wegyAItB47gt5WJcIkMsQkJWP3tTdDFOqe+7+7MC0bMdrXjYxCz21YSJLE/Mw0VKODWDYYYLESSC8u9TicrNcuYXnZuOb1xKwc9DacgFaqgUTuvifaRsGgXcLSwjySvyTPIeFyPPbkU3hy3yOMER2RSISEhAQkJCSsqIlLS1Cr1RgfH0dnZyf4fD6mpqYQFBSE8PBwThEs2ypYrsFqtdLFhJTCFyB8AawBFdIF3D+gCYJAb28vRkZGPG7J5Q/C56nCR6mUISEhdjljTM7hKTxVsyjbGIVCgYKCApe/I1uEjwoXu7t2s9mM5uZmGAwG1NbWrnuRYlPhcxbS/e2+x6E1W7HtgkugiEvAwVf+havv/q5X8xzZ/y508/OOw6Q8PkLDvA/BpOUVIi2vEFOjw/jghX+AsJpxzrV7IPTCVPvAS895FcrV67Q48t5b0GkXESaVIaukDJfeejerN+0j77+DFA/8Ci1mM6aH+qCd08Cg1SI0XI60wlKf1jjR24m04jKH72VXVKPz+BdIDimGyM1WVxuF8Z4OJK4qepm3AM88+yxu+9JQl0nw+XyEh4cjPDwcGRkZMJvNOH78OJ0iZLVaIZfLaesXd1uFsQWuK3zUNT9A+FYQIHxOQB3EFovFJdlZXl5Gc3MzTCYT6urqPM4T4JrCNzMzg5aWFiQnJyM7O9vtE5pLId3R0VF0dXU5DYU6ApsdMdxdu06nQ2NjI8RiMWpra10W8viL8AErF82PPz2Exq4+pObmI7e0Evtfeg7bzrvIqzn2v/Q8omLjsM2BjYt2cRGRLnqzuou45FRcsvdOzM3O4OM3XoZuaRG7r7kZYjfP06YvPkNeheOuC44wNtCHYx++jxBRKCIUClRu3+WTMugJpsdGYLWpNnUG7cICZob6sKzTwmg0ID4jFxmbPPNOdAar1Qrtwjzi16nIza3ajM5jh5FVVu1T5S6bUE+MQiSNWHP9CwkNxWfHTmH3jh1IS0tjdQ1BX9rMpKWlISIiAjqdDmq1GrOzs+jt7YVIJKJz/yIiIljv67saXCZ8ttE5o9G4UuUeyOELwBF4PJ5blbqUihQZGYny8nKvTji2Q6GAe+qbrTG0pyol4FtRhbvju/oMBEGgs7MTU1NTKC8vp/NkmBrfW7hDzFQqFZqampCcnIycnJwNJ6mr55mbn8ff33gPoVIZzrr0alhMJhgWF5GY4Xl/1DeeeQJFNXXIK692+P5H//4Xtp1/qa/LtoM8OgYX3PwtGLRafP7u61BNjWP7ZdciMsY5sSQIAl1NJ3HpXsfmq9Q2pw4dxGhvL8JkUsSlpuOiW25DULD/+/s2fPoR0vIL17xOEgRUk2OYmxjHskEPgsdHVkk5gllw+J/s70ZMWua62/D5fGSWVWGorQkZmyo4Z8hsMZugGhtFipOilyBZBB5+/An88Q+/Z33tFKni8XiQSCSQSCRITU2FxWKhiz96e3thNBoRHh5O5/5JJBLW18b1kK5thS6AgMK30QvgMtZT3myrPj1RkTydhym4IpVUGHG1MTSTc/gKV4RseXkZTU1NsFgs2Lx5s8cl+GxV6boa2/ZYKigoQGKi+4n7/lL4SJLE3//9OsggES67bcUm5Y1nnsCua270aFyCIPDSY7/DGRdfgeQs543nDTotwiPdJ+ueIFQiwa5rboJpeRlH3n8b4wO9qNt1vsP1vP+vZ7HtvEvWvK6dn8fn770Bs8mEMFk48soqUXXWrg0lLi31hxEZG0evwWQ0YqK/B8vaRei1SwiPTUBqkW+hWnewMDONtE3lLrcThYoRnZqOyb5uJPjBK9ATjPd0Ii4r1+n7PB4PKoMZ/3zxJdx43bWsrsVZla5QKIRCoaDzeynrF41Gg6GhIQgEAlr9i4yMZMX2i8sKn61ljE6nA4CALctGL4CLcNVP12KxoK2tDXNzc+tWfboLf+XwOZtjaWkJjY2NkEgka4yhPZ1jo0K6lLl1REQEKisrvXrqZNPTztnYBEGgo6MDs7OzqKqqQkREhEfj+ovw/fy3D8NEAFffdg8EQiE0M9OQR0evaeO1HkxGI1567He46Jt3rKuqWUwmyOSOi1SYRHBICM685EoQViuOfPAO6g+8h5K6bcgrrwIALM3PgccDohNWCHh/ewuaj3yOkNBQyGNicdqFl21Itw1HMC0bMdrbjai4BHSeOIJlvQ5mswUZRaVIXIe4MI25qUkIPMgri4yJg35xAXMTY5An+K/923rQzqlhtRIuU3lCQsXY/+nn2Ln9LI+jIZ7AXVIlFoshFouRlJQEgiCwsLAAtVqN4eFhO+uXyMhIxvr+cp3w2Sp8YrGYs2v1FwKEbx04IklarRZKpRIikQhbtmxxq5jBnXk2ypZlYmIC7e3tSE9PR2Zmpk8KBZsKGeCc8FGfITMzE+np6T4Zu/ozpLu8vAylUgmCIFxWEHsyLhOwHffv/3wB/WPjOO+mvXQrs/f/9Tdcdef9bo+3oFHh7b89hatsPPac4ZM3/43Srad5v3gPwRcIsO38S7D1vIvRdOQzvP7040jJzkNPcwMUCUl44y9PIEwqQ3J2Li665XZO5px98vrLWJgeh2FpERmFm7wqTGECMyMDSM4v8mifpKxc9Dc1IEgcBskGtMqzBUmSmOjrcfszCGUR+M0j+7Dvd79hbU0EQXh8TePz+ZDL5bQYsby8TKt/ra2tIEnSzvrFm2sPtbavQ0hXp9N51N3k/yu4d+XiEFb3052cnERbWxtSU1ORnZ3N2MGzESFdgiBo24/S0lJER0f7PIe/FT6CINDT04OxsTFGPgOb+XCryfDi4iIaGxsRERGB4uJiry+abJpFkySJjs5O/Pvd/2DLeZcg5UulqEt5CjnFZS4LAyiM9vXg6P53cf13fuTWPqqJccQmpfq0fm/A4/FQtvUMlG09A08+8D3Mjo8ga1MZzrzkSr+vxRNMj40C4KFoy1kbug6jXgeDQe/VvpmlFeg8dhgp+SUI2cDK0+mBXkR44IXI4/EwubCE1958E5dfsjb07yuoPuu+kqqQkJA1fX/VajUmJyfR3d0NsVhMq3/u9v2lOllwVTWzJaOUwvffjgDhc4DVIV1bcrRp0ybExDBbcedvWxYq181sNqOuro6xRFZ/VumaTCY0NzdjeXmZsc/A5vptQ7pTU1NobW1FRkYGMjIyfFZV2SKpRqMR3//5L5FVUo6y086kX2/49CCu+bZ7JsutJ45iqKMdV9/zPbc+J0EQCJOx2DfLBTTTU3j3uWeQXVKK7ZdeibGBPrzzj2dw/o3f5OyN7eTHB9bNh/QXxns6kV5U6vX+udVbVip3y2s2RDUy6rRYnNMgOW9t0ct6EEmkePP9Azjr9NOddlTyFtT1iEllyrbvb3p6OsxmM+bm5qDRaNDV1QWz2YyIiAha/XOmjFFr4+p5sbqPblhYWEDh2+gFcBlCoRBGoxEnTpyA1WrF5s2bWXlK8JfCR5IkNBoNmpubIZfLUVFRwWgZv7+KNqicQ6lUitraWsY+gz+KNvr6+jA4OIiSkhLExvpuO8JmSPcHD/4SEkU0dl17E/365+++gZodu926cB754B2Yl5dx0S23uT3v8Y/2I7+yxqs1+4rP3n0dixo1rrv/R3jzmT+i9uxzkF5QjLmZKbz91ydRUF2L3FJmrEuYQuuxIwiPitrwGxlhtWJpXoO4TM8rtinw+XxkbKrAcKsS6RtQuTvc2YaknHyv9uVLwvHbPzyK3/7yIUbX5A9SFRQUhJiYGMTExNB+dWq1Gmq1Gv39/QgKCqLJX2RkJH29tW1dxkU4yuH7bwc3qTlHYLFYMDQ0hLCwMNTW1rJ2wPjLlgUATp06hfT0dGzatIlxzyZ/hHQtFguOHTuGxMRElJU57+Pp7fhsWpwMDAxgfHwctbW1jJA9gD3C9/wrr2JuSYsr77yfvvESBIHpkWFkFm1yuf/+l56HSByGsy672qN5+1qVSPdQYfEVFpMJ//zDL6GIS8D5N+2FQCiE2WxGyJcdMOQxcbjy7u/AqNfjjb88AYvJ5Nf1OYPZtIzBzjaER7Jf4OIKk4O9UCSn+TxOaJgEUcmpmOrv8X1RHkA9PgaRROo1seLz+RhSzeH9/QcYXZe/VTSq729KSgpKS0uxbds25OXlQSAQYGBgAIcPH0ZDQwOGhoawsLBA78NFrM7h+2+3ZAECCp9DkCSJgYEBaDQaREVFobiYuQbkjsC2wkcQBLq6ugAAJSUlrFWUsRkSJUkSo6OjsFqtKCsrY4ww2YKt9RsMBuj1eoSGhqKuro6RQh8KbBC+9z7YD2V7J278/gMIsbExeOdvT+HMS13ns73x9OMoqtuKvLIqj+eWyCL8egPpb2vGkQ/ewSW33mVXcRu06jfi8XioOmsn8iqq8cELf0dSdi7Ktp7ht3U6wpH/vI3E9PX97vyF+elJpJW4tmJxB1FxCTAsLWJ+agIRDPQDdgWLxYzpkUGkF5f6NI5IIsXLb76FbVs2e2Vr5QhshHQ9gW3f3+zsbBiNRqjVamg0GgwPDwMAOjo6aPsXJq9tvsJqtSIkZMULk7r+/rcjoPA5wOLiIsbGxhAXF+eXpwI2CZ/RaMTx48extLQEAC774foCtgiT2WxGY2MjZmdnAYAVsgewQ57m5uZQX18PoVCIjIwMxi+ITIehx8bG8L+/exjn3XgLbUcCrHS+EAYHISo23um+BEHghUd/g5pd53tF9jobTvhV3Xvvub9gfLAP13/3f9bYqzgzJJaGR+Cy278NsUSC1//8GPRarR9WuhazE2OYm53ZEHPn1ZifnQI/mFkD56TsPCyoZqGdn2N0XEeY6OlCQjYz1jVkqBS/e3QfI2MBX3nwcUVFE4lESExMRHFxMUpLSyEQCBAaGoqxsTF88cUXOHHiBPr7+zE3N8e684Qr2FrGBBS+FQQInwNERERg69atEIvFrIdaAfZCoWq1GkePHoVUKkVNTc2GGyN7A61Wi2PHjoEkSVRUVADAhrc/cxdjY2M4deoUMjMzWbMEYJKkLiws4MqbvoHN51ywpgPGO397Etsvv8bpviajEf98+Jc478ZvItnLPK6GQx8jv4L9/L3FeQ2ef/gX2LTlNGy74NI1v4vFYkFIyPpqQHHtVlx62934/J3XcHT/u2wu1yEWettx61WXwjAxDP3Sot/nt8VodydS8goYHzezrBITfd0wGQyMj01BOz8Hs8WEEBEz6g9fIEDP2CQOffY5I+Nx2ecOAP0gW1VVha1btyIlJQXLy8tob2/H4cOH0dLSgrGxMRhY/A2dYXUOX4DwBUK6TsHn8yEUCmmHbjbBtMJn27khLy8PycnJ9DxsPnUx/Tlse/rm5OTA9GXuFEmSrJAnpggfVdU9MTFBt3ebmZlh1T7FV8zOzuLWu+9Fcl4hTr/wcrv3Rvt6kJSVA1Go4xxW2mPv7u+49NhbD6FhYax73B3/aD8mhvpx9T3fWxO2pTDY0Yq4tHSXY4WEinHhN25Db4sSr/75Uey86kbWuoPYYrhNiSvO242C/Dycvf0svPLa6/js+CmERMczRlzcxbLBAMJqcb2hl8ir2YKuLyt3+QwXB5AkicneLiR56BvoCiJpOP7x0suoran22t+OgjcefP6CbRUsAAQHByMuLg5xcXEgSRJarRYajQYzMzN031+q+EMul7Ne7GFL+AwGQ4DwIaDwOYSrThtMg8l5LBYLWlpaMDg4iKqqKprsAewXhzAVXiRJEv39/WhubkZhYSFyc3PB4/Hoi8tGtD9zF1T4WaVSoa6uju7ly1Zxha+FJiRJYmhoCL/9w6NYWDbhstu+vWabz995HVvOudDh/qN9Pdj/4nO4/js/8onsTQwOICEtw+v9XYEgCLz8x4cREirCxd+8wynZA4CuhhMe2Zxkl5Thqru+i4ZDH+GTN15hYrlOYTaZIF7WoiB/pRUZj8fD1Vdcjsd+9SDyoiSYHxmA1cIeAVuN8d4OpBSUsDY+n89HWkkFhtuaGD9/ZocHIIlhJ5/ZHCLGH/Y97vM4XFb41jNd5vF4kEqlSE1NRXl5ObZt24asrCyQJImenh58/vnnUCqVGB4ehlarZeXaGCjaWIuAwrcOvm6ET6/XQ6lUQigUYvPmzXTCqu08bCt8lBmnt0+lFosFra2tWFhYQE1NDWQyGf0e24TPV/Kk1WrR2NiIsLAw1NXV2VUQs2n54u2aCYJAZ2cnjtbX4/PjJ3HHL/8A4aq2eg2HDmLT5tMc3nTaThzFYKf7Hnvr4bN3XsNFe273aQxnGOvvxadv/Rvn37QXEQrX5txLC/N0RxF3IQwKwu5rb8JoXw9e+/M+bD3/UsQlp3i7ZKfoP3EYP9h785rXg4ODcds3b8Hi4iKe+tvf0Ts6BnliCngskgWSILCoUSM2PYu1OQBALJEgMjEZ04N9iMvw3vbFFssGPeZmZ5DCsLpHQSgMQkv/EE6cPIXqKu+tfLhO+Nxdm1AoRHR0NG2OT/X9VavVdN9fW+sXJvr+2hJSg8GApCRutO7bSAQInxPweDy/ET4mlLfZ2Vk0NzcjMTERubm5Dk9Ef+TwAd6HXPV6PRobGxEcHIzNmzevKXDgssKnUqnQ1NREh59Xf362LF+8HddsNqOpqQlarRZPPvscbvrhzyFzEI7sbWnGVXetbaF2+P23YbWYcdE33PfYWw9CYZDTQglf8OEr/wSPz8e19/3Q7ZtTULD3N5vkrBxcfc/38Nk7r6Pxs4+w+9qbGbthz89MoTQjFRKJxOk2MpkM37/v25iYnMTvHn0cOggQmcg88QSAqaF+1sZejaj4RIwuLWB+egIRsb5X7o53dyApO4+BlTmHSBaOp//xHMpKN3lNYLhM+FaHdD3B6r6/8/PzdOVvR0cHpFIpXfkrk8m8up/Yro9qrfbfjgDhWwf+VPi8JRpU+HNwcBCFhYVISHB+MfSHTx7g3UVKpVKhubkZCQkJTgkrj8djVSnzhhDb5kuu9/37o+etu9DpdGhoaEBYWBj+97d/wO4bvoGUnLU3vw9e+Ae2nX/xmtf3v/Q8YhKTUHnm2d4u2w4LahWiGLbfMOp1+PeTj2LLORcio9AzW6UgHytO+QIBzrzkSsxOjOLNZ55A+enbkZ7ve/XxbGcz7vjO2pC7IyTEx2PvTddjYnIKHx8+ggWCD5mC2Q5Bc9MTSPWhs4anSM4pQL/yJIJEYoStqqr2BPPTkxCKQsH3Q09kAz8Ijz3xJL57n3u/22pwmfAx1UeXz+fTyh7wVd9ftVqNsbExAKDfj4qKWhO5coZA0cZaBAjfOljdS5dr85jNZrS2tmJpaWlN+NMR2Fb4qJPLarW6bYhM5ZD19fUhPz/fpezOdvszT8YmCALt7e1QqVSoqqpCRESE023Z7nnrLtRqNZqampCUlIQnnvkbUotLUXXmzjXbmYxGGHXaNXl1rz/9RxTXbfHKdsUZDv77BZx9xXWMjddS/zm6lQ248s77aPNkT8CU0hidkIyrv/091B94D81ffIrz99zmtVH4cHszLjtnp0dKB0mSyMnOwtk7tuPwF0fw+n8+gCVU5hNZorCgngW5AUQks6wKHfWfI62ozKvfyWqxYHp4ECkF7HqrUggKDsGpji60tbejqNBz0s91wsfG2tzt+xsVFYXw8HCnpDPQS3ctAoTPCfwZ0hUIBCBJ0qMTiMoXE4vFbpv5sv15bDsyuAOr1Yr29nao1WqXhIkCm4TPE/K0vLwMpVIJgiBQV1fnshqPrZCuJ2seHR1FV1cX8vPzceJkA/ompnDLT3/pcNs3//onnHPtzfTfBEHgpX2/xZmXXoUkH9pnOYLVYmakfy5BEHjjmSeQkp2Dy++416sxpkaGEBnLXCI/j8fD5t0XYLFmMz55+Tmk5hch10PrGYvZDJF+AcWFnlufUOfktq1bsHXLZrz17nv46PBRCCNjIBJ7r3hMD/QhJY+d/DdXyKnajJ4TR5FVXu1x5e5kXzdiWCwOcoQQWQQef/oZPLXvUY8JEuXDx0X4EtJ1F876/qrVanR2dsJsNkMul9MKoK391epeuuulQvy3gJtHEkcgFAr9RvgA94nS1NQU6uvrERcXh4qKCrfNfNkO6VKVtO7MYTAYcPz4cej1etTV1blF9gBuKHyLi4uor69HaGgoampq3LJe2MiQLkmS6OzsRE9PDyoqKiAQCPDI03/BDd/7icMLtnp6EpExsXThwrLBgH89/Eucf/OtjJM9o0HPSGuwmYkx/OuRX+K0Cy9B1fZdXo/TduIoUh2Et32FTB6F8795JwR8Pj74x1MwGY1u79t34jD23nCtx3OuPi54PB4uufACPPbrh7ApQYGF0QFYzGaPxzUtG6HXLW0YEREKhUgtLsVAS6NH++kW52E06H0iut5iieDjyaef8Xi//0aFbz1QfX/z8/OxefNmVFZWQi6XQ6VS4eTJk6ivr0dXVxemp6dBkmRA4VsFbh5JHIFt1Snb8wBwSS4pf7e2tjaUlJQ4LA5YD/7o2esOadJoNKivr4dMJkN1tWdeVWwrfK7GnpqawvHjx5GcnIySkhK3c1g2KqRrsVjsbGIiIiJwxY3fwPXf/R+nN779L/wDZ1x0BYCV/LpXnngEV93zXcijmc0BA4CP/v0Syrae6dMYh95+Dac+OYDr7vsRohN8q8SbGRtF5DrdRHxFQd02nH39LTjyzqto+uxjl9svqKZRkprkdasuR9cHoVCIb9x0A/7wvz9FsoiHudFBj47NiZ5OJPspJOoMYVIZohKSMN7b5db2JElioqcLiSwXajhDcIgIXzQ0oa+/36P9uOzDx1QOn7fg8XiQSCRISUlBWVkZtm3bRud/DwwM4L333sP27dvxP//zP5ibm/OI8P3pT39CWloaRCIRampqcOLECafb/uUvf8G2bdsgl8shl8uxY8eONdvffPPNdA469d/u3bu9/uzeIkD41oG7RMxXUAfAevOYTCY0NDRgZmYGtbW1XrUXY1vho+Zw9jlIksTIyAgaGhqQlZWFoqIij58Q2Vb4nJEnkiTR29uL1tZWbNq0CZmZmR6TbX8rfHq9HseOHQNBEKitrYVYLMYl11yHXTfcgpgkx9WVnY0nkLOpHMKgIIz2dmP/S8/h+u/8EKFh7IRD1FPjiIr3rmDDZDTihUd/jdjkFJxz/TcYMeYVCIWsqxZiiRS7btyLqLh4vP/sn6FdXHC67XSbEpdf7NgD0RVcHW9hYWG496478Msffgcy0xLmJ0Zcq8UEgQWNyqkJtz8RnbRiOzM/M+lyW9XoECRRri152ESwLAKP/vFPHl0HuKzw+SOk6wkoa5ecnByUl5ejtrYWl112GZqbmzE7O4vLL78cN9xwA/71r39hZmbG6TivvPIK7r//fvzsZz9DY2MjNm3ahF27djnd59ChQ7jmmmvw6aefor6+HsnJydi5cyfGx8ftttu9ezcmJyfp/1566SVGP7874M6vxTFQOXwAWC/coEKhzojSwsICjh49CqFQiLq6Oq9zEfyh8DlTsqgCh76+PlRUVCAlxTs7B7ardB2NbbFY0NTUhImJCdTW1iImxnOly98h3bm5ORw7dgyRkZGoqKhAUFAQ/vdXv0ZiUTkKq+ucjtdw6GNUnLEDbcePoLn+MK6+53sQBrHTEJ0gCIRHeRfO7VaewutPP44Lb7kdeeXMFZD4szdt5qZynHvL7Wj+9ACOO2jPNtLRist27/BJ4XFn32iFAj/9wffwvVv3QLg4i4V1CNTMyBDCWVRAPUVKXiHmpiahX4c0m4xGzE6MIYIFhdoT8Hg8qE1W/P25593eh8uEj8trs1qtiImJwX333Yd3330XISEheOyxx5Camop9+/YhPj4eFRUV+PzztS3wHnnkEezduxd79uxBQUEBnnrqKYjFYjz77LMO53rhhRdwxx13oLS0FHl5efjrX/8KgiDw8cf2Cn5ISAjdiSQuLg5yuWden0yAm78WR0A1rd5Ia5bx8XGcOHECKSkpKC0t9brKb705mISjOYxGI06cOIHFxUXU1dXR5ffewN85fFSuodlsRl1dnU+hNX+FdMfHx+kevgUFBeDz+fjiyBE0D45ixxXOc8E+ffNVVJ+5E1988A7U09O4cM+3WA0nff7uGyjdcrrH+7397J8xMzGGq+75LiQMFHvYIoQFL8D1EBwiwplX3Yj0giL8529PQjM9BWClmjRYq0FJsfehU08fMLIyM/GrB36CWy45D9bZcSzNqddso5kcQ3RisoO9Nw7ZFTUY6+lwmhc52tmK5A0qMFmNkFAxDn5xFGOr1B9n4DKp4vLabNVHq9WK5eVlbNu2Db/4xS9w6tQpTE5O4v7777frRAV8FUnbsWMH/Rqfz8eOHTtQX1/v1tx6vR5ms3nNfe7QoUOIiYlBbm4ubr/9dqjVa88vthGo0nUBfxZu2M5DEAS6urowOTmJsrIyKBS+J7bz+Xy6Hy1bWE2a5ufnoVQqERUVhcLCQp9zPvxZpTs3NwelUonY2Fjk5+f7dHHzR0iXCjuPjIzYHTNarRY/f3gfbn3wd07HIQgC4wM9MGiXEJuSisozdjjdlimM9fVgy273w5XzahXeefbPOOvya5GYznylpXZhHpJwZgmku0jKyUd8Rjbq33sDRqMRsdHR+M4e361qvCHsVZWVqKqsxAcHPsT7nxwCL1yB0DAJluY1YP9K6B3oyt2KGrvzdHF2GsIQkU8PykwjSCbH7/c9hn2/+63L34frVbobmcO3Hla3VQNgFxmLiYnBddetPb9UKhWsVuualKnY2Fh0dbmXL/qDH/wACQkJdqRx9+7duPTSS5Geno7+/n78+Mc/xjnnnIP6+nq/fofcOQs4ho3sp2s0GtHU1ERbfjBVXeQPhc+WkI2NjaGzsxPZ2dlITU1lRC3yl8JHrT03N9fr8LMt2AzpEgRBt6RbWlpCbW2t3cXtkutvwrXfe2Dd0OyrTz4KwmpFVnEpcssqGF+nI0hkEW4fE0cPvIeZ8VFcc+/3WQsxtx47guScfFbGdgcCoRBbL74Sh994GWlyCcJ9JJ++Hm/n7NqJXWfvwEv/fhVfnFJibGwUqSz2zfUFQqEQKUWbMNrRQptBE1YrJgf7WO316w14PB6mtUa88upruPrKK9bdlssqGpfXZkv4DAYDAPjFePk3v/kNXn75ZRw6dMiuGPHqq6+m/11cXIySkhJkZmbi0KFD2L59O+vrohAgfC7gb8I3NzeHpqYmxhQxW/irStdisaCzsxMTExOMqZO247Op8FmtVnrt5eXliIpa227M27HZCukSBIETJ05AIBCgtrbWzqbn5m/djl033oqIdXLllubmMNTZjhu++z9IzGC3LyqFpi8OIbukzOV2FosFrz75CAqr6lC36zxW1zTc3YFNW05jdY71YNTr0ffFR7jjmsuQl5Pj83i+9LSmwOfzcd3VV+HySy7G3//xPKwkAbPFAovFCrPFArPV9t9WWCyWr943r/ybBACBACSPD/D5CAoOgTAoGEHBweALBIylDUhk4TAoYjAz1I+YtExM9vdAkZLOyNhMI0QchncPfowdZ5257vVxoyth1wOXCd9q02WhUOhWhw6FQgGBQIDp6Wm716enpxEXt74/58MPP4zf/OY3+Oijj1BSsv5DRkZGBhQKBfr6+gKEj0vwF+Hj8XiYmZnB9PQ0cnJykJKSwnj+FJtkiQKPx8Pg4CB4PB6j6iQFtkKjwMpFwmg0Qq1WM752ttat1+thMpkQHR2NwsJCuwtwR0cHxtXzEJysR+fJ+pUb76o1WC0WNHz2MTIKitB4+FPEJqVA6Kavoy9oPX4EV9353XW3Ge7uxOH/vInzb74V4Q76/LKBID98dkeY6O0CTzWB/7n7drd9Nd0BU9eQkJAQ3PatvR7vR5IkTCYTtFottFotWltbodfrIRKLMb+wuJLv9CVJtCWSli/JpPlL4mixWr78vxVmixXgC8DjC0DweRAKg2gCqUhKwUhXO8Z7u6DXLiHSR5seNiGQhOM3f3gUD//asfk5wG1SxfWQ7uo+uu6cC8HBwaioqMDHH3+Miy++GADoAoy77rrL6X6/+93v8Mtf/hIHDhxAZWWly3nGxsagVqsRH+/fAqgA4XMBfxA+q9UKg8EArVZLG0myAbY/y+LiIubn5xEWFoaamhpW8mbYIq1arRZdXV0gSRK1tbWMr52NkO7U1BTa29vB5/NRVFS05oK29467cPejz0Asdd5yb6C9FeMDfdj7wK8xMz6Kj159EXOz00jNLUDtrvNYu9mIQkLXHfv9F/6OEJEI1973Q7/5kPmzQpcCYbWi8/BHOLOsCKdfegujY7PtH+oOeDweQkJCEBISgqioKOj1eoSEhCAjw/scTKvVCr1eT5PI+YUFzM8vYG5+HotLiyiM2YLGRiWiszOhmZ+HZnEJhCAIYbJwTnna8fh8jGoW8PZ77+Gi8893uA2XCR+X17Y6h8+TcO7999+Pm266CZWVlaiursa+ffug0+mwZ88eAMCNN96IxMRE/PrXvwYA/Pa3v8UDDzyAF198EWlpaZiaWim8kkgkkEgk0Gq1+N///V9cdtlliIuLQ39/P77//e8jKysLu3Z5bxLvDQKEzwlsc/jYtGXR6/V0vl5qaiqrpdps5vBNTk6ira0NYrEY8fHxrCVJs0H4Zmdn0dzcjOjoaGg0GlbWzmRIlyRJDAwMYGBgALm5uejt7XV4I5PGJqxL9gDgkzdfQcqXnSViEpNx/k17QZIkBjvb8P7zf8XinAZlp52F/IpqRtYOAENdHcgqdFx9qltcxOvPPIZt51+KtDzPW4n5gmCRfwnf3MwUZlpO4u4br2MsdWA1uERwAGbCzAKBAFKp1O2KeSon+mRDI2Y0c1Br5qCeX4CFL4BYFr6hpEUkkeLVd97DGdu2OczZ5DKp4vLabAmfp102rrrqKszOzuKBBx7A1NQUSktLsX//frqQY2RkxO5z//nPf4bJZMLll19uN87PfvYz/PznP4dAIEBLSwuee+45zM/PIyEhATt37sRDDz3kVpiZSQQInwuwWaWrUqnQ3NyMuLg4hIWFsX7ysJHDR5Ikenp6MDo6ik2bNmFqaorVsDGThI8kSQwNDaGvrw+FhYUICwtjrVSeqZCu1WpFW1sb5ubmUFtbCx6Ph56enjXbvfnmmyiq3bruWJ+/+wa2nHMBhrra7V7n8XjIKChGRkExCIJA27Ev8NZfn4RBp8UZF1+B+FTf8qJOHXwf53/j9jWvNx3+BH0tSlx513cQIgr1aQ5PYTGZIGLJXNoR+k7VI10Wir333s0aKeOCwrcaTBA+TyESiVBbW4va2lr6NbPZjLb2dhw7cRIzKhV6+gdhIQhYeAKEysL9Gqrkhcnw20cexa/+9+dr3uMyqeJyfuFqhS80NNSj4+6uu+5yGsI9dOiQ3d9DQ0PrjhUaGooDBw64PTebCBA+F2AjDEqSJAYHB9Hf34/8/HwkJSWhvb2d9dAx0wqf2WxGc3MzDAYDXRk6MzPztSB8lBG0SqVCdXU1wsPDsbS05DfLF2+wvLyMxsaV/qF1dXUICQmBTqdzOO6vH3kMP3j6n07HWrFh6UN+RTWW5uacbsfn81Gy+TSUbD4NpmUjTn16EPX73wNBENh59Q2QyT33VAwNFdtV2hIEgfee/RPS8gpx2Z33ezweE+hSnkJieibr8xh0OvQf+RjXXngucrOZ7UvsCP8fFT4mEBQUhLLSUpSVlgIAPv30U1RVVWFkdBRHjx3H5PQ0ZjVzUGnmYLQSCJWFQygMYmUtfL4A/ZMz+OiTT7DjrLPs3uMy4eNapw1brC7a8EeF7tcBAcLnBGzZslD2GQsLCzTRYGMeR2BS4dNqtWhsbERYWBhqa2sRFLRyMWTb+oUJwre8vAylUgmSJFFXV0eXz7NlnQL4vu6lpSU0NDRALpejqKiIvpg5W3Nceta6OWlv/eVP2Hn1jWg4dBDlp7lXJRYcIsLm3RcAWPGsO37wfcyMj0EslWLnVTcgyI3whGpyHFGJXyXST40M4/BbL2P7VTdAvoEdHHqaT2H75c5NqZnAUEcr5ntacf3llyJGoWD9Zs4VcrUaXFsTSZIgSRJCoRAF+fkoyM+3e29wcBBfHD2K0fEJqObmodLMQWcyQySVMZb3KZKG45//fh2bv2yBaDs/l0kVV9dmS0Y9Den+f0aA8LkAk0RMq9VCqVRCJBJh8+bNdtV4AoEAy8vLjMzjDEyRsenpabS0tCA1NRXZ2dl2F3C2rV/4fD7MZrPX+y8uLqKxsXENcaLG5qLCNzMzg+bmZmRkZCAjI8Pu+3Y07oO/+hUqzjzb6Xja+XmEhIoRnZCImbFRKLzoZSsJj6AJkmpyAp+++QrmZmYQn56Bredd7PRG8MXbr2H7VTeu/Pud12AxL+PSO7/DSB9cX2DU6SGWeNdFxRUIqxWdnx/E6aVFKDxzL9RqNa3oR0ZGIioqClFRUYzn8wRCuu6B+p4cHbM8Ho8+72y3Hx8fx5Gj9RgaGcXs3BxUGg2WDMsICpN4nY5gDRHj9/sew89+/CP6Na6SKpIkOR/Spc6ngML3FQKEzwWYImIzMzNoaWlBcnIysrOz15zE/vLI82UOkiTR39+PwcFBFBcXO/Ql8pWQuYIvxQ9TU1NobW1FZmYm0tPT19x4KPLExk3JG8Jnm2Po7Pum1mm75v98+BF+9Mw3nI771t+exFV3r1iiBIeE+PxZFfEJOPf6lQrToc52fPLyc1jUaJBbsxmFVfZ9e4UCAXgCPl5/4ncoP3Mn0go3+TQ3UxCFsGPHopmaxGzrSdxz8w10q6WYmBiQJImlpSWo1WpMTEygq6sLUqmUJn8ymYyRY5CL5IqLawLc/654PB6SkpJw1SrT5JmZGRytP4begQE6HLyg00MYKoZI7JpwCIRCtPUPYf+BD7Hz7B30AyjXvi8A9DWYi2QUWFu0ESB8KwgQPhfwVeEjSRJ9fX0YGhpyetNmYh53QCl83lx0LRYLWlpa6E4Ozirk/KHweUr4bH+DTZs2ISbGcRN16uLFxk3J03UTBIGOjg7Mzs7ahf5XYzXhM5vNSMp23gaur60FmUUlCAldUSFCQpkNdaTlFyItvxAEQaC74Tg+/OdfoV1cQM05FyFcEYM5jRoHnv8Lzrn5doRK/Fck4QrhEcxXx/eePIosuQS33nePw4cLmUwGmUyG9PR0mEwmaDQaqFQqjI2Ngcfj2al/VMqEJwgofO6BOi99XVdMTAwuvsi+VeDc3ByOnTiB9s4uqDRzUM3NYX5JCwSLIJZI18wpjojE3/71AoQCPmJiYmAymVh9gPYWXCd8gRw+xwgQPidgIoePKmrQ6/XrkiRf53EX1MnpqRSv0+mgVCoREhKCurq6dY1huZbDR+VMLi4uuvwNbL8fpi9knih8JpMJSqUSVqvVLsfQ2bjAVzf3m2/Zi62XXu90+2MH3sUN3/spvU9wKDvVsHw+H/lVdcivqoPZZELL4U/wt4d+jAhFNC6/+/ec6m1KEASjZtMGnRb9X3yMGy65AFmZ7hWCBAcHIy4uDnFxcSAIAouLi1Cr1RgZGUFnZydkMhlN/iQSiUdqFJfARcVqvZCur5DL5Thn1y6cY+O3ptVqcaqxEU3NLVBp5jCrmcPc4hKsAiHCZOEIlitQf/IUbrz2GqjVanR2dmJ4eBhRUVGIjIxERETEhodSqWvwRq/DGRwZLwcQIHzrgsfjeW3LsrS0hMbGRkgkEtTV1bl8QvdHn1vq5PSE8FEedUlJScjJyXF5UWS7m4cn4xsMBjQ2NiIoKMglUQXWkicm4S7ho4phpFIpiouLXRKj1WsemprGlU487j57+zXU7DyP3me0rwdxyb73CXaFoOBgCIKCIQ6T4tr7foTPXv0ndEs67LjmJojd9FJjE2N93YiMT2RmrK52BC/M4CffvtMrVQ5YOcYjIiIQERGBzMxMLC8vQ61WQ61WY3h4GAKBAFFRUVAoFJDL5U6PkYDC5x6YUvjchUQiwRmnnYYzTvuqjZ/RaERzc/OKV6Bag9a2NgQFBUEoFKKoqAgWiwVqtRpdXV0wm82Qy+X0A0AoSw9t68FqtYLH43Hut6SwOqTrqi3afwsChM8FvFHeJiYm0N7ejvT0dGRmZrp1UvhT4bNarS5vRrbWMYWFhUhIcC+xnyuEb25uDkqlErGxscjPdx7iXD02AFbW707uoUqlQlNTE1JSUtYUw6w3LrDye01PTyMtf23HDWDlM02NDuPMS6+iX1N+/gm2nX+xZx/EC0wOD2KivwfpefmIikvErhtuhX5pCSf2vwPV9Dg2n38ZYpLYJ57O0KM8iU3bznK94TqwWixoPPAuLjxtM7Ze4bhrgrcICQlBQkICEhISQBAE5ufnoVar0d/fD4PBgIiICPrmv7qFFNduyFwkfNSaNnJdIpEINTU1qKmpsXu9t7cXQUFBkMvliI6OBkmS0Ol00Gg0mJ2dRW9vL0JDQ+nwv7/UP64Wk1BYHdKVcCh9ZCMRIHwu4AkRIwgC3d3dGB8fR2lpKaKjo1mZx1vw+Xy3iIfVakVrayvm5+fXzR9zNgfbOXyulIvR0VF0dXUhNzcXKSnuEwnqgs8G4XO17uHhYfT09KCgoACJie6rTbaE79qbbsY1P3zI4XZvPvNHnH2Vfah3XjWLCIXjfEamYNTr8dlrL+KKe3+IN554mH5dLJXijCuug8VsRuPH+3HsvTeQV7MFOWVVrK7HEZbUKoRHOW9g7wrqyXGMNxzFeVtqsXVzresdfACfz0dkZCQiIyORnZ0NvV5P5/4NDAwgODgYCoUCUVFRrEcMvAXXCB8Xw8wUVtuy8Hg8umVXSkoKLBYL5ubm1qh/FAFkK5TJ5QpdwD6kazAYAiHdLxEgfC7gLhFbXl5GU1MTzGYz6urqPE4S9QfhA1wTMr1eD6VSCaFQSJv7eoKNzOGjCPfExATKy8s9bldFPeX7M6RLEAS6urowNTXlVR9lW8JHBIc6VMoW5zQIlUihiLNXaUPcbCjuC15/4ve45I77wefzwResVQSEQUGo3n0Bqsjz0XH8C7z/tz9BnpSCul0XsLouW4SIRF5/Dz3Hv0BudDguuvkGuoemPyEWiyEWi5GUlASr1Urf/Lu7u2E0GjE4OAiDwbBhob/V4KrCx0W1irI+WW9tQqEQ0dHRtPqn1+uhVquhUqnQ19cHkUhEq79Mqn9cNl0GfOul+/8ZAcK3DqgcPle9dOfn56FUKiGXy1FRUeFVQro/bFmA9QmZWq1GU1MT4uPjkZeX59UJvVEhXbPZjKamJiwvL6Ours7rJzq21u9oXNs1164yXHUX1M3z1KlTyCopc7jN23/7M67+9vfWvC5iuX3Zm39+FDuuugmhX7YsW+944vF4KKzdhsLabRjpbseB554BLygIZ115A+sFHu4YRq+GfmkR/Uc/xc2XXoiMjAxMTk6ysDLPIBAIoFAooFAoQJIkjh49Sne/6e3thVgspm/+4eEb00OWq4SPa2sCPC8m4fF4CAsLQ1hYGK3+UeH/7u5umEymNeF/b8H1kG7AlsUxAoTPBVwpb1T4MDs7G6mpqV5fODZS4SNJEiMjI+jp6UFeXh6Sk5N9Gt/fhG911w9fCIK/FD69Xo+GhgaIxWKf1kwdb/f/8Me459Fn1rzf26JEVknpGjNYgiBoaxY28NkbLyO/sgYxKalfrdXNG0RKbiFScguhnp7A56/+C7olLbZfezPELOXhBAV5VqE72tmGUK0aD9x7F/27ca1AglKrY2NjIZfLYbFYoNFo/Gb67AxcJFdcDen6WkwiFArtHgAcqX/UMSCXyz1S/7gc0l1tCh0gfF8hQPhcQCAQOJTWKZ+0mZkZr8KHjubx1iPP03lsCZ/VakVHRwdUKpVXIcXV8Dfho6qIPSl08GR8pmBL+DQaDZRKJRISEpCXl+fzmnk8HsJjEyB14CV3/OD7tA2LLQbam5GYkeXTvM7QeeoYBAIBcivtTZf5PM9uEFGxCdh5w15WCzw001MIc7MfsMViRudnB3FOXRXqavwXcvYF1LElFAoRExNDmz5rtVqoVCpMTEygu7sbEomEcdNnR+Ai4eNqSJdJr7vV6p9t+L+np8dO/YuMjFxT/LMaXA7pUub51L07ULTxFQKEbx3weDz6KcH2ADcajVAqlQBWmtgzkRvjjWWKt/NQF5LVn2M9vzd34S/jZdsuFJ5UEbs7PtOgxh0bG0NnZ6fPSqotDn32GQpWdbQAgE/ffBV1uy9weOFuPPwpdl99EyPz20IzM43uU8dw0be+veY9b28Qjgo8cmu2IJeBAo/OE/VILShwuZ16fAxz3c347jduhEwm83lef8CZ6sjj8SCVSiGVSu1Mn9VqNZqbmxkxfV5vTVwjfFxX+NggVqvD/waDgbb+6e/vR3BwMP37O1L/uBzSpe4/AR++tQgQPhewJXxBQUH0RTEmJgb5+fmMkTPbedgkfBQhm5ubQ1NTExQKBQoKChj9HGwrfFQVsVqt9riK2BV8ad3mCiRJoqurixFF2BYffHII//OXl+xeIwgCsxNj2H751Q730c0vOFQEfYHFYsEH/3gKV977I4fv8/m+3VRtCzzajx3G2089hpj0DJ8KPGZGB1GxfafT90mSRM+xwyiMj8Jt377L63k2Cu4QGVvTZ5Iksbi4CJVK5bPpsyNwkVxxWeHzh10Mj8eji3+Sk5Pp+4NGo0Fvby+MRuOa3D8uh3Qpwmcb0g0QvhUECJ8L8Hg8uj/s1NQUent7GVVnKNh65LEJgUAAlUqF6elp5OTkICUlhdELCtshXYvFArPZDJ1Ox5gqaQt3bF88hcViQXt7OwCgtraW0fACQRBIyMxdk4/3+lOPYefVzjtusNHW7JVHf4UL9t4FoRNFyN0cPlfg8XgoqjsNRXWn+VzgERQUBIGTfXSLixg4+gn2XHEp0tNSHW7DZXijpvF4PISHhyM8PHxd02cq9OdN7inXCB8XSSiwcSqarfoHgM7902g0tPVPcHAweDweLBYLp7rmAF9F46g0GoPBEAjpfglu/VIcBZ/PR1dXF7RaLaqqqhAREcH4HFT4mE3CRxAEdDod5ufnGVeZKFCEiY2L1cLCApqbmwEA1dXVrDxhMq3wUd0+qIsi09YYP/yfn6Di9O12ry2oVQiTRSAyxrm7vIjhJ953/vIEtl14OaQRzvPheHzmfy9fCzxCnDwwDLc3Q6JfwM/uv8ft44xrpIGJBxdnps8DAwNob29f1/TZ2Zq4+D1xbU0Ad5TH1erf/Pw8BgcHodVqcfjwYbvcv7CwsA3/Lm3VR5PJBIvFEiB8XyJA+NYBj8eDXq+H1WqFyWTC5s2bWa1mYzP/jfIJtFgsSE1NZYXsAez1o52cnERbWxtSUlIwODjIWjiBSYVvfn4ejY2NiI2NRVZWFj799FPG1cNPj9TjxzfZhxrf/vtTuPbeHzjdx2Kx0FYpTKD+/beRlluA5Jz8dbdj80ZgV+Bx4B2optwr8BAG25/PFrMZnZ9/iPO21KKm6mLW1usvMK3e25o+2+Z9UcrPenlfADfJFVfz0bi4LkrhnZ+fp82fqfzPgYEBBAUF2R0DG6H+re6jCyBQpfslAoRvHczOzqKhoQFCoRDZ2dmsWxewlf+2sLAApVKJiIgIhISEsHoRsS0+YQIkSaKvrw/Dw8PYtGkTZDIZBgcHWbsYMhWSptrrUXY9FJFn8vfVarVIzsm3C0l2K08ht7QSwSHOQ91dDceRkp3HyBoGO1qhX5xH7TkXutzW7MLPkgmIpVKccbl7HTyMeh1CxF/dCGZHh7HQ24bv3XITpB72+OWaLQvA/ppCQ0ORlJS0xvSZqvp01O+Vi4SPi2sCuBtqBr5S0VYbf8/Pz0Oj0dBt/8LDw+ljwF/q32rTZSBA+CgECN86EAqFKCgowPDwsF/aFLER0qWIR2ZmJtLT09HR0cF6UQXADLGxWCxobW3F4uIiampqIJVKYTKZALB3M/M1pGtLUG3b61HfC5Pr/sat30LtJdfavXbykwMObVhs0Xz0MC6+5Xaf51+an8PxD9/Dlfc4VxNt4S+vN8BRB48nIU9MQt3ur4hpx8ljiE3PBEmS6K7/DMVJsbjja1iYsR78RRhWV31SeV+2/V6joqJgtVo5R465EjpdDS4qfBQc9WO3ze9crQAPDg4iKCiIrv72Nv/T3bXZFmyIRCLOfo/+RoDwrYPIyEhIpVKMjY257LbBBJgkfARBoKenB2NjY2uIB5t5glRVma+ET6/Xo7GxEcHBwairq0Nw8Io5ri2hZCOs60tIl6oeXlhYoAkqBdsWaExhdFqF60or6b8/eeNlbDn3Ipc3+WW9DmKJZwrWahAEgTf//Ciuuu9HbpMKpoo2PMF6HTxGuzuQeO5FaD/wNm656nKkpDBbiLXR2Chi5ajjAxX2IwgCjY2NNDHwp+mzM3BVSeMy4XNnbasV4IWFBbv8T7bUv9UKnzu5pf8tCBA+N+CvLhhMzWMymdDc3Ey3GbOVswUCAcxms89zrAdfw6KUMbGjFm9MKoiO4O3aKU9DPp9vR1ApUBccptY9MDCA1PwielyLxQL11CR2XHGdy31DQn0v2Hj9j7/H+bfcvm7oeDV4vI29ea0u8OhtbUJdSQEe8KAwYz1w8abChTXZmj5PTU2hsLAQOp2ONn0OCwtDVFQUFAoFq6bPzhBQ+DyHpw/cAoFgTf4n9RAwNDQEoVDImPpnu7aAB589AoTPDWxk2zNPsbS0hMbGRkilUoctu/zRs9eXOahWdbm5uUhJWZtwzzRxcjS+p2MvLCzQqkVRUZHTizSTBSHfuO12XPndn9F/v/H049h59Y1u7Rvmo3HwwRf/joqzdkEe7bwKeDUIggB89OFjClGxCQgSiRGfkIhbb7pho5fDGrgWOqUgkUgQHR2NtLS0NabPAOzUPyZNn52Byzl8XCZ8vqwtNDQUiYmJSExMtKv+HhwcRHt7u0/ej7ZFGwaDgROVw1xBgPC5AaFQ+LVQ+KamptDa2or09HRkZmY6PMjZNkb2dg6CINDV1YXJyUlUVFQgMtKxvQfli8imwufJjZL6zqkcyfUuLEz26SWEIiR92RptQa2CVB6JyJhYl/uZjEaEybw3qlYeOgh5dCzSizZ5tJ/JqIfAw561bOHTf/8TsalpUMTFQaPROD3W/j+ASzc6quWV7ZocmT6r1Wra9FkqldLqn6+mz87A1ZAuV5VHgNnWarbV38BKtMSZ96NcLnf5ELA6hy+g8H2FAOFbB9RFgOshXZIk0dvbi+HhYZSUlCA21vmN318KnyeEbHUI2tUJyjbhc2dskiQxMDCAgYEBl985BaYI30cff4KsklL677ef/TOuve+Hbu3bUv8F0nJdtxJzhMnhQUwPD2LXjXs93ndRo4FEuvEtyT5+5TkkpGUip6IGM2Oj6Orpweba2o1eFivgqsLnjFzZmj5nZGTYmT6PjIwwYvrsCFwlVv+fFb71IBKJ7NQ/KvfPXfVvdQ5foEL3KwQInxvwR94bNY+nRMZsNqOlpYXuPOHKYNIfCp8nhEyr1aKxsRESicRhCNrX8T2FO6SMIAi0tbVBo9GgpqbG7d6qTK37xz//X9z5uycAAF2NJ5BXXuV2Ll1nwzFccft9Hs9p1Ovx2esv4opvu0csV2NpYR7B4o298H700j+QlJmN7PJqAIAiPgE9TV8wQvi+buRqI0B9R+6uabXps6Okf4VC4bbpszNwVeHj6roA9nu+U+Dz+ZDL5ZDL5cjKyqLVP41GQ6t/trl/QUFBdmsLKHz24ObjA8fAVYVPq9Xi2LFjIEnSLbIHcCuHb3Z2FseOHUNcXBzKysrcfmLfSIXPZDLhxIkT0Ol0qK2tdZvsAcwofARBQBYdC3n0iqJ46tOPUHP2uW7vbzGZ17RhcwevP/F7XHjrPV4/1WsXFhgpFvEWB196FklZOTTZAwC+QACDif3q+40C13LTPCV8tqBu/FlZWaitrUVtbS1iYmIwNzeHkydPor6+Ht3d3VCpVB5f3wIKn+dgMqTrCSj1r7i4GNu2bUNhYSGCg4MxPDyML774Ag0NDZifn0dnZyesVqvHRRt/+tOfkJaWBpFIhJqaGpw4cWLd7V999VXk5eVBJBKhuLgY77//vt37JEnigQceQHx8PEJDQ7Fjxw709vZ69dmZQEDhWwcbEdJ1V0mcmZlBS0sLkpOTkZOT4/ZFlAs5fCRJYmhoCH19fSgqKkJ8fLxH47Ot8DkbmyqICQ8PR3FxscdPuEzY1fzxyT8jv3JFkfro1Rex5TzXNiy2CAr2PI/ujScfxY6rb/KpO4ducQHhkex0d3GF9597Bml5Bch2ZL5sYf+83ghwUXH0hfCtxmrLDyrpfz3TZ2fgqpLGZcLHhbXZqn8A6BSA5uZm7N27F8HBwVAoFIiOjoZarXbZXeqVV17B/fffj6eeego1NTXYt28fdu3ahe7ubsTExKzZ/ujRo7jmmmvw61//Gueffz5efPFFXHzxxWhsbERRUREA4He/+x0ef/xxPPfcc0hPT8dPf/pT7Nq1Cx0dHYz3gXcH3DyaOAahUMgZHz6SJNHf34/m5mYUFhYiNzfXo4vVRufwUV51Q0NDqK6u9pjsuRrfVzgr2pidncXx48eRkJCATZs2eRXOYKJK9/mXVrz2LBYL5mankVlY4tH+Yg87SHz2+ssorK5DTHKqR/uthlG35JWy6CsO/OuvyCoqQW5FjcP39WbmzmsukgYurYlJwmcLKrcvJycHdXV1qKqqglwupyMIx44dQ29vLzQajcPrRkDh8xz+Cul6AioFIDExEUePHsUzzzyD0NBQ9PT0IDY2FnV1dXjwwQdx8uRJh8fBI488gr1792LPnj0oKCjAU089BbFYjGeffdbhfI899hh2796N733ve8jPz8dDDz2E8vJyPPHESroNSZLYt28ffvKTn+Ciiy5CSUkJnn/+eUxMTOCtt95i86twCm4eTRwCj8fjjC2LxWJBU1MTRkdHUVNT4xVZ8sdncUbIjEYjHQ6tq6tDeLh31aL+DOlSamRTUxMKCwuRnZ3t9Q3L15Cu0WhETGoGxBIpXnvyUbdtWCjotYuIUES7vX3HyXoIg4TIcUKWPMGyTocQkX8J3/5//gXp+cXI3FThdBu9yYIvvvgC/f39WFhY4KQy5g24+DnYIny2oEyfU1JSUFZWhm3btiEzMxMWiwUdHR04fPgwWltbMTExgeXlZQABhc8bbFRI1x1YrVaIRCLs3r0bNTU1uPHGGzE6Oopbb70VbW1tOPvss3HZZZfZ7WMymdDQ0IAdO3bQr/H5fOzYsQP19fUO56mvr7fbHgB27dpFbz84OIipqSm7bcLDw1FTU+N0TLYRCOm6AS7k8Nl2nti8efMaY19P5tiIog1br7rCwkKfng6ZtDdZb2yCINDR0YGZmRlUVVUhIiLC57F9+e6/+6Mfo3TLGZhXzSAiOgby6LVhhvWg/PwQ0vOL3dpWPTWJnsYTuOjWe7xZ6hosG3QI9qPC9/5zTyO7pAwZxWXrbhebnglghUw3NzeDx+MhMjISCoWCTgL/OoNLRMYfhG81hEIhoqOjER0dDZIkodVqoVarMTk5SZs+kyQJmUzGyZxHrqloFLhORm2LNmJjYxEfH489e/Zgz549sFgsmJ2dtduHyv1c7bYQGxuLrq4uh/NMTU053H5qaop+n3rN2Tb+RoDwuYGNJnwqlQrNzc1ISEhAbm6uTyfaRhRtTE5Ooq2tDVlZWUhLS/P5ouoPhc9kMqGpqQlmsxl1dXUu84DcHdsXonr8lBI/uvV+vLDvt7j+/h95vH9/axOqztrpcjuzyYT9zz+DK+/1fA5nMBr0HnXl8AXvPfskcjZVuCR7ABCbnIbJwXZs3bqV9oFTqVQYGhpCR0cHY5Wg/sZGkCtX2Og18Xg8SKVSSKVSpKWlwWw201W/09PTmJ2dtbN98fahmilwlVRRfopcJaOrCd9qWxahUOhVdOz/AwKEzwX8GdJdrb6RJInh4WH09vYiPz8fSUlJjM/BBqg5KH/AkZERu36+voJtwmcymXDs2DFIJBKUl5cz5vflizI5MTGBxKwc9DQ1oqCyBkHBnvcfJQjCraKN1x7/LS689R4IGVS3+OD55eb1wXNPI7+iBmlu5jaKxGGYWFiEyWQCj8eDRCKBVCpFZmYmjEYjVCoVTQqoJHDKANb283AthMq19QDcqxoOCgpCXFwcZmdnIZPJEBERAbVajdHRUTvT56ioKEilUr+vnauhZupeyEUyCqwlfO64VygUCggEAkxPT9u9Pj09jbg4xx2F4uLi1t2e+v/09LQdwZyenkZpaanbn4dJcPMX4xgEAoHfizao4obBwUFUVVUxQvaAr1QmNkkfn8+HxWKBUqnE1NQUamtrGSN71PhsrV+v10OtViM2NtYjqxh34EtI9677v4Py07ej8fOPUb19t1djBIW4Jnvv/e1JbLv4SkjCI7yawxl4frg5/OfZPyO3rMptskdh2fpVArrVaoXFYoHJZIJQKKSLdLZt24acnBy6I4yjXDAugkuEgWuEjwKlVlGGz1VVVdi8eTMSEhKg1WqhVCpx5MgRdHZ2YmZmxi/3AoC7Ch91DePi2gD7ghK9Xu9WdCY4OBgVFRX4+OOP7cb5+OOPUVdX53Cfuro6u+0B4ODBg/T26enpiIuLs9tmcXERx48fdzom2wgofG6AImJsX7CoeQwGA5RKJfh8Purq6hgt36ZOBDYvJlarFTMzM5DJZKitrWU8NMIW4RsdHcXY2BgkEglyc3MZH9+XkO7wxBQSxkew9bxLvD4GRS6Mj+s/eBupuQVIzMzxavz1IGD55vDes0+isLoOKXlFHu87o5lDe3u7Xf9WgiDo/wD79k88Ho/OBZuYmEB3dzeCg4PB5/OxuLi4IWrQagQUPvfhSElzZvpMdXsIDw+nW76xFeoPED7vYFtQ4q7CBwD3338/brrpJlRWVqK6uhr79u2DTqfDnj17AAA33ngjEhMT8etf/xoA8O1vfxunn346/vCHP+C8887Dyy+/jFOnTuGZZ54BsPKwde+99+IXv/gFsrOzaVuWhIQEXHzxxcx/cDcQIHxugFJ52C5Fp3z46uvrERMTg4KCAsZPKmo8q9XKqHpFQaPRYHJyEmKxGBUVFaxcFJgmfCRJoqurCxMTE0hNTcXS0hJjY9vC25DuyZOnkJKdjwWNGhmF7hVdrMa8WoXIGMehCQAYaG+BcWkRtbsv9Gp8VxAI2LvUvPe3P6GwdgtScgu92j8kTIKIiAjMzMygp6cHYWFhdOhWIpHQOUuUssPj8SAWixEWFoa0tDSYTCb09vZifn4eSqWStglRKBSQy+WsnGfugksEi6uEz9W6Vnd7MBgMdMu3wcFBBAcH2/V6ZeoewVXCRxEqrv6Wq1uruWu8fNVVV2F2dhYPPPAApqamUFpaiv3799NFFyMjI3a/x+bNm/Hiiy/iJz/5CX784x8jOzsbb731Fu3BBwDf//73odPpcOutt2J+fh5bt27F/v37N8SDDwgQPpegcvgA+9wANjA9PQ2LxYKCggIkJyezckJRBywbCtnIyAi6u7uhUCggFApZu1gxSfgoqxuDwYC6ujrMzc1hcXGRkbFXw9t13/7te6FITsdlt3lfMav8/BNklzguYlian0PjJ/tx6Z3f9Xp8l2Dp3vDuX59Acd02JHvZHxgAxHIFRCIRKisr6UR+lUqFlpYWAKDJX0REBJ2fapvTy+fzIZVKQRAECgsLsbCwAJVKhf7+fhgMBkRERNgVfvgDAYXPfXhKrFyZPkdERNCE35diL64SPq6uC/jqviYQCECSJAwGg9sKHwDcdddduOuuuxy+d+jQoTWvXXHFFbjiiiucjsfj8fDggw/iwQcfdHsNbCJA+NyArSrGBij7DyoBlC2yB6wcgExX6lJ5TZOTk6ioqMDCwgIWFhYYG381mCJ8lNWNSCRCbW0tgoKCsLCwsKF9eh3BwuMhPb/QIw+91Rju6sC28y5e8zpBEHjnmcdx+T3fZ/VmzMYN4t2//hElm09HUk6+T+NEp6ShvbML8fHxdCJ/XFwcSJLEwsICZmdnMTQ0BJ1OR9/Mo6KiIBKJaPXPYDDQIWCZTIbw8HBkZ2fTOaEqlQp9fX0IDQ2lyV94eDjrN04uESyuEj5f1kWpuVFRUU5/b+r9iIgIj35vrhIrLpouU7AlfIDjKt3/ZgQInxtgs1LXaDSiqakJBEGgsrIS9fX1fskVZIrUUPYlJpMJdXV1EIvFWFpaYr0oxNfx5+bm0NjYiPj4eOTl5dEXVn95/LmLtrY2CAVB2HnNTT7NTQIQOAgtvv7H3+Ocm29l3TKFz/AN4p2//BGbtp6BpOw8n8eKUMRgqLF7zes8Hg8RERGIiIhAdnY2DAYDVCoVVCoVBgYGEBISAoVCAYvFgunpaRQXF9sVRPF4PISEhCAxMRHJycmwWCzQaDRQq9Voa7ECXzYAAPIbSURBVGsDSZJ2nn9M5roGFD73wVSnDcr0mTJ+tlgsmJubg1qtRmdnJywWC93yTaFQICRk/Up7rnYA4brpMgC7HL4A4fsKAcLnAtQFio32alTOD2VGTF2k2T6hmFL4tFotGhsb19iXsO315+v44+Pj6OjoQG5uLlJSUtaMvRF9ep3h+j234Lw9t3nVA9cWcgem0e8/9xeUn7UT8mjnuX1Mgc9j7nh++5nHUXbaWUjMYqawhsfjwehGi7XQ0FAkJycjOTkZVqsVarUafX190Ol0EAgEmJychMlkQlRUlNPQr0KhQExMDEiSxNLSElQqFW0DIpPJaDIQFhbGCDniEsHiKuFjy/7Emenz1NQUnStKqX8ymWzNNZ/LCh8X1wXY5xdardYA4VuFAOFzE0wrfBTpsDUjtiV8bDr8M6HwzczMoKWlBampqcjKyrK7YLJJmqjxzWazx/uRJImenh6Mjo6irKwMCoVizTa+dsNYD55W6S4tLQECIQbampBVWoHo+ESv55asamPX+OmHiElIREZRqddjegIen5kb6ltP70PFGTuRkJnNyHgUjBbPf/PJyUmQJIktW7bAarVidnYWExMT6Orqgkwmo0O3oaGhDgs/wsLCIJFIkJGRQTd+p0yfg4KC7Dz/PA2hbbTJsSNwlfD5Q0lzZPpMqb2tra202ksRwODgYM768HGd8NmGcwEECJ8NAoTPTTBF+AiCQHd3NyYmJtaQDjby6xzBlzlIksTg4CD6+/tRVFTk0LGcbXNnbwilxWJBa2srlpaWUFtb6zSR19duGOvBk5Du7OwsmpubEREdg6vu/SGOv/82Ph3oRcWOc5DpRgcJu7EmxxFuk/83PtiPmdEh7Lphr0fj+AI+3/eQ7lt/fhSVO3YjPj2LgRXZw2hx/3wwm81oamoCSZKoqqqiQ7FSqdSOvFG5f0Kh0K7wg3qosD0HBQIB4uLikJCQ4LAQQC6X02O4U+EXCOm6j40gVkFBQYiNjUVsbCzd4UWtVmNsbIxWe81mM130w6Xvje3iRV8QIHzrI0D43AQThM9Rvhsb87iCt4TMarWivb0dGo0G1dXVCF+lGlHwh8LnyfhGoxENDQ0ICgpy6QvIhZAuVe1MhfmDgkOw9eIrQRAEmg4dxEt/+AWySitR5aYBc8sXh1BYvRkAYNTrcfjNl3HFt3/o02fxGD7esN788yOoPvtcxKVlMrQgexCCYOh0Opc3B6PRiMbGRoSGhqKkpMThjW+1h9vc3BxUKhV6e3uxvLxsp+Q48/yjbECoQgCVSrUmFKhQKCCTyZySAS6RBIC7hG+jc+V4PB7Cw8Np4+fl5WVoNBp0dXWht7cXAwMDdrmeG2nzA3Bb4bMtKNHpdODz+RtmgcJFBAifC1AXKF+J2OLiIhobGxEeHr5uuy6uKnxGoxFKpRLAisP4egnHbBM+T5SyhYUFNDY2Ijo62i1fQzYVPldj2/oBVlZWYnp6GiGhYrv9y8/ahfKzdqGn8QTeevIRSKOiceYV1637uWbHhhF9yVUAVoo0Lr3rO36/YPsy35tP/gHVO89HXFoGgyuyR2RSCrp7elFeVup0GypnVaFQ2BX6rAc+n0+Tu5ycHOj1eszOznrk+ScSiZCcnIzU1FTaNkatVqO5uRk8Ho8ePyoqir6uBBQ+98G1dYWEhCA+Ph7d3d0oLy+HxWJxaPocFRXFWK6nJ+Ay4bPNfzcYDBvy/XAZAcLnJnxprzY5OYm2tjZkZGQgIyNj3QPQX71uPSF8FGmiiktcyfn+KNpw5zuivvfs7Gykpqa6deKzmcO33tgWiwUtLS3QarWoqamBWCzG08/+HbIIucPtc8qrkVNejcmBPrz/tz/BSgLn3vwth8UdIpEIfD4fb/z5EZx93c0uO26wAQLeEZDXn3gYtedcgLhU9sgeAMQkJaOjq8Ep4Zubm0NTUxNSUlJcnsPOYFvFSeVxeeP5FxMTg7i4OBAEgcXFRTrvr6OjA+Hh4XTRB9fANWJFgau5ciRJQigUQiqV2pk+U7l/g4ODPud6eoOvS0iXMl3m4m+7UQgQPjchFAo9JjG2RQKbNm1CTEyMy324FtKdmJhAe3u7XXEJk+N7A1eEjyRJ9Pf3Y3Bw0O3v3d2xfYEzIkyFCYVCIWpqauhjQNnSBll07Lpjxmdk4YJb78G8agYfv/R3LC3MY/eNt0JqQxRFolB8+vqLKKzegujElHVGYw8E4Tnhe/2J36Pu3IsQm5LOworsIQwKhsbguCfu9PQ02trakJuby1hPawBee/7Zqn9SqRQymWxNB4j+/n76+qNQKDz2gGMDXCV8Gx3SdQSCIByuKzQ0FImJiUhMTLTL9aTSBWyPGbZMvrmu8Nnm8PnL6PzrggDhcwFvQ7pmsxnNzc0wGAzrFgmshj8InzsKHEmS6O3txcjICEpLSxEd7b7p70bm8FmtVrS1tWFubg61tbWQSqUejc22wrc61EaF+iMjI+mcPeqCarQQCHOTJ0UoYnDOzbfBoNPh2H/exPToME679GrEp2VgfHgIeWWVyCmvZuFTuQdPPeZe++PvseWCSxCTlMrSitbC4EDBHxkZQV9fH0pKSjw6BzyFO55/0dHRiIqKonv12qp/PB4PwcHBSEhIQFJSEhYWFqBUKmlTd6vVSucOKhQKxvtbuwOuEj4uKnzUdWI9YmVr+kyZfzNl+rweuEz4VufwBRQ+ewQIn5vwhIhRuT5hYWF0Bwc25vEWrhQ42/CiJ2SVwkYRvuXlZTQ2NoLH47nMM1xvbEpJYfpCsZrwzczMoLm5GRkZGUhPT6cT9/l8PgwGA4LFYR4XO4SGheHMK6+HxWzGqYPv4+2//hGElUTd+Zcy+lk8hScC32uP/w5bL7wM0Un+VSNtrVlIkkRfXx/Gx8dRXl6OCAc+hmxiteefRqPB7OwsOjo6YLFY7PL2HIV+gZXjLS8vj/aAU6lUtG2MVCqlQ4EUgWQbXCR81LnONQJja97tDqj+zmKxmDb5dmb67G6l93pr43JI19Z0OaDw2SNA+NyEQCDA8rLjkI8tpqenaX+67Oxsjy9wG120QbUbCwkJcVnRut74VEiCrX7AqwkfpZTJ5XIUFRV5fUGi1svG2m3XPTw8jJ6eHhQVFSEuLg5Wq5UmewsLC2hqaoIsSoEgL/3rhEFBqD33InQ3n4JBb8CbT/4B4VHRKD1zJyJj2DdatoVRr0ewmzeYVx//LbZddAWiE5NZXtVaLFtXSBOPx0NHRwfm5uZQVVW14flwAoFgjYGvK88/jUYDgUAAk8lEk4HU1FSkp6fDZDLRStDIyAitFCkUCsjlctaqQLlK+ADuVTTbVmx7g9WmzzqdzmGltzPT5/VgtVo3vFLYGVbn8G30ucs1cPNX4yBcFW3Y5o0VFxcjLs67m6q/FD5Hc6jVajQ1Na1pN+YpqP38RfhslTJvE+ptxwbYqXKkwnAdHR2YmppCZWUlwsPD7cje9PQ0Ojo6wOPxkJiZjZmBPq/nIwgCiph4iMLCcOYV18NkNOLjf/8TJr0OkfEJKDtjJ8Jkjq11mIR2cR6hYa5V4n8/9hucfslVUCQwlyfnCSTRcRgcHMTi4iKWl5dRVVXFOUsHWwNfZ55/ISEh0Gq1KC4udlr4ERsbi/j4eBAEQeeB9fX1wWg02rX/Cg0NZWztXCZ8XFX4mGr5JpFIIJFI3DZ9drU2rn1fFGzVx4DCtxYBwucC7uTwUSFQytTX07wxW/grh89kMtm9Rnm/5eXlITnZN3WFOuHYahFnqyAODQ2hr6/PJ5K9emyAnbAFSZKYm5ujizNCQ0PtcrAGBwcxPDyMkpISPPP3vyPzjPMxO9jv9Xyfv/VvbDptO9rrPwcABItEOOfGFbPlxTkNDr70HIQCPuJSM1By2lms9dPVLsxDFOr8wksQBF5+9Fc46/JrN4zsAUBMchre+2A/tm2uQ2VlJavdbpiCreef1WpFa2sr1Go1goKC0Nra6pbnX3h4OJ07SHn+UXlgYrGY3j88PNyn85nLhI9r62KTVK02faZa/NmaPlO/uaNwP9dDutR5S9myBPAVAoTPDfB4PKdETKfTQalUIiQkBHV1dT4nQ/vLloWagyAIdHV1YXJyEhUVFYiMjPR5fFvSxAaokHRbWxtUKtW6JtDejA0wv3aj0YiRkREQBIGampo1YfXOzk6o1WpUVlZCKpVC2dqBTVfcAvhwH1KPj+D0S65Cy+cfrXlPJo/EJbd9GwAwOTyId//yBMRhYUjOK0RB9RbwGbyga+fnEeTkSZsgCLz62G+w46rrERXnfes4JiAJj8DosgllZWWcVTCcgSAItLe3Q6fTYfPmzRCJRG57/tnmi4WEhCApKQkpKSmwWCzQaDRQqVRoa2sDSZJ2uYOeEmIuEj5Pc+X8BX+paDweDzKZDDKZDBkZGXS4X61WY3R01M7nMTIykn5o4Or5YSsyBEK6axEgfG7CkS0L1f4qKSkJOTk5jJwE/qzSpTp/mM1mp50/vAF18WSL8FmtVpjNZiwtLaGuro7RsJttDh9ToHwMQ0NDIRQKaYWSz+fDYrGgubkZFosF1dXV9Gexgu/TTWh6dBgJmTkAANOycd1t41PTcfnd3wMA9DQ14I0//QHSiAhkl9cgvbDE55uhbnEBMQ5y8giCwL/3/Rrbr7wBkXFrW/RtBKTyKM7ezJyBijCYTCa7Vm/uev7J5XL6mFwd+lUoFIiJibFr/zUyMmKnBFG+f66OEy4SPq6GdDeqkCQ4OBjx8fF0uH9hYQFqtdrO59FoNEImk3Hy9wzYsqyPAOFzE7ZEzLafbGFhIRISEhidZ3W4lWlQc9TX10Mmk63b+cMbsNkTWKvV0nknlGcdk+DxeIxas1D5hZmZmRAKhRgfH4fFYoFQKITBYIBSqURYWBjKysrsPkvYl1Wh3l5QP3v9JVx8+70AgOVl94+nnNIK5JRWAABOfrIfyic+hCwyEsVbz0Jcqnd+eHrtIoJX5YIRBIFX9/0a26+6EZGx/i0iWQ+e9NTlAkwmE5RKJYRCISorK52ex+t5/rW3t7vl+SeRSOjcQaPRSCtBQ0NDCA4OpskfZRq9GlwkCP/tCt96sG3xl5WVRf/m/f39GBoawsTEhJ36x4Uw72rCx6aV0tcRAcLnJijCZ+vzxmQocfU8bEKr1WJ+fh6ZmZnIyspi5WLHRmiaUlTj4+MxOjrK2gWGCcJHkiSGh4fR29uL4uJixMbGQqPRwGg04vDhw5DJZFhcXERcXBzy8/PtfgOCIBAWLv9yHM/nJggCkvBwBAWv2NKEhIqhW1pEmFTm0ThVZ+1G1Vm7YbFY8Plbr6D+P29AHh2L0jN3IkLhvpn1sk5nl8NHEAReefRXOPuamyGPWd9Y2t/4OhE+2wcGTyrTmfD8CwoKQnx8vJ0BsEqlQnd3N0wmk53nH2WPxEXCx0VLFoAbhG81RCIREhMTMT4+jrS0NAgEAofFPmyaPrvCah++tLS0DVkHVxEgfG6AyuGzWCw4duwYhEKh1z5vrsCmLQulTI6OjiI0NBTZ2dmszAMw78VH2ZgUFhZCLpdjdHSU1SpgX0K6BEGgs7MT09PTqKqqgkwmg9VqhVQqxdatWzE8PIz+/n4EBwdjYmICOp2OtlAICwtDe3s7Er8Mx3rz8T5+5XmUn7mL/js+KxezY6MIyy/06vMIhUKcdfl1AACDToePXn4ey3otopNSUbljN8SS9YuUlvU62paFIAi8su9X2HntzYhw0UVkIyAIlUCj0TCSy8ombPv6rn5g8BS+ev5RShBlAKzT6aBWq+0sQBQKBeuRC2/ARdNlgLvrAr6yZaFIPbCiplGKb19fH0QikZ3i6y/yGvDhWx8BwucmlpaWYDabfbYscQW2FD5bZTInJwdjY2OMz2ELpggfVVRC2ZjI5XLaD9GfPn/uwmKxoKmpCUajEbW1tRCJRHbKyPDwMIaGhlBaWgqFQgGj0YjZ2VnMzs7S7vivvP4Gaq69FV/u5PEatBo1Ym3Cr7llleg8/gXSvCR8tggNC8MFt9wOAJibncH+5/+KkJBgxKdnomTbWRAGrS1aWjYaEBwiWiF7j/wSO6//hkcKoT8RlZyGru5ubK6r2+ilOAXVRSMpKQmZmZmMngPeeP6tDv1SBDI1NZXOHaSsYwCgo6MDCoUCkZGRG+7nxkXVEeCmwkfBUZWuv0yfXWF1SDdQtGGPAOFzA0NDQ+jq6gIAn5+mXYENwmc0GqFUKukOFFqtlvVKYCaUSrPZjKamJiwvL6Ouro72BLOtpGXjouioBZo7MBgMaGhoQEhICKqrq11W4gIrYRJKXbFYLCs5MsMj2KVYyT0xm80erWG0rxtJ2fl2r4VHRkG/MO/x53EFeXQMLrvzfgDAWH8v3n76cYjDwpBauAl5lbVf/TYEAR6fj1ce+SV2XX8LwhXczatRxMWjp6Wes4SPKrrIyspCSgq7nUjc8fyjyF9ERMSa0C+wcq7GxMQgLi4O/f390Gq1CA4OxuDgoF3uoEKh2BA1JhDS9Ryu1ubI9NlW8aWsfhQKhcemz65gS/gCtixrESB8boAkSZSVlaGhoYF1l3Gmc9+oCtGoqCgUFRWBz+dDr9f7pRLYl8+h0+nQ2NgIsViM2tpau+/cH7Yvno5Nfc8xMTF0OytXlbirIRQKERsbi5AwGf1Q4enF8Oh7b+DSO76z5nULy+G0pMxsutK348RRvPHEw5BGRCCvejNIYIXs3fBNhEcpWF2Hr+ALBNCbPCPZ/sLk5CQ6OjpQUFCA+Hj/VzXbev4RBIG5uTmoVCr09vZieXl5jecfdQ7YWkCFhIQgIyMDWVlZdr1f+/v7IRKJ7AikPwgPV0OnXCZ8nvir2po+U4qvL6bPrrDaeDlA+OwRIHxuICMjg1Za/EH4mCJjExMTaG9vR1ZWFtLS0uxMpP2h8Hk7B9XxIzExEbm5uWsuyGwTPk+LNqh2ellZWUhNTV3TE7epqQlisXhNJa4zhNn0bQ3y4FizWCwIl0dB6MAfzWL2X/5UQfVmFFRvBkEQOPHhf9B8/Cg2VddhQTUDWWQUJ2+wtjCYuVe4MTIygr6+PmzatAkKxcaTZj6fT9+kc3JyXHr+UeqgQqGAxWIBj8dDcHAwEhISkJSURIcBVSoVOjo6YLVaERkZSY/hKxFwhoDC5xlsH2S9gSPTZ7VaTZs+S6VSWv3ztMczSZI0GSVJMkD4HCBA+NwEn7/ii7ZRbc88AUmS6OnpwejoKEpLS9eUpvujX6+3pJI68fPz85GU5LjrAtPWKavhbtGGbaePkpISxMTEOOyJGx8fj5ycHLcuXrYVugDgSWD5wL/+iuqzz3f4nsmNPtBMg8/nw0pYkZqdi9MvvxYDbc1o+uwgwmThSMrOR3ZpJaMGz0xhdm4e7e3tdKXqRtpNUC0bx8bGUFFRwbgrABPg8Xjrev5ReX4SiQTJyclOCz+ioqLscgdVKhXGx8fR1dVlRwQkEgljDw1cVfi4SkSp6yIT54St6bNtj2fqgd+R6fN6oO4HtlW6Eonrlo7/TQgQPg+wkX1u3QUVPtTpdKitrXV4wFMXXDYTlj1V+EiSRHd3N8bHx1FeXk5XfzE1vidwZ2yqJ+7s7Cyqq6shlUod9sTNzs72qFVdU1MTknPy6L89+XV0CwtQJDjuVrG8vOz3BHW9dhGq0WGce8M3MdbTgYozz0bFmWcDAHqUp/DOX55AmFSKmJRU5FdvRTALVe/eIPjLLhS9vb1obW2FXC6nc5L82VuXJEl0dnZCpVKhsrLya3PzsvX802q1OHXqFN1G8OjRo3Z5eyEhIQ4LP8RiMVJTU5Genk6rg5Tps0AgoJU/X/3fuEqsuKrwUfcmNta22vSZMvqmTJ9dGX1Ta7MN6TLZC/r/AwKEzw3YhkKpixJb8EV90+v1aGxspNu8OXsiok4INnsievI5KJKq1+tRW1vrlgzPJuFzVbRBFZOYTCbU1NSsqcQdGhrC4OAgiouLPTb+fPm111F2+c0er7mvtYk2THaEMFkElubnIJP7z27knacfxwV774FILEbXySN27+WUVSKnrBIAMD7Yjw+efwahISJExMahcPPpHnsGMonIhBQIBAJs2bIFOp0Os7OzmJ6eRnd3N8LCwmjyJ5PJWCPQBEGgtbUVOp0OVVVVX8sb1+LiIhobG5GYmEj7fVKef7Ozs257/gkEAsTFxdG5g/Pz87T9x/LyMiIiIuwqhz0BVxU+Lq8LYL8zCZ/Pp70iMzMz7Yy+h4eHIRQKafVPLpfbdcKytWX5ujwk+QsBwucBHLVXYxoCgcCrPAlKBk9ISEBubu66+1Lv2VY0MQ13CZltZWttba3b/Tk3SuGjSLVIJEJ1dfWaMD9ViVtVVUVX4nqCrv4BnGFb2MBz7xho/OgDXPpl0YQjJOfmY3pkyG+E79j+d1Gy9UyIvqy8tBidt3dLTM9E4q33AADmVbP49LUXIeDxIIuMQkHdNsj97NcXk5KG1q4O5OfnrwlVUgbFjY2NdOsxpkO/tkU+lZWVrOWvsYm5uTk0NTUhPT3dzvzWG88/28IPighERkYiKyuL9n+bmZlBb2+vxxWgAVsWz0ARUX+vjTJ9TkxMXEP6jUYjIiIiIJVK6fxQk8kEs9nsdQ6fRqPB3XffjXfffRd8Ph+XXXYZHnvsMacEUqPR4Gc/+xk+/PBDjIyMIDo6GhdffDEeeughuzQMR8faSy+9hKuvvtqrdXqKAOHzAP4K6QKenfAjIyPo7u5eN+/N2RxswZ0cvrm5OSiVSsTFxXnsbbgRhG9+fh6NjY2Ii4tDbm7umkrclpYWmM3mdStxXSFIZG9N4c7NyGQ0IiI6Zl3CkV1ajsZPPkT2pnKv1uUJDDotpof6UbXjHPq1ZaPBrX0jFNE4/xsrPn9GvQ6fv/UqzHotwsLlyKuqRVxqBitrtoUoVIzZRe2a16nuElTIaX5+HrOzs4yGfk0mExobGxEcHIyKiooN96nzBlTuXk5OzrrXo9Wef0tLS1CpVB55/olEIiQlJSElJQUWiwUajQYqlYquALUlkI4eJrlMrLi4Lk8qdNkCn89HZGQkIiMjkZ2dTZP+6elpPPnkk7jnnntQW1sLAF6fP9dddx0mJydx8OBBmM1m7NmzB7feeitefPFFh9tPTExgYmICDz/8MAoKCjA8PIzbbrsNExMTeO211+y2/fvf/47du3fTf0fYFOmxja/f1WQDYBvS9Rfhc6ca2LajA2VK7A6oogc2P4srQkZVEOfk5CA1NZXx8X2Bo4KQqakptLa2Ijs7G6mpqXb5elQlbmho6Lr9TN1BWMQqBc6N4pH9//ortl54+brbiCUyLOvWkhg28PbTj+GCb95l95rJYoHFbHJozOwMInEYdl57M4AV1evYB+/gxIH3IAmPQHpRKdIKillTZ4wuKnVtbzq5ubmMhH4ptVsmk9EWSl83TE1Nob29HYWFhYiLc79Hsm0Cvy+efwqFAjExMSBJEouLi1CpVBgZGUFnZ6cdgaRywLis8HGhN+1qcJGIUqbPEokEd999N1QqFd58800AQFZWFrZv345zzz0X5557rlvelZ2dndi/fz9OnjyJysqVtJM//vGPOPfcc/Hwww8jISFhzT5FRUV4/fXX6b8zMzPxy1/+Etdffz3dO51CRESER+cGkwgQPg/gD8LnbjWwyWRCU1MTzGaznSmxu2DbmsVZDh+VDD8yMuKwgthd+KtKl2pH19/fj02bNiE6OtrnSlxnIAgCkohVpN2N4UiLxa2wpz+sWY4feA8lm0+HSGwfSknNK8bE4ABSbApSPIFQKMTWCy6l/2764lO8/fRjkIZHIC4jG7kV1RAK3UsHcAcGD3vq+hr6XVpaQmNjI2JjYx1aEX0dMDY2hp6eHpSUlPjctN4bzz9b9Y/P50MikUAqldrlgKlUKgwODiI4OJi2t+Hid00QhNvpLf4EFwkfBavVColEgu3bt6O8vBwfffQR6uvrsX//frz88su4++67kZeXh4MHD65LuOrr6xEREUGTPQDYsWMH+Hw+jh8/jksuucSt9SwsLEAmk60RAO68805885vfREZGBm677Tbs2bPHb8dggPB5AH8QPnfmoW4OMpkM5eXlXilKbFuzUGFOW1itVrS0tGBxcdFpBbEn47Ot8BEEgfb2dqhUKtTU1EAikTisxGWq68GpU6eQnJPvekMbdJw8hoySMre2Zdt82aDTYnKgF5V7717zXvHmbThx4F2vCd9qlG49E6VbzwQA9Lc2462nHkN4RAQUSSkoqN2GEJFvRQ5Gi9Vr9cfT0O/8/DyUSiVdlcpFAuIKVKFSWVmZ25EGd+Gp5x9F/qjrA4/Ho3+TxMREWK1WuvXX9PQ0nY5hWzm80eAqsWIz79tX2KqiOp0OYWFhKC4uRklJCb7//e9jfn4en3zyCWJj1384npqaQkyMfetHqnfw1NSUW2tRqVR46KGHcOutt9q9/uCDD+Kss86CWCzGhx9+iDvuuANarRb33HOPB5/UewQInwfwR5UuNY8zMjYzM4Pm5makpaXRlW/ezsG2wmc7vtFoRGNjIwQCAerq6nxORGc7h89iseDUqVMwm82ora1FSEgIY5W4zvDPl1/BlhvvsHvN1e/bduRTXH7PD9wa37TsvHCCCbz99GM4/5Y7Hb4nChWzFlLOLN6EzOJNAIDp0WEc+OffEBISjIjoWBTUnQbpatXUDYgiojA1NeVzRwtXoV+RSASj0YiUlJSvJdlb7RMok7FbXe3K8w8ATf7kcjl9nVgd+qVMnUUiEebm5iCTyejWXxKJxGvzX6YQsIvxHLb5hTqdbk3U6ze/+Q1++9vfrjtGZ2enz+tYXFzEeeedh4KCAvz85z+3e++nP/0p/e+ysjLodDr8/ve/DxA+LoE64f1RpQs4Vt9IksTAwAAGBgZQXFzscw4A2wqfLaGk2o4pFAoUFhYycsFgk/ARBIGRkRFERESgrKyM8UpcZxgYHsU5q6to17nZGHRaRMXGu31DMpnMrOUsnTz4AYpqtyE0zLlqa1qnUpcpxCan4sJbVxTGxXkNDr/1KniEFRJ5JPJrt0ERtzb/xhFiUtLQ3tnFeAszW7IyMjKCnp4eyGQyjI+PY3JykpWqX7ZAkiS6urowOzuLqqqqDelqYOv5R5IkFhYW6Lw/qlcvRQAdef5RudIpKSlIS0uDyWSiCz9szX8VCgUiIyP9VkTDVWLF1XUB9uqjoy4b3/nOd3DzzTevO0ZGRgbi4uIwMzNj9zpVEOTqvru0tITdu3dDKpXizTffdBmWr6mpwUMPPYTl5WW/KMsBwucBNiqka7Va0dbWhrm5OdTU1DDyFO0vhY8qdljd3o2J8d3phuEp5ubmMDs7C6lUirKyMrs2aUxV4jpDqCPvuXU+4v7n/4rtV93g9vgyRQzmVTOM25wY9XoMdrbisjvuX387o57ReV1BFhGJc2/+FoAVsnn4nddgWJhDWHgEcsqrkZCR7fR4DI+KxlBjF2trGxoawsDAAMrKyhAVFcVa1S9boNIdFhYWOOMTyOPxaO+27OxsO8+//v7+NZ5/FosFs7OzkMvldrl/MTExiIuLA0EQWFhYgFqtxsDAwBoCKRaLXazIe3DZh4+rDyK2azMYDBCLxXbfIXUuuUJdXR3m5+fR0NCAiooVb9NPPvkEBEGgpqbG6X6Li4vYtWsXQkJC8M4777h1zjY1NUEul/stjSBA+DyAQCCAieU8KGoeioxRoVA+n4+6ujrGDgy2FT4ej0fbLJSUlLjMm/AUbCh8VOVweHg4wsPD7cie0WiEUqlkpBLXGcIchR7XueYLBXxIPfDVSysowtTwIOOE7+2nHsW537jD5XahsggsaNQIj1y/iwobCBaJsP3K6wGA7vHb8NF+SMIjkJJfhIziUjvlgsfjwWhmPn2DJEn09fVhfHwclZWV9MObq9CvRCKh1T82DZ/dAZWLazQaUVVVxYmcN0dw5fkHrFR4pqSkOPX8o64FWVlZNIGk/N9CQ0Np9S88PJxR5YurShoXbFmcwVbho3L4vEF+fj52796NvXv34qmnnoLZbMZdd92Fq6++mq7QHR8fx/bt2/H888+juroai4uL2LlzJ/R6Pf71r39hcXERi4uLAFaIpkAgwLvvvovp6WnU1tZCJBLh4MGD+NWvfoXvfve7zHwBbiBA+NyAP21ZbOehkrmZDIXazsGWwme1WjExMQGj0Yja2lpW8nqYJHy24fLS0lKoVCosLy/T5fRUJS7lv8fGzXZ1D11XUB7+BFllVR7NkVm4CUf/8ybyK2s9XZ5TnProAxTWbIVY4jq0XVx3Osa6OxBet42x+b0Bn89H7e4L6L/bjh3BO888DqksHDFpGcivqoMwKBhGC7PnB2WjpNFoXIZAHVX9zs7Osmr47A4sFguamppAEAQqKys5WUnqCLaefwaDAadOnYJQKASPx0N9fb1bnn/BwcFITExEcnIyLBYLXTnc3t4Oq9Vq5/nna44yVwkfV9cFrM3h8yXF4IUXXsBdd92F7du308bLjz/+OP2+2WxGd3c39PqVqEVjYyOOHz8OYMUKxhaDg4NIS0tDUFAQ/vSnP+G+++4DSZLIysrCI488gr1793q9Tk8RIHwewJ+ET61W071YU1NTGScZbCl8y8vLUCqVMJvNkEgkrCVxM0X4CIJAW1sbNBoNXYlrNpvR1dWFI0eOICwsDIuLi8jMzLTrGMA0Dh8+jJTcgjWv85x02uhtOIHL7/m+R3MEi0SwMFi4YdTrMdrbiQv3updwnJyVg45jh1G4wYRvNYpqt6CodgsAYLi7A/959imIxKGYHRsFbt3DyBxWqxWtra3Q6/WoqqryKETrD8Nnd2AymaBUKhEUFISysjLOhvbWg16vR0NDA6KiopCfnw8ej+e1519UVJSdabRarcbY2Bi6uroglUrtKoc9vX5zlVhxOaS7OofPl5B7ZGSkU5NlAEhLS7NLKTrjjDNcphjt3r3bznB5IxAgfG6Cx+NBKBSyXqVLkiT0ej0MBgPKysoYqwBdDTYUvqWlJTQ0NEAulyM1NRWDg4OMjm8LJggfdQOzWq10Wzer1Yro6GgoFAp0d3djYmICwcHB6Ovrg0ajQUxMDF3dxyReeOXf2P6t76x53dFtYml+DtGJSV49BFgZ9OJ7++l9OHfP7Rs2PxtIzS1Aam4BlubnMHvqc0bGpHovkySJqqoqn1QxZ6HfqakpVkO/VGoJZXXBRTLiCjqdDg0NDYiNjbXzzPTE8y84OBgEQazx/AsLC4NEIkF6ejpNIFf3fVUoFJDL5W4RJq5W6XI9pEspq46KNgIIED6PwLbCR/XQNBqNSEpKYo3sAcwrfDMzM2hpaUFaWhoyMzOhUqn8avviKaiLv0QiQXl5+Roj566uLqjVatTU1EAqldI31snJSfoJPjo6GjExMbRrvy8Ym5p2aB/i6Jnxwxf+ht033urgHddgyouv8dMPkV9Z61Yol4352YTFbMLgFx/hge982+exlpeX6d7LJSUljKsj/gj9Uv2j5XI58vPzOXvDXw/Uw2hSUhIyMzOdnq+eev4BsMv7o4SBuLg4mkDOz89DpVKhp6cHJpMJcrmcnsNZsQuXFT4urgtY68PHZlHN1xUBwucB2CR8Op2OvjHExcWxLpsz9VlIksTw8DB6e3tRVFRE21j4w9jZW8Kn0WigVCqRmJiInJwctypxbW+sJpMJKpUKMzMzGBwcpKv/oqOjERER4dUFUewkf8/RbSkkROQx0aKwzEBI12Q0YqijFRd9y3NCZLJYYLGYGe2KwSRIkkTz/rfw4zu/5fONjSJKERERKCgoYP1GyUboV6vVoqGhAXFxcT53ktkoULZQaWlpSE9Pd3s/pjz/IiIi1vR9nZmZQW9vL8RiMT1GeHg4/f1ylVgRBMHZ/s626mNA4XMMbv5yHASPx2ON8KnVajQ1NSEhIQG5ubno6elhVR0DmAmJEgSBjo4O2ofLtgk0mz55ALzuBUxV4ubm5tLVe55W4gYHB9MhIKr6b2Zmhm7YbququHtxdFawsVrhO37gPeRXb/HkI9vBbLH47Jb/1lOPYveN3/Jq3+ScfEwODiA5O9fr+dlE26f7cdu1V/p8s1hcXIRSqdwwosRE6HdhYQFKpRLJycnIyMj4WpK9ubk5NDU1ITMz0+duOL56/vF4PIhEIiQlJSElJQVms5n2/GttbQUA2hDaarVy8vu2DZtyDbbXNYPBQLfOC+ArBAifB2Ca8JEkSZuv5ufnIykpiZ5neXmZsXkcwVeLmdW9fFcrBv7u5OEKlB3G8PAw7X1mS/YWFxfR1NTkcS9T2+o/25tAf38/2traEBkZSb/vzL6CIAjHliwAeHz7dYx2t6N653luf+7ViIpLgmZ6CtEJiV7t33joIHLLqxHmZTHOpi2n4dTBDzhJ+PoajuGcmnIkf3keeguNRoPm5makp6ezUnDlDTwN/Wo0GjQ1NTHWNnAjoFar0dzcjJycHPrayhQ88fyjCtccqX/R0dGIjY0FSZJYXFyESqXC8PAwLBYLuru76Zzh1Z5yGwWuKo+Aa+PlAAKEzyMw2VqNsmiYnp5GZWWlXf9Jf1QD+0LItFotGhsb6fw3RyoW2wqfJ+PbGldXV1ev6Yk7MzOD9vZ2n29uq28CjvL+YmJiEB0dbZf3d+DAAaQVFDsblf7X3OwMYpPTvF4fAKQVlWBmdNArwmcyGjHY1oyLb7vX6/lFYgkMukWv92cLE33dyJWHobqywqdxZmZm0NbWhtzcXCQmekeq2Yaz0G9PTw+Wl5cRFhYGrVaL7Ozsry3ZoxT3goICxrulOIIrzz9byxZnnn9SqRRSqRSZmZn45JNPEBUVhfn5eQwODiI4OHhN+HgjwOUqXdu1BQifYwQInwcQCAR0U25fTjiqOtRisaCurm5N4i7b+W++zEG1HEpOTl43VMUVwmcymdDY2AiSJO0qcQH2euJSWJ33Nzs7i9nZWQwMDNjl/b3479dwwX0/cTneRy//A+d/w3GvWneRlleIL976t1f7vvX0Puy6wXfPKH+0WPMEC6pZCGZHcdE3bvZpnPHxcXR3d6OoqGhN83WuYnXod3BwEP39/RCLxejt7bVr97bRhs/uYmpqCu3t7SguLt6Q32G16k8Z0E9MTKCrq8ul5x+FuLg4ZGRkwGq1Ym5uDmq1Gl1dXbBYLJDL5XbhY3+B61W6TPnw/X9FgPC5Car6CvDtoF9aWkJjYyNkMhkqKiocqmNcVfhGRkbQ3d2NgoICl+oF1fqMrRCAO4SPUiKlUimKi1cUtNWVuCqVyq7jAVugTFsTExPX5P2NT01DEh6x7v4kSSI0VAyRj5VnQqHQKy8+5ecfI6e0ChJZuE/zA8CygTuEz2Q0YuzEZ/jJ/d5X5JIkiaGhIQwNDaG0tBSRke53P+ESRkZGMDg4SKc8cMnw2V1QpGrTpk2cyOHi8XiQyWSQyWTIyMhwy/NvenqaJtYmk4km5QqFAjk5OdDpdDSBpPIxKdsXqVTKKin/OoV0qSrqAL5CgPB5AOpgslqtXnlpTU9Po6WlBenp6etaA/iD8Hmi8BEEga6uLkxOTq4JPzsD9V2xSfjWM7qkCmGSkpKQnZ0NkiRpos52T1xXWK0AyP/+T5f7HH7ndZRsO5OR+S1mz/JDzSYTBpobcfHt9zEyvyhMisU5DWQetIVjAyRJou3Dd/CTb9/h9U2SJEn09PRgamoKlZWVkEq9q57eSJAkicHBQQwPD6O8vJwuvnIV+qVICFd6/Y6OjqK3t5fTpNuV5x8VTs/NzYVIJFrj+cfj8RAaGoqUlBQ6ckB5/jU1NdnZykRGRjJeUcvlkO5qwseF/s5cQ4DweQAej+dVKNS2dVdxcTHi4uLW3Z7tggdP5jCbzbQ3YF1dndveRhTJY+tzrKfwjY+Po6OjA3l5eUhKSvKqEtdf4PF4kMqd95alLvQzIwPYduFljMxpXvasWOetPz+KnTd8k5G5AaBw8zaM9nSgsGYrY2N6g6YD7+Cum671mqxQVerz8/Ooqqr6Wvp+kSRJh27XI6wbZfjsLqjUDFvCynWs9vwbHh5GX18fwsLC0N3djbGxMYeef7YpKQKBALGxsTQpX1hYgEqlwsDAwJrKYSaOT64qfFQ0iUq7Cih8jhEgfG7C2366VEul+fl51NTUuBU65IrCR7UhCg0NRU1NjUeq5kYQPurmNTIygvLyckRGRjqtxM3JyeHEhctisUDipEIXWDkWZsZHEZOUxticyyb3Fb7mI4eQVVLGSCiXQmpOPrpOHt1Qwtd2+BOkR4Sht7cXc3NziI6ORmRkpNvHhNVqRUtLC4xGI6qqqvyaR8UUSJJER0cH3dvXE0LgquqX6lbDduiXepgeHR1FRUUF66kZbGFiYgIDAwN24XRvPP/Cw8Mhl8vtPP9UKhX6+voQGhpKh37Dw8O9uv5xNYePuhfY2rIEcvjWIkD4PIQnZIxqR8Tn81FXV+f2TYELOXyUOTHlDejpSc7j8bz2ynMHqwkfRawXFhZQU1ODsLAwVipxmcZbb72FtMISp+8L+HwcevUFXHSb710fKBAECbPJhCAXflpmkwm9jSdwye33MzY3PfYGFm6MdrWjOiMRO886k66m7OzshNlspvujKhQKp35jZrMZSqUSPB4PlZWVPrVK2ygQBIHW1lbodDqPe/uuxkaFflerk19XRWdsbAw9PT12oWgmPP9CQkKQmJiI5ORkWCwWaDQaqNVqtLe3gyCINS3j3AFXQ7rUfSZgvLw+AoTPQ7jbT3d+fh5KpRIKhQKFhYUeEaaNVvjGxsbQ2dmJ3Nxcn8gRm5W6tmMvLy9DqVQCAK1E2oY9hoeH6XA6m+3qvMGrb76Fy3/4C6fvEyQJiUyG4BDmbpQxyalQT00gLiVt3e3e/POj2HndNxib1xYEyz2pnUEzNQGpXo3dl1wLYEU1USgUIEkSWq0WMzMzGBkZQUdHB8LDw+lcS+rmQT3EicViFBcXc/Lm5wpWqxXNzc0wmUyorKxk1EjXX6FfkiTtiq6+rjd3Ku+wrKzMaW40U55/CoUCMTExdpXDY2NjtGUUdS6s1yqSqyFdW8JHkmSgStcJAoTPQ7hDxqgcsuzsbK+MV/1hy+JI4aMS0EdHR1FeXo6oKOe5Zd7OwRQowke1fgoPD0dRURGAjavE9QaLOgNCQp2H0prrD+Pa+/+H0TkzS8owMzK4LuFrOXoYWUWbHPb3ZQLLJhOsFgsEfsyhNOi0ULecwPfvWWttw+Px7HzQjEaj3U1VJBIhIiICKpUKUVFRfmmVxgbMZjOamppodZLtHFY2Qr9UKHpubg6VlZVf2+T8kZER9Pf3e5x3yITnX1hYGCQSiV3lMGX6bFs5LJfL7X4XroZ0qYINHo8HvV4PkiS/toovmwgQPjfhTg6fLWEqKyvz2haAOklJkmQt+Xk1qaQqV7VaLWpraxk5WdhW+MxmM44dO4aUlBRkZWU5rMQ1mUwbUonrLn7z4M/R2vAZdMvLMFmBZYKAyUpCIA5DVHI6QqXhiE/PZHTOxIxs9CtPOn3fYjaj++RRXHrndxid1xbJ2XmYGh5EYmY2a3PYgrBa0fXxf/DA/fe4dU5RLbCSkpJgsVgwOjqK/v5+8Hg8qFQqdHR0eNw+b6NBKeEhISEoKSnxuzrJROiXIAi0tbVBq9WisrKSs+e1K9gWmYSHe58f663nH3VdpuzG4uLi6FaR8/PzUKvV6Onpgclkoj3/IiMjQZIkJwnfatNlAAGFzwG+HlcqDsEZ4TObzWhpaYFer0ddXZ1PB5ut/QtbNxNb9c1gMKCxsRFBQUGora1lLMTDJuGbnZ2F2WxGUVER7W3nqBK3qqqK0zfkTSXF2FSytsuGWq3GhwcPwmLQ4T/PPonKs89DbHIqI3Py+XxY1inceOupfdhx7R5G5nKGkq1noPGT/X4jfM0H38G937zZq3y7hYUFDA4O0p0nbNvntba22rXP4yoBoc5xmUzmcYoJG7AN/ebk5ECv17sM/VJ5ukajkfFQtD9BWeAwXWTiiecfFT52FPqVy+WIioqiCz9UKhWmp6fR3d0NYCUMHRMTwykj7tWmy5R9TQD24O6dkKNwRPh0Oh0aGxsRGhpKd3PwdQ6AvQpX4KtcB6q5eHR0NONhKjZC07YqKp/PX0P2uFiJ6ylMJhP6+/uRmZGB8849F2lnno+PXn4ehsV5pBdtQvHWM33+XNrFJYevtx37Amn5Rax75IklUhi0jtfANDq/+ATXnbvTqxQFqmtDfn4+EhISAMAun4oiKtQNUSKR0OSPbRNcd0FdnxQKBfLy8jixJlvweDyXod+oqCgsLS2Bz+ejoqLia1koAwD9/f10RTHbno2uPP9WF2048vwTiURITk5Gamoq9Ho9jh07huXlZTQ3N4PH49l5/m3kb7Lag48rvYe5hgDhcxO2IV3bog3K8DIxMRG5ubmMHGTUzZzNPD7q5Dh16pTXuYbuzMEkaaWsMJaWllBSUoKmpiZYrVY6zMDVSlxPoNfroVQqIZFIUFRUBAtBomt0GDuvvRkA0NusxGuP/RaK+ERUn3Ohyw4dzsDDWtNqi8WCjuNf4LI7v+vDJ3Af/mixNtzWhM25GcjLzfV4XyqhvqSkxGmxj1gsRmpqKlJTU+2IysjICB1uo8JhG1Hgsbi4iMbGRiQmJiIrK+trcRNcHfpVq9V0FTUAtLW1ccrw2R2QJIn+/n6Mj49vSEXxas8/6kFlZmYGPT09CAsLo1MUqOjUas8/yui+sLAQwIryrVarMTQ0RBc52Xr++fNYWx3SDRA+xwgQPg8hFAppkjEyMoKenh7k5+cjKSmJsTkoQ022CB/lrA+snLyUcsE0mAzpLi8vo7GxETweDzU1NbSqRykXJpMJo6OjX6s+pquxsLBAW+FkZ2evfNaqSnz6138iLjUdAJC9qQzZm8qg1y7iwL/+juAgIYq2nIG0grVh4fVgNq01X379iYdx9jU3M/FR3MKywcDq+LNjI4jBMs48zTO/P8rbjfJzdDehfjVRmZubw+zsLLq6uty2fGESlHqfnp6OtLQ01udjA1arFQMDA5BIJCgpKcHy8jKnDJ/dAUmS6Ovrw8TEBCoqKja8mMCRokoVbTQ3NwP4yvMvMjISPB4PBEFgcXERAoEAZrMZfD4fMpkMERERyMzMhMFgoDt+UL3CKc+/iIgI1iMtjhS+ANYiQPg8hEAggMlkQnt7O2ZmZtxuNebNPGwQPlu/OgCsutIzRfiWlpbQ0NAAuVyOoqIiWtHbvHkznZ9iMpnotkRisXhdawEuYmZmBm1tbWvUSYFAgDDh2s8hlshwyZfefEfffxsNH3+ApKw8lG/f7dJfD//H3nmHt1mf6/+WvLctDzneO95Dku0sQkhC9rATKKNtEnahYRUOpOfHKKshQHtCEg4ESkloA4Q4e5A9GEkg3tuO95bkIduSJWu9vz9yvm8lx0OWNY0+13WuUxyNV7Ks936f57nvBwDFZGJYJoWT8605l8obVxGVlAIvX9PtH3VwdcOgqM8oTmDJQD/EtaV44o9/mNT9KIpCTU0NBAIBMjMz9T45a1ZUZs6cCbFYDKFQiNbWVlRWVsLT01Mr8sXQn1US2BsXF2fQi1FTIpfL6eD31NRUMJlM2NvbW0Tgs66QERQ+n2+x8TG6ZP65ubmho6MDsbGx9DiQZuvX0dERQUFB9GYj0j6uqqqCUqnUah8bI6R85AyftX3/mwqb4JskFEVBIBDAyckJs2fPNtpgqDHm34iZgcFgYNasWfj++++NPic41dfQ3d2N4uJihIeHIzo6mnaYMZlMODo6oqenB46OjuBwOBgcHIRAIEBjYyOcnJwQEBAAf39/eim5pdLS0oK6uroxq5MBXu4YlkrhNMZnbc6KtQCAzuZGHP7fv8GL5Qfe0pXwZY9duQ2MiEF3exuCo2OhVCpR/tP3WL/ZNK1cQvKsO9BWW4WErDkGfVylUoGbV07j9Reem9T9iAN0cHAQmZmZBvvb1ox8IcP0QqEQQqGQroYQ8WeIagifz0d5eTmSkpImXONoqZC8QzLaMNp7Yum7fsnFg1AoBI/Hs4qq02iZf83NzWhtbQWDwUBLSwukUumEmX/kvSf5lsQ5rFmV9fX1Ndicq63Cpxs2wacjDAYDg4ODaG1thZ2dHbKzs43q/jR0hY/M8rBYLPoL1Nh5f1Ot8LW0tKCmpgZJSUmYMWPGhE5cDw8POlqAuNNIi8Lf3x8BAQFmm6UaDbIpoKOjY9zW4d13zscXZ39A8twF4z7ejPBI3PvMy1DI5Tj31R4o5TLEZmQiIWvObV+qsWkZaL9ZjeDoWBz9ZDsWP7DRQK9Kd8JnJuByXgEAwwk+iqJQevooXvrDY5P6PSuVSpSUlEChUCAzM9OoLVcnJyc68kXzs1pWVga1Wk2LFF9f30kPwpOtDePNHVo6UqmUrugnJibqJAh0cf2S6p8pWr8jg6Gt1TEqlUrR0dGBxMREBAYG0q1fzcw/zRlVckGumflH5lwjIyMhl8vp1i+ZcyWP4ePjo/c5VVPw2UKXx8Ym+HREoVDgl19+gY+PD9RqtdGjPgwp+Ph8PkpLSxEVFYWoqCgtA4oxK3z6Pj65Mm5vbweXy4WPj8+knLh2dnYICAhAQECA1pV/dXU15HI5fUL19/c3m7NMpVLReWJZWVnjXpH6+/sDkn6dH9vB0RErNj0OACi/9gMObN+KwPBIZC5dA5f/+yIMCAlD5bXvUZ3/M0Jj4+Hla3pxwGQyDb5ireLKOTx8T86k4i7kcjmKiopgb29vkjBiTTQ/q6Sd1t3djcbGRpSXl8PHx4f+rE4kGki223hbGywdiUSCgoICBAQE6G2CG8/129LSYvTWL0VRqKqqQm9vr1WLPTIDOnPmTAQHBwOA1mdVc1tHVVWVTpl/dnZ2YLPZWlXZnp4e1NfXQyqV0pEwfn5+k3rfRpo2rPU9NzY2wacjDg4OmDNnDvr6+tDS0mL05zOEGCPmjPr6eqSkpNzW3rHECp9mAHR2djZcXV3HdOKGhoZOeEIYeeU/cn3WZE6ohkIul6OkpAQURelcTfJwsNMriDt59h1Inn0HBvp6cfKf/wsXF1ek37XkVitXPozSHy8ZNWB5Igxp3Kgv+gWLOEmIiozQ+T4kn87d3R0pKSlmjfHRbKfFxMTQGWikTUmclCMNCsQB2tbWZvBsN1NCtuYEBQUZ1FFsytYv2QIiEomsOhi6r68PRUVFiIuLo8WeJrpm/hHTBjB669fb2xssFouOOCIVxLq6Ori4uNAC0svLa9y/zZEtXVuFb3Rsgm8SuLq6YnBw0Ohrz4CpV/jIPFJPTw+ysrJGTXM3doVvsoKPzO1otsw13wOyE1dfJ+7I9VlSqZSepaqtraXbPgEBAXB3dzdK22dk7Iqu1QVOUgLKmhoQpOfWDU8fFtb/8QWo1WpcObwfv3x3FMW/XMPmrdvNOt84rDDMirWupnpEujlgbna2zvcRi8UoLCyEv7+/RebTubq6IiwsDGFhYbSTcjSDQnd3N7q7u5GZmWm1JzoychIWFobIyEijbhgyVutXrVajoqICg4OD4HK500Ls6Wr4GSvzT1NUk8qdg4PDqJl/Tk5OCA4ORmhoKJRKJXp7e9Hd3Y3y8nJQFEUL89FGHVQqFX3hbBN8Y2MTfJPEmHEphnoe0qJSqVSYPXv2mF88xtyEQR5f19dAnLgsFgtJSUlarQDg1k5cMvxsqAqGi4uL1gmViL+mpiaDD9ID/4ldmTFjBuLi4iZ1MsnkcXH+s716Cz4Ck8nEXesfgFqtRtG1n3D+670In5kI7qJlJt1rSwiKmomu1iYER8bo/RgDfb1Qtdbhnscf0fk+IpEIxcXFCA0N1RpzsFQ0nZSkSkWc3SqVCiwWCyKRCPb29kZxQRoTkUiEoqIik8fHGLL1q7nyjcvlWt3vgKCP2BuJITL/mEwm/Pz8bmsft7S00O1jIiDd3NxsFT4dsQm+SWDsfDxN9H2ewcFBFBYWwsvLCykpKeN+SRn7tYwMqR4LoVCI4uJiREVFITIyUsuJq1QqUVZWhuHhYWRnZxvtqtnBwYG+QiULyQUCAUpLSwGAFn/6zvyMFbuiK0wmE+72hms3/nTiMDh3LkRy9lzYOznj8P/+HTMio5G1dBUcHE13skqbtwBFl8/qLfgUcjmaf7qAV194Vuf7kMgSaw3oZjKZ8PLyQktLC5ydnREfH4/+/n60t7fTJ0NjRr4Ykt7eXhQXFyM2NhahoaFmPRZ9W79qtRplZWUYGhqy6pVvRHgbMspH38y/ka1fd3d3rfZxd3c3Hfrs4OAAhUKBGzdu4De/+Q0kEoleW3UIvb29ePrpp3H8+HEwmUysX78eH3744bgRTQsWLMCVK1e0fvbEE0/gk08+of+7paUFTz75JC5dugR3d3ds3LgRW7duNenMsE3wTRJTCT595uuIKzU8PFynGRhLmOFrbm5GbW3tuE5cZ2dnk+7EHbmQfOQXv6+vLwICAnQO0CUbG5KSksBms/U+Lra3B2RDQ3A2QOSAsLkBq594Fhf3f4mF923Aus0voruzA0c+2Q7/4FDMWp5jkOeZCHdPTwz0dut131uO3CP4f0//QecKbGdnJyorK606skSpVKK4uBhqtRqZmZlwcHAAi8VCZGQkfTI0VuSLISHO5Pj4eKOFv+uLrq1fX19fNDY2Ynh4GFwu16rFXmFhIWJjY42a26hL5h95X52cnEZt/drb22PGjBn0Wk2RSITz589j69ateOmll+Dl5YWsrCy0tbXp9Vp++9vforOzE+fOnYNCocBDDz2Exx9/HF999dW493vsscfw5ptv0v+tacRTqVRYuXIlAgMDcfXqVXR2dmLDhg1wcHDAX//610kfo77YBN8kIYJPnwF6fZ5HFyiKQnNzMy0qdP3yNOcMH4kt6OjoAI/Hg7e396hOXOLWM9eJisFgwMfHBz4+PoiNjYVEIoFAIKADdMkXVEBAwG2mD11jV3Tl7gV34vPvLiN53l1TehyFXA4Pli+YTCaGBgfon/vNCML6zf91y+Dxxf/C29cfs1fmwtXDuCYAhp6fwbIL3+GPGx7QOXOL5B2mp6dPqQJgTjQdxVwu97ZqM5mDIifD3t5ercgXzW0f5tx9SrICk5OTp3QRZArGav2SzE8ACAwMhEgkspjA58mgKfZMWWUdLfOPXKzU1dXRFysTZf75+PggKioKP/zwA9rb2/H444+jsrISERERSElJwcqVK7Fq1SpkZmZO+LupqqrC6dOncePGDfB4PADAzp07sWLFCnzwwQfjnltdXV3HvIg8e/YsKisrcf78ebDZbKSnp+Ott97Cyy+/jL/85S8mu1CwCb5JQK4uiN3c2IKP7I4cD7VajaqqKjrJfTJxDKao8I32+CTzbGhoCLNmzYKLiwt9BcdkMiEUClFeXo7o6GiEhYVZTEuKwWDA3d0d7u7uiIqKgkwmo2dTbt68CTc3Nzrs2dXVFZWVlRgYGDDYML2vry8wNDDxDSfgwv5/IeOuxbf+g8GEeKAf7p7/MfV4+rCQ++SfMCQexOl//QOOzi6Yn/MbeLKMI5Jkejh16/KvYfUd2QiaMWPC2450sY5mYLIGiKnJzc1NJ0fxyEr1wMCAVjWFONT9/PxMGlRLqqzWmhXo4OCAgIAAdHZ2wsPDA5GRkejr67OYwOfJQNq4ltBSd3FxQWhoKEJDQ+l8Sl0y/1QqFb3uLT09HWFhYcjJycGDDz6IM2fO4MSJE1ixYgWeeeYZ/OUvfxn3GK5duwZvb29a7AHA4sWLwWQy8fPPPyM3N3fM++7btw///ve/ERgYiNWrV+PVV1+l/66uXbuGlJQUrYubpUuX4sknn0RFRQUyMjKm9ubpiE3wTRJyhaBUKo2qyu3s7CCbIKNMoVCguLgYcrlcr60f5qjwyWQyFBQUwMHBAdnZ2bdVMqfqxDUlzs7O9BeU5sB3c3Mz1Go1HBwcEB8fb9C4F09H/eJZNJEOiOAXeCtqYd7ae1Fx9XtkL1t92+1c3T2Q84fnIJfJcGbfP+Do4Ijs5WvBYk8ssiaDo4srxP0iuHt563T71ppKhLvag5OWOuFtSSZaT0+PWZbWG4qhoSEUFhbCx8cHCQkJk654MxgMeHl5wcvLCzExMbc51F1dXWlx6OXlZbSLLBIMbc1VVpVKRbfUuVwu7O3tERAQYBGBz5OBiD0ScWVJjMynHCvzj8VioaOjAxRFwc3NDUqlElVVVZg9ezZYLBYeeOABPPDAA1AqlZDqcGHZ1dV123nH3t4eLBYLXV1dY97vwQcfRHh4OIKCglBaWoqXX34ZNTU1OHToEP24IyvZ5L/He1xDYxN8k4R80Rp7jm+ili4JKHVzc9N764exK3wjBeXAwAAKCgrg5+eHxMREkzhxTQUZ+Pby8sLAwAAcHR3h5uaG6upqVFVV0Vf8fn5+U2r5cJKTUNpQh6DoWL3uLx7ohw/7P20HVgAb/YLOce/j6OyM1Y9shlKpxNl9/wRDrULm0lUICAnX6xhGkpg9F203qxHPmzXhbfsEfIjrysHmcXDlypVxzTQk3FoikSAzM9Piqy1jQfLpAgMDJ+3uHgtNh7pSqaQjX4qKimiH5FRMSqNBLuasORiazE8CQEZGhtb37sjWL9kqYarA58lgyWJvJONl/jU0NGDbtm3w9/fHypUr8csvv0Amk2HevHlaj/HKK69g27Zt4z5PVVWV3sf4+OOP0/87JSUFM2bMwKJFi1BfX4/o6KklKxgSm+CbJKZy6o4nxnp6elBcXIyQkJApnQCM/To0K3wCgQAlJSWIjo5GRETEmE7crKwsq01J7+/vR3FxsdaJWXMwua6uDuXl5WCxWHTrd7JVYh4nA+c+26u34Dv/9R4sWP+g1s/EA/3072I87O3tsWLj41Cr1biw/1+QD4nBuWspgmPi9DoWQkRCMi7n/XtCwTcsk6Kr4Ef89wvPAwBtprl58ybKysrAYrFoAWhnZ0dXYazZOUmifIwZH2Nvbw82mw02mz2mO5UIFX1Fc0NDA1paWsDhcKy2pa5UKmlBnJ6ePqFgc3R0nND1O9X3VR/IZyo6Otrixd5okMw/qVSKvr4+PP744zhz5gyef/55SCQS3HnnnfTnjbjwX3jhBWzatGncx42KikJgYCAEAoHWz0km4GRMXtn/lwdaV1eH6OhoBAYG4pdfftG6DZ/PBwCTmsdsgm8SaK4kM1eFr7W1FdXV1UhISJiym4rJZEIul0/pMSZ6fJVKhaamJty8eZOeYRjpxC0uLoaTk5NJnbiGhgzGR0dHIzz8P5WvkdsTJBIJhEIhHaHh5eVFmz50maOaajwLg6Lg4a1dXYnJyEJTZSmiktN1egwmk4m7/2/37pUj36LgwndIueMuRCZO3GId6/EmWrGmVqtRcfYYXn1uM/13ONJMIxQK0dHRgaqqKjCZTDg7OyM5Odms5oSpQCJLTBkfM5Y7tbOzE9XV1fDw8KBFtS7h5BRFoa6uDh0dHeByufDw8DDJ6zA0CoWCNsukpaVNujo30ftqqtZvf38/CgsL6floa6WxsRGtra3g8Xhwc3OjxxK+/vpr1NTUYP/+/XjmmWeQkJCA9evX4/XXX9dpXnT27NkQiUQoKCgAl8sFAFy8eBFqtZoWcbpAqsAz/m/GePbs2XjnnXcgEAjolvG5c+fg6emJxMTESb56/bHOs6uZ0TVfbqrPoSn4NF2tXC4XLBbLIM9hzBk+BoMBmUyGhoYGZGZmwtPT0yKduFNF19gVTdNHZGQkbfog1T8SSBoQEAAPD48xv/Rn+HhBKhHDxW1y82jCznb4h97ehk2deycufL1HZ8GnyZ05vwEAXD9zHCVXLiAxex7iOJmTfpzhCQRf6bkTePbhDaMG2mq+r4GBgcjPz4ejoyMcHR2Rn58PZ2dnrWgSS5qjGguS22jOyJLRWpRkTpXkn5H31cfH57a/X7ITWyAQ0Cdma0ShUKCwsBCOjo5ITU2dcivWXK3f6SL2mpub0dTURH+m/va3v2H37t24ePEiUlNTsXr1arz44ovo6+vD2bNn0dzcrPNjJyQkYNmyZXjsscfwySefQKFQYPPmzbj//vvpv8P29nYsWrQIX375JbKyslBfX4+vvvoKK1asgK+vL0pLS/H8889j/vz5SE29dRG8ZMkSJCYm4ve//z3ee+89dHV14ZVXXsEf//hHk4Z02wSfHpiqwkfEmKardfbs2QZz1Blzhk+pVKKurg4qlQpz5syBs7Mz/VyW7MSdDKR60d7erlfsykjTR09PDwQCAfLz8+lB8NFOposXzMdnJy8g5Y5Fk3q+7w99g2W/f+y2nzOZTAz09U7qsUYya+kt00fJD5dw6KMPEJuRieTZ83X+vQ4PD0OtUoE5ysmt5vr3+M2SBRNeoZPQcTabjZkzZ4LBYNBuP5JRCUw9RNvYEBdrSkqKRRmXHB0dtcLJ+/r6IBQKUVFRAaVSqTWnam9vr2WWMaUL2JDI5XIUFhbC2dkZqampRrkoNUXrd7qIvdbWVjQ0NIDD4cDd3R27du3C9u3bcfbsWVpcEXx8fHDfffdN+jn27duHzZs3Y9GiRXTw8o4dO+h/VygUqKmpwdDQEIBbv7/z589j+/btkEgkCA0Nxfr16/HKK6/Q97Gzs8OJEyfw5JNPYvbs2XBzc8PGjRu1cvtMgU3wTQJy8hq549UYEFFJ3HlOTk6YNWuWQdtTxqrwSaVSFBQUwM7Ojl71ZK1O3LFQqVSoqKgwWOzKyNVZJD+tvLwcarWaXjNEJ9JLxZN+DmcnpzHDlB1cXDHQ2zPl6JW0O+5C2h13oargOg7ueh9RyWlIv/PuCU+UM6JjwW9twowI7QHnlspS8MJnIHmCtkdfXx+Ki4sRHh6utYt1pNtvtJMpCdG2hHVYpFps6S5WOzs7+Pn5wc/PD/Hx8RgcHKQd6hUVFfRoRlpamlWLvYKCAri6uuoUg2MIjNH6JWIvKirKqsVeW1sb6urqkJGRAU9PT3z22Wf461//itOnT2vFqEwVFos1bsgymUEnhIaG3rZlYzTCw8Nx6tQpgxyjvjAozSO3MS5qtZpe4TJjxgyjJpL39/fjxo0bYDKZCAwMRHx8vMG/cNrb29HW1jap2YSJIF8u/v7+CAkJwY0bN3DHHXfQlRTixE1PT7fa4W0Sh0NRFNLT041qCCD5aQKBAEKhEFKpFCwWCxd+uo6Elb/RuYLWVF2J3o5WpM0fvSo40NeL8p8uY9aKHAMePdBYWYbCi6cRNjMRvEXLx9zXKxaJUPLjRWQtXUX/rKezDQ5dTdj04P3jPgeZn5zMSiiKoui5P6FQiIGBAXolWUBAgMnbjxRFobGxEc3NzcjIyJhySLe5UKvVKC4uhlgshqurK0QikckiXwzJ8PAwCgoK4O7ujuTkZIsYN9Fs/fb09NCtX39/fzqbbiQkGSEqKkprttja6OjoQHV1Nf238eWXX+Lll1/GiRMnMH/+fHMfntVgq/DpgSlauj09PVAqlUhISDDaH6qhK3x8Pp/eURoeHg65XA4nJyd8//33YLFYdA6SNTtxpVIpioqK6Kt+Y7cENfPTNM0JbG9PtN2sQWhcvE6P8/Ppo8h54rkx/93Th4X+br6Bjvo/RCamIDIxBR1NDTj0v39DUGTMqPt63b29IR0Q0f8tFYshqijEfz391LiPT04Ek11bN3Kecnh4mBZ/DQ0NJp37IxtZOjs7wePxrNbYoFKpUFJSAoVCgVmzZsHR0VEr8oUMsmvOp1miSYuIPQ8PDyQlJVmE2APGbv3W1NSM2vqdLmKvq6sL1dXVSEtLg7e3N7755hu89NJLOHr0qE3sTRLL+2uzAowp+MiXPxk0NWYJ3lAzfBRFoampCXV1dUhNTUVAQABUKhWYTCZmz56Nvr4+lJeX04aNiooKus1mTdloJHZFc0bM1JBh77CwMLyze4/Ogs/dwxP2E4wDSMTiMefopkpQRBTWb/4vdHd24OjuD+l9vU4awl8+fMu4oVapUH3xJF5/4dlxH7OpqQmNjY1IT0+fsonJyckJISEhCAkJoef+SJQQYLy5P4qiUFlZid7eXmRmZlpt+5Pk01EUBQ6HQ4+eaEa+aLbUSUQR2fZhKVspSDC8l5cXkpKSLLYaOVHr18XFBVKpFCEhIVbdxhUIBKioqEBaWhp8fX1x8OBBPPvsszhw4AAWLlxo7sOzOmyCbxIYO5aF5NENDg6Cy+Xil19+gVqtNloVyRAVPrLaTSAQICsrCx4eHrc5ccvLy2knLqmkCAQC1NbWwsPDgzYnWPIWBM3YFUswmTCZTHg66va5KLv2AyJTJl7dk5h9B+pLCxGbMXmXra74zQjCuj++iIG+Xhz//CP4+P1nX69s6FYFuOTMUfzp8YfHrP5o7ijmcrkGD+nWde5PnxxFTdRqNcrLyyEWi606GJpEltjZ2SEjI2PM7yvNvdRxcXF0tXrkVgp/f/9xXerGgswe+/j4IDEx0ex/47oy0vVLclrd3NzQ2dkJPp8/YevXEiHfuampqfDz88OJEyfwhz/8Afv27cPy5cvNfXhWiU3w6YExYlnInkw7OzvMmjVLa6OHsf5Ap1rhI7Nsw8PDyM7O1smJq5nwT2IeBAIB3UYjJ1pLWkNE1kFNtm1obGawvDEkHoSr+/gtwNIfL+M3z7484eMlZs7CuX1fGFXwETx9WFj31H/29bp5eEKhVOL68YN4NHflmJsYyAUGqYgZe9ZOU6RottRJjqKnpyct/iZzLKT9KZfLrToYmrhYnZycJh1ZMlrkS3d3N5qbm2Fvb68lUozdVpVKpcjPz6dNKJby3TNZBgYG6AvTiIgInVq/lkhPTw/KysqQnJwMf39/nD59Gg8//DD27NmDnJwccx+e1WITfHpgb2+P4eFhgz0eMTr4+fnRMyPES2PMnLypVPiIe9jZ2RnZ2dm3iceWlhbU19eP68QdGfNAxB8RvmSAfrSML1OgGbtiieugltx1J3YfO4uU+YvHvI1arYaPn5/O759ksN9Qh6cTmvt6P37leUQF+CAuNmbU26pUKpSWlkImk5mlIjbe3F99fT099xcQEDCuOYFcKAEAj8ezyDk2XSCzbm5ublN2sWp+F6jVajrypaqqCgqFAr6+vrRIMbQ4HhoaQkFBAfz9/c02qmEISCxRREQEIiIiANze+pVIJOju7jZ54PNk6O3tRUlJCRISEsBms3Hp0iVs2LABu3fvxj333GPuw7NqrPObxkwYo6Xb1dWFsrIyxMTEICIign4OBoNh9F23+j6+SCSi887i4+Nv24lLwla5XK7OTlw7Ozut9U59fX10+KxaraZPpKbKTiOzhv39/SapJOmDt7c3mDLJuLe5fvo44jPn6vyYzu6e6BN0wSfAdOt+gFufxci4eLiyRs/aGymSLGF7xlhzf5rmhJFzf1OpiFkSpP3p7e2NxMREg16QMZlM+Pr6wtfXFzNnzoRYLIZQKERraysqKyvp7TSTraqOBtlJzmazDban2BwMDg6ioKAA4eHhtNgbieYFy3iBz+Zs/ZJ4pfj4eMyYMQM//vgj7r//fuzYsQMPPvig1f5+LAWb4NMDQwg+iqLQ0NCAhoYGpKWljVoFM7YbmFT4KIrS+Q+JCNTY2FiEhYVp7cQlFZip7sTV/MKPj4+nd9GSnam+vr50G80YJ36FQoGSkhKoVCpkZWVZdLvNw9Fu3N9fc3U5spes1Pnx5ufci/xzpzBv7b2GOkSdOP75R7hz/QNor6lAZ2cnvZIIuFVJ0gy/tUSRpDn3p1ar0d/fT8+pDg8Pw9fXF15eXmhvb6cNAZbi/pwspCLm6+uLhIQEo56EGQwGPDw84OHhgaioKMhkMnrbh2ZVlUS+TOY9lUgkyM/PR1BQEGJiYqxWTGiKvcjISJ3vN1nXr7Ehpri4uDgEBQXh559/xr333ot3330XDz30kNX+fiwJm+CbJAwGY8pCTKVSoby8HH19fZg1a9aYMQymEHwAdDKGkJyw+vp6pKWlwd/f3yQ7cUfbRSsQCNDS0oLKykra5Wcox69m7Mp4A+iWwqyMdFy/WY2wuITb/k0hl8OL5Tepx3N190BPV4ehDk8nWmqrwQ4Ng7uXN2I42Th88jSeevQhAP8ZHTBGJclYMJnM28wJ7e3tqK+vB0VRcHR0REtLi0EqVKZGLBajoKAAgYGBZqmIOTs731ZV1dyiQrZ9TBT5Ql5HcHAwoqOjrVZM6Cv2RmLu1u/AwAC9CSQkJASFhYVYt24d3njjDTz11FNW+/uxNGyCTw+mYtog1Qrg1kLl8dL9TdHSBSY2hqjValRWVkIoFI7qxB0cHERRURH8/f2NEhBN0GxJREVFQSqVjur41Tc4d2BgAEVFRWaNXZksaakpOPnpnlEF34UD+5Bx15JJP6ZKqYRSoZgwxsVQ/PzdYax+/FYEi529PfhiKVQqFSQSCYqKijBjxgzExsZaxe9jJAwGA2q1Gp2dnQgPD0doaOhtFSpSrbb0UGIiLkJCQixCJI10U5NOQH19PcrKyrQqVJrdBvI6QkNDER0dPc4zWDaGEnsjMXXrl8weRkZGIiwsDGVlZVizZg22bNmCZ5991uyfs+mETfDpgb6r1cgfqI+PD5KTkyf8QzFlhW8sSOQCCVPVXJOm6cQl4Z6m/OMc6fgl4k8fxy+JADDH65gKDAYDng6jf46koh4EBIdO+jFT71yE2sJfkJit++yfvlw++A14i1ZoXSQEp3CRd/goAnx9EBkZOeZMkjUgEolQVFSEiIgI+qRMKlRjhRJb4p5fYizTfB2WhGYnIDY2ls6l4/P5WpEvLi4uqKmpsdjXoSvkXBIWFmb012HM1i+ptIaFhSEiIgKVlZVYtWoVnn32Wbz00ktW8z1sLdgE3yTRt6VLQlyjoqIQFRWl0wfZ2IKPwWDQC+ZHg8zqkPamPk5cU+Ho6Ijg4GAEBwfTJ1JNxy+poozm+G1ra0NNTQ2SkpIQGGhas4IhCPL1gWRwAG4e/8mjGxIPwFtP40VcKgdn//0Pows+2ZAYkv5eBMfO1Pq5TwAb1384iz899jCCg4ONegzGpLu7G6WlpWOufNMMJR5r7o8IQHPOkZJBehKvZA24uroiPDwc4eHhUCgU6O7uRkdHBxoaGmBnZ0d3B6wpl46gKfaioqJM+ty6tn51yVIkhpmQkBBERUXh5s2bWL16NR599FG89tprNrFnBGyCTw8mI8Q0t1CkpKRMSlAYevXZZJ6jr6+PbqfNnDkTarV6yk5cUzHyRNrb20tXIjUdvywWC01NTWhtbQWHw7G42BVdWXTnHfjo0ClkLFxG/+z8N//CHWv0jzCQDAwY4tDG5eQ/P8biBx8e9d98wmKM/tk3Jnw+H+Xl5UhMTNQyoIzFaHN/mnl/hnSmTgYiWmfOnGm14tvBwQEuLi4YGBhAbGwsPDw8IBQKUV1dDblcbjHCWhc0K2KmFnsjmaj1a2dnR89UjhTWxOUdFBSE6OhoNDY2YtWqVbj//vvxzjvv2MSekbAJPj3QVfCRaI/u7m5kZWVNWhiZYmfvaHOCnZ2dKC8vR1xcHMLCwmixZ0gnrqlgMpnw8/OjA1U1qyhSqRRMJhNRUVEWveVjPCiKAp/Ph0TYpf1zpQKeLF+9H9ed5QthRxv8g26vTBmCm8UFCI9PgssY4iWWm40jp8/i6cceMcrzG5P29nbU1NQgNTUV/v6jx8yMhy55f6aY+xMIBCgrK9NZtFoqpEIZExOD0NBbIw4jI180g7Q1hbUlCQ+xWIz8/HyEhoaaXeyNxsjWb19fH7q7u29r/bq7u6OsrAxsNhsxMTFobW3FypUrsXr1avztb3+zCmOWtWITfHpAhNh4cRhyuRxFRUVQqVSYPXu2Xg5SUwg+zQrfyKiYkU7c4eFhFBUVwcnJyWKy0CYDmfNxc3NDf38/LQb5fD7q6+vh4+NDn0gtNYFeE7Kaa2BgAMG+PvTnsVfAh98Uhdoda+/F9VNH4Z97n4GOVpuS7y9g9eNPj/nvTCYT3RI5lEqlVQUTk/2+hgzq1sz7Gzn3x2AwtJyphmpPdnV1oaKiAikpKWYf15gKvb29dNTHyLb6yMgXTWHd0NAAJycnWvx5e3ubVYhoij1rMJpoRmtptn7b29tRWlqKnTt3YvHixbjjjjvw2muvYfHixdi1a5dN7BkZ6/kmtRDIDB9wy9062slILBajsLAQHh4eSElJ0fuEZcoKHxEPvb29yM7Ohru7u1mcuMaGxK64uLiAw+HQv0upVAqBQEAPeU/V8WtsRmYFenp54aeaSoTHJ+HSgX1Y+rvRW6W64uziComo10BHq813X36G7OVrJqyehKTzcOrMWaxZucIox2FIKIpCfX092trajLLfl2CKuT9SoUxLS4Of3+RifSyJnp4elJSU6NyOHhmkTUZBysrKoFartYS1KS92SRvXWsTeSEjF2sHBAR0dHUhJScGTTz6Jo0eP4tNPP4WzszMYDAZOnDiBxYsXw9XV1dyHPG2xzrO2mSECbjQx1t3djevXryMwMBDp6elTqk4YO5YFuCUq5XI5bty4AbFYrCX2KIqinbj5+fkIDw9HQkKC1Yq9gYEB/PLLL/Dx8UFaWppWNcTFxQXh4eHg8XiYP38+QkJCIBKJcP36dVy9ehV1dXXo7++nV96ZE5lMhvz8fNjZ2dF7WFOSk9HbdBMA4OjgABe3qbeoZTIZFHLDrRAEgIG+XoBSgx0WMeFtvX39UdHYYtDnNwYURaGmpgYdHR3g8XhGE3sjIXN/M2fOxNy5c5GdnQ0vLy+0tbXh+++/x40bN9DU1ASJZPxtLJq0traipqYG6enpVi32uru7UVJSgvj4eL1mD8lqx8TERMyfPx8cDgcuLi5obGzElStXUFBQgJaWFkilUiMc/X8gYo9E4VgrZMOMh4cHsrOzce+996Kvrw+5ubk4cuQI3Nzc8Pzzz8PX1xerVq3C2bNn9X6u77//HqtXr0ZQUBAYDAaOHDky4X0uX74MDocDJycnxMTEYM+ePbfd5qOPPkJERAS9TvSXX37R+xjNha3CpwdjuVubm5tRW1uLxMREgww4m6LCR05W3t7e4HA4Yzpxk5KSwGazjXosxoQMn+sSu6KL4zcgIMAsbR6xWIyioiKwWCwt8c1gMODhYIfWulrMiBx9F+1k4S5ajuob15Ey906DPB4AnPnyUyzf9Aedb095stDY1IRIC41mIRmVIpEImZmZZptpNcTcH2lHczgceHt7m/5FGAhSlUtISDDI7CGDwYCXlxe8vLwQExNDO3yFQiFqa2vh5uZGV1UNGUqsGQ5tiTN7uqJQKFBYWAg3NzckJSVBJBIhJycH0dHR+Prrr+Ho6IglS5bgf/7nf1BdXY3jx49P6bwnkUiQlpaGhx9+GOvWrZvw9o2NjVi5ciX+8Ic/YN++fbhw4QIeffRRzJgxA0uXLgUA7N+/H3/605/wySefIDs7G9u3b8fSpUtRU1NjVSMPDMoSShZWhEqlglKpxPnz55GdnQ0PDw+o1WpUV1ejq6vLoLM7dXV1GBoaQmpqqkEebyR9fX345ZdfwGKxwOVy6TVrBOLETU9Ptzgn7mQwVOwKcfwKBAIIhUJQFAU/Pz+T7fglmW6ktTPyxHL42AnknT6Pe55+EfYOhnEbnv3351j84EMGeayyq99DrVIgIUv3uBe1Wo2u6xfw7BOPGeQYDIlKpUJZWRmkUildHbBENOf+uru76bk/4lRnMploaGig3eqmqlAaA2I0SU5ONskFqkKh0HpvDRVKPF02gRCxR3ZHi8VirFmzBr6+vjhy5IjR/2YYDAYOHz6MnJycMW/z8ssv4+TJkygvL6d/dv/990MkEuH06dMAgOzsbGRmZmLXrl0Abn0vhYaG4umnn8aWLVuM+hoMia3Cpyek+kaWug8PD2PWrFkGnT8wZixLR0cHKioq6KvT0XbiymQyq3DijgWZqzJU7Iqm45ck+2vOT5GTqJ+fn8FnfAQCAcrLyxEbG0s7DUey+K47cezS9wYTewAg6RcZ5HHUajVqC3/G6sfGNmqMBpPJREtvP73z1M/PzyKiM5RKJT1DaekGppFzfyODc52cnCCXy5GRkWHVYo9E4ZjSaOLg4IDAwEAEBgaO+t76+vrSs3+6ihuST2ftYk+pVKKoqAgODg5ITU3F0NAQ1q9fDw8PDxw6dMhiLpCuXbuGxYsXa/1s6dKleO655wDcakcXFBTgz3/+M/3vTCYTixcvxrVr10x5qFPGJvj0xM7ODhKJBGVlZXB1dcWsWbMM7iY0RkuXiKCmpiakp6ejvb0dSqUSKpVKy4nr6OiIzMxMiz6RjQdptfX19SEzM9PgsSsjk/3FYjEEAgGam5tRUVFhUMdva2srbt68OWHAtYeHB9YtWYTKny4ice7CKT0nwScoGF0tjQgMm1qa/3d7P8GcNev1um/i3IXILy5GulKJyspKeHt70++tOS5GSNXC3t4eHA7HqlzEmsG5sbGxKC8vR09PD1xcXFBQUGC2vL+pQlzF+kbhGILRQomFQiE6OjpQXV2tU+SLRCJBfn6+1Ys9lUqF4uJi2NnZIS0tDTKZDL/5zW9gb2+Po0ePWlQRoaur67ZqMJvNxsDAAKRSKfr6+qBSqUa9TXV1tSkPdcpYzzeVBVJZWYmQkBDEx8cb5Q/T0KaNkU5cEk9SX1+Pnp4eeHp6oqOjAwEBAVbtxCUOVqVSiaysLJO0DUi8Q3R0NO347erqQk1NDf1FP1nH78gKpS5zVauXL0Vc7U3sO7Yf6cty4OA4tdc+b+U6/HD0wJQEX3dnB5xd3ODLDtLr/p4+LNRKb1XQZTIZ3VIn81NkptLd3d3oJ0iZTEbPI6WkpFjt3wi5IBoYGMCsWbPg4uICmUymtefXxcWFFiiWvOe3s7MTVVVVFuUqHjlTSVY/ksgXR0dH+r0l23+I2CNhxJb6fk8EEXsURSEjIwMKhQIPPvgghoeHcebMGavNPJ0O2ATfJGEwGGhra8PQ0BCCg4ORkHD70npDoe/O3tEguYBqtRqzZs2Co6MjVCoVwsPDERgYiMbGRjQ3NwO4tbqnubnZYiNJxkMzdmWqLml9IY7f8PBwrR2/9fX1cHV1patT4w14q9VqVFVVobe3d9IVyplxsdjyh2Bs//RzBHPngTVDfwORvaMjhgZEet8fAM5//QXWPPHMlB7DnsVG7c06xMXG0PuTycosUll1cHCg31tjGGqGhoZQWFgIHx8fq3arkws/sViMzMxM+oLI2dl5wrw/MvdnKevISPUsLS0Nvr76B40bG00jmGbkC9n+4+3tjb6+PgQFBSEmJsZqxZ5arUZpaSlUKhU4HA5UKhU2bNiA3t5enDt3ziJHBgIDA8Hn87V+xufz4enpCRcXF9jZ2cHOzm7U21jbKk6b4JskmlUbYzvZDFXhIzMhJBdwpMNYKBSiq6sLqamp8PHx0RIopq6gTIXBwUEUFhYiICAAM2fOtIgT8kjHLxEoBQUFcHBwoCt/mgJFc4YyMzNTr5awq6sr/vzsZvz7wEHU8zsQnZ6p92uQy+UYlkrhpEcb5pezJ5E0+w7Y209tNCAyJQPfXbyAuNj/OJAdHBzoZP+RuWmGNtSQIfrAwEDExcVZ9N/BeGhuyiGRPqMx0dyfJawja2trQ21tLdLT08FiscxyDPpAIl/I7DSZz7Wzs0NbWxvEYjH979aUSUfEnlwuB4fDAUVReOihh9Da2oqLFy9a7OrK2bNn49SpU1o/O3fuHGbPng3g1nc4l8vFhQsXaPOHWq3GhQsXsHnzZlMf7pSwuXQniVKpxODgIGpqauDj44MII8ZF9PT0oKKiAvPnz9f7MXp7e1FUVISQkBDExsbe5sStra0Fn88f1YmrKVC6u7vh6OhIiz9La/GQ2JXIyEhERERY1LGNxmiOX9LeaWlpgb29PdLS0gwyQ/lzfgHO/FyItLtX6yWC2xvrwW+qR/qdiye+sQZKpRKH//fvWDvF6h6h/PIZ/PfjmyZs0WsaagQCwZQFSn9/P+2OjoqKsvjP1liQVptKpUJGRoZeny2KoiCRSOjP7eDgoFnm/shcqyFTEcwBuRifMWMGYmJitNrqvb29cHV1tYq2OqkaDw0NgcvlgsFg4LHHHkNZWRkuX75s0ugSsViMuro6AEBGRgb+/ve/46677gKLxUJYWBj+/Oc/o729HV9++SWAW7EsycnJ+OMf/4iHH34YFy9exDPPPIOTJ09qxbJs3LgRu3fvRlZWFrZv345vv/0W1dXVVhVXZhN8k4SiKMjlcpSWlsLNzc2oYZgkhuOuu+7S6/7t7e2orKxEfHw8nR6v6cQlkRIZGRkTDtGqVCo6j04oFILJZNLij8ygmIv29nZUV1db7c5PIlA6OjrQ0dEBAPDz8wObzTaY41coFOKjvfswc+FKuHtOPmLnzL8+w92/ndxe27xd72PBPQ/C08cwrTZxvwiu/Ebctz5X5/sQgUKq1kSgkNbvRBUUsporJuZWK9laIY5JBoNh0FEHIlAEAoHJBArJBs3IyLDqvEAi9gIDAxEbG3vbezVWnI6h1+hNFYqiUF5ejsHBQfB4PNjZ2WHz5s24du0arly5YvLv5MuXL496zty4cSP27NmDTZs2oampCZcvX9a6z/PPP0/P5b/66qvYtGmT1v137dqF999/H11dXUhPT8eOHTuQnZ1t5FdjWGyCb5IQwVdRUQF7e3vMnDnTaM81ODiIn3/++TbL+ERQFIW6ujo0NzcjPT0dvr6+o+7EdXR0RGpq6qQFBVmMTSoopDpl6vkeTVNDWlqaVbV1RjIwMICioiIEBAQgODiYFigSiYR2/AYEBEzJgKJSqfDJni9hFxSF4NjJzZ4e/Oh95PzhTzqfwNsbbqK+pACzVuTocaRjU3vpO/y/Z57U+/4ymYwenu/t7aVjiQICAuDh4aH1+kirLT4+HkFB+hlOLAHiKnZwcLhtw4wh0RQo5KLQ0HN/zc3NaGhoAIfDseps0KGhIeTn548p9kZC1uiR91Ymk4HFYsHf3x9+fn5m2/1NURQdPE7iiZ5//nlcuHABly9ftuqLpOmITfBNEiL4qquroVarkZiYaLTnGhoawg8//ECXlXWBVO76+/vB5XLh6uoKtVqttRO3uLgYfn5+BnHijmyfyeVyrTw6Y5kmNGNXMjIyrNr5RXZ+jrYFZGhoiBZ//f398PT0pKtT+rbPTp+/iOJWPpLuWKTzfX46cRjhMxMRFB2r0+33/89WrH3iGTANLC6aKkqwKi3OIGYpEppLRhbITKW/vz+Gh4dRVVVlsgBfY0EyxFxcXJCammqySrzm3J9QKKTb6uR7QZ+5v8bGRjQ1NRl1V7EpmKzYGw1StRYKhejv74eHhwf92TXVrDVFUaiurkZPTw89D7plyxYcO3YMly9fturtINMVm+CbJETw1dXVQSqVIiUlxWjPJZPJcPnyZSxZskSnL2qyr5DY4YkTF7jlLu7u7kZZWZlO68X0gaIoiMVi8Pl8CAQCDA0N0V/yhhzuVigUKC0thUKhQEZGhsUEeOpDZ2cnKisrkZCQMGEVSXNdVk9PD+34Ha06NRF19Q3415GTSF2WA0cd3j+lUokrB7/CXff+bsLb/ngsD4HhkQiLT9L5eHSFoii0Xz2P5/9g2M0bmjOVXV1dUKlUYLFYCAkJga+vr1Vl7RFkMhkKCgrg6emJpKQks41dGGLur6GhAS0tLeByufDw8DDBURsHIvbYbLbBzD9yuZye++vp6dG6cDHWuA1FUaitrYVAIACPx4OTkxNee+017N+/H5cuXUJcXJzBn9PG1LG+bzEzQ/5ATbHnlrRASCjyeBAXoZeXF5KTk7WcuAwGA62trairqzPqTlzNPLqYmBj6S76trQ1VVVUGCSOWyWQoKiqCs7MzeDyeVZ6IgVtfmKQ9RdruE+Hk5KQVm0Fmp/Lz8ycdSRITHYUtTz2KDz/9J9gZs+EXFDLu7e3t7XWKZ5HLZOgTdCJr6aoJb6sPDAYDIgUFqVRq0PBWJpMJX19fDA4OAgASEhIglUpRX1+P8vJyun02mY0J5kQqlaKgoAA+Pj5ITEw067C/ZiZdVFSUVlu9rq5u3Lk/iqLotW/TQewVFBQYVOwBt1ykQUFBCAoKgkqlQl9fH4RCISoqKqBUKrXm/gxx0U1Ghvh8Png8HpydnfHXv/4V+/bts4k9C8dW4dMDuVyO5uZmCIVCcLlcoz2PWq3G2bNnsWDBgnEFUk9PD4qKihAWFoaYmJhJOXFNBVk4LhAIIBKJ6NZkQECAztEDg4ODKCoqMlg72lyQq2Oye3mq7Sm1Wk3PTgkEAgCY1Ezl13mH0KmyRyx31ri3O7z7Q9z9wCa4uo990j246wMsvH8D3DyM13IbEg/Csa0WD9yr3+aO0aAoCjdv3kRnZyc4HI6WsNCsTg0MDFj8NgpiBiDxRJbq7ARGn/vTrE41Njaio6MDXC7Xqsc2iNgLCAgwWawPRVEYHByk31uxWGyQz259fT3a2trA4/Hg6uqKv/3tb9ixYwcuXrxotL3vNgyDTfDpgVwuR1tbG9rb25GVlWXU5zpz5gzuuOOOMUURqZ4lJCTQoZ76OnFNhVwup2f+yOD8RFl/PT09KC0tRUREhFXErowFiS8YGBgAh8MxeM4WRVEQiUS0QJHL5VqzU2MZdPILi3Dy6g2kL1kzppDmt7eipbIU3EXLR/33hopSCFsakLFwmcFez1jUXD6NV57+g0Eei6IoVFVVoaenBxwOZ9wTIWmra7pSdQnSNhUki9IaA3xHzv3JZDIwGAxERUUhODjYInYo64NUKkV+fr5Jxd5ojDQsubq60tU/b29vnY6LBPTzeDy4ublh586deO+993D27FnweDwTvAobU8Em+PRALpejs7MTjY2NdDijsTh//jyys7Nva2WQKlFraysyMjLAYrEM6sQ1FZrbErq7u+Hk5AQ2m63V3rH22BUCWflGctCMfQIjM5VEXEskEro1OZrjt6enB7v2/Buxdy6Dh/fo2Wan9+7Gkt+PPj934MNtWPPEMyY5oTVXl2NJQgRSk5On9DiaWyc4HM6kRg1IW53EZpBAXXNFFZG8wLCwMERGRlqV2NOEoijU1NSgq6sLM2bMgEgkMlve31QhYs/f39+iqq0jI18AaLV+RxuVaWpqok0z7u7u+PTTT/HGG2/gu+++M/p50IZhsAk+PSAVqurqatxxxx1Gfa5Lly7dljdlaieuqRiZ9WdnZwcnJyeIxWKd59wsFc3Zw9TUVLNkaA0NDdHvrabjV7OtrlarsXvPv0AFhCF0FNPFwV3vI+fJ2+NZzu//F2LTOZgRYbxcSk0oikLbT+fwpycf1/sxVCoVSkpK6M0AUxHgmlFFQqEQKpWKPoEa061OIJmdxJBlrRCxR8ZlyOdytOqUpQcSW6rYGwlJWiDv79DQkNbMqrOzM519SOYo9+7diy1btuDEiRNTWgxgw7TYBJ8ekDiHkpISLFiwwKjP9f333yMpKYkWO8PDwygsLASDwaDT8k3pxDUVSqUSJSUl6O/vpwWrObL+DIFYLEZRURFYLJbF7GAd2ZocmUd3/tIV3GhoQ/Kdd2t9hn4+dwoBwaEI1xCD4oEB/HD4ayy6f6NJX0P5lXN46aEH9ar2KBQKFBcXAwDS09MNWgGnKAoDAwP0+0tOoKT1a2jTB/kuio2NRWhoqEEf25SQ1npvby+4XO6YIyjjzf1ZyneDtYi90SCRL93d3RCJRHB0dMSBAwewZs0aLFy4EN9++y2ee+45HD16FAsXLjT34dqYBDbBpwcKhQIikQg3btzAokW6Z5npw48//oi4uDgEBARgcHCQdt4lJSXRTlwGg2EyJ64pIGJPoVAgPT0dTk5O9FyaQCCAQqEwSdafIRCJRCguLkZISAiio6Mt8ot/5Ao94viVymQ4fP57pC5dC8f/a3Wq1Wpc+GavlrjL27ENSzc+Didn086ISiUSMJor8Pv7fjOp+5H4IicnJ5NUW0dmpnl6etLieqqtSbI72NrDoUmAb19fH+381AXNuT/NHFBSWTXH3J81i72RtLS0oKysDB9//DGuX78Oe3t7SKVSvPrqq3jppZfMFvhsQz9sgk8PFAoFBgcH8dNPP2HJkiVGfa5r164hIiICDg4OKC4uRnh4OKKjo+kWLhF7NTU1ZnfiGgLS+iQn45FijjjPiPiTSqVgsVj0GjJLGuwmmxqsqfKiUqm0dvzK5XJc/jkfUXMXgR0WCQA4/tkOrHzk1tLwyhtXIRMPInnOnWY53upLp/DqM0/pfHupVIrCwkJ4eHggOTnZ5NVWzSzF3t5euLi46N2a5PP5KC8vt/pwaIqiUFFRQY+o6CsiyMwqeX815/4mkwYwFYjYI+M01iz2Ojs7UVVVhfT0dLBYLBw8eBCPPvooFi9ejPLycvT09GDp0qVYvXo1Vq5cCX9/f3Mfso0JsAk+PVAqlZBIJLh8+TKWLl1q1D/qX375Bc7OzuDz+UhMTKSzlizdiasP+sSukC94Pp8PsVhskKw/Q9DW1oba2lokJyebdHG4IaEoCj09Paiursaln67CPjASyXPvxJFPd2Lhb34HV3cPHNr1AdY88YzZjrHtZhXuiAgEj5Mx4W0lEgkKCwvh6+uLhIQEs5+Mx2pNkrGF8T7/HR0dqK6uRkpKilWfaDVNM1wu16DtblPP/ZHsQ19fX6sXe+RiIi0tDX5+fjh9+jR+//vfY8+ePbj33ntBURRKS0tx7NgxHD9+HE5OTvjhhx+m/LwfffQRva82LS0NO3fuHDMJY8GCBbhy5cptP1+xYgVOnjwJANi0aRP27t2r9e9Lly7F6dOnp3ys1ohN8OmBUqmETCbDhQsXsHjxYqO1FCmKwvfffw+5XA4ulwsfH5/bnLjFxcVwcHCwaCeuLhgidkUqldKVv7FMCcZGc79veno6fHxGd7taA8RVrFarkZaWdiu65adfEDvrTlTnX0NvVycyFiyGf7B5q5etP53DnybYvGHpcSXE9EFak5qBuSPjdMjFRFpamlUbmdRqNcrKyjA0NAQul2vU6jwR12RswdBzf9NJ7AmFQpSWliI1NRX+/v64dOkS7rvvPuzevRsPPvjgqK9teHh4ymJ9//792LBhAz755BNkZ2dj+/btOHDgAGpqaka9aO7t7YVcLqf/u6enB2lpafjHP/6BTZs2Abgl+Ph8Pr744gv6dk5OTlb9vTwVLHf4ycIhXxBKpdIogk+lUqG0tBRyuRxhYWHw9vbWEnvEiUuqFZZgBNCXjo4OVFVVTTl2xcXFBeHh4QgPD9cyJdTV1dFZf2w2G25ubkb5Qlar1fTQeWZmplUHxWrG+mRkZMDOzg5zZ89CYvxM7Pjnl2itq4e3f4DZxR4ADKpv/T2MtYWBOFgjIiIQGRlp4qPTDbLpw9fXFzNnzqTHFpqamlBRUUG7JoeHh+koJms+aanVapSWlkImkxld7AG3NsWw2Wyw2Wytub/q6uopz/2RFXYsFsvqxV53dzdKS0uRnJwMf39//PDDD7j//vuxY8eOMcUeAINUZv/+97/jsccew0MPPQQA+OSTT3Dy5En885//xJYtW267PYvF0vrvb775Bq6urrj33ntvO7bAwMApH990wFbh0wOlUgmVSoWzZ89i7ty5Bs+EkslkKCwspGNJ3NzcEBERAUDbiRsZGWnVIcRkbVJLSwvS0tJu+wM2FCOz/pydnenKn6HCcolAl8lkyMjIsOph5qGhIRQWFsLLy2vUHaxqtRpPPvMcfCNjET93IVzMnIk2LJNCWVuMTb994LZ/Iycwa5qjHAmJ02ltbYVMJoObmxtmzJhB59FZ29+/Wq1GSUkJhoeHweVyzdqZmOrcn0wmQ35+Pu3At7bfhSbE7Z2YmIjAwEBcv34dubm52Lp1K5588kmjvja5XA5XV1fk5eUhJyeH/vnGjRshEolw9OjRCR8jJSUFs2fPxqeffkr/bNOmTThy5AgcHR3h4+ODhQsX4u2337bqyvhUsFX49MCY+3SJE5fFYiEpKQnV1dXo7u6Gp6cnfHx80NbWNi2cuKashjk4OGDGjBmYMWMGVCoVLf6IqCbiT5cdtKMhl8tRXFwMBoMBHo9n1a110voMDAwccysAk8nE7l07IJVKceDIMVTwu8FOTIffjGAzHDHg5OyChu4+UBSldbxkDsnaA7tdXFygUCigVqvB5XLpNYUNDQ1wdnamxYml5tFpQrIPlUql2cUeoL3/e7w9v6NdHE4nsdfX14eSkhLEx8cjMDAQhYWFWL9+Pd544w2jiz3g1oWZSqW67ZzGZrNRXV094f1/+eUXlJeX4/PPP9f6+bJly7Bu3TpERkaivr4e//3f/43ly5fj2rVrFhHfY2psgm8KGFrwCYVClJSUICIiAlFRUVCr1QgJCUFLSwu9CJuiKMTExFj1oLZm7EpmZqZJq2F2dnZarR3iSC0rKwNFUfSXu6+vr07ij7g+3d3dkZycbNVfIn19fSguLtZ5jtLFxQUbHrgPFEXh3MVLKLhyGna+gYhISjP5yc8rIg6/3MhHdlYmAKC9vR01NTX0HJK1QoKIBQIBvc4KAL1GkcylkQsOS8uj00SlUqG4uBgqlQocDsci45ScnZ0RGhqK0NBQrbm/wsJCrbk/Nzc3FBYWTguxR6Kj4uLiEBQUhLKyMqxZswZbtmzBs88+axWv7fPPP0dKSsptBo/777+f/t8pKSlITU1FdHQ0Ll++bPRINUvE8v7irAhDCr6WlhbU1NQgKSmJrkSp1Wq4ubkhLi4OMpmMXo3V2tqKxsZG+Pn5gc1mw9fX1+K+3MdCM3aFx+OZ9UufyWTCz88Pfn5+Wjtoq6uroVAotMTfaMc5MDCAoqIisNlsq8/bIhEycXFxCAkJmdR9GQwGlixaiCWLFqK6uhonL56FmOmIuKy5sHcwTUxOUFQMfvzxHLKzMtHc3IyGhgY6TsJa0QwizszMvM2Br1mdHjmXplAodNqhbCpUKhWKiopAUZTFir2RjDb3JxAIUFVVheHhYTg7O8PLywsKhcKi4qAmA/kOi4mJQUhICCorK7F69Wo8++yzeOmll0z2nebn5wc7Ozvw+Xytn/P5/Ann7yQSCb755hu8+eabEz5PVFQU/Pz8UFdXZxN8NnRDs6WrVCqn9FgURaG6uhodHR3g8Xi0OYOiqNucuLNmzYKDgwOd5C8QCFBbW0sPHVt6EDGJXbFEowmDwYCPjw98fHwQFxdHD83X1dWhvLycPnn6+/vDwcGBdhVHRkZa9UYTAPSuYkPkucXHxyM+Ph69vb349uhxdPYPIZw7a8zdvIZEDDsUFRXReW6enp5Gf05joVarUVFRgYGBAZ2CiJlMJlgsFlgsFuLi4ugdys3NzaioqICPjw99AWPq+VKlUomioiIwGAxwOByruTjVhLy/rq6uEAqF8Pf3h4eHB1pbW1FVVQUvLy/6+8FUiQBThYxvREVFITQ0FLW1tVi9ejUeffRRvPbaayb9TnN0dASXy8WFCxfoGT61Wo0LFy5g8+bN4973wIEDGB4exu9+97sJn6etrQ09PT1WPeIxFWymDT1Qq9VQKBT4+eefERISguBg/WaXlEolSktLIZFI6MBRzZ24ZCXXeAKJDB3z+Xw6iHikOLEEiEAKDw+3usXu5OQpEAggFovh6uqKoaEhxMbGWvXeUuDWQvTGxkajmWYUCgWOnfoOlc3t8IqIxYzIGIM/B0Euk6HmzCG89NwzVu2Q1owr4XA4U3ZAkpk/gUAAkUgEd3d3ujJobNOHQqFAUVER7OzskJ6ebpVij0DcuN7e3khMTKTft7Hy/gxpCjM0YrEY+fn59PdxQ0MDli1bht/85jf44IMPzHIxvn//fmzcuBG7d+9GVlYWtm/fjm+//RbV1dVgs9nYsGEDgoODsXXrVq373XHHHQgODsY333yj9XOxWIw33ngD69evR2BgIOrr6/HSSy9hcHAQZWVlBl9xaA1YZinISrC3t9e7pUucuPb29sjOztZ6LCaTqbMTV3PoOCYmBhKJBHw+Hy0tLaisrKR3eAYEBJit7UBiVxISEqxy/ZO7uzvc3d0RGRmJuro6NDc3w9XVFTdv3oRAIKDfX2sKvaYoCjdv3kRnZ6dRq2EODg5Yv3YN1gO4ev06fvz+DBSunojhZBv8pOLo7AyGm6fBXfOmhJgaFAqFwQxALi4uCAsLQ1hYGORyOW1aamxshJOTEy1OvL29DSpOFAoFCgsL4eDggLS0tGkp9oDb5/66u7shFApvm/uzlLlKiUSCgoIChIaGIjIyEi0tLVi1ahXWrFljNrEHAPfddx+EQiFee+01dHV1IT09HadPn6a7Di0tLbcdW01NDX788UecPXv2tsezs7NDaWkp9u7dC5FIhKCgICxZsgRvvfXWr1LsAbYKn16QCl9xcTG8vLwmne01MDCAgoIC+Pn5ITExkX5MAFo7cYk9Xl9InINAIMDAwAC8vb3BZrNNtoWCoig0NjaiubkZqampVm2FpygKtbW16OrqQkZGBjw9PbWy/np7e01aOZkKarUalZWVEIlE4HA4Jm9BtbS24vCps+hTUIjJmgMnF8M9P7+lCek+jpg3Z47BHtNUKJVKFBcXg6IopKenG706T0wfpDoFQGvTx1TEiUKhQEFBAZycnJCWlmZR4xuTZTyxNx6ac39CoZCeqzTnnt+hoSHk5+djxowZiImJQVdXF5YuXYoFCxbg008/terfk42JsQk+PaAoCnK5HGVlZXBxcUFMjO5tKoFAgJKSEkRFRSEyMnLUnbjk6sbb29tgxyyTySAQCMDn8+ktFGw222iVKRK70tPTg4yMjDFDca0Bsv5pYGBgTIGkUCho8dfT02OUrD9DoJkXaIh24VSQSCT49sgxNHf3YUZSBlhsw8zVNP94Fi8++bhBHstUmLv1qVar0d/fT4uT4eFhvcOI5XI5CgoK4OrqipSUFKsWEcPDw8jPz6czKfX9O9bM+yOjIaae+yN7fgMCAhAXFweBQIDly5cjMzMTe/bssYjqow3jYhN8ekAEX2VlJezs7DBz5kyd7tfU1ISbN28iOTkZgYGBY+7ETU9PN+oXAKlM8fl89PX1wd3dnRZ/hmiHkdnE4eFhqw8hJuvFVCoVMjIydDrxaWb9dXd3w97eXivrz1zij1SlAZikgqQrarUap8+dR3FtPRzZIQhPSJnS41VdvYzN966xGoeuXC5HYWEhnJyckJqaavYT72jixNvbmxYn410gErHn5uaG5ORkm9gbg9Hm/sj7a4wLRJIZSFa/9fT0YMWKFUhMTMRXX31lsUY/G4bFJvj0gAi+mpoaqFQqui07Fmq1GtXV1ejq6gKHw4GXlxftxGUwGGbdiSuXy7UqU1NdQSaTyejXkpaWZtVfJJoRMqmpqXq9Fs2sP4FAAAC0+GOxWCY7IZLX4uzsbBGiYizKKipw9vufMGTnhJjMObC3n/zfgkIuR+e183j68UctPi5jeHgYBQUFdI6jJQokYvoQCoX0BSJp/bq7u9PfEeS1eHh4jLqhxZogr8XT09PgYm8kmnN/xtjzS4Srj48PEhISIBKJsHr1aoSFheHbb7+1+L8RG4bDJvj0ZHh4GPX19ZBIJEhNTR3zdiRkmCwI18eJayqUSiUt/jRXkLHZbHh4eEz4pUdeCwkjteYvfGO8Fs2ZHoFAAJVKpRWnYywRJpFItEJireH3IhQKceD4SfAHpYjgzoa7l/ek7v/LsW+xJCuDrkxZoqlGKpVqzYZZw+9Fc01hT08PHBwc6C0fdXV18Pb2NrpAMjamFHsjUavV6OvrowX2VOf+5HI58vPz6dcyODiINWvWwM/PD4cPH/7Vmhd+rdgEn54MDw+jqakJfX19yMjIGPU2ZAuDo6MjXe0iTlxL34mr2ZYUCoX0FzubzR51hVNvby9KSkoQFhaGqKgoi3otk4Ukz4eEhCA6Otoor0UzS1EgEEAmk2mJP0NVeQcGBlBYWIigoCDExsZa3e9FLpfj0PGTqGntACsmAYHhUTrdT9jWjBgHJRJmxtFtM1K9HlmZMgdDQ0O0cSs+Pt7qfi/Are+I3t5edHV1oaurCwwGA4GBgXRYuaVWkcfDnGJvJKS1Tr6DSWudVP8mGvtRKBTIz8+n2+tDQ0PIzc2Fi4sLjh8/bnEXQDaMj03w6YlcLkdLSwv4fD54PN5t/97f34/CwkL4+/sjISEBFEWBvNUMBgNtbW24efPmlJ24poB8sfP5fAiFQq2Efx8fH3R1daGystJqY1c0IRsnYmNjERoaapLnpCgKEolEK+uPxOn4+/vrfRVORDi5oLBmRCIR9n39DboGJXANDEN0Om/Ck3HjD2fx0lO3zBualanu7m44OTnRn2FT76AVi8UoKCjAjBkzrFKEa0KqlD4+PggKCqI7BMPDw1qbPqyhbajZkk5OTra438tk5v6IS9rFxQUpKSmQyWRYv349AODkyZNWnVNpQ39sgk9P5HI52tvb0draiuzsbK1/4/P5KC0tRUxMDMLDw29z4tbW1qKzs9PgTlxTQFoOJOiZzCJGR0cjPDzcKtpSY9HW1oba2lokJSVNeePEVBgZp0PcfJNpS/L5fJSXl08LEU6Ea1RUFMLDw9HY1IQjp8+hX8VAbNY8OI5hCqq+/gOeWLsUAQEBWj8fGUdCdtCaYq6SVFxDQ0OtvhJOqpT+/v5aqwXJBQwRf4ODgxa/icLSxd5IFAoF/RkeOffn6emJkpISeo5aLpfj/vvvx+DgIM6cOWPVG2hsTA2b4NMTuVyOrq4u1NfXY87/ZX5RFIWmpibU1dUhJSUFbDbbbE5cY0NiV4RCIXx9fdHX1weVSqW1f9ZaWjoURaGhoQEtLS1IT0+Hj4/x14DpCrmqFwgEOjuqiXBNTk6+TexYG0KhEGVlZZg5c+ZtG20GBwdx4OhxNHeLEJLKg7e/9mtVKhUYKLmGJzZtGPPxR2alKZVKrcqUIU1HIpEIRUVFiIiImHR2p6VBwnvZbDbi4uLGFUgjP8OktU7Wk5lbXJE5N2s1m2jO/QkEAnR2duIf//gH1q5di7Vr1+KFF15AV1cXzp07Z1HfbTZMj03w6YlCoYBAIEBlZSXmz59PCyA+n087ccmeXU0nrr29PdLS0iwmEkMfRotdoSiKzvHi8/lQKBTw8/MDm802qiFhqhAHdXd3NzgcjkW3OkZm/bm4uNCVP5JzSIKuLU246kNnZycqKysn3PGrVqtx8vRZlNY3wiUwDKHxSfS/VVz8Dq89/YROJ3GKougdymRNoWZrfSptyd7eXhQXFyMmJgZhYWF6P44lIJFI6PDeybakSWudVKYcHBy0Nn2YWmwRsWfJLmldUalUKCoqglAoxIULF3D+/HncvHkTbm5uePnll/Hggw8iOjra3Idpw4zYBJ+eKBQK9Pb2oqioCHfccQeKi4shk8nA5XLh5ORksU7cqaIZuzJWhIzmiZPP5xvNkDBVNEOIrS0vUKlUoqenB3w+nz5x2tvb059Ba2/btLa24ubNm0hLS5vUhpbiklKc++k6ZA4uiOXNhkgoQLSdDHcvWjjpYyBzlUKhUO/WOgB0d3ejtLR01CqltUHmD4ODg6dsaNKMLBIKhVCr1XRb0tfX1+iRTtMpM1CtVqO4uJjOCwWAxx57DIWFhXj00Udx8eJFXLp0CXFxcVi7di3uueeeMc2Gk+Gjjz7C+++/j66uLqSlpWHnzp3Iysoa9bZ79uzBQw89pPUzJycnyGQy+r8pisLrr7+Ozz77DCKRCHPnzsXHH3+M2NjYKR+rDZvg0xuFQoH+/n5cv34dLi4u9Aoha3LiThYiXH18fHSOkSDzPGTmTyKR0C2zqVZNpoJcLkdxcTEYDIZFhRDrAwlUHhwcBIPBoOd52Gw2fHx8rOpERsYimpqakJGRofeMa1dXFw6e+A7CITnU0kG8+fKLUzqu0Vrro2XRjUQgEKCsrAyJiYmYMcMwm0TMxeDgIL2D1dDzh6RDQN5jmUxmsOrqaEw3sUc6LlwuFwwGA5s3b8a1a9dw5coV+nPX39+P06dP49ixYwgJCcG2bdum9Lz79+/Hhg0b8MknnyA7Oxvbt2/HgQMHUFNTM+ooyZ49e/Dss8+ipqaG/hmDwdCq3m/btg1bt27F3r17ERkZiVdffRVlZWWorKy0qgtyS8Um+PREoVCgs7MTRUVFCA0NRXx8vFU7cSfCULErmm7UwcFB+Pj40FUTU2VCkbgc0sax1HazLqhUKpSUlEAulyMjIwMODg63Zf1Zy1wlRVG4efMmOjs7weFwDLKOb3h4GMdOnMS969cZ4Ahvoavjl7SkU1JSrH6Wkog98vdvbEarrpLP8VRnn6eb2CNz4VwuF3Z2dnjuuedw6dIlXLp0yajjA9nZ2cjMzMSuXbvoYwkNDcXTTz+NLVu23Hb7PXv24LnnnoNIJBr18SiKQlBQEF544QW8+OKtC7T+/n6w2Wzs2bMH999/v9Fey68Fm+DTk9bWVnrl1uLFiwGAbuECsGon7kjIiSs+Pt6gLSmpVEoLk/7+fnh5edGGBGNdzQ0MDKCoqAhsNlvLWWiNkColk8lEenr6bS0wzaw/Pp9P70e1tNY6cOtYye5lDodjkBV/poA4fon4I45fOzs7tLW1IS0tDX5+fuY+zCkxMDCAgoICs8X7yGQyWmBPdQ3ZdBJ7FEWhvLwcYrEYXC4X9vb2ePnll3HixAlcvnzZqMYguVwOV1dX5OXlIScnh/75xo0bIRKJcPTo0dvus2fPHjz66KMIDg6GWq0Gh8PBX//6VyQl3Zq5bWhoQHR0NIqKipCenk7f784770R6ejo+/PBDo72eXwvWu/fKzEgkEiQlJaG0tBQKhQJ2dnZgMpn0FZdEIkFWVpZVO3E122vp6emTmqXSBRcXF4SHhyM8PBzDw8O0+KutrYWHhwct/gz1Hvb09KC0tBQRERFW316XyWQoLCykT1yjVe4YDAa8vLzg5eWFmJgYOsS1qakJFRUVdMssICDArDlparWaPnFlZmZaVetGM5OSOH7r6+shEonAZDLR2dkJlUplkpk0Y0DyREkkjjlwdnZGSEgIQkJC6DVkAoEAhYWFsLOzoyt/E40vELHn6uo6LcReZWUlBgcHwePxYG9vj9deew1HjhzBpUuXjO4C7+7uhkqlus1MxWazUV1dPep9Zs6ciX/+859ITU1Ff38/PvjgA8yZMwcVFRUICQlBV1cX/RgjH5P8m42pYX3fQBZCTEwMFAoFysrKUF9fjxkzZsDJyQklJSWwt7dHVlaWRVVQJoume5XH4xmkvTYeTk5OCA0NRWhoKORyOS3+6urq4ObmRos/fV20pEo5HXLpyKo0YgLSRbgyGAx4eHjAw8MD0dHRdNZfR0cHqqurtVaQmVJwabakeTyeVQT0jgWTyUR/fz/EYjF4PB6YTCaEQiHq6+tRXl5u1Jk0Y0BiZKKjoy3GWWxvb4/AwEAEBgbScSQCgQAVFRVaqwpHCmxNsZeSkmL1Yq+qqgp9fX3g8XhwcHDAO++8g3379tHGDEtk9uzZmD17Nv3fc+bMQUJCAnbv3o233nrLjEf268Em+PSksbERgYGBSEtLuzUgfvAgqqurkZubi+joaKu8micolUqUlZVBJpMhKyvL5BUXR0dH+opeM4qksbGRjiJhs9k6r8dqampCQ0PDtGiv9ff3o6ioaMpr31xdXelKp6YhgVRXifgzZmuVmE0AgMvlWvUFEkVRqK+vR1tbm9YFEqmukpm0trY2VFVV0QLb39/fIldc9fX1oaioCHFxcQgJCTH34YwKk8mEr68vfH19ER8fT48v1NfXo6ysjN5B6+3tjfLy8mkj9mpqatDT04PMzEw4OTnhgw8+wKeffoqLFy8iMTHRJMdBorb4fL7Wz/l8vs7z6g4ODsjIyEBdXR0A0Pfj8/laBic+n6/V4rWhP9arSsyIXC7H7Nmz4e3tjbVr18LDwwPvvfceNm3aBE9PTxQXF8POzo6uSnl7e1tN+3B4eBhFRUVwcHCgrx7NiYODA4KCghAUFKTVzrlx4wYcHR1p8TfaLA9FUaitrUVXVxe4XC68vLzM9CoMQ09PD0pKSgye5ebs7KxVXSXir76+np6XIll/hvocy+VyFBYWwsnJCampqRZtJpkIzc8Zj8cbtQrt5uaGyMhIREZG3iaw3d3dtQS2ub8rSGagNcXIaI4vxMbG0ps+2tvbUVVVBXt7e7DZbEilUquZDx0JMTUJhULweDw4OTlh586d+PDDD3Hu3Dmkpqaa7FgcHR3B5XJx4cIFeoZPrVbjwoUL2Lx5s06PQRYRrFixAgAQGRmJwMBAXLhwgRZ4AwMD+Pnnn/Hkk08a42X86rCZNvRELBbj1KlT2LZtG91e+93vfod169YhPT0dIpGI3j1LrOdkzsTcX+hjoU/sirnQHJYXCoWwt7enT5re3t70QPPAwAA4HI5Vz1ICt2JGKioqTBrvoSmwSdYfEdhT2T8rk8m01lhZ8udsIiiKokcfuFzupD9npIJNgojNueMX+M9FRXx8vNWPPpB9so6OjvD390d3dzd6enrg6upKz/1N1vRhTurq6tDe3o7MzEy4uLjg008/xRtvvIHvvvtOq1VqKvbv34+NGzdi9+7dyMrKwvbt2/Htt9+iuroabDYbGzZsQHBwMLZu3QoAePPNNzFr1izExMRAJBLh/fffx5EjR1BQUEBXJrdt24Z3331XK5altLTUFstiIGwVPj1xcXHB9evX0dLSggsXLqCvrw8HDx7E6tWr4e3tjTVr1mDdunWYN28e+vv76f26DAaDPmmaI1l+LAwVu2IqRg7L9/b2gs/no6SkBMCtK357e3u67WHNaIYQm7IlrTkvpVKp6JBckl9I3v/JZP3pM39oqajValRWVkIkEoHH4+nVmtWsYGtexBQVFYHJZOr1HusLCYhOSEiw+sxAIvacnZ2RmpoKJpOJ0NBQOrCcmD7Ie+zv72/0PcpToaGhAe3t7fTnbO/evXj99ddx4sQJs4g9ALjvvvsgFArx2muvoaurC+np6Th9+jRtumhpadF6P/v6+vDYY4+hq6sLPj4+4HK5uHr1qlYb+qWXXoJEIsHjjz8OkUiEefPm4fTp0zaxZyBsFT49kEgk+O1vf4vq6mqcPHlSa12NVCrFmTNncPDgQZw4cQLu7u5Ys2YNcnNzkZmZicHBQTqEmKIoWvyZMyDXWLEr5kAqlSI/P5/ORKQoSiuHzlK/0EdDc8fvVEKIDY3m/lk+n09vSJgo629wcBCFhYUICgpCTEyM1Ys9zUgMQ19UjNyPOp4hwRAIhUKUlpYiKSnJ6jNDRxN7ozHyPVYqlVrvsbnHWQgkKYHH48HNzQ1ff/01nn/+eRw9ehQLF05+g4yNXy82wacHlZWV2LJlC/bu3TvuvlKZTIZz587h4MGDOHbsGJydnWnxN2vWLIjFYvD5fPD5fFqYsNlsk11pktiVxsZGpKamWr2hgVSPSEuawWBohRCTL3Q2m20VIcTV1dUQCoUWveNXc4eyQCCAXC7X2qRChAlxfEZERBg9MsLYkJV8w8PD4HA4RnfcauYpCoVCg+74Bf6zDWSincXWgK5ibySa6yCFQiEkEglYLBa96s1cFaaWlhbU19fT6xLz8vLw1FNPIS8vD8uWLTPLMdmwXmyCz0TI5XKcP38eBw8exNGjR2Fvb4/Vq1dj3bp1mDNnDr1+jM/n09sRiDAxhvhTq9WoqamBQCAw2FYDcyISiVBcXDyme3WsEGI2mw0/Pz+LclWT6tHg4CA4HI5FujhHg6IoOutPc42eq6sr2traEBcXh9DQUHMf5pRQqVRaO0vNUQUaua1mKo5fPp+P8vLyabENRKFQoLCwEI6OjkhLS5vS9yaJLRIKhejv76ed6/7+/iYz1pBNTRwOB15eXjh+/DgefvhhfPXVV1i7dq3Rn9/G9MMm+MyAQqHApUuXkJeXhyNHjgAAVq9ejdzcXMybN4/+suHz+VAqlQZfjUViV6RSKTIyMqxGUIyFQCBAeXk5YmNjdRIUmsKEz+fTFRM2mw1/f3+ztnKUSiVKSkqgVCqRkZFhFXltYyGRSNDQ0ECHpmqu0bPGmRwSI0P2L1vCRYJMJqOFCdnxq6vjt7OzE1VVVUhJSYG/v78Jj9rwGFLsjUTTud7b2wtnZ2da/BnLWNPe3o6amhpwOBx4e3vj9OnT2LBhA7744gvce++9Bn8+G78ObILPzCiVSly5cgUHDhzAkSNHoFQqsXr1auTk5GD+/Pn0Fzqfz4dcLqfFH8lBmiwkdsXe3h5paWkWM6eiL21tbaitrUVSUpLe7ShSXRUIBBCLxWbbQEGiShwcHJCWlmYRgmIqkJNWSkoKPDw86KqUSCQyWdafoSCCgvxuLHEcQC6X067qnp6ecYUJCdxOS0sz+AYdU2NMsTcSYvogzmomk0m3fVkslkE+F0SIp6eng8Vi4eLFi7j//vuxe/duPPjgg1Y9+2rDvNgEnwWhVCrx448/4sCBAzh8+DBkMhlWrVqFnJwcLFiwAHK5nG77yuVyrZakLl801hS7MhGahob09PRxZyknA6muCgQCDAwMmGwDhVQqRWFh4bSIKgGA5uZmOuyaxWJp/ZtmxaSnpwdubm70e6xrmLYpGR4eRmFhoVUF946MLdJcQSaVSlFbW0sLCmvGlGJvJJrmJaFQCIVCAT8/P/j7++u9q5rP56OiooIW4j/88APuuece7NixA5s2bbK4vw0b1oVN8FkoKpUKP/30E/Ly8nD48GGIxWKsWLECa9euxaJFi6BUKmnxJ5PJJpxH6+vrQ3FxMUJDQ6e0ocES0Fz7ZkxDA6mukqqUp6cn7ao2ZBtcLBajsLAQAQEBmDlzplX/bjQ3TmRkZEwYdj0y64+EaZsrh24kJDPQ09MTSUlJViH2RqK5gqyrqwtKpRIsFgshISF6dwosAXOKvZEQ0we5kJFIJPQIg66mD2KeSU1Nhb+/P65fv47c3Fxs3boVTz75pNn/FmxYPzbBZwWoVCpcv34deXl5OHToEEQiEZYvX46cnBwsXrwYarWaFn9SqRS+vr60+HNwcKBDe2fOnGmxa5J0hTgkZTIZMjIyTDYLNjw8DKFQCD6fT89KkTDtqbQkiXvVWvIPx4OsfSJGoMkK8ZFVKVPn0I1EKpWioKAALBbL6jMDgf/kOcbFxUEqlUIgEEAmk9Guaj8/P6uZGVUoFFqjKZYmWsn7KxQK6REGUmEdbbayu7sbJSUltHmmoKAAa9aswV/+8hc888wzVv/Zs2EZ2ASflaFWq/HLL7/Q4k8oFGLZsmXIycnB0qVLoVar6Zk/sViMxsZGREVFITk52erzteRyudbQvLnmD8l2BD6fP6WWpFAoRFlZmc5mE0tGM4SYy+VOuQKqWZUimZXkhGmoWanxkEgkKCgomBZVV+A/LfaReY5isZiuSmk6fi3ZWKNUKlFYWGixYm8kI2cryTYVsueXhN4nJiYiMDAQpaWlWLFiBbZs2YL/+q//svrPng3LwSb4rBi1Wo2CggJa/HV2dmLJkiXIycnBwoUL8eyzz+Ly5cv4xz/+ATs7Oy0nqrVcyRPIjJu7uzuSk5Mt5kteqVTSJ8zu7m56UH6itU0dHR2oqqqaFkG3ZCemVCoFh8MxeAixZtYfn8+nZ6VIVcrQ5pbpFBANgM7aJPEeYzFyhEEzisRSciCtTeyNhFSxiemDoiicOXMGUVFRePDBB9HS0oLly5fj6aefxquvvmr1nz0bloVN8E0T1Go1iouLkZeXhwMHDqChoQHOzs545ZVX8PDDD8POzo4+YQ4ODsLHx4duSVq6+CMnYDabbdHVFpVKRV/JC4XCMXfPNjc3o76+flo4JEmMjKly6UikDnFVGzqEuL+/X6vFbu00NjaiubkZHA4Hnp6eOt9vLMevOffPWrvYG0lfXx8KCwtx5MgRnDp1Cr29vWAwGLj77ruxZ88eq/9usGF52ATfNIPP52PVqlUAgPnz5+O7775DY2MjFi9ejLVr12LlypVwcHCgW5IDAwNa+WiWtne2p6cHpaWliIiIQEREhMWKvZFo7p4VCAS0S1KhUKCnp2fCaos1QOao7OzszBYjMzKEeLKD8poQY1NUVBTCw8ONdMSmgbjYW1tbweVypxSsTi5kSFVK0/FrqtnK6Sb2+vv7UVhYiJiYGISGhqKurg6LFi1CdHQ0FAoFSktLMX/+fOTk5GDt2rUICwszyPN+9NFHeP/999HV1YW0tDTs3LkTWVlZo972s88+w5dffony8nIAAJfLxV//+let22/atAl79+7Vut/SpUtx+vRpgxyvDcNiE3zTiOrqaixfvhxz587F559/DicnJ1AUhYqKChw4cACHDh1CbW0tFi1ahLVr12LVqlVwdnamxV9/f79FzfCQHb8JCQkICgoy67FMBbVajZ6eHtTW1mJoaAj29vZ0ddWSF7aPB4kqcXFxQUpKikWcgKVSKd1e13RVBwQEwNXVddz79vT0oKSkBHFxcVZvbCJO6fb2dnC5XIO2Y0fOVpI9yiSKxBifAyL27OzskJ6ebhGftakwODiI/Px8+sKipaUFS5cuxapVq7Bz504wmUw0Nzfj2LFjOHLkCL7//nvU19dPWfTt378fGzZswCeffILs7Gxs374dBw4cQE1NzahbVn77299i7ty5mDNnDpydnbFt2zYcPnwYFRUV9M71TZs2gc/n44svvqDv5+TkZLCYLBuGxSb4pglKpRKJiYm499578fbbb49aCSP7WYn4q6ysxF133YWcnBysWrUKrq6uWidMLy8vWpiYWvw1NTWhoaFhWuz4JTNuQ0NDyMjIoB18AoGAXqNnyE0qxoa4V729vS02z1Eul9PvcW9v77jGGmKeSUhIwIwZM8x41FOHoijU1dWho6MDPB7PqKHWZLaSfGdoOn4NtbFGqVSiqKgITCZzWog9sViM/Px8hIeHIzIykp67XrhwIXbv3j3q35JIJNIy2uhLdnY2MjMzsWvXLgC3xHtoaCiefvppbNmyZcL7q1Qq+Pj4YNeuXdiwYQOAW4JPJBLRG6NsWDY2wTeNEAgEOu/DpCgKtbW1OHjwIA4ePIiysjK6hbB69Wp4eHjQX+R9fX3w9PSkxZ8xV7GR4+rs7NQpx83SUSgUKCkpgVqtvm3GTdOMIBAItMK0fX19LXLThjVmBioUCq2sPycnJ/qzLJVKUVFRgeTkZL03tVgK5G+Hz+eDy+WadIMJRVFa7XWxWAwfHx/6YkafC8bpJvYkEgny8/Ppfd98Ph/Lly9HZmYm9uzZY9TXJ5fL4erqiry8POTk5NA/37hxI0QiEY4ePTrhYwwODiIgIAAHDhygx4Y2bdqEI0eOwNHRET4+Pli4cCHefvtt2/yhhWITfDboFhBx+xYVFWHevHnIzc3F6tWr4e3trZVB5+HhQZ8wJ2qVTQa1Wo2Kigr09/eDw+EY9LHNAWl7Ojk5TTh3RIJbyQlztDxFc0MMDaGhoVabGaiZ9cfn86FWq+Hn54fw8HB4e3tbZLVSF0gGolAoBJfLNfvfzsj2+mRX6U03sTc0NIT8/HwEBQUhOjoaPT09WLFiBZKSkrBv3z6jX9x1dHQgODgYV69exezZs+mfv/TSS7hy5Qp+/vnnCR/jqaeewpkzZ1BRUUEL+G+++Qaurq6IjIxEfX09/vu//xvu7u64du2a1f/OpiM2wWdDC4qi0NTURIu//Px8zJ49G7m5uVizZg1YLBa6u7vB5/PR29trsABi4vZUKpXIyMiweOfwRAwNDaGwsFDvtqemE1UikWi1yszx3pCssOlgaABuhRDX1tYiKiqKFieaWX++vr5WI/4oikJVVRV6enrA4/GMWoHXB81Ver29vRM6fqeb2JNKpcjPz0dAQADi4uIgEomwatUqRERE4NtvvzXJxdxUBd+7776L9957D5cvX0ZqauqYt2toaEB0dDTOnz+PRYsWGez4bRgGm+CzMSYURaGlpQUHDx7EoUOHcP36dcyaNYt2jvn7+9PijwQQs9lssNnsSYk/zUpYamqqRbYyJwOJkQkMDERcXNyUK2FDQ0O0+NN0oprKVU1m3GbOnEkPa1szo4UQUxRF70UVCAR01p8lt9eBW8ddWVmJvr4+8Hg8sxutJkKpVNIV1u7ubtjZ2dEXMj4+PlCr1dNK7MlkMuTn58PPzw8zZ87E4OAgVq9eDX9/fxw+fNhkqQhTael+8MEHePvtt3H+/HnweLwJn8vf3x9vv/02nnjiCUMcug0DYhN8NnSCoii0tbXh0KFDOHToEK5evQoej0eLvxkzZmiJPxcXFy3xN5bokUgkKCwshI+Pj8UaACYDifYwVoyMpuGjv78fXl5etPgzRmWHOKWny4xbY2MjWlpaxs2lG6u9bkgzgiEgDvz+/n5wuVyLF3sjGc3xy2Aw4OjoCB6PZ/VV/uHhYeTn58PHxwcJCQmQSCTIzc2Fi4sLjh8/bvJKbHZ2NrKysrBz504At97/sLAwbN68eUzTxnvvvYd33nkHZ86cwaxZsyZ8jra2NoSFheHIkSNYs2aNQY/fxtSxCT4bk4aiKHR2duLQoUM4ePAgfvzxR2RkZCA3Nxdr165FcHCw1pC8i4sLHUCs6ZAUiUQoLi5GcHDwtNhoIBAIUF5ebrJoj+HhYfpkaYzZSrJ7dToERGu6VzkczqRy6cj6MbKu0BJyK8m86+DgILhcrsXlZ04WpVKJ/Px8yOVyMJlMDA8Pw8/Pj458sRSRrStyuRz5+fnw9PREUlISpFIp1q9fDwA4efKkWTaX7N+/Hxs3bsTu3buRlZWF7du349tvv0V1dTXYbDY2bNiA4OBgbN26FQCwbds2vPbaa/jqq68wd+5c+nHc3d3h7u4OsViMN954A+vXr0dgYCDq6+vx0ksvYXBwEGVlZVb/mZyO2ASfjSlBURT4fD4OHz6MgwcP4sqVK0hLS0NOTg5ycnIQGhpKt3CEQiE9v+Pg4ID6+nrExsYaLFTUnLS3t6O6uppefm5qyJwUma0k7XUSQzIZyBxnU1PTbbtXrRFiaBAIBFN2r46ssE4m689QqNVqlJeXQyKRGGWVnalRqVQoKioCAGRkZIDJZI7q+NU3UNvUyOVyFBQUwM3NDSkpKRgeHsZ9990HiUSC06dPT2rjiaHZtWsXHbycnp6OHTt2IDs7GwCwYMECREREYM+ePQCAiIgINDc33/YYr7/+Ov7yl79AKpUiJycHRUVFEIlECAoKwpIlS/DWW29ZfTdgumITfDYMBkVR6O7uxuHDh5GXl4fLly8jKSmJFn+RkZHo6enBrl27cPXqVbz22msICgoy67qmqUJRFJqbm9HY2Ii0tDSwWCxzHxIdQ6LZXieixMPDY9z3eSqVMEtEc8aNy+UatI02PDysZUZwd3fXcqIa4/OsVqvpTEcul2v1bc+RYm+0mb2pOn5NiUKhQEFBAR1IrlQq8dvf/hYCgQDnzp2z+osnG9aNTfDZMAoURaG3txdHjhxBXl4eLl68iLi4OLi6uqK8vBx79+4Fj8ejK3+a2yc0985aMhRF4ebNm3RmoDmv3MdCqVRqtdcdHR3p9vpIka3p9uRwOBZ3Mp0smm1PDodj1MrQyKw/Y+yeVavVKCkpwfDwMLhcrtW1OUdCxB5FUeBwODoZNEY6fsnFjL+/v9kvGslGEAcHB6SlpUGlUmHTpk1oaGjAxYsXrX4swob1YxN8NowOqfzde++9+Pnnn6FSqRAXF4e1a9ciNzcXM2fORG9vL/h8Pr2rkxg+LFX8qdVqVFZWQiQSWU1moGYGHXmfNcWf5kyYpbfNJkKtVqO0tBRSqdTklTCye3akE5XsntXn86xSqVBaWgq5XA4OhzMtxF5xcTEdSK6PC3osx29AQIDJMxVJlAxZ/6ZWq/HYY4+hvLwcly5dMsuYhw0bI/lVC7533nkHJ0+eRHFxMRwdHSESiSa8jy7Lont7e/H000/j+PHjYDKZWL9+PT788EOzDOpaAkNDQ7j//vvR0NCA7777Dh4eHjh+/Djy8vJw9uxZREREYO3atVi3bh3i4+MhEolo8cdgMGjx5+3tbRHij5x8ZTKZ1c5QqdVq9Pb20nNSSqUS9vb2SEhIgL+/v1W7pVUqFUpKSqBQKMwujka+zwBoUaLrHmXyekhGpU3s3Y7m+0wyFf38/EyysnBkWxoA/vjHP+L69eu4cuWK1a/rszF9+FULvtdffx3e3t5oa2vD559/rrPgm2hZ9PLly9HZ2Yndu3dDoVDgoYceQmZmJr766itjvAyLpre3FytXroSjoyOOHj162wzLwMAATpw4gby8PJw+fRohISG0+EtKSkJ/fz+dQcdgMOiKlLm2IigUChQXFwMA0tPTrf7kq1AoUFRUBKVSCS8vL3R3d1ttADFwq9JSXFwMiqIMJiYMxcisP6VSSYsSPz+/UUWJMcSROTHF6xm5stCYjl8ixlUqFTgcDhgMBp577jlcunQJly5dmhaGNBvTh1+14CPs2bMHzz33nM6Cb7xl0VVVVUhMTMSNGzfokMrTp09jxYoVaGtrQ1BQkAGP3PKRSCR499138f/+3/+bsE04ODiIU6dOIS8vD9999x3YbDYt/lJTUzEwMECLP4qiaPHn4+NjElEik8lQVFRED2RbeyisXC5HYWEhHB0d6dVv5GRJ3mddRImlQMQraatZ8rFqZv3x+XzIZLLbsv5Im5DBYCA9Pd0m9vSAoig6VsfQjl8yU0kqyUwmEy+//DJOnDiBy5cvIzIy0oCvxIaNqWMTfJi84BtvWfQ///lPvPDCC+jr66Pvo1Qq4ezsjAMHDiA3N9dYL2NaIZFI8N133yEvLw+nTp2Cr68v1qxZg3Xr1oHD4dBX8Hw+n65Isdlsndtk+hxPYWEhWCwWEhISrKrqNRoymQyFhYVwd3dHcnLyqK+HoigMDAzQlRKZTEaLP39/f4sSIES8km0tliz2RkMsFmvFkHh7e0MqlcLZ2VlnQ4MlYymVytFidUg1ezImJeKWJjOidnZ2eO2117B//35cvnwZsbGxRnwVNmzoh+V8Y1sJy5Ytw7p167SWRS9fvpxeFt3V1XXbgK69vT1YLBa6urrMdNTWh5ubG+655x7cc889GBoawpkzZ5CXl4c1a9bAy8uLNnzMnTuXrpRUVlZCpVLR4s9Q7ciBgQEUFhZOm4BoIl59fX2RkJAw5uthMBjw8vKCl5cXYmJiaFHS2NiIyspKsFgssNlsswfj6iJeLR0SZhsVFYWBgQF6Zq+/vx+FhYVG3aZibEa2Pc15oeDi4oLw8HCEh4drOX4bGhp0dvxSFIXy8nI6Gsfe3h7vvPMO9u3bZxN7NiyaaSf4tmzZgm3bto17m6qqKsTHx+v1+Pfffz/9v1NSUpCamoro6GhcvnzZtizaSLi6uiI3Nxe5ubmQSqU4e/YsDh48iPXr18PNzQ1r1qxBbm4u5syZA7FYDD6fj+rqaiiVSq1ZNH2qJL29vSguLkZUVBQiIiIM/+JMDNnzGxQUNCnxymAw4OHhAQ8PD0RHR9PBuC0tLbT4I6LElI5YqVSKgoICeHt7IykpyerFuEKhQFVVFdzd3ZGamgqlUkmLkps3b2pl/VmDCUzTcGJusTcSR0dHBAcHIzg4WMvxW1hYCHt7e/q7Q3NemKyzE4vF4PF4cHBwwAcffIBPP/0UFy9eREJCgplflQ0bY2M5f30G4oUXXsCmTZvGvU1UVJTBni8qKgp+fn6oq6vDokWLEBgYSLvxCEqlEr29vQgMDDTY8/5acXFxwdq1a7F27VrIZDKcP38eBw8exH333QcnJyda/M2ePRtDQ0MQCASora2FXC6nv8B1nUXj8/koLy9HQkLCtJi9FIlEKCoqQkRExJTni9zc3BAZGYnIyEhIpVLw+Xx0dHSguroa3t7etCgxZrwLqVT6+fkhPj7e6sUeaUs7OzsjNTUVTCYTdnZ2CAkJQUhICBQKBS3+GhsbJxWobQ4sWeyNhOSAstlsLcdvWVkZPTLi7+9Pt4KJ2Nu5cyc+/PBDnDt3DqmpqeZ+GTZsjItthg+Tm+Ebychl0cS0kZ+fDy6XCwA4e/Ysli1b9qs0bZgKuVyOixcvIi8vD0eOHIGdnR1Wr16NdevWYc6cOZDJZODz+eDz+ZDL5fDz8wObzR5T/LW1taG2thYpKSnw9/c3wysyLD09PSgpKUFsbCxCQ0ON9jwymYyekRKJRPTqMTabbdB2pFgsRkFBAWbMmIHY2FiLEzuThazjcnV1RUpKyoRt6ZFZf/b29loZdOZ+P6xJ7I2Hpompvb0db775JlxdXbF69WoMDQ3hb3/7G06fPo1Zs2aZ+1Bt2JiQX7Xga2lpQW9vL44dO4b3338fP/zwAwAgJiaGbpfEx8dj69atyM3N1XlZ9PLly8Hn8/HJJ5/QsSw8Hu9XGctiDhQKBS5fvkyLP7VajVWrVmHdunW44447MDw8TIs/YkTQFH+NjY1obm5Genq6VtyOtUIqlYmJiSbNBJPL5bT4I6vHyDaVqWzxIDOVoaGhiIqKMru4mSrDw8MoKCjQewZxZNYfg8Ggq9nGMjFNdDzEvTodcgMpikJtbS34fD6YTCaOHj2KAwcOQCgUgsfj4eGHH8batWttF/M2LJ5fteAbLUQZAC5duoQFCxYAuDW79MUXX2DTpk06L4vu7e3F5s2btYKXd+zYYRUzN9MNpVKJ77//HgcOHMCRI0cgl8uxatUq5Obm4s4774RCoaDFn0QiQUNDA2JjY5GRkTEtxF57eztqamrMXqkk7Ug+n0+vxCLiz93dXWfRRtrSkZGR02KmUiaToaCgAF5eXkhMTJyyOFOr1VpZfyqVyqSxOtNR7NXV1aGzsxM8Hg8uLi74+uuv8fzzz+Pjjz+GUCjE4cOHcfXqVWRmZiI3NxePPPKIwdaoffTRR3j//ffR1dWFtLQ07Ny5E1lZWWPe/sCBA3j11VfR1NSE2NhYbNu2DStWrNB6Pa+//jo+++wziEQizJ07Fx9//LHNaPIr4Vct+Gz8ulCpVPjhhx+Ql5eHw4cPY2hoCKtWrUJOTg7mzJmDDRs2oLq6Gp988glUKhV8fX0twoWqL83NzWhoaEBaWhpYLJa5D4dG04gwmb2zxEBj7La0qSBiz9vbG4mJiQavVI4Xq+Pn52fwzzQRe9Nl/RsA1NfXo62tDTweD25ubsjLy8NTTz2FvLw8LFu2jL6dQCDAsWPHcPjwYXz++ecGmdfev38/NmzYgE8++QTZ2dnYvn07Dhw4gJqamlFXtV29ehXz58/H1q1bsWrVKnz11VfYtm0bCgsLkZycDADYtm0btm7dir179yIyMhKvvvoqysrKUFlZafXrFG1MjE3w2fhVolKpcPXqVeTl5eHgwYPo6uqCq6sr3n33Xdx3331Qq9V0zp9YLNaKIDGlC1UfKIpCQ0MDWltbkZGRAS8vL3Mf0phozqIJhUI4ODjQM3+ae5S7u7tRWlqKmTNnIjg42MxHPXWIu5jkOhq7LU1RFO2sJll/xFnt7+8/5fWA01HskdEOHo8Hd3d3HDt2DI888gi+/vprrFmzxujPn52djczMTOzatQvArfc4NDQUTz/9NLZs2XLb7e+77z5IJBKcOHGC/tmsWbOQnp6OTz75BBRFISgoCC+88AJefPFFAEB/fz/YbDb27NmjlUBhY3piE3wWyGR3/CoUCrzyyis4deoUGhoa4OXlhcWLF+Pdd9/VmiuJiIhAc3Oz1n23bt066pfHr4Wenh6sXLkSSqUSWVlZOHXqFHp7e7F8+XLk5OTg7rvvBgBa/A0ODpotgkQXKIpCTU0NBAIBOByOVY0RqNVqOhqD7FEm73FjYyOSk5OnhdNdKpUiPz/frO5i4mAXCAQYGBiAl5eX3ll/01Hskeo4j8eDh4cHvvvuO2zYsAF79+7FPffcY/Tnl8vlcHV1RV5eHnJycuifb9y4ESKRCEePHr3tPmFhYfjTn/6E5557jv7Z66+/jiNHjqCkpAQNDQ2Ijo5GUVER0tPT6dvceeedSE9Px4cffmjEV2TDErBO69Q0Ry6X495778Xs2bPx+eefT3j7oaEhFBYW4tVXX0VaWhr6+vrw7LPPYs2aNcjPz9e67ZtvvonHHnuM/m8PDw+DH7+10NraiqVLlyIpKQn//ve/4eTkBLVajRs3biAvLw+vvPIKHn/8cSxduhQ5OTlYunQpmEymVgQJWdMUEBAw5SrJVFGr1aisrIRIJEJmZqbVhfQymUw6/kKtVqOvrw+NjY1oa2uDnZ0dent76RBzawxXBm79rebn54PNZiMuLs5shhNXV1dEREQgIiICMpnstqw/Xc0101Hstba2oqGhARwOBx4eHrh48SI2btyITz/9FOvXrzfJMXR3d0OlUmnNhgMAm81GdXX1qPfp6uoa9fYk8J/8//FuY2N6YxN8Fsgbb7wB4FZcjC54eXnh3LlzWj/btWsXsrKy0NLSorXA28PDY1pUSaaKSqXC0qVLMX/+fHz00Uf0MDuTyUR2djays7Pp+Ze8vDy8+eabeOKJJ7BkyRLk5ORg+fLlsLOzg0AgQFdXF2pqakyWPzfW6yGrnjIzM80uPqcKk8mEVCrFwMAAMjIyYGdnBz6fr7VNZSqB2uZAIpGgoKAAgYGBFhUl4+zsjNDQUISGhmpl/Wlunxgt60+tVqO0tBTDw8PgcrnTQuy1t7fj5s2b4HA48PLywg8//IAHHngAO3fuxIMPPmgxvzMbNvTBJvimKf39/WAwGPD29tb6+bvvvou33noLYWFhePDBB/H8889bbUbWVLCzs8PRo0fH3TbBZDLB4/HA4/Hw17/+FSUlJcjLy8PWrVvx5JNPYvHixcjJycGKFSvg6OhIt31ra2vh5eVFV0mMLf6USiW9uooEwlo7LS0tqKur03JL+/j4YObMmRgYGKDfZ5KpSIwIlvpZJrmBk91wYmocHBwQFBSEoKAgevsEn89Hfn4+PV9JzDVlZWWQyWTTRux1dHSgpqYGGRkZ8Pb2xvXr13Hvvffivffew6ZNm0z6OyOOaj6fr/VzPp8/5gV7YGDguLcn/5/P52vFM/H5fK0Wr43pi22Gz4LRNxBaJpNh7ty5iI+Px759++if//3vfweHwwGLxcLVq1fx5z//GQ899BD+/ve/G/jIpzdkl+a3336LQ4cOob6+HosXL8batWuxcuVKODs701WSvr4+eHp60uLP0G1WhUKBoqIi2NnZIS0tzWIFz2RobGxEU1MTXWUZC4qi6D3KAoEAUqmUdlYbw4WqL2KxGPn5+VadG6hSqeisP6FQCKVSCXt7eyQkJMDf399qW+yErq4uVFZWIi0tDb6+vigoKMDq1avxxhtv4JlnnjHL7yw7OxtZWVnYuXMngFsV1bCwMGzevHlM08bQ0BCOHz9O/2zOnDlITU3VMm28+OKLeOGFFwDcyrQMCAiwmTZ+JdgEn4nQZ8evPoJPoVBg/fr1aGtrw+XLl+Hp6Tnmbf/5z3/iiSeegFgstvoWoLmgKAqVlZU4cOAADh06hJqaGixcuBBr167F6tWr4erqSufP9fX1wcPDgxZ/rq6uU3ru4eFhFBYWwsXFBSkpKVbT2hwLiqLoGAwulzvp+VKxWExXWSUSiUU4qwcHB1FQUICwsDCDrnQ0F6SNS1y+ZNbMGlvsBLJCLS0tDX5+figtLcWKFSuwZcsW/Nd//ZfZBPr+/fuxceNG7N69G1lZWdi+fTu+/fZbVFdXg81mY8OGDQgODsbWrVsB3IplufPOO/Huu+9i5cqV+Oabb/DXv/71tliWd999VyuWpbS01BbL8ivBJvhMhFAoRE9Pz7i3iYqK0joxTVbwKRQK/OY3v0FDQwMuXrw4YfhnRUUFkpOTUV1djZkzZ+r0HDbGhjhkSdRLRUUFFixYgJycHKxevRru7u7o7u6mw4fJcDybzZ60+COxHiTDzdorLGSbQVdXF7hc7pTdxcSFSpzV5jDXkI0g4eHhU95dbAmo1Wp6TpS0cTWz/vh8PoaHh42a9WdohEIhSktLkZKSgoCAAFRWVmL58uV4+umn8eqrr5q9Grtr1y46eDk9PR07duxAdnY2AGDBggWIiIjQmvU+cOAAXnnlFTp4+b333hs1ePnTTz+FSCTCvHnz8L//+7+Ii4sz9UuzYQZsgs+CmYzgI2Lv5s2buHTpkk5bFfbt24cNGzagu7t7WmyVsCRIQj+p/JWUlGD+/PnIycnBmjVr4OXlRYu/np4euLm50eJvImekWCxGYWEhAgICMHPmTLOflKYKRVGoqqpCT08PuFzulCufI5FKpXTbt7+/f0oRJLrS39+PwsJCREVFITw83CjPYUpGE3sjoSiKrrIKBAK6ymqpEUZkv3RSUhLYbDZqa2uxbNkyPPLII3j77bet/u/Kho2R2ASfBTLZHb8KhQL33HMPCgsLceLECS3bPYvFgqOjI65du4aff/4Zd911Fzw8PHDt2jU8//zzWL58+ajr5WwYDhKEnJeXh0OHDqGwsBBz585Fbm4u1qxZAx8fH3o4vqenB66urnT48MhKV39/P4qKiqx6HkwTzSgZLpdr9CiZ4eFhWpCQFjt5rw0lNMn6t+joaC2HvLVCxN7Q0BC4XK7Owm1k1p85XewjIVtbEhISMGPGDDQ0NGDZsmW477778P7771t9xdyGjdGwCT4LZLI7fpuamsZsGZH7FBYW4qmnnkJ1dTWGh4cRGRmJ3//+9/jTn/5km98zIRRFobm5mRZ/N27cwOzZs+nKn7+/P715oru7m47FYLPZkMvlKC0tnXZVI4lEAi6Xa/LPoVwup801pMo6ltDWlb6+PhQVFU2b9W/6ir2RaGb9aQptXbL+DI1IJEJhYSG9taWlpQVLly7FqlWrsHPnTpvYszFtsQk+GzbMBEVRaG1txcGDB3Ho0CFcu3YN2dnZyMnJwdq1a8Fms+nNE6dOnYJKpcKKFSsQHR19WyaataFSqegMNw6HY/Z2n0Kh0Gqxj5c/NxakahQXF4eQkBATHLVxUavVKC8vpwW5oX5HI4X2yIq2MT/XpNUeGxuLkJAQdHR0YOnSpVi4cCF2795tE3s2pjU2wWfDhgVAURTa29tx6NAhHDx4EFevXgWXy0VOTg6Ghobw3nvv4e2338a8efPQ3d0NR0dH2u3r6elpVeJPMzcwIyPD4gb7NfPnyHtNxJ/mfl9NyDxYfHy81jpDa8VYYm8kSqVSq6Kty3utLwMDAygoKKBb7Xw+H8uWLUN2dja++OILq3MX27AxWWyCz4YNC4OiKHR2duLw4cPYsWMHamtrERUVhUceeQRr165FaGgoent7wefzIRQK4eDgQIs/Q58kDQ3JDWQymUhPT7f43ECVSqW139fOzo4WJD4+PmAwGOju7kZpaSk9D2btmErsjWRk1h/ZpUze66lU30g8Dlkn193djRUrViApKQn79u2z+M+hDRuGwCb4bOjMO++8g5MnT6K4uBiOjo46uYdJDMBnn30GkUiEuXPn4uOPP0ZsbCx9m97eXjz99NM4fvw4mEwm1q9fjw8//HDK0RzWzrvvvott27bhyy+/RHt7O/Ly8nDlyhWkpKQgNzcXOTk5iIiI0BJ/9vb2dHvM0sSfXC5HYWEhnJyckJqaanUVFbVaTQsSgUAABoMBDw8P9PX1ITEx0Sb2DHwcIpGIjntRq9V6Z/2R4GuShdjX14dVq1YhIiIC3377rcVVmG3YMBY2wWdDZ15//XV4e3ujra0Nn3/+uU6Cb9u2bdi6datW0GdZWZlW0Ofy5cvR2dmJ3bt3Q6FQ4KGHHkJmZia++uorI78iy4SiKGzZsgV79uzB2bNnkZaWRv+8u7sbR48exYEDB3Dp0iUkJCTQ4i86Ohp9fX20+GMymbT48/b2Nqv4IyHRrq6uSElJsfpZKbVajaamJtTX18Pe3h4MBkNLkFjj6yNiTywWg8fjmX2ukkBRFPr7+2mhPZl1ehKJBPn5+QgODkZMTAz6+/uxZs0aBAQE4NChQzbDmo1fFTbBZ2PS6JoPSFb5vPDCC3jxxRcB3BqaZrPZ9CqfqqoqJCYm4saNG+DxeACA06dPY8WKFWhra5sW81CTpaSkBOvXr8epU6fGDESlKAq9vb04evQo8vLycOHCBcTFxSEnJwc5OTmIi4uDSCQCn8+nq1Ga4s+UgkQmk6GgoACenp5ISkqySjE0Ej6fj/LycqSkpMDf3x/9/f30e61QKGjxR3aiWjpqtRoVFRUYHBy0KLE3ktGy/nx9fREQEHDbRhWpVIobN24gMDAQsbGxkEgkyMnJgZubG44fP272aBhL48svv8Tzzz+Pjo4OLSGck5MDDw8P/Otf/zLj0dkwBDbBZ2PS6Cr4GhoaEB0djaKiIq3l3HfeeSfS09Px4Ycf4p///CdeeOEF9PX10f+uVCrh7OyMAwcOIDc310ivwrKRy+U6n3QpioJIJMKxY8eQl5eHc+fOISoqCjk5OcjNzUV8fDzdHhMIBKAoihZ/U52NmoihoSEUFBTA19cXCQkJFtVi1peuri5UVFQgNTX1toBzzc0TAoEAMpmMrkb5+/tb5KyYtYi90ZBIJLTjVzPrz8vLC6WlpfD398fMmTMhlUqxfv16AMDJkyd/9eMioyGVSjFjxgx89tlnuPfeewHcWjsXHByMs2fP4q677jLzEdqYKpb37WNj2tDV1QUAWkHQ5L/Jv3V1dSEgIEDr3+3t7cFisejb/BqZzEmXwWDAx8cHGzduxMaNG9Hf34/jx48jLy8P//M//4Pw8HCsXbsW69atw7x58+j2WHl5OSiKgr+/P9hsNlgslkHFn0QiQUFBAdhsNuLi4qaF2Ovs7ERVVRW9d3UkDAYDXl5e8PLyQkxMDF2NampqQkVFBXx9fen9vpYwO0ZRFC32zDmzpy9ubm5wc3NDREQEZDIZBAIBurq6cPHiRXz44YdYuXIlcnNz8eabb0KhUOD06dM2sTcGLi4uePDBB/HFF1/Qgu/f//43wsLC6PxXG9aN9fdWbEyJLVu2gMFgjPt/1dXV5j5MG5PAy8sLv/vd73DkyBHw+Xy8/vrrqKurw8KFC8HhcPDhhx9CJpNh3rx5SEtLg729PSorK3HlyhVUVFRAKBRCrVZP6RgGBwdx48YNBAUFTRux197ePq7YGwkxdURHR2P27NmYPXs2vL290dLSgitXrqCgoABtbW0YHh42wdHfDkVRKC8vp8Wetc+zOTs7g81mQ6lUIi4uDhs3bsS1a9dw55134scff8Qdd9yBxsZGmKqp1dvbi9/+9rfw9PSEt7c3HnnkEYjF4nFv//TTT2PmzJlwcXFBWFgYnnnmGfT392vdbrTv6G+++cYgx/zYY4/h7NmzaG9vB3Crm7Np06Zp8fdrw1bh+9XzwgsvYNOmTePeJioqSq/HDgwMBHBr3knTwcjn8+kWb2BgIAQCgdb9lEolent76fvb0B9PT0888MADeOCBByAWi3Hq1Cnk5eVh6dKl8Pf3pyt/c+fOxeDgIPh8Pqqrq6FUKvV2RZJw24iIiDE3wFgbbW1tqK2tRXp6Olgsll6P4ebmhsjISERGRkIqlYLP56OjowPV1dUmXzs2srJn7WIP+I8L3MPDA8nJycjMzMQvv/yCpKQkPPPMMzh37hzmzp0LNpuNdevWYf369Zg1a5bRjue3v/0tOjs7ce7cOdqM9vjjj49pRuvo6EBHRwc++OADJCYmorm5GX/4wx/Q0dGBvLw8rdt+8cUXWLZsGf3f3t7eBjnmjIwMpKWl4csvv8SSJUtQUVGBkydPGuSxbZgf2wyfjUkzWdPGiy++iBdeeAHArfDTgICA20wb+fn54HK5AICzZ89i2bJlv1rThimQSCQ4ffo08vLycPLkSbBYLKxZswbr1q0Dl8uFWCwGn88Hn8+nTQhsNntC8dfX14fi4uJps/4NAFpbW3Hz5k1kZGTAx8fH4I9PWpECgQAikQienp70jKUxdgsTsTcwMDBtxJ5CoUBBQQFcXFyQkpICtVqNRx99FBUVFbh06RI9NiKVSnHu3DkcOnQIg4ODOHjwoFGOx1BmtAMHDuB3v/sdJBIJPf/JYDBw+PBh5OTkGOXYP/74Y2zfvh133303bt68iTNnzhjleWyYHpvgs6EzLS0t6O3txbFjx/D+++/jhx9+AADExMTQczHx8fHYunUrbbbYtm0b3n33Xa1YltLS0ttiWfh8Pj755BP6SpjH4/1qY1lMjVQqxZkzZ5CXl4cTJ07A09MTa9asQW5uLjIzMzE0NESLPxKJwWazb3Ogkm0T02W1GHDrM19fX4+MjAyDVVHGQy6X0+Kvt7cX7u7utPgzxM5ZIvb6+/vB4/GmhdhTKpUoKCig8x0pisIf//hHXL9+HVeuXDFLPqKhzGj/+Mc/8Oc//xlCoZD+GYPBQFBQEIaHhxEVFYU//OEPeOihhwzWdu3v70dQUBCUSiW+/PJL3HfffQZ5XBvmx9bStaEzr732Gvbu3Uv/d0ZGBgDg0qVL9FBvTU2N1szJSy+9BIlEgscffxwikQjz5s3D6dOntdpW+/btw+bNm7Fo0SI6eHnHjh2meVE24OLiQse5yGQynDt3Dnl5ebj33nvh4uJCi79Zs2bRrci6ujqUl5fT4g8AKioqpk0AMQA0NTWhsbERHA4HXl5eJnlOR0dHhISEICQkBAqFAkKhEHw+H42NjXBxcaE3quizc3a6ir3CwkI4ODggNTUVAPD888/jp59+wqVLl8z2WTSEGa27uxtvvfUWHn/8ca2fv/nmm1i4cCFcXV1x9uxZPPXUUxCLxXjmmWcMcuxeXl5Yv349Tp48abQqog3zYKvw2bBhY1TkcjnOnTuHgwcP4ujRo3B0dMTq1auxbt06zJ49G8PDw+Dz+fj666/R0tKCRx55BGFhYfDz87MIB+pUaGxsRHNzMzgcDjw9Pc19OPTOWbLf18nJaVK7lCmKQmVlJUQi0bQReyqVCkVFRWAwGEhPTweDwcBLL72EkydP4vLly0aZH92yZQu2bds27m2qqqpw6NAh7N27FzU1NVr/FhAQgDfeeANPPvnkuI8xMDCAu+++GywWC8eOHRv37+m1117DF198gdbWVt1fyAQsWrQISUlJtgvvaYZN8NmwYWNCFAoFLl68iLy8PBw5cgQMBgOrV6+GnZ0d/vWvf+HDDz/EnDlzwOfz6TBcS4ofmQz19fVobW0Fl8uFh4eHuQ/nNsh+XyL+yDq9gICAUTeqaIo9Lpc7LQKHVSoViouLoVarweFwwGAw8Oqrr+Lbb7/F5cuXtVY3GhKhUIienp5xbxMVFYV///vferd0BwcHsXTpUri6uuLEiRMT/r5OnjyJVatWQSaTTVnI9/X14fLly7jnnntQWVmJmTNnTunxbFgWtpauDatnsrt4m5qaxrz6//bbb+kMqtGqJl9//TXuv/9+wx28leDg4IClS5di6dKl+Pjjj3H58mW88cYb+Omnn+Du7o6rV68iMDAQ8+fPh0KhgEAgQEtLCyorK8FisehqlCWLP4qiUF9fj/b2dvB4PIvNa7Ozs6MFnlqtRk9PDwQCAUpKSm7bqMJgMKad2FOr1SgtLYVKpQKHwwGTycQ777yDr776yqhiDwD8/f1vC9sejdmzZ0MkEqGgoIA2o128eBFqtRrZ2dlj3m9gYABLly6Fk5MTjh07ptPvq7i4GD4+Pgap2mZkZKCvrw/btm2zib1piK3CZ8PqmewuXpVKpTUEDQCffvop3n//fXR2dtInegaDMWr8wXQ4aU6VDz74AG+//TaOHTsGlUqFAwcO4MiRI5DJZFi1ahVyc3OxYMECqFQqeuXY4OAgWCwWLVYsKeSXoijU1dWho6MDXC7XYsXeeKjVavT19WltVHFwcIBKpQKPx4Orq6u5D3HKELE3PDwMDocDe3t7fPDBB9i5cycuXrxIz/FZAhOZ0drb27Fo0SJ8+eWXyMrKwsDAAJYsWYKhoSEcPnxYy6Tj7+8POzs7HD9+HHw+H7NmzYKzszPOnTuHF198ES+++CLeeOMNc71UG1aCTfDZsGoMFX+QkZEBDoeDzz//nP6ZseMPrBGKovDWW29hx44dOHPmDF29AG4J6R9//BF5eXk4fPgwxGIxVq1ahZycHCxcuBAURdHib2BgAD4+PrT4M+dMGUVRuHnzJrq6usDlcg3ihjU3arUaJSUl6Ovrg52dHdRqtd65ipaCWq1GeXk5JBIJeDwe7O3tsWPHDrz//vs4d+6c1mfREujt7cXmzZu1Og87duygLyZIp4GY3i5fvjzm+rLGxkZERETg9OnT+POf/4y6ujpQFIWYmBg8+eSTeOyxx6bFjmobxsUm+GxYNYaIPygoKACPx8NPP/2EOXPm0D83dvyBNSIQCHD33Xdj3759SE5OHvN2KpUK165do8Vff38/li9fjpycHCxevJh+LIFAgP7+fnh7e9NtX1OKP4qiUFNTA6FQCC6XOy2qYBRFoaqqCr29vbRBY2BggBbbJFonICAAfn5+FrnfdySa2YE8Hg8ODg7YvXs33nzzTZw+fdqoAco2bEwXLP8v3YaNcTBE/MHnn3+OhIQELbEHGD/+wBoJCAhAUVHRhNUEOzs7zJs3D/PmzcPf//53/Pzzz8jLy8OWLVvQ09ODZcuWIScnB0uWLAGTyaR3oNbU1MDLy4sWf8Zsn1MUherqanR3d4PH4xkl5NjUjBR75P0j+31jY2PpUO2GhgZ6v29AQIDFGmyI6YTEyTg4OGDv3r34y1/+gpMnT9rEng0bOmKr8NmwSEwVfyCVSjFjxgy8+uqr9DaQsTBG/MGvDbVajfz8fOTl5eHQoUPo6urC0qVLkZOTg6VLl8LBwQECgQB8Pp/eOkHEnyEFmaYw4nK501rsjYdYLKbfb4lEYnEzlkSU9/T00NXKr776Cn/6059w7NixMVugNmzYuB2b4LNhkZgi/gAA/vWvf+GRRx5Be3v7hO47Q8Yf2Lgl/oqKipCXl4eDBw+ivb0dd999N3JycrB8+XI4OTnRYqSvrw8eHh5gs9lTXjk2HWNKRgojfV7T0NAQ/X4PDg6afcaSoijU1tZCIBDQFdi8vDw89dRTyMvL0zJT2bBhY2Jsgs+GVTPVXbwLFiyAn5/fbcvJR+Odd97B3/72N/T29hrk2G38B+K+JOKvqakJixcvRk5ODlasWAEXFxd66wRZOUbE32Tm7tRqNSoqKjA4OAgOhzPtxJ6hqpVkvy+fz0d/fz+8vLxo8WeKaihxTXd2dtIO42PHjuGRRx7B119/jTVr1hj9GGzYmG7YBJ8Nq2ey8QeEuro6xMXF4dSpU7dVC2zxB+aDoiiUl5fjwIEDOHToEOrq6rBo0SKsXbsWq1atgqurK711oqenB25ubrT4G89hS1yeYrEYXC53WlRpjSH2RjI8PEwbbEillYg/Yzma6+vr0dbWBh6PBzc3N3z33XfYsGED9u7di3vuuccoz2nDxnTHJvhsWD2TjT8g/Pd//zf+/e9/o6mp6TYTgi3+wDIgc2lE/FVXV+Ouu+5CTk4OVq1aBXd3d3R3d0MgEKCnpweurq508LBmlp5arUZZWdn/b+/eo6Ku8z+OP4e7lwARGCD9JV5IWVQUFdEsClLEC2M3bW1RVnEjzVOZmuWltLzXcV3bxF1vZWpKal45KoJuyorAQVS8USYazAAiEKBcZr6/Pzx8t0lFSxCB9+OcOcX3+/l+5/MZPGdefD83ysrK8PPzeyTGpz2o+ph0UlFRQV5envp5t2jRQv28W7RoUSsz2Ku3tate/PrQoUOMGjWKVatW8ec//7kWWiFE0ySBTwjRIFSP6aru9j19+jTPPPMMOp2OYcOG4eDgoIa//Px8mjVrps4+/fHHH9XFehtL2KteTqa+ZhhXVlaafd52dnbqBJvHHnvsD4W/y5cvc+nSJXVbuyNHjvDyyy/zj3/8gzFjxjTpJZGEeFAS+IQQDU71NmjVT/7S0tIYMGAAI0aMYNiwYbRq1Ypr165x+fJl5s+fzyuvvEKvXr1wd3f/w2HkUfEohL3fMhqNajd7fn4+NjY2arevg4PDfX3eV65cITMzEz8/P+zt7fnvf/+LTqdj0aJFvP766w36dybEo0ACnxCiQVMUhUuXLqlLvaSkpNCvXz9CQ0PZvHkz5eXlbNiwgYqKCjWMVD+Jsre3b1BB4lEMe79lNBrV/X3z8vLM9v5t1arVHT/vq1evcvHiRXr06IGjoyMpKSkMGzaMjz76iMmTJzeo35EQjyoZjCREHSkoKGD06NHY29vj6OjIuHHjKCkpqfGawMBANBqN2ev11183K5OVlcWQIUPU8WpTp06lqqqqLpvySNNoNLRv355p06aRmJhIZmYmISEhLFiwgLS0NOzt7YmPj8fZ2Zmnn34aLy8vbt68SUpKCt9//z0XLlygqKiIR/1v34YQ9gA14Pn4+PDMM8/g7e2tzsI+cuQIGRkZXLt2DZPJBEB2djYXLlzA19cXR0dHTp48SVhYGB988IGEPSFqkTzhE6KODB48mJycHKKjo9XZw71791ZnD99JYGAgXl5ezJ07Vz3WvHlz7O3tgVtPT3x9fXFzc2PJkiXk5OQQHh5OZGQk8+fPr/M2NQTVe/gCrFy5ktjYWLZt20ZiYiK9e/dGp9MRFhaGu7s7169fx2AwkJeXh5WVlToB4X67IR+WO61J19CYTCYKCwvV5V5MJhMtWrTg8OHDvPrqq7Rp04aMjAwGDx7M5MmTmTlz5iP1OxCioZPAJ0QdqF4f8MSJE/Tq1Qu4NfM3NDS0xvUBAwMD8fX1ZdmyZXc8v2/fPoYOHUp2djZarRa4FWqmT59OXl5eo5iQ8CCKi4sJDQ3F1taWnTt3qsuGKIpCdnY227Zt49tvv+Xo0aP07NkTnU6HTqejTZs2avjLzc1Vn1JptVocHR3rNXj8Ouw1pv1+L126REpKCtOnT6e4uJgePXpw+vRpJkyYwOLFiyXsCVHLpEtXiDqQmJiIo6OjGvYAgoODsbCw4Pjx4zVe+/XXX+Ps7IyPjw8zZsygrKzM7L5du3ZVwx7AoEGDKC4u5syZM7XfkAZmw4YNtGjRgt27d5utEafRaHj88cd58803iY+P58qVK4wZM4aDBw/SrVs3nn32Wb766iuaNWvG008/zZ/+9CdMJhMnT57kyJEj6pZl1d2QD0tjDHsA+fn5XLp0icDAQDIzM/nnP/9JWloalpaWfP7557z00kts3LiR4uLiOq+LDL0QTYUEPiHqgF6vx9XV1eyYlZUVTk5O6PX6u1735z//mQ0bNhAfH8+MGTP46quveO2118zu++uwB6g/13TfpiIqKopdu3bV2OWp0Whwc3PjjTfe4ODBg/z8889ERkZy+PBhevbsydNPP83atWuxsbFhwIAB+Pj4AHDq1Kk7jkGrK9Vhz2AwNLqwl56ejo+PDy4uLly5coU5c+YQERFBXl4eSUlJdOvWjYULF+Li4sKwYcOoqKios/qMHj2aM2fOcODAAXbv3s2RI0eYMGHCPa+LjIwkJydHfS1evFg9ZzQaGTJkCBUVFRw7doz169ezbt06Zs+eXWftEOJerOq7AkI0JO+99x6LFi2qsczZs2f/8P1//UXTtWtX3N3dCQoK4ocffqBDhw5/+L5NhUaj+V3d2hqNBldXV/72t78xYcIErl27xnfffcfWrVv5+OOP6dy5MyNGjECn0zFgwAB1DNrp06dRFAUXFxe0Wi1OTk61uiC3oihcvHgRg8Ggbi3WGBQUFJCeno63tzdarZbs7GyGDh3KoEGDWL58ORYWFvj4+ODj48OcOXO4ePEi33//fZ0NVTh79iyxsbFmQy/+8Y9/EBoaytKlS2vcmrF58+a4ubnd8dz+/fvJyMjg4MGDaLVafH19mTdvHtOnT+fDDz9s8kMvRP2QJ3xC/A5Tpkzh7NmzNb7at2+Pm5sbubm5ZtdWVVVRUFBw1y+JO/H39wdubQMH4ObmhsFgMCtT/fPvua+4nUajwdnZmXHjxrFv3z70ej1vv/02ycnJ9O3bl759+7Jy5UpMJhMDBgyge/fuWFpakpGRweHDhzlz5gx5eXkP/OSvOuzp9fpGFfauX79OWloanTt3xt3dHYPBwJAhQ+jfvz9ffPHFHQNzp06diIiIqLM6ydAL0ZTIEz4hfgcXFxdcXFzuWS4gIIDCwkJSUlLw8/MD4NChQ5hMJjXE3Y+0tDQA3N3d1ft+8skn5Obmql3GBw4cwN7eHm9v79/ZGnE3Go0GJycnIiIiGDt2LEVFRezcuZOYmBg+/fRT2rVrh06nY8SIEfTv359ffvkFg8HAuXPnqKqqwsXFBVdXV1q3bo2lpeV9v29jDXtFRUWkpaXh5eWFh4cH+fn5DBs2jB49erBmzZrf9RnVpgcZevHEE0/g4eFBeno606dP5/z582zbtk29rwy9EI8aCXxC1IEuXboQEhJCZGQkK1eupLKykkmTJjFq1Ci1m+jnn38mKCiIL7/8kj59+vDDDz+wceNGQkNDad26Nenp6bz99ts8/fTTdOvWDYCBAwfi7e3NX/7yFxYvXoxer2fmzJlMnDgRW1vb+mxyo6XRaHB0dCQ8PJzw8HCKiorYvXs3MTExBAYG0rZtW8LCwhgxYgT9+vWjpKQEg8HA+fPnqaysVLt97xX+FEUhMzMTvV7fqMbsFRcXk5qaSocOHdTZ0MOHD6dTp0589dVXWFnV/teQDL0Q4nYS+ISoI19//TWTJk0iKCgICwsLXnzxRZYvX66er6ys5Pz582pXkI2NDQcPHmTZsmWUlpbStm1bXnzxRWbOnKleY2lpye7du4mKiiIgIIAWLVowZswYs3X7RN1ycHBg9OjRjB49ml9++YU9e/YQExNDcHAw7u7uZuGvtLQUg8HAhQsXqKiowNnZGa1Wi7Ozs1n4qw57OTk5+Pn5mc0wbsh++eUXUlNT8fT05P/+7/8oKipCp9Px+OOPs3nzZqytrevkfadMmcLYsWNrLFNXQy86dOiAm5sbSUlJZmVk6IWob7IOnxBC1IKSkhL27dtHTEwMe/fuxdnZWQ1/PXv2pKysDIPBgMFg4ObNm2r4a926NT/99BPZ2dn06tWr0YS9kpISkpOTeeKJJ/D09KSkpASdTkeLFi3YtWsXdnZ29V1Fdb3M5ORkdejF/v37CQkJqXG9zN86evQoTz31FCdPnqRbt27qepk5OTlql/GqVauYOnUqubm58jRe1AsJfEIIUcvKysqIjY0lJiaGPXv24OjoyPDhw3nhhRfo1asXN27cwGAwoNfriYmJYcCAAfTs2ZM2bdrUSRfnw1ZaWkpycjJt2rShQ4cOlJWV8eKLLwKwd+/eRyrUDh48GIPBoA69iIiIoFevXuqOOPc79KJNmzYcPnwY+N+OOB4eHurQi7/85S+MHz9edsQR9UYCnxBC1KEbN26wf/9+YmJi2L17Ny1btmT48OHodDo2bdrEjh07WL16Nfb29pSWltK6dWu0Wi0uLi511uVZl8rKykhOTsbd3Z2OHTtSXl7OK6+8wo0bN4iNjeWxxx6r7yqaKSgoYNKkSezatcts6EXLli0B+Omnn/D09CQ+Pp7AwECuXLnCa6+9xunTp9WhFyNGjGDmzJnqFogAly9fJioqioSEBHXoxcKFCxtFoBcNkwQ+IZqogoIC3nzzTbMvur///e/qF92dys+ZM4f9+/eTlZWFi4sLOp2OefPm4eDgoJa705ZYmzZtYtSoUXXWlobi5s2bHDx4kK1bt7JlyxbKy8t54YUXiIyMJCAggPLycnWv2ZKSEpycnNBqtbi6ujaI8Hfjxg2Sk5NxdXXFy8uLiooKRo8eTV5eHgcOHMDR0bG+qyhEkyV/agjRRI0ePZqcnBwOHDigdmVNmDBB7cr6rezsbLKzs1m6dCne3t5cvnyZ119/nezsbGJiYszKrl27lpCQEPVn+aK/xc7OjiFDhnD8+HEcHR358MMPSUpKYvTo0VhZWTFs2DBeeOEF+vfvT0VFBQaDgatXr3L27FmcnJxwdXXF1dX1kVy49+bNm6SkpODs7IyXlxdVVVVERESQnZ1NXFyc/BsQop7JEz4hmqDqweq/3mEgNjaW0NDQ3zVYfevWrbz22muUlpaqXVUajYbt27ej0+nqqvoN2pw5c4iOjiYhIYHOnTsDt2Zsx8fHExMTw44dOwAYOnQoL7zwAgMGDKCqqgqDwUBubi7FxcW0atVKDX+PwgSA8vJykpOTcXR0xNvbG6PRyPjx48nIyODQoUO3rXUnhHj4ZKcNIZqgB9lh4NeKioqwt7e/bVzSxIkTcXZ2pk+fPqxZswb5u/KWLVu2EB0dTXx8vBr2AKytrRk4cCCrVq0iOzubTZs2YWNjw/jx42nfvj1Tpkzh4sWL+Pr60r9/f5ydncnJyeE///kPycnJXLlyhfLy8nppU0VFBSkpKTg4OODt7Y3JZGLixImcPHmSAwcOSNgT4hEhXbpCNEF/dIeBX8vPz2fevHm3bTQ/d+5cnnvuOZo3b87+/ft54403KCkpYfLkybVW/4ZqxIgR9OnTh3bt2t21jJWVFUFBQQQFBbFixQq+//57tm7dyhtvvEFZWRlDhw5lxIgRPPvssyiKQm5uLnq9nvPnz+Pg4KCO+XsYy55UVlaSkpJCy5Yt8fb2RlEU3nrrLY4dO0ZCQoK6Q4wQov5Jl64Qjcj97jCwbds21q9fz/nz583Oubq68tFHHxEVFVXjPYqLi3n++edxcnJi586dNU4omD17NmvXruXKlSv33xBxG6PRyNGjR4mJiWH79u2UlJQQGhpKWFgYwcHBaDQadcJHYWEh9vb2avhr1qxZrdensrKS1NRUbG1t1Z1gpk2bxp49e0hISMDT07PW31MI8cdJ4BOiEcnLy+PatWs1lmnfvj0bNmxgypQpXL9+XT1eVVWFnZ0dW7duZcSIEXe9/pdffmHQoEE0b96c3bt33/NJ0p49exg6dCg3b958JMabNQYmk4nExEQ1/F2/fp3Bgwej0+l4/vnnsbCwIC8vD4PBwPXr13nsscfQarVotdpaCX9VVVWkpqZibW1N9+7dAZg1axZbt24lPj6eTp06PfB7CCFqlwQ+IZqgP7rDQHFxMYMGDcLW1pa9e/fe136vn3zyCZ9++ikFBQW12gZxi8lkIikpiZiYGLZt20ZeXh4hISHodDoGDhyItbU1ubm55ObmUlBQQMuWLdXw90f26zUajaSmpmJhYYGvry8WFhZ8/PHHrF27lvj4eLp06VIHrRRCPCgJfEI0Ub93h4Hi4mIGDhxIWVkZ27dvN9stwcXFBUtLS3bt2oXBYKBv377Y2dlx4MAB3n33Xd59910++uij+mpqk2EymUhJSVHDX05ODgMHDkSn0xESEoKtra365O/atWu0bNkSV1dXtFrtfe1+YTQaSUtLQ1EUevTogYWFBUuWLGHFihXEx8fTtWvXh9BKIcQfIYFPiCbq9+4wkJCQwLPPPnvHe126dIl27doRGxvLjBkzyMzMRFEUOnbsSFRUFJGRkVhYyKIAD5PJZCItLY2YmBi+/fZbrly5wvPPP49Op2Pw4ME0a9bMLPy1aNFCDX93Wny7+n5VVVX07NkTS0tLli9fzpIlSzhw4ID6pFgI8WiSwCeEEI2cyWTi9OnTbNmyhW3btnHp0iWCg4MJCwtjyJAhNG/enPz8fHJzc8nPz6dZs2Zm4U9RFNLT0ykvL6dnz55YWVkRHR3N3LlziY2NpW/fvvXdRCHEPUjgE+IB5eXl0bVrVyZPnsz7778PwLFjxwgMDGTfvn0EBQXVcw2F+B9FUThz5gxbt25l27ZtXLhwgaCgIMLCwhg6dCgtW7bk2rVrGAwG8vPzsba25ty5c9jZ2TFy5EhsbGxYt24dM2bMYM+ePQwYMKC+mySEuA8S+ISoBXv37kWn03Hs2DGefPJJfH19CQsL47PPPqvvqglxV4qicO7cOTX8ZWRk8Oyzz6LT6Rg6dCgtWrRg5MiRXLx4EYPBgJOTEx07duTEiRPs3r2b55577qHW9/fu/1w9LOFOtmzZwssvvwzI/s+iaZDAJ0QtmThxIgcPHqRXr16cOnWKEydOyDIkosFQFIWLFy+qY/7S09NxcnKiqqqKPXv24OnpycyZM1m7di02NjZotVpeeuklXn75ZXr37n3H0FTbBg8eTE5ODtHR0epEo969e991/2ej0UheXp7ZsVWrVrFkyRJycnLUoKjRaO64//PDWLxaiIdGEULUirKyMqV9+/aKtbW1kp6eXt/VaVBWrFihPPHEE4qtra3Sp08f5fjx4zWW37Jli/Lkk08qtra2io+Pj7Jnzx6z8yaTSZk1a5bi5uam2NnZKUFBQcqFCxfqsgmNitFoVF599VWldevWSrdu3RQrKyvFx8dHsbW1Vb777jvlxo0bys6dO5Xw8HDFwcFBadu2rbJ06dI6rVNGRoYCKCdOnFCP7du3T9FoNMrPP/983/fx9fVV/vrXv5odA5Tt27fXVlWFeCRJ4BOilpw6dUqxs7NTLC0tlZ07d9Z3dRqMzZs3KzY2NsqaNWuUM2fOKJGRkYqjo6NiMBjuWP7o0aOKpaWlsnjxYiUjI0OZOXOmYm1trZw6dUots3DhQsXBwUHZsWOHcvLkSWX48OGKp6encuPGjYfVrAbLZDIpkydPVtq1a6dkZWUpJpNJ+fHHH5XXXntNmTp16m3ly8vLlb179yrbtm2r03qtXr1acXR0NDtWWVmpWFpa3vd7JycnK4By9OhRs+OA4uHhobRu3Vrp3bu3snr1asVkMtVa3YV4FEjgE6IWlJeXK927d1fGjBmjzJ8/X3F1db1rYBHm+vTpo0ycOFH92Wg0Kh4eHsqCBQvuWP6VV15RhgwZYnbM399f+dvf/qYoyq3A4ubmpixZskQ9X1hYqNja2iqbNm2qgxY0HiaTSZk6darSpk0b5ccff6zv6pj55JNPFC8vr9uOu7i4KP/85z/v6x5RUVFKly5dbjs+d+5c5fvvv1dSU1OVhQsXKra2tsrf//73B66zEI8SWRhLiFrwwQcfUFRUxPLly5k+fTpeXl789a9/re9qPfIqKipISUkhODhYPWZhYUFwcDCJiYl3vCYxMdGsPMCgQYPU8pcuXUKv15uVcXBwwN/f/673FP+j1Wo5dOjQQ9sL97333kOj0dT4Onfu3AO/z40bN9i4cSPjxo277dysWbPo378/PXr0YPr06UybNo0lS5Y88HsK8Sixqu8KCNHQJSQksGzZMuLj47G3twfgq6++onv37nzxxRdERUXVcw0fXfn5+RiNRrRardlxrVZ71y95vV5/x/J6vV49X33sbmXEnWk0GqZMmfJQ33PKlCmMHTu2xjLt27fHzc2N3Nxcs+NVVVUUFBTg5uZ2z/eJiYmhrKyM8PDwe5b19/dn3rx5lJeXy8Qr0WhI4BPiAQUGBlJZWWl2rF27dhQVFdVTjYRoOFxcXHBxcblnuYCAAAoLC0lJSVF39Th06BAmkwl/f/97Xr969WqGDx9+X++VlpZGq1atJOyJRkW6dIUQ9cbZ2RlLS0sMBoPZcYPBcNenNm5ubjWWr/7v77mnePR16dKFkJAQIiMjSUpK4ujRo0yaNIlRo0bh4eEB3Nr/uXPnziQlJZldm5mZyZEjRxg/fvxt9921axf//ve/OX36NJmZmXzxxRfMnz+fN99886G0S4iHRQKfEKLe2NjY4OfnR1xcnHrMZDIRFxdHQEDAHa8JCAgwKw9w4MABtbynpydubm5mZYqLizl+/Phd7ykahq+//prOnTsTFBREaGgoTz31FKtWrVLPV1ZWcv78ecrKysyuW7NmDW3atGHgwIG33dPa2prPP/+cgIAAfH19iY6O5rPPPmPOnDl13h4hHiZZeFkIUa+++eYbxowZQ3R0NH369GHZsmVs2bKFc+fOodVqCQ8P5/HHH2fBggXArW3rnnnmGRYuXMiQIUPYvHkz8+fPJzU1FR8fHwAWLVrEwoULWb9+PZ6ensyaNYv09HQyMjJkMV0hRJMkY/iEEPVq5MiR5OXlMXv2bPR6Pb6+vsTGxqqTLrKysrCw+F9nRL9+/di4cSMzZ87k/fffp1OnTuzYsUMNewDTpk2jtLSUCRMmUFhYyFNPPUVsbKyEPSFEkyVP+IQQQgghGjkZwyeEEEII0chJ4BNCCCGEaOQk8AkhxD18/vnntGvXDjs7O/z9/W9b9uPX/vWvfzFgwABatWpFq1atCA4Ovq382LFjb9tNIiQkpK6bIYRowiTwCSFEDb755hveeecd5syZQ2pqKt27d2fQoEG37fpQLSEhgVdffZX4+HgSExNp27YtAwcO5OeffzYrFxISQk5OjvratGnTw2iOEKKJkkkbQghRA39/f3r37s2KFSuAW+sEtm3bljfffJP33nvvntcbjUZatWrFihUr1G29xo4dS2FhITt27KjLqgshhEqe8AkhxF1UVFSQkpJCcHCweszCwoLg4GASExPv6x5lZWVUVlbi5ORkdjwhIQFXV1eefPJJoqKiuHbtWq3WXQghfk0CnxBC3EV+fj5Go1FdE7CaVqtFr9ff1z2mT5+Oh4eHWWgMCQnhyy+/JC4ujkWLFnH48GEGDx6M0Wis1foLIUQ1WXhZCCHqyMKFC9m8eTMJCQlmiz6PGjVK/f+uXbvSrVs3OnToQEJCAkFBQfVRVSFEIydP+IQQ4i6cnZ2xtLTEYDCYHTcYDLi5udV47dKlS1m4cCH79++nW7duNZZt3749zs7OZGZmPnCdhRDiTiTwCSHEXdjY2ODn50dcXJx6zGQyERcXR0BAwF2vW7x4MfPmzSM2NpZevXrd832uXr3KtWvXcHd3r5V6CyHEb0ngE0KIGrzzzjv861//Yv369Zw9e5aoqChKS0uJiIgAIDw8nBkzZqjlFy1axKxZs1izZg3t2rVDr9ej1+spKSkBoKSkhKlTp/Lf//6Xn376ibi4OMLCwujYsSODBg2qlzYKIRo/CXxCCFGDkSNHsnTpUmbPno2vry9paWnExsaqEzmysrLIyclRy3/xxRdUVFTw0ksv4e7urr6WLl0KgKWlJenp6QwfPhwvLy/GjRuHn58f//nPf7C1ta2XNtamTz75hH79+tG8eXMcHR3v6xpFUZg9ezbu7u40a9aM4OBgLl68aFamoKCA0aNHY29vj6OjI+PGjVNDtBDi3mQdPiGEELVmzpw5ODo6cvXqVVavXk1hYeE9r1m0aBELFixg/fr1eHp6MmvWLE6dOkVGRoY62WXw4MHk5OQQHR1NZWUlERER9O7dm40bN9Zxi4RoHCTwCSGEqHXr1q3jrbfeumfgUxQFDw8PpkyZwrvvvgtAUVERWq2WdevWMWrUKM6ePYu3tzcnTpxQx0TGxsYSGhrK1atX8fDwqOvmCNHgSZeuEEKIenPp0iX0er3ZOoUODg74+/uri1snJibi6OhoNgEmODgYCwsLjh8//tDrLERDJIFPCCEagc8//5x27dphZ2eHv78/SUlJdy27bt06NBqN2evX6wTC/Y2rqw3VC1jXtLi1Xq/H1dXV7LyVlRVOTk73vQC2EE2dBD4hhGjgvvnmG9555x3mzJlDamoq3bt3Z9CgQeTm5t71Gnt7e3JyctTX5cuXzc4vXryY5cuXs3LlSl599VXi4uLw8vK6LShWv86dO1fXzRRCPAAJfEII0cB99tlnREZGEhERgbe3NytXrqR58+asWbPmrtdoNBrc3NzU16+fsCmKwrJly5g5cyZhYWEsWrSIpKQkrK2tWbp0KWfPnr3t1b59+z9U9+oFrGta3NrNze228FpVVUVBQcE9F8AWQtwigU8IIRqwiooKUlJSzMbAWVhYEBwcrI6Bu5OSkhKeeOIJ2rZtS1hYGGfOnFHP/XZcnYuLC7179yYgIICsrCw6d+5828vGxuYP1d/T0xM3Nzezxa2Li4s5fvy4urh1QEAAhYWFpKSkqGUOHTqEyWTC39//D72vEE2NBD4hhGjA8vPzMRqNNY6B+60nn3ySNWvW8N1337FhwwZMJhP9+vXj6tWrwP2Nq7ubrKws0tLSyMrKwmg0kpaWRlpamtmaeZ07d2b79u3ArSeNb731Fh9//DE7d+7k1KlThIeH4+HhgU6nA6BLly6EhIQQGRlJUlISR48eZdKkSYwaNUpm6Apxn6zquwJCCCEeroCAALOt4fr160eXLl2Ijo5m3rx5D3Tv2bNns379evXnHj16ABAfH09gYCAA58+fp6ioSC0zbdo0SktLmTBhAoWFhTz11FPExsaaTST5+uuvmTRpEkFBQVhYWPDiiy+yfPnyB6qrEE2JBD4hhGjAnJ2dsbS0rHEM3L1YW1vTo0cPMjMzAfNxdb/e39dgMODr61vjvdatW8e6detqLPPb5V81Gg1z585l7ty5d73GyclJFlkW4gFIl64QQjRgNjY2+Pn5mY2BM5lMxMXFmT3Fq4nRaOTUqVNquLufcXVCiIZFnvAJIUQD98477zBmzBh69epFnz59WLZsGaWlpURERAAQHh7O448/zoIFCwCYO3cuffv2pWPHjhQWFrJkyRIuX77M+PHjAfNxdZ06dVK3O/v1uDohRMMigU8IIRq4kSNHkpeXx+zZs9Hr9fj6+hIbG6tOusjKysLC4n8dOtevXycyMhK9Xk+rVq3w8/Pj2LFjeHt7q2XuZ1ydEKLhkL10hRBCCCEaORnDJ4QQQgjRyEngE0IIIYRo5CTwCSGEEEI0chL4hBBCCCEaOQl8QgghhBCNnAQ+IYQQQohGTgKfEEIIIUQjJ4FPCCGEEKKRk8AnhBBCCNHISeATQgghhGjkJPAJIYQQQjRyEviEEEIIIRq5/wdSZc+A/69puQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Slice with compound conditions\n", + "mask = (sphere.cell_centroids[:, 0] < 0) & (sphere.cell_centroids[:, 2] > 0)\n", + "quadrant = sphere.slice_cells(mask).clean()\n", + "print(f\"X > 0 and Z > 0: {quadrant.n_cells} cells\")\n", + "\n", + "quadrant.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Every other cell: 160 cells\n" + ] + } + ], + "source": [ + "# Slice by index array\n", + "indices = torch.arange(0, sphere.n_cells, 2) # Every other cell\n", + "every_other = sphere.slice_cells(indices)\n", + "print(f\"Every other cell: {every_other.n_cells} cells\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Slicing Points\n", + "\n", + "`slice_points()` keeps only the specified points. Cells that reference removed points\n", + "are automatically removed, and remaining cell indices are remapped." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original: 162 points, 320 cells\n", + "Z > 0: 73 points, 122 cells\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sphere = sphere_icosahedral.load(subdivisions=2)\n", + "print(f\"Original: {sphere.n_points} points, {sphere.n_cells} cells\")\n", + "\n", + "# Keep only points with z > 0\n", + "mask = sphere.points[:, 2] > 0\n", + "top_half = sphere.slice_points(mask)\n", + "print(f\"Z > 0: {top_half.n_points} points, {top_half.n_cells} cells\")\n", + "\n", + "# Note: cells that cross z=0 are removed (they reference deleted points)\n", + "top_half.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 4: Merging Meshes\n", + "\n", + "`Mesh.merge()` combines multiple meshes into a single mesh. The meshes must have:\n", + "- Same spatial dimension\n", + "- Same manifold dimension\n", + "- Same cell_data keys (if any)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sphere 1: 162 points, 320 cells\n", + "Sphere 2: 162 points, 320 cells\n", + "Sphere 3: 162 points, 320 cells\n", + "\n", + "Merged: 486 points, 960 cells\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create three spheres at different positions\n", + "sphere1 = sphere_icosahedral.load(subdivisions=2).translate([-2.0, 0.0, 0.0])\n", + "sphere2 = sphere_icosahedral.load(subdivisions=2).translate([0.0, 0.0, 0.0])\n", + "sphere3 = sphere_icosahedral.load(subdivisions=2).translate([2.0, 0.0, 0.0])\n", + "\n", + "print(f\"Sphere 1: {sphere1.n_points} points, {sphere1.n_cells} cells\")\n", + "print(f\"Sphere 2: {sphere2.n_points} points, {sphere2.n_cells} cells\")\n", + "print(f\"Sphere 3: {sphere3.n_points} points, {sphere3.n_cells} cells\")\n", + "\n", + "# Merge them\n", + "merged = Mesh.merge([sphere1, sphere2, sphere3])\n", + "print(f\"\\nMerged: {merged.n_points} points, {merged.n_cells} cells\")\n", + "\n", + "merged.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Merge preserves attached data\n", + "sphere1.point_data[\"id\"] = torch.full((sphere1.n_points,), 0.0)\n", + "sphere2.point_data[\"id\"] = torch.full((sphere2.n_points,), 1.0)\n", + "sphere3.point_data[\"id\"] = torch.full((sphere3.n_points,), 2.0)\n", + "\n", + "merged = Mesh.merge([sphere1, sphere2, sphere3])\n", + "merged.draw(point_scalars=\"id\", cmap=\"Set1\", backend=\"matplotlib\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Merging requires matching dimensions.** All meshes passed to `Mesh.merge()` must have the\n", + "same spatial dimension *and* the same manifold dimension. This is a fundamental constraint:\n", + "the `cells` tensor has a fixed width (`n_manifold_dims + 1`), so mixing triangles and tetrahedra\n", + "in a single mesh is not possible.\n", + "\n", + "For structures that pair meshes of different manifold dimensions - e.g., a tetrahedral volume\n", + "mesh and its triangular boundary surface, as in a DrivAerML-style problem - use separate `Mesh`\n", + "objects. You can apply the same transformation to both:\n", + "\n", + "```python\n", + "rotation_args = dict(angle=math.pi / 4, axis=[0, 1, 0])\n", + "volume_mesh = volume_mesh.rotate(**rotation_args)\n", + "surface_mesh = surface_mesh.rotate(**rotation_args)\n", + "```\n", + "\n", + "Future versions of the Mesh library may support a collection object to facilitate multi-dimensional meshes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 5: Boundary and Facet Extraction\n", + "\n", + "PhysicsNeMo-Mesh can extract:\n", + "- **Boundary mesh**: Only the facets that are on the boundary (shared by exactly 1 cell)\n", + "- **Facet mesh**: All (n-k)-dimensional facets of an n-dimensional mesh" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Boundary Extraction\n", + "\n", + "Extract the boundary surface of a volume mesh. We'll show this step by step to\n", + "make the structure clear." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Volume mesh: Mesh(manifold_dim=3, spatial_dim=3, n_points=125, n_cells=384)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n", + " Manifold dim: 3 (tetrahedra)\n", + "\n", + "Sliced (x < 0): 192 cells\n", + "Sliced volume mesh (reveals interior tetrahedra):\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnwAAAKHCAYAAAAbuJWMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvXd8W3e9///S3suy5L2deMRxEmc7XXReuMAFLrNAS3dpC18os5fL3vMHlwsUSqHQAi2X7rRJk2bv7e04tmM73lOyra1zzuf3hyzFdjw0jpb1eT4e+cOOdM5HsnQ+r/Mer7eAEEJAoVAoFAqFQlmxCOO9AAqFQqFQKBRKdKGCj0KhUCgUCmWFQwUfhUKhUCgUygqHCj4KhUKhUCiUFQ4VfBQKhUKhUCgrHCr4KBQKhUKhUFY4VPBRKBQKhUKhrHCo4KNQKBQKhUJZ4VDBR6FQKBQKhbLCoYKPQqFQKBQKZYVDBR+FQqFQKBTKCocKPgqFQqFQKJQVDhV8FAqFQqFQKCscKvgoFAqFQqFQVjhU8FEoFAqFQqGscKjgo1AoFAqFQlnhUMFHoVAoFAqFssKhgo9CoVAoFAplhUMFH4VCoVAoFMoKhwo+CoVCoVAolBUOFXwUCoVCoVAoKxwq+CgUCoVCoVBWOFTwUSgUCoVCoaxwqOCjUCgUCoVCWeFQwUehUCgUCoWywqGCj0KhUCgUCmWFQwUfhUKhUCgUygqHCj4KhUKhUCiUFQ4VfBQKhUKhUCgrHCr4KBQKhUKhUFY4VPBRKBQKhUKhrHCo4KNQKBQKhUJZ4VDBR6FQKBQKhbLCoYKPQqFQKBQKZYUjjvcCKBRK4kAIAcuy4DgOYrEYQiG9J6RQKJSVABV8FAoFAMBxHBiGgcvlAsMwEAqFEIvFEIvFEIlEEIlEVABSKBRKkiIghJB4L4JCocQPQgg4joPX6w1E+BiGgUAgAMdxIIRAIBBAIBBQAUihUChJChV8FEoKQwiB1+sFy7IAAIFAAIZhwLLsHDFHCAkIQyoAKRQKJfmggo9CSVH8UT2/uBMIBAAw53eLQQUghUKhJBdU8FEoKcbstC3HcXPEHhCc4FvomFQAUigUSuJCBR+FkkIslMKdLfYAgGGYQNNGJOehApBCoVASByr4KJQUgWVZeL3eBaN6swknwrcc8wUgANoFTKFQKDGECj4KZYVDCAlE7YCFo3qziYbgW2hNVABSKBRK7KCCj0JZwfgbMziOA7C82ANiI/jmQwUghUKhRBcq+CiUFchyjRlLEQ/BNx8qACkUCoVfqOCjUFYYwTRmLEUiCL75UAFIoVAokUEFH4WyguA4Dh6PJ+So3mwSUfDNhwpACoVCCQ0q+CiUFYA/hesfjxau2AOSQ/DNxy8AWZbFqVOnsGHDBsjlcioAKRQKZQZxvBdAoVAig+O4wDg0ABGJPQARPTde+NPWAoEAHo8n8B54vV54PB4ANAJIoVBSGyr4KJQkxZ/S7OnpgVgshtlsTkqxxif+1y8QCCAUCgOCzh8BpAKQQqGkKlTwUShJyOzGjImJCchkMmRkZMR7WQmLP/pHBSCFQklVqOCjUJIMv7eev86OipLQoQKQQqGkGlTwUShJwmLeegKBAHz2Xq2EtHCo7wcVgBQKZaVDBR+FkgTM99ab3ZjBt+CjUAFIoVBWHlTwUSgJjt9uZTFvPSr4og8VgBQKJdmhgo9CSVAIIWAYBgzDAFjcbkUgEARm5fJ13mQWkLFISVMBSKFQkg0q+CiUBMTfmOEXcksJBRrhiz9UAFIolESHCj4KJYFYrDFjKajgSzyoAKRQKIkGFXwUSoKwVGPGUlDBdy2xfj9YloVIJFr0/6kApFAo8YYKPgolAeA4Dh6PJ+io3myo4Isfg4OD+MCdn4BMqYFaIYNeq8ZHP/B+vOtd71o2DU8FIIVCiSVU8FEocWR2YwYhJKw5uHw3bSQ7sfIRfPGVV/DHv72A6utvCUT3OI7DX17fg189/RdIRUKkadT46Af/E+98579RAUihUOIKFXwUSpzgOA4Mw4Scwp3PSjBKTjYe/8pX0T1mRVHV+jm/FwqFMGXnwJSdA8D3N37mtV345R+fgUzsE4Af+dB/4p133EEFIIVCiSlU8FEoMYYQEujCJYQENvdwoSnd2DE2NoZ7H/0M9DkFyMwvWvbxPgGYC1N2LgCfAPzzK2/gl3/4c0AAfuwjH8Idt90WtgC0Wq3o6+tDeXk5FYAUCmVRqOCjUGLI/MaMSMWe/xh0tNpcoiGAd+1+C7966k8oqKyGSBzepVMoFMKcnQdzdh4AnwB8+sXX8Ysn/wiZWIQ0rRp3fuTDuP3WW0MSgFarFQKBgEYAKRTKolDBR6HECH9Uj2XZsNO3C0EjfNHniW98Exd7B1FcXcPrcYVCIcw5eTDnzAhAlsUf//Uafv67pyATi2DUavDJj30EN99886Jizf+3FwqFNAVMoVAWhQo+CiXKhOOtFwpU8EWPqakp3PXQp6HOyEVWYUnUzycUia4RgE++8DJ+/JvfBwTg3R//GG666aY54m6hcXu0BpBCocyGCj4KJYqE660XCjSlOxe+1r/vwEH85H9/i4KKaoglEl6OGSpCkQjm3HyYc/MB+ATgb/7+In74699BJhYhXafB+9/zbhiNxiWPQwUghUKhgo9CiRIsywbGo0VD6Pmhtiz8883vfR917V0oqd4Y76XMQSgSISMvHxl5PgHIsiz++vpbsI4OQ/mr/0W6QYe7PvZR3HjjjbQLmEKhzEFAaC6IQuGV2d56AD+NGUsxMDCA3t5ebN26lZfjsSwLj8ez5OSIRObQoUPYtGkTVCpVyM91OBy468GHIUvLgM6YHoXVRReWZTE20IepiTHIRUKYDDrc/fGP4/rrrwtJrPkFIMdxc2oEqQCkUJIXKvgoFB7xN2b4I26x2BAHBwfR3d2N7du3R3wsp9OJ+vp6TE1NQa/Xw2AwwGAwQK1WJ83mfujQIWzcuBFqtTqk5504eRLf+skvkF9RBYlUFqXVxZaAABwfhVwsgilNj3s+8XFcf/31IR2HCkAKJfmhgo9C4YFoN2YsxdDQELq6uiIWfMPDw2hqaoLZbEZmZiampqZgsVhgtVpBCLlGACZqrV84gu8HP/05TjY0I6dkdcK+Lj5gGQajA32wTYxBJhbBlGbAvZ/8OK677rqQjkMFIIWSfFDBR6FESDS89UJheHgYnZ2dqK2tDev5HMfh4sWLGBgYwJo1a5CRkQGPxzOnvstms8FisQQEoEAgCIg/vV4PlUqVMEIpFMHncrnwqYcegVBjgN5kjsHqEgu/AJyeGINcLILZaMB9d30y5M8SFYAUSuJDBR+FEgGxasxYipGREVy6dCnkKA0A2O121NfXAwDWr18PpVIJjuPmCL75cByH6enpgACcnJyESCQKCECDwQCFQhE3AXj48GHU1NQsK/jOX7iAJ77zA+SVV0Eql8dodYlNQABaxiEXC5GRZsB9d98VcvSYCkAKJfGggo9CCYPZjRmEkLiJPQAYHR1FW1tbyIJvYGAAzc3NyMvLw+rVqwOb73KCbz4cxwXSvxaLBVNTU5BIJHNSwAqFIuTXFS7BCL6f/+rXOHD6HPJWlSdMZDIRYRkGI/29sFknoJyJAN7/qbtDbhCiApBCiT9U8FEoITK/MSPWKdz5jI2NoaWlBTfccENQj2cYBq2trRgZGcHatWthNs9NZYYq+ObDsiwmJydhtVoDAlAmk82JAMpk0WuKWErwMQyDTz30aTByNdLMmVFbw0rFJwCvwG61QCEWIcOYhvvvuRtbtmwJ6ThUAFIosYcKPgolSPyNGV6vF0D8hZ6f8fFxNDc3ByX4pqenUVdXB6lUinXr1kG+QCozUsE3H4ZhMDk5GYgATk9PQ6FQzBGAUqmUl3MBPsG3YcMGaDSaOb9vaWnB57/2TeSWVUKmUPJ2vlSGZRgM912BwzoBuUSMTGMaHrzvHmzatCmk41ABSKFEHyr4KJQg8DdmXL58GRMTE6ipqUkIsQcAExMTaGhowE033bToYwgh6O3tRVtbG4qKilBSUrLo+vkWfPNhGCYQ/bNYLLDZbFCpVHOaQCQRTLZYSPD95vdP4c2DR5BfVpkwf7eVCOP1YqS/F45JC+RiEbJMRjxwz6eoAKRQEgA6aYNCWQZ/Cpdl2cAGk0iiYbm1eL1eNDU1wWq1YuPGjUhLS4vRyhZGLBYjPT0d6enpgfX5u38vX74Mu90OtVo9RwCKxcFfqma/HxzH4d5HHoNTIEFB+RreXwtlLmKJBNmFxYGfGa8X3/vfP8Ax9RMoxCJkmdLx4H33oKamZsnjBDMJhGVZsCwLvV5PBSCFEgRU8FEoi7CQt55QKEy4MWZCoXDRWbpWqxV1dXXQaDTYsWMHr6lTvpBIJDCbzYFaQo/HE4j+tbe3w+VyQaPRBJpA/Bv8cnRevozHvvgVZJaWw6gKzYSZwg9CkQgypQpOhw0T09OwTNvw2Fe+homhQRSVlKAgJxsPP3Af1q9fv+RxFhKAExMT6OnpwYYNG3znohFACmVJqOCjUBZgvreevwt3KXEVT+aLUEIIurq60NnZidLSUhQWFiZUVHIppFIpMjIykJGRAcDnledPAbe1tcHtdkOr1QYigFqt9hoB+Nzf/4HXDxxBwdoauulHEbfTifGhAUxZxuFxuSCVyyGRyiCVySGVyyBTKJCelYXKjZuhTTPCabfhlT/+DtvueDeUGg0Yrxff/OVv4ZyyQiEWISfDjAfvuycoAQj4vpcSiYTOAqZQgoAKPgplFv66ocW89QQCQUJG+GbjdrvR2NgIu92OLVu2QKfTxWll/CCXy5GZmYnMTF9XrdPpDEQABwYGwDBMQADqdDr8+vdPgah0KKyoivPKkxuO4zBtmcD4yBDsk5MQCAWQSmWQyGSQyuWQyuRQarRYVb0exswsKDXaJW8q2urO4cKRA9hww80BgS6WSJBTVBJ4DOP14pv/32/gnJ4MCMCHH7gP1dXV1xyPEBI4XzApYCoAKakOFXwUygyzvfUAXCP2/L9L5Ajf+Pg4GhoaYDAYUFtbG1HzQ6KiUCigUCiQnZ0NQkhAALa2XsSPfvVr5FashZKmcJfF4/FgYngQk+OjcDudkEglkMjkkMp8ETqZXAF9ugnFa9bCYDJFNF94/0svwOVwYF3tjUs+TiyRIKe4NPAz4/Xg6z//tU8ASkTIzTDj0w8+gKqqqjmCbz5UAFIo10IFH4WCuY0ZszeK+SRihE8gEIAQgkuXLqGnpwfl5eXIzc1NmhRuJAgEAiiVSrzy2ut49qXXUFqzlW7a8Akc+9QkxoYHYLNaAY5AIpfNiDmfoJOrNCgsK4cx82aodfqovG8Mw+ClJ/8HOcWrkFVQvPwT5iGWSOcIQK/Xg//6yS/hsk1BIgD0agWe+NKXUFW1dDSXCkAKhdqyUFKchRozlhJK4U61iCYTExM4ffo01Go11q1bd43/XKhE25aFTziOw2e+8CUM21ww5+bHezkxg2EYWEaGYRkbhstuh1gimamdu5pu1aYZYcrJhSHdDLky9r6D1rFR7PzLU1izpRZypSoq5/B6PBju7YbLNg2FVIS8jEw88tADqKysDOk41AaGkgpQwUdJWeY3ZgRjpBzqVItoMzIygoaGBjAMg9tuuy2o7tXlSBbBNzg4iAc+8zkYC0qg0iZ3neJ8HDYbxof6MW21gPF6IZXJA7VzMpl8phkiG+lZOdAY0nj5u/NJ8+njaDl7BpWbt8X0cxQQgNNTUEglyM/KwCMPPYiKioqQjkMFIGUlQlO6lJTEPzEjmKjebPzp03jDcRza2trQ39+P1atXo6WlJaU2nxdfeRV//NvzyK9cl3BiZzk4joN1bASW0WHYp6chEgp93a0yf3erHGqtDms2b0OaORNylSqp0vN7XngOBEDV1tqYn1silSK3ZHXgZ5fHja/84Gdw2aehkIiRn+WLAC4nAGkKmLISoYKPklLMbswghIQk9oDEaNqw2+2or68HANTW1kIoFKKlpWXJIvaVxBe++l/oHrWgqGp9vJeyINdYlchmizmfVYkxMwvlNZugS0uHeIU01jCMB//63f+gYHUl9OmmeC8HACCRypBbOlcAfvkHP4PHPg25RIyC7Ew8+vBDKCsrW/I4VABSVgJU8FFShtl2K8DCXbjLEW/j5YGBATQ3NyMvLw+rV6+GUCgMbDgrnbGxMdz36Gehy8lHRn5hXNYQsCoZHoRjagoQCiASiSGTKyBTKiCVyaBUa7Cqej3SMjKh0upSQoSPDQ3irb//BWu21EKmUMR7OYsikcqQN0sAOtxufPG7P4bHYYNCKkZBdhYeeehBKgApKxIq+Cgrntneev4oWLibcLxSugzDoLW1FSMjI1i3bl1gKsVs/Onplciu3W/hV3/8Mwoq1kIUwpi1UPF6PJgYGcLk2CicTgekUsnV6NxMutVvVaJPN0EqC9+qZKVQf+wwLrc0Yf3170i6z59UJkPeqqvizu524wvf/TE89mkopGIU5eXg0YcewqpVq5Y8DhWAlGSACj7KiiacxoyliIcty/T0NOrq6iCVSrFjxw7I5fI5/z97k1mJPPGNb+Ji7yCK126I6Dh+q5LxkSG4bDZAAMgUCsjkCkhkckikEshkChSWVyLNnAG1TgehMLnqA2PNrr89A6lcgfKazfFeCi9IZTLkzxKANrcLn//2D+GxT0Mpk6AwNxuPPfwwSktLlzgKFYCUxIQKPsqKZba3Xjjp24WIZQ0fIQS9vb1oa2tDYWEhSktLF3wN/t+tNME3NTWFux96BKqMHGQVliz7eIZhYB0ZwdTEGNxuJyQymS/VKpdDLJVBIpVCrdMjr3QV9HGyKlkpeDwevPTk/6CoograNGO8lxM1pDL5NQLwc9/6Pjx2G5QyCYpzc/HIww9SAUhJCqjgo6w4/N56/hQuX2IPiF2Ez+v1oqmpCVarFTU1NTAaF99UoyH4/KnreNWfHTh4ED/69W9RUFEdaGpw2m0YGxqA02YDx7GQK5SBRgixRAqpTI6ckhJUbdsObZox6bp3k4XhvivY/9ILqNy0DVKZfPknrCB8ArA88POU66oAVMkkKM7PxaMPP4zi4qVNpqkApMQDKvgoK4r5KVw+xZ7/eP7zREsMWa1W1NfXQ61WY8eOHZBKpUs+PhqCL55i773v/09cvtKLoooqjA/1QyKTQyyRQKnWoGrzduhNJihU6pRohkg0zh18GwPdl7Gu9kb6/gOQyucKwEmXC5/9+nfgcdihlEpQWpCPxx55GIWFhUsehwpASiyggo+yIuCzMWMp/MfkOI73CBIhBF1dXejs7ERpaSkKCwtDeg3JntJ1OBy468GHITVlocKUBdvUJDxTbojFDqzdfh1yipZP61Kix86/Pg21VofSCGspVzJSuRz5q696/FlcTjz6tW/B67BDJZWgpCAfn3n00ygoKFjyOMsJQLfbDavViry8PCoAKUFDBR8l6ZntrQdE3pixFNFqkHC73WhsbITdbseWLVug0wU/OcL/epNZ8J08eQrf/MnPkV9RBYnU1/lqyskDADBeLy7VnUfd0UMgHAepXI6aG29GemZ2PJecMnhcLrz01P+iuLIaGr0h3stJKmRyBQrmCcBHnvgmGJcvAriqsBCPfvqhkAXg1NQUent7kZmZSSOAlKChgo+S1MxuzJh9QYwWsyN8fDE+Po6GhgYYDAbU1tZCEoYRbzILvh/97Bc4Xt+E4uqaBYW6WCJB5izfPY/bhfpjh+FyOEA4DkqNBptuug3atLQYrjo16LvcgeO7Xkflpu2QLFNaQFkemVyBgrKrAnDcOVsASrGqqACfeeTTyMvLW/I4/tpk8YxFEU0BU4KBCj5KUuJvzGAYJuTxaJHAZ4SP4zh0dnaiu7sb5eXlyM3NTTp/wEjweDy468GHIVQbkFu6tNHtbKQyObJnde26HA6censXvB43OI6DzpiOjTfeAqVaE41lpwwn9+7CxPAQqrbuoPV6UUKmmC8AHXj4K/8Nr9MBpVSCspIiPPbph68RgH7B54fWAFKCgQo+StIR7caMpeCrQcLpdKKhoQFerxfbtm2DRhOZOOFT8MXivbxQV4+vfud7yCurglQeWaenXKmcMz/VYZvGkZ2vgPF6wTEszLm52HD9OyI+Tyqx85mnoDWmo6iiKt5LSSlkCiUKyioDP485HXj4y/8NxuWAUuYTgI8+/DCkUumSYo0KQMpCUMFHSSr8diuxjOrNho+U7sjICBobG5GRkYGKigpemj+SKcL3//36f7H/5FkUV2+Myt9PqdbM6Zy0TVqx/6UXwDIsOMIit3gV1m6vhVhMU5TzcTkceO1PT6Koci3UOn28l5OSuBw2jA70Y8piAcd4IZXLIJHJwUrlOHz6HF58+Z04vG9vSOKMCkAKQAUfJUmY3ZjBt7deqIQ7T5fjOLS1taG/vx9r1qxBVlYWb2viW/BF471lGAafevgRMDIV8mYVskcbtU4fEC+EEExZJrDn+b+DEBYcR1BcWYWKjVtSfnPruXQRZ/fvRcWmbQHvQwq/+GYxWzA+PAD71BSEQvimvMjkkMlkkMoVUGl1WLN5G9LMmZCrVIHv4oUjByCWSOGx2yIeo0gFYGpCBR8l4fE3ZvhFVjzFHhCeuLLb7aivrwcAbN++HSqVKu5riiWtFy/ic098HbllldAq4jfhQiAQQJdmhG5mOgQhBJbRYbzyx9/OWO2IUbVlO0rWrkupze3YrtcxbbGgYtNWWq8XAQzDwDo6AsvoMFx2O0QSMaQyX4ROOjP5RZduQvGaNdCnm4OaxcxxHA698n8ord4AjmWRlZcPjuN4/TtRAZgaUMFHSVhme+vFK4W7EKGOVxsYGEBzczNyc3NRVlYWlYtkIgu+3/z+Kew6eATF66KTwo0EgUCANHMm0syZAACOZTHQfRmNp46D41hIpDJsuP6mOeO1VhIcx+GNvzwFvSlzTvMAZWE8LhfGhgYwNTEGj8cDqVQKiUzmm/gik0GmUCIzPx9VW/mZ9uJxu7Hn+Wdx20c+gayCIjzz4+9AKRFFHOFbDioAVyZU8FESkng2ZixHsOPVGIZBa2srRkZGsG7dOpjN5qiuKdEEH8dxuP/Rz8AOMfLL18R7OUEhFIlgzs2HOTcfAMAyDNob6nD2wNvgOAZypQqb3nEbMvOW9k1LBuxTk3jzuT+jaE01VLSjGQBgm5rE2NAAbBYLCAikUllA0Mnkcig1Gqxauw5pGZlQaXVRvSZZR0dw9M3X8OHHvgClWo3m0ycgFAghnLn+xFJcUQG4MqCCj5JwcByHoaEh2O125OXlJYzQ8xNMhG96ehp1dXWQSqXYsWMH5FHuEE00wdd5+TIe+9JXkVlSBqNKHe/lhI1ILEZ2YTGyC32zUb0eDxqOH8XxydfBcRzUWh223vZvMJgy4rzS0OhsbkT98cOo2LgVInFqbAMcx2FyfBQTI0OwT09DJBRBKpNBKpf7/snk0BjSsL72ehhMGZAr41d60H2xBV2tTbjry18PiKZLDRegMxrB2qwxF3zzoQIwOUmNbzolKfB763m9XkxNTcFisSA/Pz/ey7qGpSJ8hBD09vaira0NhYWFKC0tjYlgTSTB96e/PosX39yDgqoNK+4CL5FKkVd61QLG7XLixFu74LBNAQAMJhO23vrOhO5wPfrGq3DYplFRsyXeS+EVxuPB+MgQrKMjcLuckEilgVSrVCaHVKFAmjkDZRs2QpeWnrCNKfXHD4NjOXzokc8Hfue02TDS1wNzTj6EEF7jwxdvqABMDqjgoyQEHMeBYZhAClckEvE6zYJPFovweb1eNDU1wWq1oqamBkajMWZrSgTBx3EcHvnc4xh3syhIEf82mVyBooqr6Wqn3YZDr70El8MOQgjMOXnYcssdcY0W+eE4Djv/8hSMGdnIC8HoOlHw2ZUMYNpqAev1QCqXB5ohJDI5FCoV8letxobrb4JGr4dQyO+s62hDCMHRN19FYXklNlz3jjn/d/bgXuiNvpIQgTD2Kd1QoQIwMaGCjxJXZjdmEELmXCgSVfAtFOGzWq2or6+HSqXCjh07II3xGKp4C77e3l48/PkvwlS8GiZj8qZwI0WhUqO4cm3gZ9ukFXv++Ry8LjcICPJKV2PDDTfH/PPhs6J5FsVrqqFIwBQ7x3GwTVowPjgI+/QkIBBAKpUGUq0SuRxqjQ6Vm7YgLSMTCpU64Uo9IsHjduPQq/+HG977QeQUlVzz/70dlwJ/N+GM4BMnUSqeCsDEIHk+MZQVx2xvPeDqRQEI3+suFsyO8BFC0N3djY6ODpSWlqKwsDAuG1E8Bd/fn38Bz770GgrWrKcX6HmodXqsWrsBgO+zMm2ZwK7n/gxmZpMrqapG1bYdUd28L9WfR8vZ0yjfuJUXk+9w8NuVTI2Pwe12gmMZSOWKgKCTyRXQGU0oqgjermSlYB0bxcm9b+IDD34WSvW1YnygqxO2yclrBF8yC14qAOMDFXyUuOCP6rEsO+eL7yeRBZ9fXLndbjQ2NsJut2Pz5s3Q6/VxX1Ms4TgO/+8LX8agzYGiNdUxPXcyIhAIoE0zQjvLA9A6OoKdzzwFhvFCKBSifONWlG/YyNvGdvj1l+BxuVC2fiMvx1sMv12JfXISDOuFTKGEfCblKpHJIJXKkFNczJtdyUqhr+MS2pvqcefnvrro37zu2EEYM6+atAuR+CndUKECMDZQwUeJKf7GDIZhlvTWC9XrLpYIBAJMTU2htbUVBoMBtbW1kMS5ADzWgm94eBj3Pfb/YMwvhjnXFLPzriQEAgEM5gwYzL4OX47jMDbQj1fPnwbLshCLxajecQOKw6iHZBgGb/z1aZiyc2DKzot4rbapSYwPD8JlswECQK5QQqqQQyqVQyKVQqZQYvW69TCYMqJuV7JSaDl7Gm6nHR/69OcWfQzLMBjo7oIxY5bgm7kZXsliJxgBODIygszMTMjlcioAg4QKPkrMCMVbL1EjfBzHweVyobu7GxUVFcjNzU2IzS0ao9UWO97Lr76OPzz3D+RXVNNIDY8IhcIZgZYDwDc3uudiK+qPHgLLspDJ5ai58ZYFa7xmYxkdxb5//R0lVesgVy4/0cVvV2IdG4Hb6YJYKoFMrphphpBBIpFCpdMjt/h6GEzmhGhASWYIITi5503kFq/CDe95/5KPbTx5DNJ5lk7Cme9mKomb+QKQZVm0tbVBr9fPmcBEI4BLQwUfJSb47VaCnZiRiILP5XKhvr4eXq8XRUVFyMuLPHLCF7GK8H3xia+ha2QCRVXron6uVEckEiEzvxCZ+YUAAMbrRcvZ0zi1Zxc4wkGpVmPzzXcEBCIAtJ49hfaGOlRs2hbY7Px2JTarBR63GzK5fKZ+TgaJVAaJVIr07ByUrd8InTFx7UpWAl6PGwdf+RdueO9/LivcAaCzqR4anWHO74RCIViWTWkx47/WSaVSSCQSmgIOEir4KFFlfmNGsBMzEk3wjYyMoLGxERkZGRCJRJAlWFF5tAXfxMQE7vn0Y9Dl5CNjRoBQYotYIkFucSlQXArA19l5/tB+WEaGMGWdAEcIxGIxcopKMXSla2ZChAwymQJFZRXQmzOS0q5kpTBlmcDxXa/jAw8t3Jwxn2mrBWOD/YGpL4DveioSJZ4PX6zx7w3+DAOtAQwOKvgoUWP2HFxgbhfuciSK4OM4Dm1tbejv70dlZSWys7Nx/vz5hFjbbKIp+Hbtfgu/+uOfUVCxNmWmMiQK19iVQACp7KpdiUKlgnHterReOIP80nJ43E543G44bDbopDJUb78eSjo2Le70d3XiUt053Pn5xZsz5nNm/57AjGc/HMdCoVKs+Bq+5fA3+y22n4QqAL1eL8RiMRQKRcxeQzygV28K78z21gs2hTufRBB8drsd9fX1AIDt27dDpfLVQyViQ0m0BN8T3/wWLvYOonjGWoTCL367EsvoMJx2G8QSScBI2D8hQp+ejsLyShjSzdfUc40NDeLAy//E2q3XQTZvs3LYpnHk9VfAMF5wLAtzTi7WXX8j5HJagxdLWs+dhtNumzM5YzkIIejrbIdGPzedy7EcVEpl0tuyRIo/pR3se7CcAPzVr36F1tZW/POf/4zmsuMOFXwUXgmlMWMp4i34BgYG0NzcjNzcXJSVlc25m15qtFq84FvwTU1N4e6HHoEqIwdZBcW8HTfV8LhcGBsexNT4GDwup286hFQGiVwGmUwOmUKJjLw8VG3dBq3BGFIEtfHUMXS3tqByVr3ebJRqDfJXlwd+tk1aceCl/wPH+jrks4tKsK72OojFsTWBThUIITi1dxeyi0pw/buXbs6YT/fFFrhdLsyPzXIcC5VKmfIRPo7jImoYmy8AHQ5H4IZ+JUMFH4U3OI6Dx+MJO6o3G38UzT99I1YwDIPW1laMjIxg3bp1MJvNi64tkeBT8B04eAjf+8WvkF+xlhbwL4N9ehKjAwOwTVpACIFUKpupnZNDKpdBqdaidM1aGDOzeLUr2f/S8wCEKF27PujnqHX6wIxfQgimJsax54W/gbAcCOFQVFGFik1bU1pI8IXX48ahV1/Edf/+PuSWrAr5+U2njyN9lveeH47loFarU17w8d204nA4Vnw6F6CCj8IDfm89/3i0SMUegMCXOdI7uVCYnp5GXV0dpFIpduzYAfm89JmflRzh+/p3votzFztQXF3Dw6qSG79dycTwMBy2SQhFIp/vnEwWqKHTGtKwbsf1SDOZg7JAiRSPx4Odf/kDcopKoTWEP6tZIBBAZ0yHzpgOYMYEemwEu//+l5nPNkH5hk0oXlOd0sIiHK42ZzwGpVob8vO9HjcGr3TBlJlzzf9xHAudWkMFH8vyui84HA6kp6fzdrxEhQo+SkRwHAeGYSJO4c4nloKPEILe3l60tbWhsLAQJSUlS15MV2KEz+Fw4M5774dEb0J2USmPK0tc/HYl1rFRuJ12SKRSSKQztXMzY7/SzJlYva4GOmM6JDGefzuf4d4eHN75Clavq4FUtvDNSLgIBAIYTBkwmGZMoFkWgz3daKs7D0I4iERiVG7ZhoJV5cscKbUZ6LqMtvrQmjPmU3f0IJSqhYUix7LQ6bS0S5dnwWu321FYWMjb8RIVKvgoYTG7McOfduUz9Tpb8EUTr9eL5uZmWCwW1NTUwGhcPmqy0iJ8J06cwNe+/2PkVVRBIk0su5lIcDkcGBvsh8M2DZfTDql0JtUqk0Eil0OhUiOvdBU2XHcjNAZDQtuV1B09hP7LHVizeXtMShyEIhHSs3KQnjVjAs0w6G5pRtPJ4yCEQCKVYN2OG5GZVxD1tSQLF8+fgcNmW3JyRjB0tbZApVm4s5pwHDQaGuHjO8LndDqhTAFDcSr4KCEzvzGDb7HnP6b/XNHCarWivr4eKpUKO3bsgDTICM5KEnzf//FPcfR8A4qqa5Kq689vVzIxPASXwwGRWOSbDuFvipBKoVBrULlpCwwmMxRqTVK9vtns/effIJHKURzHecUisRjm3Hz4K1q9Hg9azpzCuYP7QDgOMqUSm266JRAhTCUIITj19m5kFRThun9/X0THmhgZwsTIEDJmee/NP5dSqYTb7U5pwcd35oc2bVAoC+CP6oXaFh8qfhEZDWFFCEF3dzc6OjpQWlqKwsLCkF6H3+k+kQhV8Hk8Htx57/0gSh1ySldHcWXhwbIsLKPDmBobh9vtgEQmh0zhq5uTSmUQS6XQphkXtStZCbhcDrz5lz8ht3T1NfYc8UYilSKroCjws9vlxLlD++F2OkE4Dmq9HptuujXQJLJS8Tdn7Pj3/0BeSeTfo3MH34YpM3vR/+cIB5VKlfKCLxpNG1TwUSgz+BszGIbhpQs3GKJhzeLxeNDQ0AC73Y7NmzdDr9eHfIxkj/CdP1+HL37jW8gtWxM3oTTbrsTtds10t0ohlckhmRFz2YXFqNoSul3JSmCguwsndu/EqnU1ca8dDAaZXIGcWbWfTrsNx3fthNfrASEsDKYM1NxwCxQraFOdskzg+O7X8YEHw2vOmA8hBP1dl6FLW7yshHA+wTcxMZG0EWs+iEbTBhV8FAr489YLFb4F3/j4OBoaGmAwGFBbWwtJmJYjydy08bNf/g/2Hj8V9RSufXoKY4MDcNmn4fV4fGnWGbsSmUIOhVKNkjVVMGb47EpSOVoxn7OH9mGk9woqNm1N2k1doVIjb1VZ4Gf71BQOv/YiGK+vwcuUk4ONN90adBlFojHQdRkX687izs+F35wxn7b68+C4pTMHhOMCtWap/J3hs4aREAKHw0Fr+CgUv91KrKJ6s+FL8HEch87OTnR3d6O8vBy5ubkRvY5kjPAxDINP3v8g3BIF8iLstPTblVjHRuByOiEWSyBT+OrnpDP1cyqtDutqr4MhRnYlKwFCCPY8/ywUKg2KKqrivRxeUWm1UGl9UTBCCKYtE9j13J/h9bgBACVV1Vi77TqIkyCSe/H8Gdinp/DhECZnBEPbudMwpF/r+zkbjmXnTPxJVfiO8NntdqiDmG+c7CT+t4sSFwghYBgGDMMAiF1UbzZ8CD6Xy4X6+np4PB5s27YNmkW630JdVzJF+FpaW/HYl55AzuoKqBTL38UyXi/Ghwdhs1rgcbsglStmGiJkvkidRIr0rOyEsStZCThsNrz53J9QWFYJlVYX7+VEFYFAAG2aEdqZ1CUhBNbREex85imwjBcCoQjlGzejfMOmhBI1hBCcfns3MvMjb86Yj8vpwFBvD8w5ecstAlKpNCqNcskEx3FhZ2gWgkb4KCnL7Dm4QHS6cIMhUsE3MjKCxsZGZGRkYOPGjbxFDxI1wrfQmn7z5O/x6tsH56RwZ9uVcBwLuULpq52Ty3zWJXI5CsvKYTBlJLxdyUrgSnsbzuzfi7L1m1JysolAIIDBnAGDecYDkOMwPjiAV88/CY5lIBSLUV17A0oq4xf19Ho8OPTqv7DjXe9FXmnZ8k8IkXMH3w4I4KXw39glkhCOByzLLmqMHw5Op5NG+CipxWxvvXikcOcTruDjOA5tbW3o7+9HZWUlsrMX73oLd12JHuHjOA6btu8AKxQhIzcfQ73dgXSr365En26GUpO8diUrgVNv74ZlZBgVG7fQv8MMQqFwrgcgy+LKpYuoP3oIHMdCKpOh5sZbkFscG4PwaasFx958LezJGcFwpb0N8iCi7xAI4PV6U17w8WnLwjAMPB4PbdqgpA7xasxYinAEn91uR319PQBg+/btUfkSJ2qEzy/4Ojo78amHH0XB2g2wT1rBMF54ptwwFK/C2u21EItpCjbecByH3X97Bto0IwrKKuO9nIRGJBIhM68gYPLMeL1oPXcGp/fuBkdYKNUabL75Dpiyrx1FFimDPV1oPXcmoskZyzHcdwVTE+OQ5wQh+AjBhQsXAACXL1+GwWCAVquN2fjJRIFPWxabzQYANMJHSQ04joPH40mIqN5sQhV8AwMDaGlpQU5ODsrKyqJ2gU7kCN/Tz/wVz7/2BlZv2g6hUAhjhm8AOyEEUxPj2PP832Y6AQUoW78RJVV0VmqssU1OYvffn0Fh5Vqo1JHXlKYaYonEF92bifB53G6cP3wA9imrzwPQYMC2W98ZmBMcLm0XzsI+NYUPP8pvc8Z8zh/eH4hmLodILEZFRQUuXboEp9OJgYEBMAwDnU4HvV4fEIAr/TvNZ9OGw+EAABrho6xs/N56/vFoiST2gOAFH8MwaG1txcjICKqrq2E2L93pFimJGOEjhOB7P/kZXCIZChbo8BQIBNAZ0wObIMdxGLrSjUv150E4DhKpFOt23IDM/MIYrzy16GptQt2RQyiv2ZJy3oLRQiqTIX+WBYzb6cCx3a/DabMDhIPBnImtt71z0XFl8/E1Z7yFjLx87HjXf0Rr2QBmZhZ3Xw56QokAgEQigVQqxZo1awKWIlarFRaLBX19feA4DjqdDgaDAQaDAWq1esUJQD5tWRwOB6RSaVJ0iEfKyn+FlAXhOA5WqxVCoRAymSzhxB4QnOCbnp5GXV0dpFIpduzYwWsh72JEMrc2GvT29uLB//c4slZVwBRkxGh+nRTj9aDl7GmcO7Tf5/Wl0WLzzbcl3ISHZOb47p2wTVpRvnFLvJeyopEplCgqv3rT47BN48DLL/imgBCCzPxCbLr5Vsjl16ZQvR4PDr/2Imr/7T1zfASjRfOZExCKgt+GBULBHLEjEAigUqmgUqmQk5MDQgjsdjssFgssFgt6enpACAlE//wCMNGu9aHCZ4TPbrdDqVQm/XsSDFTwpRizGzNaW1thNpuRn7/w3MZ4s1QkjRCC3t5etLW1obCwECUlJTG7i02klO7f//EC/vTCv1BUvRHCCC6AYsncUVkuhx0n3noDXo8bHMfBnJ2LDde/Y0WOMIs2HMfhzWefhsGUGZUOT8rSKNUalKxZF/h52mrBnr8/C6/bBalSgeyiUqyrvQ5Omx3H3nwN73/wUag0sbHGaW+oW3KyxnwEECwZ3RIIBFCr1VCr1cjLywMhBDabLSAAu7q6fF3RM+JPr9dDpVIlndjhM8LnF3ypABV8KcT8xgyRSJRwqcnZLCasvF4vmpubYbFYUFNTA6Mx+AsmHyRCSpfjODz6+S+g3zqNwjXVvB9frlTNESfTVgv2vfQCWIYBIRyKK6pQsWnriksV8c2UZQJvPf8sStZUQ6Fa+UXhyYBEJoNCrQEBAeNh0HOxGQ3HDsPtcuK/nvxrzD7T9ukpjPT3IiM3+BtuoXBpwTcfgUAAjUYDjUaD/Px8cByH6elpWCwWjI6OoqOjA2KxeE4EUKFQJLwA5DPC53Q6U6J+D6CCL2XwR/X83U0CgQBCoTAg/hKRhVK6VqsV9fX1UKlUqK2thUwmi8u64hnhGxoawt0PP4K0vGKYcwtick6N3hBI7/qNcnf97ZlA7eeardtREOEEj5XGpfoLaDlzEhUbt6ZcF2U8cdimMTbQh+lJKziWg1TmH+vnsyUymMyo2LQFaSYzFGoNLtWdQ/PpEyCI7fSKs/v3BLwHgyVSHz6hUAidTgedTofCwkJwHIepqSlYLBYMDw/j0qVLkEql1wjARINPWxa/6XKii1w+oIJvheNvzGAY5pou3GSI8PnXRwhBd3c3Ojo6UFpaisLCwrh9QeMZ4Xvx5Zfx22eeQ35FddxExHyjXJZh0N3SjKaTx+F1uyCRybHttnfBmJkZl/UlAkfeeAVuhwNlGzbFeykrCo7jYJ+axNjQAOxWCyAQQiqTQiKXQyaTQyKXQ6MzYO3265BmzlhyrB8hBKf3vQVzTh7SMrLgmLHniBV9ne1QakLz9RMKQovwLXs8oRB6vR56vR5FRUVgWRaTk5OwWq0YHBxEW1sbZDJZQPwZDIa43GTPxr+n8ZnSpRE+StKznLceX7Nqo4V/fR6PBw0NDbDb7di8eTP0en3c1xWPCN/nvvxVdAyOoqhqfczPvRQisRjm3Hz4e6M9bhfO7H8L9ukpEI4gLTMT2257F5Qp4HPFMAze+OsfYcrORU7xqngvJ+ngOA5TE+MYHx6EY3oSQqHo6hQYmRwyuQLatHRsvOEdMJgywq4p9Xo8OPz6i9h+x3ugMxpx7uC+wKzfWNDbcQkO21TIgs9/sxmtm12RSIS0tDSkpaUB8H2eJycnYbFY0Nvbi5aWFiiVyjkRQGmMRyv69yw+mzao4KMkNX67laW89UQiUcKndB0OB44dOwaDwYDa2lpe5yeGS6wjfFarFXfe+wA0WXlJYZsilcnnmAk7pqew71//gMflAgFBUVkl1l1/w4ozgLaMjmDPP/6K1Rs2LRlZSmU4joNldBgTw0Nw2mwQScSQynzj/KQy37zmNFMmSqvXQW80RWVOs23SiiM7X8H7H3wMaq0O+/71DxizsuFyxC7C13D8CNIyQp8AJOA5wrccYrEYRqMxUCfNMEzAAqanpwfNzc1QqVRzmkCifY32X3v5tGVJxLR1NKCCb4VBCAHDMGAYBsDSEzOEQiG8Xm8slxc0ftuYyclJVFRUIC8vL2FqLGIZ4Xtj91v4+W9/j/zyqqSds6rUaFG6dj0A3+dzcnwMO595GgzjhVAkwprN27CqekNSN4A0nTqO1nNnULX9+qR+HZHCMAwsw4OYtEzA63ZBJldAKvcJOYnU9y8jNw+Vm7ZCl2aMuRfhYE83Ws+ewscffyLwPe6/3AG13gABYnN9YbxeDPZ0wZiZFfJz+U7phopYLEZ6ejrS031+nl6vFxaLBVarFZcvX4bdbodarZ4jAPn2t5vddMgHDoeDRvgoycfsObiA725wKZGUqE0bLpcL9fX1sNvtMJlMCWcbEysfvi9/7eto7u5D8doNUT9XrBAIBNCnm6BPNwGYMYDu6Ubz6RPgOA4yuRybb749KSKZfnb/4xkQDqjaWhvvpUQdj8eDiaEB2CYtYLxeSBVKyOVySGQ+MSeVyZG3qgzrzBnQGAwQChOnWaWt7hymLBP48GOPB37X2dwQMJ4XS2KzHTYcPwJZmBElf5lLotxUSCQSmM3mgNm9x+MJWMC0t7fD5XJBo9EEUsB6vT5iocb3RCgq+ChJxVKNGUuRiE0bIyMjaGxshNlshtFohN1uj/eSriHatY82mw0fu+cBKEwZyCosjtp5EgGhUOir/5uxpmC8HjScOIozB/ZCAAGUGg0233x7QhpAM4wHL//+N8gqLIYxM/T0XCLicjowPjQI+5QVHMtCrlTNpFt9gk6mVKKkqhoGkxkqrS5hhMdSEEJwZv9bSM/Owzvv/NSc/2s5cxJp5gywDAOxJDbNCJdbGqDW6cN6rjDCLt1oI5VKkZGRgYwMX0OXy+UKRADb2trgdruh1WoDEcBw5gDz2bABUMFHSSKWa8xYikRq2uA4Dm1tbejr68OaNWuQnZ2N7u7uhFnfbPwRPkII72nmAwcP4Ts//yUKKqoglqysGrdgEEukc/z/rhpAe8BxbMIYQI8NDeDAS//EqvUbIZMnT/2Pw2bD2GA/nHYbAAKZQgGZXAGJTA6JVAqFSo3ymk0By5JEKaMIF8brxaHXXsS22/8dBavn2gZ5XC4M9XTDlJMLjmMhjcHf0To+irGhwZC892bjn7SRLGPA5HI5srKykJXlS187nc5ABNA/B3i+AFxOzPFpyQL4BF+svVzjRXJ8aigL4u9gDTfEnShNG3a7HfX19QCA2trawN1WIgnS2fjfZ74F3ze++z2caWlH8doNSb/R8sVSBtAgHIriYADdeOoYultbULl5e0JFWgghsE9OYnxk0NcQIRJBplBAKpcH6ueUWi2qt++AwWRe8Y0ltkkrjr7xKt73wKNQa6+dnHHu0H5oDDPekhyBVBb9G6xzB96OKBosEiRWSjdUFAoFFAoFsrOzQQiZIwD7+vrAsmzAJiYtLW3BOcA0whc+VPAlIf4Urr/2JNx6hkQQVAMDA2hpaUFOTg7KysrmfJETYaLFQvjXyFcdn8PhwJ333A+JIR05xaW8HHOlMt8A2jI2glee+g04jkAslWD9dTehsKwiauff/9LzEAhEgSaUWMJxHKYt45gYHYHLYYdYLJmJ0MlnInQSaHRpyF9dBoPJHPcoaDzxN2fc+fmvLioOei61BEQvx7FRT+kSQtDf1QGNPi2i40TTliWWCAQCKJVKKJXKa+YAW61WXLlyZcE5wHxO2QCo4KMkMBzHgWGYsFK484lnhI9hGFy8eBHDw8Oorq4OFP3OJhEE6UL4NxA+UgunTp3CE9/9IXLLqyCNs6FpsiEQCJBmykCa6aoB9OWmBpw/tB8cx0Kp0WDrLe/kxQDa4/Fg51/+gJyiVdAaItuwF8NnWTKCieFBOO02iMRiSGVySOUySGUKSKQSpGVkoqSqGvp0c1QsS1YCbXXnMWUZn9OcMZ+R/j5Mjo/BnJMHwPfeR/v719ncAK87MlcEUYij1ZKJYOcAKxQKMAwDm83GyxxgOkuXknAQQgJduP5UYqQf9HgJqunpadTV1UEqlaK2tnZRD6REFXyzU7qR8IOf/AxHztWjqLpmRdyxxxuRWIyswuJAo8scA2hCkJYRngH0SN8VHHr9FaxeVxORKGAYBpaRIVhmInQSqQQSqV/QySFXKpGelYXKTVviYlmS7PiaM/YiPTvnmuaM+Vw4vA/pWTlXn8sRSKIcEW05cxJpGaGNUpuPcKbRbiUKvvksNAfYZrOhp6cHTqcTZ8+ehUgkmjMFJJw5wA6HA+oUMIUHqOBLCuY3ZvAh9oDY27IQQtDX14eLFy+isLAQJSUlS1644j2zdjH87324YtTj8eDOe+8HUeqQU7qaz6VRZnGNAbRtGvtf/AdcThcADoVllVh//Y1LGkBfOHoQA5c7sWbztmW/c37LEuvYCDxu94xNyYypsFwOuUKJ7MJiVNdeB60hLaEsS5KdQHPGbe9CwTIpfY5l0d91GQbT1awCx7GQSqMX4fO4XBi60g1Tdm5ExxECKSP45iMUCgMNHoQQVFVVzZkD3N7eDrFYfI0AXA6n00kjfJTEwB/V8xeq8hkJiqUti9frRXNzMywWC2pqaoLqilqJEb66+no8/rVvIqesMqm6O1cCSrUGJTNj6QghmJyYZQAtFGHNlrkG0HteeA4yuQLFa6oBAG6XE+ODA5i2WuBy2n0NETI5RCIJ5CollCoNCssrkZ51a9JYlqwEbJNWHHnjVbz/vkegDmLsYsu5U9f8bQghYXvjBcP5I/vDtmKZjVCU3E0bfODfCxeaA+wXgPPnAPvrAOXzoriEEBrho8SfcL31QiFWgspqtaK+vh4qlQq1tbVBD99OZMEXTkPJz3/1a+w5eoKmcBMAgUAAvdEEvfGqAXRXazOOvPYyCAicdhvSMrKQXViE8aEBiKVSKJQqlNVsgiHdDKUm+S1LVgJDV3ym3R9fojljPu31F6Azps/5HSEEkihG+HoutkKhikxUEEIgFokS2ocvFizWtDE7vet/nH8MXH9/Py5evAi5XA6DwYCpqSlkZ2cjJyeHl6aN3/zmN/jpT3+KoaEhrFu3Dr/+9a+xZcuWZZ/3/PPP42Mf+xj+4z/+A6+88kpEawgGKvgSkEi89UIh2k0bhBB0d3ejo6MDpaWlKCwsDOl1JKrgA0JLNzMMg0/c9wA8UiXyVkevg5SyNLZJK8YGfVMiAEGgdk4ik0EqkSKnsBgZeflor7+ATe+4DZbRETjtNjimp6HUaLBm87aENIBOVS7Vn8fk+Bg+8pkvBv0c+/QURvquBIy+/RBCIJVFp4ZvbHAAlrGRsL33/HAsC6VGlfIRvmBfv0gkWnQO8O9//3u8+OKLyMvLw8TEBE6cOIHVq1eH5cf3wgsv4PHHH8eTTz6JrVu34pe//CXuuOMOtLW1LdiM6Ke7uxtf/OIXcf3114d8znChgi/B8NutRCuqNxu/aImGgbDH40FjYyNsNhs2b94MfRCploXWl6iCL9jxai2trXjsS19F9qpKqFOkTiQe+C1LxoeHYJ+ahEgkhEQmv1pDJ1NAm2ZEzQ03QW8yL5hOP3vwbYz09aJq6w4IBAJkFRQF/s9vAG2fmgTLMsgqKMbmd9yW0tYn8cLXnLEHxsxsvPPj94T03LP790BvXqBxgnBR+1ueO/R2xLV7gK/OUKWigi9cW5bZc4Cffvpp/PCHP8Rbb72FRx99FL///e/xpS99CWvXrsXNN9+Md7zjHbjhhhug013r3zifX/ziF3jggQdwzz2+z+KTTz6JN954A3/605/w1a9+ddHX8PGPfxzf/va3ceTIEVit1pBfTzhQwZcgEELAMAwYhgEQvajebPi0F5nN+Pg4GhoaoNfrUVtbC4lEEvb6ElXwBbO23zz5e7z69gEUVW+k6b8I8VuWTI6PwuW0g2M5yBUKX3ROpoBMIYch3RyWZQnHcdjz/LNQarQoqqha8DHzDaCnLBPY/fe/wONxg3Acymo2oWpLbUpvxLHA35yx5dZ/Q1H5mpCf39vZDpVGe83vOY5AEgVbFo7jMNB1OTA7OqJjsSzUM4Ivla8nHMeFvafMxmw24wMf+AAeffRRHDp0CEKhEAcPHsT+/fvxxS9+EZ/5zGfw2GOPLXkMj8eDc+fO4Yknngj8TigU4tZbb8WJEycWfd53vvMdmM1m3HfffThy5EjEryVYqOBLAPyNGX4BEatNwy/y+DKy5DgOnZ2d6O7uRllZGfLy8iK6MCWy4Fuqho/jONz90Kdh44TILwt9U0pFApYlIyNwOWxQqNRQqDWQymWBbtfMvDzeLUscNhvefO5PKCyrhGqBaQyLoTWkBfz4CCGYGB7Cq0//DizDxsQAOhWxT03iyM5X8L4gmzPmc6W9DS7b9IKCjxAOsiikdNsunAV40mYcx0GjphE+Po2XHQ4HAEClUkGj0eDDH/4wPvzhDwMIzoVhbGwMLMsGZgf7ycjIwMWLFxd8ztGjR/H000+jrq4ussWHARV8cSQWjRlLMTvCFykulwv19fXweDzYtm0bNBpNxMf0C75opJwjZbGUbkdnJx7+3BeQUVIGY4RF2isJxuPB2NAAJidG4Xa6IJFKfdE5uQIymQxypSrmliU97Rdxbv/bKFu/CeIIIgYCgQDGzCwYM33zQv0G0OcO7QNhOSi1/BlApypDvT1oPn0CH/vcV8Le7BtOHIEhI2vB/+NYLio+fG0XzgYagyKFY1loNZqUF3x8ZqQcDkdg4sd8ovEeT09P45Of/CSeeuoppKenL/8EnqGCL07EqjFjKfzdppE2boyMjKCxsRFmsxkbN27kbbD37BFmiSb4FmraePqZv+Ifr72B/KoNKXdB9rhcGBvsx+TEGLwej692bqaGTqZQQK5So7C8EsbMLKh1+ri/P6fe3g3LyAjKN27h/bO1qAH01IwBdGZ4BtCpSnvDBVhGR/GRx74Q9jEYrxeDPd1Iz1xY8BHCQSrnN6XrtNsw3HsF5tw8Xo7HcRx0Wm3KCz4+Z+k6HA4olcqwrwHp6ekQiUQYHh6e8/vh4WFkLnCD58+Avec97wn8zh9wEYvFaGtrQ0lJSVhrCQYq+OIAx3HweDxxierNJxIvPo7j0NbWhr6+PqxZswbZ2eEPBV+I2QbHiXaBm53S5TgODz72WYw6PChcpAYs2XHYbBgf7IfDNg2X0wG5QgmJTAaZXA6pTA6lRoNV69bDmJGd0JYlHMdh19/+DJ0hfVmDXr5YzADa7XSCEILC8uUNoFMRQgjOHtiLtIwsvOsToTVnzKfu2CHIFYs3TRFCeH//zx58m5faPT+EI1CpVNSWhceUrn+sWrjXK6lUio0bN2Lfvn143/veB8B3jdm3b9+C9X/l5eVobGyc87v//u//xvT0NH71q18hL4+fm4PFoIIvhsxuzPB/aeO9MYZbJ+dwOAI1CLW1tVEZPs1nyplv/BG+/v5+fOrTj8FUtAqmnMjGJsUT26QVE8NDcNimIBKJIVUoIJPLIZHKIJHJoFRrULWtFgaTOWI/sXhhm5zE7r8/g6LKtVCqIy85CJdQDaBTEcbrxeHXX8LmW+4IqzljPl0tTVAv0XEpgID397u3vY3X7wpHfF26TqczpT8bfKd0I52y8fjjj+Puu+/Gpk2bsGXLFvzyl7+E3W4PdO3eddddyMnJwQ9/+EPI5XJUVc0NCvgdLOb/PhpQwRcjOI4DwzBxTeEuRDhefIODg2hubkZOTg7KysqidvFJZMEnEAjw4suv4MXde5FfuQ5CHruc+cZnWWLBxOgQ3A47RGIJZAolZHIZJDI5JFIJ1DoD8lathmERy5Jk53JzI+qPH0F5zZaEmlG7kAH0UE8Pmk+fBMcxkMkV2Hzz7cjML4zvQmOIrznjZbzvvkfDas6Yj2V0BOPDg0v74PF8KR7svgyb1cqr4CMcB7VanfKCj8+Urt1uh0qlimgv/shHPoLR0VF84xvfwNDQENavX4/du3cHGjmuXLmSMH+vxLnyrVAIIYEuXH8tWiIIPT+hRPhYlkVrayuGh4dRXV29pKkkX2sDEk/wcRyHX//+KdghQmFldbyXE7AssYwOwTE9DbFYDIlMBolECp0xHWKpFAZTOkqqqqBPN0V1okAicmz367BPTqK8ZnO8l7IsQqEQ5ty8QN0X4/Wi8eRxHN+1EyzHQmdIw7bb/x3atLQ4rzQ6DPZ0ofnMSXz0/32Ft1rgcwffRnomv+Umy3Hh6CEYs/g9J8dxUKlUGB0dTRgBEQ/4jvAFM293OR577LFFLVwOHjy45HOfeeaZiM8fLFTwRZH5jRmJJvaA4CN809PTqK+vh0QiQW1tLS9fkmBINGuWoaEh3P3wI0jLK4Y5BBuPSPBZlgzDMjoEl8MBsUQSaIiQyuWQKZRIz8pC5cbN0BqNEIsj96haCXAchzeffRoGc+YcD71kQiyRILdkVeBnl8OBo2++AqfdDkI4ZOYXYcvNt68IA+iWMycxPjKEj4YwOWM5CCHov9wBbdrSExT4vC6zLIPB7stIy+C3K5twXCD9mGj7SCyJRoQvVaCCL0r4o3r+D2eifkGXE1SEEPT19eHixYsoLCxESUlJTO8uQxlhFm1eevVV/OZPf0V+RTWvRtV+y5LpyUmwXjekciVkCl8zhN++JLuwENXbd0BjSOP13CuVyYlx7HnhOZSsqU7amsOFkCuVKKpYG/h52mrB7n/8BR63GwKBAKuqN6Bqa3IZQBNCcHz3TqRnZeP99z/K67HbGy6A4YIpWeHv+tx08hjEUTBxJiwbECfJ9PflGz4jfE6nM+IavmSCCj6e8XvrDQ0NobOzE1u3bk1YsQf4LhyLRfi8Xi+am5thsVhQU1MT1pzBSEmUCN/nvvxVdAyOomim2D4U/JYlNtskOC/jq5/zT4mQyiCTK1C8pgoGU0ZCWJYkO5fqL6D17ClUbtya0LWVfKDRGwLzfa8aQD8JlmUgFkuw/vrENoBmGC/2/vNvqP2396BkDf/lEa3nTiMtffnSEz4v0R1NDdBGaeayUChM6euDv0SKzy5dGuGjhMX8FK7H40losQcsbssyOTmJuro6qFQq1NbWQhaFO9ZgiLfgs1qt+Ni9D0Cblbdo4bzLYcPo4AAc09MACGQKBWRyxUyHqxRypQplGzbCYDJDqdEm/GcimTnyxitwOZxYvX5jvJcScxYzgD5/aD84joVSk1gG0LZJC/a/+AI++MjnA1NL+MTldGCotxvm7OhaXczGNmnF6EDf0g0iYSIQChLSoiqWzG565AOHw0EFHyV0WJYNjEcTCoUQi8URGxrHgvmCihCC7u5udHR0oLS0FIWFhXEVKPEUfLt2v4Wf/fb3MObkY2JkGP1dHRCJRJDKFYEaOolUCqVGi6rN22EwJ69lSbLDMAze+OsfYcrOQ25xTryXkxBcawDtxpn9e2CfnvQZQGfEzwB6oKsTdccO4a6vfJO35oz5nNn3FrSGYLMS/FzjzuzfA6M5OoJaAEHKe/D59wI+mzao4KMEzWxvPeCq3UokhsaxZHbThsfjQWNjI2w2GzZv3hzwB4on8RJ8D3/mMzhy4jS8bjdECgXW77geBlMGZDFqVqEEj2V0BG//399RunYD5ClUjxMqUplsjtm0zwD6ebicTgAcCstiYwDdfOYkLKPDuOtLX4/qedob6mAwBekkwNNNbV9nO9Q6PS/Hmg+N8GFOAyQf2O32uJQqxQsq+CLA35jhFySzv4gikSggAhMZv6AaHx9HQ0MD9Ho9amtrIYlgtiifxFrw2Ww2fOyeByA1pGP7He/2vTdDAzh3aD8Ix0GmUGDTO26FwZS8JssriZazp9DRWI/KzdtTeiMMB58B9DoAswyg//I0GK8XQpEIazbzawDtm5zxNjR6A9533yO8HHMxBnu64LLbgSAHXfChH3raWuB2OqIm+IQCYcoLPn/9Hl+Cz+FwRH26RSJBBV8Y+BszGIZZdDyaSCQKFJgm8hdUIBBgbGwM3d3dKCsrQ15eXkLVmM0eYRZtDh0+gm/99BcoqKiCWOKLcgiFQpiyc2HKzgXga8A4e2AfPG4nOI6DOScXG66/GdI41TimMode+RcYlsGq6g3xXkrSs5gBdMuZU2BZBjK5PCIDaIbx4vBrL2HzzbejKAbjB0+9vQsZ+QVBP97rdkd8zsaTx2CMpt+fwPd3SaTrc6zh05IF4GfSRjJBBV+IzG/MWMxyxV9jkMiCz+VyYXR0FAzDYNu2bdBo4jduajFiFeH7xne/hzMtl1C8dsOSF1SpXD7HF23aasHb//oHOJYBiADlNRtRvKY6Yf/mKwGG8WDnM08jI78QZmN6vJezIlncAPp1cISD1mDEttveFZQBtH1qCkd2voz33vtwVJoz5sOxLAa7u5EZguBjGG9E5/R6PBjs6UJ6VvTqRwWgKV0+5+gCPlsWWsNHWZD5jRlLCQP/h5Jl2agVJUfCyMgIGhsbIZfLkZaWlpBiD4i+4HM4HLjz3vsh0aUjp3jV8k+Yx2xbDI7jMNjTjba68yAcB6lCjo033JowXZErgbGhARx8+f9QWr1hRY6AS1SuGkD7viMuhwMn9rwBxusFx7EwZeWg5oabrzGAHu69gsZTR/HR//flmF0H644dglId2iYuFEQmouqOHoQiys0v/mxHKgs+Pi1ZANq0QVmA2Y0Z/i6p5cLq/qkaidapy3Ec2tra0NfXhzVr1sDpdMJms8V7WYsSTcF36tQpPPHdHyK3vIqXlKxQKER6Vk7gLt/jduHC0QNwOx3gOA7pmdnYeOMtK2IqQjxoOHEMPZdaUbl5e0qntRIBuVKJ/FXlgZ9tk1bsf+kFsCwLwrEoKK+ETK6EdXQYH/3Ml2K6tovnz0CbFtvIb/fFZqg00Z28IxQkdsYoFvCd0rXb7VDHoUs9XlDBtwwcx4FhmGVTuPPxd+omkuBzOByoq6sDANTW1kKlUqG7uzuhu4mjJfi+/5Of4si5ehRV10RNPEhlcuQUlQZ+tk1ase+lF8AyXhAClK2vQena9Sl9AQ+WfS8+D6FQhNKZJgNK/PG4XBgbHoR9ygrWy0CuVEKhUkEsleL4rp0QQID/+v1fYrom26QVE8NDyCkuXf7Bs4ngGjAxPITRwX5k5ReFfYxgEAiE1JYlChE+WsNHCTRceL1eEELCmoObSIJvcHAQzc3NyMnJQVlZWeCiEW9j4+Xge7Sax+PBnffeD6LUITfG81XVOn2gg4/jOAz39aK9oc6X/pXJUXPTzTEf8p7oeDwe7HzmKeQUl8ak/otyFb+gmxwbgcflhtZggFylgkQmh1QqhUyhxOrq9UgzZwQMxRnGiyOvv4z81eUgcbiuHNv1elimx5Hc9J14aycyYmDuLKS2LLxG+AghcDgcNMKX6sxvzAhH7AFLjy2LFSzLorW1FcPDw6iurobZPNeXKpFE6ULwKUjr6uvx+a99A7lla+Je/yUUCpGemR0QeB63G3VHD8HtdMDtdCI9Owdbbr0Dcnnq3H3OZ6i3B0d3vopV62poF3QU8Au6qbFReLweSKUyn6G43DfuT6HWoHTNWqRnZQc1IcY+NYUjb7yM99zzEF5+8tcQS6Pr57cQvR0XYcyI3U0TIQR9lztgzomB4KM1fFGJ8ClSyFuVCr55+KN6/juJSO784i2mpqenUV9fD4lEgtra2gU/2IkgSpeCL8H38//5Nd46chzF1RsTsv5LKpPNSf9OWy3Y8/dn4fG4IRAIUbl5K8rWb0yZi/25g29jqPcKKjdvS8i/VzIQjKBbVVUNY2ZWxCP/hvuuoPHkMXz0s19GR8MFX1Ykxp/Vyy1NYJnwrmXhvvKL589AFKNmFH/TRip/H6Jhy0IjfClIMN56oRIvwUcIQV9fHy5evIjCwkKUlJQs+iVJ9IkgkQo+hmHwyfsfhFuiQP7qSh5XFl3md/+O9Pei9expcCwLhUqJLbe+E6bslTlC7LVn/gCVRoviyrXxXkpCM0fQedyBcX9SuRwyuZxXQbcUHU31GB8cwEc/80UAQNuFM9Aa0+F1u6JyvsU4f3hf+JG2MN+bxpNHYczICu+cIUK7dPm1ZWFZFm63m3bpphrBeuuFSjwEn9frRXNzMywWC2pqapYdG5MMNXzhvocX29rwyBe+jOxVlUhL4sJcoVAIc3ZeYAi81+PGuUP7YZ+0ghAO5tw8bLnt35I+/etyOfDKH36Lwooq6NJSZ9zRYiSKoFsMQgjOHdoHrTEd/37X/QAAp92God5eGDMyYxb5Anw+eMO9V5A9Mzc4ZMJ479xOJ0b6e+dE5qMJreHjN6Vrt9sBgEb4UoXZjRl8RfVmE+vo2eTkJOrq6qBSqVBbWwtZEHVPyZDS9XpDN0X97R+ewit79qEoQVO4kSCRylCweq4lxp5/PAuP2w2BQICKjVtQXrM5qTaG/q5OnNzzJtZs2R6YcrLS8bhcGB8exOT4KDwej0/MyXxpV1/KVR1XQbcUvuaMV1Bz480oWVMd+P3Zg29Db0z3dZOKYre9nNn3FnQRmHCH886e2PNGTOsF/TV8fNawJRssy/I29tPhcAAAjfClEqF464VKrCJ8hBB0d3ejo6MDJSUlKCoqCvq1rLSULsdx+NRDj2CaBfLL1kRxZYmDWqfHquoaAL7XPzY4gFf++DuwjBdKjRabb74d5pzcOK9ycc4efBsjfX2o2Lg1oURNpAQj6EoTVNAthWN6CodffxnvvechaOdFYnvb26BQqeH1uCEWx67RprOpHuqZEohwEIRhvNx9sRm6GPn9uZ1O9Hd2guO4hJlzHg/4FLwOhwMSiQTSODQXxYuUFnz+7ttoRUJiIfg8Hg8aGxths9mwefNm6PX6kJ6fDCndYNd3uasLD3zm88gsLYNRlTph+tnMn/3r9XjQePIYXA4bOI7AkG7CpnfcBnkCpLg5jsOe55+FUqNFUUXyiXO/oLOMjoBhvCtG0C1FoDljgckZA12dsE1OQqFSgxACkTg2wmR8eBCTlomIBF+oIb7h3iuwT0/FRPDZJq0Y7LkMg0ab8j58fDZt2O12KJXKFfG9DJaUFnxAdFOa0RZ8ExMTqK+vh16vR21tbVh3fvHuJF4Of6Hycjz9zF/xj1d3omDthpS+IM5HIpXOqWuyT03h4Cv/AsswIIRF8ZrquKR/HTYb3nzuTygsq4RKG90JBeGyUiN04TK/OWM+F44chDHT18BAOBKzGr7ju3ciKy/4ubkLEerf7uSeN5CZVxjROYNhYmQIMqUSlZu2AdMWWsPHcw1fKpkuA1TwRZVoiSlCCDo6OtDd3Y2ysjLk5eWFvdn4jY395tKJxnIRPo7j8OBjn8Wow4NC2tW5LCqtFiqtFoDvc2QZGcauvz0DwnEgHIutt70T5jCMa0Ohp/0izh3Yh7L1myCOY3rKL+isoyPwej2QyuUpLegWgxCC84f2QZtmDDRnzIdlGAz2XIZxxlfSF+GL/vZCCMHA5U6YcyPzwROEEOLjWBYD3V3IzI9MZC7HcG8PCsorcesH78QzP/oWso2GlBd8fEb4Um3KBkAFX1QRCoXweDy8HtPlcqG+vh4ejwfbtm2DRqOJ6Hj+Lw/LsjEbbh4KSwm+/v5+fOrTjyG9aBVMORkxXlnyIxAIkJaRibSMTAAA4/Wg7uhhTFst4AiH9KxsbL/933lN/57cuwuTY6Mor9kcdQHlF3S2SStYxguZUgmZXAGpTAaJTAa5QomSNWthzMyCSqtLWUG3FCzD4PDrL6PmhptRUlW96OPqjx+GdJaZOSFcTMR8y5mTkMh4qMEK4W/feOIo5MroFfoTQjDYfRkb33Ebtt32Tpw9sBcKlTpwLUzlzymftix+wZdK72fi7fArCLFYzGuEb2RkBI2NjTCbzdi4cSMvAs3/5UnUOr7FBN/f//EC/vTC/yG/ch2EKdy1xidiiRR5q66Om7NPT2HPC8/B43YBEKBsw0as2bwtrDtsjuOw67k/Q2c0IX91BS/rvUbQKZSQKWYEnVQGmVKJVdXrYDBlUEEXBv7mjPfc8+CytWqXmxsDvpFA7CJ8jaeOwWDi4WYvhM9Gy7nT0KdHp3aP4zgMdHXinR+/B6VrfXOju1qboNLqIOTcKR/h47tpI5U6dAEq+KK6CfBVH8hxHC5duoTe3l6sWbMG2dn8WQH4Lx6JLPjmz9J95HOPo9cyjcI16+K0qtRApdFiVfUGAL4NfHx4EK88/TuwDAu5Qo7Nt9yBzCBqp2yTk9j992dQVLkWSnXwEWkq6OLHSH8vGo4fWbA5Yz7W8VGMDQ3MmWFLOAKxNLoRPpfDjrGBfuQUR+6DF+xHxz49hbHBfuSWrIr4nPNhGC+Gerpx5+e+EqiFtIyOYHx4CBm5+RDN3PymsuCLRtNGKpHygi+a8FHD53A4UFdXBwCora3l/Y7E36WcqI0bsyN8Q0NDuPvhR5CWVxzWgHRK+AgEgjmzfxmvFw3Hj+KY9TUQjiAtMxPbbnsXlPNMTC83N6D++FGU12y5JuJzTQ3dTP2cRCaDTKGANs1IBV0c6Giqx+hAPz762S8F9fiz+/cGavf8EMJBLIqu4DuxeyfSeZo2E2wN3/Hdr0dlbq7b6cDEyBAe+MYP5pRQnDv4NoyZ2eA4DlKZJOUFH43wRQYVfFEkUsE3ODiI5uZm5OTkoKysLGpf9ES2ZvGv7aVXX8X/Pv1XFFSsjamDP2VhxBIJ8kpXB352TE9h37/+DpfTAaFQiNXrN2JiaAh9XR3Q6Axobzi/YISupKoaxoxMKugSAF9zxn5oDQa85+4Hgn5Of1cHtAbjNb+XBGH8HgldbS0wpJt5OVawc397L7XBYOa3Xthhm4bH5cTD3/npnGv87PeWYbxQKFTUloXnpg0q+FKMaG4y4Qo+lmXR2tqK4eFhrF27FhkZ0W1ISGRrFqFQiCf/9AwmvQTFa9fHezmUWXg8HowPDWBybAQetxtiiQRqrR5KjRbH33wdBnMGhEIROI7FttvfhayCongvmbIIvuaMl7D+undgVfX6oJ/X0VgH1stc83tCOIiiOGljoKsTLrsD4KGUjnAchKLlRcSV9raZelb+mLJMQKlR4+Of/+o1/9fZVA9m5r3lWBZqpSqlI3z+yVh8N22kEikv+KJJOFMspqenUV9fD7FYjNraWigUiuWfFCGJGuGzWq24894HoMspQGYkpqqUsJgv6KRy2cw8VzmkcjkUKg1KKqvmdLlOToxjzwvPYfMtd0AxY37NeL1oPXcG5w8fAGFZaNLSsPnm20Oq56NEj1CaM+bTcubUwhEvgqh26Z56ezcy8vgp6+AIF9Q4v7P798DEYzrXMjKM3FWrcfuHP7Hg/7ecPYW0mfeWYzmo1VTwEUKoD18EUMEXRUKJnBFC0NfXh4sXL6KgoAClpaUx+2InYg3frt1v4ae/eRL5FWvj6tW2kvF4PJgYGsDk2CjcHvc1xsJylRrFFWuQnnVbUCnXS/Xn0Xr2NCo3bp3TOS2WSOZE9xy2aRx5/WXYJidBQLCqej3WbrsuZTeyeDLS34v6Y4eDas6Yj8vpwFBv94I1bQTR69JlWQaDPV28RYwJRyBZZrwWyzAY6u3h5ZyEEIz092Lzzbdj4423LPgYj8uFoZ5umGZGInIcC61Gk9K2LP49iq/rhNPpDHkyVbKT8oIvEVK6DMOgqakJFosFNTU1MBqNyz6HTxJtnu5Xv/5NNF7uQfHMfFhKePgFna/LlYFUoYBcoYBkpoZOLBajqGIN0rOyI66hO7LzZbidLqxev3HZxyrVmoA1CyEEEyNDePXpJ8EwDGQyGTbefBtyZk0HoUSHjqYGjPb34WP/78thPf/cwbevmaUbgCCoqFk4XDhygNfpLBzHQSKTL/mYc4f2Qa3T83Kuwe7LePfdD6CwvHLRx50/sh/qWWKEY1loZgRfqt4Y+fcoWsMXPikv+KJJMIJvcnISdXV1UCqVqK2thSzKhc4LkSgpXZvNho996j7ITVnIKiyJ93ISnmAidHwJusVgGAZvPPtHmLLykFOcG/LzBQIBjBlZMGb4bCgYrxctp0/i5O6dkCkU0OjTsOnm26GK0GCcchVCCM4f3g+1zoD3fCq45oyFuNJ+EXLFwhumz3g5OttL24Vz0BrSeDse4VhIpUtfd9vrz8/xGQwHxuvFUG83PvmFr0GfblrysT1tLYGSCMAndpQKeUoLPpZlA64SfEAFH4VXRCJRoNB0/oeUEILu7m50dHSgpKQERUVFcQvVJ0JK99DhI/jWT36Ogsq1UYsMJBuJIOiWwjI6gn3/+gdKqtbzNo1DLJH4PM5mfM6cdhuO7nwFXq8bhBDkryrHmi3bE3IqTDLgn5yx/rqbQmrOmM/QlW5MTUxAnrOI4EN0avimrRZYRoZ5rf/kOAKpYnHBNzUxDsvoCJQabdjncDsdsIyO4KFv/whS6dLRxPGhQUyMjiAz96rHJSEEPT090Ol06OrqgslkgsFgCGt+erLCZ8MG4Kvho4KPwhv+D+f8VnKPx4PGxkZMT09j06ZNMBji25AQ75TuN7/7fZxuaUNxdU1K1af4BZ11bBQejxtSqRQSmRwyue+fXKWJq6BbipZzp9DRUI+KTeFN3ggWhUqN/NXlAHyb3uT4GN76x19BOA4isRjVtdcjp4hGg4PBYZvG4ddewrs/9SD0xsjaW88fPoD0rMU98Hx/H/7FyLE3X+Pdg5NwLKSyxZvjju16DRn5hWEf3zE9Ba/Xg4e+/eOgvitnD+6FOXtuXSThWGzZsgUulwsikQhdXV1oamqCRqNBWloaDAYDdDodr4Io0eDTkgWgXbopSbQnbQC+D6r/TmxiYgL19fXQ6/XYsWNHQtyhxSul63K58LF77oNYa0ROMf/O9fHmag2dBYyXgUyphFwuB8exkMoSW9AtxaFX/gWWZQNTOGKFQCCAPt0USIexDINLdedRd/QQCMdBrdNh8813QKUNPxKzUhnp70P9sUP46Ge/FHHkzdc0cRlp5swlHydephEiVAgh6O24hPQs/iYNAb7IkUy+cNSNEIK+zvYlxe1STE2MQ6M34OMPfSbotQx0X4beODflSzgCrVYLl8uF0tJSiMViuN1uWCwWTExMoLW1FV6vFzqdDgaDAWlpadBoNElzTQkGPufoAjSlS+EZoVAIgUAAlmVBCEFnZye6urpQVlaGvLy8hPkyxsOH79SpU3jiez9EblkVpHGoW+SDxQSdRCaHRCaFTKFE6drqFTMpgmE82PnM08gsKAzZviMaiMRiZM6KvDjtNhx981UwHg9YlkP+6jJUba1N+fRvZ3MDRiJozphP08ljEC9T80Y4jvf3vbO5Ab5kMb8QQiBXLrzxdzTUgYR5yvGhQRRXVePm93846Oe0XTgLcNeekHAs1Go1RkZGAoEEmUyGzMxMZGZmghACh8MBi8UCi8WCK1euAAAMBkNAACoUiqS+BvGZ0vW/X+p5k4FWOql9JZxBIBBcM6+VL0QiERwOB5qamuDxeLB161ZoEywCEesI3w9++jMcPnMBRWsTO4V7jaBTKGYmRaxMQbcUY0MDOPjy/2FVdQ2ki0RD4o1CpUb+qrnp3z3PPztTQyvA2m3XzZkOkgpcOLwfSq0+6MkZwdDeWA/tMg0MhBBIJPzeyNUdWTqNHC4syy5qy1J37BBMIY5vI4RguK8HtXe8G+t23BjSc9vqzkJvunZ6CMtxgfTjQtcZgUAAlUoFlUqF3NxcEEIwPT2NiYkJjI6Oor29HVKpNJD+NRgMcWkQjIRopHRphI/CO/X19cjIyMDGjRsTMtoQq6YNj8eDO++9H0SpRe7MxhxP5tTQuV2+kV8zNXRSuRxyhQqlVdUwmFe+oFuKhhPHcOVSKyo3b0+a92Ch9G/bhXM4s28PWI6F3piO7Xf8Oy9WG4kIyzA4svMVrNtxA6+p92mrBeOD/TAvU0dHCIGQx2udx+3CcN8VZEehe59wHKQL2LL4zxlKjSjHshjs6cL77v80cktCu7lwOR0Y7r2ysK8hR6BUKiEQCIL6DgoEAmi1Wmi1WhQWFoJlWUxOTmJiYgK9vb1oaWmBSqUKCEC9Xp+Qe9Ns+G7aoIKPwhscx+HSpUtgGAZFRUUoKyuL95IWJRYp3br6enz+v76B3PI1kMmjPz0EuCropi0TcNimIVMo5gg6RZLW0MWS/S89D4FQjJKqdfFeSkSIxGLkFJcip7gUAOBy2HHw1RfhctgBAEXla7DuuhsTftMLhkBzxt0PLGv/ESpn9r+FtBkLnaUghEDKYw3f6bd3Q8/T3Nz5cCy7YNT69Nu7YVgg2rYYXo8bI329uOvLXw/LNmYpX0PhzKUp3AiXSCRCWloa0tJ86/J6vYH0b3t7O1wuF7RabSD9q9VqE87+hc8Inz+lSwVfCsJ3StfhcKC+vh6EEKhUqrh34S6HUCiE1+uN2vF//j+/xltHjqN43UZeRRVNuUYPj8eDnX95CjlFpbx6niUKcqUKJWuqAfjTv6N4/Zk/gGUYiMUSbLjxZhSsStybtMUYHehD3dFD+OhnvhiVpom+znZo9Mt/HgjHb4TvcktTxD54i8FxHCQL1CSGck6X04Gp8TE8/O0fh/2+X2lvg1yxSNeoALx68EkkEpjNZpjNPkHrdDoDArCxsREcx0Gv1wcEoEqlivv1k88In9vtBsuytIaPEhmDg4Nobm5GdnY2ysvLcfr06bh73C1HtCJ8DMPgk/c/CLdYjvzVi7vKL0Ywgq6kqhppKZ5y5Zuh3h4cfeNVX71ektX5hIMv/WsORJBYhkFH/QWc3b8XHMdCl2bE9n/7d2h0iX3jdrm5AcN9V3hrzphPV0sTvG5PUI8VCPibiDA62I9p60TUBB8hLCTzInxjgwOYsgR3TtvUFAjH4YFv/jDs1zzcdwVTE+OQ5yws+ATwBSWiFXVTKBRQKBTIzs4GIQR2ux0TExOwWCzo6uqCUCicU/8Xixnv8+EzwudwOACA2rJQwoNlWbS2tmJ4eBhr165FRoZv6HU8OmBDJRpNGxfb2vDoF76MrFUVSFukA87r8WCcCrqE4sLRQxjo6kTlpm0p+36LxGJkF5Uge6Z2y+Ww4/CrL8PlsIEAKCyrwPrrb4I4Cj5z4XLh8AEoNRq851MPRe0cTWdOIC1jaSuWq/D32Tmxeycy8/mZm7sQHHutLcuJt3YiK69gkWdcZXJ8DHqTGe+779MRreHC4f1LNqQIhIKYTdkQCARQq9VQq9XIz88Hx3GYmprCxMQEBgcH0dbWBrlcHoj+xcoAmk9bFrvdV8pBU7qUkJmenkZ9fT3EYjFqa2vn3P0ki+Djc42//cNTePmtfcgtX4vx4UHYJi9RQZcE7Hn+OciUShRXro33UhIKuVKF4jW+98Tf/bvzmT+CYbwQi8VYf91NS85FjSYsw+DIG6+gevv1WL0uerOnPS4Xhnq6YMoOcnweT19ljuMw0HUZGXn8mi3PP4dk1vQLjuPQ39WBjNylBd/Y0ABWr9uIG9/7gcjOz7Lo776MNFPGoo8RCoRxG6smFAqh1+uhn5ntyzAMrFZrIPrnN4D2C8BoGUDzmdJ1OBxQKBQJV6cYbajgQ/jmy4QQ9PX14eLFiygoKEBpaek1H6BkEHx8Ttr43g9+iD8+8xeYsnNgysmjgi4JcLkceOMvTyN/VRnUCZ62jDcLdf92NNbj/KH94AgLjT4NtXe8G5oY1O06bTYceu1FvPvu+6PW0ODn/KF9celobjp1POo2QBw3t2mj5czJBbt2/RBCMNTbjevf/X6s3boj4vO3nD0FkXBpISMQxC7CtxxisRjp6elIT/d5cfoNoC0WS8AAWqvVBppE+DKAZlmWt6Yq/5SNVNuTqOALE4Zh0NTUhImJCWzYsCHw4Z9PMgg+PiN8Xi+Dyk3bMD01ha7WJlhGR6AzGrGqegPvHYOUyOnv6sTJt97E6vU1dIZxGFzb/evA4Z0vw2W3gxCCgrJybLjhJojF/L63owN9uHAkOs0ZC9HV1gKFKvYF7i1nToTUKRsus4VE0+njMCwSbfNNGenCfz70WWQXFvNy7vaGC9AtM+pOMNO0kYgCZb4BtNPpDNT/+Q2g9Xp9IP0brtDiM8Jnt9tTrn4PoIIvLCYnJ1FXVwelUokdO3YsaWAZK4+7SOAzwqfVacBxLIzmqxdpm9WKPS88B7lSBX16OjLyClBcuXZRs1NKbDh78G2MDvSjYtPWhNxIkhH5rJQ4IQSTE2PY+czTYBgvRGIJ1l93I4oiTP9ebmnE0JUe3Pm56DRnzGekvw+T4+OQ54ayQUb+eXLabBgbHAiI6agxy6HB5bBjpLcXeauu9dDzeDwY7buCe574NtRaHS+ndtimMdJ3ZVlfQwESJ8K3FAKBAEqlEkqlckED6I6ODkgkkjn1f8EaQPPdtJEIncexhgo+BJ/SJYSgp6cH7e3tKCkpQVFR0bLPFYlEYBiGj2VGDT6bNgxa7TUCVyyVIqvgatF1e2MdGo4fgc5ohDbNiOLKapiyc1LuyxcvOI7DnuefhVKjQ2FZfGrPUgGBQAC90RSYi8qyLC43N6Lp1HEIACjUamx6x23QLeK9thAXjhyEQq3Ge++JXnPGfM4f2hfytAk+vsrH33o9+JpBnji26zWY8641PnbZ7ZietODh7/6UV6/Gswf2BpWOj2XTBp8sZgBtsVjmGED7BeBSBtB8Nm34U7qpBhV8QeLxeNDY2Ijp6Wls2rQpaG89kUgEt9sd5dVFBp9pZ41WC26ZY+kMRugMvk3ObXfg8GsvQiyRQm8yIT0rB6VV6yBPwS9jLHDYbNj1tz+jsKwSSk1ijfhb6YhEojlpQLfTgVN7d8PrcYNjWGQVFWH9dTcsmP5lWRZHdr4c9eaM+XAsi4HuzkVTnIsTueLrabsYk3Tu7LWO9PVeM1fXNmWFSCjGg9/8Ie9n7u24BKVaE8QKk1PwzWe2AXRJSckcA+iOjg44nU5oNJpA9E+n0wVeM5+vn6Z0KYsyMTGB+vp66PV67NixI6QW9GSp4eMrwqfX6UBCOJZQLEbGLPuD/ssdaD5zAjqDEdq0NBSUVSKroCjpL3SJQE/7RZw7sA+r122EOAY2CpSlkSmUgdm+hBBMWyaw54W/gWM5CABUbt6KooqqQHPGv991XxjCKzKaz5yAUBT6NhFphK+34xLcTmdkBwkSjvNdn4eudGPKMjFH8FnHRmHKycG77+JvFrGf/ssdsE1NBiX4hKLo+vDFi/kG0C6XK1D/NzAwAIZhAvV/Ho+H15QuFXwpymKpREIIOjs70dXVhbKyMuTl5YWcdkwWwcdbhE+jARfB1BKlWhO4AHo9XpzeuwuEEOjNGUgzZWBV9QaotDQyFSqn3t4F6+gYyms209R5AiIQCKBNM0Iql2G0vx/26SkceeM17H/pn2AYL77yP3+MSXPGfNob6kJKOfPFmf17YM69NrUaDfzNKOcPH5jjhTc60Ic1m7djx7veG5Xz1h07hPTM7KAeG09bllgil8uRnZ09xwDaYrFgYmICTqcTra2tGBkZCUQAwzWAttvtKefBB1DBtygulwsNDQ1wu93YunUrtGGKjGQQfLw2bWi1IBw/r1coFCJ9Vg3P2NAA2urOQ63TQWc0Ird4FfJWlUXF82mlwHEcdv3tz9ClmZC/ujzey0l5PC4Xxgb7YZuaBOFYyBRK34xnqQwSmRQqjQ5V22qRZs7AYHcXzuzfA7FMFhexZ5+axGh/77INBXzDMgyGrnTPqfuNLgJwLIvBnstIM2eCcBwGr3Tj1v/8KMpqNkfljP5uX2MQc4kBQDhjy5JKN2uzDaDz8vJw9OhRFBYWwuv1BgygZTLZnAkgwc5vdjqdVPBRfIyOjqKhoQEmkwk1NTURFenyKaaihVAoBCEEhJCILygajSaklG4oyOQKZBf6NgHCEdQfP4wzB/bCYDJDbzRhVfX6Ze0NUgnb5CReffq3KN+4Nai0ESVyGI8H48ODmJwYBctykM8IOr/ZuFypQtmGjTCYMqBcwp/swpGDUKhUMOXkweWwx/ZFzHBm/x6kmYOdrDGf8K8j5w7tg1qrD/v5oSIQAE2nT0AskYFlfELsI489HlWh23jiWEj+gsIkbdrgE0IIdDodNBoNioqKwDAMJicnMTExgZ6eHjQ3N0OtVgcEoF6vXzQYQCN8FHAch0uXLqG3txeVlZXIyQmtM20hkiHC57+I8GFsqdPpYiZwZ29G05YJvPX8sxAKBNClm5BTUopVazekrPVLZ3MDzrz9FtbtuAkiHrsKUx2GYWAZGYZldBguhx0SqRRCkQhKtQYSmQwKpQqFFWtgzMiEWqcP+QYq0Jyx7TqYcvLQdPoEVHFqruntaIdaF6b9SAT3je3152NiXB1AIERH4wXIlUoM9fbgvv/+HpTq6HoOdjY3hDybOdUF33xbFrFYDKPRCKPRV3Lg8XgC6d+LFy/C4/FAp9MFOoA1Gk3g+Q6HA7pwP9sz/OY3v8FPf/pTDA0NYd26dfj1r3+NLVu2LPjYp556Cn/961/R1NQEANi4cSN+8IMfLPr4aEF3AvhCxw6HA/X19eA4DrW1tbyp/2QQfP67ID6EmlqtjktEc771y+WmJlw4fAAavQF6kxkVNZuRnpUa1i/Hdr+OydExrLvupngvJengOA6T46MYGxyA026DWCKBVCaDVC6HVK6AXKFEVkEBqmt3QGtIg3CZCQmh4LTbcOjVq80Ze//5HNIzs+G023g7R7D0tLXA7bSHL/jCVHxTE+OYGB2OaQc56/Wit/0SVFodHv7OT3i1XVkI26QVowN9yAghguiv4YvFzNpEhBCyrPGyVCpFRkYGMjIyAgbQfgHY29uLjo4O/Otf/8INN9yAvr4+ZGaGG70GXnjhBTz++ON48sknsXXrVvzyl7/EHXfcgba2tkADymwOHjyIj33sY6itrYVcLsePf/xj3H777WhubuYlsBQsVPDBNwv3+PHjyM7ORlkZvzVhySD4Zre983GsRLgH1RmN0M3c+XEMgwMv/RMEgD49HZn5hSjfsBmyMAt+ExWO4/DGs0/DaM5CUWVVvJeTkHAcB5vVgrGhAdinrBCKxFcFncw369mYkYnyDZugM6bHLDo6NjiA84f3ByZnEELQd7kT+jiVKDScPAZjkA0FCxHubdXRN19DZn6savd8TFsnkJlfiE9+8WsxOd+Z/XtgDDFV7ndSSNUIn39vCnZvnm0AnZOTA0IIMjMzceXKFezduxfnzp3D8ePHceXKFdxyyy245ZZbkJsbvOfjL37xCzzwwAO45557AABPPvkk3njjDfzpT3/CV7/61Wse/7e//W3Oz3/84x/x4osvYt++fbjrrruCPm+kUMEHX1SqpqYGaWlpvB87GQSfQCDgdyJIgkXRhGIxsmb5nw32dKPp5HGotDro09OxqnoDsotKkjr6Nzkxjr0vPIfiNdVxGYGVSNimJjE+2I9pqwUAIJXJZyJ0csjkCujTzSheUwV9ujkhUv5drc0Y7OnCnZ/7SuB3bRfOgpD41P56PW4MXumCKTOCyEMYXyVCCPovt8/plI02ltEROB32mIk9AOi73B5yjWKq1/D596ZwX79AIMDq1avxrW99CwDwvve9D5WVldDpdPjd736He++9F6tXr8Z9992HL37xi0sey+Px4Ny5c3jiiScCvxMKhbj11ltx4sSJoNbjcDjg9XqjojmWggo++P5Y0Xrj/UKKj4aIaMKnF58wgV8nAKg02kBdFMdxOLlnF7xuF3TGdJhyclG5aWtSmRJfqj+H1nNnULFxK4Qp0LHsctgw2t8Ph90GgECuVEEml4NjWUjlCmjT0rDuuhthNGeGVBgfD+qOHoJUobhmcsbF82dgCGICQzS4cOQAVOrIPv/hXAEu1Z+P2c0iIQSjA33IKijC2GBfTM4JAD2XWuG020MWfCLByvThCxb/3sTX63e73Vi/fj3uu+8+fO9734PVasWhQ4eC2gPHxsbAsiwyMuZ6YmZkZODixYtBnf8rX/kKsrOzceutt4a1/nChgi/K+OtB+Bz8HA14jUQmtt6bg1AonOP3ZRkbxct//C0UShV06SYUla9BYUUlr7VafHLk9Zfhcbuwet3GeC+FN/zWJfapKbAcC7lCcbXTVSqFQq1B1dZaGMzmpI1msiyLoztfRtW2HShbv2nO/zntNgz3Xrn6uYzx96n7YgsPXd2hL7r+2OGgfekigeM4DF3pwh0fvRsXL5yOKHUdKo0nj8IURgTTb8uSqoLP37DBV9DE6XRCPasxR6/X4z/+4z94OfZy/OhHP8Lzzz+PgwcPQh7jG1Iq+GYQzNxB8c3sDthEFnx8RPgIIbh8+XLUbFligVyhRP6qq3519SeO4Pzh/dCbzDCkm1BavSEuRrTzYRgGbzz7R5iz8+Z4FSYDjNeL8eFBWEaG4HG5IJXLIZHJIZtJuyrVWqyqXg9jZvaS1iXJisNmw95/Pof3P/DogrYnZ/bvgT7dFIeVAeNDg5gYGQ6poYAPPC4XRvp7kVNUEtXzMIwXQz3duPNzX4HOmI4DL78QszpNxus7dzgC0399XmnfhWDhO2ASyWi19PR0iEQiDA8Pz/n98PDwso0gP/vZz/CjH/0Ib7/9Nqqrq8M6fyRQwRdl/B/SRK/ji7SGzz9r2GazQRTGKKZEZXbEYWpiArv/8VcoVSro003IzC9CUcWamI8pmxgZxv4Xn0fp2vWQKRJvPBDDMLCOjmBieAgupw0SqRQSma/LVSaTQ6FSoWB1GWpueAfUOn1KRS1G+ntxau9u3P2lry9qptzZ3AC98argE8QwxHf24F6Y+LiBCHHJJ/e+CWNG+F2TweBxOTE+PIgHvvEDyJVKnD24F3KlGl6PK6rn9VN39CBkivDcH2gNH8vbayeEwOFwzInwhYJUKsXGjRuxb98+vO997wPgE6T79u3DY489tujzfvKTn+D73/8+3nrrLWzatGnRx0WTlbMzJyi8N0REiUgMoq1WK+rq6qDValFbWwuR6Fc8ry4xEEulyJ5l/dJ24SwuHDkAfboZOqMRxZVV/GyWS9By9hQ6m+pRsWlb3C7+fusSy9gI3A4HJDIZ5AolCMdCIldArlAgMz8fa7fX8m5dksy0159H3+VO3PPEtxZ9zJX2NrjsdmCW4GMYbwxW5/u7DnRdjkt0saulCdooRs4dtmm4nU48/J2fBr43XS3NUOt0sI66o3be2XS1Nodlc0MIgYAKPl4jfA6HIyLrtccffxx33303Nm3ahC1btuCXv/wl7HZ7oGv3rrvuQk5ODn74wx8CAH784x/jG9/4Bv7+97+jsLAQQ0NDABCYJBIrqOCLAcnQqRtOSpcQgitXruDSpUsoLS1FYWGhT+CmSNZBZ0wPTPZw2mzY/+ILgEAAfboJWfmFKKvZBJmcP+uXg6/8CxzHonTtBt6OuRAcx8E2acHEyBBcdjtEEinkCoWv01Uqg0QmQ3p2TsytS5KZ0/veglyhxIce+dySj/PNkL2aTiWEgLCxKZFoPXeav6aJEI4z0tcL2+Rk1ATftHUCCrUaH//8VbsM69goxocGkJFXEJMayTnnCxHCcZDL5Skt+PhO6TocjrBTugDwkY98BKOjo/jGN76BoaEhrF+/Hrt37w40cly5cmXO3+p3v/sdPB4PPvjBD845zje/+c1A53AsoFfqGaJVwwckx3i1UEUpwzBoamqCxWLBxo0b53Q5xzIFlSiIxGJkz6o/Gui+jMZTx3zWL0YTVq/bgKzC4rBqcBjGg53PPI3MgkLo0vjxZbNPT/nMhW3TEIpEkCsVkMqvNkbo0tJRVFEFgykxrEuSFZZlsf/F57F+x42o2LR1yccyXi+GrnQje5aFEAAIYrTJX6o/x5vvXyif8hN73kBmQSEv552PZWQY+avKcOuHPz7n92cP7IUxhvYvkZyP4zgolYqU7tLlM6XLcRwvs3Qfe+yxRVO4Bw8enPNzd3d3ROfiCyr4YsBKi/BNT0+jrq4OMpkMtbW1kMlkc/4/VhtUIqPS6qDS+tI3HMfh+FtvgHG7oUtPhyknz2f9EkQn5OhAPw69+i+sqq4JyWLE5bBjdKAPUxPjkMhkkMn9gs4XoVPr9Fh/3Q0wmMy8RiEpV3Habdj7z7/jffd9GmlB1KedObAXWsO8KFeM7JwctmmM9PXCnJO3/IODIrg1+9PImfmhR76WghCCkf5ebL75dmy88ZZr/q/vckeg+Sra7y8hBAPdndDow7P+4lgWapWKV9GTbPAZ4bPbfbOpY5lKTRSo4IsBySL4glljf38/WlpaUFhYiNLS0gUvlkJR6kX4lkIoFM7perSMjuDlp34DhVINXXo6iivXoqCs/Jpat4YTR3Hl0kVUbt5+zfvsty6xTU2C41gICIFErpjpdFVArdVizeZtSMvITFrrkmRmtL8PJ9/ehU9+8b8gkcqWfwJmZsjq585XJYjNDdTZA3vnNIpESrBXgMYTRyCPILW2EBzHYbD7Mt599wMoLK+85v87G+vBzqmLjO71qrO5AV5P+HWYHMdCo1bTCB9Pr93pdAIAb+NTkwkq+GaI5l1eMgi+5dLOLMuitbUVw8PDWL9+PUymxTeHxBiulrjMtn7hOA71Rw/hxFs7odEbYM7NQ8XGrTix5w1MWSyQyeRou3AGMoUSMrkcErkcUpkMcoUKq9fXIM2cuSKtS5KZ9oY69HZewj1f/VbQz5kYHsLUxPg1gg8x2uR729v4NRsP8uPYcvY0r00i/rT4J7/4tUWP23Lu1IJ2ONGi5cxJpJkzln/gInAcB41Wk9I1fHw2bdjtdohEomsyU6kAFXwxIBkE31IpXYfDgbq6OggEAtTW1kKxzAxaYap0bfCAUCiEMSsb/kSezWrFMz/6NgRCIdLMGSitXIuqbTtoHV2ScHr/HsjkCnz4kc+H9Lxju3ciK7/wmt8TkKhH+Ho7LsFhs8V8uoyvjrQfuSWreDme2+mAZXQED33nR5BKFy5/8LhcGOrpgml26jqKN0setwtDV7oj6t7nWBZatTrlffj4Erv+ho1UfC+p4IsBySD4Flvj8PAwGhsbkZOTg7KysqC+dFTwhYfTYYd1dBgfeuRzOHvwbeiNJvR1daCjqR46owl6oxHFVdUxmUZACQ1/c8a62htQuXlbSM/lOA4Dl9vndOcGIIBAEF3Bd3rf7qBqDEMiiM30+K7XYc7jx+DZMT0FxuvFQ9/+8ZLXqHOH9kFjmFtLF82r1YXDBwK1vOHCsRy0Ghrh4zPCp1KpqOCjRIdk8OGbv0aO43Dp0iX09fWhqqpqWQfx+ceKTr/zysU6NgqFWo2Hv/NT9HW2A5zvHdQbTQFPNrvNhgMv/xNSqRx6kwmm7FyUVq1L+HmxKx1/c8Z/3PswjJlZIT+/5cxJSBZJL0U7wudLgfZc0xkcC660X+QltTo1MQ6NIQ0feHBx01s/PZdaIVfOq92K4sbfc6k14jF1hHBQqVRgGCZlBR/HcYExpZHicDiWzVKtVKjgmyHVa/iEQiE8Hg8AwOVyob6+Hl6vF9u3bw+5uFUoECCxX23iwHEchvt6sPHGW7H11n8DAEik0gUtgsRiMTLzCgM/97RdxIUj+6HS6qFPn7F+KQjP+oUSHqP9fTjx1k584ktfWzSNuBxNp47BYFqkxosA0dzjz+zfA938zmBeWPoz2HPpIryeyA2Px4cGUVxVjZvf/+FlHzs60Afr2Og1Y+Oi9W0ZHxqEZWR44chtCBBCoFAoMD09nbKCj2VZSHkqa/GPVUvF6yQVfDEgGQSfv2ljfHwc9fX1MJlMqKysDCuMLhIIqeALArfLibHBAXzss1+aExkSS6XggvCEVOt0Aed+juNwbNfrYL0MdMZ0mHPyULFpS8TRBcritDfUobfjEu792nfDPobTZsPoYD9yixerYyMQCKI3qaSjsQ5qnZ734y63lZ49sBem7PAtYAghGO7rQe0d78a6HTcG9ZxzB/ctXEsXpX3/3KF9vJRfEM4X4UtlwcenLUukUzaSGSr4YoBIJApEzxIVgUCAqakpnD9/HhUVFcjNDb/IWChKzYtSKExZJiAUifDI9352zUVcKpUCJDSjbqFQOCf6NzEyhJef+g1kCiUy8wtQsKocOSWldMwZT5zZvwdSmRwffjS05oz5HNv1OsxLCB/fWK3ofJ8mRoYxOT4eFcG3FIsZTAcLx7IY7OnC++7/NHJLVgf3HI7DQHfnIpFU/t9fQggGujqg48HqhiNcwDMuVQUfn7YsVPBRop7STeRJGx6PB319fXA6ndi2bRu02si69VLzkhQcfkPYyk3bcMN73r/gY8RSacSfF7lSFbB+YRkW5w7tx6l9b8FgMkNvMmPV2vXQGsIzgk1lOI7Fvhefx9pt16Nqy/aIj9dzqXVZy45oifTju15HFs+Gx8Fw5sDea+1ngsTrcWO4rxd3f/nrIX1+W8+egmCR9zEaV/62+vNBRemDgbBsoMkgFdOQAL9NG5GOVUtmqOCLAYmc0rVarairq4NUKoVWq41Y7AGAkMeZhysJj9uF0f4+fPDhzyKzoGjRx0lkMvA55U8oFM5JGVvHRrHrb3+BUq2GPj0dWQVFKKxYA7FYwt9JVyAuhx17Xvgb3nvPQ0jPijxVF0wdW7QifIQQ9F/ugDmXr8kac3HYpxf9v46GC2EJPpfTganxMXz62z+GOMR6rksN5xcfGxcFDdV27jQM6WZejsURAqlUmrLRPYCmdPmCCr4YkIiCjxCCnp4etLe3Y9WqVZBKpejp6eHl2CKBALRNdy7TVgs4lsHD3/3pst1mYrEUJIoRYalUhuzCq4Kz5dwZXDhyAPp0M3RGI0qq1sGYEXq36UpmdKAfJ/e8iU988YmwmzPmc3b/nuX92Uh0SiRazp4KWTSFwmJRScvIMKxjoyGnkW1TUwAIHvjmD0MWPk6bDSO9VxZsniBRGF3ncjow1NezZKo+FPyvNlWjewC/KV2/LUsqQgXfDKnUpcswDJqammCxWLBp0yYYDAaMjIzwlnaWyaTgHN6UviP1QwjB2EA/itasxW0fujOo5wiFwmg6RVyDId0EYMb6ZdqG/f96AVKFHPp0M8w5uShZU53S1i8djfXouXQR9zzxLd6OyXi9GOpd3g6FgEAQhRBU48mjEU1/WI7FrqdH3nhlyej2QkyOjyHNnIH33vtwWGs5c2AP9ItE2wghEPFk9+Hn/MF9185EjgSBIKU9+AD+I3zUloUSNRJJ8E1PT+PChQtQKBTYsWNHoNWdT69AtUoNbnospS9QAMB4PRjuvbLoTM+lic/dvFgsRmZBYeDn7ostaDx5FFpDOnRGI4oqq5CRm58y0Yb6Y4dBCMFHHnuc1+Oe2f8WdGlBiAICiET8XqaddhvGBvuRU1TK63GXgxCCwe7LIdmUjA0NoGz9pkXrXYOht+PSot3qhOMglvAb6bzSfhFyBX81YkIq+Hhv2jCb+Um3JxtU8MWARBF8/f39aGlpQVFREUpKSuZs2nw2lqjVanDsMCBJ3Zow+9QknA47Hvz2D8NLASaInlLr9IH0m8ftxpGdL8Pr8cCQboY5Nw+Vm7ZCoVLHd5FRgONYHHvzdaxaX4OqzZE3Z8ynvaEuqDo2AsJ7Svf47p1Iz8rh9ZjzWeh+oL3hAoRBRtN8NYbtuOn9H8barTvCXsdAVydsU5OLCj6O4yCV8jdTdaSvF5MTYzDn8DNBBAAEQir4+Izw2e32QNdzqkEFXwyIt+BjWRatra0YHh7Ghg0bkJ5+bfHyUrN0Q0WjUYPj4i9w48X40CCyCgrxibvuj/dSeOUa65fhIbz0h/+FQqWGzmhCadVa5K0qT/qNyeVw4PBrL+L2j97FS3PGfMaGBjFtmQiucYHwX27Sc6mVt4aCUGg9eyooXzqOZdF9sQV3fv4ryAox/TufC0cOLnlOwnGLTjkJh/OH9yM9K3xLq4UQQABCSNJ/ryKBzwify+WiXbqpTjRTVPEcrWa321FXVweRSIQdO3ZAvkgtFp9r1Ou04BIgohlrWIbBUG83bv3gnSiv2Rzv5USd2dYvHMfh3JGDOLbrdeiM6UjPzEbl5m1h22/Ei/HhIZw7+DY++OjneGvOmM+J3a8jMy9YOxSyqJ1IOPR1dsDtdPJ2vMWZez11O50Y6u2BOWfpRga3y4WBrg489J0fQx3hDFqWYTB4pWvJBiSO4yCR8ZPS5TgOA12dMPBcGylI8ZQux3G+WkueZ+mmIlTwxYB4RfiGhobQ1NSEnJwclJWVLXnB4DOlq9fpEiKFHUscdhtslgnc+1/fhZKHdEGCZHSDRigUwjQrkmKbnMTrf34KUrkcuvR05K8uQ8ma6oS2fum51Ire9ku483Nfido5OI5Df1cHMnKDE3yEACIRf5+GM/t2Lyu6+EA2b17tuYNvL9vIYJ+egnVsBJ/9ya95mZvacPIoJMt0IhPCX4Sv5eypoFPWoeAXfKlSNzsf/75EbVkihwq+WQgEggVnmEaKX0xFwwJgITiOw6VLl9DX14eqqipkZi4/oFwoFIIQwsudpFajiaqtSKIxMToMg9GMj/MpFATJfTcvlcuRt+rqFIS28+dw9sDb0OjTkGYyo2LTVhgzlv9cxoqGE0chEovxvvsfiep5mk8fh1QWSocgf6PVfBGv7ojTpMEw/yrXc+ki5Euk0azjoxBAgMd+8P/xtobOpvplRSbHcZDyJPjaG84H14gTIqlew+cPHtBJG5FDBV8M8N+ZsCzLy53rUrhcLtTV1YFlWWzfvj3oD7Z/jXxcWDQaTVSEc6LBsSyGentw3bveG/Q8z2BZaTfzBpMZBpOvbszr9WLvC89BKBJBZ0xHTlExVq/fxNvGGwr+5oyyDRtRuWlb1M/XdOpE4H0IBkIIBDxFNs4d2ge1Vs/LsZZl1ud3uO8Kpizjiwq+0YFemLLz8f4H+BPb01YLBro7kVdStuTjfDV8kafuHbbpRb3+IkUIfq7LyQrLshAIBLy8fkIInbRBiS6zxVQ0GRsbQ319PTIyMlBRURFSCNz/ZeJjjVqtdsVH+FwOByyjQ/jEF/4rKnf1KxmxWIyc4quWIFfaL6Hu2BFodDro0k0o37AJGXkFUY+GuxwOHHrtRdz+kU/ClB3drlXAJwrGB/uRU7IqpOcJeYr2Xqo/D40hNjWVs70Dzx/at2hXcH9XJ6q3X4cb3vMBXs9/9M1XkZW3fCST4zjIQoq4LszZA3sX9fqLFKFAmNKCj+/XTrt0KQCil9L1f1gZhgn43vEJIQSdnZ3o6upCRUUFcnND7xLzr5GP2judTgd2BXfpTo6PQq5S4+Hv/DRlL8J8otEbAs0dHMfhyM5XwHg9yMwvhN5oQvnGzbxbv0yMDOPs/r34UBSbM+Zz7M3XYAq1fo4QiHiwZbGOj8I6OgKVJvLRiaHAsSwGui8jzTw3fU8IQU9bK+746F2o3LyV13MSQtDXcSko6xnCsrw0bfR1XIJiEeuXSBGIUlvw8TlHFwCcTieN8FGih0Ag4LUpYjYejwf19fVwOp3Ytm0bNJrwLjr+kDkfa9Ss0Bo+juMw0ncFG264Gdtue2e8l7MiEQqFyMwvDPw8OtiPlj+cgkKtgS7NiNK165BXunQD0nL0XGrFlfZLuPPz0WvOWIgr7RevET7LQQh46dI9vut1ZMx6X2NF0+kTEM1r1GEZBj2XWvHJL/03zMuNlguDzuaGoCc7shwbYk3ltQx0dcI2ORk9wYfUTuny/dodDgeN8FGiSzQ6dS0WC+rq6qDX61FbWxtxfSBfgm8lpnRdLifGB/vxsc9+GcbMGMyZXWlFfGGiUKnnWL+cP3wAZ/fvhcFkht6UgdXrNoQ0l7XhxFEIRSK8P8rNGfPpvtgCr8cTxjMJhBFGNwgh6OtsX35ubxToaLgwp+TB7XRioOcyPv3dn/HSzb4QF44cgClIY2k+mjbqjh2GMQp+jX6EgtT24eMzwuf1euH1eqngo0QXPgUfIQQ9PT1ob2/HqlWrUFDAT70TX2sUCoVJZyuyFNbxMYglEjzyvZ/H7KKbqhYMSyEUCueY6FpGhvHms3+CUqv1NX8UFqOgrHLB2agcx+L4rtexet1GVG6OfnPGfM4e3BuWHQohBCJhZJ+FtgtnIeR5PNtS+MWJfWoSI/29yJjxHHTabbCODuOzP/6fqDWveT1uDPdeQU5RSXBrjdB4mWUZDHZfRloUO86FKd6ly+eUDZvNBgC0S5cS3U2WLzHl9XrR1NSEyclJbNq0CQYei7D5nLaxEiJUhBBcudSK9dfdhJve96F4L4cyD6lcjqzCYt8PxJc+PHdoPwwmM7TGdJRWrUOaOSPQnHHbRz4RlRTicng9Hgxd6QlahMwnUrHWcOJITC1wCMdBJBbjzP49AdPjaasFMrkCj3z/F1E996m3d4fUPMGxHGTy8FO6jSeOQczjaLaFEELIq+hJNvieowtQwUeJMnwIvqmpKdTV1UGpVKK2tpb3BhA+o5DCJBd8HrcLg91d+PBjjyO7MLyNOhKS+92LDwbT1QkH9qkpvP1/fwMEAsgVKnzi8ScgXWTKTLQ5s+8t6I2msJ5LCInIzNftdGKkvxc5RaXLP5gnCCEQicXo62yHSquDdWwUmQWFeOedn4r6uS83N4Y03YUjHKQR2LI0njwKbZQ7n/0+fJIUnU3OZ0rX4XBAJpOlrHimgi9GRDq6rK+vD62trSgqKkJJSUlUopF8RvgESZx+mLZawDJePPajX0bdN3FxqOSLBJFIBKlMgfSsbBhM5riJPQDoaKqPaMRcJNGNE3vegDEjevVlC0EIgWV0BAKhCPbpKazfcRO23vZvUT/v2NAgpizjIb3XhGUhVYb32bBNWmEdGwuphjQcRMLU7tLlM7ppt9uhVCpTtmSGCr5ZRPNDIBaLwxJ8LMuipaUFo6Oj2LBhA9LT06OwOh98ztNNxq8TIQRjA/0orFyD2z/8iXgvhxImjNeL4b4e3Pahj6NswyYcevVfcVvL2OAApiwTYQs+EuFG393aBF2Y0cVwIYTDSF8vDOYM3HHnXShdsy4m5z3x1k5k5RWG9BxCCMTi8DIlx3a9jsw8/o2W5yMQpnaXLt8p3VS1ZAGo4IsZ4Ygpu92OCxcuQCKRoLa2FvIoRyn4tI4RRFhoHmsYrwfDvVfw7rvvR2H5mngvJzkVcwJgm7TC7XTgwW/8MBDVi+fMl+O7d0Y0yowAEIRpvDzY3QWHzRZzwccyLJx2Gz79mZ/GpqMdPuHWf7kDGSFOuiAIv/u1r6MNaRnRf31CpHaXLp8RPv9YNRrho0SVUOvjhoaG0NTUhNzcXKxevTomX3Y+U7p8TQeIBbZJK1wOOx789g9jZsK7HCvN1ibaEEIwOtCHwrJK3PGxu+K9HAC+jaq/qwOZM12qYUHCt2U59fauQIdsrPC4nLjc0oCaG2+JmdgDgJazpyCJcvPEbLpam+FlmJicy+12w+VyxeRciQiN8PEHFXyzSIQuXY7j0NbWhv7+fqxduxYZGRnLPocv+EzpJkuAb2xwAFkFhXj33Q/EeylzCM+zLTXxuFwYHejDe+99KODZlwg0nTwGmSLyzSWcyxLLMhjs6ZpjYh1tnDYb3C4HCsoqYzbCzU/TqaNIM8fuWnn+0L6YdXwL4Mv2tLe3Y3R0FGlpaUhLS4NarU6JSBXLspDxNGfbbrenbIcuQAVfzAgmXep0OlFXVwdCCGpra2N+J8JrSjfBI3wsw2Cotxu3fvBOlNdsjvdyroGNUfQg2ZmyTIAQgoe/+9M4NtgsTPOZEzCkR5ZOJWFG+OqOHoIyhmPUpiwTUGk0+LeP341nf/Z9ZBcUx+zcLqcDI/39yC2OTScy4/ViqLcH2YXRf40cy8Jhm4ZarUZmZiYEAgEmJibQ3d0NkUgUEH8Gg4E3UZRo8Fm/6E/ppiqJdYVcwYhEIrjd7kX/f3R0FA0NDcjIyEBFRUVc2sb57dJN3DtP+9Qk7FOTuPe/vhs1t/+ISYE790jgOA4j/b1Ys3k7bnjP++O9nGuwT09hbGiQFxESzs3TxfNnoDWkRXzuYLCMDCNvdTlu+9Cd2PPCs0gzZ0EcQwuRE2+9gfQoTrqYz9mDe2Py3jJeL9rqzqKidBUIIZDL5TCZTMjNzQXHcZicnMTExAR6e3vR0tICtVodEIA6nW7FWI/wactit9uhUEQ2Si+ZoYIvRiyW0iWEoKOjA93d3aisrEROTnAjgaJBKvjwjQ8PIs2ciU984b/ivZQlSdUC7WBwOR2YGBrERz7zxZhu9KFw/M3XYc4NfbLGfHwRvtA+C9NWCyyjw1BGabarH0IIRvp7sfnm27HxxltACMFAVyfEEilEkthtLd0Xm8P2OQyHjsa6qFuxuJwOjPRdQfmGzcjWKq6JcgmFQhgMBhgMBpSUlMDr9WJiYgITExNobW2F1+uFXq8PCMBkblSIRtNGqkIF3yxiXcPndrvR0NAAl8uFbdu2QaOJ7gV6Ofit4UsswcKxLIZ6u3Hdu/4D63bcGO/lBEFyXpyjjXVsFHKlCp/+3s8SWhT3tLcGpkxESqgRvmNvvoaMnOjahXAch8GeLrz7rvtRWF4JAGirPw+OEBBCYmYSPNjTBee0LWaCb3JiDNbR0f+fvfcOb6y80/5vVVc1W+5lPJ7emGG6B4YeeicQCL0PCYQEEgKEEFoglDSSre9vs/vubvJmNz0hMMMwFaa7jntXs7pkyVYv5/n94ZHGRZZVniPJtj7XlesKtnTOY43Oc+7zLfcXBSIJa+dwjtnhcjjwxGs/wn+88wOsLN80Z1pTIBCgrKwMZWVlIITA5XKFBeDQ0BD4fH5Y/BUVFVE37WcT2k0bWcGXhXWmC77R0VG0trZCJpPhwgsvzIj6Iy6XCx+lZgFuBqV0XY5x2M0m3Pf896YMcs9oMufjywgmBLsSO6++DlsuvSrdy4nKcHcHtRrMCTuO2KMbhBCoB/pYjXwG/H4Y1Erc9/zLkE6qUexpOgWZvBTjtlHwBakRFKf2f4Ky2tR1Ih//5G8oY7ERZmzUCh6Phyd+8DaO7/0b8sUSFBTkx1XHxuFwUFBQgIKCAtTU1MyZ/pVKpRn98JSN8NEj/SpjkRASfIQQKBQKDAwMYOXKlaitrc2YUDvNpo1MEXwWgw6FYgn2vPl+Rm9q08mU70Qm4HKMY3zUige+/UrKuz8ToenwAZRWJZ/OBQAQJq5rabDjLAhhz3nQ63Zh1GScYWHkcTlhUKlQWl0zMVotBYKPCQZT2ok8Iab7UVLJTtmN3WqGWFqE2598BgCg6u+FQJCDwsLCpHz4pqd/fT5fOPrX1dWFQCAAmUwWFoCZNomCdoSvpCS1vpSZRFbwpQgej4dAIICWlhaMjY1h27ZtkEql6V7WFGj78KXT8JZhGOiVw9hy+Zew80vXpXEliZE52216sRp0KCqrxL3fejHxg7AogKbj93lhUCtRuZTS/GWCuLp0Wz4/xJogcY2PIeD348nX351xA248/BkkoSlAhKQkY9F2/Cjykmy64sRxpfW3tyZ1rmjYzCZU1C3Ftfc8CAAwaTXnxrZJICospNqpKhQKUV5ejvLychBC4HQ6YbVaYbFYMDg4CIFAMKX7N93pX9qzdLMRviwA2I2qeDyecIfQrl270n4RRYJq0waXAzpHih+PywWLQYt7vvFCSs1faZJJT9jpIOD3w6hR4Yov3401m7enezkxc+qzvZCWlFI7HgMSc8e2z+OBQaNCFS2xOYkxqwWioiLc/vjTEX+v6utFXvhGSlLStNHddBqSIvZGTU6n7YsjrIhpi16H1Zu34eIbbgn/rPnIQZRUVsE5ZodMIgHDMKzsCRwOB4WFhSgsLERtbS2CwWA4/atUKtHZ2QmRSDSl+zfVmRLaKd3CTHVmSAFZwTcNDodDNSVCCIFGo0FPTw+4XC42b96csTdzmhE+Hic9gs9qNEAgzMHX3vrxvErhTied0dF0Y7da4LBZ8fir7yBnnlkoDHacpWvZQQAeL7Zt+tT+T1gxH7bodahffwGuuO2uiL/XKRUYt1vDgo8hSHg+baw4x+yw6HWoXrYiuQPFuBf7fV4YNSp6kVuc63LWqNBw7Y3YuOuS8M8ZhoFWMQSpvASEMEmndONhsrcfgCnp387OTgSDwSndv6lI/9JM6WZtWbKwRiAQQFdXF8xmM9asWYPe3t6MFXsA3QgfJ8ViixACnXIY67fvwqW33JHSc7NBPKmmhQIhBCPDA1iyai0e+u6r6V5O3Jh0Ixi3jVIVfAQkZkvGwY42SJI0ep5ybkJg0Kiw65obona2t3x+CPLySZEvwrDuw3fsk7+htCb5TuRYrzLakVvCMNApFbju/kdQv2bq7O7elsbwwghDkJ+fD5/Pl5YH2NnSv2azeUr6t7i4GDKZjHp3NiEkG+GjSFbwsYTD4UBraysEAgF27dqFYDBITUyxBe0IX6rweSdSWV/e8w1U1tFPZ6WFRab3vB43RoYGcPuTz2Dp6nVzvyEDObH3b6hYspTuQQnA5c69TRtH1PB66c1bDTVE3PrYU6hetnLW1wWDAegUgyiaZEFDCMBnOaWr7u9FUVk5q+eYzFBnO0RSOg1DTDAIrXIIX3nm2xHHs/W1NoZtZhjCpFXwTSZS+tdms8FqtWJ4eBgdHR0Qi8Xh6J9YLE56zaH7Ea2/3e12Z2fpZqGLTqdDR0cHamtrsWLFCnC5XHg8nvDTSrov3Nmg6sOXor9x1GwECPC1N94HPwPrIhMlkyPBtLEaDQj6/Xj2/V+yVOzPfoKcYRiMDA2y0DEam/Fy85GDkFfQqS/z+7wwaNR48IXvzxmt7Dh5DPyc3Ck/I4Swasui7O2G3z/71KK4iOE6M+t1GBu1UhF8Ab8PerUSD7/4OgolM738PC4n9Oe6nYGJSGBBQQFsNlvG3Td4PB6Ki4tRXDxhdeX1esPp3/b2djAMM6X7Ny8vL+59LST4aET4Qv6E8z3Cp1AosHTpzAfLSy+9FIcPH4763qzgm0YyNXwMw6CnpwdarRYbN25Eaen5FEDoC5vJgo+mLQuPy2X1PksIgU4xhBWbNuPqu+5j70RpY+ELPsIwUA/2Yd32i3DVl+9O93KSov3E58hlofuPEDKn8TITDEI7PAgZhfo9j9uFMasFT73+bkwPUP3tbRBPF0KEgMdiSrfx0H6UVFKyvYlBgJzc9xEqapL3+vN5PLAYdHjy9R9NsbSZTNPkbmdMXCOhmrNMfwjMyclBRUUFKioqQAiBw+GA1WqFyWRCf38/cnJypnT/xpL+DQUgssbL56mpqYFOpwv/t16vx1VXXYVLLrkkyrsmyAo+SrjdbrS2toIQgl27ds0IG4cEXzAYzAiT5UjQTOkKBAIwngAr4jbg90E7PIibHnlqRv3LgiGz9/ak8bpd0A4P4t5vfw9ltDzrZiEVriydZ06yNO1h7ghfV+PJuKxbZsMxZgcAPP7q2zFdt+O2UZh1IyirnlpLRwjD2qSNgN8PvVqJyrp6Kseb6zKbqCsdTNpX0eN0wukYw5433ov62aoG+pCbd/7ewQSDKCwsBJfLzXjBNxkOhwORSASRSIQlS5bMSP9O7v4tLi6GSCSK+LmEGjZo/e0LQfDxeDyUl0+UM3g8Htx6661oaGjAa6+9Nud7M1N5zDNMJhPOnj2L8vJyrF69OmL4OfSlzeQ6PppNG4UFBdC7rNQFn91qhs/jwVNvfgBhbuSn5IXA/Nna48dmNkGQI8Q3f/yPGRvtjgfnmB1Wgx5V9cupH5sQzDlpo/9sKyTFydmT2C1mFJWW4eZH9sT8njMH9qG4dGYdHSGEtS7dpsP7qTbFzHWd9TSdBi/JB3TnuB0ccPDYK29FfZ1Bo8KY1YLcqqnBAqFQOO+vk9nSvxaLBSMjI2AYZsrot1BUk2bDRiilO98F32QeeeQRjI+PY//+/TF9R7KCbxrxPEkQQtDf3w+lUol169ahsjL6OCOagooNaEb4CkWFYPQmgE/vSV+rGMKSlatx44OPUztmppLqLudUwASDMGiU2HbFNdh2xdXpXg41Pv/oTzOiXNQg0SN8zjE7jBp1uOYrEcx6LVZt2opLbrotjmURaIYGIta1ERZTuv1nW1EokdI74Bz7ffupY0nNRA7V/t3+RGT/wsm0HJ1Zh8kBWPPgSyfT07/j4+OwWq0wGAzo6+tDbm4uioqKkJOTQzW6RwhZMILvrbfewr59+3D69GmIRKKY3pMVfAni9XrR1tYGr9eLhoaGmApB54Pgo9VYIhGJwFD6W4OBANQDfbju3oewevM2KsfMdBaaLYvbMQ671YJ7n3t5/swzjhFlXw+9UWrTmKuG78zBTxP23iOEQK9W4JKbbsf67bvieq+ipws+T+SuYMIQVlK6NosJNrMJBeKZzQ4JE0VMeN1uGEfUqFqaWOTWZjaiculyXHP3/XO+dsJ7bxiyadYvnHMP4fM9whcNDocDsVgMsViMuro6BAKBcPp3ZGQEPp8PTU1NU7p/ExGBLpcLABaE4PvDH/6AN954A5988gmWLYvdmSIr+BLAarWira0NRUVF2Lx5c8w1eZku+Gg2lojFIirRQofdhrFRK558/R3kF4qTPt68YQHpPatRD5m8DF9NZjxahjLU2c7q7FoCErU+TzPYn5AACgYD0CkVuPOpZxPqLO44eWzWKTYEBFwW6pSPf/xXlFHugo52mZ389GMUl0XP2syGWa/Fuq07sOu6m2N6fVfjqYj/zqEI30IWfNPh8/mQy+WQy+WQyWQYHBxERUUFrFYr1Go1AMzo/o0Fl8sFDocz742XOzo68MADD+C73/0u1q1bB71eD2Ai9R8yzJ6NrOCLA0IIhoeHMTg4iFWrVqGmpiauJw2atidsENpUaAg1qUSSdIRPr1agtLIG93/7e0mvZ76xEFI4Ab8fBo0KV9x2F9Zu25nu5bBC09ED7KVzAQgEQnBnifApe7vgcbniFnw+nw+mERUefuk1FCYgFv0+L3QqRdQxY7QFSiiFXBLBty4Zol1nip4OiOMc3RaannHRdTdhQ8PumN/Xf7Y5YuSbw+UsOsE3mWAwCIFAgMrKSlRWVkZM/+bl5YXFn1QqnTUAE6rfm+97a2NjI1wuF9566y289db5utCsLUsCzPZl8Pv9aG9vx9jYGLZv3w5JBA+lucj0CF9oU6GxRqlEgiCT2HGYYBCq/h5cdutduHD3ZUmvZT7C5fLOpfPm5+bkHLfD7XDgsVfeQu4CNTr1+7wwqumO25oOIQCXH/lm3x4lyjYbHqcDjjE79rzxfsJuAc1HDqFAnNpoe19bMzt1rbNcXwa1Cg77WFyCjzAMdCoFrr/vESyNwz3A7XDAqFGhtGrmgwMHnJSNVctEpovdaOnfgYEBuN1uSCSSsAAUiUThPdTpdKZkFBzbPPTQQ3jooYcSeu/i/BbFid1ux/Hjx8OWK4mIPSDzBR+Hw6HWuCESiSaGasaJyzEOzWA/Hvnem4tW7AEAT8AHodRAk0oIITBpNSguq8Djr76dEWKPrc/x1P5PqI7bmp2Z27Tf54VOORzXURxjNhBM2K4kYw2l6O1EfmFsReK0OHvsKOTliaVXoxP55n9q/8coX1IX81GYYBAjw4O46+vPxSX2AKDx8H5IiyN/jzhcDtVZsvONYDAYtUs3lP5duXIldu7ciZ07d6KsrAzj4+NobW3F559/jmeeeQYffvgh+vv7k56y8Q//8A+oq6tDbm4uduzYgdOnT0d9/e9+9zusXr0aubm52LBhAz7++OOkzp8si/NbFCOEEKhUKpw+fRo1NTXYvHkzhElMc8h0wQfQ69QtLCwEQ+I7jmlEDYDgmXd/vuAK++OFzxewWhvGBj6vF9rhQVz9lftx3b0Pp3s5Yfw+HyvHHexsZ134TFiczBRnrV8cRr4o9iibzWyaqKP85neTWo9Fr8Oo0Rj1NbQbjnyeidGJbMCNEO2ZaKAYillkBfw+6JTDePjl16OmuWdDPdA3q8VUKMI336NSiRKvLUteXh6qqqqwYcMGXHzxxbjgggsgEonw29/+Fk899RS0Wi2++c1v4u9//zscDkdca/mf//kfPPfcc/jBD36A5uZmbNy4Eddccw2Ms1wPx48fxz333INHH30ULS0tuPXWW3Hrrbeio6MjrvPSJCv4phG6sAKBANrb2zE4OIgtW7agvr4+6YuO5iQLtqAlSiUSCUgwtr+VYRgoejqxoeES3Putlxbt0+xkeAJhxn9XJjNus8LtGMOe199F3eq16V7OFGh1i0/GNKKGwz5K/bgRiXA5DHd3xSw2TVoNVl24FTc++FjSS2k8vH9uUUNZm5z67BP25uZyZy6249QxCGMs7Pd5PDDrtHji9XcSqofUKRUYj/I94p6r4aPlRTffSCa6yeVyIZVK8fbbb+P48eP42c9+hpqaGvj9fjz77LMoKirC5ZdfjnfeeQde79yj+n7yk5/g8ccfx8MPP4y1a9fin//5n5Gfn49f/epXEV//85//HNdeey2+853vYM2aNXjzzTexefNm/PKXv0zo76FB9s4aAYfDgZMnT8Lj8WDXrl1zdr7EynyJ8NESfEwMNXwelwuKnk7c/+1X0HDN9Umfd6HAFwhA4oyQpgPCMDColViyci0eevG1jJxnHG+kORaO7/0I5bUz51lShxBwuVMjfBa9Dlajfu63notUXXrT7dh17Y1JL4VhGGiHB+ec6kE7FjXc1Y68Arbmn85cbdeZk5DJ507Vu51OOMZsePL1d2cdlTYXrV8cgrx8dgHN4XAWpA9frNAUu1wuF9XV1fjHf/xHDAwMoLu7G1/5ylfQ19c3Z+YuZA1z1VVXTTneVVddhRMnTkR8z4kTJ6a8HgCuueaaWV+fCrJNG9OwWq04efIklixZguXLl1ONNs0HwUcrCikWi0Hm+FstBh24XC6+tUAmLtBEIBTC53anexlR8brdsOi1uPNr30Qpi52qyUL7u8UEg9Aqh1FOYb7qXBDMLNifiLJF71YNBgLQqRT4ytPPUfMI7Gk+E9PsWZqKz6TVYNxug0jGTonH9ACf2+GASadF9RxTU5xjdnC4XDz6vTcTPjcTDEKnHIasZHYfRS6yXbq0BJ/b7Z5Sw7ds2TIsW7YMe/bMPV3GbDYjGAyirGzqv1VZWRl6enoivkev10d8fchGJR1kBd80xGIxLrzwQsjlyY0qisR8EHy0avhMJhNmq0AjhEDd34MNuy7BFbfdlfS5FiICgTCjI3x2ixnCnFw89dYHi+5mdPbEF8jNS5156+TPdyLKNgSpfPa5vT6vF2atBo9+703kx2AIHyt9rY0xzgump/hO7GM5kjpNwB7f9zeUziGmx0atEMlkuP3xuadnRKPzzIk5m2eytizBpOrmJ7PQxqolQlbwTUMgELAi9oAJwedjqYCcFsmmdCePm4tUEO3zeqHu78E933whYQf7xQBfmJORNXwT49FU2HrZVdh+1bXpXk5a6Go8CSlLe8Rc9DSfjhplczkd8DjG8eQb7yXViTsdt8MBwyzWIWwRErdlLEZSp6dKlb1dkJXMXi9oMxtRtWwFrr7rvqTPPXC2bc7IJZezuAUfzZSu0+lMWPDJ5XLweDwYDIYpPzcYDCgvj/x9KS8vj+v1qWBxfovSxHyI8CWT0vX5fGhsbITBYEBDQ8OMTcpmNmLUZMA33/9lVuzNgVCYeV26bqcDxhE17n3upUUr9hx2G6yG1KVkpku73tZmSIsji81x2yh4PB4efeUtqmIPAM4c+nRW65CZ0InwdZ4+DkEue1MRJvztzosJ7fAg/H7/rK8367VYvXkbFbHnHB+DcUQ95+s4HO6i9uGjaUnjcrkStmURCoXYsmULDhw4EP4ZwzA4cOAAGhoaIr6noaFhyusBYP/+/bO+PhVkI3wpZD4IvkRTumNjY2hpaYFIJEJDQwP4fH7YKJUQgpGhASxfvxHX3Zc5dh2ZjECYk1E+fFajHlJ5CZ568/10LyV+KOrmYx//hdXJGtFwOxwwqpUR6yVtJgPK6+px3VcfYuXcmoE+5MVqQUMpo9t5+gSKWPQ5JAwDnuD8LbD12NGIDRSEEBg0Klx8/c3YsPNiKuduPLQf0tK5/zbuIk/p0o7wJZO9e+655/Dggw9i69at2L59O372s5/B6XTi4Ycn7mkPPPAAqqqq8M477wAAnn32WVx66aX48Y9/jBtuuAG//e1v0djYiH/913+l8vckQlbwTYPNbqhMH60GJCZKtVotOjs7UV9fP8W+xufxIOD3Q9HThdv3fAPL1q5nY8kLEmFeXkZE+AIBP4xqFS697U6s35a+J9NMgBAC1UAfSwbAs3F+Pzp96FNIp3WPhoyuN118GXawFHUdGRrA+Jg9ZsFHYwedaJ4YQXX9CgpHiwzDMMjJmYggTswWHkZR6dQi+4npGcO44f7HqNoNaQYHYqqvDKV0s7YsyZNsDd9XvvIVmEwmvPrqq9Dr9di0aRP27t0bbsxQqVRT1rpr1y785je/wSuvvIKXX34ZK1aswJ///GesX5+++2BW8KWQhRbhYxgGvb290Gq12LRpE0pKphZ0m3Qj8Af8ePa9D2c1Fs0SGYEw/T58zrExuJxjeHSej0ejJZuHOs+mVYSPTIuyMQwDvWoY19zzIJav38jaeVu/OBKfyKWg+I7v+willXS6i2eDEAa5BRPf645TJ8AXCKb8PiQC7/nGC5BX0BP5I0MDcI7ZYhJ8nGwNHzWxm0xKN8TTTz+Np5+O3KwTaY7tnXfeiTvvvDOpc9JkcX6L5oCtKN98EXyxrNHr9eLMmTOwWq1oaGiYIfYAgC8Uoqp+BU4f2AebxcTGchcsfIEgbSldQgjM2hHISkvxxKvvzGuxR5Pmo4dQUhH/JIWkOLcVqQf74RwfD/84EPBDqxjE3c98h1WxN2HvMhyn4Eh+/1T2dbP+kMgwDATCHADAYHsrxLLzfqt+nw96pQIPv/Q6VbEHAG3Hj6I4RgHNO/cAvlgFH80In9vtznbppnsBi4n5IPhiadoYHR1Fa2srioqKsH79+lmfwKqX1IHD4WBEMYj2U19AIitGcXklVlxwIerWrFu0m1gs8NNky+L3eWEcUeP6+x9DfZwzQTOX5KNyPq8HBo0ybc1GZ48dDU+b8HncsBj0ePz77M8qbjt+NG5T4WTl3sjQALwuV5JHmRvCMBDk5MI5ZodxRB3uBvZ53LAaDXji9XcSNlSejWAwAJ1iOObJIRwuFr3goxnhywq+LCljPoxWixbhI4RArVajt7cXK1aswJIlS6JGQzmciU1KKMxBeU0dAMAxZsfBP/4WHA4XJVXVqFiyFOu370IeRb+whQBfIIh5NB0txm2jCAb82PPauxk5MSOdnNr/SVS7DrbgAAj4/dAph1FcXgGXYxxetxt73ngvJSJgqLMdIpksznclJ/lOfbY3JUbeDMNAKMzBmYOfhgWY2+mEx+XAk6+/y8rn23HyGPg5OTG/nstZ3BE+2indrODLMgMOh8NKrc58ifBF8goMBoPo6uqCyWTCli1bYho3x40wp5LL5YbTGcFAAP1nW9B4+DMUl5ahuLwSa7ftRHlt3aIdJRRCmJMDJkX1YoRhYNRqsHLTlqwR9iwMdbZDXMTOtIfocNB67Ahy8vIxNmpFfqEI937rxZScecxqgVmnRVlN6rqSg8EA9CoFKpawP7aOYRgIc3Mx2NGGfJEYjrEx8LhcPPLyG6ydc6DzLMTS2AU0N5vSpfK3E0Kygg9ZwZdSQoKPEJKxgiZS04bb7UZLSws4HA527dqF3BhrayIZL08nr6AwPCfTZjHjr//+r8jJzUVJZTVqlq/Emq3bw3U2iwm+MCclKV2vxw2zTosv7/kGymvrWD9fekhOOBvUKjjG7GkSfMBwVwd8Xg9qV6zCl+66N2XnPX1wH4oTqV9LYmtr+fwQCsSSxA8QB4RhYDUa4HKMIxgIQFRUjNse+xpr53PYbTCNaOKy9eECi9aHj2EYEEIywnh5oZAVfCmEx+OBEJLxgm9yFNJisaC1tRXl5eVYs2ZNXBtPLIJv+rlLqybGGvm8HrR8cQjHP/0I8vIqlFRWYcPOi1BUmj6X8lQiEAjBsJzStVvMEAiF+NoiHI8WDyc//XvaxHAwGED/2WZcc8+D2HLplSk7b8g7U8zSDNvZ6G1pmtI8wSaEkHBzSHndUiqGytFoPLQfxXHuX1ze4o3whQIPmWC8vFDICr4UEnpSodl5RJtQnSEhBAqFAgMDA1izZg2qq6PPl4xEsqJWLCsO33CMahX+p/EkRBIZiisqsWztBizfsAncBepPxRcKwLAU4QuNR9t86ZXY+aXrWDlHJpFMZpwJBqFVDKVF8DEMA6tRj7uffQHL1m5I6bmHutoR8M0+dSIanARDfA67DVajAfmxGjwnCSEMrHotrrjjHjRccwPr59MMDaBAJI759YQQ8M/tx5kaIGCTkOCjWcNXuMhrxbOCLwJs2rIAE4JPMM3zKVPgcrkIBAJoa2uDzWbDtm3bIJVKEzoWj6Ko5QuF4cYPj9OJz//+Zxz52x9RUlmF8uol2NBwccpSQalAwFJK1+10wGY24avf+i6kxTOtdLJMpe340bQ0FAX8fuhVCuTk5qVc7AETY81i7SSlxRcf/wXlKZpiQgiBWafFxosvS4nYUw/0we0Yj0vwMcEg8kUFizbCFwwGweFwqNyPA4EAfD5fNqWb7gUsJjgcTsZP2wgEAhgbGwOXy0VDQwNy4ugomw6Xx6U51WoKodQuYQiGe7vQ8sVhyErKUFxWjlWbt6Fm+cp5/VQsFOaAMHQ/PavRAHFREb721gdUj7uQ6W48BUlR4uOYEsHtdMCs1eDy2+7C3t/8Z0rPDUxMyNErFSipStD4OMHrTp2iKSaEYaBVDiMnNxebLrqE9fMBwNnjn6OorCKu9zBMEAUFi1vwcblcKvu40+kEgGyEL90LWGxkcqeu0WhEX18feDwetm7dmvQmwwHVMaazkpuXH065jdlG8fF//wqEYVBSWY3alauxcdclyMljbwg7G3D5fGrGy8FAAHq1EpfefAc27LyIyjEXAw67DWaDHjUpSjECwNioFV63C0//6Of433/4CYR5qZ9Q03z0IArj6CSdTiK356GuDjAp2BdDPng3PvQ4/vcffgphDvufbzAQCNvqxAMTDKJwEQs+2pYsQFbwZQVfBBbbPF1CCAYGBqBQKLBkyRLo9XoqGwyPy0WqXQe5XO6ULrjeliac+uwTSOWlKK2swoWXXBluDMlkJj7/5OXy2KgVdosJj33/7ZhGOWU5zxd//wsqzpnxpgKLXodCiRQPvvB9eFxOmLUjaalRVfR2hTvnEyKB7bP5yAGUJhpRjBG/zwejRoVHX3kDJ/Z9DGlRMYS57D8Inj3xeUJTQxiGgaiwYNF26dKeoysUCsHnL27Js7j/+jSQaRE+v9+Ps2fPwul0YufOnQgEAtBqtVSOzeWkf5MqlEhQKJmo7Ruz2fC7f/wJhDm5kFdUYfmGjVi7dSd4C3ATIIRApxxGZV09Hnzh++lezryDEAJVfw9KKlPzcKBTDWP5+o24+iv3AwCO7/0I8soqmLSalJw/hEmrgd1sStL4OD7F5/f5YFArUbl0WRLnjI7X48aoyYA9r78LnkAA7fAAOFxuSmZ8D3W2Q5RAxJQJBiEWibIRPgo4nU7k5eXN6zIfGiy8O12Gk0nTNsbHx9HS0oKCggI0NDRAIBDAbrdTE6Q8XmZtUnw+H5V1528qZw7ux5G//gFFZRUor12CrZdelTavtcgktjn5fV6oB/pwyyNPYfkG9uasLmQGO86mJLpGCIF6oBcX33DrFNsVRU8XZCWlrJ9/Ok2HD0CeIpEb4syBfZDI2auTdDsd8LicePK1iekZw92d8Hg8IAxhPaU7bhuFWTeSkIBmGAYSsXjRCj6aEb6sB98EWcGXYng8HgKBQLqXAZ1Oh46ODtTV1WH58uXhJx+agjReH75UIyspDd9UTRoN/u97b6JALIG8vAJrtzegfu2G9G60CXx8NrMJHpcTz777YXY8WogEMuNdjSdRHGeRfbwwwSAUvV2462vfRM2K1eGfawYH4HWzP0t2xnoYBlrFUNJCM94oykBHW0IRsFhw2O3g8flTpmd0nj4OeVkFjBoV+Cy7JTQe+jRh71DCkLBv3GIVfDRr+Ba7Bx+QFXwRYTPsm+4IH8Mw6Ovrg0ajwcaNG1FaOnVzjzRpI1G4XG5qujYoIMzNRfWyFQAm0twH//g/+PS3/wV5RSWq61fgwksuT66uKRHiMJAjhMA4osbS1WtxzT0Psriohc9El+pw4l2qsZzD64VmsA+Pv/r2DKPh0wc+Scks2el0NZ4Cl5vamkGrQY8xq4UVwTc2aoGkuAS3PvpU+Gd+nxc65TDkFVVIduZvLGiGBlGYoF0UQ4IoLCyE2+1elKlImildt9uN/Pz8Rfk5TiYr+FJMOmv4fD4fWltb4fP50NDQEDHEzeVyQQihkkYQCgRgPIF593TK5XJRUlEV/u/hnk40HTmA0upaFJeXY922XSivXZIxm4fX7YZZN4I79jyDiiX16V5OBhLfU0fTkQNJdanOhcsxDoteGzEKGwwEoFcpUzJLdjr9rc2QFFMoaYjjsji+9yNUsGBqPWoyonbFKlx151en/Lz1iyPIKzznhcfy5avs64bX5UxY8BGGQV5eHtxu97zbQ2mQTenSJyv4Uky6BJ/dbkdLSwukUik2b948a7dS6ImKhuArLCiA3mWd95tVfqEo7P5vt1jwl3/7J+QW5KOkoho1K1ZhzZbtELCQPo3FlsVuNYPPF+BrP/zxvP+cMwVlsl2qUbBbLQgG/Hj6nZ9F/PdqOnIAhWIpK+eOhnN8DCOKQVSx2DgxHUIIRoYHqHfnmnUj2LDzYuy8+voZv1P0dKJAlBqbnfaTX6A4CV9BhmFQUFAAq3X+76GJQLtpI5vSzQq+iLCd0k214NNoNOju7sby5ctRV1cX9e8LbSw00roFBflg9CaAn5lTRRKBy+WirGYi3ebzetD8+UGc2PsR5BWVkBTLsfnSK1FUWkblXHlR/N8YhoFRo8KFuy+PeGPLkhhGjRo2iwVl1fRvDmadFrKSUnz5qWdnfU1/WzNEMvaii7Nx/JO/TYlqp4KeptNUO+QJITBolNh90+1Yv61hxu+tRgMsBn3YtinREXCxEPD7oVMqkjKSJgwTTkNmSjYhldC2ZclG+LKCL+WkUvAxDIPu7m7o9Xps3rwZxTGka0IXGI01isQiMMHM6EhmC4msGDg373fUaMCvf/oj5BcUQF5RhVWbt2LlBZupd3u6XU7YTAbc8+x309LJuZBpOvIZSirpCx+tYghrtmzDFbffPetr7FYzrCYD8uMYv0ULVX8vtQeVWIXU2ZNfUGuMYRgGOsUQbn7kSdROaoCZTPORz1AyWYCxKKLajh9Fbl5yAoMEJ2r4FmN0D6BvvJyN8GUFX8oJzaplG4/Hg5aWFhBCsGvXLuTFOGkiNP6NRoRPKhaDYTLHc5Bt+EIhquuXA5jYrL746M848Pvfori8ApV1y7Dl0iuSnvdrNRkgksjwtbd+TGPJWSbBBIPQKoapCR/gvJ/f5bfdhY27oo/xOvbx31Bem/raPWVfD/w+L70DxqCjvG43TCMaVJ27XpIhNMni3m+9OOv8X0IIRoYGp9gusRk0G+7qCPt/JgOXy120go/mzPlshG+CrOBLMXw+H14vxc01AlarFa2trSgpKcHatWvjfkqiFYWUSqUpGZeUqUyu3xkZGkDrscMQSYtQUlGJDQ27UbtiVfRUzaRfBQMBGDQqXHzDLXMKhyxTibVlo+P0CfAF9LZEJhiEoqcL93zzBVTWRW+mIYRAM9iXMqPnyTQe/JTyeedWUic+/XtS9W0h/D4vjBo1Hn3lDeQXzh4ZHWhvRSBFe9GY1QKzbgRlSU5p4XA5YBhmUaZzgQnBl0vJGDvbtDFBVvBFYL6OViOEQKlUor+/H6tWrUJNTU1CfwvNCF8mTRVJJ7n5+ahZthIA4PV48Ml//woEgLy8AktWrcWmiy6d4fofSo05x8fgHLPj4Zd+EPWmliU5+tqaIZbRMd72ejzQDg/gyTfejalLs7e1MS2RnIDfD71aOacgjYeg3zfnawY7ziYdSfW6PbCZJ6ZnzOU52d10GkUzyh/Y2efPHNqPYgr1kBwOd9GaLgP0bVmKiormfuECJyv4ZoHD4YDE4YMWK2zV8AWDQXR2dsJisWDr1q2QJVH4TUuUFhYWxuUlt1iYaPw4//Tf29KI5qMHUVxeAXl5JdbvvChcQG/WaVFeW4f7nnspXcud98RyHY/bRmHWjoQbcpLBOT4Gm9mIb7z3i5hnd7YdO0ol4hUvjYf3z/ABTBb/HILPoFYikGQK2eV0wOdy4YnXfjSnIPK63dArFSiZNkObjQf7idTxABVfQQ6HjlvCfCXbtEGfrOBLMWwIPpfLhZaWFvB4PDQ0NCQdBqdlDi0Wi8GQhd20QYNCiRSFEikAwKzX4ff/9DPk5hVAM9iPXdfdjCu/PHuhf5YYiOG7fPrAPhTPUv8VDzaLCQAHT7/905jfQ7OeLV76z7aEv3u04HCiR2Wajx5Manybw24HXyDAwy+/HtPrm48ejNz5zEKAT9HTBZ/XQ+VY3GyEj2rTRlbwZQVfyqEt+EwmE86ePYuKigqsXr2ayuZAK6UrEolAFniXLm34fD4KRBL4fT5ULVsBzWA//u2tV1FSWYXS6hpc0LCbtTFUC5W8OdLgE1GZfoikyUW6TCNqyKtqcPvjX4/rfbTq2eLFZjbBZjZT9/2LFjhjgkEMd3WgIsEU8pjVAllJKW5+ZE/M71H2dSM3f+bNno2Ebsfp41RH8i1mwZc1XqZPVvClGFrRM0IIhoaGMDQ0hLVr16Kqip6VBC1RKpFIFlWXbrIQQmAaUWP5ho248stfxb+99f0ptiuagX6cPXEUkqJSFJeXY9WmrViyas2iLeqOnegp3aGudvi9c9edRWNkeBAXNFyMS266Pe73Kro7ISmWJ3X+RDj28V9RzsKUi2jfx7MnvphTgM/GqNGAJatW48ovf3XuF5/DpBuB3WKexdyZ7nXj9/mgVyogr6Aj3jkczqIWfFlbFvpkBd8sZHINXyAQQHt7O8bGxrBjxw6IxXQL+WlF+MRicTbCFyNetwdmnQa3P/k0KuvOTTuYdj8S5uaivGbCtsNht2Pfb/8TwUAA8ooq1CxfiQt3XxYxkpElOh2njs9q5zEXhBAoujtw7VcfxtptO+J+v045DNf4eMoFX6jWbHpdG9t0N56CVB7/32rSanDBrkuw80vXxfW+5iMHzs3NjQDl56TWY0eQV0hvQkvoHrRYBV+2ho8+WcGXYpIVfA6HAy0tLcjNzUVDQwOELIz0otW0wefzUzGffN5jt1rA4/NnjkebYyLK5KjFUFc7Gg99CkmxHCWV1dh08WVpmcc63/B5PDColAkJn2AgAGVfN+5//mWUVifW7HFq/ycoq41m38HOBdTb0ggOZUPwMLM8JzvHx2DW61C9LPZaRUII1AN9uPLLd2P99l1xLYNhGGiHhyCVl8T1vkRRdHeigKppNkEgMP9mkdMiGAxSifARQuByuSaaCBc5WcGXYpIRfAaDAWfPnkVtbS1WrlzJWiqPVtoZYNfiZr7DMAwMGiUuvOgyNFx744zfxzP6afK8X9fYGP74r78EXyhESUUllq5Zjw07LwafkonpQqLx8P6ERpl53W5oFUN46s0PkJ/gjYQJBqFVDqMialqVnS73tuOfQ15Or9ZsMoLcnIg/P/bxX1BaHfvcXIZhoOzpwh1PPYslKyNPz4hGb0tjVL1Mc28aNRlhMejCY9toQBiCwcFB8Pl8qNVqFBcXIy8vb9HsqbRtWbIRvqzgmxU2xVQwGAQhJOZzEELQ398PpVKJDRs2oLw8+W7CaNBK6QIAd5FsTvHidjlhMxpw97PfQVFp5H/PRD85Lp8/xVet7dhRnD6wDyWVVZBXVOGCht0pi3pkOsq+nrjT4I4xO8ZHrfjGex/GbLsSiZYvDqNgjno2Nua9et1umLRqVC1lpyuYy4v8maj6elEco8gMBgJQ9nbhke+9AVlJYn59vS2NkBbP/j2n+dk2Hf6MeuONUChAVVUVbDYbzGYzBgYGkJOTg+LiYhQXF0MqlSb1/ctkCCHZpg0WWJjflgwm9MQS69OLz+dDW1sbPB4PGhoaUhKWpmoOnRV8Mxg1GVAokWLPm++nJF0zuT7MoFLi/50+DpGsGPLySiy/YBPq125YlGkjg0aFMasFuVWxF3NbTQYI+AJ87a0Pkj5/T/MZiNNgBnvy049RXMZeV3CkK1492B/z+Daf1wPNYD+eeuuDcNQ6XtxOBwwa1SzNGlEWmgCEEGiHByGi7GfIAQd8Ph8ikQhr1qxBMBjE6OgorFYr+vv74fF4IJVKUVxcjKKiIhQUFCyY6F+ofp5mSjcr+LKCL+WEvsCx1CeMjY2hpaUFIpEIDQ0NKXuao5nSzUb4zjMxHk2Ji6+/BRsvunTuN7Dw0fGFwvC8VpdjHIf+/Hsc/vPvUFJZjfKaOmxouCjhm2ymQmZJizYdjlLQHwGjRoWKpctw80NPJL2mcdsoRk2GtHzWw90d7DaJRPjenj12JKY6R7fTAZNWg2ff/XDO6RnROLH3o7n/Rkp702DnWfh9firHmgyXO7VLl8fjQS6XQ36u6cXlcsFqtcJisWBoaAgCgQBFRUVhATifo3+hgAONB1GPxwOGYbI1fMgKvpQT+gLPFUHTarXo7OxEfX096uvrU/rkRjPCt1CeOJPF5RiHwzaKh196LY7xaOx+dhwOB/Jz3alMMIihrrNoPnoARWXlKC6rwJot21G5dNmC/DcMBgPQK4cgmyWdPhlCCEaGB7D50itw0bU3Uzn/sY//irKquQUQ7Qo+vVoJl4PtruCp35dgIACdUjFnOtdht8E5PoZnfvTzpG/0yr6elJUtdDWeQlFZcmPiIjGXLUt+fj7y8/NRXV2NYDAIu90eFn+dnZ0Qi8Xh9G9hYeG8uo5DAQcaET6XywUAWVsWZAXfrLB1cXA4nKiCimEY9Pb2QqvVYtOmTSgpSX2tFY/Hg8+XnC9ZCA53/mwybEAIgUWvRXnNEtz7rRfjem+qN+jc/AKU106kPexWC/7+X/8GQU4OSiurUb1sBdZs3QFhDp1h5umm4+Qx8ISRmwsmwzAMlL1duPGBx7Fy02Yq5w51nsbi10b7G3Dq079PGetHm4lU3FSZ2nb86Iw50dOxWUzgcnnY8/q7Sa9BqxiC2+WEFNH3zgCFPc7n9cCgUsQVKY4VLnfCliUW0cPj8VBUVISioiKsWLECbrcbVqsVVqsVSqVyyu+Li4shyPAGrlD9Ho090Ol0AsgKPiAr+NLCbJ26Xq8Xra2tCAQCaGhoSNsXlGaEbzGndP0+H4waFa6950Esv2BT3O9P5xRiLpeLknPjr3xeL9qOf44jf/kDisrKUVpdg82XXEnNYDYd9Le3QjzHxJJAwA9VbzceevG1mJsNYmGw4yzS8a/LBIPQKoZZMVsOQwi43KkCZaizPep0GLNeC1lJKb6851kqSzj92d6YumUD/uTTsC1HDyOfqhXLeULNc4lEO/Py8lBVVYWqqiowDAO73Q6r1QqVSoWuri6IxeKw+BOLxRkX/aPtwZefn78o65SnkxV8aSBSjdzo6ChaW1tRVFSE9evXU2tHTwS6XbqL8yJz2G3wetx44vV3IBQmFhXLpC1YJJWFb9p2qxX/78P3kJtfgJKKKqzceCFWbd4G3izdmZnG2KgVZp02qijwuFzQqxX4+ts/RS7lB6/WLw6xEhGai7bjR6kaA0diIiJ1/nswZrVMfNY1kT9rvVqJ+rXrcc3dD1A5PxMMQqeMTdTSEADKvi7W6jBDs3STFWNcLhcymQwymQzLli2D1+sN1/5pNBoACIu/4uJiVrxd44WNKRuZJmrTwfzYodMAm18OHo+HQCAA4Fx6R61Gb28vVqxYgSVLlqT9i0nXh4/KYeYNE+PRNKhftwFfuuve5A6WoZ8dn89Hdf0KABN/74lPP8HBP/0OxWUVqKyrx5bLrkShRJreRU5mWjDtzMFPo1pojNtG4Rofw7Pv/YJ6VMDn9cCgVqFy6bLY3kDxAupuOg1JEbsTPQgh4E1qFjhz6FMUzxIJHhkawOZLr8SuCB6UidJ2/GjsvohJfrZWox5Wo4Gq995kOBx2Zunm5OSgoqICFRUVYBgG4+PjYfHX3d2NwsLCsPgTi8VpiYzRtmTJpnMnyAq+NBASVMFgEF1dXTCZTNiyZQuK0mDREAm6Kd3FE+HzejwwazW47YmvU/I4y1DFN42i0jIAE0XrOtUw/v2dH6BAIkNJRSXW77wIdavWpv0hJsTESLF+iKSRrzWLXod8kQh73niPlfOf2v8JZKX0C/znwjlmh0WvQ/WyFayeZ0Lw8cL/f2RoYMZnTQiBqr8HX7rzXqzb3kD1/BNWN7GK2uS+k02HD6CEsvfeZHgpmKXL5XIhkUggkUhQX18Pn88Xjv61t7eDEAKZTBbu/M2doxaTFrQjfAvJsiYZsoIvDfB4PLjdbpw6dQocDge7du1K2YUUC1RtWRZJ3YTdagGXw8WeN9+nZofAhuku2+Tk5qF62UoAE7V/n/6//0SQYVBSUYnaFaux8eJLkZuXvqftwY42+L2Ra7eMI2rULFuJ6+9/hLXzD3WejUOQ0OPYx39FOYvNGiEIYcDjTTTDDHW1w++d2hjBMAwUPV2462vPomZF/NMzouEcH4NFr0NVfWwPW8kIAEIIhjrb45ocEi9zdemygVAoRHl5OcrLy0EICUf/dDodent7kZ+fHxZ/UqmUtbWxUcOXJSv40kIwGER/fz8qKyuxZs2ajBNFVGv4FniXLsMwMGpUuKDhYlx0/S3pXk5GweVyp3iv9Z9twekD+yCVl6CkshoX7r6M1Y7RSHSeOTnDQoMQAuOIGpt3X47tV13L2rmNGjUcY/a4BB+tq0fVH/uUi2QgDAHvXAdo5+mTKCo7b3tDY3pGNI5/8jeUxCHAkgn49DSfAU/A7u0zmaYNGnA4HIjFYojFYixduhR+vx+jo6OwWCzo6upCMBiETCYL1//l5eVROzetObpANqU7mazgmwU2wr+EECgUCoyNjaG8vBzr1q2jfg4aJDPvdzoLuUvX43Ri1BR9PFpSLLCPrkAsQYFYAgBw2m34wz//AoIcIeQVlVi2fiPWbt3J6rxfr9sNvVqJ0nPdx8CEYNcph3DD/Y9h6Rp2r8cTn/49bHqdSoa7OxAMBlJyrokIHx8+rwd6lQIllRPNKT6vF5qBXjz11o8Tnj08F+r+3rjS5cns8e0nv0BxGbsCmsfjghCSMQEBgUCA0tJSlJaWghACp9MJi8UCo9GI/v5+5OXlhcWfVCpNSrCx0bSRJSv4UkYgEEBHRwdsNhvkcjlEosydZkAzwrdQffhGTUYUiMWsjkdbwFoZXD4fFXXnxU/TkQM4+tc/QCYvRc3K1azM+2068hnEk+rJAn4/9GoF7n/+e6yb9DLBILTDQyivTW1EE5ioNYs6YowihBDwBQK0HD2EAvGEXYnH7caYxYRn3/8la4Je1dcDX4yj20IkKvh8Hg+MIxpUxdp4kyDcNKR0Y4XD4aCwsBCFhYVYsmQJAoFAOPrX09MDv98/ZexbvF2y2Tm67JAVfCnA6XSipaUFQqEQDQ0N6O/vpzerlgVoN23QkY6ZQTAYgEGtwq5rb8KFuy9L93IWDNLikvCge51KgdYvjqCopBTyymqs3Hgh6tasT376Qm83cvMnNn6v24VRkxFPvv6jhG1z4uHsiS/C504lfp8PerWSdXESItSlq+idsCtxOcbh83jw+A/eYVW4NB7eH/aNjJkEBd/J/R+juIyFiP4kGIaBMEdAxZYlFfD5fJSUlKCkpCQ8u9ZiscBisWBwcBBCoTAs/mQy2Zx1zjQjfG63Oyv4zpEVfLNA6yIzGo04e/YsqqursXLlSnC5XKopUzag2bTB43IWjOALjUd78LuvovBcapJdMn+jZwOhMAc1yycaP5zjYzj4x/8Bh/M7lFRWoay2DhfsvDg+PzkC6FUKjI1akZtfANf4GAJ+P558/d2URU+6m05BKk99s0bjoU8hZXWM2lQIIXCOj4cj4AJBDh5+6TVWzxkMBKBXKVGxJPZ0OSEEnAQdBBTdHRDJihN6b6wwwSDy8goyNsIXDQ6Hg4KCAhQUFKC2thbBYBCjo6OwWq0YGBiAx+OBVCoNp38jddDSbtrICr4JsoKPJQghGBgYgEKhwPr161FRcb7eg+boMjaga7w8/0ULIQQ6xRCql6+Iezxacsz/zy5ZuFxu2DMvGAxisKMNzUcOoKi0HMXlFVi7bScqliyd8wGt+eiE2fGY1QKRVIbbn3wmFcsHcN4SJdbuUZr0n22NOuWCNoRhMNw1MVlDWlSCmx5+gvVzNh05ELfvY6wjy6Zj0o1g3G5jX/AxQRTk589LwTcdHo8HuVwO+bkHHpfLFbZ+GR4ehkAgCIs/mUwGgUBANcLndDohk6XuGshksoIvChwO59xsyPjw+/04e/YsnE4ndu7cOaNebz5E+AghVDYb3jzfrAJ+H1T9vbjh/kewevP2FJ89ncPVMpO8gkLkFUxE9+xWC/767/+CnLw8lFRWo2b5Kqzduh2CaTNyg0wAOsUQCCGoX38BrrjtrpSu+dgnf2XNnDcaVoM+LHBTBSEENosJ63delLLPub+tOe6/kTDMjO9JLJzcx37jDSEEyp4uyHnMghB808nPz0d+fj6qq6sRDAZht9vD4q+zsxNisRjBYBAikehcJDa5B1+3243q6jjT/QuUrOCjzPj4OFpaWlBQUICGhoaIQ6pppkzZILTB0NhsuLz5u1mN20YxNmrBM+/8bM7h72zAZPBDQSbA5XLDQsrv9aL1i0M4se8jyCsqUVJZhfU7LkZxWTn6Wpvg9/lw1ZfvwcaLLk35OlV9SViiJHGzO773I1SwOTc3AhaDDktWrU6Z2BsbtWLUZIx7ni0hDPg58Qk+Qgi0w4NTrIZoQwiBorsDspIybNu2Y0EKvsnweDwUFRWFhw54PB5YLBYoFAro9XqYzeZw7V9RUVFCY9+cTidVy5j5TFbwUUSn06GjowN1dXVYvnz5rE8m8yHCB0yk0JI1EeZyuPMuUEUIgUmrQc3ylXjgO6+kbx0Z/FCQiYhlxRCfS7UZ1Wr8b+OPkV8ohnN8HPc//1LYEDqVDHV1IMikxhJlMoQQaIb6UxZZJIRAr1KAy+Vh067LUnJOYMJ7rywBUcsEGeTEKQK6zpyEIE6RGA8Mw0Dd34s7n34Of/qXX0IkLswoW5ZUkJubi6qqKlgsFshkMhQWFsJqtUKlUqGrqwtisTic/hWLxTFF/1wuFwpZniE9X8gKvijEmtJlGAZ9fX3QaDTYuHEjSktLo74+0wVf6CKiEYXk83ggPgacebJp+TwemHQjuOXRp1DD8hiquWBIVvAlCl8oRIFICp/Hhc27L0uL2AOA5qMHUFqZGkuUyXQ1nmLV03AyDMNApxjCdfc9gr/82z+m7LyEEKgH+yBPYLwZQxgIc+KL2necPs6KYTQwEc0fGR7EQy/+AD3NZ5BTkA9R4eITfCFCxssymQwymQzLli2D1+sN1/5pNBoACIu/oqIi5Mwixt1ud9aH7xyL75tEGZ/Ph8bGRpjNZjQ0NMwp9oD5IfhoWbMUFhZkdPp6MmNWK7xuN/a88V7axR4A8PmCbJQvARiGgUGtRFV9PR77/g/B4dIp/o4Xv88Lg0qZlnO3n/icdWNgYKJDVjs8iPuefxk6xRBEUhl4lEYLzsVwZztIMLHrgzAMBHGUaXjcLpi0Iwmday4CAT+0iiE88r03IJWXQNnXjZzcvHBn6WIUfJGaNnJyclBRUYH169dj9+7d2LhxI/Lz8zEyMoJjx47h9OnTGBwcxOjo6JR7jtPppBrhs1qtuPfeeyEWiyGVSvHoo4/C4XBEff0zzzyDVatWIS8vD7W1tfjGN74Bu91ObU2xko3wJYHdbkdLSwukUik2b94cc/oz0wUfQK/OUFRYiKDBmrKbQCIwDAPjiArrd1yE3Tfcmu7lhOEJBBNFy+leyDzC7XLCZjTgrqefh7wiFPlJT03BmQOfQsKyoXMkPG4X7FYLSqvYjWr4fD6YR9R4/NW3kZufD/VALwTCHPAF8ddZJULz54dQUpVYMT7DMMiJQ/Cd/PRjVkbT+X1eGDXnP0OLXodRkxE5ubnIz8+Hy+WaFz58tJnLloXD4UAikUAikaC+vh4+nw9WqxVWqxUdHR04cuQITp06hSuvvBI2m41qhO/ee++FTqfD/v374ff78fDDD+OJJ57Ab37zm4iv12q10Gq1+OCDD7B27VoolUrs2bMHWq0Wv//976mtKxYy9y6c4Wg0GnR3d2P58uWoq6uL66KcD4KPljVLYWEhGCZz/1aPywmrUY+7n/lOSmaNxgOfLwBDGHCRngjVfIIQAotBB1lJKb72wx+nezkAgIGOtqQ7ZBO52Tce2g9xEbu2IR63C2MWM5584z3w+fywz2FOTi74LM+YBSYMpQ1qJSoTNJQmDIPcvNhFgKKnCxLKn6nP64VFr8We198F/1wzQtORAygpr4TdakFeXh5cLlc2whcDQqEQ5eXlKC8vByEEIpEILpcLv/vd76BQKPDMM8/gyJEjuPbaa3HxxRfPmv6di+7ubuzduxdnzpzB1q1bAQC/+MUvcP311+ODDz5AZeXM8oL169fjD3/4Q/i/ly1bhh/+8Ie47777EAgEkq6Tj4fF902Kg0ibLcMw6OzsRG9vLzZv3oylS+f2AJvOfBF8NNYokYgzttt01GQEh8vBU29+kHFiDwD4AgEIM886XtKAz+uFdngQl9x0O76859mZL0jDR2jW6zA+ak39iQGo+3rjEjPx4nKMw+ty4fEfvBO+WYV8DhmQlNTwnTmYXPQ0GAzG3HlvUKvgHKebfvO4XbCbjXhyktgLdQFz+XwQJhhOQy5GwReq4UsEDoeDTZs24e2338YXX3wBqVSKJ554AqOjo3jwwQdRVFSEm266CadOnYr72CdOnIBUKg2LPQC46qqrwOVy4zqe3W6HWCxOqdgDshG+uPB4PGhpaQEhBLt27Uq41Zvm6DK2oJXSlUkkGSf4QuPRdl5zA7ZcckW6lzMrfKEAXrc73cvIaMasVhDCTImSZAIn9v0N5TWpn5urVykwZrMil6XJAg67DcLc3CkG5EwwCJ1iEEVlFQAD8PjsC77Bjra4zZYnQ5jYmzZO7f8Y5TV1CZ9rOm6nEx6nA4+9+vYUMdff1hxu1GIYBvn5+YtS7AF0J214PB7cfPPNWLduHQgh6OjowN69exNK8+r1+hl1+nw+H0VFRdDr9TEdw2w2480338QTT7BvSj6drOCLEavVitbWVpSUlGDt2rVJuYDz+XwwDEPFVJItaIlSmVSaUU0bLsc4xm2jeOCF70OUxA0jFQgEOfA4neleRkbCBIMwaFTYdPFl2HXtjelezhQYhsHI4CDKalJvthyKtLGB3WqGvLwSNz74+JSfd5w+Dv45E2MChnXhPWoywm61JCf4CANB7txpPYZhoFUMoYySeHeOj4EJMnjke2/M+F1P8xnI5BNigiFkUQs+WpM2gsEgPB5PuAGGw+Fgw4YN2LBhw5TXvfjii3j33XejHqu7uzvp9YyNjeGGG27A2rVr8dprryV9vHjJCr4ohGxZlEol+vv7sWrVKtTU1CQt0kIXMQ2fO7agEeEjhMBms2VEpykhBFaDHvLKqhSPR0scvlCY0KSXhY5zfAwO2yjufe6lmOqqUv0Jdpw6nhaj7mAwAJ1yCEWl5dSPbTXqUb9uAy6/daah8kB7K8SyCeNcwjCs72nHP0k+ehoMBiEUzv1vNPFvSce012G3Q5AjwN3PfWfG73weD/QqZbgJhYPzbgmLjdCUJxqCz+VyAcCcXbrPP/88Hnrooaivqa+vR3l5OYxG45SfBwIBWK1WlJdHv+7Gx8dx7bXXQiQS4U9/+lPEoQxsk5lqI0MIBoNob2+HxWLB1q1bqc3jo2lszBbJNm0EAgG0t7fD6XSCpNlPLuD3w6hR4aq77sWqTVvSupZ44AuFGRUdTTeEEJi1I6hYWo/7nnsp3cuZla4zJyArmdueiTYdJ4+BL6BvDGwcUWPzpVdg2+VXz/idw26DcUQTNngmhEDAwhpCEEIwMjyAksrkRmURholJlHc1nqTybzk+OopCmRS3P/50xN83HT2IQqk0/N8cDp1JR/OR0J5H428PCb6COUocSkpKUFIyd01oQ0MDbDYbmpqasGXLxL3k4MGDYBgGO3bsmPV9Y2NjuOaaa5CTk4O//vWvyE3DAyGQbdqIilKphNvtxq5du6gOX54c4ctUkknpulwunDp1Cn6/H7t3706raHHYbbBbTHj81bfnldgDAKEwJxvhO4fP44ZOMYRr730QN01LKWYSbocDZp2W2vHiySX0t7dBTHGfIoRApxzGZbfeGVHsAUDjoU9RPCmiSAgBl8WH2N7WJnB5yR+fCc5dw+dxOal479ktFhRXlM8q9gBA1dsdnhENABxwFq3gC913aEX4+Hx+wl2501mzZg2uvfZaPP744zh9+jSOHTuGp59+GnfffXe4Q3dkZASrV6/G6dOnAUyIvauvvhpOpxP/9m//hrGxMej1euj1+pRrgMwML2UIS5cuRXV1NfWLjsPhZPw83UTXZ7Va0dLSgoqKCqxevRo2mw1MguaoyRAaj1a3ai2uueeBlJ+fBsLcnIxIh6cbm9kEYU4Onnrrg4y/AR775G9JR58mE+u0FYfdBrNuhNootdD0jNuffBqVdbNbn6gHBlAokYT/mxCS0LzTWDl7/HMUlyWfso5l0saJfX9HSWVy9ZCjZiOWLF+NK++8Z9bXWPQ6jJqNU/7tOOcyLJla480mIRFE4293Op3Iz8+n+jn++te/xtNPP40rr7wSXC4Xd9xxBz788MPw7/1+P3p7e8PRxebm5nAH7/Lly6cca3h4GHV1ddTWNhdZwRcFLpfL2g0m061ZEknpqlQq9Pb2YvXq1aipmRgnJRaLQVLsw+fzeGDSanDzI0+idsXqlJ6bJoJFHuELBPwwatTYde2NuHD35eleTkyo+rupjt+KNT165uDUSFsyBAJ+6JUKPPDCK5AUyWd9nbKvBx6Xc4bgYyvC5/N4YBxRoypB773JkGBwzlm6yp6upKxfLAYdVl24dU4z96Yjn6Fk2ng4LmfxRvhC9Xu0BN9c6dx4KSoqmtVkGQDq6uqm7NuXXXZZxuzjWcGXJjJd8MWzPoZh0N3dDYPBMKPWMdU1imOjVoAQ7Hnz/Yytj4wVgTAn4yxtUoXNbILH5cTDL72O/Hky+FzV1wOf10v1mLF0khJCoB7oS9rkGQB8Pi/MI5rw5IdotJ/8fNI0kwk4YM837tRnn1BrSGFI9G5inUoBl9ORsOAzaTW4cPfl2HZF5FR4iJD3nqR46nk4i1jw0bRkcblcCdunLUTm9x1xHpPpgi/WCJ/X60VrayuCwSAaGhoiXlypSEtMjEdTY922Blxy022sny8VCASLr0uXMAzUg/1YuXETrrv3EUoHTc1neObwfqrp3FhR9nbB6/FAlORxPG4XxqyW8PSMaAT8fugUwzMtYFi81oe72iGS0Zt2EU1UnN7/cUJWLIQQGEfUuOjaG7GhYfecr+9va551n12sgo9Why7ATkp3PpMVfFFg80syHwRfIBCI+pqxsTE0NzdDKpViw4YNs16kXJYvNo/bBatBj69MmZ86/+ELBWnvcE4lrvFxGDQq3Pv8Syirqkn3cuIi4J9Ig1bW1af83O0nj0Ge5KQYl2McAZ8Pj08zA56N1mOHkZufusirSTeCcbuNquCbDSYYhFYxjPLaurjeRwiBXqXA1Xfdh+UXbIrpPd3NZyKWACz2CB8twed2u6mndOczi+/blCFkuuCbq2lDr9fj1KlTqKmpwcaNG6NfoCwKPpvZBBDgqTffX1BiDzhny5KGhpdUQwiBTqUAOMA3P/gldbGXiijpmUP7IWZFjES/dvw+L3RKRVJnGLeNQiAQ4sHvvhqzwBju6pxSu8c2J/b+HeW1S+kdMMpXov3kF3GLWUIItIoh3PjgYzGLPZ/HA4NKEfF3XO6EB+xiFHw0hW4owpdlgmyEL01kuuCbzZaFEIKBgQEolUps3LhxxpiZiMdiQfAxwSD0aiV2Xn09tlx6JfXjZwICgTDmLs35it/nhXqgH9d99SGs3Ta7j1Vy5/CwctzJDJxtSWryw2zMdeW0fH4IBWJxwse3W8woqazCDQ88FvN7Rk1GWPRaatMn5mJi2sUgtQ5kAFE/2K6m05DKZ29WmU5ofV/5+nMojWONE957kesuuRxuNsJHAZfLlY3wTSIr+NLEfBB80yN8gUAAZ8+ehcPhwI4dOyASxVY1RDs17nKMY3zUige+/QpEFH3HMg2+QLigbVksBj2Cfh+eefenMU09SJRggN3rbNRogN1qZkXwzcVwdxfyCxOr3rMa9Vi+fhMuveWOuN7XdPgzFM8yvo0Tl3NgbHSePhHz3NtkcTscsOi0qKpfPveLcW66iWII93/7FUjjbPCY7r03GQ4Xi9qWhWbTRlbwnScr+KLA5sVGa1YtW0xP6bpcLjQ3NyMnJwc7d+6My2uL5udoNehQVF45b8ajJYMgRwjCLLymDSYYhHqgD5suvhSX3Xon++djWTR/8fFfUFFTx+o5ImHR6zBqNCQ0s9c4osaWy67C1suuiut9hBBohgZmH2nHwpbZmcLJJcf3xe6jGPD7oVcp8PDLb6BQHF96O5L33mQWc4SPZtNGVvBNJSv45iA0T5c2mR7hm7w+i8WC1tZWVFZWYtWqVXFvQlxu8neB0Hi0K798D1Zv3pb08eYDQmHugkvpjttGMWo04KGXfgBpceIeZ/HAYfGmSQiBZnAA5bWpSW9OpvHwfpTEWbcaaiy46s6vYuXGzXGfc7C9DcGAP8or6Co+j8sJs3Yk5ohbsih7e2ISl36fF0aNGk++9qOE5iZH8t6bzGL24aMZ4XM6nVlblklkBV+ayHTBF4pAKpVK9PX1Yc2aNaiuTsxyItkIn8Nug8flxOOvvp2WofTpgi9cOCldQgh0iiGU19bhge+8ku7lUKO76TQElMY2RWSWS4dhGGiHh+JKI4amZ3z5qWfj7kAN0dV0MqoXHu2kyIl9H0Ge5LSLWNEOD8JzbjpCNHxeDywGHfa8/m5UL7/ZmM17bwocupGu+QTtCF95OR3vxoVAVvClCR6PN6ftSbpxuVwYHBycYaYcL4k2bRBCYNaOYMmqNfN2PFoyLBTB53V7YNZpcMP9j2Lp2vXpXg5V2k9+QWXUV7z0tjQiaqvpNGKdnhENr9sNvVKBkhRa5ih7u6MLI4qcObR/zvS4x+3C+KgVe15/L+EoVDTvvRChCJ9AIEjoHPMZ2k0bhfPEuD0VZAVfmsjkCJ/X68XAwAAYhsHFF1+M3CSjalxO/Bujz+uBSTuCmx9+Yl6PR0sGPp8PEsdNPROxmU0QCIULYvLJdDwuJ0wjmpSlGyfT29IIqTy2ujaf1wuzNrbpGdFoPnoQIllRwu+PF51yGC6HgxXBN725hAkGYdFro47Fczud8LiceOz7P0wq5djT0jjn+D0el7uobVlo7RVutztryzKJhbUDs8Biq+Gz2+1oaWlBQUEB/H5/0mIPiL+Gz2Y2gcPlYE8Mjv9ZMpNgIACjRoUdC9g25/je1KUbJ+N2OqBXK2OyKfG4XRiPcXrGXCj7upGbP1cBPL2c7qn9n7Bm/TL9Qarj9Anwonw+rvFxMITBIy+/ntR5fR4P9CrFnI0hnEXctBEMBpFDqUyCjVm685ns3TRNZKLg0+l06OjowLJly1BUVISmpiYqx41V8BGGgV6twLrtF+HSm2+ncu4sqcdht8HtcuChl15L2DJkPqDo7YIsxihb4sy8dhoP7Y/pvC7HOIL+AB6LcXpGNExaDWxmM8qq50jnUtJ7TDAInWoY5Wx1P09LqQ60t85qnO2w2yHMzcFXnn4+6dM2HT0Y08xjHpeTtWWhQLZLdypZwZcmMknwEULQ19cHtVqNTZs2oaSkBA6Hg5qdRSwpXbfTAavRgLuefg6laZhHmiV5CMPAqNVg2doN+NJX7kv3clhlZGgA3hgK/NlAPdA3q39biHHbKHLzC6jZFzUdOYCSmKKZdARK24nPkZvHXu1Vvui8jYpzfAymEXVE0+QxmxViWRFue+zrVM6riilKuri7dLO2LOyRFXxzwNYTVqYIvkAggLa2NjidTuzcuTNc4BrJeDlROHNE+ExaDQolUnztrQ8W5Qa3EPC4nLAa9PjyU99MyBduvnH6wL64pirQQjs8CIfNFlXw2SwmlFbV4Ib7H6VyzomO4ME5684AegndnjinXcTL5H298dCnkJbO/NvsFjNKq2tw/X2PUDmnWafFqMk0d5QU2Vm6NP5uQghcLle2hm8SWcGXJjJB8DmdTjQ3NyMvLw8NDQ1TOsJ4PB4IIVQ2HS6Hi0jSMWTAe9GNt2DbZV9K6hxZ0ofVqIdIKsNTi0SwBwMB6JTDqFhCcbZrjLR8cRjFUbz3LHodVlxwYdzTM6LR3XgKXG6MtwoKis85PgazXodqNpthJq1TMzgwo/TAZjKidtUaXHnH3dRO2XTksxijpNkIH60In9PpzHbpTiIr+NJEuidtmM1mtLa2orq6GqtWrZoRyQxtNFQEH5czQ/A57DbYLWY8/PLrs7v2ZwErowso4ff5YBpR4/LbvsLaHFwqUG66ajpyAIViKdVjzsbkbtKQ0Cwuq5jxOkIITFo1tl5xDbZccgXVNfSdbYakOLZrlMa39fjev6E0higYDUaGBuAat08RfBa9Dqs3b8PFN9xC7TwhH8pYO455vMXdtEFL8GW7dKeSFXxpgs/np0XwEUKgVCrR39+PtWvXoqoq8hNn6IILBoNJd/fxeTxMdhzUKoZQXrsE93/7e0kdd3GQmbYs46NWBAIBPP7a26zOwc1E+tqa0zLD+eyJzyMaj09MzxjG1Xfdj+UXbKJ6TpdjHAa1KqaO4AmSl3zq/t6Y0sfJEBLSbcePoKjsfMTUpNXgwkuvoJ5x6GtrBhPjgwchBBwuZ9HastBu2shG+M6TFXxzwFYNXzoifMFgEJ2dnbBYLNi2bRukUumsrw393TTq+EKfYMDvh6qvG9fe+zDWbduZ9HGzpB4mGIRxRI1123fhkptuS/dyYoPiJTxmtcBq0KFAJKZ30GhMWvtgx1mIJFOFJhMMQqccTmp6RjRi7Qimhaq/F16Pm/0TcYBgMACdQoGisnIQQmDUqHDRDbdgw46LqJ+up/lMzJ8jYRjk5uYu2ggfrZSuz+dDIBDICr5JZAVfmqBZIxcLHo8HLS0tAICGhoY5/fU4HA41UUoYBnabGQ67DV9/+6dJmb9mSR8uxzjGrBbc/Y3vpGyYPRUoBkmPfvRHVNQto3fAGBkbtcKs005piAn4/dCrFHjwu69CzJIhsnqgH/nx3DCTFNeNh/ajtIr9ZhgOh4uOk8cgyM0Jzxe++q77qEdIgYkJJQa1ck7vvRAMw6CgIG/RCj5aET6n0wkA2S7dSSy+b1OGEHqCodUJGw273Y4TJ06goKAA27dvj9lMmcfjUVnfiEYNi16He597KSv25iGEEJh1IyiQSPDUm+/PL7FHEUII9EpFis3AJ9TqmYOfTmnW8Hm8MI6o8eRrP2JN7GmHB+Ecs7Fy7EgEAwHoVYoUiRyCgY6zKBRJoFUM4eaHn2BF7AHnJpTE4L0XggkGUVBQsCh9+EJBEBoRvqzgm0k2wjcHbNqyAHRq5KKh1WrR2dmJ5cuXo66uLq6/h5Y1y4oVK2FwefHbD9+DuEgOeUUl1m7dieplKxbdhhYv6f58fB4PTLoR3PDAo1i6el1a15Ju+tqaU35On8cDQgg0g/1hYedxuTBus+LJ199lde9o/eIwistn7wiOSBLf15bPD6FQIpn7hRTweb0walQI+P34yje+zar3p6qvJybvvRAME4SosHBRRvgIISCEUBF8LpcLubm5i+4zjEZW8KUJLpcLDofDWh0fIQS9vb3QaDRhM+V4oWUdk1+QD64ngPLaCRsLh92OT379HxDkCFFSWY26VWuxZsv2qKONFitsjPWLFbvFDB6fnx1xd472E1/EL4CShMPhYOBsK7xuFyArgsNuA2EYPPGDd1g970RH8ER9Wzwk83jS29oEkTQ1s3rNuhHkFYrwyMuvQ1LEnt+fWafFqDk2770QTDAIkUi0KAVf6H5DK6Wbn5+f9ofmTCK7i6cRtrz4/H4/2tra4Ha70dDQkHBIm1aET1xYCMY0Ct65rxuXyw37Ufm9Xpw59CmO7/0IJZVVqFhShwt2XbKgR3LFw/Qh76kgGAjAoFFj+1VXY9vlV6f8/JmI1+2GYUSFyiX1KT4zB20njqKksho2sxHCvHzc+83vsn7Wsye/AF8omPuFM0js+zpuG8Wo0ZCS6z7g98Pr8eCbH/wS+YXsNt/E470XgmEYiAsKFmWXbuh+Q+PvzpouzyQr+NIIG4LP4XCgubkZBQUF2Llz5xQz5Xih1bQhEonARDmOdJI31XB3F1q+OIyi0nLIK6pwQcPFMRc7Z0ke55gdLsc4Hn7pVdZvhqmCRpT01GefoKgkvmgXDZhgEEa1CoLcXJRW1+KWh59MyXmHOs7OOls2Gok+nhz75K9xWL8kjt/nhaJnYgYy299vQgi0w0OQyuPLrjBBZsrEo8VEMBgMNwwmS2isWjbCd56s4JsDNr8stAWfyWRCW1sbampqsHLlyqTXTqtpQ1xYGPPfmZufj/L8OgCA1WjA7//5QxSKJZBXVGLVpi2oW7N+cW2CKdqsCCEwjaixZNVaXPvVB1NyzlRB4xNU9HTFVXhPC6NWg0KxBKu3bscVt30lJecct43CqB1BeSIj8hL8sDUDfayny30eD6wmA9Zs3gaL0cDquQCgt60ZJIEWcUKYcNPGotrrQH+ObjbCN5Ws4EsjtAQfIQQKhQIDAwNYt24dKivpbJy0UrpSiSRqhG82+Hw+ymuWAABcDgcO/vF/wOH8L0qqalGzbAXW7WiAMGdhm/6mQu55XE5YjQbc8cTTKE/DuDC2STa+p1cp4LDbUy74CCHwuJy49qsPYutlV6XsvGcO7oO8fOY0D7YY6upg3ZPU43bBYRvFY6+8hf/77hsQ5uSwej4A6G2K3XtvMoQQ5ObmwuVyLTrBR9N02el0Zjt0p5EVfGmERsp0spny9u3bIaHY5UYrpSuRiJMWjlwuNxwBCAb8aD91DKcP7IO8sgql1TXYuOsS1uwpFjJWowGF5+xWFtvNJVZOfbZ3iv9dKiCEYLi7AwUSaUrF3kRH8EDi4jaBiHTL0QMorWJvlJrb6YDP48ajr7yF1i8OR5xWQhuv2w29RplQ9y9hghgcHERFRQV0Oh3kcjlyUiBQMwGaY9WyEb6ZZAXfHLCZ0k12vJrH40FzczO4XC527dpFfVOgldKVSCQAoes3KJLKwjcl7dAg2k9+AZm8FPKKSqzbvgsVS5ZmazeiEPD7YNSocemtX8b67bvSvZyMJTTJIhX1ZZPPqezrQXnNErjPeYmlCkVPF7xeD1LVMuX3+aBXq1BZx04zjGt8DADw0IuvAQCGOtshksowbrexcr4QzUcPQpygaGaCDC688ELo9XrodDr09fWhoKAAxcXFkMvlEIvFC3Zvo5nSDXXpZjlPVvClkWQiaDabDS0tLZDL5Vi3bh0r0RlaEb7CwkIwDHv2IsLcXFScs3wZGx3F3/7j/yAnLxciiRSrNm+bsHzhzdOvOgsb+7htFAG/D4+/+nZKoh3zmdZjR5CXn7rRTAG/H+qBPjz6/Tfx25+/Dz4/8aarRGg7fgTysmTSufF9XxsPfQpJUfzNIbHgGLMhJzcfd339WwDOTSvRa1FWXQsOy25Hyr7uuLz3JsMQBnK5HCaTCVu3boXP54PVaoXFYkFbWxs4HA6KiopQXFyM4uLipBrzMg3ac3SzKd2pzNO7YGrhcDis+KElGkHTaDTo7u7GihUrsGTJElbNoak0bYjFYJjUzA3mcrkorTqfRjn92V4c/vPvIS+vRO2KVdh86RUJb8TpgOa/LMMwMGpUWLt1Jy695Q6KR1649LU2QVyUmlIBn8cDnWoYT7/9E/S2NEKYmwsmyP4knhB+nxeawX5ULV2e8DHi/b4OtLehUCJN+HyzMTZqhaRYjlsffSr8s6ZD+883hrAYIDPrtLCZTQlHhQkhEAqFYeEjFApRXl6O8vKJmb9jY2Mwm81QqVTo7u6GWCwOi7/CwsJ5Hf2j3bSRFXxTyQq+NMLj8RAIBGJ+PcMw6O3thVarxYUXXgi5nD3DUIBmDZ8EJAUj5CIhKymDrKQMADDc04mmIwcglZegtLoWWy67KqXF6QlBafN22G1w2G34yjPPo6g09fYi8xGH3QazXoeqpezPznU5xmGzmPDMj34OHo+HrqaTkBaXwJqCbtIQZw7uD18rqcBmNsFmMVEXfHaLGWU1tbju3ofDPyOEQD3UD5FEBkIIOFz2RNGE917iVlJcYFZrEg6HA4lEAolEgmXLlsHr9cJsNsNisUCpVILP54fFn0wmm3eG6bQjfCJR1s91MvPr27DAiCeC5vf70draCq/Xi4aGhpTUJnC53LgE6WyIxeKURipmI79QFDZ2HRu14rc/fw95BYWQV1Zhw86LsXTNuox7OiZJ1j4SQqBTDkNeXoGn3nyf0qoWB8f3/g1lLDYThBi3jcLv9+Hrb/0YwIT4M2m1qFq6LKW220NdZ1EgSrLpK44FH/v4L+HpO7QYNRlRt2oNrrjj7ik/V/V1w+d2AxIZCMNAIBBSPW+IRL33pnDuQTsW4ZOTk4OqqipUVVWBYRjYbDZYLBYMDAzA4/FAKpVCLpejuLh4XtSz0Y7wlZWl7gFmPpAVfDHAZko3lghayEy5sLAQO3fuTNlTG4/Hg8/nS/o4QqEQyZtj0IXP56OqfiJ1FfD7sf9//xsME0RJRTXq123Ahp0XQyBk56YQD9wkag+9HjdGhgZxyyN7sHzDRoqrWvgQQqAe6GM9GmozG5FXIMID33kl/LMTez9CScW56QwpUnwWvQ52szl5wRfjggkh0CqGIK+IbwpFNCwGHdZu2Y5d190843dnTx4Lp3MZwoDPkuDrS9B7bzJcIKEpG1wuF0VFRSgqKsKKFSvgcrlgsVjCAjA3Nzfc+CGVSjOyKz9bw8cuWcGXRmIRVEajEWfPnsWSJUuwfPnylEagaKV0AXa7nZNlou7vfCTn7MkvcPyTv6GorByVS5dh62VXsVJnFAu5CT6Vm3VacDjAs+//Yt6ldTKBoa52KvWr0TDrtCivXYKbHnpiys9V/T2QJuDflgwn938c9rxMBr/XE9PrBtpbk3qYmY5Jq8GWy67ClkuvnLkmnw965XBYXBKGAT+PnWal3ubEvPcmw+FywDBM0ntmfn4+8vPzUVNTg0AggNHRUVgsFnR3dyMQCEAmk4XTv7kZ0rxF25YlK/imkr0TpJFoET5CCIaGhjA0NIT169ejoiL1tWa0mjaAzBZ805HIiiE5N1ZKr1LgV++8BrFMhpKKSmy94pqUWnTE+7kFgwGo+/uw40vXYde1N7K0qnlGAtH51s8PQ87i5Ae9SoE1W3bgslu/POXnqv4eeN2TRRP71w0hBCNDg3HPfI1MbOvtbjqFotLk022EEBg1Klx8021Yv60h4mvajh1B7qROa4ZhIBDS97Xzut3QqRPz3psMBxzqUzb4fD5KSkpQUlICQgicTifMZjP0ev0U25fi4mKIxeK0Rf+ykzbYJSv40shsgi8YDKK9vR02mw07duyAWJyemaaLJcIXjZzcPNQsWwEA8Dhd+NP/+SXyC0SQV1Zj+YaNWL5+I7iUNqiIxKFV7FYzxketePwHb6NQTM+Ae74T75QXn9cDg0aFChamjkyIqwHsuu5GbLl0pqFy0+EDKKlK7ezo7qbT4NGKAsdwnfu8HuhVyqRnZBNCoFcpcPU992P5utlLFoZ7OlE4yZCeMAwr5RrNnx9K2HtvMhwOfcE3/fiFhYUoLCxEXV0d/H4/rFYrzGYz2tvbQQgJi7+ioqJzJTmpIRgMUstIuFyu8EziLBNkBV8MsGl7Ml1Qud1utLS0gMfjoaGhIa0O6zQjfNx5Kvgmw+XzUVY9kfbyul04+rc/4ehf/4iSqmpU1y/H+h0XIScvj+5JY/jYCCHQKYZQs3wVHvruD+iefwHAj/OGdfrAvuSK7meBEAJVXw9uePAxrNiwacbvg4EA9CoFymvrwj9LxWXTefoElWgbgJgM1k999knSJRKEYaBVDuO2x78W1UbGbjXDotdNicozDAMBCylMVRLee5NhW/BNRyAQoKysDGVlZWHbF4vFArVaje7ubohEonDtH9u2L9kIH7tkBV8amS74RkdH0dLSgtLSUqxduzbtRbW0ZukC8zfCF43isomCfiYYRHfTaRzf9xFk8lKU1y7B1suvpiQaon9uXrcLZr0Otz72NVTXJ+6fluU8w10d1Gs2Q9Mz7nvuRZTOUhLQdORAymtFPW4XjCNqapMuYkmVKrq7p0Tc4oVhGGiHB/GVb3x7zvRp42TvvXMQhkEO5RncZp0WoyYjlXKPUA1fOvb/ybYv9fX18Hq94cYPlUoFHo83JfpHuz6YVtMGISQb4YtAVvClkckpU7VajZ6eHqxatQo1NTUZIZCopnQzsCOMJgViCQrOpVFHjUb81wc/RIFYjJLKalyw6xLUrliV0L9ptLeMGg3IE4nwtbc+SPvDwULBpNVgzGalKrxC0zOeePVtFEpnP27/2ZaZ52V5Hzi57+8oKqPYiTzHcs06LcZsloQFXzAQgE45hAde+D4kRdF9SEO1idPnAjMMAyHlzEnz0QNJp6hDcMFJqEuXDXJyclBZWYnKysopti9DQ0Po7OyEVCoNC8D8/Pyk71vZpg12yQq+GGAzpRsIBNDV1QWdTofNmzejuJidMUOJQDelS+Uw8wK+UIjqc3V/Pq8Xn/z3rwAOByWV1Vi+fiPW79gVR83UzA8u4PfDqFHhkptuw4aG3RRXvjCJp2Xj5P5PUF5TR+3cXo8bBpUCT7/9k6hj7GwWE2xmU9gnMlWo+ntnCCI2megGrkvovQG/Hwa1Eo++8ibyC+euax7u6oDPM7NrmBACYS690gtCCEaGByEtplMGwE1xSjdWptu+uN1uWCwWmM1mDA0NQSgUhj3/pFJpQsKN5t+dFXwzyQq+NMIwDLxeL6xWa8rMlOMhm9JNHi6Xi7JJdhdNRw/i6Ed/QlFpKZauXo9Nuy+L6yY/bhuF3+fNzsFlgVCqsJSS2bLLMQ671Yxn3v1wzpvYiX1/nyXVy951Y1Ar4Rofpyr4gv7ZjdpDn28ikTCvxwOdYhBf/2F04TyZztMnUBxhkg4hdJs2+tqaqdqM0rJlYZu8vDxUV1ejuroawWAwbPvS09MDv98/Zd5vrLYvtCJ8DMNka/gikBV8aWJ8fBwdHR0ghKTUTDkeYjWGjoWF0LRBA5m8BLJztX3Kvm60HT+KorIKlFZVYf3Oi88b7p4j9LExDAPjiBqrN2/D5bfemeplLwraTx6jJqLHbaMIBPz42psfzPlaQghGBvtn1JoB7JqyNLLSETy78ulpOp3QPud1u2EcUeOZdz+M+f1+nxc6tWLG9QSci/BRrOHrbT5Dtckn1U0bNODxeJDL5ZDL5Vi5ciWcTicsFgsMBgP6+vqQn58fFn8SiWTWv41W04bL5QKAbA3fNDJPZSwCDAYDzp49i+rqaiiVSmo1C7ShGeHjcubP5pUqcvMLUF47kXIw6/X4/T/9DIViKeSVVVi1cQvq1qwDwIHb6YDNbMJXnn4+YsQiCx26m05RScuNmowoEInwwDOvzP1inIsQRXggIoSAgB3zZyYYhE4xRP37xOXOvpd1njkJWZyTS9xOB0bNRjz9zk/jEkAtnx+eNXI+kdKlU8NHy3tvMpma0o2VybYvS5YsCdu+WCyWcJBjcvRvsu0LraaNkODLpnSnkhV8MUArtE4IweDgIIaHh7FhwwbIZDIolcqJYd4ZGAELNW3QWB+bw8oXAnw+P1zb5Bofx8E//hYcDhd6lQIimQx73niPalRiURFDus05PgaLTofKpcl1q5p1I6hYshQ3Pvh4zO85e+wIissiCy++gB1bpo7Tx+O2q4mJWe7VE93AKlTWLYv5UM6xMbid43jqjffjFgH9bc0oEEWu8yNBhtq11Hz0IMTSIirHCsE9l9IVCARUj5suptu+jI+Pw2w2Q6PRoLu7G2KxOCz+aKV0XS4XuFxuxkwQyRSygi9FBAIBtLe3Y2xsDDt37oRIJEIgMFHvQnN+IE1CFx4NwZdN6cYOl8uFSFYEk3YEUnkJRLIi/PvbP4C8sgql1UuwcdduiGV0bzKLnRN7P0JpkulNvUqBtdt24tKb74j5PV63GxajIaKdByGEtQelvrZmSIrYaBCLvN5Tn36CollEbSTGbaNggkE8/urbca/AajRg1GJG/myCjzAQUBJ8yr7uhMcfzgaXw53XEb5ocDgciMViiMVi1NfXw+fzTbF9CQaDGB4eRnl5eVK2L6GGjUwMpKSTrOBLAW63G83NzeDz+WhoaAiHsEOCKhgMZuTTXGjDobH5LMTNiy3sVgu4HA72vP4ufvPz9yCSSMOF9dqhAbSf/AIyeQlEEhkuvORyVC5dlt3YohHDR6Ma6E14BiohBOqBXuy+8TZsvuSKuN7beHh/VHsRDgulEM4xO4wjGlRMMnimBWeWD1vR2xXzQ4rdYoYwNxdf/U5sKfHpnPz0Y5RH8cML+P3IoTBL16zTwmY2UR+1yE2jD1+qEQqFqKioQEVFBYLBII4cOQKhUIjh4WF0dnZCIpGEO3/jsX1xOp1UbGIWGlnBFwPJfGmsVitaWlpQUVGB1atXT7mIORwOVa872kwWpMk2lXCzKd05CQYDMGrU2HzJFdh59fUAZmoVYW5u+Ebt9Xrw1//4F/B4fJRUVmPFxs1Ys2UbeBSH0i8I5pilO9zTiYDPl9ihGQYjw4O48cEnsGzdhrjfr+ztRl7BLIXlhLBS+3r6wD5WakFn847TqxRwjtljEnyjJgPERcX48p5nE17DyPBA1DnIwUAAQmHygq/pyGfUvPcmw+Fkjg9fOli2bBkEAkHY9iXk+ycUCsOpX5lMFjX1m+3QjUz2zsAiKpUKvb29WL16NWpqIls90OyEpU1I6NJo3OByOCyVny8MnGN2OMftuP/570Eki80mg8vlTvE0O7X/Exz58+9QXFGJ2hWrsfmSy6mMelroNB7cn9CNmwkGoRnqxz3PvpCQlYtRo4J91DKr4CNgJ6WrHuhjxXuPMAy4ER4MTx/YN8WaaDYseh3Ka5fEVf84nb625jkDugTxj9ubcQxCoB0eYmUE32KK8E0mdB8M/d3TbV9sNhvMZjP6+vrg8/kgk8nCAjBv2khLp9OJvLy8bIRvGlnBxwIMw6C7uxsGgwFbtmxBUdHsT7aZLvhorY/L5WYFXwQIITDrRlC9bCXue/7lGb8PPe3HsnFNzEOdmIk63N2BpsOfQSovQVlNLbZcdtWsjQELnWBwdm84v88Hq0GP0ur4BFvA74NWMYxHX34z6vSMaDQe3o/SyijnJfRTuur+XnjdLnYEHyEzDMUnuoGH5/x8TVoN6tasw9V33ZfUGjpOHotob0Ob3rZm1o7Nxfzw4aNNKLAQSehOHukWGptmsVhgNBrR398ftn0xmUzYvHkzddNlq9WKZ555Bn/729/A5XJxxx134Oc//3lMti+EEFx//fXYu3cv/vSnP+HWW2+ltq54yQo+yvh8PrS0tCAQCKChofIXHnkAAKmUSURBVGHGk8d0MjmlC9CzZuFxOJj9trs48brdsBi0uOXR2efg8vj8hJpm8gtFYVsKu9WK3/z0PUjlcpRW12D15u0Jj3qbj/Cj1Mc2Hz2IgjjHfHndbpj1Wjz11nsJpwaZYBDa4eGoqVUC+indlmNH4mqeiIdIgq/91PE5p1roVQqs334Rdt90a1Ln93k9MGhUqFiyNKnjxEJvE13vvcmE9tzFGOHjcrlz7kscDgcFBQUoKChAbW0tAoEArFYrjEYjHnzwQYyNjaGmpgaEEBgMBpSVlSW9tnvvvRc6nQ779++H3+/Hww8/jCeeeAK/+c1v5nzvz372s4zZa7OCLwZi/ccaGxtDc3MzpFIptmzZElPdG5/Pz3jBRyvCl+U8oyYjcvML8NSb0efgTgg+BrP6XcQAn89H9bIJQemw27Hvt/8JPp+P0qpa1K5cjTVbtlOdPJBpRKtpHO7umNW+IxJupwPj9tGk5xd3nD4xd1qR0LUzCvj90CsVKKmcaUZMA0IY8PlTxXVP82lI5bM3pWiHB7Htymux/cqrkz7/mYOfQlIcfb4ukLyZtdfthnZ4AOUsCcv57sOXKImaLvP5fJSWlqK0tBTd3d04fvw43nnnHbS3t6OyshKbN2/GDTfcgOuvvx5bt26N+3Pt7u7G3r17cebMGWzduhUA8Itf/ALXX389PvjgA1RWzh5Rbm1txY9//GM0NjaioiL9GZbF9Y1KgrlEn16vx6lTp1BTU4ONGzfG3OSQ6RE+WvN0F9vmNRsBvx9axRC2XHYlvvrNF+b8XHh8AQhDb24Tl8tFSUUVZCVl8Pu8aP78IP797Vfxx3/9Bxzf+xGcY3Zq58p0LAY9Rk2GmF/vGLMjEPDjyR/8KOnvc19rUwy2KAQcHr3rpvXYYeSxaERLGALeJMHncozDrB2J/FpCoB7owyW3fpmK2AOAoa6OlMwiPn1gL6QlyUeNZiO05y62PZOGPRmPx8Pu3btx5ZVX4uqrr4ZOp8MzzzyDnp4eXHPNNbjyyivjPuaJEycglUrDYg8ArrrqKnC5XJw6dWrW97lcLnz1q1/FP/zDP6C8PD7DcbbIRviShBCCgYEBKBQKXHDBBXGHj2kJKragldLlcjlU503OR8Zto/B5PXj0e2/G7N3FFwjgDfhZW5NEVgzIJoSHqr8HbcePoKikHPLKSmzYcXHctW3zicaD+1BaEVuzht1qRqFEhi/v+UbS53WO2WHSalA+hy0KIYSqf+VQZzsKJVJqx5sOIQQ8wflbyol9f4d8ltFm6v4e3PDg41i+fiOVc1v0OoxZzCgUx5CeT/IzHe7phEhCvwYSOPdvzlucXbq0TJeBiaaNgoIClJaW4oEHHsADDzyAQCCAkZHIDyDR0Ov1KC2datnE5/NRVFQEvV4/6/u+9a1vYdeuXbjlllviPidbZAVfEkQyU44XHo8XNmDORKildBF788FCg2EYmEbUWLlxM6644+643ssXCOBxpkYp5+Tmhbt+bUYj/vh/foF8kRiy4hKs2LgZKzduBjdDxwDGC8Mw0AwPoiiGSI3VoEfl0npcd+/DVM596sDemBsLOFFGlcWDzWKCxaCb0tVNG0IYCATn09Sq/p4Zo+oIw0DZ14M7v/5NVNevoHbuk59+jPIYOoEnFpH4eUy6EYyPjrIm+BgmiLyCvIw142cTWnN0gci2LHw+H0uWnP+OvPjii3j33XejHqe7uzuh8//1r3/FwYMH0dLSktD72SIr+BLE5XKhubkZQqFwiplyvGR6hI/G+sbGxuByOcEI8xedR5zb5YTNZMRdX38O8or4uwf5AiEYkvrvB5fPR1n1xOYYCATwxd//goN//B/IK6pQu3IVNu++AsJ5PLaop/l0TNEzk1aDNVt3YPcNt1I7t2agP6YuWULRh+/MZ/sgjzGamSiTI3yawQF4XS5gUtaaCQah7OvBA995JaFrIdp5RxSDKIkQTYxIEs+cpz79ZM7IbDIwQQYF+fmLNsJH6292uVyQR6kdBYDnn38eDz30UNTX1NfXo7y8HEajccrPQ40is6VqDx48iMHBQUindfDfcccd2L17Nw4fPjzXn8AKi+vumwQhewwAsFgsaG1tRWVlJVatWpXUlzSTbVmA5CN8BoMBZ8+eRUmJHErr+KIRfIQQWA16yErL8LW3Pkj4OAIB3Rq+RJncTTpwthVnDnwKWWkZymvrsPXyq2ZEcjKd7uYzkEaZrEEIgV6lwEXX3YyNF11C7bzKvh54XDHaolBq2iCEYGRoABKWukonn4d/LsLXePhTlEzyJgwGAlD19+Cx7/+Q+ljA3uYz4FKKhEYjJCxLWTBbDsEwQRQU5C9aWxaaKd26urqorykpKUFJydzXRENDA2w2G5qamrBlyxYAE4KOYRjs2LEj4ntefPFFPPbYY1N+tmHDBvz0pz/FTTfdFNsfwQKL4+5LCUIIVCoV+vr6sGbNGlRXJ3/hZ7rgSzTCRwjB8PAwBgcHsWHDBpxuasawqZOFFWYePq8XphENrr77PqzcuDmpY/EEgnNduplDgViCgnO1UqMGPf7r/R+iQCJFSWUVNjbsRk2GWb5M9+FzOxwwatSzpgAnpmcM4IYHn0D9mnVU19J27EjM0S0CQsWHb6C9LSV7DGEmBF8wGIBeqQibLQf8fqgH+7DnjXeRXxh7R3SsdJw+geKyeIriE/tudjedhiDJiUNzwQQZiEWibNNGktCctLFmzRpce+21ePzxx/HP//zP8Pv9ePrpp3H33XeHO3RHRkZw5ZVX4j//8z+xfft2lJeXR4z+1dbWYulS9m2DZiMr+GKEYRh0dnbCaDRi69atkMU4DWEueDwe/H72ivKTJZGmjdBnZTabsX37dkgkkvAmttAZs1pBwGDP6z9K2s0fAAQ5OSAZ/LnxhUJUL5uoxfJ5PPjk1/8OcDgoqajC8gs2Yd22hhnebKkmMO36On1w36y1e6HpGV/91ouxpwhjxO/zQa8aRkk0s+XJEFCpmew6cxxFcQmixCCEgUAoRMvnh5F3rlvW5/VCpxjC0z/8CSslAF63G4YRFSqX1Mf8nkSfRTpPn4CslN3PcdxmRVFR0aIVfLQifG63m6rx8q9//Ws8/fTTuPLKK8PGyx9++GH4936/H729vXC5XNTOyQZZwRcjbW1tcDqdMZkpxwOPx4PH46F2PNrEm9INGU8Hg0E0NDQg99wmLxVLMjqSmSxMMAjDiAoXXnwZGq65kdpxBQJhuJQg0+FyuSidNEi+8fABHP3bn1BcXonqZcuw9dIvIS8GZ3ra8Kal+wbOtkQ0Hw74fdAqh/HoK2/F1u0ZJy1fHEJeHBEuGqPVfB4P9GolSqtq535xkhBCIBAK0dvSCLGsCF63C6YRDZ7+0c+SnsU9G6cP7I2p8SZZvG43jCNqVNbFLizjZXzUgh0b1+O2W27BqVOnwDAMgsFgeOb6QoemyKU9aaOoqCiqyXJdXd2c+3Qm7ONZwRcjK1euhFAopPYEEmIhpXQdDgeam5shEomwYcOGKZu8VCoGk8F/ZzI4x8fgsNtw33MvU69P4gsEGR3hi4ZMXgLZuboxzUA/Wj8/AknxxLSPLZdeycrg+blQD/TNiPgBgMflglk3gqfeTHx6xlwMd7bHJyQJkq5NazryGURSut/J2SCEgdfjhsWgQ1FpOWxmE77+zk9ZFSvD3Z2sjImbzukDe1HEYnTPbjFjx/q1+P7L30VLSwvkcjkEAsGUewOXyw3/byFCM8JHW/AtFLKCL0YKCwtZEWaZbrwc6/rMZjNaW1tRW1uLFStWzKjhKiwszLhatGQJzcGtXFqP+557iZVzCITCBZEKz80vCKd+x202/O8//BR5BQWQV1Rj7bYdqF+7gbUb2eTn6sbD+yGfJjRd42MYG7Xi62//hLU1WI0GWIwGVMTV4Zl8p6aipwt5BamJqhJC0HXmFAolMrjG7NjzxnusihOTVoNxmy1uwZdISlfR08Wah6HdYsbFF16Al7/7HTQ1NaGgoADr168HMPGZBoNBEELAMMyUebMcDmdBRf8YhqESCQ7N2s0KvplkBV+amQ8RvrlqDFUqFXp7e7F27VpUVUWuexKLxRnRbUoLn8cNs06Lmx/Zg5rlK1k7j0CYgyCTud+PRODz+eHUmN/nxaE//g8++92vUVJZg7pVa3HBroshEOZQP29otNhkW42xUQsIw+CpN9+nfr7JnDm4D2VxRjRJkl26Zp0WdqsZufmpufERZuIBqLxmCR579W3Wz3dq/16U18bovTeF+D5Tk24EY6MWVgSf3WzEZTu24TvfehaNjY0QiURYt27dFBEXinqFUrwMw4QFIICw6Jvv4i8YDCZsbzadkPFylqlkBV+MsNV1mOmCL1rTBsMw6O3thVarnbORZULwzf9IFQDYzCbk5ObiqSTnqcYCXyAEFpBQng6Xy50yjaHzzAmc3P8xisrKUbGkHlsvu5Lajbbp6MEpxxo1GlAoleKurz9H5fizEbJFkcVda5Zcl27jof2xN4hQwOUchzAnFw9+91XWz8UwTOIWKXHWUjUd+gzltfQ7K20mA67evQvPfv1raGxshEQiwbp162a910xO54ZEX0gALoTUL9vGy1mygi/tzAfj5UiCNBAIoLW1FW63Gw0NDXNeXBKJBMw8j1QFAn6o+3pw+e1348Ldl6XknAJheoyX04VIKgun6AwqBf79R69DIiuCvKoamy66NKmi+YH21rDgM2k1qF62Atff9wiNZUelt6UxoeEOhJCEb4DMOWsZNuvOJjNqNMCi0+KB77ySkvN1N55K3CIljqgpIQQjw4MoKqXbGDJqMuCGyy/B1598Ao2NjZDJZFi7dm3MgYWQmAvdPyanfAkh4elN8yn6R9uWpTANDWKZTlbwpZn5MFptuiANTRnJycnBzp07IRAIZnn3ecTi+d20YbOY4Bobw9d++JOY5+DSgC8QLqhUeDwIc3NRXb8cwIR33l/+7Z8gEOagpKoaKy/YjFUXbonZtmTUZITNaET+0kLolMPYsONi7L7pVhZXf57uptMJd5ImmlnoaToNTopu8Ba9FiXVNbCa9ODz594LaNDZeCphi5R4ygV6WxqTHb07A6tRj9uvuQqPPfwQGhsbUVRUhDVr1iT8bz1Z/AHnU78hEThfon+0mjb8fj/8fn82pRuBrOCLETZTupkc4ZvetDE6OoqWlhaUl5dj9erVMW8cufN0DBdhGGiG+rFi42Zc99WHUn5+vjDzjJfTAZfLDdfeMcEgju/7CIf/8juUVFahevlKbLr4MuTmzS7ET+z7O0praqEe6MOlN99BdXpGNDxuF/RqZexzXidBCEnYh6+75QxkUSaJ0MI0okH9ug0QyYqg6OoEL4aHv2TxuF0walSoWrosoffHs5d3N51OIBU/O1aDDnfdeB0evO9eNDY2oqSkBKtW0TUqj5b6nd74kUnij1ZK1+l0AkA2wheBrOBLM5lewzdZkGq1WnR2dmLlypVThlDHSiZNX4gFt8sJvXIY9z7/MsqqUlcLNRmBMLONl9PF5BTbYMdZnDm0H0UlZSirrsXmS66YYjRMCMHIYD+c43bc/MhTqF+7PmXrPPHJ3yBNdKQZQUJROrfTAZNGHZ50wRZ6lQLrd16M3Tfcgt/87F3kFhRQMRufi8aD+6eM+mMLr9sNg1qFsho6HoYWvRb333EL7r7zTjQ2NqKsrAwrV65kdV+cLfqXialfWindkPlxVvDNJCv40kxI8BFCMlIQhSJ8/f39UCqV2LRpU0zzByORiX9fJAghsBr1KBRL8c0P/iGtT8CCnJyMjgBnAvmFIuSfm+wwajTgNx++hwKRBCUVVVi/YxeMGhXMOg2eevPHMY81o4VqoC9hb0aCxCJ8Zw5+SjUqFYmR4UHs/NJ12Hr5l2CzmDBqMoLH57NmsDwZVV93eJJHQsS4DTUd3g9JsTzx80zCohvBI/fciTtuvRWNjY2orKzE8uXLU74nTo/+Tf5fulO/tCJ8LpcLOTk51D1zFwJZwZdmJj95ZeoX1OVyQavVYufOnUk9Nc0Hwef3eWEc0eBLd92LVZu2pHs5EGYjfHHBFwpRVTeR6vN63PjLr/4JDvsonvvpv6BARH+OazS0ymG4xuyJm3ETAm4Cc19V/b2s/a2EEGgG+3HFHXdj/fYGAMDJfR+jtLoWZq0GAgF9O53JGDUq2EetSQk+ToyfqbKvh4qljUU3gj0PfBU3Xn89GhsbUVVVhWXLlqV9P5wt9UsImRL9S5XnH60In9PpRF5eXto/30wkK/hihM0aPoCuyzgtPB4P+vv7wTAMGhoakvZI4mb4BTjhyUaw5zU6c3BpwOXzM2Ikz3yDEAK9SoGq+uXgcXkpF3sAcOazvShNMq3KjTNiplUMYXzUysrfSwiBsq8bNz/0JJatvyD8M3V/D+SV1RM1hyxH+BoPH0Bp0uUVc+9DZp0WNrMZ5bXJCT7ziBrPPPYwrvnSVWhsbERNTQ3q6+szTozMlfpNhecfzRq+rCVLZLKCL82ELppMq+MbGxtDc3MzCgsL4ff7qRhiZtomFyI0B3djw25cdP0t6V7OFPh8PkhCph6LF7fTAeOIGnc8+Q3ULF+JP/3rL1O+BiYYhE6lQFl14vVfiZR5nNr/yZR5xrQgDANFTyfueubb4c5pABjqOgvOufFvHC6XmnFuJBiGgVYxhOKy5KxmYvlIGw99itLq5ISlSaPCd57eg0t370ZTUxNqa2tRX8/eLF6apMPzj2YNX7ZDNzJZwZdmOBxOxjVuGAwGnD17FvX19ZDL5WhsbKRy3EzUey7HOMZto7j3my9Sq9fJkh4IITColZDKS/CNdz8M3zzSIZdbjx1BXn7yReO8OCJmwWAAOpUizvFtc8MEg9AM9eOBF16dUQPZcepEuIGC7QhfV+Mp8PgUsiBzbEQT3ntDSXnvGdVKvPLcs9i5YzuampqwdOlS1NXVJXy8dDI5+hdK99Ju/Agdi0aEz+12Iz8/P2MDDOkkK/hihO1OqkwQfIQQKBQKDAwMYMOGDSgvL4fD4aDWNBBr7UwqIITAotOifEkd7v3Wi+leTpYk8bhd0CsVuOnhJ7B8/cZ0Lwe9rU0QFyVYuxeCxDdLt/Xzw9RTucFAACPDA3j4pddn1CL6fV7olYpwJIwDsFrj1dvSCGlxgh3Pk5hrH+ppPpPwwykhBEa1Eq9993ls27IFzc3NqK+vT8jVIBOZXstHy/MvdI+hldLNRvgikxV8GUAmRPgYhkFnZyfMZjO2b98OiUQC4LwYpdFFzOVlht+T1+2BWT+Cmx56AktWrk73crIkiVGjRm5hAZ59/xcZ4SnmsNtg0esS9okLQeIcrdbTfCbxBpEIBPw+aBXDePzVd5AfoVmr+cgBFEql1M4XjVCaPhE/wxnMsY/1NJ9JqMt5Quwp8PYrL+OCDevR3NyMZcuWobaWfoo9U4jX8y/0/6cTuv/RatrICr7IZAVfHHA4HFYK6NMt+Hw+H1paWhAMBtHQ0DDFJDn0xEVF8GVAiN1mNkGQk4On3nw/45pkssSHz+OBVjmEq++6H+u270z3csIc3/sRHd9GgphtWRx2G6xGA/IpRfh8Xg+MGg2eeus9CIWRTdOHu7vCdjhs03hwP2QldIyko+1CHrcrIe89QgiMqmH8+K3XsXLFCjQ3N2PlypWork5g1u88JRnPP4ZhqDWCZOfozk5W8GUA6Zy24XA40NzcDJFIhA0bNszw0Zp8QSZ7MaazpiIYCMCgUWHn1Tdgy6VXpG0dWehg1mnB5fHwzI9+nhLvt1ghhEA90Etlhi1DSMypxeN7P6IT/QLg8bgxatDjqbfen/WztRj0GDUbp52Tvetb1d9DTcxGe2RPxHuPEALd8AAevPMOgBA0NTVh2bJli0rsRSIezz+/3091jm5W8EUmc3bKRUy6InwWiwUtLS2ora3FihUrIgqyybYxyd5YuXGkp2jisNvgcTnx8EuvR0xNZZk/+H0+aIcHcMnNd2DzJbEJ91Ta2gx3dyJIaTY2h8OJOcKnGeyjYrbsdjowbh/Fnjfei3oDbjy4D6UVVVN+xtbznF6lwLjdRk3wRXvwVPX2ILcg9j2CEAKDcgj/8tMPUFxcjO7ubuTl5WFwcBB6vR4lJSWQy+WQSCSLuolgLs8/t9sNLpeLQCCQtOdftkt3drKCLw4WUkpXpVKht7cXa9euRVVV1ayvC21SNNbH5aZ2wyMMA6NWg2XrLsCX7ro3pefOQh+rUY9gIICvvf3jWdOMkUnd9675yAGUVFKK7JDYaviGuzvg9/uTPp1zfBx+jxtP/uBHcyyLYGR4MILAZOdzbjpM8TPF7ILPpBuBzWJBeYyCjxACg2II/98vfgq5XI729nasW7cOFRUV8Pv9sFgsMJlMaGlpAYfDCYu/4uLijIpKp5rpqd/x8XH09/ejsrKSiudfVvDNzuL91mUQqRR8hBD09PRAq9Viy5YtKJqjkzBkG0Mj5ZzKCJ/H5YTVaMCdTz3Lii9ZltQR8PsxMjyA7Vdei13X3pju5czKxJQWNSqWLKV2zFganVo/P4LSJAWRw24Dh8vFwy+/Pudre1ubQFIUrWKCQeiUQygupzMSjzDMrFHTxkP7Y/beIwwDg2II//HPv4RUKsXZs2exfv16lJVNiGCBQIDy8nKUl5eDYRjY7XaYTCYMDg6ivb0dRUVFkMvlKCkpQV5eHpW/bT7icrnQ0tISHjU33fYlka5fl8uF4uJitpc+L8kKvgwgVYIvEAigra0NLpcLDQ0NMdc5cLlcOoIvRXrPatRDJC3CU2++nxFdm1kSx2Y2wuNy44kf/CiJdHxqUrrNRw5CQvFGQ2KI8Pl9PuhUw0mJzFGzETm5ubj3Wy/F9PqeptMokkdooGBBA3aePgGegJ6ZM0MYCCIcj2EYaIcHY6q9ZBgGRuUQ/vv/+2cUFBTMEHvT4XK5kMlkkMlkWLlyJVwuF0wmE0wmE/r6+lBQUBAWf4sp9etyudDY2Ijy8vLwXOHQ355I48fk42YjfJHJCr4MIBWCz+Vyobm5GTk5Odi5cycEAkHM76XlE8jlcsFma4rf54NxRI0r7rgba7dsZ/FMWdgmGAxgZGgQGxt247Lb7kzqWKm6fQ51dyC/kKIPHgfgcqPX8DUe2g9xUeIi02o0QFZSgtufeCam13vdbuhVyri7WBOlt60JUoqG6IRhwBfO3Pt6WxpjElohsfe///dX4PP5aG9vx4YNG1BaGnsHcX5+PpYsWYIlS5aEU79msxmtra0AEBZ/Czn163a70dTUhLKyslnrx4H4Gj9C/8sKvtlZmN8mlmDryYtt4+XR0VG0tLSgvLwcq1evjjvqRS2ly6LgGx+1IhgM4InX3o6zvitLpmG3WuCw2/DIS69DJJMlfbxgIPn6trmwGPSwmYwopzjlghAyZ93rUOfZhM2WzXotKpYsxY0PPBbze84c+jRlE2lcjnGYtCPUuo+BCdGQmz9TDPQ0ze29xwSDMCqH8Pv//r8AgM7OTlxwwQUoKUncDDpS6tdsNodTvzKZLFz7t1A6Tz0eD5qamiCXy7Fy5cqY76uxev6ZTCZWR/zNZ7KCLwPg8/nwer2sHFur1aKzsxMrV65M2O2dVkqXDbnMBIMwjqixbscuXHLjbSycIf1k0oQSNmGCQYwMD2LVhVtwzd0PUDuuIIf9B4AzB/YlXUc3HSYYjNqlazXoMWoxJ9S9ahxRY9m6C3DVnV+N630Dbc2QRErnssDpA/tQRKHzeDIMw4A/TQx43C7oNcqowpIJBmFSDeNP/++/EQgE0NPTg40bN1KtFZuc+l2xYgVcLhfMZnM49Zufnx8Wf1KpdF6mfj0eDxobG1FUVITVq1cn/DfM5vnX3NyMtrY2KJVKamteSGQFXwbARoSPEIKBgQEolUps2rQpqadQWilnHpcLmrEWl2McY6NW3PPNF6iMXMqSPsZto7BZTLj/29+jZrAbgsNydzjDMNAqBiArSd57bwqERPU6Obn/E1Qk0JCkVylwQcNuXHT9zXG9z6BRw+V0QjJLgI/2g4l6oA+FYgnVYxKGgVCYM+VnTYc/g1Q++/4RDAZgVg3jz7/9DbxeL3p7e7Fp06Y5G96SJT8/H7W1taitrYXf74fVaoXJZEJbWxuAidRvqOs3nhKddOH1etHU1ASZTIY1a9ZQFaxcLhft7e2444478NZbb+GFF16gduyFRFbwxQFbT1S0jZeDwSDa29tht9uxY8cOiETJueHTa9qg00BBCIFFr0NZdU12Du48hzAMRhRDqFu1Fg9855V0LychelvOgAP6zUEEHPB4kbdoQghGhgYgr4ive3VkeBANV1+PLZddFfd6Th/Yi7IoUTCf1x33MWdjZHgQrvExdgRf7tSIr7KvB3kR0rzAhGG7RaPAR7//XzgcDvT19eHCCy+EjEKpQTwIBAKUlZWhrKwMhJBw1+/Q0BA6Ojogk8nCtX+ZmPr1+XxoamqCRCLB2rVrqd9Lu7q6cPPNN+Nb3/oWXnjhhXkZ/UwFWcGXAfB4vHD3UbJ4PJ6w71NDQwOVWgZaEUgehUiLz+OBSTeCGx94DHWr1yZ9vHnBAt28HGN2WHQjuOdbL9IZRZYmuptOQ0o5KgngnA9f5F/1tjSCE8cDFCEEmsE+XPnle7Fu2464lzLRxTqE0qrZ09bcWcRpIrQcPQh5xez+oInCTBN8Jt0I7BZTRMEXCPgxOqLC3//wO9jtdgwMDGDz5s2Qpmh+8GxwOBxIpVJIpVKsWLECbrc73PXb39+P/Pz8KV2/6XYqCIk9kUiEdevWURdjfX19uPHGG/HEE0/glVdeyYq9KGQFXwZAK8I3NjaG5uZmFBUVYf369dQudBrrI4SAy+GCMInP5LVbTOAJhNjzxnsLtnstEgtt+yKEwKhRo6y2Fvc//3K6l5MUbqdj4m+h2FhwHgIuN/L3vOPUcRSXxZZCJoRA1deDmx5+EsvWbUhoJZ2njkOYmzP3CykQDAagUykgp+S9N5npEb6mQ/tRWjUzLR7w+2HXafDxH38Pi8WCoaEhXHjhhWkXe5HIy8sLp34DgUC467etrQ2EkCldv6lO/fr9fjQ1NaGgoIAVsTc0NIQbb7wR9957L958882s2JuDxXPXzGBo1MgZjUa0tbWhvr4e9fX11OsjkhF8oW6qvLxcWMfds6apZmNiDq4a2790DbZd9qWE15El/XicTpgNWtz62NdRs2xFis7K3k3gzMFPqYw0iwQhkesPvW43DBo1Kuvm9t5jGAaqvh585ZnnUVlXn/BauppOz1knS+tTbj95bEadHS0YQsJd/AzDYCSC957f58O4YQQf/+n3MBqNGB4exubNmyGR0E0vswGfz5+R+jWbzRgeHkZHRwekUmm48YNt65KQ2MvPz6cagAihVCpxww034NZbb8X772c9V2MhK/jigM0avkQFHyEECoUCAwMD2LBhA8rLKReOI7mU7uSWeVFhIRibEzGOBwUAOMfscDsdePilV+l6nGVJKYQQmLQayEpK8fUf/iTFmzN7xsuqvl4UiNn6XpKIPnynPvsERaVzi0wmGISyrxsPvvAqissrEl6F2+GAWTcyt2CktD0OtLcm5S0YjYkI34SYjOS95/d54TDq8cmf/witVguVSoUtW7ZAzNq/MXtMTv0uX74cbrc73PXb39+PvLy8KV2/NK9Jv98f9n3dsGED9etdq9XixhtvxDXXXIMPP/wwK/ZiJCv4MoBEBR/DMOjq6oLJZML27dtZewJNJKU7eUQOMCEaCwsLwQS1Mb/fNKJG3ep1uOYeehYd85H5nqbwuF0wjWhwwwOPYtm6C9K9HGqMDA/COW5jTfAREnm0mqKnCyJp9KaBYCAAVX8Pnnj1HRQmmYY8uf/jGNOryX9PnWN26BTDqGYp+ksICdv09DRP9d7zeb1wmw345M9/gEajgVqtxpYtW5JuessU8vLyUFNTg5qaGgQCgXDXb3t7OxiGCXf9yuXypFK/gUAALS0tEAqF2LhxI3UxZjAYcMMNN+Ciiy7CP/3TP2XFXhxkBV8GkIjg8/l8aG1tRSAQQENDA3Jz2fMaizfCFxqAPXkINofDgVgsBsPMfRy3y4lRowF3PPkMVSPbecs8FXyEEFgMOuQXiPD0Oz9dcBtz89GDkFfQ9d6byswIn0GjhmPMFlXwBfw+aAYHsOeN95MYR3ceVV8PaxG36ZzY9zFKWZziMWHLkjvhvac+773n83jgHTXhk7/8EUqlEiMjI9i6dSsKKXx+mQifz0dpaSlKS0tBCMHY2BhMJhMUCgU6OzshlUrDtX/xpH5DYo/P5+OCCy6gfs2bzWbcdNNN2LRpE371q1+FffiyxEZW8MVBpqR0nU4nmpqaUFhYiM2bN7PewMDj8eD3x+agF4rqETKRRpt8wcvE4jn/TotBB5FUlp2DO8/xeTwwjqhwxZfvxbqtaR5zx0JGNxgIQK8cZqWTNAyZaWV0+rNPUFYdxRrF44FOpcDX3/kxlYkzI8MDcDscsQk+CvujeqAHUhaNnRky0bQx2XvP6/YgMGbB3//0BygUCmi1WmzdunXRjOficDiQSCSQSCQzUr+Dg4PIzc0Ni79oqd9gMIjW1lZwuVxs3LiRuhgbHR3FLbfcghUrVuC///u/F1XjHi2yn1gGEEqZTgxLj75pWiwWtLa2orq6Oq6xNMkQa4RvcmQvNNh6MhKJGGSW4wT8Phg0alx+251Yt62ByrqzpAerUQ8+X4Cn3vpxRmzKoYcPmpw9/jly8vKoH3cyBGSK9QoTDEKrGJ7VGsXjcsGsG8HT7/yU2ufeeHA/SqpTY5mj7u+F103Pyy8SoS5dZW838goK4fG4QZx2/P1Pf8DAwAAMBsOiEnuRmCv1W1xcHO76Ddl+hcQeAGzatIm62LPb7bj11ltRWVmJ3/72t/PCaDoTSf9unCV8cQSDwagbtVqtRk9PD9asWYPqajZTSVOJpYZv8lzDSGIPAEQiEZgIN1+ryQAOgCd+8DaEKRiDNd+YLwldv88Lg1qF3Tfcik27L0v3clhloL0VIim7kxZACDiTavjaTx2b9fqYmDpjwdffptcQM2GPMhw1okiTpiMHUMKyHyPDMBgftcJuNYPD5YLrduDPv/9f9Pf3w2QyYevWrRlpXJwuZkv9KpVKdHZ2QiKRoLi4GGazGQCwefNm6mLP4XDgjjvugFQqxR/+8Afk5KTGHmghkhV8GcBcgo8Qgp6eHmi1WmzZsoX1kT7TmcuWZXIn7mxiDwDEYjHIpBo+hmEwMtSPjRddhktvvp36uhcM86CGz2Y2gTAMnnzjR1RSiTShHQUfG7XCrNeyXl9KAPA452+ePU1nIJXPnGvmsNvgdbvx1BvvUz1/27GjyMuPvWEhmU85GJjw3os2z5YGhGHQdvwoxLJiCPxu/OF/f4ve3l5YrVZs3boVeSxHbecz01O/Ho8HRqMRQ0ND8Pv9yMvLw+DgIORyOWQyGZUHD5fLhTvvvBMCgQB/+tOfWK1VXwxkBV8csJU+DR03Uto0EAigra0NLpcLDQ0NaXn6nC2lG6kTN9pnJBKJEAxMvNZht8FmNuH+b79CfXbqgiODBV/A74dBrcTWK67Gzi9dl+7lRIRQLuI7/dleyCtTEGEnBBzexL+9c3wMZr12hjXK2KgVHACPff8t6qfva22GOI6Hy2Rm6bZ8cRgFKeqGVfb1oKJIiv/5za/R09OD0dFRbN26NSsm4kQoFMJisSAvLw87d+7E+Pg4TCYTOjo6wqnfUNdvIhOfPB4P7rnnHvj9fuzdu3fBNtCkkqzgixMOh0O9JojD4URs3HC73WhqakJOTg527tyZtrqFSCnd2TpxoyGRSODzuDEyNIDKpfW4/9vfY23NWdhn1GREMODHo6+8hbxMrnmieLkSQjAy2A9x8cxIG20IAM65CN/JfX+HvHJqg4jNbEJ+YSG+8sy3qZ/bOWaHRa9F5dJlsb8pieeS/tZm9lPkmKhzLCoswO9+/V/o7OyE3W7Pir0EYBgG7e3t8Hq92LJlCwQCAXJzc1FSUgJCSFj8qVQqdHV1QSKRTOn6nete4fV6cd9998Fms2H//v3z0gcxE8kKvgxhuqiy2Wxobm5GWVkZ1qxZk9aO1ekRvmiduNEoLCyEZmgAD7zwfay+cCsra12IcDOsii8YDGBkaBAXNOzG5bfdme7lpJShrnb4YuxYTxpCwuUeqv7ecFcpAFiNBhSVluG2x7/OyqmP7/0IpSmab+yw22Ax6FBVv5z188glInzy1z+jo6MD4+Pj2Lp1a7YmLE4YhkFHRwdcLhe2bt06IxARsuASi8VYtmwZPB5PuOt3aGgIOTk5YfEXKfXr9/vx8MMPQ6vV4sCBAxk5zm6+khV8GcLkCJ9Wq0VnZydWrlyJ2tratBvvThajc3XiRiMvLw+lldU4/OffofP0CVTU1mHjxZeiQJR9eotKBqV07VYLHHYbHnn59TnNfxci7SePQZ7E1Ir4mEjpqgZ64fOc714167SorF+GG+57hLUzqwf7IIvXHiXB7+nxvR+hrJo97z0AcI2PoUyUj//47X+ho6MDTqcTW7ZsyYq9OCGEoLOzM/z5xZJ1ys3NRXV1NaqrqxEMBsNdv52dnQgEAvD7/ejv78ftt9+O0tJSPP744+jv78ehQ4dQXJwa/8fFQlbwZQg8Hg+BQAD9/f1QKpXYtGkTSkqiz65MFaGmjVg6cec6ToFIDPk5WwnVQC/ajh9FcXkFSqtqsPGiS7P1fJHIAMHHBIMYGR7Eqgu34Jq759fkE1oZXZ/XA4NKgdL/v737jo+qSv84/plJIaT3hBRI6J1AQgcBBWmBTEBUREFsa8HuuljWhhXLIoLioqziiigJvdcAKiKThJ4C6aTMTHpvM/f3B5v5GQghZWYyCef9eu0fO87cexIyd75z7jnPY+RwUkeSJOQyC2KiDunXDKquZNB7yBBunzPfaOdNS4ijuqrKaMe/VkZSIq5G6kcMV29P+zjb881XX3Lu3DnKy8sJDg5u0bqyW1ld2KubGW3J78/CwgIPD496t34PHjzIunXreOWVV3B0dMTS0pJffvnFbD7/OhIR+JrJGGv44GoYSk5OpqqqipEjR5pVO5+6W7qtCXt1/toMvpNNZ/1OR03mFTau/BgnV3c8fP0YNGqs6LLxP20d90oKCyjKy+WBl167pQN5dNQh7E2wzqyOJF39kM1JT8XLvxvZ6akMGXsbY6fNMup5Y44dxqNFBaWb/5eaEneBmqrKFpyraUqLi+jm7sKaLz7nzJkzVFVVNXgbUmicJElcvHhRv+bREGG57tbvnDlzUCgUPPTQQxw6dIhhw4YRGhqKp6cnoaGhhIaGMnHiRDEbawCilYEZqKqqoqysjOrqakaNGmVWYU+SJCwtLamuriYxMZHi4uJWHe9GHwmW1tZ4dw2gs709xQX5bP32K3745D32bPiO1PgLRgnZ7UYbJT5Jp+NK8mVcPLx4+sMV7TbsGerXlxp/wSCtyppMkjh9PApbB0cyky8zasp0o4e92poactJTW7RmuCXfAc/8dhQPH+OsFSwtKqC7lxtfrVzBmTNnqK6ubvJtSOH/SZJEXFwcBQUFRrkNrtPpePnllzl58iRKpZJ9+/aRm5vL6tWr0Wq1PPLII6xfv96g57xViRm+NlZSUkJ0dDSWlpZ07drVrL7F1K3Xs7GxYfDgwajVas6cOYNMJtMX42xuvSVZE54rl8v1a3rKS0rY/8sGrKws8fTtSveBg+gzJBj5LdRDsTXlLlqqrLiIPFUO9z77d7xMtHjfnGmyMynKy8XG1rS7kS+di6UwV82UeQvoFzLS6OeLPXYYeyfnFr1WW1vbrOfX1tSgyszA0wglbkoKCujb1Yd/ffwRp0+fRqvVMmzYMBH2mqmuBmxdnUJD72bW6XT885//ZNu2bURFRREYGAhcXe89Y8YMZsyYwerVq6lt5t+W0DAR+JrJkBso6gJU9+7dKS4uNqtZrGt34tYFPJ1OR2FhIWq1mgsXLqDVavHw8MDT0xM3N7ebVllvybo/jy4+wNU1VCf27uK3Xdvx9PWja+9+DBgxGqsOvhbnr7fBjU2SJLLTUvDu2o1nX1xpsvMakyHeVcrD+43eBeJaEnD53Bnuf/FVuvcfaJJzXjp3usWBr5NN84oWn/4tis5GCNDFBfkM7N6VTz54n9jYWCRJMknP8Y5GkiQSEhLIzc01StiTJIn33nuPn376iSNHjtCrV68GnyeTyURQNxDxDmgDkiSRmprK5cuXGTRoEN7e3pw9e7ZJ/WpNobGduHK5HFdXV1xdXenTpw/FxcWo1WoSExOpqqrSb7f38PBo8E3a2uhSd1tRq9Vy9vfj/HlwDx6+/vgE9GDI2PEmn4ExCRNt2qgoK0WdmcFdTzyLX/eGL763Ip1OR1ZKMq5e3iY9Z6FGxUOvvo1fD9P8WxTn55Gnym7xv31TZu//KvnCOYPv9C7Oz2Nonx68/87bxMTEIJPJjNLuq6OTJEnfbi44ONjgHUgkSeLjjz9m7dq1HDlyhH79+hn0+ELDROAzMZ1Ox8WLF9FoNIwYMQInJyfgas9Ccwh8zdmJe22rnbKyMtRqtb7YpouLi35msO5WtSFnSB1cXHBwufqBkXzxLLG/HsHNqwte/l0JGjcRRxfTtqAzFmPHPUmSUGWk4eLhyTMfrWzTmo/G0bo5vovKk8gtTHep1Gm1pCXG0amzrcnCHsDve3fg3TWwxa9vzlu7uCCfvJxsg27MKs7PY8SAfrz9xmvExMRgYWFBUFCQCHvNJEkSly9fJicnxyi9hSVJYuXKlaxcuZIDBw4waNAggx5fuDER+Eyourqa06dPU1NTw6hRo+p9a7pR+zJTampP3IbIZDLs7e2xt7ene/fuVFRUoFarycnJISEhAUdHRzw9PZEb6fakja2dfnYvOz2VC599gIunFy7uHgybOLmFuw7NgzFv9VeWl6PKSGPW4r/RY0AHvfC28teXEKtssIetMWhra0m/lMAdd81n5/pvTXJO+P/Q7+hqmp/T0O3pinJzGTtsEK8v/QcxMTFYWloyZMgQEfZaICkpiaysLKOFva+//pqPPvqIvXv3EhwcbNDjC40Tga+ZWjpDVVZWRnR0NPb29g2uJ6mrw9cWmtsTtyk6d+5Mt27d6NatG1VVVWg0GtRqtUl+RmvrTvqZg+LCQn754jNsbG3x8PUjaNxE/Hv2bvNi1s3R3FtlTSFJEprMK9g6OPDM8o44q2cY5aUlaDIz8PLvZvRz1VRXk5lymSff/YRd67/BydV0RWdTLp6nprq1HUSa9p6SJInM5Ms4GujnK9So6enrxcRxY/ntt9+wsbFhwIABIuy1QFJSEpmZmQQHB2Nn4HaJkiTx3Xff8dZbb7Fr1y5GjRpl0OMLNycCnwnk5eVx+vRp/Pz86N274bDRVoGvJT1xm6tTp076SuudTLzBwtLSEp/Aqw3na6qr2fXDN8gtLPHy8aNfyCh6DRlq9mHHwsCLzasrK8lKS2bavQtNsvOzrbXmz/nPQ/twMWJR4DrVlZXkpKfy1PufggTqK+km3Zt97o/fcGttB5EmDjg1/qLBCjsXatTcOX4Uzy1ZwqlTp4Cr63uPHz+Oq6urfj2x6JV7cykpKWRkZBASEoK9gcsPSZLEhg0bWLp0Kdu3b2f8+PEGPb7QNCLwGVlGRgbx8fH069cPP78b38K4tpeuKbS0J25rtHVPYG//AODqXb5jOzdzePNG3H386DU4iEEjxxo8XBmCjKvFvg0RxHOzs7CwtOTpDz+/ZXYtamtbvlQi43Ii9o5OBhzN9SrLy1FnZvDUB//C0tKSX3dtw9HNnQK1yqjnrVNTXYUqIw0P39bdYm3qX+e5P47j/r+d961RoFYx647beOrxx4mOjsbBwYFBgwYhl8spKytDo9Hol5Q4ODjow5+9vX27muE3hdTUVNLS0ggODjZ42AOIjIzk+eefJyIigkmTJhn8+ELT3BpXfANq6oWibkt73fS4q2vjGwj+2kvXFFrbJq2lzGk2zd37/z90Th+P4rdd23Dv4kO3Pv0ZdtvtWJvJrICFlWWrA19NdRVZKUlMmH0XQ2+7tS64Wm3LZs6vJF+ivLTEqIGvvKSYksICnv5whf69kXE5AVt7B4oL8o123r+KOXoIOydD/Iw3//usqa4mOy0Vz1aWuMlX5zBn6mQee/ghlEol9vb2DBw4UP87tLOzw87OjoCAAKqrq8nNzUWj0ZCamoqVlZU+/DW3jmhHlJaWRkpKCsHBwUYp+r99+3aeeOIJfvrpJ6ZNm2bw4wtNJwKfEdTW1nLmzBnKy8sZNWpUk9ZCmDLwtVXYA7Aw02/WTm7uOLldXbB++fxplEcO4OLphW/3ngy//U7sHBzbbGwWllZIOh208IMpX5WDTqflyfc/xdraPEKsKclkLfu9xR47Uu9LgaGVlxRTU13N4+8s1z+Wl5NNYa4G7652JrulmxJ/EVt7A3zQN2HAsb8ewda+de+lfFU2d8+azuIHHkCpVOLk5ET//v1vGNysra3x8fHBx8cHrVZLQUEBGo1GX0fUzc0NDw8P3N3db7l6b+np6SQnJzNs2DAcHQ1/jduzZw8PP/ww33//PbNnzzb48YXmEYHPwCoqKoiOjqZTp06MGjWqyRcQUwW+1uzENYT2cCvFzsEJO4erMx456amse+8NnNzc8O4awPDbp5q8xZilpVWLdurW1tSQmZLEyDunM3rKDCOMrOPS1taScSmRLgEtL1PSmNKiQiwsLHlw6Zv1Hj91eH+rZ7+aI1+dQ6FajVdX429KAUi5eA77Vswm5uVksXCugvvuvYfo6GicnZ3p379/k68rFhYWuLu74+7uTt++fSkpKdHP/F24cAFnZ2c8PT1xd3c3+A5Vc3PlyhWSkpIYOnSovjyYIR0+fJhFixaxdu1a7rrrLoMfX2g+EfgMqLCwkJiYGLy8vOjXr1+zbhUYO/AZYyduSxhjx6kxdbLprK+FVpSXx38/+wBbe3u69e7HwFFj8TbB7k1La+tmN5gv0Kipqqzg8bc/wqaDf3AZw6kj+7F3djbKsYvz87FzdOSuJ56t97hOpyMr9TIuHqYr8Kw8fAAPH8OULLpZC8DCXA35KlWLa+/lZmfyyPx53DVnDkqlEldXV/r169fi65hMJsPR0RFHR0d69OhBRUUFGo0GjUZDYmIidnZ2+lu/jo6O7eLLalNlZmaSmJjIsGHDcDbC3/mxY8eYP38+q1atYv78+QY/vtAyIvA1043e9NnZ2Zw/f55evXrRrVu3Zl8cjBn4TLETt6ks5DLavrx0y1haWeHXvScARfl5bP3mS+wcHHH38aXfsOF069P0mYZmndfSkqqKpm3o0WpryUxOYsi4CUycPdfgY2mfmj87mng6xuBdIAAK8zS4eXVh9uK/Xfff4mP+RIbpvhBJksSVlMu4uBtoxvomf/qnDu1rce293KwrPL5wAWGzQlEqlfoZOkO+3zp37kzXrl3p2rUrNTU15OXlodFoiImJudri8X/hz9XVtV2XfMnKyiIhIYGhQ4caJez98ccf3H333SxfvpxFixZ1qKDc3onA10qSJJGUlERqaipBQUF4eHi06DjGCnxtsRO3MRYyebsNfH8ll8vx8usKQHlJCQc2bUAuk+Po6ka/kJH0Dx6B3EAfClbWnZB0Nw8tRfl5lBUV8dBr7+DQwn6oHZGume+rovxcSgoKDB748tUq/Hr0ZOq9Cxv87wkxSpzrLRcw7gflpTMxTfq7arobj7cuXDq7Nf/6qMnM4JlHFjNj2lSUSiVeXl43LG9lKFZWVnh7e+Pt7a3vH67RaEhISKCqqkq/7s/DwwPrdtTLOzs7m/j4eIKCgnBxMfwXmujoaObMmcOyZct4/PHHRdgzMyLwtYJWq+X8+fMUFBQwcuTIVu1wMkbga8vNGTdipEYbbUoul9db3H/ywB6ObovA09ePwH4DGTJ2Alat+FCwtLJCkm48w6fTaslMSaLPsBCm3vNAi8/TUVn+r61fU53YuxNP/64GHUNeThY9Bw1loqLhtUyV5WWorqSbpMBznQvKk7h6Gq7GYGNv7eSL59DWNH+3tOZKOn9f8ji3T5yIUqnE29ubXr16mfRa9tf+4b1799aXfMnMzCQuLg5HR0d9+LOzszOL62xDcnJyiIuLY8iQITetGtESZ86cISwsjNdee41nnnnGbH8PtzIR+Jqp7o+4qqpK35x79OjR+l6xLSWXy/W3Xg0xC2eOYQ/afobRFP76IXpReZI/DuzBzcsb/559CJk0Wd8CrqmsrDvdcNNGSWEBRXm5PPDSaybfTNJe3Gxt2V9JksSVpEu4GXB3rjozgyFjb2NUIxtnTh3ef83snnFVVVSgzkjD08+AwbaRX3NLCjurM9J49bmnGT9uLEqlEh8fH3r27Nmm17K/tpAMDAzUdxHSaDQkJydjY2OjD39OTk5mc71TqVRcuHCBIUOG4OZm+A4uFy9eZPbs2Tz//PO89NJLZvN5I9QnAl8LlJSUEB0djYuLCwMHDjTIeo66Yxgi8LX1TtzGmMsF0FQcnF30twbTLyUQc/Qgbl186dItkJBJU3B0ufk3batOna6WZfkLSacjMzWZwD79Wfj3140y9ltR4pmY1rberScnI43RU2cSNHZCo89LS4y/vvSPEd+2yqgDRuib2/CA6wo7N3X3sSRJqDPSeOsfLzJy+HCUSiX+/v50797drK5lUL+LkFar1a/7O3PmDADu7u54eHjg5ubWZoXO1Wo158+fZ/DgwbgboSd0YmIioaGhPPbYY7z++utm928k/D8R+JqppqaGP//8k4CAAINegOoCX21tbYsvDOayE7cxFnI5ks4wXSPam852dvj36guAJjuT9cvfxdHNDS9ff4ZNvAOPLg3vlrTq1KleF5ay4iLyVDnc++zf8TJhCY9bwbkTvxqk9p4kSaQlXGTa/EU3bV+XlZZCaVGhSWs9pifEYWNnuI4KkiTd8MtczNHD2DdxTenVsJfK+6+/ytCgIURHR9O1a1e6d+9usLEai4WFBZ6ennh6eiJJEkVFRWg0GpKSkjh37lybtHrTaDScO3eOQYMGtXh9eWOSk5MJDQ1lwYIFLFu27Ja8rrcnIvA1k5WVFWPHjjX4G7YunLW0vZo57cRtjI2NDVJpJbJ2vMvNEKytO+HbvQcAxYUF/LLqM2ztHPDw82PImNvw6/H/65Ss/3dLV5IkstNS8O7ajWdfXNmWw++QqioqUGem06Vb68KFJEmkJcYT/ugSAvr2v+nzY48exqOFu1dbQpN1haL8PMMGPp0OuUXDHycp8ReaVNhZkiTU6Sl8+u7b9Ovbl+joaLp160ZgoHFqIRqTTCbD2dkZZ2dnevXqRVlZGbm5ufpWb/b29nh4eODp6Wm0Vm+5ubmcPXuWgQMH4ulp+OUCaWlpzJw5E4VCwccff3zL3b1pj0Tga4HOnTu3qBDuzbR044a57cRtjIO9HZnFZQbbwdoRWFpa4hNwNWRUVVSwa/03WFhZ4unblX7DhmNhZUl5STEFGhXznnwO38CebTzijunkwb24eLRuE4NOpyMtMY75z75MlybUm9Nqa8lKS25wVtFYX9eURw7gYeCZYUmSGuxDna9WUaBR6XtYN/Z6VVoyKz98n549exAdHU337t3p1s10m1iMqa7VW7du3eq1ektLSzNKq7e8vDzOnj3LgAED8PIy3MacOllZWYSGhjJ16lRWrlxpss+c1atX8/HHH5OTk8OQIUP44osvGDFixE1ft3HjRubPn09YWBhbt241/kDNlAh8LSCTycwm8Jnr5owbcXBwQKvNxvLW6mDUZHK5XL9TU6fVcnR7JLlZmdTUVDN78eM3/eAUGtDE92pq/IVWlWLRabWkJcax+JW3mhwcTx+PwsqqdRu+muNqcedkXD0NW9z5auC7/kvcqcP78OzS+OxlXdj76tPldO3alZiYGHr06EHXrobdKW0u/trqTafTkZ+fr2/1Vltbq1/319JWb/n5+Zw5c4Z+/frh7W34It4qlYqZM2cyduxYvvrqK5OFvZ9//pkXXniBNWvWMHLkSFasWMHUqVNJSEhodAYzNTWVl156ifHjx5tknObMfKeCbkHNDXztLewBODo4NLsu2q2qsrycsuJixswMw69HL07/GsXXby1l05f/4uSBvVRXNq/7hnBjqisZlBYVtfj1tbU1pCXG8dgbHzRrlvDS2Vicbrhr0vDv5zjlSWRyw8+uS5IOy2vCiSRJZKUkIW9kTbIkSeSkJvHvFZ/h7+9PTEwMPXv27LBh71pyuRx3d3f69evH+PHjCQkJwc7OjrS0NI4ePYpSqSQtLY3y8vImHa+goIDTp0/Tt29funRp3q7opsjNzWXWrFkMHTqUdevWmbQA9Weffcajjz7K4sWL6d+/P2vWrMHW1pZ169bd8DVarZYFCxbw9ttvt4t1oMYmZvjMSHMCnznvxG2Mo6MIfDcjSRLqzAzsHBx5ZvlKMpMvc/lMLE4e7ji5Xd1ld+lcDKeO7MfNyxufwB6ETJpi0kX/7UoT3hsnD+zBq4W192qqq8lMucyT737arDZ2pUWF5OVk4xPYo8H/Xl3ZtA/55og/rcTF3fCL9yWdhMU1a/gunY1t9Hom6XTkpCXz/VercHNzIzY2lt69e+PnZ7r1jOakoVZvdbd+L126hK2tbb2SL9de8wsLC/W/Qx8fw5UVqlNQUMDs2bPp1asXP/zwg0l3HVdXVxMdHc0rr7yif0wulzN58mROnDhxw9e98847eHp68vDDD3P8+HFTDNWsicBnRpoS+NrDTtzGODs6tnhjyq2gurKSrLRkpt27UL+709LK6rrfmZ2DE3YOVxueZ6elsO79N3F0ccXbvxsjJk9t9Vq0jqS2prrR/67TaslKS27RjufqykpyMlJ5+v1/YdnM4ton9u5qtFSJ3MDrHirKStFkXtF3iDEkSdJhcc14L576AzevhmeZdDod6tQkfvzmaxwdHfWzUsYIKu1V586d8ff3x9/fn9raWvLy8lCr1cTGxl7X6q20tJTY2Fh69epllMBcVFSEQqHA19eXjRs3tuhWc2vk5uai1WqvW4/o5eVFfHx8g6/59ddf+fbbbzl9+rQJRtg+iMDXAsYKWDcLfO1lJ25jnJycROC7gdzsTCysrHj6w8/rfXu2tLZu9HfWyaazvsdvcUE+P638BEcXVzx9/Rg8enyLm9V3FDdrH3buj1/p1Klzs49bWV5Gniqbp97/V4tmO9IvJxi008XNKA8fMFzf3GtIklTvlm51VSU56akNdg6pC3sbv/uWzp0769ebGeMWZEdhaWmJl5cXXl5eDbZ6kyQJLy8vo+zGLS0tZe7cuTg7OxMZGdnqJgOmUFJSwgMPPMDatWuNUnuwvRKBz4w0Fvj+ul5PJpOZ9U7cxjg6Ol5XRPhWV1NdRVZKEhPD7iJo/KTr/ru1tXWTf2eWVlb63aElhYVs+fZLbO3scffxo3/ISAL69G93XxJaS3aT90pczCmcm/mhUF5aQklhAU+++2mL3osp8Reora1p9utaI+1SA8WdDeTaXbrRUYdwbKB9l06rRZ2WTMR/v8fS0pKzZ8/Sv39/o2wu6Kj+2urN29ub6OhoXF1dqaio4Pjx4wZt9VZeXs68efOwsrJi69atJqsfeC13d3csLCxQqVT1HlepVA3+7dT1t581a5b+sbovzZaWliQkJNCjR8NLKToyEfjMiFwubzDwtcfNGTdiZ2dn4Ibt7ZsmKxNJp+XJ9z/F2rrhi6mltTWyFjQhlsvlePtdnWGpLCvj4C8/Ipdb4OnvT8+BQfQJCr5FyuPc+O+trLiIvOxsfAKbvqC7tKiQ6qpKHn/7oxaP6PSxI3iasPZeVloKZUYs7ixJUr3bfGkJF+lsV7/2nk6rRZOezJaf/gugrxFnjLIht4KSkhJiY2Pp3r07AQEBwNWWn7m5uajVapKTk+nUqZM+/Dk7Ozfry0llZSX33nsvtbW17N27Fzu75rWENCRra2uCg4M5dOgQCoUCuBrgDh06xJIlS657ft++fTl37ly9x15//XVKSkr4/PPP8fe/NQvWi8DXAqa8pduRwh5cvaUr6cSmjdqaGnLSUhkxZRojJ09r9LlWnW7cS7ep5HI57v/r5FFbXcPv+3ZxfNcWPH396da7HwNHjsWqmWvQOoIT+3bh7ttwh5OGFBfkYWFhycOvLWvxOWuqq8nOSGtSnT5DiTl6CHcjBkxJp8Pif4EvLyebfI263s+n1daSm57C1o0b0Gq1nD9/nkGDBhnlFuStoLS0VN+FpC7swdVWb76+vvj6+tZr9Xbu3Dl0Op0+/N2s1VtVVRX3338/RUVFHDhwAAeHmxfONrYXXniBRYsWERISwogRI1ixYgVlZWUsXrwYgIULF+Lr68sHH3yAjY0NAwcOrPd6Z2dngOsev5WIwGdGLCws6q3Vaq87cRvj5OSE9hYPfEX5udRWV/Pom+83aVenpWXTb+k2lavH1Q9aSSdx7o/fOHlgDx4+fvh270nQuAnY2Lbdt3lTSr+UgItH00JHYa4aOwcn7l7yQqvOGX30II5OLa/311w6rZb0xLhWdxBpzNU1fFe/MJw6vB+vv4RLbW0teVdS2RnxC5WVlVy8eJHBgwcbpdXXraAu7NX1F76RlrZ6q6mpYfHixWRlZXHo0CF9UGpr99xzDxqNhjfeeIOcnByCgoLYu3evfoY4PT293S51MhUR+MxI3Qxfe9+J2xgbGxujFK1uD7S1taiupDF4zG2Mn6lo8uuuXsSM9+/v4OyiLzicEnee2F+P4OrVBW//rgwdfzuOLtevxWpPZDf43aUmXKSmumm1DPNVObh18UHx8BOtHk/S+bPYOTm1+jhNdeb3Y/od3cYiSRJW1tZXa++lJul3idfW1lCQmc6uyE2UlZURFxfH4MGDxUL6FiorKyM6OhpfX99m1ZW7ttVbeXk5Go0GlUrF+fPneeuttxg3bhyzZ89m3bp1XL58mcOHD+N2wxqRbWPJkiUN3sIFiIqKavS13333neEH1M6IwGdGLCwsqKqqavc7cRsjl8tvyWrfJYUFlJeWsOgfb2Lv2PwPX1P9CdjY2uH9v9m9nIx0/vvp+7h4eOLh40fQuIm4d2l/ZTOkG6zhizl6GPebdIGAq7un/Xv2Ztp9D7Z6LAUaNYW5mib1ljVUyE84HY2jq3E/uOvKsiTEKvW/7dqaGgqzM9i9OYKioiISEhIYMmSI2YWI9qK8vJzo6Gh8fHzo0aNHqz4XbG1t6datG926daOkpIQHH3yQXbt2MWvWLGQyGQsWLCA2NpaJEye2i125QtPcip+9rWbsNXwdcWbvr262a7IjuVrjLQWfwB48/vZHLQp7bcXauhNdugViY2tHQa6GTV/+ix8+eY+9G77nSvKldj1TW1tTQ05G2k1vAaky0ug5aKhBwh7AH/t34WmEOng3cnVTSpbRzyNJV3c/xsX8iauHFzXV1RRnX2HPlkgKCwtJSEggKChIhL0WqqioIDo6Gi8vL3r27GnQzwUHBwf+9re/ERgYiL+/P9999x329vY8+uijeHh4cPfdd7Np0yaDnU9oO2KGz0xIkoSNjQ1qtZqamhq8vLzw8PDokN+uOl6EbVhxfh5FeRoWvvwGzq3tbtDGwd/S0lJfz6+spJhd67/F2sYGTx9/egcNo8fAIe1q/Ywy6gAON1lHl52WwtDbJjH6zpkGOackSVxJutz0WVID/JOf2Lcbd18T7Ab+X41QVXoqrl5dKFVns2fbZn2XiKFDh+LiYrp1ix1JRUUFSqUSDw8PevfubfBJAJ1Ox8svv8zBgweJiooiMDCQBQsW8MUXX3D69Gm2b9+OUqlk3rx5Bj2vYHoi8JmBuvV67u7ujB07FrVaTXZ2NvHx8Tg5OekLarZVDSRD6+gzfDqdjuzUZAL6DmDRP94wzEHNaDZNLpfrO0RUV1VydHskR7dF4uHrR/d+A+k/fFS9mmzm6PL5s9g3so4uM/ky42bMbrAuYkslno6GFpTXaY2Mywmt/7LRBJIkER/zJ53tHSnXqNi7bQs5OTkkJSUxbNgws1n4395UVlYSHR2Nu7s7ffr0MUrY++c//8n27ds5cuQIgYGB+v8mk8kYOnQoQ4cONeg5hbZj3ldlM2XIN921O3E7d+6sX1tRVVWFWq1GpVKRmJiIo6Mjnp6eeHl50blz8zsDmIsOeJdar6y4iDxVDvc99w88fJpe7uPmzPeXVtc+S6fVEn30EL/v24mnrz/+PXszePR4rM3si0qBRk1Rrga7BtbRSZJExuVEps1fSJ+hIQY977k/fsP9Bq3GjCHtUjzVlRWmOZkkkZ2eirNtZ/Zs38KVK1dISUlh2LBhOJlwg0pHUllZiVKpxNXVlb59+xo87EmSxHvvvcdPP/3EkSNH6NWrl0GPL5gfEfjaSFN24nbq1EnfS7G6uhq1Wo1areby5cvY29vrZ/7asiBmS3TEdYmSJJGdloJ31wCeffFVw5+gnfzKnNz+f/dlfOwpTh3Zj7u3D10CujN0/CSjFf5tjhP7djXYT1aSJNIS45nz2BK69e5r0HNWVVSgzkw3ammUaxm79t5fVVVVUllYwO79e8jIyCAtLY3g4GAcHdv+37s9qqqqIjo6GhcXF/r162eUsPfxxx+zdu1ajhw5Qr9+/Qx6fME8icDXBuqCXt2i96bsxLW2tsbPzw8/Pz9qamr0W+qTk5OxtbXVz/y1tpWOKchlHeuWbnlpCZqsK8x78jl8A3sa5Rw3Ki1izuwcnPTlQK4kXeLs78dx9fLG08+foeMmNbn+XWv99f0gSRJXki/h0aX+7KtOpyMtMY4Fz/2jwf6vrXXy4F59qZKmas2/uLa2lpz0NLyN8LNcq7KiHKmyAuUfv5OWlkZGRgbBwcFmUay3PaquriY6OhonJyf69zd8K0RJkli5ciUrV67kwIEDDBo0yKDHF8yXCHwmZoieuFZWVvj4+ODj40NtbS25ubmoVCpSU1OxsbHRz/w5ODiYZfgz8TImo5EkiZyMNFw9PHnmo5XG3bTQzn9nnWw606Xb1fVBednZ/LRyOY4ubnj6+jF49Hj9hhBj+Otu4oSYU8jl9dvJ6bRa0hLjeOjVd4y23i01/oK+1qEpxBw9bJLZ1MqKcigr5tjBfaSkpJCZmUlISAj29vZGP3dHVBf27O3tGTBggFHC3tdff81HH33E3r17CQ4ONujxBfMmAl8LtPRNaIw2aZaWlnh7e+Pt7Y1Wq9X3UVQqlVhbW+srrTs5OZlF+JMkCV0H6KVbWV6OKiON2Q89Tvf+xm/VU11RbvRzmIqllRVdul4NfyWFhWz59ks629nj0cWPAcNH0q2P4Wc16pw7+TtuXv/fbL22toaMSwk89taHRiuZo7qSQUlRoUkD3+Xzp41+vsqyMmqK83npmSUcP34crVbLgAED2t0SE3NRU1NDTEwMtra2DBw40Chh77vvvuOtt95i165djBo1yqDHF8yfCHwtJJPJmlWH7K+3cY1VX8/CwgIvLy+8vLzQarXk5+ejUqmIjY3Vt9nx8vLC2dm5TcKfTqcjLi6uXvu49kaSJNSZGdg7OvLMciPP6v2F3NLq5k9qh+RyOd5+V287VpaXceCXH5FbWODp15WeA4fQJygYuYXFTY7SNJUV5agzM/AJuLqOrqa6iszkJJ5899MmtbhrqT8P7TXJrdU6xQX55OVk49vdOMsLACrKyuhMDdu3bSExMZGcnBxcXFy4ePEily5dwsPDA09PT5ydndtVuZ62UlNTQ3R0NDY2NgwaNMjgvzNJktiwYQNLly5l+/btjB8/3qDHF9oHEfhMoC164lpYWOj7JOp0OgoKClCpVJw5cwaZTKaf+XNxcTHJBbm2tpazZ89SVVWFTTutLVhdWUlWWjLT5y+ib/AIk57bHGZnjU0ul+P+v7V1tdXV/LZnB4e3/IKXrz8B/QYwZMxtWFlbt/j4J/fvwfV/s3vVlZXkZKTy9Af/wrIVx7wZnU5HVkqSvoyNKfy+ZwdeRrxFXl5WioNcx88//JeEhARyc3MZOXIktra26HQ68vPzUavVnDt3Dp1Op78Oubm5YWnm5XraQt3MXqdOnRg8eLBRrseRkZE8//zzREREMGmS4UoNCe2LePcZkbn0xJXL5bi5ueHm5kbfvn0pLCxErVZz/vx5JEnSfxt3c3MzysWmsrKS2NhYrK2tGT58eLv8xp+bnYmFlRVPf/i5+NAykb/eer345x+cPLAb9y6++PXoTfCE27Gxbd6tw9SEizi6uFJZXkaeOoclH6zAwkCzhzdy/uRvJi1LI0kSqow0o7VSKy8pwaWTBT9+9x3x8fHk5uYSEhKiLxMll8txd3fH3d0dSZIoKipCo9Fw+fJlzp8/j6urK56ennh4eGBtxKDdXtTW1hIbG4uVlRVDhhinePn27dt54okn+Omnn5g2bZrBjy+0H+KTy0hashPXFORyOa6urri6utKnTx+KiopQqVTEx8dTW1tbL/wZ4sOwtLSU2NhYXF1d6dev39Veuu1o10ZNdRVZKUlMDL+boLET2no4tywHFxcc/tepIT0xjtPHjuDs6YlPQCAhk+686Xq1nLQUyotLsLS0pLSoiCeXfWKSLx5x0X/i7NayjSAtaV2XGneB6qqqFp3vZspLinG37cT6b9cSFxdHfn5+vbB3LZlMhrOzM87OzvTq1YuysjLUajWZmZnExcXh5OSkv97YGvGWurmqC3sWFhZGC3u7d+/m4YcfZv369cyePdvgxxfaFxH4WqixNXyG2IlrCn+9IPfu3Zvi4mLUajWJiYlUV1fj7u6Op6cn7u7uLZrVys/P58yZM3Tt2pXu3bvrA297CXz5qhx0Oi1Pvv8p1tbmVTz4VmZja4dP9x4AqLMy+e6jd3Byc8PLtyvDJt5xXckVgJOH9mHr6EBlZQV/e/tDk4yzvLSE3OxMfAJ6tOj11i1Y+nDu5K9Nb93WDGXFRXRxtmfdmq+4ePEihYWFhISENKv7j52dHYGBgQQGBlJZWanfYHb58mV9aSkPDw8cHR3N4suxMWm1Wk6fPo1MJiMoKMgoM82HDx/mwQcfZO3atcydO9fgxxfaHxH4DMwYO3FNQSaT4eTkhJOTEz179qS0tFRf5+/ChQu4ubnh5eWFu7s7VlY330CQnZ3NxYsX6du3L76+9T+A5TI55rxPt7amhqyUJEbdOYORU6a39XCERlhbd8Lvf5sTigsL+GXVZ3S2s8fTz58hY27Dr0cvJEkiNf4Cbl7eLHr5HZON7fc923H3NmS3lcbVVFeRk56Gh4GLLZcWFdLV3YWvV63k/PnzlJSUEBwc3KpWjzY2Nvq6onWlpTQaDTExMfr1x6ZcY2xKdWFPkiSGDRtmlLB37Ngx5s+fz6pVq5g/f77Bjy+0TyLwGZAkSdTW1gJtt17PEGQyGQ4ODjg4OOjDn1qtJi0tTR/+brQOR5IkUlNTSUlJYciQIbi7u193fLlchtZUP0wzFWjUVFdW8re3PzLqzs3maq9/S6ZkaWmp34FbVVHBzvXfYGllSYFGg4e3L/e/+JpJx5Odloq9k7PJzhdz7Ai2Bq69V1pYQPcuHqxe8S/Onz9PaWkpwcHBdDLgxqu/lpaq22CmVqu5cOGCvsd43TKT9r5+VqvVcubMGXQ6HUOHDjVK2Dtx4gR33303H3/8MYsWLRLXDkGvfb972tC1b6K6XbjGLLvSVuzt7bG3t6d79+6Ul5ejVqu5cuUKcXFxuLi46Hf8WltbEx8fj1qtJiQk5IZtleQyudkFPm1tLZkplxk6fiK3zRK3P9o7uVyOm1cXslKTsbN3YPGrb5n0/JnJlykvLTFp4EuJO2/QYsslhQX09uvCyk8/5ty5c5SXlxMSEmLUzRbXbjArLi5Go9GQlJTEuXPncHNz0+/6NWToNAWdTsfZs2epra1l2LBhRgmvSqWSuXPn8u677/K3v/2tQ30OCa0nAl8rmctOXFOxtbUlICCAgIAAKioqUKvV5OTkkJCQgKWlJTKZjCFDhjTaQ9PclvAV5edSVlzMw6+/a7Tiu4Jp5eZkIQOefO9jtvz7S5OfP/b4EX2JGVPIV6so0Kjw9g8wyPGKC/IZ2L0rn374AWfPnqWyspLg4GCT7qy9dplJWVkZGo2GrKws4uPjcXR01N9pMPdiz3Vhr7q62mhh78yZMygUCl577TWefvrpDv05JLSMCHytYK47cU2lc+fOdOvWjS5duhAdHY1Wq6VTp04olUr9xdjLy+u6XXwWZrImR6fVkpmSRN/g4dx59/1tPZzG3UJ/V61RXVlJdloyE8PuImj81XpjkmTaQt/a2lqy0lIa3DzSPE3/Nz91eB+eXQyzdq+kII+hvXvwwbJ3OHPmDNXV1QQHBzdp7a4x2dnZYWdnR0BAAFVVVWg0Gn3JF1tbW/26P3Pb9KHT6Th37pw+NBvj93jx4kVmz57N888/z0svvWRWP79gPkTga6H2ujnD0MrKyoiNjcXR0ZGBAwcil8uprq5GrVbrd+DZ29vr+/va2dmZxSLsksICivJyWfjy6y0um2FKt+ZfV9NJkoTqShpW1p1Y8n79Ysqm/ns78/sxbGwaLlViDJIkkZWSbJA+wMV5uYwY2J933nydM2fO6G8/tnXYu1anTp3qbfrIy8tDrVYTExODXC7Xz/y5urq26fVGp9Nx/vx5ysvLjRb2EhISCA0N5bHHHuP111+/ZT+LhJsTga8FJEnivvvuY8SIESgUCnx8DF8GoT0oLCzk9OnT+Pj40KtXL/2FxtraWn8xrqmpQaPRoFarSU5OxtbWlsrKCiQbyzZr75aVkkRgv4Es/PvrJj9/i4mL+A1VVpSjzkhj8t0PMGD4yOv+u6k/8C+fO4ODi6vJznfpbKxB2hUW5eUyJmggb772KqdPn0an0xnt9qMhWVpa6ltK1m360Gg0XLx4kdra2nqbPkwZXCVJ4sKFC5SWlhpt7WNSUhKhoaHcf//9LFu2TIQ9oVHm/U42U7W1tYwfP55NmzbxyiuvMGLECMLCwlAoFPj5+d0Sb7q6Th29evXC3//GbaOsrKzw8fHBx8dHX37B0sKCap0OmZG7HFyrtLiIfFUO9z33Dzx8TLe+yjA6/t9Uc0mSRG52JvZOzjz9ken6GjemuCCfPFW2YXrnNvE6cvHUH7h6erXqVEW5aiaMCOaVv79EbGwsAEOHDjX7sHetv2766NOnDyUlJajValJSUvSdPuo2fbSmrMzN1IW9uhI2xgh7aWlphIaGEh4ezvLly83i718wb+IvpAWsrKx45plnOHbsGGlpadx3333s2bOHgQMHcvvtt/P555+Tmpraokr57UF6ejrnz59n4MCBjYa9a9WVX/D19UWnM90+XUmSru7WdHDk2eUr22HYE3HvWpXlZWSlXOaOu+Zz33P/aPzDzoRvw1OH9pl0s0ZVRQWqK2mtOkahRsWUcaP0YU8mk7XLsHctmUyGo6MjPXv2ZPTo0YwZMwY3NzdycnL49ddfOXnyJCkpKZSWlhr0Wi1JEhcvXqSoqMjgJWzqZGVlERoaytSpU1m50nRfdlavXk1AQAA2NjaMHDmSP//884bPXbt2LePHj8fFxQUXFxcmT57c6PMF4xOBrxVkMhm+vr4sWbKEI0eOkJGRwYMPPsjBgwcZMmQIEyZM4LPPPiM5OblDhD9JkkhMTCQ5OZlhw4bh6enZouPY29uh05pmIX15aQkZlxJQPPIEcx5bYpJzGoVIfMDVv0F1ZgaWVlY8+d5n9Bgw+OavMcG44OrYMpIuGSwoNeWfPDrqII4uLe+bW6BRMX3CeF545hl90WNjdX5oa7a2tnTr1o3hw4dz22234efnR2FhISdPnuT333/n0qVLFBYWtupaLUkScXFxFBQUGC3s5eTkMHPmTMaNG8dXX31lsrD3888/88ILL/Dmm28SExPDkCFDmDp1Kmq1usHnR0VFMX/+fI4cOcKJEyfw9/fnzjvvJDMz0yTjFa4nkzpCEjEzkiSRm5vL5s2biYyMJCoqigEDBqBQKFAoFPTs2bPd3fbVarVcuHCB4uJihg0b1qrelyu++IL9J6LpbMRSCpIkkZORhpunF/OeeqHd3+74+q1X8PQ1bAeF9qa8tIQCjZqwh5/Av0evJr8u4qsVzH38WaO/55IvnOPQ5p9x9+5ikOPl5WTzyD/fbfQ5P634CBs7+xYdv0CdQ9idt/PkY48RExODtbU1gwcP7pBhrzFarVa/6UOj0SCXy/W3fV1dXZv8+5AkiYSEBHJzc5vddq6pNBoNM2bMYNCgQfz3v/816SzsyJEjGT58OKtWrQKurof29/fn6aefZunSpTd9vVarxcXFhVWrVrFw4UJjD1doQPueszdTMpkMDw8P/va3v/HYY4+Rn5/P1q1biYiI4P3336dPnz768NenTx+zD381NTX6VkAjRoxo9XoUZ0dHdFrj3dKtLC9DlZHO7Icep3v/gUY7jymZ+Z+IUUk6HarMDLp0DWTB8zf/YLmeaX55507+ZrCw1xSa7EyKCvJaFPjyVdncHTqdhx9cRHR0NDY2NgwePLjdfzFqCQsLC33xeJ1OR2FhIWq1mvj4eGpqanB3d8fDw6PRtpJ1dz80Go3Rwl5BQQGzZ8+md+/e/PDDDyYNe9XV1URHR/PKK6/oH5PL5UyePJkTJ0406Rjl5eXU1NTg6mq6DU1CfSLwGZlMJsPNzY2HH36Yhx56iIKCArZt20ZkZCTLly+nZ8+ehIWFER4eTr9+/cwu/FVUVBAbG4utrS2DBg0yyLd/Zycno6zhq7vdZ+/oxDPLzWMRv8GY2d+FqZQWF1FSkMfcJ57Dy7fp60WvJUmSUd9bNdVVqNJT8WjFGJtLeeQAHj7NP19eThYLwmex6P77iY6O1r+3O9T7pYXkcjmurq64urrSp08ffVvJ1NRULly4oO8s9NdNH5IkcenSJVQqFSEhIdfVHTWEoqIi/abAjRs3mrxMTm5uLlqtFi+v+puDvLy8iI+Pb9Ix/vGPf+Dj48PkyZONMUShCUTgMyGZTIarqyuLFy9m8eLFFBYWsn37diIjI/nss88ICAggLCyMOXPm0L9//za/ABcXFxMbG4uXl5dBZyIdHByQdIZdSVBdWUlWWjLT5y+ib/AIgx7bHNxqcU+n05GTlkJgv4E88OKrrTqWTCYDI69ciTl6GDtDt1Fr5B/9anmh5Gbvzs3LzmTxPXdx793zUCqV2Nvb6+tnCvX9tad4jx499J2FVCoVCQkJODg44OHhQUVFhf42bmuWutxISUkJc+fOxdnZmcjIyHbXUg7gww8/ZOPGjURFRRl1d7TQOBH42pCzszMLFy5k4cKFFBcXs2PHDiIjI5k4cSJ+fn768NcW375zc3M5e/Ys3bt3p1u3bgadHXF0dEQnGW6GLzc7E0sra57+8PN2v7Pwxm6dyFdckEdxfj4LXliKq6d3Ww+nSVLiL2Br72DQYzb2Lx4f8yfyZvYozM26wt8W3sdchYLo6GgcHBwYMGCACHtNVNdZqFu3blRXV5Obm0tKSgrl5eXY2NiQmZmJh4cHzs7OBrtelpeXM2/ePKysrNi6dWubhSV3d3csLCxQqVT1HlepVHh7N/4e/eSTT/jwww85ePAggwfffJOVYDwd9dOx3XF0dGTBggUsWLCAkpISdu3aRWRkJFOmTMHLywuFQkF4eDhBQUFGv0BfuXKFhIQEBgwYcNM3c0s4ODggGWCXbk11FVkpSUxUzCNo3MTWD8yc3QJ5T6utJSslmT5DQ1j08huGO7BMhmTEvbp5qhyD9rFtivjoUzi7N32XfG5mBk8/spjQGdNRKpU4OTkxYMAAs1tC0l5YW1tTWVlJTU0NI0aM0Ld6O3PmDIC+zVtzNn1cq7KyknvvvRetVsvevXvbtF+wtbU1wcHBHDp0CIVCAVydZT506BBLlty4+sHy5ct577332LdvHyEhISYarXAjIvCZIQcHB+69917uvfdeysrK2L17N5GRkcyYMQM3Nzf9mr/g4GCDhj9JkkhKSiIjI4OhQ4cabXGtk5NTq8vU5KmyQZJ46v3PsLJuf7c4msuYm1zMQWGuhoqyUhYvfQsHFxfDHtzImUZ5eL/B+tg2RUVZKerMDLyaWNxZcyWdF5/8G3dOvgOlUomrq6tZrhduT1JSUkhPTyckJAR7+6ubZuo2fRQVFaFWq0lISKCqqkq/6cPDw6PJa++qqqq4//77KSoq4sCBAzg4GHb2uCVeeOEFFi1aREhICCNGjGDFihWUlZWxePFiABYuXIivry8ffPABAB999BFvvPEGGzZsICAggJycHADs7e31vzPBtETgM3N2dnbMmzePefPmUV5ezt69e4mMjGT27Nk4Ozsze/ZswsPDGT58eKs2VOh0Oi5evEhBQQHDhw836hvSwcEBrba2Ra+trakhMyWJ0VNnMnLyNAOPzHx1MmFvVlOqra0hKyWZIaPHMzF8nlHOIUNmtGJ8kiRxJeUyrh6t63TRHMojB3D2aNrsnjojjVeeXcKkiRNQKpW4u7vTt29fEfZaITU1lbS0NIKDg6+7Tsrlcn2h4d69e+s3faSnp3Px4kWcnZ31mz5utLmjpqaGBx98kKysLA4dOoSzs7MJfqqbu+eee9BoNLzxxhvk5OQQFBTE3r179Rs50tPT601AfPXVV1RXV3PXXXfVO86bb77JW2+9ZcqhC/8jAl87Ymtry5w5c5gzZw4VFRXs37+fyMhI5s6di52dnb6926hRo5oV/mprazlz5gw1NTUMHz7c6OtEbG1tWzTDV6BRU11ZyeNvf4SNERZHm7UO+Pmcr1ZRU1XJo2+8j60xv/Eb8XcXH3MKmcy0a+DSLyXcdL2gJEloMtJ48x8vMmbUKJRKJR4eHu2iDJQ5S09PJyUlheDg4JvOujW06UOj0aDRaEhMTMTe3h4PDw8sLS3x9/dHLpdTW1vLo48+SlJSEkeOHMHNreVFtY1hyZIlN7yFGxUVVe//p6amGn9AQrOIwNdOde7cmbCwMMLCwqisrOTgwYNERkZyzz33YGNjw+zZs1EoFIwZM6bRjQyVlZXExsbSqVMnQkJCTLLpQS6XN6vFi7a2lszkywy9bRK3zZpjtHGZt47zIV1TXU1WajIjJk9lzNRQo59PW1NrtE438TGncHH3MMqxG/o3z05LpbSwsNHAJ0kS6oxU3n11KcNDglEqlXh5edG7d28R9lohIyODpKQkhg0bhqOjY7Nf37lzZ7p27UrXrl2pqanRh79HHnmEvLw8br/9dlQqFRkZGRw9ehQPD2P9XQm3KhH4OgAbGxtCQ0MJDQ2lurqaw4cPExERwf3334+lpSWzZs0iPDycsWPH1ltD8ueff5KYmMjQoUPp16+fSXfryZp4rqK8XMpLinnkjXexc3Ay8qjMV0f5mM7LyUKSJJ5c9jHWJtpxKJPLjRL4KivKyclIw7uJa+marYF/9Jijh3BvpBe0JEmo0lL4ZNmbDBo4EKVSiY+PT7vs7mNOrly5wuXLlxk6dChOTq2/DllZWeHj44OPjw9Hjhxh+/btvPvuu2RkZODk5MSrr76KQqFgypQpRin1ItyaxH78Dsba2ppp06bxzTffkJ2dzQ8//IBcLmfx4sX07NmTJUuWcOjQIbZu3UpoaCgpKSltUvPvZh89Oq2WjMuJ+PXoyZPvfXpLhz0AmlmCw9xUV1WSlhjH0Nvu4NE33jdZ2APjhWXl4f04G21273o6rZbstOQbvlevhr1kPv9gGYMGDiQ6OhpfX18R9lopMzOTxMREgoKCjLKeztbWlpiYGAASEhLYsWMH7u7uvPjii7i7u6NQKPQbHgShNcQMXwdmZWXFlClTmDJlCqtXr+bYsWNs2rSJBx54gKKiIoYPH87IkSOpqalpdbu05mpshq+kIJ+i/DwWvvw6zm7itgaArB13vNZkZmBp3Ykl732GpYn/zgBkchnG2LWRlhhv8Np7jTn/5+9Y3mBHel3Y++rT5QQGBqJUKvH396dHjx4mG19HlJWVRUJCAkFBQbgYevc4VzfLvf7662zfvp2oqCh69uxJz549GTt2LMuXL+fixYts375dtCMTDEIEvluEpaUlkyZN4uTJk0iSxPLly0lLS+Opp56ivLyc0NBQFAoFt99+u0kquTc033C1e0ASgf0HsvDlfxp9DO1KO5yhqaooJyc9lSl3P8CAEaPacCSG/93lpKdSUlRg0sB36UwMTq7XL+KXJImc1CTWfv4v/P39iI6Oplu3bgQGBppsbB1RdnY28fHxBAUFGSVwSZLEe++9x8aNGzly5Ag9e/as999lMhkDBgxgwIABBj+3cGsSge8WUVtby9NPP822bds4evQoQUFBAHz++ef8/vvvbNq0ieeee46SkhJmzJiBQqFg8uTJRtuxK7vmFmVJYQEFGjX3PfcPPBpZo3SrkslkRu8HayiSJKG+ko6doyPPLP/CLDo5GHoNX3TUITxMWHuvrKQYdeYVvLsG1Htc0ulQpSbzny9X4u3tTXR0NIGBgQQEBDR4HKFpcnJyiIuLY8iQIUYLex9//DFr167lyJEj9OvXz+DnEIRrtf2VWDCJyMhIjh8/zh9//KEPewAWFhaMHz+elStXkpaWxu7du/Hy8uLll18mICCAxYsXs23bNsrLyw06Hvn/Zl0kSSLjcgIOzs48u3ylCHs3YGFpiaRrfXcSY6soKyMtMY7Jdy/ggZdeN4uwZ+iQfHUtXYoJfrb/H/epQ3tx9e5Sfxw6HarUJNb/+0u8vLyIiYmhe/fuIuy1kkql4sKFCwwaNMgoZVEkSWLlypWsXLmSffv2MWjQIIOfQxAa0vZXY8Ek7r77bk6ePEnXrl1v+By5XM6YMWP417/+RXJyMgcOHMDf35/XXnuNwMBAFi5cyObNmykrK2v1eEpLiikrLiI1/gJ3PfEs4Y/euD2PAJZW1kYrLWIIkiSRnZaCTC7j2eVf0HPgkLYeUn0G/NWd/u0olk3smGAoGZcTsf7L+j2dToc6NYmN332Lq6srsbGx9OzZk27djLRj+BahVqs5f/48gwcPNkpZFEmSWLNmDR999BF79uwhODjY4OcQhBsRge8WIZPJmtWLUS6XM3LkSD755BMuX77MkSNH6NGjB2+//TYBAQEsWLCATZs2UVpa2qLxqDKvIOl0PPfJanwCxMLym7G0skSSzHOGr7ykmIzLCYQufIT5z/zdLGb1/qrudrihJJ6JwcnN3WDHu5G6icmMpETKS///S5ZOq0WVcplNP3yHnZ0dsbGx9OrVC39/f6OPqSPTaDScO3eOQYMGGS3sfffdd7z99tvs2LGDkSNHGvwcgtAY87oyC2ZJLpcTEhLCRx99REJCAr/++iv9+vXj/fffJyAggHvvvZeNGzdSXFzc5GMe3LOLft27cXjj95w8sJvK8tbPGnZklpbW6HTmNcMn/W+TTSdbW55d/gVde/dt6yEZXVlxEXnZWSY95+njUbh38QH+dzs55TIvP/MUCQkJxMTE4Ovri4+Pj0nH1NHk5uZy9uxZBg4ciKdn09rWNYckSWzYsIGlS5eybds2xo8fb/BzCMLNiE0bQrPI5XKGDh3K0KFDee+99zh37hybNm3i008/5cknn2Ty5MmEhYUxc+ZMnJycbrh+KjAwkBUfXW2ynZmZyadffEl+RRX27p4MGTuRzqK5dj0WZjbDV1pUSIFGzT1LXsDLWIWHDUUmQzLQPd0T+3bh4Wu6zRra2lpy0tNw7+KDVltLXnoKOzdtRJIkzp49i4uLCyqViqysLNzd3fH09MTNzc0kHXM6iry8PM6ePUv//v31fWENLSIigueff56IiAgmTZpklHMIws3IJHNeGCS0G5IkcfHiRTZt2sTmzZtJSEjg9ttvJywsjFmzZuHs7NykxfMqlYpPv1iNprSczi4eDBk3ATuH5rcx6mj2bfyBfFU2NrZNvy1vDHWlc7r16c/sxY+16Viaatu6NUydvxCbzq3vWLDu/Tdx8TD8DFBDCjRqgsZN4Pwfv2Pr4EDelTR2bNpITU0N586do1+/fnTp0gVJkiguLkatVqNWq6msrMTNzQ1PT088PDzqddcR6svPz+f06dP07dvXaLOk27Zt45FHHmHjxo3MmjXLKOcQhKYQgU8wOEmSiI+PJyIigs2bN3PhwgUmTpxIeHg4oaGhuLq6Nin8qdVqPvtiNTlFpXR2cWfIuAnYOzkb/wcwQ4c3/0xOeiqd7dpu5rO4IJ/i/DwWvLAUV0/vNhtHc21bt4ap9z7Q6rCclhjH3g3f4el7441PhlSgUePg5AxyGQVX0tkZ+QuVlZWcO3eOgQMH3nA2qrS0FI1Gg0qlorS0FBcXF334M1aZpfaooKCA2NhY+vTpg6+vcaoD7N69m0WLFrF+/Xrmzp1rlHMIQlOJwCcYlSRJXLp0SR/+zpw5w2233UZ4eDizZs3C3d29SeEvPz+fT79YTWZeITbOrgweOwFHl1un+vzxnVtIT4zHtg1mO3VaLZkpSfQOGsa0+YtMfv7W2v6fr5ly94JWh+Uta1ej0+lMtilFfSWdmpoaOsll7Nq8ibKyMs6fP8+gQYOavM6soqJCH/6KiopwdHTUh7/mbOLqaAoLC4mJiaF37974+RnnFv3hw4e59957+fe//819991nlHMIQnOIwCeYjCRJJCcn68NfTEwM48aNQ6FQMHv2bDw9PZsU/oqLi/nsi1WkqvKwdnRi8NgJHb4F2x/7dnHp/BnsHU3bU7gwV0N5aQn3v/hqg10e2gNDBL7amhr+/c6rdLmm8LExXTz1B25ubuzfsZXi4mIuXLjQqnIh1dXVqNVqNBoNeXl52NnZ4enpiaenJ/b29u2iqLchFBUVERMTQ8+ePY22s/nYsWPMmzePL774gkWLFt0yv1vBvInAJ7QJSZJITU0lMjKSzZs3c+rUKUaPHo1CoSAsLAxvb+8mXSRLS0tZsepLkrJUWDo4Mmj0bbh6GmfhdVs6deQAccqTODgbvp9nQ7S1tWSmJDFo9DhuD7/bJOc0lu3ffc2Uuxa0aiPQyYP7SDwdjb2TaQJ3dVUVl2JPcfrUSQoKCoiLi2Pw4MG4uxumHExtbS25ubmo1Wpyc3OxtrbGw8MDLy+vRjdbtXfFxcVER0fTo0ePRmuStsaJEycIDw9n+fLl/O1vf+uwv0uh/RGBT2hzkiSRkZGhD39//PEHI0eOJCwsjLCwMHx9fZt00SwvL2fll1+RkJ6FpZ0DA0ePx+2a7gTt1ZnfjnH6tygcXYw/y1agVlFVVcmil/9p0l6xxmKIwPfjio+wNdH6yeqqKso1OezZtpnc3Fzi4+MZMmSIUbo+AGi1WvLz8/WzfzKZTB/+XFxczK6uYkuVlJSgVCrp3r270QpUK5VKZs+ezTvvvMPTTz8twp5gVkTgE8yKJElkZmayefNmIiMj+f333wkJCSEsLAyFQoG/v3+TLqKVlZWs/vprzl1Ow8LOnoGjxuHhY7pyGoZ2UfkHfx7ab9TbqrU11WSlJBNyxxTGTptttPOY2o7v13LH3HtbHF4L8zT8+NmH+AR0N/DIrlddWUllvpo927aQk5NDYmIiQUFBRunn2hCdTkdhYaF+x69Wq8XDwwMPDw/c3d2xsLAwyTgMraSkhOjoaLp160ZgYKBRznHmzBlmzpzJK6+8wksvvSTCnmB2ROATzJYkSWRnZ7NlyxZ9L+ChQ4fqb/sGBAQ06aJaXV3Nmn9/Q2ziZeSd7ek/YrT51467RuKZGH7bs91oaxXzVNlIOh2LXn4D6w62k3Pn999w+9x7Whz49m74npKiQqPXtquqqKSmKJddWyLJzs7m0qVLDB06FBcX09zGv1ZHKfdSWlqKUqmka9eudO9unNB+8eJFpk2bxrPPPsvrr78uwp5glkTgE9oFSZJQqVRs3bqViIgIjh49yuDBg1EoFCgUCrp3796ki2xtbS3f/Oc7fj99FpmNHQNGjjXJzE1rJV88R9S2CFzcDVsDrrqqiuy0ZMbPVBA8cbJBj20udn7/DZPm3N2ieo6SJPHvt1/B09e4bcsqKyuQSgrZuTmCK1eukJSUxNChQ3F2djbqeZtKkiTKysr04e+v5V48PT3p1KnTzQ/SBsrKylAqlfj5+dGjh3FaOCYkJDB9+nQeeeQRli1bJsKeYLZE4BPaHUmSyM3N1Ye/I0eO0L9/f33469WrV6MX3bqemT169ODAkSP8pjyNrLM9vYNH4BvYwywv2BmXEznw839xMeCGFHXWFaysrFn40mtYWlsb7LjmZtcP3zIx7C7sWrDDOeF0NMd3bsHNy3hrQSsrypGVl7A94hcyMjJITk5m2LBhOJlog0hLVFRU6MPfX8u9eHp6Ymvb+gLXhlAX9nx9fenRwzjv66SkJKZNm8b8+fNZvnx5h1nvKHRMIvAJ7ZokSeTn57Nt2zYiIiI4dOgQffr00a/569u3b70L/Q8//ICrqyshISH1CtfqdDp+/Gkjh0/8CTa29AoKwb9XH7MJf9lpKez6YR1uXq0veFxVUUFOeip3zJvPoJFjDTA689aawLft2y+N2sO4sqwMq9pKNm/cQFpaGqmpqQQHB+Po2H66y1RVVaHRaFCr1eTn55tFuZfy8nKUSiXe3t43/QLYUmlpaUybNo1Zs2axcuVKEfYEsycCn9BhSJJEYWEh27ZtIzIykgMHDtCjRw/CwsIIDw9n48aNfPXVV2zatKnRfpY6nY5fIiLZf+w3pE42dB88jIC+A9o0/OXlZLN57SrcvVve/kmSJNRX0rF1cOS+55feMv1Wd/7wDRNn39XsLi3VlZWs++BNvPyMU76joqwMG101ERv+S2pqKunp6QQHB+Pg0H53RtfU1NQr99KpUyd9+DNVuZeKigqUSiWenp707t3bKOfMysrizjvvZPLkyaxZs0aEPaFdEH+lQochk8lwcXHhwQcfZMeOHahUKpYuXcqFCxcYPXo0K1asICwsDHd3d3Q63Q2PI5fLuffueaxbtYJvP36fgc42HPnvWg79/ANJ58/QFt+RLK2tkFox01RZXkb6pXjumDufhX9//ZYJewAWFi3bXBB99KDRyuCUl5ViL9MS+dOPpKSkdIiwB2BlZUWXLl0YMmQIEydOpHfv3lRXVxMbG8uxY8eIi4sjLy+v0fdfa9SFPQ8PD6OFvZycHGbOnMn48eP56quvTBr2Vq9eTUBAADY2NowcOZI///yz0edv2rSJvn37YmNjw6BBg9i9e7eJRiqYo1vnqi/ccpycnLj33ns5ePAgvr6+PPvss/z222/cfvvt+Pj4oFAoCA8PZ/DgwTe8aMvlcsLDZhMedrVMyfadu9j237VorW3o2ncgPQcFmeSCb2VtjSQ1/0NSkiRyMtJwdnfnmY9uzdtO8hZ+5qfGX6SzEdqPlZeW4GQl56fv13P58mWysrIICQnBvhV1As2RhYWFfnZPp9NRUFCAWq3m/Pnz6HQ6PDw88PT0xM3NzSDlXiorK4mOjsbd3Z0+fYyzHEOj0TBr1iyGDh3Kt99+a9IyNT///DMvvPACa9asYeTIkaxYsYKpU6eSkJDQYKu933//nfnz5/PBBx8QGhrKhg0bUCgUxMTEMHDgQJONWzAf4pau0GGVl5dz9913k5GRwd69e+nS5erC+9LSUnbt2kVkZCS7d+/G09OTsLAw5syZw9ChQ5scivYdOMCmHbvRWtng26svvYcMQ26kD4Dq6krWvftGs8rJlJeWkJt1BcWjS+jWu69RxtUe7N+4njHTZzfrlq4mO5PINZ/j5WfY8j3lJcW42Xbih2/XcunSJXJycggODr6l+tpKkkRRUZF+00dVVRXu7u54enri7u7eonIvVVVVKJVKXFxc6Nevn1HCXn5+PjNnzqR79+788ssvJi9LM3LkSIYPH86qVauAq0tP/P39efrpp1m6dOl1z7/nnnsoKytj586d+sdGjRpFUFAQa9asMdm4BfMhZviEDuutt96ipKSEo0eP1itvYW9vzz333KO/IO7Zs4fIyEhmzpyJq6srs2fPZs6cOYSEhDQa/qZOmcLUKVMAOHr0KD/8tI5ay0506d6LvsHDsbAw3NvL0tIaXRO/m0k6HdnpqXj5deXZj1cZbAztWXO/1yoP78fDx7ClWMqKi+jiZMe6r9eQmJiISqUiJCTEbHa1mopMJsPZ2RlnZ2d69epFaWkparWa1NRULly4gKurq77WX1PKvVRVVREdHY2Tk5PRwl5RUREKhQI/Pz82btxo8rBXXV1NdHQ0r7zyiv4xuVzO5MmTOXHiRIOvOXHiBC+88EK9x6ZOncrWrVuNOVTBjInAJ3RYb7zxBpaWltg0UkjYzs6Ou+66i7vuuovy8nL27dtHZGQkCoUCR0dHZs+eTXh4OCNGjGj09s2ECROYMGECAL/9/jvfb/wP1RbWeAf2pF/IyFaHP7lcjowm9BYuKqRArWLekufp0tU4HQXaGwlZswKfTqcjKyUZVwPsiK5TWlRIV3cX/r36C+Lj48nNzb0lw961ZDIZDg4OODg40KNHD8rLy1Gr1WRlZREfH4+Tk5P+tnDnzp2ve31dEHJwcGDAAONsrCopKWHOnDm4uroSGRnZJjUHc3Nz0Wq19SoLAHh5eREfH9/ga3Jychp8fk5OjtHGKZg3EfiEDqu5a6JsbW0JDw8nPDycyspK9u/fT2RkJPPmzaNz58768Dd69OhGw9/YMWMYO2YMANHR0az97/dUySxx7xrIgOGjsWzp7EAjn2U6nY6s1GS69urDAy+91rLjCwDEKU8iM+Ct+dLCArp38eDLz1cQFxdHfn4+ISEhDQaYW52trS0BAQEEBARQVVWl7+976dIl7O3t9eHPzs6OmpoaoqOjsbe3N1rYKy8vZ968eVhbW7Nly5ZGvzwKgrkTga8DyM/P5+mnn2bHjh3I5XLmzp3L559/ftPAc+LECV577TVOnjyJhYUFQUFB7Nu3T3wQATY2NsyePZvZs2dTXV3NgQMHiIyMZP78+VhbW+vD35gxYxrd8RocHExwcDAAp0+fZs3366nEAnf/AAaMGINVcwoe32CWqrggn+L8PBY8v9Sgs1IdhVwmu+HvriHxp5W4uBumhV1JYQG9/brwxWefcPHiRQoKCggJCRHBoQk6deqEv78//v7+9cq9pKSk0KlTJ7RaLXZ2dgwYMMAom5EqKiq499570Wq17N27t03XWdb1MVapVPUeV6lUeHs3/J739vZu1vOFju/W27LXAS1YsIALFy5w4MABdu7cybFjx3jssccafc2JEyeYNm0ad955J3/++SenTp1iyZIlt+QuzpuxtrZm5syZrFu3juzsbL777jt0Oh0PPPAAvXr14plnnuHIkSPU1NQ0epygoCDW/OtTvvvXch688zaUW37k0MbviTl6iOqqypuO49oZDJ1WS8blRLz8/Hn6wxUi7BlARWkp6ivpBjlWcUE+AwL9+eKzT7hw4QKFhYUi7LXQX8u9jB07FkmSkMlklJSU8NtvvxEfH09+fr7Byr1UVVXxwAMPUFxczK5du9q8XI61tTXBwcEcOnRI/5hOp+PQoUOMHj26wdeMHj263vMBDhw4cMPnCx2f2KXbzsXFxdG/f39OnTpFSEgIAHv37mXGjBlcuXIFH5+GC/WOGjWKKVOmsGzZMlMOt0Opqanh6NGjREREsGXLFnQ6HaGhoYSHh3Pbbbdh3cTZu8uXL7Py67UU1+hw8vZlyJjbsG4gFKx542X9Lt3CXDXlpSXc/+JrOLkap1ZcR3Fg04+MuGMqTq7uN33u0e2R5KSlNvj7b47igjyCevfgo3eXcf78eUpLSwkODjbbnrPtRW1tLTExMVhZWTFkyBAAfbkXtVqNJEl4eHjg4eHR4nIvNTU1LFy4kPT0dA4dOoSrq6uhf4wW+fnnn1m0aBFff/01I0aMYMWKFfzyyy/Ex8fj5eXFwoUL8fX15YMPPgCulmWZMGECH374ITNnzmTjxo28//77oizLLUzc0m3nTpw4gbOzsz7sAUyePBm5XM7JkycJDw+/7jVqtZqTJ0+yYMECxowZQ1JSEn379uW9995j3Lhxphx+u2ZlZcXkyZOZPHkyq1at4vjx42zatInHH3+cqqoqQkNDUSgUTJo0qdHw17NnT1Z+/BEAKSkp/Ourf1NSU4ujZxcGjbkNm87/W9gvk6GtreVKUiKDx9zG7XPuMcWP2e7JmnEjI+NyInYOrWtrVpyXS8jAvrz31pucO3eO8vJyQkJCmvwFQGhYXdiztLSsVzvTzc0NNzc3+vbtqy/3kpiYSHV1NW5ubs0q91JbW8ujjz5KUlISR44cMZuwB1fLrGg0Gt544w1ycnIICgpi7969+o0Z6enp9e7QjBkzhg0bNvD666/z6quv0qtXL7Zu3SrC3i1MzPC1c++//z7ff/89CQkJ9R739PTk7bff5oknnrjuNX/88QejR4/G1dWVTz75hKCgINavX8+XX37J+fPn6dWrl6mG3yFptVp+/fVX/cxfWVkZM2fORKFQcPvttzf5ll5GRgb/Wr2Ggspq7Nw9OfDLjzh7ePLwa+9ga99+eq22tYObfmL47VNwcmt8hi8zJYmd36/F07fl5ViK8nIZEzSQt15/jbNnz1JZWcmwYcNE2GslrVZLTEwMcrmcoKCgm87cSZKkL/eiVqspKyvTl3vx9PRs8N9Dq9XyxBNPoFQqiYqKEmvdhA5HzPCZqaVLl/LRRx81+py4uLgWHbtuncvf/vY3Fi9eDMDQoUM5dOgQ69at098SEFrGwsJCX6ZlxYoVnDhxgoiICF588UWKioqYPn06CoWCyZMnN7pBxt/fn88+fA+A7Oxs0k+fwtbNgzO/HWXI2InY2rfvNlymcnXPxs2/18YeO4x7F98Wn6cwV83EEcG89o+XOXPmDFVVVQQHB5u8ZltHo9VqiY2NRSaTNSnsQdPKvZSWluLn50evXr3Q6XQ8++yz/PHHHxw5ckSEPaFDEoHPTL344os8+OCDjT6ne/fueHt7o1ar6z1eW1tLfn7+DS9adR0n+vfvX+/xfv36kZ5umAXrwlUWFhaMGzeOcePG8dlnn3Hy5EkiIiJYunQpeXl5TJs2DYVCwZ133tloTbYuXbqwPeIX4Oot+c++WE1OSRm2Lu4MGTsBO0cnU/1IHZJWW0tWWgoeLQx8hRo1d44fxUvPPcfp06epra0VYc8AtFotp0+fRpIkhg0b1uJWZn8t91JZWYlGo2H58uV8//339OjRA1tbW9RqNb/99hv+/oYtuC0I5kLc0m3n6jZtKJVKffmP/fv3M23atBtu2pAkCT8/Px566KF6mzaGDh3K9OnTef/99002/luVTqdDqVQSERHB5s2bycnJYerUqSgUCqZNm9bkEhC5ubl8tupLsvKL6OzixpBxE5vVQuxWcGjzRoaNvx0Xj+v7jdaJ/TWKsyeO4+jc/DVbBeocZky8jeefWcLp06fRarUMGzas0XI9ws1ptVrOnDlDbW2t0X6fOTk5LF68mJMnTwIQEBDAnDlzCA8PJyQkxCi1/QShrYjA1wFMnz4dlUrFmjVrqKmpYfHixYSEhLBhwwYAMjMzueOOO1i/fj0jRowAYMWKFbz55pt8++23BAUF8f333/PJJ59w/vx5evTo0ZY/zi1Hp9MRGxtLREQEkZGRZGZmMmXKFBQKBdOnT29ySYjCwkI++2I1Gbn5WDu6MHjMbTddt3YraErg2/TVCiwtmz8bl6/OQXHn7Sx5/HFiY2ORJImhQ4eKsNdKOp2OM2fOUFNTY7SwJ0kSy5Yt47vvviMqKgo/Pz/27dvH5s2b2blzJ05OTnz55ZeEhoYa/NyC0BZE4OsA8vPzWbJkSb3CyytXrtQXXk5NTSUwMJAjR44wceJE/es+/PBDVq9eTX5+PkOGDGH58uVil24b0+l0nD17lk2bNrF582ZSU1OZPHkyCoWCGTNm4OTUtFu3paWlfPbFKlKyNVg5ODFozG2NBp6O7PCWXxg6bgIuHl4N/vfSokJ++PR9vP9X8qap8lXZ3B06nUcfWqxfYzZ06NAW33YUrqp7D1RVVTFs2DCj3BaXJInly5fz5ZdfcvjwYQYNGlTvv1dXV3P48GF69eolvgALHYYIfIJgpiRJ4vz58/rwd/nyZe644w7CwsIIDQ3FycmpSbecysvLWbHqSy5dycbS3oGBo2/D7RYq0nxk6y8MGXMbrp4N/8yHIjeSn5ONZTN20ublZLEgfBYPPvAAsbGx+k41Iuy1jk6n49y5c1RUVBhtDaQkSaxcuZKPP/6YgwcPMmzYMIOfQxDMkQh8gtAOSJJEXFycPvzFx8czadIkFAoFoaGhuLi43DT8lZWV8ccff7D/SBTq4jIs7RwZMGoc7l0aLs7dUTQW+CRJYv3Hy3B0aXrx6rzsTBbfcxf33XtPvSLAIuy1jk6n4/z585SVlREcHGyUUjaSJLFmzRqWLVvGvn37GDlypMHPIQjmSgQ+QWhnJEkiISGByMhIIiMjOX/+PBMmTEChUDBr1izc3NyuC385OTkkJCTg4+NDz549kclkVFdXs+qrrzmflILM1p4BI8bg6de1jX4q44nauonBo8c32HouJf4CBzdtwN27aaE3N+sKf1t4H/PmzCE6OppOnToxZMgQ0ZKwlepms0tKSoxWpFqSJP7zn//w2muvsWvXLrF85Rrr16/n+eefJysrq15HGIVCgYODAz/88EMbjk4wBBH4BKEdkySJy5cv63f7nj59mvHjxxMeHs6sWbPw8PDg8OHDLFy4kA0bNjBhwoQGj1NbW8vXa78lOi4BOtvSL2QMXboFmPaHMZLGAt/2dWvQarVNOo4mM4OnH15E2KxZREdHY2try6BBg0TYayVJkrhw4QLFxcVGaz8nSRI//vgjL774Ijt27Ki3llm4qqKigi5durB27VrmzZsHXC0B5evry/79+5k0aVIbj1BoLRH4BKGDkCSJlJQUffiLjo6mb9++JCQk8NRTT/Huu+82ac1fbW0t/1m/nhOnz4GNHX2CR+Ib2H4Xrh/dHsHAEWNx8+5S7/Ga6mr+8/6bePj63fQYmivpvPjEY0yfNpXo6Gjs7OwYOHCgCHutJEkSFy9epLCwkJCQEKP1Gt60aRNPPfUUkZGRTJ061Sjn6AiefPJJUlNT2b17NwCfffYZq1ev5vLly6JETQcgAp8gdECSJPHtt9/y1FNP4evrS0ZGBqNGjUKhUBAWFkaXLl2adAHX6XSs//FHjv0Zg2RjS++gEPx69m5XF/8bBb6TB/dy6WzsTXvnqtJTmX3HBEaPHo1Wq8XR0VGs2TMASZKIj48nLy+PkJCQJrccbK5t27bxyCOPsHHjRmbNmmWUc3QUsbGxDB8+nLS0NHx9fRk8eDDz5s3jn//8Z1sPTTAAEfgEoQPauHEjDz/8MOvXr2fOnDlcuXKFyMhINm/ezO+//86IESP04c/Pz6/J4W/jLxEc/O0E2HSmx+Bguvbua/bh7+iOzQwYPuq6dXobv/iETjY3bm0nSRKajDTe/MeLjB45EqVSiYWFBTU1NVhaWuLp6YmXl1eTd0sL/69uHapGoyEkJKTRFoOtsXv3bhYtWsT69euZO3euUc7R0QQHB3PXXXdx5513MmLECFJTU0X3kQ5CBD5B6GC++eYbnnvuuQZvX0mSRFZWFps3byYyMpLffvuN4OBgwsLCUCgUdO3atcnhb/PWrew+cgw62RIwYAiB/QeaZfA5vmML/UJG1OuTm69W8fOqT/D2D2jwNZIkoc5I5d1XlzJq5AiUSiUuLi70798fSZLIz89HpVKh0WiQyWR4eXnh6emJs7OzuM17E5IkkZiYiFqtNmrYO3ToEPPnz2ft2rXMnz/fKOfoiL766itWrFjBlClTuHTpEvv27WvrIQkGIgKfIHQwO3bswNnZmfHjxzf6PEmSyMnJYcuWLURGRnLs2DGCgoL0M3+BgYFNDnDbtu9g+4FDSNa2dO0/iB4DB5tN+Gso8O3b+AOlBfnIG+jgIEkS6vQUlr/zJkOHDCE6OhpXV1f69et33c+k0+koKChArVajVquRJAlPT088PT1xdXUV4e8akiRx6dIlcnJyCAkJabR/dGscO3aMefPm8cUXX7Bo0SKz+VtsD4qKivDx8aG2tpb169dzzz33tPWQBAMRgU8QhKu3LzUatmzZQkREBEePHmXgwIEoFAoUCgU9evRo8ofm7j17iNy9D8m6M759+tNr8NA2DT7Hd26l77AQPHyubs6QJInvPnwLZ/frO49IkoQ6LZkVH7xL//79iY6OxsPDgz59+tz055ckicLCQlQqFWq1Gq1Wi4eHB15eXri6ut7ya/4kSSIpKYnMzExCQkKa3C+6uU6cOEF4eDgff/wxjz32mAh7LbBw4UJ27dp1XYkWoX0TgU9od/Lz83n66afrtZL7/PPP9a3kGiNJEjNmzGDv3r1s2bIFhUJh/AG3M5IkkZeXx7Zt29i0aROHDx+mX79++vDXu3fTN20cPHyYjVu3o7WywadnH/oEhSA3cfC5NvAlnFby6+7tuF7Tak2SJFRpyXz16XJ69OhBdHQ0Xl5ezfp5/3qsoqIi/cxfdXU1Hh4eeHp64u7ufkuGv6SkJK5cuWLUsKdUKpk9ezbvvPMOTz/9tAh7LXTHHXcwYMAAVq5c2dZDEQxIBD6h3Zk+fTrZ2dl8/fXX1NTUsHjxYoYPH86GDRtu+tp//etfHDhwgD179ojA1wSSJFFQUMC2bduIiIjg4MGD9O7dW7/mr6HbnDdy/Phx1m/aTK1VJ7wDe9E3eDgWFtffUjW033ZvpfeQEH35lS3frIZrrnqSJJGTmsS/P/+MwIAAlEplvSLVrSFJEiUlJajValQqFZWVlbi7u+Pp6YmHhweWDdxW7miSk5NJT08nJCSkSV/MWuLMmTPMmDGDV199lZdeekmEvRYoKCggKiqKu+66i4sXL9KnT5+2HpJgQCLwCe1KXFwc/fv359SpU4SEhACwd+9eZsyYwZUrV/DxuXHHhNOnTxMaGopSqaRLly4i8DVT3azV9u3biYiI4MCBAwQGBhIWFkZ4eDj9+/dv8q3bkydP8u1PP1Mjt8azW3f6Dx+FhZGCz18DX1VFBf/54C28/P+/o4ik06FKTWbdlyvx9fUlOjoaX1/fZt3GbipJkigrK9Pf9i0vL8fV1RUvLy88PDyM0ju2raWkpJCWlkZwcDAODg5GOcfFixeZNm0azz33HK+99poIey0UEBBAQUEB//znP3nppZfaejiCgYnAJ7Qr69at48UXX6SgoED/WG1tLTY2NmzatInw8PAGX1deXk5ISAgffPABYWFhyGQyEfhaqaioiJ07dxIREcG+ffvw9/cnLCyMOXPmNKsocUxMDP/+4UeqZJa4+wcwYMQYLA0YfH7bs4Neg4Pw9PXn193byLiciE3nq5sFdDod6tQk1v/7Kzw9PYmOjsbf35/u3bubJDSUlZXpZ/5KS0txdXXVb/owRnsxU0tLSyMlJcWoYS8hIYHp06fzyCOPsGzZMhH2BOEGOv69BKFDycnJwdOz/mJ7S0tLXF1dycnJueHrnn/+ecaMGUNYWJixh3jLcHJyYsGCBSxYsICSkhJ27dpFREQEd9xxB126dNGHv5v1mh02bBhrhg0D4Ny5c3y17nsqZBa4+PgzaNRYrKxbt2hcJpNR9702PTGeznZXbynWhb2N332Ls7Mz0dHRdO3ale7du7fqfM1hZ2dHYGAggYGBVFRUoFKpyMrKIj4+HmdnZ/3Mn7GKEhtTeno6ycnJRg17SUlJhIaGcv/99/POO++IsCcIjRCBTzALS5cu5aOPPmr0OXFxcS069vbt2zl8+DCxsbEter1wcw4ODtx7773ce++9lJaWsnv3biIjI5k2bRru7u768Dds2LBGw9+gQYP48l+fABAfH8+qb9ZRqgNXb38Gjh6LdaeWBx/1lXSKCvLpbGePTqtFnZZMxH+/x9bWFqVSSWBgIAEBAS0+fmt17tyZgIAAAgICqKys1M/8JSQk4OTkpJ/5M1bdOkPKyMggKSmJYcOG4ejYeCeTlkpLSyM0NJQ5c+awfPlyUQJHEG5C3NIVzIJGoyEvL6/R53Tv3p3//ve/zb6l+9xzz7Fy5cp6HwharRa5XM748eOJiooy2M8h1FdeXs6ePXuIjIxk165dODs7M3v2bObMmcPw4cOb/CGdlJTE519/Q0mNFkcvHwaPHk+nJgafE/t30b3fQKKPHqKirAwkCU16Mps3/JdOnToRExND9+7d6datW2t+VKOpqqpCo9GgUqkoKCjAwcFB3+XDWHXsWuPKlSskJiYybNgwnJ2djXKOrKws7rzzTqZMmcJXX30lwp4gNIEIfEK7UrdpQ6lUEhwcDMD+/fuZNm3aDTdt5OTkkJubW++xQYMG8fnnnzNr1iwCAwNNMvZbXUVFBfv27SMyMpKdO3dib2/P7NmzCQ8PZ+TIkU0uVZKWlsa/vlxDYVUtDh5eDBk7ARvbG5f5OLF/FwF9+rPrh29xdvcgNz2FrRs3YGlpSWxsLD169KBr1643fL05qa6uRqPRoFarycvLw87OTt/lw1i7X5sjMzOThIQEhg4diouLi1HOkZOTw/Tp0xk1ahTr1q27JUvcCEJLiMAntDvTp09HpVKxZs0afVmWkJAQfVmWzMxM7rjjDtavX8+IESMaPIbYtNG2KisrOXDgAJGRkWzfvh0bGxt9+Bs9enSTS5VkZmby2aqvyK+ows7NkyFjJ9D5muBzYv8uSgsLSb+cQG1ZCTs2/YwkScTGxtK7d2/8/PyM8SMaXU1NDbm5uajVanJzc+ncubN+5s/e3t7k69nq1h4GBQXh6upqlHNoNBpmzJjB4MGD+eGHH26JkjaCYCgi8AntTn5+PkuWLKlXeHnlypX6GY7U1FQCAwM5cuQIEydObPAYIvCZj+rqag4ePEhkZCTbtm3D0tKSWbNmMWfOHMaOHdvkD3WVSsWnX6xGU1pBZxd3hoybgJ2DI3/s383p344ir61hZ+Qv1NbWcvr0afr06YOvr+/ND9wO1NbWkpeXh0qlIjc3F2tra/3Mn6Ojo9HDX3Z2NnFxcQwZMgQ3NzejnCM/P5+ZM2fSo0cPfv755zYtYdPc4u/5+fm8+eab7N+/n/T0dDw8PFAoFCxbtgwnJycTj164VYnAJwiC2aipqeHIkSNERESwdetWAP3C/PHjxzf5Qz43N5fPVq4mq6iYzCuZZCVf4uTxo1RVVXHmzBn69u3baM3G9kyr1ZKXl4darUaj0WBpaanf8OHs7Gzw8KdSqbhw4QKDBw/G3d3doMeuU1RUxKxZs/D29mbz5s1tXrKmucXfz58/z5tvvsmDDz5I//79SUtL4/HHH2fw4MFERESYePTCrUoEPkEQzFJtbS1Hjx5l06ZNbN26lZqaGn34mzBhQpM/9HNycrC3t6eiooJz587Rr18/unTpYuTRmwedTkd+fj4qlQqNRoNMJtPf9nV2dm71Zge1Ws25c+cYPHgwHh4eBhp1fSUlJSgUChwcHPS3/9tSa4q//9WmTZu4//77KSsrE7emBZMQgU8QBLNXW1vLr7/+yqZNm9iyZQuVlZWEhoaiUCiYNGnSTRu8azQazp49y8CBA/Hy8mr0uR2VTqejoKBA399XkiT9zJ+rq2uzw1/d73TQoEHX1cY0lLKyMubOnYtcLmfXrl1G68HbHC0t/n6tb775hldeeQWNRmOsoQpCPeJrhSAIZs/S0pKJEycyceJEVq5cyW+//UZERATPPvssJSUlzJw5k7CwMCZPnnzdDNChQ4fQ6XQMHjz4lg17AHK5HDc3N9zc3Ojbty+FhYWo1WouXryIVqvFw8MDT09P3NzcbrrzNTc3Vx+gjRX2KioquPfee9FqtWYT9qDlxd//Kjc3l2XLlvHYY48ZY4iC0CBRvEgQhHbFwsKC2267jZUrV5KamsquXbvw9PTk73//O4GBgTz00ENs376diooK1q1bx7x587Cysrqlw961ZDIZLi4u9OnTh/HjxzNs2DCsra1JTEzk6NGjnD17FpVKhVarve61eXl5nD17lgEDBhjtd1pVVcUDDzyg7+BirE4df7V06VJkMlmj/4uPj2/1eYqLi5k5cyb9+/fnrbfeav3ABaGJxC1dQRA6BJ1Ox59//klERASbN28mKyuLmpoaHn/8cd5++22zLFJsbiRJoqSkRN/lo7KyEnd3dzw9PfHw8KCoqIgzZ84YdR1kTU0NCxcuJD09nUOHDhmtxMu1jFn8vU5JSQlTp07F1taWnTt3tvl6ROHWIgKfIAgdznfffceTTz7JzJkzOX36NNnZ2dx5550oFAqmTZtmFkWKzZ0kSZSVlaFSqVCr1ZSVlSFJEj4+PvTu3dsoZVFqa2t5+OGHiYuL48iRI0bbCNIaLSn+Dldn9qZOnUqnTp3YvXu3+AIimJwIfIIgdCjr1q3j2WefZdu2bdx+++3odDpOnz5NREQEkZGRZGRkMGXKFBQKBTNmzDDJ7cL2rqCggJiYGNzd3amoqKC0tBRXV1f9pg9DlEnRarU88cQTKJVKoqKi8Pb2NsDIjaO5xd+Li4u58847KS8vZ8uWLfXWI3p4eIhuIYJJiMAnCEKH8eOPP/LEE0+wc+dObrvttuv+u06n49y5c2zatInNmzeTkpLC5MmTCQsLY+bMmSYpUtzeFBYWEhsbS69evfRdSSoqKvS3fYuLi3F2dtaHv5bcptTpdDzzzDMcO3aMI0eO4O/vb+gfw6CaW/w9KiqKSZMmNXislJQUAgICTDh64VYlAp8gCB1GRkYGV65cYfTo0Td9riRJXLhwQR/+EhMTueOOOwgLCyM0NNQoRYrbm6KiImJiYujZs+cNQ1hlZaW+1EthYSGOjo76Lh+dO3e+6Tl0Oh0vv/wyu3fvJioqSoQfQTASEfgEQbjlSZJEfHy8PvxdvHiRSZMmoVAoCA0NxdXV9ZYLf8XFxURHR9OjRw+6du3apNdUV1frZ/4KCgpwcHDQz/w1VFZFp9Px+uuvExERQVRUFD179jT0jyEIwv+IwCcI7YTo32kakiRx6dIl/Zq/c+fOcdttt6FQKJg1axbu7u4dPvyVlJQQHR1NQEBAi2fcampq0Gg0qFQq8vLysLOzo6ysDBcXF4KDg5EkiWXLlvHdd98RFRVF3759DftDCIJQjwh8gtBOiP6dpidJEsnJyfqZv9jYWMaNG0d4eDizZs3C09Ozw4W/0tJSlEol3bp1IzAw0CDHrKmpITc3l9WrV7N69Wq8vLzw9vbm0qVLHD16lMGDBxvkPIIg3JgIfILQDoj+nW1PkiRSU1P1df6USiWjR48mPDyc2bNn4+3t3e7DX13Y69q1K927dzfKOQoLC3nqqafYtWsXlpaWdOnShblz53LXXXcxfPjwdv87FARzJTptCEI7cOLECZydnfVhD2Dy5MnI5XJOnjzZ5OMUFRXh6Ogowl4LyGQyAgMD+fvf/87vv//O5cuXUSgUREZG0qdPH6ZOncqXX35JZmYm7fF7dFlZGdHR0fj7+xst7EmSxE8//URUVBTHjx8nLy+Pzz77jJycHO688066devGf/7zH6OcWxBudSLwCUI7IPp3mheZTEa3bt144YUXOH78OCkpKcybN48dO3bQv39/Jk+ezBdffEF6enq7CH/l5eVER0fj4+Nj1LD3n//8h7fffpsdO3YwcuRIOnfuTFhYGOvXr0etVvP111/Tp08fo5xfEG51IvAJQhsS/TvbP5lMhr+/P88++yxRUVGkpaWxYMEC9u7dy6BBg5g0aRKff/45qampZhn+ysvLUSqVeHt707NnT6PcUpUkiR9//JFXXnmF7du3M27cuOueY21tzfTp0xkzZozBzy8IgljDJwhtSvTv7LgkSUKlUrFlyxYiIyP1mxPCw8MJCwuje/fubb5eraKiAqVSiaenJ7179zbaeDZt2sRTTz1FZGQkU6dONco5BEFonAh8gtAOiP6d7ZskSeTm5rJlyxZ9zbn+/fsTHh6OQqEw2sxaYyorK1Eqlbi7u9OnTx+jnX/btm08+uij/PTTT8yaNcso5xAE4eZE4BOEdkL07+wYJEkiPz+frVu3EhERweHDh+nTpw8KhQKFQmHU8FWnLuy5urrSr18/o51v9+7dLFq0iPXr1zN37lyjnEMQhKYRgU8Q2gnRv7PjkSSJwsJCtm3bRkREBAcPHqRnz56EhYURHh5ulDBWVVWFUqnE2dmZ/v37Gy3sHTp0iPnz57N27Vrmz59vlHMIgtB0IvAJgiCYicLCQnbs2EFERAT79+8nICCAsLAw5syZQ//+/ZHLW7fPrqqqiujoaBwdHRkwYIDRwt6xY8eYN28eX3zxBYsWLWrztYqCIIjAJwiCYJaKi4vZuXMnERER7N27Fz8/P334GzRoULPDX3V1NUqlEgcHBwYOHGi0EHbixAnCw8P55JNPePTRR0XYEwQzIQKfIAiCmSspKWH37t1ERESwZ88evLy89OEvKCjopuGvurqa6Oho7OzsGDhwYKtnCm9EqVQye/Zsli1bxpIlS0TYEwQzIgKfIAhCO1JWVsaePXuIiIhg9+7duLm5MXv2bObMmUNwcPB1YU6j0RAXF4eTk1OLZgab6syZM8yYMYNXX32Vl156SYQ9QTAzIvAJgiC0U+Xl5ezbt4+IiAh27tyJk5OTfsPH8OHDyc/PZ+rUqUyaNImPP/7YaGHv4sWLTJs2jeeee47XXntNhD1BMEMi8AmCIHQAFRUVHDhwgIiICHbs2EHnzp2pqqqiS5cuHD58WL+b29ASEhKYPn06jzzyCMuWLRNhTxDMlAh8giAIHUxubi4TJkygoKCAiooKbGxsmD17NuHh4YwZMwZLS0uDnCcpKYlp06Zx33338dFHHxltBlEQhNYT705BEIQOpKysjLlz59KlSxeSkpJQqVT85z//QavVcv/999OrVy+eeeYZoqKiqKmpafF50tLSCA0NZc6cOSLsCUI7IN6hgtBKGo0Gb29v3n//ff1jv//+O9bW1hw6dKgNRybcasrLy5k9ezZyuZzt27fTuXNnrK2tmTZtGt988w3Z2dn897//xcLCgsWLF9OzZ0+eeuopDh061Kzwl5WVxcyZM5k2bRqff/65CHuC0A6IW7qCYAC7d+9GoVDw+++/06dPH4KCgggLC+Ozzz5r66EJt5CioiJef/11Pvjgg5uu2autreXYsWNs2rSJrVu3Ul1dTWhoKOHh4UycOBFra+sGX5eTk8P06dMZPXo03377rWjRJwjthAh8gmAgTz31FAcPHiQkJIRz585x6tQpOnXq1NbDEoSb0mq1HD9+nIiICLZs2UJ5eTmhoaEoFApuv/12/d+xRqNhxowZDB48mB9++MFgawEFQTA+MQ8vCAbyySefUFtby6ZNm/jxxx9F2Gul1atXExAQgI2NDSNHjuTPP/9s9PmbNm2ib9++2NjYMGjQIHbv3m2ikbZ/FhYWTJw4kVWrVpGens727dtxdXXl+eefJzAwkEceeYSNGzcya9Ys+vTpw/r160XYE4R2RgQ+QTCQpKQksrKy0Ol0pKamtvVw2rWff/6ZF154gTfffJOYmBiGDBnC1KlTUavVDT7/999/Z/78+Tz88MPExsaiUChQKBScP3/exCNv/ywsLBg/fjyff/45qamp7N69G29vb55//nnKysrYuHEjVlZWbT1MQRCaSdzSFQQDqK6uZsSIEQQFBdGnTx9WrFjBuXPn8PT0bOuhtUsjR45k+PDhrFq1CgCdToe/vz9PP/00S5cuve7599xzD2VlZezcuVP/2KhRowgKCmLNmjUmG3dHVl5eTlVVFS4uLm09FEEQWkDM8AmCAbz22msUFRWxcuVK/vGPf9C7d28eeuihth5Wu1TX93Xy5Mn6x+RyOZMnT+bEiRMNvubEiRP1ng8wderUGz5faD5bW9s2D3v5+fksWLAAR0dHnJ2defjhhyktLW3SayVJYvr06chkMrZu3WrcgQqCGRKBTxBaKSoqihUrVvDDDz/g6OiIXC7nhx9+4Pjx43z11VdtPbx2Jzc3F61Wi5eXV73Hvby8yMnJafA1OTk5zXq+0D4tWLCACxcucODAAXbu3MmxY8d47LHHmvTaFStWiC4gwi1NrLoVhFaaOHHidTXMAgICKCoqaqMRCULHExcXx969ezl16hQhISEAfPHFF8yYMYNPPvkEHx+fG7729OnTfPrppyiVSrp06WKqIQuCWREzfIIgmBV3d3csLCxQqVT1HlepVHh7ezf4Gm9v72Y9X2h/Tpw4gbOzsz7sAUyePBm5XM7Jkydv+Lry8nLuu+8+Vq9eLf4ehFuaCHyCIJgVa2trgoOD63Up0el0HDp0iNGjRzf4mtGjR1/X1eTAgQM3fL7Q/uTk5Fy3CcrS0hJXV9dGb90///zzjBkzhrCwMGMPURDMmgh8giCYnRdeeIG1a9fy/fffExcXxxNPPEFZWRmLFy8GYOHChbzyyiv65z/77LPs3buXTz/9lPj4eN566y2USiVLlixpqx9BaKKlS5cik8ka/V98fHyLjr19+3YOHz7MihUrDDtoQWiHxBo+QRDMzj333INGo+GNN94gJyeHoKAg9u7dq9+YkZ6eXq9/65gxY9iwYQOvv/46r776Kr169WLr1q0MHDiwrX4EoYlefPFFHnzwwUaf0717d7y9va+rw1hbW0t+fv4Nb9UePnyYpKQknJ2d6z0+d+5cxo8fT1RUVCtGLgjti6jDJwiCIJi9uLg4+vfvj1KpJDg4GID9+/czbdo0rly50uCmjZycHHJzc+s9NmjQID7//HNmzZpFYGCgScYuCOZABD5BEAShXZg+fToqlYo1a9ZQU1PD4sWLCQkJYcOGDQBkZmZyxx13sH79ekaMGNHgMWQyGVu2bEGhUJhw5ILQ9sQaPkEQBKFd+PHHH+nbty933HEHM2bMYNy4cfz73//W//eamhoSEhIoLy9vw1EKgnkSM3yCIAiCIAgdnJjhEwRBEARB6OBE4BMEQRAEQejgROATBEEQBEHo4ETgEwRBEARB6OBE4BMEQRAEQejgROATBEEQBEHo4ETgEwRBEARB6OBE4BMEQTBDq1evJiAgABsbG0aOHMmff/55w+euXbuW8ePH4+LigouLC5MnT270+YIg3HpE4BMEQTAzP//8My+88AJvvvkmMTExDBkyhKlTp6JWqxt8flRUFPPnz+fIkSOcOHECf39/7rzzTjIzM008ckEQzJXotCEIgmBmRo4cyfDhw1m1ahUAOp0Of39/nn76aZYuXXrT12u1WlxcXFi1ahULFy409nAFQWgHxAyfIAiCGamuriY6OprJkyfrH5PL5UyePJkTJ0406Rjl5eXU1NTg6upqrGEKgtDOiMAnCIJgRnJzc9FqtXh5edV73MvLi5ycnCYd4x//+Ac+Pj71QqMgCLc2y7YegCAIgmA4H374IRs3biQqKgobG5u2Ho4gCGZCBD5BEAQz4u7ujoWFBSqVqt7jKpUKb2/vRl/7ySef8OGHH3Lw4EEGDx5szGEKgtDOiFu6giAIZsTa2prg4GAOHTqkf0yn03Ho0CFGjx59w9ctX76cZcuWsXfvXkJCQkwxVEEQ2hExwycIgmBmXnjhBRYtWkRISAgjRoxgxYoVlJWVsXjxYgAWLlyIr68vH3zwAQAfffQRb7zxBhs2bCAgIEC/1s/e3h57e/s2+zkEQTAfIvAJgiCYmXvuuQeNRsMbb7xBTk4OQUFB7N27V7+RIz09Hbn8/2/QfPXVV1RXV3PXXXfVO86bb77JW2+9ZcqhC4JgpkQdPkEQBEEQhA5OrOETBEEQBEHo4ETgEwRBEARB6OBE4BMEQRAEQejgROATBEEQBEHo4ETgEwRBEARB6OBE4BMEQRAEQejgROATBEEQBEHo4ETgEwRBEARB6OBE4BMEQRAEQejgROATBEEQBEHo4ETgEwRBEARB6OBE4BMEQRAEQejg/g9+LgEyZ8xfWAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Step 1: Load a tetrahedral volume mesh\n", + "cube = cube_volume.load(subdivisions=4).clean()\n", + "print(f\"Volume mesh: {cube}\")\n", + "print(f\" Manifold dim: {cube.n_manifold_dims} (tetrahedra)\")\n", + "\n", + "# Step 2: Slice to reveal the interior - this shows the mesh is filled with tetrahedra\n", + "sliced = cube.slice_cells(cube.cell_centroids[:, 0] < 0).clean()\n", + "print(f\"\\nSliced (x < 0): {sliced.n_cells} cells\")\n", + "print(\"Sliced volume mesh (reveals interior tetrahedra):\")\n", + "sliced.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Boundary mesh: Mesh(manifold_dim=2, spatial_dim=3, n_points=98, n_cells=192)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n", + " Manifold dim: 2 (triangles)\n", + "Boundary surface (hollow - no interior tetrahedra):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Step 3: Extract the boundary surface - only the outer shell\n", + "boundary = cube.get_boundary_mesh().clean()\n", + "print(f\"Boundary mesh: {boundary}\")\n", + "print(f\" Manifold dim: {boundary.n_manifold_dims} (triangles)\")\n", + "print(\"Boundary surface (hollow - no interior tetrahedra):\")\n", + "boundary.draw(alpha_cells=0.5, backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Boundary edges: Mesh(manifold_dim=1, spatial_dim=3, n_points=98, n_cells=288)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n", + " Manifold dim: 1 (edges)\n", + "Wireframe of boundary surface:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnwAAAKBCAYAAADN4XaRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/XmYHFle3ou/J/bcl9pUKu1bS93qltTd0zOtZoAZxhgwYIzB2GAW24B9YQxmzDV4AX4YY2yPjQcDhouNt4sx2zXga34GPAPMNEP3MDPdKu1La5dKKlVVLpVL7OfcP2LJiMzIyqWytPX5PI8eSVWZkRGZkXHe+C7vlzDGGDgcDofD4XA4Ty3Co94BDofD4XA4HM7WwgUfh8PhcDgczlMOF3wcDofD4XA4Tzlc8HE4HA6Hw+E85XDBx+FwOBwOh/OUwwUfh8PhcDgczlMOF3wcDofD4XA4Tzlc8HE4HA6Hw+E85XDBx+FwOBwOh/OUwwUfh8PhcDgczlMOF3wcDofD4XA4Tzlc8HE4HA6Hw+E85XDBx+FwOBwOh/OUwwUfh8PhcDgczlMOF3wcDofD4XA4Tzlc8HE4HA6Hw+E85XDBx+FwOBwOh/OUwwUfh8PhcDgczlMOF3wcDofD4XA4Tzlc8HE4HA6Hw+E85XDBx+FwOBwOh/OUwwUfh8PhcDgczlMOF3wcDofD4XA4Tzlc8HE4HA6Hw+E85XDBx+FwOBwOh/OUwwUfh8PhcDgczlMOF3wcDofD4XA4Tzlc8HE4HA6Hw+E85XDBx+FwOBwOh/OUwwUfh8PhcDgczlMOF3wcDofD4XA4Tzlc8HE4HA6Hw+E85XDBx+FwOBwOh/OUwwUfh8OJQSkFY+xR7waHw+FwJoj0qHeAw+E8HjDGQCmFrutwXReyLEOSJIiiCEEQQAh51LvI4XA4nDHhgo/D4YAxBtu24bouKKVwXReu6wIACCEQBIELQA6Hw3mCIYznbjicdzWUUliWBUopBEGA4zhwXReCIIAxFv6hlALgApDD4XCeRLjg43DepTDG4LoubNsGYywUbXfu3MEv/dIvQdM0fMu3fAuy2WzsOVwAcjgczpMHF3wczrsQSmkYyQM80UYIQb1ex/HjJ7C8fB+MMTx//AQ+8YlPQJXExO1wAcjhcDhPBryGj8N5FxEIsyCqFwi9gN//5B/j3r2l8P+n334Lv/rZ8zi4fz/KqoiSIqKkipAF7znR54uiGBOAhmGEj+ECkMPhcB4tXPBxOO8Soo0ZQFysUcZwpaZjVSt1nkAIJElGvjyFpkPRdChutWwAQE4SUOICkMPhcJ4YeEqXw3kXEET1gmaMqLhq2y7eXm2hZjoAgP/1X/8j/ttP/Qsoqorv/yf/Au/50JehYdMNt5+ThVD8lZSOAOyGp4A5HA7n0cAFH4fzFBM0ZjiOE3bhRoXUUsvEmdU2nD6XgedLKralZNiUoWa5qJguqpY7tAAsqyKKIwpAAGg0GpiamoKiKFwAcjgczgTggo/DeUrZKIXrUIZzlRbuNK3w8SlRgO7GhdzRoor5tNyzbZsyVC0X1S0QgI7j4PXXX8d73/teKIrCI4AcDoczAXgNH4fzFBLYrSRF9eqmg7dXmmg5HZG2PaMgIwu4UjNi2+l3NygLBLOahFnNu4TYlIXir2q6aDhxAdiwKRp2pAZQFlD2U8BRAUgIgSh6HcGBwOM1gBwOh7N5uODjcJ4iggiZ43j1eFEhxBjD9XUTF6vtUMiJBDg6lcH2tIxPLa2P/bqyQDCbkjCb6hWAFdNFs48AvOkLwHykBrAgdfaXN4FwOBzOZOApXQ7nKSFozIg2QwSix3QpFldbWNHt8PEFRcSJmSwysog1w8ab9xsAgLRI0Ha9y8KzBRULmd6U7qhYlKFmuqj4EcBuAdiD3sSOUh7TaQUlRYTEm0A4HA5nU/AIH4fzhBP11ktK4a7oNhZXmjBp595uX17DM6UUBP9xtxtm+LuSKqLd9iKEk7obVLoigAMFYCqLOwbFHT+Kl5eF0AewGBGAPALI4XA4w8EFH4fzBMMYw/r6OhhjUFU1JmQoY7hU1XFtvVOXpwoEx2aymEl1ona2S3Gv7TVvyAJBQZFwd8KCr5seAej6TSCWi6rpoOnEX3ndpli3KW7ABoFfA8gFIIfD4QwNF3wczhMKpRSWZeHKlSvQNA0HDx4Mf9eyXby90kTdcsOfzaRkHJvOQBWF2HbutCwEwb+FjAIxpnseTsWHIhLMpSTMpSQAKj7xyU/hmRMvo8nEngggQ68AzMsdI2guADkcDqcXLvg4nCeMwFsvOh4tKMVljOFuy8LZtRb8MjwQAEdKaezJqz0ihjEWS+fuyqmoGnbk91t+OIkQ18G0ImCHpgKIRAD9NHCrSwDWbYo6F4AcDofTFy74OJwnCEopHMcJvfUEQYAgCJ7nHmU4u9bCUqvjrZeRBJyYyaKgJn/Va5aLhu1tq6hKyCkS6mZE8G3hsQwi2k8WjwAClktRtWhoBD2sACwrIgpcAHI4nHchXPBxOE8A0caMbrsSQgh0iHh9qQ49Inx2ZBU8V8707XAF4s0au7JeNI2g8/hHJfgGiSlFFDCXEkIBaLoUtVAAOmhFagAHCcCiIkLkApDD4TzlcMHH4TzmbDQxgzGGmpRBRcoAvtiTCMHz02lsz6gbbtehDEstM3zOfEZJePEJHsgWosYEoArTpbFJIMMIwGgTCBeAHA7naYMLPg7nMSaI6rmu2yMiDIfi1GoTFTkb/qyoSjgxnUFaFgdue6llhnV+27NKJM3ZeczjktIdFVUUsC0lYJvfjTysALzuC8CC0jGCLspcAHI4nCcfLvg4nMeQoDHDcZxEb73ltoXF1RbsoL2WMRwopnCw2PHWG8SthHRusK3wn5s7jLGZtDjqJwCDGsB2lwCsWV6K+HqTC0AOh/N0wAUfh/OY0Z3CjYoDlzJcqLZxMyLWJOZiyqjimdKhoV+jbjqhZUtBEWNNHVEZ8oRkdEcmSQBWIrOAg0kjwMYCsLV8F//+pz8Gx7bx3d/93Th69CgXgBwO57GECz4O5zEisFtJiuo1LM9bL+iqBYC5tIzcehWWYyZtri+3mp3H78zFa/1iwuMRTl58mFMfVVHAfFrAfNoTgIZLw/RvPwH4oNHGh//cl6O68gAA8Ju//dv41J9+HvsXtkEko0UAXdeFLMtIpVJcAHI4nC2BCz4O5zGAMQbHceA43oSL6ILPGMOtponzlXZokCwQ4NlSGrtyKq41HsAcQRw5lGGp6Vm3iAQ9zR2PQ4TvYYsdyhgMl8Fwqf9359+EAAKA7um/y7dvYe3+vfD/7WYTv/Xpz+PF938xCoqAsp8CLijiQAF4/fp12LaNgwcP8gggh8PZErjg43AeMdE5uEBcFFguxZm1Fu63O954OVnEiZkMcooUPn6UaNi9lgXHf/x8RoG8gW3L05DSDTwKdZfB9IWc3iXuLDr6kU7PLyCdy0FvtQDGIIgSduw/EEsBo2lDQLwGMEkACoIAURQhSRJPAXM4nC2BCz4O5xExqDFjzbBxaqUFw+3ElnbnVBwppcOmAWB0wXe7GW3W0Hp+/7joiGGPyaUMBmUwHNr5uytK1x2dGwWBAJpIoIkCJMKwZlK4DEhlMviR//Br+L//5T+BY1v4zu/9uzh2YA+qpgs9kgKmAKqWZxQdE4CqhJIioqAI4bHyJhAOh7NVcMHH4TwCNmrMoIzhnZqOK3UjfLwsELwwlcG2BK+8UQRfw3JQNb20cU4WUVR77VtiKd1HNVotks42af90q+FS2JtRcwBUgYSCzvs7+m8BsuDtz3LbxpmaGYt6Pn/8OH70P/86AOBQXsHurPf5GF1NIMkC0EurCwAUtQTVMVExXRQVIey05gKQw+FMCi74OJyHDKUUlmUlRvXajotTK61QlAFAWZNwfDqLlCQkbm8UwXe7q1kjSRREf7bVes+hyULOWjiItxqAtd7a1D6IBDEhl4oIOU0kUEUy0MaGMYbzNQN3207s53syMnKKgDPV3oYZTRSwPS1gu98EojtxH8BuAWiIKgxRxefXdD8CKEZGwXEByOFwNg8XfBzOQyJI4Qbj0boX4XstC6dXW2F9HQFwsJjCgYK24WI9rOBzKcOdZieqtJA0WQOTa9qgLKiZi0fkouLO6fcCqRzMAS9OAKgJEblolE4im2sAsVyKz63pMaNmAcDxsoYpTcJ93e7/5OjhSAJS0vACsGp5P7/mv17RF4AlLgA5HM6YcMHH4TwEKKVwHCcxhetQhvOVdiz6lpIEnJjOoKTJA7c9rOC737ZCo+ZtGQWK2C9iOHBTXlcxQ4+Q8xojOqJuM0hg0CQxHpmTOqJOEQZH5zZDxXDwdsWI1f+lRIL3TKeg9nnvhqVbAJ5/5xoMQYZamkHFcmPvHQVQsVxUfN9ELgA5HM44cMHH4WwhjLGwC5cxFluQAWDdcvDWShOtSCHafFrB89NpyMJwomJYwRdr1sj1n7PbPb5tqW0nRuk2o+cIsGHd3FufeQPHX3ge+Xx6/BcZE8YYrjYsXG/Go3dzmojnS/2jrZuRSzJzIbsuDpa8JpogAhjUAW4oAAlQlLkA5HA4G8MFH4ezRXQ3ZkQXX8YYbjRMXKy0wwiSSIDnyhnsyCojLbbDCL6W7WLN8GrQ0iJBRhJQNx3oDoXuUu9vx4XhULQixs4rposV0+232b4oYSNEcrpVEcjGaWq2yU6MMbEpw9trOupdnSDPFlQsZHqjrVvV1NIvBZwoAFl/AVhWROS5AORwOOCCj8PZEoKonuu6PYul6VKcXm3hQaT+K6+IODGTRVbu7ZodRLfgcymD7lIYTkfIRX38dJfhE3fqYx5Z3KakX5RO3KQ4eBTiYt1y8Pk1I1ZXKBHg5ekUcmN8LqMQRH/7ERWAzDeJrkRqAPsJwKvwBaAihkbQeZkLQA7n3QgXfBzOBBnkrbeq2zi12oQZWaD35jU8U0oNJZKY3wihO9QzEHZcrLoS6oV5vL5Uh+HQgSbCg4JSIihceOnkjEiwIyMn2pRsNQ9rtBpjDLdaNi6vW7GfF2QBL06lIG1gTD1Jhn1PCSFISQQLkoAFXwDqLgubQCqmC5N2CUD/52h4ArCkiKERNBeAHM67Ay74OJwJMchb71JVx7X1jreeIhAcm85gNt3plnUog+64EUEX+eNH7XplkARoWdjW4NQrAZCRRS9iJHpRI82PHslguHbpAlbqDbi7ngUAtCsruH/zAUqlEoRSCeliEYQ8PZcNhzKcqRpY7Upb78nKOJAbLbX+qCCEIC0RpLsFoB/9SxKAa6aLNV8Ain4EkAtADufp5um5cnM4j5DAbiUa1WOM4Zd/+ZfxqU//CeaePY73fMVfCBfBnCxiLi3jgW7jZsMMBZ0zxoivAK8RoiPgAlF3q2li3ReDL89mYwIzoF6v49TiIjRNw4snTuDNNa/BY2ZmBtvKKVSrVVy5cgWGYSCXy6FUKqFYLKJYLEIUJ5/ufBhioWlTvLWmx8SQAOBYWcX0EN3Rk2SS0cyYAMzEBWCQBo4es8sFIIfzroALPg5nEzDG4DgOHMdriIgubL/wC7+A7/3e74UgiqCui79RreEr/upfBwA0bBeN+mjNELLg25N0CTq9UcfSzet47b2v9NiUtB0XZyttAF4d2EwqLmQYY7h58yauXLmCffv2Yd++fWjZDgBP8AmiiLnpOczNzQEADMNAtVpFtVrFxYsXYVkW8vk8SqUSSqUS8vn8xATgVqZ077YsXKhbsWhpSiR4aSrV1+B6IJvUM1sliPoJwOgkkGEFYFkVkeMCkMN5IuGCj8MZk6Axg1KvozO6+NmU4Zf/+295j/NTvJ/7w/8dCr5uCNBJr4oRQScJ0EQvBduvlmxFJ7jn2ImedHcakcka2fhkDcuycPbsWayvr+Pll19GqVTy9yUyaaNLc2mahvn5eczPz4eLeiAAl5aW4DhOjwAUhrSXeRi4/tSM+3pcbM9qIo6WtE03mzwJRAXgDl8AtrtSwNYQAjBoAuECkMN5MuCCj8MZkUGNGTXTwdsrTczsOQjy+ifBKAURBOzYf7BnWwRAURUxrcmYTskoqtLIZsL9bFkYY7jd7DQi7Mx2vPeq1SoWFxeRz+dx8uRJKEry1A22QYsHIQSpVAqpVArbt2/3hEO7jVqthmq1ijt37sB1XRSLxVAAZrPZoQTgViz+LYfi7TU9NtUCAJ7JK9iVTT7+UdjMHj+sBpUkCCHISJ5Vz6YEoO8DOIoAvHTpEnbt2oVsNssFIIezxXDBx+GMwEaNGYwxXFs3cKmqgwH4K9/799CoVXD+s2/i2Zffix/4Rz8EXRTQjHi8McBbWE0XV+oGRAKUNRlTmoRpTUZeEQcufP0E3wPdhuF6rzWbkqFJgreP167h2rVrOHjwIHbv3t2z/XGXWUIIMpkMMpkMFhYWwBhDq9UKI4A3b94EY6xHAPY7vkmKoPttG+dqZmxqhkSAF6dSKCjjp6AfnUzbOjYSgEENYF8BCE8AliKTQDYSgLVaDTt27OiJAIqiCEmSuADkcCYIF3wczpBQSnHv3j00m80eoWQ4FIurTaz65sYAoKXT+J5//m8AeOLilV3l8LFrho01w8GqYUN3OjLEZcCKbmNFtwHokASCKU3ClCZjWpOQlXsFYD/Bd7sRn6xhGAbOnDkDXdfxyiuvoFAoJB5ndPObETSEEGSzWWSzWezcuROMMTSbzVAAXr9+HYSQUPwVi0VkMpmJLuyUMVyqm7jTdmI/z0sEx6c2PyItzpPnPTgMGwpAPwrYLQBXTTfsfJZIfBScYLbxv/7X/0IqlUIul4MoiuGfIPpHKeUCkMOZMFzwcTgDiDZmNJtNrK2tYc+ePeHvl9sWTq+2YoteURVRi1h9RCNLmiRgIatiwU+xtv0pGKuGjTXDjnn0OZRhuW1j2TdOVgWCqZQcisC0JCQKPsOhobGzKhKQZh1/cvYMpqamcOLECUhS/69+dBmdZKaREIJcLodcLoddu3aBUopGo4FqtYqVlRW88847EEURpVIJruvCMIyBhsQboTsUpyoGmk58asaOtIRnCuqWzuEdlUeZ0h2VRAHoxI2go98FJyIATUPHD379n8OtKxcBAO9536v4zd/4jdi2k1LAXAByOJuHCz4OZwMopXAcJ5bCDRZnlzFcrLRxIxJJU0WCY1MZLK62YtvZaD1PyyLSsoidOdVLgzoUa7rtC0AHdmTxNCnDUsvCUsurzUuJAnIig50pQndo2GF6p2mG0bm02cTixYs4cuQIFhYWhkgRR/Z7w0duDkEQUCgUUCgUsGfPHlBKsb6+jmq1itXVVVy8eBHXrl2LpYBTqdRQ235gODhbNWLzfgmAZwsKtmc2X6/HiSMLQF4WoAgEeZmg6TA0bG8CSHRyyfnPvhmKPQD47Jtv4Hcu3sHh/XtiNYCkTwqYC0AOZ3y44ONwEggWFdu2wyhT0F1IKUXDcnFqpYn1yNzZuZSMF6YzWDOc0OZCFghs6rU+DBOtIoQgK4vIyiJ25zUw5i2cq7qDNcNGxbBjC6juUugugJld+IM7NWQkAVOahHvBKDXG4Kws4dVXX0U2mx3y6B/NQikIQujtt7y8jAMHDkAQBNRqNdy7dw+XLl2Cqqqh+CuVSlBVNbYNyhjeWbdws2XHfq4KwImprR+RthkeV4FC/VFuhkthuJ6li+FSGE7nZ8NOPs7k42UERBCgZjKJKeCy6ncBS1wAcjiTgAs+DqeL7saM6CJDiABdy+GP79URBN4EAEfKaezOebYnt2MRPwE29bbDMLqUIoQgr0jIKxL2FTRQxlC3XKzpXvq3YjqIejW3HIpWpDOXgKF88Dm0BAWqSyEPUbO2VSndUREEAeVyGeWyV/voOA7q9Tqq1Spu376N8+fPI5VKheIvnS/ifNPFuh2XH2VFwAvlFOSHNCJtHB5VSpcxLwLnTXXpCLhA4OkuGziqbyMIAJl4JQ0OAw6+cAJf8+3fhd/6xZ+DKIr49h/4YZTK5dhNjJNQAxjU/5VVEVkuADmcseCCj8OJEET1XNftWRRsl+KGK6OZnwtznVlZxImZDPKK91Vq2y5WDC+6lJK8FFcAG0fxdSEQgpIqoaRKOIAUXMawVF3HuRt3kJ/fiZrpxNKwjAi42bRw0xeBBcWzgJlKySipUqK3X0zwbW53N0W3CJIkCVNTU5iamgLgCcDAAuad+6toWyogxi9pezMS9ufVd+3iTv3Zy/EIXVzUuZv4kEWCyJxl3xjcn7msiQQuo/jcmoGgjJIQgm/9/n+Er/+uj0CURKj3r+N9RRGupIQWMFXLRVSzOwxYMVysGFwAcjibgQs+DgeDvfUqho1TKy3otJMS3JVT8WwpDTEimm43I52xWRVrRie1uBXiSSQEJUWEuLaEFw7txls3r6AxdwAgnn1y92vWLRd1y8XVdQMEQEmVvAYQ3wNQJCSm+Dby4dtKhll8AwFYU3JoN+MpXFAXwt2rqBAHLNIFvFGzymbZrFwYR3A4tBOJi4q6aKRuMygCQSoi4DTJ+3fwM4n03+97bQvnavFpJiVFQF4WcBNp/ycMgiAg5Zcx7MwgrGONNoEMIwADI2guADmcZLjg47zrGeSt907dwOWaHj6eUBcn5gqY7yr+p4yFgo8A2JFVUTGd2O+3qj6OUoo33ngDub3PhF0Xe/MaDhQ0VEwHq7rXANKI1BwyABXTQcV0cKVuQCBAWZVQ2oQv3cPEdCnOVA1UrXgKNyMSHJ/NQZo9GlrABHOAs9lszAZms2PgJiWH+xlnmzQi5BzWFaGjsVToqAiAL+I6UbmUH6kLBN44ncyMMZyvmVjS41Y4+3My9uVUXFk3Iw/uFYzROtZdvgBsOjQUf4MEoByJAHIByOF04IKP867Gdd1wPFr3RV13XJxaacVEW05gYEvvYH7fqz3bWtE7liqzac/oOFoxtxWxMsdxcPnyZTDGcOzYcZy3ZAT5s105FbIoYC6tYC7tiVPT9T0A/SaQVsSyhDJg1XBiXoJNm+Jm0+pJnT0MNqprq5gOTlfNWAczAMyqIp4raX6qWsHcXHwOcJACvnTpEkzTDMfAFYtFFAqFic0BHgaXMhiUwXAoWkoWhphCs2rEInSbOWdkIUizRiJ0/t8pkUAWyMQ/T9Ol+NyqjnYksijAM7guqd57G//IhmtkyskicrKIXUgQgKYLO7JNmwEPDBcPuADkcGJwwcd5VxL11gPQcwG/17JwZq0VExSHiimUnDbOO3bP9gDgViOezgW6LE4mrPjW19dx6tSpcCyamC+idb8BAChrEjIJHamqKGB7RsX2jLd/uuN5AHo2ME44mSPAYcDlda/+Txbg101JKKsi0uLkBUPARtM3rjdtXG1YPb87lFewKyP3fa6madi2bRu2bdsGANB1fcvmADPGYFOWmGoNulxjvSUZry4RXVGxfhAgJuBiETpJgCaQWKnBw6BiOni7YsQEXUokeGU6BSXSLBTXe6P7LG4kAIM0sLORAPTP46AGMMMFIOddAhd8nHcdQWMGpd6KG13UXcpwvtLGrUgtXkoUcHwmg7Imo1LRw+dF0R03NDrWRAEzKRkAQCIpXDohxccYw61bt3D58mXs27cP27dvxyc/+clEwTmIlCRiR1bEjqzqG+hSrOgWzlX0nsfaNL5wqgLxaqf8+qnAA3BSdEf4LJfhbM0IR3gFSAQ4VtZQVke7nHXPAY4KwGAOcKFQCAVgLpcLz5XAqqQVSZEv6TaWdWdkq5IkpEgzREqKizpNJFC3IDo3LowxXG1YuN5VR7lNE3G0pPXsZ+xj3YSxdsDIApD2EYD+ecwFIOdphQs+zruGQY0Z65aDt1daaEYW8fm0guen0qGdSdR4OcrtiBXKzpwaWTAirz+BY7AsC2fPnsX6+jpeeukllMtlmKYJJoi43w4icQTb0qObCxNCkJFFpEQV5yvePOCMRLAjLScunCZluK87uO9HpVIiCRfNsipOdGxZzXRxumqE/oYBOX9EmrbJ1yKEIJ1OI51OY/v27bApQ7XZxtp6E/cNE9furIJJdQhaGkxS4BKC7nrMujW8xOsWcJXl+8iqMnbPz3nNEI+xhUwUhzK8vaaj1mWF82xBwUIfg+t4onrzgq+bfgKwEkkBbywACUqKEBpBcwHIeVrggo/zrmBQY8bNhokLlXYYlREJ8Gw5g51ZJXahJoT0RPgYYzHvvZ3ZzkIXXbc3YWcGAKhWq1hcXEQ+n8fJkyfDVC4hBKwwHUZOFjLKptN5QYcvAcGurBIunA3b654MFs/oMekug952sOTPrc1IBGVF8uqnVDFmUTPw9aOfTcvGlfXeFO5CWsLhMUakjWRVImaBTBbI+M8dYvuDrErUhGaIs7cayKl5ZB9jY+huGpaDz1eMWGpaIsDL0xsbXHeV8G25EIoKwN3wz+OuGsC4AGQ9ArAcmQWckQgXgJwnEi74OE89GzVmWC7F4morTMcCQF4RcWI6i2xCt2pShG9Ft8Pat9mUjJTUeV40pTtuCT5jDNeuXcPVq1dx6NAh7N69uzdNVpgJ/70rN1w6dyOIr/hY7GcEeUVEXhGxJ+sJp3WrIwBrlht7fMthaDk2bvtTP3KyEFs4B0WxbMqwWDXC7ssoRwoqdmTkxOc9DKsSTSSQmAvDstEW/BrKyj1MExvlYgGlfBHpdOqpXdRvtyxcrMdFeF4W8NJUauDnyroV30OGEIK8LCIfFYA2DX0Aa1avAFw2HCz7zUyKQMIU8LgCUBAESJIEWZa5AOQ8NLjg4zy1RBszGGM9F9VV3cap1WbYWQsAe/MqnimlPT+6BJIifNF6v26xtdmmDdM0cfr0aei6jve+970oFAo9j1m3KaB5vmZFVUJOmeTXuv9OC4SgqIooqiL25bzZwjU/YlIxvYkX0Wc3bIqGTXGzZYPAEwjB+KyiIobvOWMMjqzhsqvBduNiTwbwXEmDLBLc121PwDlbYFUiCl2ec8lWJXdaNi7Uvc9/57ZZSI0KHiwv450rVyBJUmwM3EZzgB/VpI1RcRnD2aoRRr8CdmVkHMorQ4mW2E0EHv1IueiNzO5sPJJdTRCA1gYCsKyISA8hAHVdx2c+8xl8wRd8AQRB4BFAzkOBCz7OUwmlFI7jJKZwKWO4XNNxtW6Ej1cEghemM6F9ST+6I3yGQ/HAj2CpIgmbNcLHR/dpxGNYXV3F6dOnMTU1hRMnTvQ1Db7b7kQnh23WGESw1IyiQ0RCMKVKmPKbJxzKwpRZxXLRiOT+GIC6TVG3Ka43PQGoOgZ+4nv/Jv7kj/4A2/fsww/87H/E9j37wucIABwAp6oGxmUrrUrSqTQWpgvYu3cvXNfF+vo6qtVqbA5wsVgMBaCmabHnP+4LfNuh+PyqDiOSxycAXiipmE0lR1uTiJ5Tj+MRd0eyNyUAu7rZowJQEATIssxTwJyHBhd8nKeK4OJp2zaY3wEYvVC2bRdvrzRRszoRimlNwrHpLLQhukwJIeFdOiEEd5pmGLHYme2tJ4u+9rBRHEoprly5glu3buHIkSNYWFjoe7F3KMM9X/CJBD1m0OMSCr5NbEMSCGY0CTOad5kxXer5/Jku6haNNWAwAP/l//q3+PQffgKMUixdv4b/60d+AD/6n389fMwgwfzIrUoimxZFMRR2gFdWUKvVUKvVcPfuXVy8eBGapoWPSer8fpxYbts4UzNj54MqELw8nUJ6xO7saGnDk6BhkkoZghRwUAfoDhKAkUkgaZHEMg68BpDzsOCCj/PU0N2Y0S327jZNnF1rhXfnBMAzpRT25XutI/oR2HIE4i2azt2ZEF2LGS8PoZ7a7TYWFxfhui5effVVZLPZDR+/1DLDxWabljwbdywSavgGEViVdBohohMiBluVVFceeIIaAKUuKsv3enZJEQjSEkFGEiJ2JY+fVUk3oij2nQN88+ZNNJtNNBoNtNvtUATK8vBRs62CMoZLdRN32nF/wClVxLGSNpaA7k7pPmkIhKCgiCiMIgB1B8t6RwDmBAY3P42WQ/tGALkA5EwaLvg4TwVBVM913Z6Ln0MZzq21cKfVKTJPSwJOzGRRHNG7LUwLU4qqzaD7kypmNBnphM7E6DV4UAzn/v37OHv2LObn53H48OGhpj5Evfe2pybX4dm9dDDG4DDEjIODUV/Bz6xNtiF/0Vd/LT7+6/81jKJ+6V/+lvg+wLOCMS2GlsNQUgBJFaHIj7fYS0KSJExPT2N6ehoAcOrUKaiqZ+dz/fp1nD17tmcM3FbOAU7CcClOrelodBVF7s8p2Jvtb3A9iMc9pTsqfQWgX8pQSxCAa5QAs7vwJw/aoZ9lKRIB5AKQsxVwwcd5ohnkrVc3Hby10kQ7MkJsIaPg6FRmrGhYNMJ3q9GpJdvZpzM2muLtl9J1XReXLl3C0tISjh49Gk6CGETddFAPUtNGC1lJ2/gJG+BZlVDoDkXL7ixQlsvwJw/acauSMUiyKlEEYFl3seYfw+EXX8FH/5/fxeKnP4U9u3fhaz/0xZAL3jzi7vmp3WkzTSTh5ISyKm7al+9hIwgCcrkcduzYAcDzW6xWq6jVanjnnXfQbreRy+VCAVgoFLZUAK6ZDhYrRuwzFwlwrKRhStvc63Z3fj9txAQgOgIwsDLqFoDdfpZRAVhWRaS4AORMCC74OE8sg7z1rq8buFjVwwVGJMDRqQx2bKKxIdi+4bhYDpo1BIK5dHL6LXqJTdJLzWYTi4uLEAQBJ0+eRDqdHnpfbkfSyUJ9FYyV+z7WoQy640J3PFGn++JOdygMh8JwaeL+USA2b7cfitDdCOHXz/mdrhKJL+5Nm+J01ejZ9p7Dz+GD7zmB6uUzSAsM2zIydmbkmHluJSFtZrgM93QH9/xFMy3Gp4AoD0EAbmY57b4ZUJT4HGDTNMMpINE5wEETyKTmAPebmpGWCF4spyYyTeVpi/ANIioA98ITgHdWq7i+UkFubmFoAViUBfzer/8y/viTf4QXXngB3/M93wNJkrgA5AwNF3ycJ5KNvPUMh2JxtYlVo1N3VFBEnJjJJs6XHYXgdZZadiiQdiQ0a3Qe3/l3d8bz7t27OH/+PHbt2oWDBw+ONLfVpQx3/ekeIgFIu4G65aIOsyPqfDHXdimcTaRbR7UqGcS9to3zdbPn/ZAIcLSkYUaT8FZC80tonpuNR00C77SodGy7DO22g7t+7VlWEmKF8/KEah0flpmKqqqJc4BrtRouXLgAy7JiY+DGmQNsuQynqzqqXRND5jQJz5XUvlZFoxKP8E1kk08UAiFIwUWqWcGLzx7w/CztiBF0l6F5IAB/+Zd+BT/7Dz8CIgj4zd/8TdxeWcOP/9iP8QggZ2i44OM8UUS99QD0XKgetC0srrZi9WT78xoOlVIjT2RIImgquBsZct8vnQsAQoLxsuM4OH/+PFZXV3H8+HHMzMz0ezoAT9x1InJelG5Nt+H4oRKXAdh7FG/XHXjGJaOhCF4Xa0oSvKkQkoBrdR0W9UTYF2/LTGQxcP0GgLvt3n3MSgKOlbVYx+dGXc2xqEnOE4A1i6JqOqhYXhdw9NlNh6LpUNxueZGr0ANQ8f5saffukIzyHm9mDnASNcvFqTUddtdb/kxewc7M+PV6ScS6dCe21ScLlzIw2StX0F3mR9kZKAMUAhgJp/7pN16HIAhhR/fHP/4JfMXf/vthOUOQBuYCkNMPLvg4TwzRxozArT7AZQyXqjqur3fq6lSR4Ph0FtMjeIQNghACpPPQ/RzMlCZtGDXsjvCtr6/j1KlT0DQNJ0+ehKqqYe1cGJVz3dj/N9MMQQBPzIm+oAv/iOHPusUOYwy31g1Y/sI8iQt/y6E4XTHQTEgPb0tJeLagbkp0CYSE9Xv74S2oNcsNp4Csd816Xbcp1m2KG/A8AAtKMAVEQlERJnJzMAqbMV6OzgFeWFgAYwztdjsUgLdu3QJjLEz/FotF5HK5sDnmdsvGpa7RdRIBjpdTKKmTH/UWS+k+paIiadqLHulWN2kKmNuPz68N7ym579nn8fr//C0A3o3ugeePAegtZ4gKwLIiQuMCkOPDBR/nsWdQY0bT99Zbj3jrzaZkvDCdgboVtVul2fCfo4wxu7laRWNtFdkdB8DSWby5akB325uesZuVBLTrVcyViyiktYi4E6GK43WvTvLavqw7OFczepo+CICDeQW7EiJIm11cRIFgSpPCBgM7agJtujHhyQDULIqaRYGmDQFA0S+YL6ki8vLDF4CbgRCCTCaDTCaDHTt2ePWPzWaYAr5+/brnLVcqQS8voEni3o05WcDxsrZljS9R98Un6X0NYIzBpiwu5iKd6/pQ0176H7fkNzipgnfervsb+3Pf8u1ortfx1qf+AAePvoD/3z/5cZiSiJodTwH3E4BBRDtah8kF4LsLLvg4jzWDGjPuNC2cq7RCMSEAOFxOY09O3ZILkuVS0GwRACAToKxKWLecWETOa4rwonTRsW01KMDUdtQBwBgu9ap1R+ZEASu6jWV/9u+z5TT25jX84ZW3sW/hBIqF/uO7xmEzWpQyhsvrVphGjaIIBM+XNJQ3iCBNctyYLBDMahJmfQFouZ3JCRXTRTvyOVHAiwxaLtDwaiSjHcBZaWsWu61aQAkhyOVyyOVy2LVrFyileFBv4kKbwSHx97/ITBxOqVC3MMUdvNMEj2eEz+tYTxBzbmeE32Zu0hSBQHBtMNPAtqkSNMnrWg9qYmWBeHOkK3oo9gBAlCR8y/f9AL7x7/wANJHg6Fwm3N+61fEB7K5n5QKQE8AFH+exZaPGDJtSnF1rYynirZeRBbw4k0V+QrNko1YlwZ/ltg0Q7wLpMOATd+pjb18kiKVXNSku7jSxN7LkMoZLNR2AJ24X/MkaQXpuUhDfeXncTeqO14XbnUoFgIIs4IUtjCANgyIK2JYSsM1P9xuub5vhe6cZEQHoMmDVdLFqejcdMoHfASzBdCczIeNhztK9Z7i4oAtgkVOLgGHaboJV7uPzV+qxOcDFYhGpVGpiC/qjTum6gUG4kyzmTJeNfaND4JWSRDvWQzHnG4WLhOD27duoNqs4tK/XgqluuXi7q55SJMDLUym8taaHrxMgEN/GRRWB3HgCsBytAeQC8KmFCz7OY0dQg2RZFlRV7bl4VA0bb6+2QtNjwJty8Ww5PZK33rhWJeF+Dti+yChc2wIUzx9vLi1jR1YNU67jzG1dblmw/fDCtowS2o1MXvB5jLPFB4aDc1UjMa21kJZwuNC/qzl8/Ye8WGiigO1pAdvTngWM7jKvA9hfNKN1lDYDHhguHhhubBtVy+1ZMB8nXMZwsW5iqatpRhEIjpdTKCg5YPd84hxgRVFCAZg0B3gUtjLCFzMId3ojdMYmDcIFgmQx51sQDWsAHtzEdu/7jaaFdxrxiHhGInh5Kg1FJAjOuI2+P+MIwCXdwZIvAFPdTSBcAD41cMHHeawIGjNu376NarWKEydOxFK479QNXKl1vPUkgeCFqUzPDFnmp2Wi6dWomNNdGgqncclI0ahcpAmCOrhy/hwMvY2FIy/gYsu7vJZVCdvSm5t1Gx3ltiviJzhpwTdO+yRlDO+sW7iZkMIVABwuqljo41eYxMOMekUhxBvflpYE7PA9AFuBB6C/aCaJ2aW2g6W240VMIhYww0Yyt3JBbDkUi2s6Wl2FlEVFwAslLVbrmjQHuF6vo1qt9swBDhpBVHX4Wtbgcx1H8DHGYNLuRoh4lG4zBuEyQRiJi4m5MN06mc+pW/BZLsOZqo5KjyWOiKMlLRR4wVdilIx7twB0GcO61SlpqHcJQN1l0PsIwG5Tcy4Anyy44OM8FgQXCdu2w8HijDEQQvDpT38at+7eQ/mF98DRcuFz8rKIfQUVNmW4VG2HnnOGL+w2IxdkgcTq5lKSgOW2jYrpXQT3qwyH54s9z1tdXcXbp09jamoKL544iVWTAq0mgF4fvlFp2S7W/Nq/jCSgHJl48KgjfIbrdeHWE1K4mkjwQklDQRm+4/NxWgwIIcjKIrKyiF3wztWG7S2Yd9s22l3qz3BZKP4AL0JTUqSwCURJWK23Utwu6w7OVo2e0X67MjIO5pWB0VZRFFEul1Eue8be0TnAt2/fxvnz55FOp2MpYEXpf2Oz0aSNxHnMTjzlupl3ShX8SS9Sr5jTRDK5WdQDCK5tAFAxHZypGLC6DuxgTsHuyAg7xjrHvpkYspggAKMRwKEEYGQSyDgCUBAESJIEWZa5AHyIcMHHeeR0N2YEd4SUUvzYj/0YfvzHfxwAUJrdhn/5338PxWnPt27ddnFqtT3y6/W3KhGgiV4Ko/vCb7s0rJ0j1EWpS7tQSnHlyhXcunULR44cwcLCgnfxszo1hptd0qOTNXZ2NaVsleAD4otTEquGg7M1AwlaD2VFxPMlDYo4+sX8UUX4BkEIQV4RkVdECAS4VPc+41lNhE3Rs2C2HIaWY+OOP5klF5hA+4vmVokMyhiurFu41RVxJQCeK6qYHyHaGqV7DrBt26EAvH79OlqtFrLZbMwGRpa913Jop+GBAWjnpnG6aoSiztysBVEQmZuAQfhWQikFEQRcbVi41ohb4ggAXih7BuSx50TemkkehxixNOoVgA5qXZ6WusugR25oAgGYFNHuJwAbjQZOnTqFkydP8gjgQ4QLPs4jJeqtF/2SC4IAx6X4Fx/9aPjY2soy/vj//9v4ym/59g23KRHSI+Q6TRFxX6phudOywguu3K6DZPPh73Rdx+LiIhzHwauvvopsNhv+LrqWb0bAUMZwp+EJPgL0jIebeEo3AkNyhrffGK6A3RkZB4aIID3RRN7yWU3CfFr2F0w3nAKybscXzIZD0XAobrU8D8C8LMDKTqHJRLiUTcQE2nC9FO56V/RREwiOTWnIb3LiTBRZljEzM4Pp6WnYFGgYJtYaLdTbBpYqLdgVA6KaApMVUNIRAxQEeqYMXR+uYz2wK4k3QnSEnTJGTeyjwgbBanoaRpfY00SCE2UN2YTPJ3oTsZWByLgAVMLzuRrOAh4sAENT8z4CMCryeAr44cEFH+eREHjrRVO40S+0CRG18k6o6Qxs2wb8O8N0JhvbjkiArOwZ5s6mFRRVEfKII6WG2dfbjU50TWvXQKm3H/fv38fZs2cxPz+Pw4cP98wzJRGptJl+zuW2HUY/5tJyj7/gxCN8A66tpktxpmqiark9vxMJ8FxRw1xq/MvLk3xx9xZMCWXVO34n6gFouWjYcQ/Auk2B7BRuALh5v4WiIqCkSigrIgpjmECvGg7OJDTNlBUBz5dTiSnlYdjIriT4fycKpQKaCvi9Hb1nSS+KEETj4p2tnfq5J/eciLJqOLirTYMJXZY4ioBjpVTfaDiNfL8f5lvRfT5HBWDSVBvdZbgbGWuYJACjN/i8BvDhwQUf56EzyFvvVsPEBUsCU2R8+J/+a/zk9/0tWKaBl77wg/jgV39tbFsu81JodcvFjYaJjCRgOiVjWpMxpUmQJ2D9UTNdNGxvX0uqBIE6cF0X58+fx9LSEo4ePRrOOO0mHuEbfx+i6dxdud4Oya1N6cZ/UDEdnKmaid2OaZHgWJ8Ixag8rindUZEEghlNClN0NmXhYlkxXbS6TKCrFkXVsnAN3vlTUjrpsrzcf6FjjOFaw8K1hIjrnqyMAzllw0XyYdiVaCIJBQJxHQj3rgGWgUI6hVLRGwVXKBRGngP8JBBrauoSe9vTEo4M6F6PpXQf4VC6qADcD8Qi2tUhBGBaJEgxATRXhuFS3gTyEOGCj/PQiDZmJHnrWS7F6bWW53XnX9De88EvxX/6zDkYrRYOLGzDe+ZyaNguVnUHq4aNimHHuvJaDkWrYeKmH5ErKiKmfAFYUqWx0mW3mp3xRzuzKm779XqqquLkyZNIp9N9nxsTTmMul23HxYpvtJySBExrvV/bLRV8wd+M4UbTxjtdaaiAGU3Ec0XtqYnEbBWyQDCbkjDrR0BNl+LzF9+BUpqBISrh2D7AW+TXTBdrpmcCLQUegL4ADEygLT/iWumKuAoEOFrUMKuJnl2J4yY2Qmy1XYkidOrn/vBeEw7z3oeSJuHA0ePhFJClpSU4jjPSHOAnAd2hOFNNbmo61GfaTDcPK6U7Kj0RQMpQt/sLwLbL0IYITO3A68ttpLuaQFQuALcMLvg4DwXGGBzHgeN4d3ndX8g13cap1WbM8JY4FpikQNVSULUUAOIXzEvIKxL2FTRQxlAzHazqNlYNBzXTiV1capbnO3W1bkDwJ2MEEcC8Ig68KNiU4p5v7iwRAtRXsb6+junpabz44osDF6Lo9sddT+9E0sk7s8kTRCaf0u28BoNnG3G2ZnjCI4H9OQV7s4MXrXFe/2lHFQWoRgM7xALm5krQnfgUkGgjg8OAFcPFiu8BKAsERG/hx77vu3D2s2/g0LGX8Hc++jPIlcoQiTcm7VrDwrna1tiVBP8fxa4kNlpNEDacA3z79m1QSnsE4JN0fizrDs7XelPsAmN4YSrV05zRj0eV0h0VUegVgDW7UwOYKACjEUApPgmEC8DJwQUfZ8uJNmYELfnh7xjDlZqOd+qdKJosEOxSGa62412EbkKETCAEZU1GWZNxCF691JphY82wsao7YSrWey2vfmbVcADokP15q4EATCeMzFpqWuFCqZkNXL59Bfl8HrOzs0NFHTab0mWM4XazE1HbmU32OyOEgNLJTH3opm65OF8zEzsoJQI8X9ISo46b5UlL6W5mPYkea0oSsCAJWPBNoNsuw5rhYNW3zIgKB5sy/Mef/Of43B99HJRSnP6T1/F//8sfx3f9+L+Cy7wZwcOQZFeiRSZGTLKTODjUJB++fnOAgy7gmzdvAkCsAzibzT6Wi7nLGC7XrbA7O4rg2tiNNmYiNlODeFxSuqMiCgRTqoSpiAB8594yVtsWlNJ0rwB0GNoOF4BbARd8nC0jaMxwHCcxhdu2Xby92kLN7HTpTWkSjk9ncXm13tMaOkyETBII5tIK5nyDY8OhnvjzBaARGYVlU4b7bRv3/QtySgzq/yRMpWQoAokZHcvNCt772ms4f/780GIkegjjOAM+0O1wn2dTMrQ+UxwmffGKbu1UxUjc86wk4FhZQ/oxnSzxMJiUJGWEwISAFcOJN0UMYVeyfOdWKPYpdXH/9o2exyiCbyYddKs/QrsSFvnHoPM2Ogd4586doaVHtVrF2toarl27BkEQQgFYKpWQTqcf+WLecjxfyqbTK7iLigDx7m2kpqdG2mbclmWze/joEAWCNLWR02t44eAuLwJoedG/pK72bgGYkeKTQLgAHB4u+DhbwkaNGQCw1DJxZrUNJ+K6f6iYwv6CBgZg2er8HPAWiXEiPpokYCGrYiGretESh/rpXy8F7ESuorpLcbtphg0SaUlA279gq8zBqyeOhReUYaNpsdToGOog2h28K9d/msGkI3wslnjrZVtKwrMFdSIWIkk8TRdfxhhsiki9XFf9nENhzz+DmgugYgzcXjevfflX47Of+D0Iogjqunj/V35tz2MsymBZDI7kLbg5SUBOFh9JveXGZ9bGEEKQz+eRz+exe/duUEpDAbiysoJ33nknnAMciMBJzgEehqW2jYt1MzGFvj0l4UhRxeJtd+S6xKgMepIFH+BlfQJHA9HPtExpkRTwBgLQ87V0cGeCAvD3f//3cffuXXzkIx95CEf/6OCCjzNxAruVpKieQxnOVVq4E0lTpiQBJ2ayKPkh/wdtC0EmajYlY9VvzNjspApCCDKyiIwsYndeA/O7ywIBWDWcWGF0O3J3bhIJb95vYDolw5LUWD3NRkQv6aPuvuFQPPCbNVSRYCbV3yh3kgtazXRQtShcx4EgxuscCbwi851DFJlvlictpduyKe4xu6sZotuuZHQCuxJVAFxGehoz3v+VfwHTpSIenHsL73vPy3jtQ1+GiukkWmY0HYqmQ3HbN2POyQLKfrqsuIUm0AHRz5RgY0PvYRAEAYVCAYVCAXv27AGlNBwDt7y8jMuXL8fmABeLRaRSqc0eRiIO9WYV3+vjK3gwr2C3/72hlI587NFz6Em/IQpsWZLoFoAO9buA/brWwQJQiKSAhXDeONBfAJ46dQq3b9/emoN9jOCCjzMxoo0ZSd56ddPB2yvNmA3F9oyCo1OZWKThViM+UaJiOnAZG1pkDQshBEVVQlGVcAApuJShajq4U2vg3nobVEnFCrMqpuONVsttQ4UxVJYbYQo4Kyc3gER/NOr+32ma4YVtZ3Zjy4ZJRPgYY7jZMHH2wTp+6ge/F6//zm+hUJ7C3/vpf4/DL74CRfBGpJXUyZn2PglsZFfSjHRdJtmhDCKwK7HbTeQ1FcVMqjMhwq+nEwmBSxku1E2sJIiJWU3EB/7iV0L6+q8Kf1ZSRc8yw4+WVCLRkigNm6JhU9z0TaALSmexLCgixAkLC9b1n0l33wqCMHAOsKqq4WNGnQPcj4bt4kzVQCthyLLo17lGmzO6Z+kOQ7yG78kmGuEbhJQgAIMIYLIApGg5NKydjApAzbXw33/9V6HrOv7SX/pLmJ6eBiEE7XYbmUxm0of52MEFH2ciRO1WgF5vvevrJi5W2+EXUyTA0akMFjJxbzDdccOoFmwT02ohvLhtNsI3CIEA9aVbWLl2DdsOPoslP6GclQQwICZUKSF4oNuxCNyU5jV/TKckpCTvYhY1Xh5F7zHGYvWD/Zo1AjbbpWtThjOrLdxrW/jD3/4NvP4/fxMAsF5Zw8e+/8P4j3/0WRzKqygoD2epeZgRDJv21sxtlV1J9+xW1a+f++xnz2P3nj2YyRd7ttFyKBYrRuz8CziQU7Bng+7o7miJHQhAvwO42eUBWLMoahbF9aYNAZ6tUTADOC+PbgLdDetSfFv9OSfNAQ4E4DhzgLthjOFO28HluplorK6JBMfLGnJdvpTBDfEoPCldusMwjuANkASCaU0KG8WGFYC3WxZ++Jv/Is5/7k0QQvAzP/MzePPNN5HP59Fut5HLDd9A86TCBR9nUwzy1jNdisXVVugjBwAFRcSJmSwyCea80Y5UUlsBYzP+IsPGanoYFtM0cfr0aei6jldeeQVnWgD81NmxmSyKqoS242JNd3B1eRWGqMKNjIkyXYalloUl38IlMIAuKp2v2Ch7v2Y40P3FeFqTkB5gZLyZhXPdcvDWg07ktba2AiIIYJSCMYb1yhpMynCmZkCoI7xbLisichsYAW+WSaR0GfMEWxiZc1jPhIiEoMzQCOj4o02pIqb8SQKj2pX0O9b7uo3ztd56sHG7o+UuE2jLZX6tlIOK6aId9QAEvMig5XkAir4JdDAHOJfQ1T7wOLv+/7BTk5IkYWpqClNTXsNEdA7wjRs30Gw2kclkYgIwmAPcjU0ZLtRMLBvJKVxvcoYWSykGjJPSjb53T/q4Qtd1IUmblx+MMTiMQRIIspIAiRCkJRdNx6+NjbxpK0t3cf5zb4bPu3PnDj796U/jy7/8y9FutzE3N7fp/Xnc4YKPMzaDGjNWdBuLK81Yh+G+vIZnSqnEC1b3CDNSX/FEpP/QrYrwra6u4vTp05iamsKJEyfQcoF6dR0AkFe81BYApCUR6ZyIxu06iCBgYd+BwQbQ6ByPZxhtD2UAfaux8WSNbsZJ6QaWL+cqrdh7e/LLvxr//Rd+GnqzCQD4s9/4reHvYkbA8PzZPAEgoayKSI8xp3gzUMa6GiGiws772WZOm8CuJDriK2pXcqdt48q6J/IX0vKmxsl1H9fldSustYsyye5oRSSYS0nhfhsu9Qxz/UkgUV9MlwGrpovVns9eREmRkJEGf/bxAN/WR/gGEcwBnpmZAQBYlhUKwKtXr4aRn6gNjCRJqFsuTleN2PsTJWjO6CfMNp3SfbL13tAp3eg4Pz3a7DTG9ztbKECSFTh2J6gwPz8PADyly+FsRNRbr1voUcZwqarj2nqn41AVCI7NZDdsPOi2IFlz7Nid8KRr+CileOedd3Dz5k0cOXIECwsLIITgdr0VPmZXgtGxIAhgjI1kAA14bvufWW4MNIA2XYr7be+ipAgEc+n+71nAqAunQxnOrrVwt9U7NWPbzt34yd/+A3z+j/43pue3429+3VfDpAjTgFEBbzPggeHigW8ErIkkbALods0fheB4nGi6NSrshrArGfga/v72zm19NHYlwTHrDsXpqtFTbwdsfXe0JgrYnhaw3fcA1F0WTkyomG4svR3/7C0oAgkjv2VVRCpBkEa/wpNo2pg0iqJgdnYWs7OzALzIf2ACfeXKFeiGAWXbbuj5mb7Gi9HmjH6MJ/giKd2Rnvn4EawbwQ1btGM9uGnTNznOTyCAJgA29c7VdDaH7/tX/xY/98P/J2zTwHf/3b+H48ePA/AEXzab3XiDTwFc8HFGIvDWs207sTGjZbt4e6WJeqSTcCYl49h0ZuDi321BUvGjVlsR4dN1HYuLi3AcB6+++mr4ZXcpw10/rSwSYHu2t56HEBJGNQP6GUCv6hZudI0i62sArcmYTsm437bCi9yOAc0a0X0aNsLXsFy8tdJE0+4/0n52YQe+/Jv+GgBAFUVMaR0R0HYYKpYTCsBoStRwGZZ0B0t6p2OuHBkFFm3O2ciupJbdBleUcOV+C+MiEsRHfIkEmhSpnxMebjRyGFYMB2ervVMZCDwhMcwIrklBiO/dJwnYkfE++5b/2VcTPnuLMtzXHdz3P3tNJLHPXhOF+HjBJ6AJW1VVbNu2Ddu2bYPlMpyptFGJ5gkZBfzSDgEMR4tq6AG6EWyM6GZ8tNrjdd72I2h40rtqY9fy81gTVFy8N5nvd6prCkxKJGjY3ji76Mf1vi/9CrzvS78CAPBcsVMX3W63t6x7+3GCCz7O0GyUwmWM4W7Lwtm1VpjaJACOlNLYk08eBxbFcCiW/To/TRQwk+rYFwQXt8CLb7ML3vLyMs6cOYP5+XkcPnw4llpYalmhN+B8RoGccBceRPg2IjCAnk3JoeBLSwLKmjTQADp6dMNE94DhI3x3mmbsM4oiAJhNy+F+dIhYaRCCjEyQkRXszHifx7pNQ/FXs9zYwtQpmPa2KQveiDoGTyD0FfHS4EUzsCtJmt2qiQIk8uTYV1DGsORIWE7w4ZMF4IWSFo6qelQQQpCVCbKygl3+Z99wOingquXGzivDZVhqO1iKTEzIR6N+j0FKd1iqpteFG40oEwDMF3ui60BaegcXLjexVCigWCyiXC73nQP8tKR04xF4Ct2JR+z6Njwpg8VVMM6vZ0az5P3d7/tNGcPVhoUbXV3zXiV4h2gHOo/wcTg+0caMQHBFv2g2pTi71g4bFgAvsnNiJovCkIvU7VhHqgLBH8HGGIulLyjz7uzGwXVdXLp0CUtLSzh69Ci2bdu24X7syibXzo1qvBxcaGSB4Nh0dqABdPSi9Mb9BnKyGNq/lDU50Stt0D65lOFcpR07vigpScCL0xksrrV7ftdPkwV37w5lkAWCgiJAEQmatlf7ldQMYVPAHia0wxgkUGRVOSFK17EreRowXYr2zG40aO93JSd7hf9J6dFHDSEEeVlEXhaxJ+sttIH4ryaIf29iQieqbEgqVimQMxyUHoIH4DgwxnCtaeNaJEovEO86FJzFXnNGHvKOl2JzgO/cudN3DvCmu3QncXAD8BoiEBFy8XRrd1PEqEhgSMtiJEoX72If53xoORRnE8ohcpKARleXe3QdabfbSKfTYx3HkwQXfJwNiXrrAegRe1XDwdurzbCjFPAsRJ4tp4f+wnY3a+z0J0oIghCL8AGe27w4xhzJZrOJxcVFCIKAkydPJn65G5aDqj/mLSeLKPbxmxsmwhclEHzhDNENDKCvrxs9d8UN20XDdnF93dtWSfVGv01rnoeg4H8m/fapZbt460ET631SuHNpGcemMmjYbpjmVQSE5tcVw1vAJ2lXkoQAIKcImFJFNJduISuL2L+wb6Kv8bhRNb3if1frjS5sT0k4XFSfGGErEIKi4hk4I+fdENQjFjDddhlMEFEX0jhVMUAA5GUhbAIpyuKW1SkOi+lSnKmaqEbKUxSBxM77+ZSEZyPNGd1zgFutVigAb968CcYYisUiKKVhGnHYKGc8wrf596a7pELvqo/dbAd793zmVCRKd+btz+Hg/v1ht/QkjmVJd3Cx1muPM5+SIBMkCL5OdopH+DjveqKNGcSPuAUwxnC1buByTQ8v4hIheH46je2Z0YxMV3QbeqRZI/Cw6wi+iGHpGBegu3fv4vz589i5cycOHTrU98662/C534V41I5Y31Um0acr2F5RlZCRBFyp6wC8u89dORUVw4nVQzJ0DKCv+I+b0mS4UgYpavakvO+1LJxebfa9cO/JqSiqEm5FRsoBXiQu4HKjt7FjEFJQX9N11y4SBt3xhEDVprEuRwqgblHULQrk5rHGXOhVI2wA0cZsANlSxlwQGWO42bTxTsPqtSoB8ExBxY609MSkPJMQCfG7tzt+afd1Gxfq/vnEWNj4wADUbYq6TXGj6ZlAFxUBJVVCWRFRUDbvATgKq4aDszUTduSCowokltId1JxBCEE2m0U2m43NAa5UKlhbW8PZs2chiuLQc4DjNXyDj4Exr6kpqYZusxNgAsPwmJDrEnYbfV7UcSZmur2RPc7erIy9WRl//EDv+V13hI936XLelQSNGY7jJHrrGQ7FqdUm1iJfsKIq4cR0ZqBfXBJRg+HovNiO4Os8dpROXcdxcP78eaysrOD48eOh9UISLmVhx6pAgB2Z/jVko5ocC4TA9Uf4bMTdlhVegL0oqXcBslyKNcOzf1nT7ZgBr8u87mYoOQA5rNypwVi+ix/929+Jq1cu45UPfTn+1j/+KOQ+ZrI3GibQ6E3zDjq6QXYlg6K7O4GwC3TN9HzgqpYbE5ouEXFPd8JRVemgCcC3gHkUc2A3Yti9sSnD2aoR2ptEeZqnmUiCFwEM0MwmpmQCIV9CxXRj5zUDULUoqpaFa/C+kyVFDD0g81vk/5hU/yUTAASh2BMJcLSkYXZED8RgDnA6nca1a9fw6quvwjCMnjnAUQEYjQB2Gy9P0rKkZ1+Bnpq5aFmFOkDQDWKUSRsbUTFdnKv12uMQAIcLKnZkZKwYThiV1QQCI/wc4zV8XPBx3nUM8tZbbltYXG3F7nwPFDQcLCZ76w3CcCgetJPnxSamdIe8gq2vr+PUqVPQNA2vvfYaNG1jL7t7bSs8pvm0AnmDaNI4KV2gf4QP8CdrNJKFryIKmM8omPdFaNtx8aDtTfmoGk7YZAJ4BtA/8pG/jQunF0FdF3/027+BPYefw1d923cOvb+AF6ELooLb0xJKijhxu5JoF+hOvws0aAK4XVmHKapg0Yuyy9Bud2Zm5mQv/Vv204iPIgU46oK6brlY7OPfliEUL85kH89I5oSIHjVhDDk42FnwznXTpaH9S8V0oUejv1H/x4Z3fpYiHcDZMUygu9Edr6uzHrnryEkCWg4Nrzv9JmeMQnDtkCQpcQ5wrVbD8vIyLl2+AjmdQbZUhpLNoyZ0Gh3eWtNh0/EbnQUgrJlLitJtdQf7ZiZtAJ7YvdawcD1hnKFIvCanwJR8KdKEpooRwSd09oULPs67jsBuJSmq51KGC9U2bkZEiSYKOD6TwZQ2XCdpErc3mBcbCr7ItXWQ4GOM4datW7h8+TL27t2L/fv3D3Xh6raE2Yhgv4YlePmNNGLd8ur0AG+clSoKqJsO2g6F7lDojgvdDf5NY4K7m+Xbt0Ajgv3B3fhQcAKv+y0riUjLAlKSgJvrRrjAntyWxd2GiZt+Z+32lPxQIk7RJgDz7hpEScLUjj1eCttyUbfiNWDBHNgbCFKAHf+/SYwBmyTBCK5LdTNxkZYaazg0nXuqxR7Q/f2Nlx+oooBtKQHb/Js+3YkLwGg61WHAiuFixfd/lIWO/2NpDAPwB7qDc7W4Hc6UKoYG4wBQkAUcLydPzhiF4NpB4d3wxrznkIKRU6GnZuFuY3ABhH3bkUuONeDyE7Ms6YrSpUQC+RFbEgU+fOPQ9oV5kk+lIhCcKGvI+5Fki7LwHFEEEss8BNeHdttrVOOCj/OuINqYkeSt17A8b71GpOh/Li3jhanMpi5+/Zo1AkLBJ8VNnfth2zbOnj2LWq2Gl156KZyfOYimP1oKALKyVze0EaPW8Al+20aQYGEssDDo/LkTSWvXLRf/+3Zt6O1388Vf8/X4jZ/7GARBBGMMr/7Zr4z9nsFbTE2XgkECAUKxV1BElDQFS5ERd4/MLo0xlPwFfD+8GrDqBnNgq/48zauRMWBTvgDMTCACNC4OZbhQN0N/uigEwJGiils3lyDMPPPwd+5RMsCWJSV5NyOh/2NgAm26qFhOLP1vU4ZlwwnruNTABFr10sD9upxdxnCla6KJJnhTdaJir7s5Yxi6TcODOrqW7cA9cBx/tNxbVzY01AUsAxJ1kZIEZFUZ5WwGWU3e0LLkcYD55S2jpnQZY7inO7hY7x01CAAZieBEORX7rO/rHU+A+ZSEemQNC2r4uODjvGuIzsEFer31bjVMnK+2wztzgQDPltLYtUFTw7CsGp1mjZmUjLQUvwCEgi+6v322Va1Wsbi4iFwuh9dee22kAei3YpYw2sDjGlTD51IWica5YcrVchn+4E4NhrPxVOCNfufV1gjhYpiSvIv7tWoTlt/c8pe/5//Ejn0HcOf6O3jpiz6El15+GUVVRs10YqI9bgDtvzYDbq4bMOxoquTxcMiVeubAUm/Wa0IKsHsM2DBTILaCpk1xuqqjldA1owoEx8oaCoqIW3h8F+hJEvvaMAZChvscCCHISASZSPq/6dBwBFy1ywTapCxW/5kS4wJQFb1U7ZmKEevenFZFmJR584N9DuYU7M72NmfYlPW3LHEpEgJQHQb4TMoCCae+BBG6pbaDhr/RL9qeB3HTqNVq3ii4B1U8GGEO8KMkWi40LMPMLT5eTvXU9QYekIBXmlKtdT7X4NXb7TYEQRhY9vM0wAXfu5Sot15SCtdyKU6vtbAcqX/IySJOzGSQUyZz2sRq1rK9adTkGr74wskYw/Xr13H16lUcPHgQu3fvHmnhdBkLo2sCgB0JkzW6oUSALSpYblthytUI0q4O7TvuK4isDSITijkxFHVp/29VjKcqV3Qbp1Y6Yg/wFsf3f9XXAvDqKw8VO4XfhkO9CSCG3WMADQDrtouzlbgX39XlNbg5FVOF/MQ66wYxzGeoJKQA13wBUDHdWNq7ewpEVACUFQnKuOaOG3CvbeN83UwsQygpAl4oddKDo9SEPslEz7bNmKgTQpCTReRkEbvgXRcagQegH+mNvu+6y3C37eBuuxMBtGinqeHcm5+GW7mHfe95P7IzcwC868H+nOKVPLTsiVqWwLFQSGmJliWaSBLrUVf0uFiRhpgDnM1mYwJQkh79kh8NLgxD1XRxNqExI2BOk3C01Bt99eysvNfKywKysgiXdRpvSCSlm8lk3hU3XI/+0+c8dILGjLNnz6JUKmF+fj52sq8ZNk6ttGJiYHdOxZFSemKF8YZDQzGpigSzCRMlkrt0O/82TROnT5+Grut45ZVXUCgURt6P5UizxraMAlkgvnij0F03lnYN/jhMAWb24HMPmiO/nix4hdGpSJTuZsNE2xeCr23LoThETSRjDJdrOt6pG9EfhgWDskBwfDqD2a4xT5okYCGrYiGreqay6wYuVr3UUrcTfUBNyuCUDpDaKjTXwpQqYnsxh3x2ay+So4qglCRgR2QMWNPpTADpngIRFwAmspIQpn+L45oA+0+hjOFS3QybS7rZlZFxMK88VjWGD4t43+jkJm0IhKCgiCgoIvbC+wzqFvWjfw5qXfWf0Zuy3/j5n8J/+9g/BwCkc3n8y9/8fczt2AUK4MoYlkQAeibAROvorFYTZ06fwyvvf/9I24weQdLpmTQHOBCAV65cgWEYyOVyofgrFosT6ZQdlWEjfEmNGd3XqD1ZGQdySuJ5dK8rugcgvAZEO3RbrdaGdjhPE1zwvcuIeuuZpgnbtmNt/1e6RIQsELwwncG2IeZDjsKdDZo1ArpHqwX7CACrq6s4ffo0yuUyTpw4MfSdK2UsIugoLtc6dTRruo3fvVndsJt2EKpIkJJELyLni7pr6wbaDgUB8KW7SrHH100HF3zBlVfEocReki0OgFDslVQJJ2YyoZ9hPwghsQiutnwNqixjevc+3G07sRQpADA1DR1p3AFwZ51CeLCMDBxMp2RsL+WRfoxmUUYjQLu7pkCsmU5PA0jToWg6FDdbXgNIQRH89K80kgec7lAsVo0wshBFIMCzBRXzfcblvRsWnO6U7lZFjANbkbLiNXAUFYqK6WDd7rUq+R+/+HPhv41WE5/6H/8Pvv67vm/gtpN8JoexLLEx3nGParysqirm5uYwN+dFLAMLmGq1iosXL8KyLOTz+TACmM/nH4oATMooddP2J2ZEO6ajzgEAcLigYGcf+yzq1/sB3uc152cBohG+8LXeJVM2AC743jUE3nrBeDRBECAIQni31XZcnFpphZMmAKCsSTg+nZ14vRNjrKtuLrkrNinC51KKy5cv4+bNmzhy5AgWFhZiFw6Hsk5Xqy/qOtE5t29aAEDfVGwAgRdFkpiLdr2GvQvzsbRrSkoWBneaJtpIngUcH+U22LB6Tbfx9moTZp/j2JvXcLg0nEVO049+AAAxdSyU8jh08KC3f6SFd9a9fZvVRBgui3fFEQE0lUUDQAPA9TULollFjlDMZlTMlwoj1VF2M2nxE50CsS+nwI02gFhuTKAxADWLomZRXGvaEEmnA3hqAwuQdcvFuaqRmOobZOfxbknpxpt0xz9m6o/1i475CpsjXApzBA+6TKGAdrMRlrlkC8XY7wk8D8iCImJGkzClChA3YylC6Vjnd7SOehw0TcP8/Dzm5+e9xrGIAFxaWoLjOD0CcCsE+UYefP0aM6ITTgQCPF/UMJvqL1/WTDd8/IwmQvHftH4RvlEmnjzJcMH3LoBSCsdxerz1RFEEpRRLLRNnVtthcwEBcKiYwv7C4AaGcVg1nLCWbUaT+5o1B4JPiuzD5avXQIw2Dpx4BZas4nylPbRdySAkAqQk0TMTDurmxE49nepbPVQqFZy5dgeHju4farv93kOXMtz1u2FFAmzfQPAFk00u1ZI7+wQw5Ncf4Nk9R4baJwC42ehsa2dOxTPbFzr7HFku51MyZlMSbMr8FKmDiumiHb0iCyLcVB41ADUXuHy/CdnSUZSAbbkUZoqFsbrytgpRIJjWpNCry6LMawBIODY34gF3BYAsAGXFM3++fuMG/ut/+S9QUyl8+Td+GzL53rKCsiri+ZIWLjr9eDcsOPEAX3/hE8xpjlmWuJ0miUE3Z4NICYDNvIjRh3/ip/DPv+vb0Gqs49UPfAm+8hv+CqKW2AxAy2Vo6Q6WdCfsAA/GwOVG7AAf14MuyG5MQoIRQpBKpZBKpbB9+/ZwvFiQAr5z5w5c1w1Tv+VyGdlsdiICsJ8li00ZLnZ1s6uCV/cZiDfZt10pKBtfS6Lee9v9iDpjncki78YpGwAXfE810caMILIUuzAJIu6RFNZXWuGPUpKAE9MZlDbhrTeIW41OyjhqxdJtV7Ku5lATZND1zuNbhW1AATjfdAHEmwsGoQT1c5IATRRwu+ndRRIAX7g9j4wsDnXhHnm0WuTflHUuNvfaViiy5/36wSQsl+LUagsreq/JKOBZqWyz11GzWom/T6LZauFmrQ2Ini3LM3P9LWyCpVUWCOZSEub8O2vdiXfJxmbrSgpsScEKgBUTwO0qNMdASRawvZhFKZ97rASOMsKx2RRYNhxcubeM7/lzfwatxjoYY3jz938H/+I3fje2mG1UY/RuJKrhKRGxzkQYLbun23Uzc5qDsX6i4HVJRyOu29MStqcknKma4XfvhVfeh7cuXUWGmsjn8wAAw+10AFfMeGaguwNcDkygVRElRUJG2tjjjo2Zyg6uOFtR+0kICecALyws9MwBvnXrVjgHOIgAZrPZ8SKVCRG+muniTFdjRlkRULdpGJVLiwQnplJID8g4dXvvTfkeov1S4q1Wiws+zpNN1FsPQI/Yq5sO7qWmYQudU2B7RsHRqTTkLaqrcSlD3XJw37/7EuE1TdxYN/yRQF12JYp38cUQna1JdiWxTldRiDWc3GtZ3lgxeJ6C2RE6j0edtBHVcdFnDepSBoCKYePtrgaaKLtzKo6U07h3tzH0Pi0vL+PUtdtg8/sAANvSSo+fIhliUFhKErAgCVhID26SgKLBUDTcA3CvyUDWHiBNbUxpEhZKOWS6iqZHHV83abqPreWw0AA6sAC58Pk/RaNWDZ9z/fxZrN5bwuzCDhAAu7My9maHE3tPW0q3n2VJtCzAzk/jmgOg3jvabyOSLEuizREiAW61bFxZ78wplgjwbNGz3XirYvSZnNH5DmqigPm0ENZb6sG5bSXcADDggeHigeECsEILoGAMXKrLBPpRpXRHIWkOcLPZDAXg9evXQQgJG0BKpdLQna7RCCdlDNcbFq5FGjMkAsylJCy1nfDz80yvU0N10y93ee8F4s6NfMeim9F1ndfwcZ5coo0ZhJDY3SRjDDfWTVystkF9sScS4LlyBjuGXJz6YbvdNXM0Vk/XnYZxgXB+7bBkJAFlTR5oVzKI+GSN0fyXRhUj0ffUex5BI1I/l5VFFLvMnhljuO530Ca9kkiAF6YysTTwoH2ilOLKlSu4desWUodOoOE/PGmyCImJ1MHHmtQkEXRJVrqbJAgB0zJoAWgBuFV1Idy/jyxczKYVbC8XhjqehwUhBFmZICsr2AW/jnTdws2de7w3yo+eK1oKBd/smwG40bRxs2kjLwuhBUxREZ/47lzGGGyKcF5rd7p1s5YlSXOao39v5BRgUYYzlfic4oIs4GhRxX3DxdVI121BFnCsrEEdwjw+vAHIdG4AqpYT3uBEj7fbAihoHgmmgDwOKd1RIYQgl8shl8th165doJSi0WigWq1idXUVV69ehSiKYfSvew5wlCClmzTKriB703ZuRzpsZzURR0tarO5uI7q998LXjXxG78Y5ugAXfE8VQWOG4ziJnVCmS7HYlRqUXQsnd80gO2A2JPMHdW9sVzL+Vb7brsRqNXH/9k2kJAF7jzyHsxWv3mxnTsX+wua6Qdu2ixXDew9SkhDWcQ3LyKPVIv8OnnW72UlTd5tY2/7ntNwnhZuTRbw4m419ZoOijoZhYHFxEbZt4/gr78OfVr1tpyUBUwOOf5yPVSCkMyUjp2w4JQOCAJrKYR3AOgPeeaBDoCoUW0dmZQ1zxfxjYyBrUYZzVROrpovdzxzB//FjH8Wv/cy/gppK4zt/5CeQSadjiz8DULcp6jbF9aYNwa//CgRATu58Rx+XtC9jXkq1W8RFmyI2WUIHABCMNuayKkqZdCxKN64grpouzlSN2I3lnqyMPVkZF+tWrDZsPiXhSFEdWkREid4A7MwgNgO6mhDdNlyGJb/+DwAUpCAU5rCsOygp4tAekFuZ0h0VQRB65gCvr6+jWq1ieXkZly9fhizLPQIQ8AMSmSLeXGmH3xUCYG9Whu6ymNjbmZHxTH74QETTdsMocs733gvoF+HjKV3OE0fgrdfdmBGwottY7OruLDMTWmMZWXlbj12J7lC0nY6wMxy6absSWSBo+l/GjCTgSDntR+g6vmeO4+D8+fOorKxgwTcU1SL2IpMI+nR3xo660I4a4YuldFlg9uxFGgQACxFrgZrp4K2VZl+D5h1ZBUfLmcQoR799Wltbw+LiIqanp/HSSy/5UQ5P8O3sc/zRn0wiztY9JcN04ymyWPe0KIFmSzBQwgUbuLC0DsXWUZQIthcyD9UAOkrdcnG6Gq8z+tDXfSM+9HXfCACY07zmDIchUv/lxKZs0EgDCBpe+qqsirBzU9ApkNuEGfGwMOY1PSROiPCNhcf9rscsSxKidGumgwt179yXmmvYObUdhczmxDxjDNebdix6JwvA0aKGnCzg7bV4FOlATsGehMkZ4xKdAb0nYgFU9W9uapYbez8tiEC6iNNV76YvK8UjwP1qeR9mSndUBEEIGzz27t0L13VRr9dRq9Vw7949XLp0CaqqolAqo5oqQS9sCy8sKZHgSEHFjZaNSiQyeyivYPcQRvhR+kX3gK4InxCP8PGULueJIbBb6Y7qXbhwAR/96EdRNx186Fv/FnYdOgzAu7uZScnQ2zZWMrP4xO3qhnYlgwjsSsI/YnxKhCYJEAnBWw+aaNreRfmZUhpzXd5+6+vrWFxchKqqeO2113Dv3j3U6/Uu4+XNyQ/KWCj4CIAdQ1ihdDN600akfgcMyy07ZvasiF507mbDxIVKO3GxFQhwtJzpmTcc/j4hwscYw7Vr13Dt2jUcPnwYO3bsAAPCySIbHf9WBxHUSI1UdE5q0CUbSwnKKixZxQMADyIG0GVVxMJDMoC+3bZxuW5tKH7n056IkAkwm5J82wgVhtupbayYbiwC5fj1X5jZidNtQDXaoQF0WRWHSjd2Q4NovJ9yDaZDBMLOGMGypBsB6KmZi9bSqcLGDQswu8sbNofpUpytmrFRaCVFxNGSCpsy/OmqHl7bhrHzmARRC6C9Oe8Gr251altrphv7ggUekLf8eb5hCYC/DVEgseve4yj4uhFFEeVyOZxn7jgO7lbXcc0U4ETqxtNWCztUgkt1rxMa8M6xoyUtbKAalm7vvWACT0C/CF+73cb09PRIr/WkwgXfE0x3Y0ZU7K2vr+ODX/IlqNfrAAP+6H//Hn7u428iky/AZfAbJ2RAlmEPEHuib1cSq5tLsCvZCNOluN/2xJ4iEMxFzGcZY7h9+zYuXbqEvXv3Yv/+/WHtIaU0Lpg2uUas6HYY5ZxNy9DG8BgMokvDjoaK1cOx+OzeXVlvYTqz2sK9dnI9Y0YS8OJsFvkNGku6o46WZeH06dNotVp473vfG3YfPmhb4QI4m+p//NH3fKsr6ZLmpF64fgtNSBDz5Z4ISWAAfRfA3XUG8mAZWd8Aer7oNYBMCocynN9ghqcsIJyZ2u9M0EQB29MCtg8hbk0aT/9lJIKyKqHs24DIAkm0LDEiAm8zN28iQbxmTopPjFAGCboBdPvwbWZba4aDszUz1kCxL6dgX1bGiuF1fSY3ZzxcROJ/hn6d7vWbN7FmOMhv29HjAQkA67bX3HIDHRPwYsSGRBiioepxgjKGmzrFdVsB8y83hFLskh3YThtXhCKY5Is9RrFXslCWRr8R7+e9FxBzkerq0t2zZ8/Ir/ckwgXfE0p0Di7Q24X7qbfPoFqphP9vrddx+51LOPziKz3bitqVxIyERU/cSZu8yAP9J2sEI95qtRpeeuml8I4Q6DNabZPyY5jO2EGEk0k2MBCNEt3/lu2GEzIykgBJAD69VEerTwp3e0bB81OZgaO+ooKvVqvh1KlTyOfzOHnyZKz+Ldqs0i9a6G2v8++H3TtBCIEGF4Kl4/D0AlzGUIvU/8UNoAlY1AC6YkNcWkJO2LwBdNN2sVg10O7TgTCreRNVbjSTay37HVu3uF23Kd669A4ys9vRoCR2U9NyGFqOjdt+9IdgcwI8sCxJitJpkgCZbG0tYTS2yMbuVmW42rBi77sqEBwtaSgp3ufxzpjNGQ8DwhjSrolDBe/7ZwcekH4HeLS+laFjAh7QcFxcb1hhDejjUNPXD92hOFszYvuvuhbK7TVM79mLRaqE1xcFFNPtFaxUVnHjXGvkOcBJ3ntRNorw8ZQu57Ek6q2X1JhhU4azay00C9ugpTMwDa/ZQVFVbN/baxRMHAvbSjnMaDKmNAnyFlwUGWMxoRUIjWq1isXFReRyObz22ms9C3OQOo0WVm8mwqc7Lh74jRApUcBMarzaoWiEbxii0bJoFC+niPiT+43EYxIAPFtO9zR09H0N/726efMmLl++jAMHDmDPnj2x5xoODY9fFcmGxz/pGr5xCN5fkRBMqRKm/AhJxwDai5L1GECnew2gCyIwnx/eAHqpbeNC3ex7vgV1YNdGEHsBoWVJJEpHVa/ZQyQbn+ODPotBliVjzQieINGvzLAR8ihJnZ1TqoijRQ2iAJytxY17t6UkPDtmc8ZW0W3LIgskUgLgZUOiDU7dIw5tCk/Q+jWgpYgFTL8pMI+Ce20bF+tmLIK9L6fAvX8PLTmFt9aM8HzOywKOl9NQxTyA/bAsK7SAuXLlCnRdD+cABwIw+j3u570XJfq9ip4Puq7zpg3O48egxoyq6eDUShNthyJXLOFH/uOv4lf+zUfBGMN3ff8P4JmFeawadmwaBZMU3GqYoSArql5h/XRKRlGVJnL3uGY4aPt3rVOahLQk4Nq1a7h69SoOHjyI3bt3J16kEiN8m1Aft5sdsbVzSCGVRDTCN9zjO/+Ozq69304WCylJwEszWRTU4b+eruvCMAxcu3YNL7/8MkqlUs9jhplf/CQQN4BWhzKAXgWwOoQBtMsYLtVN3G0np3AlAjxf0jqd3Ql1kzZD3wkRfS1LsiW0NtMVBc/XsqgE9V+DDYAfBfGU7mgRvge6g3M1I9bZeSCvYHdGhkUZPr+6tc0Zk2KQLYsqCtiWEsIaNN2hWNYdXGn0lnw4DFgx3FDsBFNgAiPo9BDlNpPG8Sdm3IsIb00keL6koSAL+KyYRl0rhL+bVkW8UNJijRSKoiTOAa7Varh06RJM0wzHwBWLRTTkTKL3XpSNInxc8HEeKyilsCwrMaoXjN26XOt4thEAh469iB/+xf8GADhY0HColPZSSJaLFd3GvUYb6w4DSOfiUzMd1EwHV+oGJEIwlZIwo8mYTslIj3n3GI3ubddEfO5zn4Ou63jllVdQKBT6Pi+s4YtF+MZTfIyxWDpznGaN6H4F2xzq8ZF/Dxr9NpeWcWwqM1KktdFo4OLFi2CM4eTJk1DV3mNjkWYVoP/84nCfe7wDHy6jdEL3miRTrI1iAM1sTKkSyrksrpoC1m0XtmVCUeP+jFlJwAslFZJAULdc6C5FLdIscKFuwqYMmyih81KrCc0Qmv9/J4huJk2AQHTxt6D6BsDBH+0xSGmOE+GjjOHyuhWmtQHvfXqh5I3YatguTlWMh96cMS6jTtpISQJmNCkUfDOaiGlVCs+D6DUlmAIT1JxGz4GSIk58Lno3dcuzxolGJbelJBwuqBCJ9x2Jir0daQnPFAbffEbnAANeVC46B9jYfhDQPNGWdXVQKve8x1Hveu7Dx3ksCbz1gvFo3WLPcChOrTbDujAAyCsi1i03tp3gmkAIQUGVUFAlTMPEW6cWcfSVV7Gi21g1HDTtzvMcxrDctsOolHfh8cTf9JDp32izhkQYrrz1p5gql3DixImBNRmTjPCt6HY4rWI2JW/qwjd6hG+IlCyAw6U09uZHizzevXsX58+fx9zcHCqVSqLYA+JR1mlN6ju/uLPPnX8/HvbHw+F5pInIRgyg1y2KtWEMoJsMV8+dwk/8H9+K6soyXvzCD+L7/82/g6qloPidkm+u6H0tSwY1S/S3LCE4/bnP4sUXnkc+t/HCI4ok1t2su5H0tuUgWt5oUq9rMYi0pMVg8ffmAPez/9hKYu8QHSz4Wn4KN9rYMKuJeLaoQRYIHuhOrDlDFQiOT2nIP4LmjGEZtvY39pzIO6cIBDsyMnZkOjc4lUgNYHcTUPQcSIlxATipusbAGudao9PJLhLgSEHFfFqGQxkWuwyxNxOBjc4Bblgu3lz1Spdkx8TVc+dx2XVRKBTCFHAul0uM8AUzhLng4zxyKKVwHKdvCne5beH0aiuWwtpf0CACPYLPTYiWCIIA5jqYTSuY9S1SdIdiVbexathY1e3YtnWH4lbTDLtMi6oYCsB+6d9oGpGuLePQwQPYsWPHUF/yUPBh8xG+WLPGBs0KwxA0yAwd+RrwOE0U8OLMaPOLXdfFhQsXsLy8jOPHj0OSJFQiTTrdxLwHh5gsMsxotScBgRAUVRFF3wDacilWDBervviLTX8hBD/7D78PtbUVAMDbr/8hfu+X/zO++q//LViUYdBMGM+eaDzLEuJYG06QSHwOIUhLBGlJCBf/Zld0M3p4bZeh3XZwx09X52TBs4CJ2H9sNV0J8A2vA/f8OspARwsADhVU7PD91a43rMe6OaMflNKRjcT7zYGN3uDsAsImoLAJpOsc0F2Gu20nLFnISB0LmNKYNwFJjRkFWcDRkoa0JMB0Kd6uREQ7Y9jO2tiby478WklEU8f7pnLYufMLwjnAtVotnAMsLewH0kUA8awLN17mPFKijRlB2iNWZ0QZLlbb4SxYwCvCPz6dxZQm4Q/v1nu2mRR8EAQhFJMBKUnAzpyKnTk1TP+uGjZWdBtVw4lFN2qm5ynlpX+BKV/8zfjpXwC4ud6ZKPHSvh2YLeaHfh+Su3RHZ5RmhWEZ1ouvZbu427ISx9wBnh/i8elMzyzbDbfZauHUqVMQBAEnT55EKpVCrVbrK0Atl+J+q2OJM5vQwdZNdFuPIsI37ixd6ke9xrUsqa+tgQWd74KAenWt80vGQBiFDIqcLKCU1lC3KFb8qMXxkorpCZxb4xIdb7cnOt7OnwEci24CaNgUjYj9R1HppH/zW9T9yeI53eTRW5Th4roZM9FNS14KNyeLcBnDhVq8RuxxbM7oxzij1WKCb4PHEUJQUEQUFBF7EB9xWDUd1LrOgZZD0XJomC7PyUI4BaaoiAObfO7rNi7UuhozsjL25hQIhKBlU7xV6XghSgRIV+6iPNW/lGcUkrz3+s0Bvlg30faf989+4p/i3Oc+gy/4gi9Ao9EIp4CMy8/+7M/iox/9KO7fv49jx47hp3/6p/HKK72OGN38yq/8Cv7KX/kr+PN//s/jt37rtza1D8PABd9jRndjRrfYa1gu3l5pohFJvc6lZLzgi4YHbSuc0lBSpXBea1JkTBS9uY79ammi6d/9hZRXP2TYvgDsTv96Q6uDcWApSYBCHejUuzyVVXEksQd0zISjC884Eb7bW9CsMIwgudeycHq1iV/5tx/Dr/3sT0KUZPzNH/3n+OI//3UAgGeKKewvaCOlNO7fv4+zZ89iYWEBzzzzTLhwbLQ/d5pWKJQXssMtio/SlmUj3OjIL7e329XaTFcPgK/81m/HL/2rfwoAkGQFX/znv77zS0LAiAgLItZcYG21DkkQAFkLfz8uW1EnGRtvB2w43o4BqPoRoasNL+VVUsTQBDozoe7PQRG+pu3idNWM2RTN+zVgkkC88ZCVJ6M5ox/jdCePa7wcPQeQU+BShprthlNA1u3km4CbLe8mIDoHuqCI4bXDoV5z01JXY8bRoua9FrxpM6cqeigGNZHgRFnDxbtNCEJvU9k4DPLeAzpzgFOOjJq/v1/z1V8FjTn4+Mc/jmaziS/7si/Dl3zJl+CDH/wgPvCBD+DQoUNDf0a/+qu/io985CP4+Z//ebz3ve/Fxz72MfzZP/tncenSJczOzvZ93o0bN/D93//9eP/73z/GkY8HF3yPEUFULxgu3d2Ycbtp4lyl3RmxA+BIOY3dkY7TqKnvjowSCr5+Kd1g28Oc3JJAYulfw6Fh9C8p/atH7kUNl+FStY2ZEbp/J1HDN2qzwrBsNLuWMoYLFS8Ce+38Gfy3n/oXAADXcfCz/+D7cPKDH8IXHtiJqRGiQZRSXL58GXfu3MHRo0exbdu22O/7Cb5xj/9RLZ2BZUmTKGipAi7Xzc7ECJfC3kQna2BZ4jIWG3cW9bb7C9/xYbznxRNwH9zBBz/wAUzv2B2mSLsNoKGmEe3lPXWvioxrYCatTNwAehJ0j7ezXIaK5STaf7gMWDXdsOZKCYr//ejPuDWwsVM0ct1hzEs1XlrvWOGIBDhcUENPtaTmjKPF0ScyPGrGivBF/r2ZG1ZRiFscRW8CqqaLRtdNQGwONLwocEoiWDXiE2PmUhKOFNQwJXxft3Guaob7nZMEHJ/SoInCWDWM/bgXG6W28fU0ugaeOHYMJ186AcuyMD09jV/4hV/A+fPn8Wu/9mv4O3/n76BcLuNf/+t/jW/4hm8YuA8/+ZM/ie/4ju/AX/trfw0A8PM///P4nd/5HfyH//Af8IM/+IPJ++K6+KZv+ib86I/+KF5//XXUarUhjnbzPFnflKeUoDHDcZxkbz2X4vRaK2bjkZVFnJjJxKYvGA7Fg3YndTmblgG/rCspkxV86QKBOSqaJGBHVsWObCf9u7Tewq21dThqOhbxaDsU79QNvFM3IPrp35mUlwLuFz3oTNroMGqEb9VwwojnjCYPbFYYlmDfumnbXgQ26N6sr63Ffk9dF0c0NpLYMwwDp06dguu6ePXVVxPrTfoJvqrZicSWVAk5Zbjj3wofvpEsS+Q8IAPrreF97pTAg65rfmvwt8uAszUD62bncxPQWUwJgGcKKj70lV8aOx/zXSOy1swEA2gATE2hiRSa6DWA3lbM922oCXjYESpFJNiWkmP2HxXTxZpf/B+9gbMow33dCT3uosX/ZUWCIg6376zrP4R4ncfn6yaWI9EiryNaQ0b2rksPdAdna0Z4HXsSmjP6MWqXLtBdwze5fUm6CQgFoNU1BxrwRth1FbPOaSJ2pyW4lonf+/jHUXGA2Re/AKLflDfl264E6eFxBG8SNmV44Dcr9vPei5I0S7fVagEAPvjBD+Iv/sW/iB/6oR+CYRh44403sGPHjoH7YFkWPv/5z+Pv//2/H/5MEAR86EMfwhtvvNH3ef/4H/9jzM7O4m/8jb+B119/feDrTAou+B4xg7z1KoaNt1daYYcp4DUdPFtK9xRZd6cu5ciXKkkoBV+6UebC9oMQgtbaA9w5dw67d+6EWCzjct2LLMkCiVkHuAx4oNsxE+Sg9m9Kk8J6tqgti+Ab0o4a4bvV6NQQbjRZYlSSBNZy28Liait2rEdeegXb9+zD0o1rAICTX/hFeObAvqFfZ3V1FYuLi5idncWzzz7b9864n+CLN2uMcPxj2LIw5qVUw5o5pzf9OknLks7oL+//G6Wqa5aL0xUjFpUg6Ig9RSA4VtZiI6y66R6RZVOG8zXDm4XbTbcB9HILsrWKgghsy2mYLcWNYx+F9U03ob1NpAGkYibb28SL/03kpE7qb6Par+6UbsNhOFdvx6KLO9ISDhW80gPGWM/kDM+k9/FvzuhHt9XUUM+JpnQnvUMRFDHucWm4XgPIiuHggeEm3vwtGy7uNgz8yLd+HS6+9VkAwItf9CX4Bz//X7CQlnGkGC+jGTfA0M193Qn3Z1sf770o0fcwuD9pt72qvmy200CiaRo+8IEPDLUPq6urcF039AsMmJubw8WLFxOf88d//Mf4xV/8RZw6dWqo15gkXPA9QgK7laSoHmUM79QNXKnp4c9kgeCFqQy2ZXpHRXX7zO3MqbE7wX4pXUJIT+PGqDiOg/Pnz2NlZQXHjh3DzMwMPhlpHDk5n4dESP/0r0txu2mG4qSgiJhJyciLDJT5d8QgoGAjRfhMl4aWMmrX/N7NEm3aoIzhUlXHtUiDSoCWTuOf/drv4E9+939CVlX8rb/6l4e62DPGcPXqVVy/fh1HjhwZeLeZJPhsynCvFVjiEMynhx8xlhThY4zBpMwXcvFmiEDgjXvrEFiWBNE4s7kOR2/hwO6dSIkCVJGMlcpijOF2y8bl9Y5dRBDVC/4/bnenLHgj0jwHPOBoUQUDwghgXwNoC8DtClTHRFkWMF/IPBaCL0q0ASS0t7FpON2ku/i/4VA0nE7tV0ERwhnABaXTABJrBsqV8flK5yZVIsCzkRQtZd4c42hzxlxKwnNPSHNGPx5lSndUVH9286oZF3vRyDgAXDn9Vij2AOCtT34CuH8Dz754tOd6N6mUbnyU2mApExvI4//dbrehqurEUsyDaDQa+OZv/mb8u3/37zA9Pf1QXjMKF3yPAMYYHMeB43gXsm6xpzsu3l5phfV3AFBWJRyfySAlJZ+YK7oN3Y8Cel2y3uOCL2a/yFi/1OSwrK+vY3FxEYqi4LXXXoOmaVgz7LDouqxJyPppl2j6t2G7ofirdHX/1i0X9cBW5tCL+OxyI5zBOUqEL2oJsyM32ckSQQ2f7lC8vdKMfVaxxwHI5Av4M3/pmwAAijI4ymZZFhYXF6HrOt773vcinx/c7JIk+JZaHUuLhawy0HaDMr/5waExX8d7firPcNnY6V0BvgedJMSEXRCl67YsudV4gLrZDKNp4+BQhnNdETiRxC/8wxq/DoMievVR29Nxf7S1RAPoFEwl5RlAtxiw+1m8dXcVMykF24tZZDOZx6oJQSAERd++ZZ9f/B82gFhuzCePIZj/auEavPe86DeA/Mnrn8Rv//qvozw7h6/9zr+NoDcyL3sp3KA20HIpTnU1Z+zPKdj7BDVn9GPTXboTPPwgKh8trQhu4tqOC71PLKB7xUhlcz2PeXaulNyFPYEIX9PulFTkZAG5IVL7QdBDJJ3yiVarhVQqNfY5NT09DVEUsby8HPv58vJyT501AFy9ehU3btzAV33VV4U/C9ZfSZJw6dIl7N/fOwJ1UnDB95CJzsEFertw77UsnF5rwfG/4QTAwWIKBwZ0c0abNXZFCvMF4hnGun2UUpI1yzAwxnD79m1cunQJe/fuxf79+zuNI43kfQkghCCvSMgrXvevSxkqphMKwGgHMgQRKxHxobsUp1dbmE5JmNbkvnYmPfN7J9SsET2Gqs3w9lK9b2fotrTcMz5tkGSqVqs4deoUisUiXn311aH9upIE3+2u43cjgq7tuF5jTfSPmyz8B1mZAN5FtCPieue4Kht40G0FDdtL4Ubn7EbFngDgcFHFwiSjvtF/R/3RhjCARioLHcAtALdqFML9+8gSxxOA5QI0bbB34sNEFAimNSkcMWdR5nd+ek0g7a4GkDXTxWc+93n84Dd/Q9gkc+38GfzQv/9l7M7IOJBXQtH9tDRn9GO8Gr54KcIor9VP0G02Ki8QLwJoUoY9zzyLr/mO78Zv/bufBSEE3/8PfygxKxFYjm1W8EUte7YPeV4Ep2Q0OtxqtZDeRHOVoih46aWX8IlPfAJf8zVfA8Bb4z/xiU/gwx/+cM/jDx8+jDNnzsR+9o/+0T9Co9HAT/3UT2Hnzp1j78swPB3foCeAqLdeUgrXpQznKu1YzVVKFHB8JoPyAEPexGYNH1EAHLd/ZCywZhkF27Zx9uxZ1Go1vPTSSyiXy+Hvop5vskCwbYg0oih43niBP17Y/du2sLTeAqT4NrrTv9MpGTOajJLWqePont+bmWBxN2MMZmEWl00BSS0NEiE4NpPBUrPXqrdf5o4xhps3b+Ly5cs4dOhQ3/nC/SCEgBEBDctrUqkYThglFQnw2QcNmJsooJMCQSf1NkNokgCZTLbpYDPbutu2cbHW6RAMPqVowf+xsjeWa7MM+452G0BvZJECQQBN57AOYB3A1RUDkrmGvMAwl9UwVyqMbNy71Six+caA4Xbq/wLrjLOf+TTAOmUZp9/witWXDQc2YygrIhhjuLhuxZszyhryE/isHhfGq+Hr/Lt77OFWCboonkWPgLQkhjd0bcfFqWpnysk3/91/iL/w7d8NIgh4/55kO5LgpnQzKdQk771hiEb4AiYxZeMjH/kIvvVbvxUvv/wyXnnlFXzsYx9Dq9UKu3a/5Vu+BQsLC/iJn/gJaJqGo0ePxp5fLBYBoOfnWwEXfA+BQY0Z65aDt1eaaEbSF/NpBc9PpYcaX7aRz5z3b5ZYwxfsyyiCr1qtYnFxEblcDq+99hoUJS7G7kY833Zk1bHc+4Pu34WMgvtvfRovn3w/TtWsxEhakP696nf/lv3u3xW9E1nb7GSNKKbrpXCNXHL9RUER8eJMFqJA8NaDJoB4ZCnpnQ4EdL1ex3ve8x6USskeVTZl0P3IXDuMzLlhxI4+8zI+tbTe8zyXAe4AsacIXrrV++PdBNz0BeuOtIQjxYcfYRq1rs1l3tD26N2/TAA7spmSIuKFkjqS0fVW0N0d+YlPfgoHj7+MBhN6ZuRClOCkC6gAqDjAhaV1KJaOokwwn09juliYSBH8JNFEAdvTAranZRiO5623+5nnws9UEEXsOnQYgBdBXmo7sc8N8EbBHS9rE71ZexwYJcIVCLp2JPp+t23hbtueSIQuFbl5kwRvFnPUAzEvC3jen5gRpXukXRC1zRaKANC3xjK6Bo5Lj/fekB3iSRE+XdeRTqc3dYP5Dd/wDVhZWcEP//AP4/79+zh+/Dh+93d/N2zkuHXr1mPz/eSCb4uhlMKyrMSoHmMMNxomLlba4ZdWJMBz5Qx2ZJWhi/u7mzWiBCd3P8EniuJQKV3GGK5fv46rV6/iwIED2LNnT8/+McZwq9lpXEhK546C151LkBY9EWhZLgiA98zlvPFvuo31SPrXZV4tY1TsCQAoZbBcuulFfk238fZqMxIpY4gmWHbnVBwppyESgmt1PRThU5ocdiR3i5j19XWcOnUKWiqFl9/3Klwi4n7L8gWdG6Za2w4N0/zjoPr1cylRRDoUdp64S0lCT1flWtsMBd/DLBIfl5ZDcbpixCJlsoCYb9+ujIyDkdTh4wRxHcyqAnZpWjgjdy2SIo1OMoCswpJVPADwwABwcxUp10JZFbG9kEUhl31s6tzWTAdnqyYsynDi/V+M7/jhf4r//Wv/FdPz2/EdH/5elBURVSu5+7PtMryxokfMfyUUla2ZAPIwiaZ0x4nQrZnDSbxuQdc99k8WOpH0Zd3B+ZoRO8/2ZmXsy/V+X261LFyqd7IXWUmIR6jRv84wCC5sJsI3ivdeAGOs418b2bdJjVX78Ic/nJjCBYA/+qM/2vC5/+k//adNv/6wcMG3RQTeesF4tG6xZ/q1aA8i4iSviDgxnUV2hPRFv2aNgODmZzNNG6Zp4vTp02i323jllVdQKBQSH+d5vvnNGqo00nH0ozNP14MBmNakMP1rut7s3xV//m932pICWFxrA2tt5P3u32k//Ttspx9jDFfrBi5FOqbBWGhdIhLghakMtvsCt7t+cCbVEXxth2KpZUJ3KFZq66g0W5B3HkZbkPDJ+63R3yAfVSQwG+uYny6HtjcAMJeWcWI6O9ac1vBQx96r8RlFsCzrDs5FPNoIvIt6IPYEAjzrD3F/HOm+CYjOyN3pW6Q0bLqhAbSONO4CuNtgICvLyDAb0ykZ20v5R2IATRnDtYaF683O9U0RCP7yt/11fNk3fpv3/+tn8HxJ7WnOiNJj/ku8KG1gAJ2TJzMBZKtIEnRmeQGXDAG22ZpohG4jQdcPlzJcWjfD2bqAl0Y/WlJ7GqYYY7iybuFmxBtzW0ryLXzi2xX7VBoGIybH/cxG9d4LiK5/3TV875Y5ugAXfFsCpRS1Wg0rKyvYtWtXj9hb1W2cikWKgL15Fc+U0iPbDcQaJBJSl6EdAryLcPfd2qCmjbW1NZw+fRqlUgknT57csHZo0L6MQ2faRsSyBkDwNVdFAQtZFQtB96/l4DPLzcT077rlYr07/avJmE55ncRJFyHLpTi12opFDQGEYi8ni3hxNouMJIQp1hW906UsEYKr9Y5QvNkwcTN8n2QgU/R8TDdQVQRehDMlCV50TuxE5tKSAE0SQF0XHz/3GTx/8Evw2dXO6+3La2Ol1R+H0WqDUrrUX4ButaKiArBoJ32TEr16vWG6+B41/RZBr8lJHM4AmhCwVBZNAE0AN3wD6CxxMZdRsa1UGGgAvVkMl+JM1UDN6uzXlCriaFHF+XrnGsEUDZ9Z1XuaM8qq6DWA+A0uMfNfvwFkzXSBhpeyL/nRv7IqIi0+3OagsWroCtOou8CgW6mooNNdFl5Tni2omNGkoQTdRqxbLs5U441Ns5qIZ4taODEjwGUM56omliMNdHuyMnZnZLz+wPOyC9K6wb4nsVlLllG99wJiFRJdNXybadp40uCCb4JEGzNarRZu376NPXv2hL+njOFyTcfVeiftqQgEx6Yz4biyUTAcGkZyVJFgNqF4NXpyu6z3i9ivaYNSinfeeQc3b97E4cOHsWPHjg0vLpZLQ8+3YZs1hiFpni6LZ1JDCCFwGEKxV1IlHCqmwujfutUn/Vv13r8w+qcI+N3/+f/i7uoadrzvS6Dki4n7poBCFiR8drkB3aGJl2+HMTgDMuYC0JNiDcWdJEATB0cxmP/7pj8kHfCmsZTGtDWJvtr4Zixbh+F6KdxoZEgTSaz2bUoV8Xypd/HaOsZ7nVFrFZMMoKumG6aAowt4YABdB1CnHQPovMgwn0v1GEBvlgeGg/NVI6ybJAAO5BXszsh+J3nnsfb8Ptj+vnY3Z8ymJMxGzH+DBpCKGR/pZTPggeGG1juaSMLoX1kVN23OvNVdrsNG6M7XjFDw5RVh6Lq1fsd00zezDt5JkXhTZranpJ5rjU0ZTlX0mIA/UlCxIyPjTssOo2dq5PvXb/c226E7qvdeQLSkKRpU4YKPMxbdjRndtXEt28WpyMgtwEtNHpvOQhtzLuVGzRoBschYglJKivDpuo7FxUU4joP3ve99yOV6PZa6uduKNmsM9nwblk6Er7MoJR1HQDTKuDunYtof3wZ00r+ruo2VrvSv6TLcaVq407Twr//ud+OPf+c3AQBT2+bxr37r48gVexspLAio9PHfix0DIuO7jDZKIsXObbPIyBJSkmcqvNmoRPD8O+1Obc3OrDr2dskjm6brv/4G+71qeGO2ooEtVYiLvT1ZGQdyw9XBPunIAkkUSBsZQK8BWIsYQJdkgu2FLEr53FgLclK0VRMJni/Fp5fEjNMF7+d53/ha6yPOog0gjDG0XRYaQHfXNxouw5LuYMnv4sxIJDSALqlij/h/2IJOEwjOnXoL7zn2PHLp4f3f+nXpjorhUpyrmt6INJ+8LOBoSfNNxOPoDsXbFT2MsgoEeKGkhc1GUQGmRL6D/fZxMx58TZuO7L0Xvm7ClA2Ap3Q5YxBE9YKTmRACSZLCyNndpomza63wwkQAPFNKYV9+Y2+9jehu1uiXQo3ezfSbthGN8C0vL+Ps2bOYm5vDkSNHhrr77/W8m1xHZ0fwdX7Wrx7RdinutZOjjC5lsFwGWSAoqt7sz4btomFRWC4NL+qtxnoo9gBg7f49vP36H+ILv+pr++6jRDodro7vKQgA82kZR6cyqBs2/nTFq8+bzah4eefMGO/Exni2LCQsaBbgCe/xN9j556OK73VHvphfF3YtUhcmC975EER9RAI894g82zYrLSclTrsF0jAG0PcB3G8xkMoKUtTClCphoZQbygC67VCcrhox8+Wk1CBlDE0n/pnOaRKeKw0/OYMQgozkTTjpqW+0/PrGyEu0HIaWY+N2qzNxRxa8UY2OPwbwYdbQUUpx3mhBlZJLSPoRE3xj7u8DvzEj2rW+Jytjf0JjBuClfN+uGOENg+JHYQM7o5ZDwwh7VhJi+7UVKd17kbKaYb33ApLm6AKTsWV5kuCCbxMEjRmO4/R04YqiCIcynFpp4m6rE3VJSwJOzGRR3MQEAaC3WaPfBI7o3UxSb0aQ0qWU4uLFi1haWsJzzz2H+fn5offFa9bw7hhLqoTcBD2zEmv4EoSrTb1RdMGFMSUJOLXaDE2F+5kjd6OoKhRVg2V20u75Ujn2GJEAomUgLzI8t3MOWdn7LBljeD1ii3KwmIJrmbhw4SIwvRsAkM5sYfogWwwv5nNpZVNdybGU7mOQ0bVcijNdkYm0SGLpy7RIcKycQlZ+eBYIj8N7sxGJBtBhA0ivATTTMmgjgzaA274BdAYOZtMK5kt5pFKp2Pbv6zbO18xYw8wzBRU70vHUoOVSLFaN2PdQri3j+SP7Ni10VZGgrIpISQQlRUDdomg5FGaCmDMpi6WEN2ISTRHdhLY0I49W6+zzqMmTURozAlYMB2eqnUaotETwYjkVTkIBgHuR6N58WsL9iDfepCN8lLHQtodgeO+98HX7RPh0XX8kI84eFVzwjckgb70WJbB3HYmJvYWMgqNTmb6DxUehO3XZDyHyWv0ifIZh4M033wQAnDx5cuSahmEijePipZwpmNjZ95sNE9Qfa6a7nqCzuy7iQYPGMCjEu+vTXQZZUfG9H/0Z/PQPfg9MXceX/9W/jmOvfVHs8S4DXFnDKoBP3l1HXhExrclISUI4JaSoijDqVZw+fRrF+R1o+M/dhLPKhhBCwIods9PNfg6POhEanRxSM12crhqxhTojkVgx/7Qq4uhDrdebHA9zjm50RFpgAF2LNIAkGUA3ADQAXF01IZkV5ASG2YyGupTCfTMuuF9IaJDpnpwRoK6vgJCNx0gFKdcgxao7fuo1koKdhLEw4EXOsrKAoiJgVpNRkMnE/dOiE5ZGet6YKd1122/MiHxXZjURR4oalD7flTstGxfrnXKhoiLgWDkVezzrEmDzKSn8/0ZfwXFr+Cpjeu8FuH3ePx7h4wwksFvp5613bd3ApaoJKF5qUyLA0akMFiY03ivarKH5zQb9iDdt9C4suq5jbW0Nu3fvxqFDh0b+MtouxZKfRpUEgvkxmjXCOpqEkV/1mT04Zcqg6NxNXls3NthaL97dudDVDOE1R8iE4FylHaaCAeB9X/oVeOVDXwbXcZBPa3hxOgNRELzpH7qNimHHLiBJ4tJpt/HWnXfw3DOHkZuZw/176/6xjvz2DEXbdsEynl1OWhIwpW3uqx3r0t3UlsaHAbjRtPDOeqe4XPbFeVTs7csp2PcUzFh9FPsvdY1IM4MGCX8KSJIBdBVA1UVsFS0JFM+X01C7xF53pCjayRmI+q0SdF6ErjMRJuWbC5suQ8ulqJkuopZ2FMC6Xyd2q+VAFUjY/FFWxb41hqMQCL5NzdId4vGMMdxs2bHvjkCAZ/IqFtK9jRnBc652Wen0S7lHm2em/OaYIPOykSB1XXeslG7UlHsce6W4LUvn31zwcfrCGIPjOHAc/06mS+wZDsXiahOrkdb1vCzgxdncRN3ih2nWCIinQjs/dxwHFy5cQKVSwdTUFA4fPjzWvtxtWeF2d2SSmzUYYzCDYdwRMdeOGAv3jXxJG4vkwLLEZV6NXrAfC1k1tCzp9/6sWw7eWG7EnOUDBEHAfDGDY1OZcNpJThGxN6/BZQynLl2FKWmg6Vw4wixKU1SB3c/hIiMoRPz7knt5N090JN9mmjWSeBRpSxdAozCPtfWOEM9IXlF40NkpEeBopICcs3lUUcB8WsC8X/8XNYCumm6s/itKlQr41J0KNMeEauv4zV/6z1haq+Clr/w6HHnpvQA88eUyBq/Zk6G17QD+4F5rooIumN+cEr1avY2+B8HxhR3AlhNrBDKpN8IrGOOVFkloAF1OaAAZhvEjfMOndE2X4mzNRMXsXJdy/sSMpMaMYPvna2Z4rIBnVH4on9z4tKT3mh93JllscBxjRPii3nuyQDA9pPdelH5durxpg5NIdA4ugB7zyAdtC4urrViNCllbwotH9k18juutDSZrdJPUtNFoNHDq1CkoioLdu3fDNM1+Tx9pX/KKiDtNMzFSN7ZmYAwKYRBFEbp/Rdlf0DCbkv0OV0/sffx2DYDXQHF0KrNhlzBjXkfu2UorUWgSAIdLKezt01QjEoI0s5G2bRzZvgOWS3Gx2sbthNm5psti5tr32zaUShvTKRllVZpINzNlDHcigm/HBCLJ0S7dh23L0rBdXEMWltZZGIqKELOFyEheZ2e/BexJ4mGmdEchagA9n5JwvmZg2digTEJNw1DT+IFv+06c/9M3AELw27/2K/iX//33sfuZI+H31986qLzxebpZQTfK8e3wG0CaTsfgutrVANJ2GdptB3f8aFNOFjCleibQRUUc6rucZMI/DGGXPzYWiw8MvzEjIlx3Z2Qc2GDCjE0ZTleMWH3sM3kFu/o0fdmU4YEeCDAvxQogEuHb4DjGaNqIeu/Nj+C9F6VfDR+P8HFibNSYAXgn0qVqG9fXOwuuKhIcn87irctLYHTPRPfngW7D8Js1Zjdo1giIfvlcynDr1i1cunQJe/bswYEDB3Djxg3out5/A/CO0Qijcp2RX+uWG9asAcDptfbIxyMSxPznOsbC3s/On1lEuVSCkZ0N/QunNRllrRPWv90wwwvzwgBLGIcynFtr4U6rV5wBXvr3xEwmtv0konY2skCw0mgDxPs6nZhOw6SewfZaV/rXoV7K/9q6AQFAWZMwnfLm/+b6mD8PYkW3w9RbWSZj2/xEeRTJUcYY7rYdXKqbCGariAAyclzszWoinitqE6mFnSSP195MBsa8CNi5mhFLf6oCgQAGg8ZT/q7r4uybn45t4+xnPo3dzxzp3TilyCjilgm6USGEICeLyMki9vgNLnWLevYvlhtvcAHQsCkaNsUN2CDwbkqC6F9eTs4sUErHOqZwZm2fp7qU4fK6GYpRwPuMniupmNqgQdBwKd5e64wkFAA8X9J8i59klnUnFKDbUnJ4nGGEb4NvwjhNG+N678VeN5bSjdfwcR8+DoDBjRlNy8Xbq81Y/dZsSsYL0xmoojD0nNpRGLVBInpyX795E9aDu3jxxRcxNTUFwDsmx6VoWG5sdmtU3HWPKxuFqGVJZ4Zrx1xYGXBRFwjZsEvXm9873HvSsFy8tdIMO4q7mUnJOD6dGaq7lfj7Zds23r5wCUZ+OwAvyrndt6XZm9dAGcP9toW3V3rHplF4nnKrhoOLVR2qQELfwGlNHlq4Rc+JbcpkFsiHXcPnUoYL9XhKSbBMKCktNkniQE7BnseoXm+S782jOKaNaui8a0FyfLdfp6soiti+dz/u37wBSr3v2a5DCWKPMaBZhaaK2JbVMFsoQpIer+VIIAQl1fPv2w/vZq1qdQygow0uDEDVoqhaFq42vBvZkm8APaWKyEhCeM0Yt0sV6EwYitLwGzOida0zvi1Ov8aM4Hlvr3WaoWQBOF5OxXwTk0gSYIyxgVM2gNEjfJvx3ovi0t4IH2MM7XYb2Wx2rG0+iTxe37DHCEopLMvq25hxu2nhfKUV3jkIAI6U09id69RPTVrw6Q7F8pDNGgFRwWcKMnYdfw+WmYAbD7zpEC2WhTOVw/JSfVP7NpeSkJbFjpgTPYEnb7LQuXuWLhCvRaxHGiaKioi8knxK322aOLPWQj/teqiYwoHC8L6IhBCYpok33ngDzszO8Oe7utKpAiEoq53PaSYlYUdWxaru+JG5zqJhUoa7LSvs7M7Joh/9k1BW5cTIZbSBhzg2itJkJpxE2eqMY8vxpmZEF9AsbDQlOUwDysSLPGy2GWVLGVOvbWVK92E1RQAMFdOLgP39n/vP+MUf+wdorT7AN/31b8ef+cAX9RpAEwLkpzwDaBs4d6cG1dZRUgTM5zMoF/IT75DdLJJAMKNJYc2o5dKwuaViurGUtcuAVdPFql9Hp/gNICkXgDJ6yUW00SX8GWO41bJxZYTGjIA108FipdNMkxIJTkylBpZItOy4917Of3y/WbXdjCp4N+O9F6VfhE/XdZ7SfTcTbcxIqrewXYoza/Guzows4MWZbI/YmLTgu9NVmC/4XW623+HanXLVHYqGZQPE+4LpqQIu1btTmRuvUqpAeqJyKUlAzXTwjp9i3Z1TcXRqa740wWi16Jc0mlgZVM/oUobzlXYsChhFFQiOz2TDaRzDwBhDo9HA6uoq9h04gGtSEWAMIgG2J9S9RHUaAcH2jIrtGTU0xV3xp390p38btpcyv77u3VCUNCkc/5ZXvPTvnUgDj9SsAFPbhj6OjYj58E1ki8l0+7gJAKY0ESsGwnbErCTgeFmLeYBxPAYKOpdNxAooKwnYlurczAUpVwC46YuOgGcOHsDv/8//EetqDc71z63qfuMHQ+wsUzSYiuYZQLcZSLVjAL29mEMuO9gA+mGjiAK2pYTQE053OgbQ1S6Ba1Hm+9QJwM5n8cfLrU4HsCINtBkJNhVcS0yX4lzN9GYK++Qkb2LGIB/Kpbb3nQv2Li8LOFHWhspsLOnx6B7pSudG9zEJ13WHjuRu1nsv9rp99o/X8L2LoZTCcZy+KdyKYePUSis0PAa8iM6z5XRi9GUSgi+4oLdtF9cjM3grpoNP3a2j7bh9o1YAQrHXD5kwUEPHXLnYY1mSEoW+XbeXqp26v0l770UJInxyZDeCi59DGZZanpATCbA9E9+Plu2lcPv58ZU1CSdGHG3nui7OnTuHtbU1FItFpOZ2wFn10rXzGQVywt1rTDzFghwdU9wg/Vs1nXD8W3QMHwWwZjhYMxwAOhSBYFqTsWpEpk40q2Bsbuhj2YitXlspY7i8boUTEACvC1IWCFYijQHbUhKeLagTG9X3ONPPKmOrBF13U4QmEjRsGmvMkAVvcklSJzRlDBdqZqxjc06T8Fyx9/MKznVRILBdBpEx5Kp3Ud69b7ABdJ1CWPYMoGfSMraXCj0G0I8DKUnAjq4GkEqkASR6ndZdr17VM0M2kZX8BhDVawDprk+NNkSsGA7O1cyY9+igxgzAO5euN21cbXTE+Ywm4vmiNnTDyb0u771w/4Y0hh4lpRuNCk+P4b0XJalLlzHGu3TfjTDGwnosxlhPBy5j3hSHKzW9E00RCF6YymA+0z+FFkyxGPTaSZYlYadrH8uSNWPwDFcwBlkkYcdWWRWxI6uFwk6TBKytruLS7Rs48cwXDN6eTy3SrFFU+6dRJ0HyaDXvDVlqdSJDCxk1dpG817JwerUFp0+67EBBw8FiaqSOr2aziVOnTkGWZezZswfNZrNrpFyy8CV9opPdCIRgSpMxpcl4puSljNYMJ4wARm80LMpC/0PAE7x2fhpVm6FA2aYFUqxLd8IhPt0fxRWtzZtWRTQjo5oAhlT9AY7Ob34Sw+NMIOiYlsGy4cCk7pYJuo2aIpIiRkXFs/JI8p+zXIbFqh5rptmXlbFvwPzi4FwiABTXxP6cMrIB9LWIAfRcRsVcqQBFmXwpw2aINoDsjkw4uVNdx4O2BapmYleCpkPRdChutrwGkIIioKx4FjAFRcC927ewdOsGDj9/DKecQvg8RSA4WlQHljpQxnCxHp+2sTMt45nC8POm1yLee54A65wX/VKm3YzStBH13tu+iegekOzDp+s6GGO8hu/dRHdjRrfY0x0Xp1Za4XxUACirEo7PZAZ2yIqiCMdx0bbdsBFikpYlAhBJs4rQRIL1tRWs3VvCgd07sWfHdtQsF2/e9+Y8FFW5J+0Z7TYdlluNTqRx1wTn5iYhCAJs2070E7yV0MBCGcOFShs3GskpXFkgOD6dweyIBtH37t3D2bNnsWvXLhw8eBC3b9+GRURU/fMiK4so9emGi2qvUcSTIgqYzyiYzyhegXFX+jc6ltRlgJufxkUduHyrmpj+HYWtSumuGg7OVjvzPINIwf1I558sEOyEjmqr+sSLvaEjdHuew7m6PXB7USZlW7JmOjhbNWMpyH1ZGXv7zFht2t6M1aAzXADwXEkdKuUW1qKBxfat2wA6qI8LBOBGBtAX7zWgWDqKMsG2XArTxcLY81q3imDCiUVs6Ku38OJLL3caQCw3NoeYAahZFDWL4lrTxhu/+//iJz/yXaDURb48hX/2a7+DuR27vMaMgjYw8uVQhtNVIybmD+YV7M6M1vy0kQAb1idw2Bo+mzKsRL33tM19nkkRvnbbc5XgXbrvEgKx5zhOojfS/ZaF02utWOj8oF/c32lFT7Ys0R2KemkXlqkI3B2vISKwLFFFIYzoyYTgpbksMpIIVexc0HVdx+LiIhzHwcnjx5DL5fxtdC4kSZM2holCRrEpxT2/qUAiZMMI5yToF+Grm05oeJxXRBRUCW3HxdsPmrFUaJSiKuHFIYR6lOiM4RdeeAFzc3PhfrXVzp3hrg3MjqM/HbdAnhCCjCwiI4vYk9dgOC7+4E49rISKfrKJ6V9f/E37/oWDXzD6n81LviQXf03wGm2iKcG87Pnrra+1UN30q2490YaLivn/sfffYZKkaXUofr5w6X35qva+e9qO71mMYLUIIcFKIBAyCwj2JyFA94rLFbBCsEIsLAuSVgIkxC5IWgQCJC4swixmYbE7a2a6uqtdte8u79KbyHDf748w+UVkZGakqZ4Zps7zzDNV1Wm+jAxz4n3fc46GYtO6uXvKFbpBYFCKB57vROIIzvaRsSpxBBeyYaQC5mez26vb2tn5ONYgecfPAFoMQRFD2ASw2QTwZAdhrYmsxGEmnUA6mXjT3DjYhIf3ElyDomAZXOebuisj+hc//KOO4rlaKuJ3/+d/x7d97w8gJ/HQKIVIO2/Lpm7gSl52CCUB8ExAcs6izfzYQ8D6qfAFIePsDeCg3nvu9TGEzzr91Wo104txj/C9PWBH+7Bkb35+Hh//+G9AmpjBM1/2buduROQI5uISDEpxdbsWzLKE7755g1qW3Ck2HMJ3MBlCzuMRt7m5iYWFBUxOTuLUqVOuA8pNlNrXYBOqoFitKq02alzadS+0lkrXXeFjkyX2x0PYsIyvvZm6Ng4lwziZ6a+F22g0MD8/D0ppW8YwBUEjZJJqDua26ATveMAosFpTHRp2MBnGsVQYfzZ/HbHJGVQhoKF52r81BasWUY+LPMasCmA2LPp+h6Os8DV1A9cLTZexay7EQafAOjMvNhMVcDJlxjiV8eYwJHZEUVaFTtaoi9CxGaX3K4NV6EIEKGyu48i+OURE7qn40Mm6gYWC7GrJ5kI8nkmHfIf3bUXoHUackRBNMU0/kWOdKnzd4GeQXFHN+bgdRUexqbtvpCwD6FUAq1UKsr2BKFUxFhYwk0kiFo2+YQTQvt54IXEEkxEBk9ZcXEMzsClreFRVwYtiK1uaUvCCiIpm4HZZAcoKwnYCiGUDE7K+j6pq4Eq+4VRHBWLarmQGSKroZX486grf2gi891i4RBvW/xuNBqJv4L7wRuBtTfgAt7DiypUr+IIv+AIYlMLQdXzFP7yCf/Qv/w0A8w6HNVcOAo4aEKmBTDziJnN9WJYYlLp81vYlWi1UwzCwuLiIlZUVnDlzBtPT0+2fzydpw7XGPlq63mSN3RRr2PCr8GmUYsVKteBgtpiu5/1NnwVCcH4shqk+K5FbW1u4du2aL4kGgAoEUM7821RM6qlw42BW3kbBYUxbIPfsoMhzCDWrOCDqmJjItdq/soqdhuaaZayqOqqqjkeVJggs8+ewaf5st387CU36RaGp41pBdtqFBMBcTMBmozUPRACcSIUw18NKYjfQi9A9jQpds9nEny88xoFTh56KFYk59N9KYyAAjnTxNzSo6ZHItvQmwjyeCTjs73ot+4cuValeIIQgKfFISjwOwjyvlaz26E5Td82GghDQSBw1ADUAjwsauLU1JIiOiWgI09kUQqHdP4/ZCGq8XNUMPKqqUAyKb/ref40Pfus3QmnKmJzbj696zze7HivrpprV/n7iAoeoQLDTbAlFwjzBxWykp4K3E3qZH7tVsN1tWXpV+KqM9UtCGNx7z299PGntd7VabY/wvZ3x67/+66aAwyJAn/r4/3YInx86WZbYSte7i7cBAKcO+xiPBsRWW7KGecDWajVcvXoVANqqTyxcdiZdWrq2WKUbSoqOstrb826UaBG+1trKSovACBzpOK+XlHg8Ox5HtI8TBqUU9+7dw6NHj3D69GnMzs76Pm7HaH32TmINFsTquw7a0mVRaGqOeXQmJCBhtdPsKoC3/WtQiqKl/t2SNRSZeVSKVvt3sdiw2jUickPOzFBK8biq4l6l5REmcQQzEQFPaqqzHSSO4Hw23Gb2OqqT8G4TOg5wZin3RQWkQ/zAFbrdvvAYlOJuWcETRhkd5gnOZtq3v41BxRkdQVs/jOrz8oRYCRcCjsK8OS9Ys387iuaqwoLjYUSTKAEoUeDuRg1CcwspAaYBdGZ3DaB7Vbh06zti1evPvfKF+OifXsHOxjrOnziKS5NJp8KZb+ooKu4KpykAaf3OARgP8VAMAwYlfbdHq6re0/zYJYro8lpBRBtrjdFW94BWsePtnLIB7BE+Fw4cONCyZOF5TMzua3tMmOeQCwuYiUnIhf3NcG3wPA9F8Y/wCgq/itrq6ipu3LiBffv24fjx410PIFe0ms+Fzb7bCkL4nnSoNO4m/Cp8rM2K0uFqfSARwqmMv11OJzSbTVy9ehXNZhMvvfSSMwfpRU3VUaHmNo8KXCAzYEIIQOlI2pRLHZJFnLaPBxwhyFpxdMdhekmaCR+mAKTOtH9Vg2KtrmCNKZg2dANbsoaMj12EH1SD4kZRdtmrZERTFf6IuZClrHm9UIfqaJBt9UZX6BaZi/N0VAw8y/a0UdfMFi5b/Zqw0hjEDt9pVdUxn5cdQ+F+xBmd0Grp7h7BFTmCiYhgxYOFIOstcrTjNYAWJGiC1GYAnRY5zKRGbwDdqaULmNt7odB0KZTHQjwOxyV8lgKxZAqhkNlOTUk8UhKPQwmTzBQVHTuyhnWmcm7DALBU17BU18ARKwHEav8mxN65vm6xhv+5rp+WbrcKn9f6ZZh9jYXj88mszbZk2avwvU3xDd/wDfiDT38Wv/Nrv4qJuX34wZ/4LxA54poLk3XDSUPgCZC1WmETERFRwX3wDOvD19B0J0UhzHPIigQLCwvY3NzE+fPnMTEx0fM1grR0gd53XirjeScQYGaXxRrs+rwVvm5zkzwBzuVimAlQdWORz+dx9epVZDIZXLp0qetdvpdwBTlh2Ft2WLqnGtQtmmHUxp0Inxcio/4FTAJrVv/a278AoBjAfF528kJzTF6o97OXFbOFy6YO7IsKKKuGKzZtzrKE6FVteKMJ3dO4GOz2rOJ6Q8WtYtOpRBIAx1MS9kU7qzSHFWf4gY3fGmWFrxfCPIeZKIeZqOgYQNvkz+uPZxtAbwDYYAygsyEeM+kkkkMaQPu1dCmlWKqruFtSnEodB/M7mouKrsg0vzM0TwiyEu8akwCAGE9AQVFnLkEGNe1Vdpo6UDHP5aYBtHlMR3n3Pm9Q6hy33QhYPy3dbteZduuX0ewjexU+E297wuclaO/74L/F3/+XPwwAeGU6iZTEo9jUsdVQsOUxw9Wp2XLdaqi4CbPaM2aRv1xYHJrwsbN7kxLw6quvQpIkvPLKKwiHg1XYXKINnysjS/hEsfPdFOt5NxMPPbXger8KXyckRB6XJuKI99nCffjwIe7fv4/jx49j//79XU/oBqVYtr8XSjEXkFjaLzls6oHLezAuuSqYQQmfF3b794DV/i01NWw2VCdJxQZFKy8UFTPuLBsSLMNYDttNA4ulloO/SICDcQmPa6pTVeEAnEqHMBM197VOhK6sSahOHsEfrtfe8oQuKEa9Fp1SLHq816I8wdlsGMkOx8ioxBm+r+355Y3Y9qzZ+X7GH2/HUsh2M4Betg2giYbxiIjpdLJvwuAlPIrlf7jNWKbEBQ5nMyHnPGYwDVu/86BuUCx4KupHEhIOWTOZbIUz33STQo0Cm7KOTeu5ISsCzv6vohrOsTvehYCxFb5uHK1XYWGU3ns2KG3dFLJrs2f43k542xM+L1gioxnmXWgmLCATFnA8Yx6g27LqED222lTXDDypNPHEGoaPIgZIKsqKhoTYnxea4RrMp1i9OY9Dc7M4evRo33NBtmDArzBmK5R7KXVdreU+q2fDwI5WKze7E+e5uIRnsrG+WriqqmJhYQHlchnPP/880ul0z+ds1lXnhCk0ygjxuUDvxVnmKf5R9MGx1MXoeVDCx4IjBJmw2Zp8UJZhUCBs2TDsePJCVQpsyBo2PCbg9WoFv/2z/wnNUh7P/o2vwclLzwMwCeBUREBJ0bHe0HpU6HhA5LuWRN9qhO5poqqaLVy2PTgVEXAq1flmzc+cd1BxRm88vQpfN9j+eGmJdxlA2xXArgbQOwr4lQKSfHADaJbwbVuJGWyLeb+VmOGevXavl4Vi2a6UGduV08wNFdBe4axbFje2BQw74tg0zIqeXdVjCdJEl9GVbmu0Qa2Rlk4t3VF77/mtba/CtwcXerVAJZ5zZaFWVN0hf3m5JV2nAGrggXgOf7paRognGI+IGLe80HqpOk2xhlWGrpXx7LmzyOWCkQsvOI7AMKivaMP89+7WLKWm5szNpSzPu6cHgnosg88ub+H/+5mfxNrjh3j5y/4GXv6yrwBgXvSfycZ8c3S7oVQqYX5+HvF4HJcvXw7s1M9m8vLlHQCHgn0Ka7caho+x3oN+38MoCJ/r9az/8xxwKm1WlOtOO6z9YmHjR7/tm3Djc6+CEIKP/8r/xI//2u9j/7ETUKk5SxQYhoGYxL+5Cd2IVNejAqUUqw0Nt0tNV/7qyVQIM5HOKmhFp7hWaKDAiDMOxUUcGVSc4bu21s/kDarw9UK/BtB6rN0AOiUA08morwE0pRTgOCyWmi7xjMQRnEmHnPdl4SZTrZ9rmoErOw3nJkwgwLlsGLku52dCCGICQUzgsM+yuCnbAhDFEoAw78d+3OtFc81ZJgLOvl6yt+OdKnxsZKkfRu2957yvi/C1fn675egCe4Sv7aTTi/B5n5uUBCQlAUdSEWgGxQ5T/WOH4Zs6xXJVwbJlJ5KWeJMARkSkQ+0n4vv5qvPz2X2TyCUHvxPhCaDBv8IH9LZmedpWLDYU3cDdJodmahL/+bu+DX/22x8HAPz5b38c3/eRX8A7/sqX4tJEvC+1MKUUS0tLWFxcxOHDh3H4cPDoroZmknsACBGAa1QCv6/9DsO0dL1WLG3vsUuEz7BsL9i0CIP6zxNpqorrn/kLAC0udP0zf479x060PbZbha5RLuLR/Xt46cUXR/Z5dhvDXJ5GQX40w7RPWWdmJc32YLirHUdVNTCfb7jEGafTIUxHR9NSs+G+pXxzVPh6YRAD6C0AW4wBdEbiMGsZQDfBYSeShcKQvVyIx5l0KJB4yd5iRUXHfL7hWOuEOIKLuXDfFiaEFYDAPNbtCudaXYPsOWGVVQNl1bSM4WBex7Ih3uX72akYbBcVOhG+UXvv2fBL2QD2CN8eALAhBHqfHhoCRzAZlTBpDdIvb25jcWUDyZn92JFVF+EqWndTd0uyY4VhRmEJeLL0BAWSBIgZaD6TGC4onLc8QTpV+LqlbWgGxYol1uAJMBN7OoSvIKt4fasGWTcP0Pk/+xSofcLgeTx87VV8z9//233NEmqahps3b2J7exuXLl3qu2LqmqkMEWz2YVht360O2tLVjZb3IE/gK0oZhPDZ0V/e2L+62qreNXTgs9uNQK8niCKm9h/E5vKSkw6w/9jJtsdFOCAXEpCLCMj6qH81gtGH+O4C3iwrrKg6ruVlV0LDbFTACcvIuhO2LXGG/V2PQpzRCe4ZvrcG4WMxqAH0GoC1KgUKO0B0win3czAjzvb1iDhjb8U5QrDRMOMJ7feKCxwu5oafsbRf37a42W7qDuGbigioqAZqDLEzAOQV3WWoDgBbDQ0SxyEmuCvw3Sp8NcZ7Lz4i7z3nffcqfA72CJ8H7MnRq1bsFzGRB1/awvMXz0CnFAVZc6p/FbV1kLSsMKxBaRp1bpPmukR2BQUbA+f7711aui6RQGz3xRqUmgbXtwt1xrKL4sgz53Ht038KQ9dh6Dre9fJzfa2lWq1ifn4eoiji8uXLgUUv7LqWqq1B9ukwj40+9o9hW7prdcXZH6djkq+Vhh/h60jonCxnvWPlNygkYkYA2ifs9/30x/Cz/+Zfop7fwtd/07fgS77oC9ravw0DWG5oWG5oTlg8q/59O2GYqqyt8LxTavkdCsQUxnSztPAVZwgcLoyIOHR6TxZvNcLnRb8G0JCYcw6lgFzDekOFHg1hOpPseE5iN1tJ0XG/0vrOshKPc9nO1jqDoqK28n2TolklBszUHLv929bitvCkruFJXYPEEUvQZf5nzy/6fe+ru+C9Z6NTha9Wqw08JvVWxR7h88DV0h1SUsmqdHli5ZlGRJyCGZ2zbZG/LVmF5posbZ2oH5RllBXdaf/GBrjzse9qdOrvt9dNTfw027mqbuDqTg0bdU9EFSH4Zx/6CfzcB74fa48f4J1/89342q/92sCva/sW7t+/H8eOHRvIV8trgB0WegtdXB/B+v+gxstPOog1WEInS1FsURHVndpICR0H8ySsU2CDmbMhAE4kJRQV3RWRdu7UCfzh7/ym6yJkzwrtWO0wVg1JYYfFK7hvWUXEiQgllkFDM4Jl/75hGE2NbxDyoxoUN4uyo7AEWhfnaJdt9nTFGS281St8veBnAP2kquBRVW0/7gmBEYk7BtD3NhsQmttI8RRTiYjLAJrtzLBq3umIgNPp0Mhm3Vi41LIMAQvxHKajHKaj7hb3w4rS1v5VPAKQMKEwJg9go6EhE+IhWfua13tvuoPX36BwVfiYw6Jer2P//v0jfa83O972hK+N/DAnvF4zfL3QbTYuInDYlwhhNibi3v37eLi+hez+w6jyYdfsn0GBzYbq+PFFBc4hf7kOOahesCSWon3WqFOFjxUJJHdZrFFqanhtq+qaBWGRyubwz//tTwEw50aCXCwMw8Dt27extrYW2LewE554vPc4aH1VZtiTchCTa/axBVlDwUrHkDiClaqCeyW5ndDFxs3/d0geaV8TrGQYvi3POcwBf7ZahkJNAiZwBMvVFhGP8AQnUhLulVWXkrHToD87K3TYUkMWrGH4HVlztSI1ChQpB+Rm8WebdUR4YrZ/QzwyIX7k1YyR4Skuq6joWCjIrgrL/piIY8nu3oaKQXEtv7vijE5wHy5/+QgfC4NSPKi4U00EAki1IoRwBLIQ9hhAi9CEtMcAWkZ9YwX//aM/g6LcxN94z3tx/MKzAHb3OzModeZACTp777Et7p2mBtm68TgYF1FRDRQ8AhCZEiA1jmsF0+4pIXLmOAeBx3tvtDd47HWcPTbq9ToikeHGpd5qeNsTPi/YHv+whE8QhK6xZY1GA9euXYOqqrh84TwSiQQ+t1FxCF8uLKCquH2T6pqBx5UmHjM5qDYB7GT9wnk+k/eC0ImYeknObsDO572Zr/tWvwgA2mwAodaBGaRKVq/XMT8/DwB4+eWXh5Lfy5qBTavqaKutm7Lu2AwEOemyjzDQih/qt+WqGNT1vXRDN0IXFThIHVSulFI8ePAAr336Km5e+TyOnr2AZ7/4nc6/T4R5TEUEXC+0zHx5ApxJh53w914QOILxsIDxsACkQmhohqOEzDc11zB8Q6dYrqtYrqtO+9f2/0uK3K5UOJ4m+rlx8IusEwlwJhM2t2UXPC1xRie0VfjerMR9SFRVA9cLMirMjZAtzLh9/T7GImOYmcyiplHkm1pHA+gqOHzbN38DCpsboJTic5/8PfzE7/wJXjg0O3i0XQBsM2kkE2Eh0A0WS+wOxCVIHLHEXoZp/2LNrLNnwopqOG1jGzwIioo+0uPabcvS+nlvhm8PHh++4V6LNTX2Jjdsbm5iYWEBk5OTOHXqFHiedyVrRHgOL06a0V5lRce2bFb5Ch7rFzsH9Xah0bJ+iYgYC7esX9xtasA7IuUn2tAMitXq7oo1NINiYaeG1Zp//FyY53A0IeB60f33TuITG/a2nZ6exsmTJ4eORlqutsyE98XNFor9mr0In03o2JuHGzt104NuyJarl9CVtzcREXgcmpvpSui6QdM0LCws4Dd/8zfxgQ98wKn+fuu/+TG882v+HpJyEYTEcE1u2dhEeYLzQwSzA+bnmGOG4VfyJdxb30Z8cgbFDu3fB56kgFyI79rK3G3sNn1RdAPXi00zJcFCWjJbuL3m7p6mOKMTPNOlf+kqfJRSLNc13Cm3LHEITGHG/pgICkAlPGpEwEq95UOpGhQc3OIMANjZWMPO2qrzu9KUsXTl05ipHcYqxyGTySCbzSKTyYy0UsWqZacDztO52qbW/zlCkLGq8kcAbGxt497aJsYOHEHe63FoYV3WsC5r4IkVAWfN/8WF3hFwndfmP8PXaDT2CN/bDcPYsvSC7cHEEj7DMLC4uIiVlRWcOXMG09PTzuPdWbUtsUYqJCAVclu/bFrzf2wLtM36JcRjPCK5xCd+ZMmvwrdaU5yLw0wsNPI2WlnR8Ppm1aX6YjEeEXFhLIa7hVaoK0/ME0un0UrDMHDv3j08fvwYZ86cwczMzNDrpC4D7Nb8nP3d6LppzdCPKGKpjwqdyBHH3Dsh8jiaDnes0F1fqyHEhZAZsPVerVZx5coVhMJhvPr6vDlnZN0IfOrj/xvv+jt/D7VQEmXaIglRvYnjYQ5RfnQXHEIIYhyFVNrEc2eOutq/+abmipryJgWY7V8euZDwVNq/o1Lp9rqY5ZsaFgpuk95DcRGHE91buJRSLNVULD5FcUbntbC/vPVFGywUneJGsYHtZut8JhLTL3NT1vCkZvmqjh1EAQBKvc8BuckppHJjqBTyZgYvL+BL3vEFuHTiMMrlMgqFAtbW1rC4uIhwOOwQwHQ6HdhX1O9z2IkdtugiCAJl6Ro6QkodJ1Ih573uVpqueUEbOjUrjfbMosSZ5DEr8ciF+L7mejupdGu1GuLxeODX+cuAtz3h82KUog22wgeYO9jVq1cBmG1G9u6CTdYg8PdZA9zWL5RS1DXDIX87suoiQ8WmjmLTbaexUlWwLxFCmDlg/Cp8S5VWrNao27lLlSau5ztHZh1PR3A0FQYFsGrdbRKYn13X/e1lms0m5ufnoSgKXn755ZEdyNuMn2JC5LBWV9DQDNRUHfqhZ/AHq5Xhor96tFw/u1FBUzdPiKezUYx1UV4O48O3sbGBhYUFzO7bh0ZmBuHxaXDEbMtwPI+J2X0wQACudQEQYICoTdx8sAlaLyOTSiGbzSKbzSIajY7sgu5q/8Js/9pKSP/2r4Zl6yKSEjmHACalN2f7t9t3Zs+CPay6TXqfyYS6Guzaz30jxBmd4LIkeguKNiilaBrUlefc0A1UFMPVvrWhUrfIohskjphelIKZLLQp6xClEN7/3/4XfuHf/wia9Tr+1nu/DQcPHQTHcUin00in0zh06BA0TUOxWEShUMDDhw8dImNX/9LpdMd0Cy/WG6rzLc1Eg5sf26SKoDORNwzDtQ6JJ6gxLd0LGXOu0VYAszc3ikGx0dCwYc0WRngmAk4SumbudvPh20vaeBuCvVCyLd1hK3yEEEcBaytF5+bmcOLEibY24yYT02aqQHvfwRBCEBN5HBJ5HEqGoRsUBSsHdauhoqq2n2zulBq4U2ogIbaMn4lHtFFqak5mcNIatB8FdIPier7mVCC9CHEEF8bjDqlZrymuHMeKRmH6Cbqfl8/ncfXqVWSzWTz77LNt7fNu6DVDV2O2YUU1cLvAEOhQtCvZYwldVdWdauxz43Gkw0LPlmtd1bFtRQ1FBQ65HjNag/rw3bt3D48ePcLxM2fxmEZQqav4uu/4Lqw+uo+bn30VR89dwDf8i+9ve64GDlo4CcwkwQGoGQpqtRLuLS1ApDpy2SxyuRwymUzXnOZ+P0tE4DArcJj1JAXsNM05IfZZJcvf60FVhUCAjEX+ciEeEf5NkNTRBbJuxqMVGYFFNsTjmS4mvTZMcYaMAuOR9rTEGZ3Afi/kTdjS9eY6NyxiJ+uWCl6nA6vsRc4c02mUCsjEo8gm4g7BC/PEISJLNRW3merf/mMn8L3/6b85v/vxdEEQMDY2hrGxMQCAoijI5/MoFAq4ffs2FEVByroZy2QySCQSHcdc2GrbdB9ZtvZNeD85ul7vvXFr/tc+rqtaKwPYO+PY0ClW6pp1M9NEXOAcApjx+Hr6VfgopajX63sVvrc72B12WB8+wKzy3blzB8VisatSdBT2JzzXsn4B7GQIDfdLDZfyF7B9lnQ8KMsg8WlEDBVCWcZERHS1HPePwAcQAKqKjte3qi7/QRbZsICLY3EX0X3CVBmnwxxqNfO5NsmilOLhw4e4f/8+Tpw4gX379rWtdVd96AwDUZFHTBJ6iiJe36yioZlENxnie16wgfZkjV7fQ7+ET1EUXLt2DfV6HccvvYDbNQOaZZYcSyTxfT/zC23PCVst07Jn4NoAUOMkIDEOJMZBQFFUG9jZ2EHz1m2kYlGn+pdMJoeeq7ThSgpIwGn/2mkI3vbvlqw7LSu7SmD7/72R6l/vd7sla7hRlJ0kBQLgSELCwXh3k17gjRdndAJ1FfgoCHn685YmoWsncw2dQtaNoSyMeGI6CMQEziFzdpKMTUBevX8Nc5ljyMXc3wWlFPcqpoWLDTsDnUWQipskSZiamsLU1JRpndJooFAoIJ/P48mTJ6CUuub/7Gp8RdWdSmVS5PqaybXX2W19bI4w0N17jxCChMgjIfI4EDcJpRMB19Rcc70AUNUMVDUDT2qMsEsyZ3uXl5fxid/6bWQmJnHpa/+W85y9Ct8eQAgBR0xS0W/ShheVSgWapkGWZbzyyisdjTXrTGRXhDdtV0aBiMBjf8IUg9wrmeRpJiaad1bMnT8lHOp8CDfyddxgns8BmIgONgvCYqXaxMJOrePJ9GgqjGPpiFsyz1S3oDSR4kVw1li8QSkURcHCwgIq1SouPvc8hGgc63V1pISOoFWVSIg8ZuOSi9D94e//Hl76oi8KNDDNngeDtIANSrHMtPjnOrT43e8RnPCVy2VcuXIF8UQCk2cu4Tpj5ipxxG0ZYWEizONMOuxcvBSdIq9o2JHN6hqrJldBoIpRIBcFcvvQgI6NRhVP7j4E6hVkM2mHAEYiEV8bl0Hgbf/Kuu39Z7V/mWPaXSUw2782AUy9Qe1fg1LcKyt4zNh5hHmCs5kw0gEq7X7ijPPZYM/dbTwNHz7NaCdyNsGTdcM3+zkIzBhAk8DpFG2V5OOWMKPXZ/KSHsD8zm8U3ZF4k2EeG3L7zXG/FJkQgmg0img0itnZWTMdpFJBoVDA1tYW7t27B0EQkM1mIaenAJjn+5k+bw70gBU+u6Xbr/ceRwjSkpnfezghQTesCDhrtpe9+WwJuwy8uvgQ/8+7vxT1ihmDubPwOfz7H/sQgD2V7tsW3gslb80uDdrSZfNaBUHAsWPHuiY7LHUQa4wK7IVrJhbCZFSCohtO6sd6VYbuc7dtAPjUchEZy/plIiIi3sH6xQ+6QXGzUHdVL1mIHMGFsZgvqWSrW1w1j4oWdb4PA8An762CS83CGJPwmZIBlMqB1sSi2wxdhCf49HoZdesKcWkijrjH9Jojwc2X2a0bZLcyjZ77b/EHWY89XnDg8GGU4xO4x5C9yYiIstI+RH0sIeGAp7ok8QRTEdHJGa1pFDuMzYTLgws8EEkBsylwoKgaKqrVIu48vooQochZ5I9t/44iFzjMc5iNcpiNtqKwdpg2kV/792FVBW+pf3OWAji6i+1f+3PWNbOFyyY0jFsku1f10U+cERc4XMiG3zTG1W7RxmCET6eeGTqr1Wr+bkAd8CadA5wcZyff2fmdg8iZM3m3irJrLi8mmGQ8aBQYpdRF+FSD4qqn9X4yJbl8El3rHHIXJIQgmUwimUziwIED0HUdpVIJ+UIBqzpnSmypgerKI2xl0shkMoFGZOxjPWiFj71BHMR7j+cIcmEBubCAYzBHGArWTV2+qTu+nq/+7m+iUW3l0n/sv/4c/v2PfQi6rqPZbO4Rvj0AAiFQQQcSbaiqiuvXr6NYLOLSpUu4c+dO14twULHGMPDzFpR4DrPxEGbjIdwrb6DYUJCeO4h7pYarImbAbf0S5s228UREwlhYgNjhQK2pZgu3rPi3cNMhAZfGYwjzHJqORYnZcq2rhlPdAgAjO40rJffrGNGk2UboNkMHN6FrkTrz91CXi3heVh2ylw0JbWQPMNv1QUkJ+z5B8nS9NwFB36OrAIBRiJ84dwEPVBE1pq1yPB0BQLHRUNueezDRvdJLCEFcJIiLEg7Ezf3MDmHfkXXXULsBYrZ/kxNAcgIaKApqA9vrO1Bu3UYyFkUsFoNhGL4VkUHBRmEdSpg3JI75c1N3KcZ1V/tXcVrZu9X+NeIZfGar7lSgCMyqUa+cVcBfnDFuiTN2OwqxHwQRbRiUtgicVZVrMNU6v8pzEBCYldIIz7mInT1DF+oxT7vT1HCj0HRVseeiAo4nQ30JYAzDcN6noRm4kped/Y4jwNlMGBmJx51Szfkb+5FHfdPB8zyy2Sy0SBLUMkROcwY4auD+/ftoNBpIJBLOzVgqlfI9HluEr/N7saKNVaaaOTOCjpbEEUxGBMcHtKKaxuSpsXHnnEgIQS6bBWAKKAHszfDtwUrb0Puf4SsWi7h69SpisRheeeUVSJLUNbYMGEys0S/Yuy6/8yXPcRC0JiaiIhaLpighInAYCwvYljWX9YvcZv0iYMISf0i6gj/6oz+CIoQROXGxzVfKRkLkIXLAZzeqw/nQYXBC1wteixw/BK2omY9t/dzrmiVbymugZfQc7D06Ez5bxayqKo5eegE3Kxp0aq5d4Agu5KIoNHXcL7fmJtmWdr/giZ2OIeBYspXBaZMrlwIPBIoYBcaiwNg+yNDRrJWgihX8yZ/+qVP9s9u/owLPEYyFBYxZYhjZs0aVWaPsaf8mLfVvk9l5B9nTdErxQAbUqUPOxo7wBOcyYSQDtGH9KkQH4yKOvoHijE5g9yWd41GgAqrlptN2lXXqm80aFGGeOKSuRebMn0M8GahFb1CK+57ZOpEDTqfCmBggAsyu8FVUHa/vyM5xIHIEFy1fxKVaK4otLnCuiu9u1WrZebpDmTjGptMAAFmWnfm/1dVVaJqGdDrtEMB4PA5TSmeiV0tXFEWoBsWWRfhEzqzwjRI7TQ0LeRkqBd7xFe/Gtb/4E3zq4/8biUwWP/PRnwNgtnMB7FX49tA7e9YLSikePXqEe/fu4ejRozh48KDznF6E72lk1fbyFrR9+Ni1HE6GcTAZtlp1rfZvu/WLhmJTw8LaDt73d78SjxZvAgD+6tf+A/yTH/yQ73pMwUiwtYd5ArVaBtEU0EgCumBWmr5wJtlXe7kfqLqBtbpJaAWOYLrDHGM/FT5XS7fHY/2MnoOgE+ErFou4cuUK0pkMEkfP4AbrySbyOJeLYrHYaM1MwiQvcYFYyuj+4uD84M3grGqt2bpiU3cNpzfAA7EsEMuCgKJiKKiUi1h8eMWstDHt334U2b0Q5jnMRDnM2O1fzUDemk/0tn/LquG6EAPAWkPDDCGB27811cC1goyq1nrsVETAqVQoUGWuphq4wogzCExxRr/zV6OEY13imaGTNeoy2lVjaSwZAKoBTwRwW5d4267hAQldN9SsFjs7H5aVeJzJhAb2MDQMA0UNuFNpdVKiPMHFXMQxDV9ljI9jHsLXjVANiqZuYNuaFwx5vPfC4TCmp6cxPT1tXgtqNRQKBccChuM4pDJZIHsAQLCWLpvHPRURR/a96ZTiblnBEjP/yvM8vuOD/wH/9If+LTiexxdMmxW9er0OURQH9it8q2KP8KF7nq5Bux9kzWYTCwsLqNVqeP7555FOp92v1YXw1dXdEWt4wa7fryDF8zx0g2LFqtpxBJiNmweC2arjEWesX/JNzSGAtvXL/J/9sUP2AOD3f+V/4O//8+9BIpPtuC6/Cp3AATfyZpUxzBGc5BpYeHwLk1NT0BJTTrtR5AZ3Xu+FlZrikNq5mNSxZTN4ha8z5etk9BzsPdoJ39LSEm7fvo1Dx45hJ5zFKjOvNxOTcCARwuvbtbYM49mYiIqiY3TWwu512gq8g3b7l6msscRAB0GNCwGpSSA1CRUG8moDm6tbUG/eQioec6p/3ewmBlljUuSRFHkc9LR/O6UEPKqqeFRVnfavnQAi+ew/q3UVt0qtRAYYBk5nI5iJCIH26x1Zw7U3QJxhWpfAmZnztl1HYV1iEzib2NltWP4pVSwpNau5i57EjKNJCQcCtNi7va6WyOJWy0seKZHDhWzE8ZGrMjcSCYGDMCIxUzesN1rpTdPRzvsfIQTxeBzxeBz79u2DYRioVCrYzBecx5QKedzeqiCTySCTybgIld3SZQmtV507KEqKjhtF2aXKZ8FbN4b2oVir1UbqFfpWwR7h8wF7kGmUgu/QrNnZ2cG1a9eQyWRw+fJlX6+xTjm1gMd2YxfEGq019K7w1aWo08KeiUkQO1w4ea4V3waY1i+PyjKueVptHM9DEFsHO4F5t5oOCZiIisiERN+W651iy+cuLJdxe+keIpEIpqenseJqTY+eiACtbF8b3ebn+prhY/ahbs/YkTXHQmcsLCAacBgccBM+Xddx69YtbG5u4sT5S7in8GjILVXcqUwUIgd8ZqPiuqjZa9ufCONmvuZa826dGnnSGsAGzNbqaqmGh1sF8Kmcq7WqgIMixoDxGDC+Hw1oWK9X8HjxHohcQ9aym3ha7d8HFcWpsNlwt3+bTvs3GxIQFwjulBWsMTNMEY7CWLqD2bnneq6DUoqluoo7pVaW7qjFGax1iXeGbhjrEtZmhJdrmI6FMJaKO23YN8O8oWpQ3CzKTnILAEQFgrPpYC32TqCU4n65CTp92PnbRJjHM5mwi8h6yZD3xmLUm4hS6vLe66c6zHEcUqkUpFgCjzZNFpuMx8FX6nj8+DFu3LjhMoDWNA0qJ7i89xJD7rMGpXhUVfGAyZa2EROIiwDypEWYa7Xa266dC+wRPl+0pW14jnPDMAdaHz16hJMnT2Jubq4jWetU4XsaYg1nDT1aujzPQ44knd/3xzsrillQSrFRV/Gw3MQzl78QX/g3/zb+5P/8fyAch2/+vh9ChBmIpbC9khQs1xTEBM4hjrmwCJ4zyYojVqAUKGzi8uXLuHr1qtkOYPbWIR1zOqKk6I5XYFrikZQ6HyL92KCwJ+puT3F5ICaCfQ/e9TQaDczPzwMADl14HjcqKgxrXk+ylNFbsoqbhdZ7JUTOaV3ZZttBSeqoEeY5jIvA8sYjfMHxfahoBnZkf2VtAwIQzQDRDHhX+/d1RHgOWcv8OZ1O70r7t6DoaFgXzP0xEVXNaGtR2+3fhz7ty5kIj2mi4KYqt/2bFwalWCw1nRQRYDBxhma0Ezm77doYkXWJLYaIMG3XfFPHNUsYIDTKmEznkO1hJv40kW9quO4RZsxGBZzoU5jhhUEpbhWbLqHC/piI40n3nKVBqXMjQGC2O++U3Q4Ho57hq6iGQypTIofYAASMvQGIhEI4NnUMgOnzac//LS4uQpZllEIpIGU+djoy3EhOTTNwoyA7BJLFXFRwjagA7nZzvV4f6Q3hWwVvnqPtTQR2PMNLkGRZxtWrV6EoCl566SUkEonur9WB8G3WGbFGdHfEGjbYc5WfYEAGB10yDSgTIo90gPxEb2oGx3H4v37sJ/Ge//dfQQqHkcukcXE8jgYz/8cO6tc0A7VKE48qTXAwjZcjAgfZMj+MGE28/Pyz4DgOnJUEwj2FCp+7utedcHGehJJuYE9rndau6AbWa+b2lDiCiT5nsQghaDab+PSnP43xiQmQqYO4yczrpSQeZ3NR3Mw3kG+2Tob74iFzVk5VWr8T4loz3c0SXxewrdWeylqf9m9BaWBrZQPKjRtIW2pDu/07koo681XORkXERa5ri9qLvGJAIQRaLA1Fpx0jolQrOSMfQJyhU9pmKNzQhrcuIUBHMhfhCcQeSldWpTvsTOgo4SvMIMDp9GDCDBaaQXG1ICNvW7lQiqMJEYeS7Tf4rJhpPMxD4knb+XrU28yllh1w9rNTjq4kSZicnMTk5CQopfjs5z6HWiJj/iOleHT18ygnE44JdNAWK6VmfOIdpuXO4nBcRFbinRsju3PBHlq26fKbZR98WtgjfGg/iARXRaz1983NTSwsLGBycjJwhBfP81DV9jv7J540i91ErwrfttYim/sDtJbrmo7XNv0tVzITkwCAo6kIsmHzBDIbD5kRWIrukL9CszU3YgBtd2OxWBwbDQ1jYYEhfK1/HzLm2BeaQbFaM78Xnpit7W7op8LntmXxx3JVcSpDs/FQXzNLlFInTun46TPYEFPIMxF2++IhzMUkfH6z5pBqAuBMLorZqIQ/XCkBsOY37c/9Bp4LO1bMfVqrO5b1izdXtwkOTcls/5LxA2hQDWuNCh7dugPSrLvUv918MvsF26JWDYqFQgM7TX+WJesUMjhg8iD+eKOGhJP9a5rM3r51Cw+WVhA6dh4It1IBjiUkJCQOK3Vt961LrN97WZf0QnvSxht/sa1pBq57vA+HFWbYkHUDV3Zkh/ATAGT1Hg48e9738e52rnnuZPMkRl0SMCjFuvWeHOBYmvT/Oq2fOwkwCCHQQjHoVptmLCzg6PlzyOfz2NnZwf379yEIgisBxO+YlHUDN4tN7HTIKD6RkrA/JuFmsd1twJuju9fS3QMAt2hDM6jLv+z06dOYmZkJ/lo+Fb6nJdZw1sAcg17CpxsUW5ZK0HWx74DthorXt6quuSob3Ww8CCFIhQSkQgKOpiNQDQM7DVP8sVlXIHteb1vWsC1XQQAIqRlQnUBgHrMbFb7VWtMh+LOx3krJfkQbvVq6w4g1NE3D9evXkc/nERufwkMSh9xs3d0+k4uCgJjzetZzQjzBs+NxZMIiVqtN5/ucjkoQeXM20VXhC7ya0SEImfYaK7dydd3xSxRAnXjav3oT5WIRt+8/RFTkHfI3qvZvSTFbmKzVyL6ogOmo6MS/FTzt34oVWfeoquK3/vtH8HM/8gMAgIm5/fjR//VbSGZyAIC7Ff886l4IccRVlWOrdYNalwSF69tk/OjeCFBKsdrQsFhqHfMEwFEfg/FBULVsV+z2sEiAU3EeNyoF39dWdOpE/kmMUtZNpoZaUhu2ZN25QZqICAN7S7JDFt0Ejko05fw8GxWRiESQSCRw4MABGIZhGkDn81hZWcHt27cRiUQcAphOp7GjAbeLTddNnQ0C4IwVH6hTig2rcumaG2XWZos23m7YI3w+YO8Eao0G7ly5DgB4+eWX+74r4Hm+jRQ8LbGGjW4+fGt1xTnhzVgXez9QSvGgLON2oeH77zGBw1w85Pj49aJBIsdhKiZBlCvYvHcV8dkjqIbM9jhLHCkAVQxjEwBqrYvcRl1FTAyWSRsUQcUaNvoTbbRg+NCnQlNzFM+ZkIBEwAHxer2O119/HaIoInvkJNYQccrSIZ7g4lgcq3XF9dkyIQGXxlu5xU+q/p+7raX7Joc7V1dycnXNCqDmuO8DZvu3yoeB9BSQnoICAztKHRvL61Cv30A62X/7134EpRSPayrulVuD5CIBTmfCmAgLoJQizJtRUbWwjo1qA/mGAi4UcXUUfuHDP+r8vLWyhD/5P7+Gv/Geb+m6Bta6pN2TbncJXS9Qz29vFOFTDXOmboPpKkSt+LphhBk28k0NV/MtBXXEsl0himyOSvh87vWG2lLKRgTne3IRvqFX5oarojhE6zpIhU81KDRrTtzPe4/jOEfZC5gBBsViEYVCAfcePEQtNQmazDmPZ68RHAHOZ8JO1X+zoTnbfiLMY90i0nsVvj3CB8DHloX5/dbiHRzIZHDixImBLB+8Fb6nKdZw1tClpRuE5GgGxbXtmuNN58VMTMLZXAzbjHlnrwocpRQPHjzAgwcPcOLESdwjCSe8+AtmkpCZ6Leqz9DRg7KMB2UZSYl3xB+ZkDDwBa2saE6+sC1a6IX+bFmYlq7PpnGLNYLtE1tbW7h69SpmZmehju3DMkOIsyEBp7NR3MjXUWDm9Q4kQjidjTrbqaaaZAgAogKHbKh1SnBvyqc7xDcKMuDK1U2F0HC8/8z4JVacYLZ/48BEHGTioNn+rZfx8OZt8GrTpf5lW03er1LRzRZunonGssndck3F3XITsua1LuEBKdKmfhVEEU3r/opSCsHjAiByptgmK/EYCwmICtxQ4oLdxpuhpVto6rhedFddRyHMsLFWV3Gj2PLRTIqmgjrEc6jKnVNjOillO83HDYumNQoBmPtnNsDcdifoAda40dAA67MH8d4TRRHj4+PgkhmsJ5ugLKs0dFDOXC9HDZyKur0DWQX8ZERkCF/rJfYI3x4cENo6He87cACnZsYHfi0v4XuaYg1nDR1m3yqK1iIDzTrSUrrtuVXVnNezq08sOACns1Fn7o892LtZNyiKgoWFBVSrVbz44otoihE0Nsxw6/GIiIQkIAFgPGK2l69cvwktHEc9kmwjf2VFR1nRcb8kQyBAziJ/42GxL0sTF/GNB6u6jsp4WTUo1iyyJpDORs/O8ynF/fv38fDhQxw7fQYrJIYiQ/YOJkKYikr43GbF2dc4AM/kYm2k3ks0O33uN2tLtx9EBA5zAoe5WKv9axPAkl/71zJ/htX+LRUKuH3/AWKSiFQ2h1g6iwZa5O9awYzJ8q5a1inWGxqCgINJtHUK/OP3fxD/4V98B3RNw6kLl/Al7/47rseqBpBvGsg3DTyoqshIvDP/FxN2z6dyULi2y1MmfAaleFBRXEppwRJmDDq7xoJa9iBsLvVYiMe5TNghkt4cXRsVtRU9mBQ5xMXWY9iz3SjJ/BrrvRfQ+7ET2GtKp7njfquJukFxt+IxUYZ5bGgW2ROogVRxBXfvbeIeIchkMkhkc9ghZiUxzBPEhdZ69ip8e4SvDZVKBQ/vPwRycwCAaLy7CrcXvITPlazxFKp7gLvMzuYDs2shxS1QOu163kZdwfxWzTdiLiJweHY8jhRTEQqioi0Wi5ifn0cymXS8C1/brDj/7lfxlAhFVG8gFx/HLaulPBkVIWuGU5UDAI2ard4N6+TiZ/3ih06m070wKuNl1+xgvLPRM2C2OhYWFlCpVHDy2Rdwu2pAMcxtQEARLW0glj2Mz2xUnBN6mOfw7EQc6ZD7cDcodTKLCcy5RdeamZ/fAh3dvsC2fw8nJKhW+PpOU8NOU3d562l2+zczDWSmUQZFGQRQgc2VJ/jcJz+B7MQUXnzXX+/ZBXBZl1hiCEOuY+XRQ5w7dw7XC7LTen7HX/8qfO2X/1WI9RKOHDkCSkgrn7ipuxIgDApHFQyYs3rZUIsA9htOvxtgCTylT2+Gr24lZrDCjIzE45kRCDMA/yzjuaiAEyl3So7RYW5xpYsPnrulO5rt5fXemx4ymYW9ufc7ddU0w7FOifJmVbob/EyUEwLnsgyK8gSXcnFEZk/BME6gUqmY83/VJmBdssVaEVtUBGDO6u3N8O0RPgAtteXS0hIWFxcxdugY7Ek1fUg5KEv46qqOLdkSawi7L9awwfmQDd2gWLGqQhwAlLYdJ3RKKe4WG7hb8vcGm4yIOD8Wa5v383sfG5RSPHnyBHfu3HHFzzV1wyFoIY5g0ufk42fLMhWVMBcPocm0frcDWL+MRySMR0z7DPvku1ZXAplO+60ruA9f55buUiWYWKNSqeDKlSuIRKOYPfssFpgZsYjAYR9kPBYjuJFvWfnnwgIujsd9Zx23Gt2rzS4fvqfM+HabDHSzLumdoW2ubWP5Cf6fd78TjVoNoBRf/g/+Eb7l+34IhBqIEAPJkIS4JPS0LimoNazwAl7faTgXNJEjuJAJIx2KA5hwHuvkE8O08bGTP3aauss/rmmYnm52eyshcMiFzfSPtMQ/tdQKFm7Rxu5X+Kjla3fbI8w4kpBwcATCDMAcd1koyNhmVKNHO7y+HS3m+hulWG+0lLJTkfabMhujKvCVVcOxM0pLg3nvsWDX6CfaYKt7U+HO3nt+JsocTAPq1YbmkN+kyOEik05iG0Ank0msbdVhH0QpqmBlbQeYNM2ut7c28at/+Dl86Zd+Ker1elsqVr/4qZ/6KfzYj/0Y1tfXcf78efzET/wEXnjhBd/HfuQjH8HHPvYxXL9u6gGeffZZ/PAP/3DHx+8W9ggfzKrJ1atXUSgUcOnSJRjRJFatFqOfjUk/YJM2vFYsT+sO1263GrR1N7ZWVxxl5lRUxIahm+vkeFzZrjkqYtfrADiZieBQMuy7dvesYOvvtoq0UCjgueeecwZzAXdu7FzCPzfW3oZ+tiwh3hSLzDHWL5sW+fOzftmWNdwqWOa+VvXvcblFbPuNMhvIh4/5udRszQ6mJN5VMWWxvr6OhYUF7D94EPX0NBYZf72xsICTmSheX9fQZJRwh5JhnMxEOs7LLPWqNr/BHcFhWrqGTeg6JEYMal3C4tXf/S3IFtkDgN/7pZ/He7/v3yBqKKDlPDa3N1APS8hmsxCzWfDpNAhpv7huqATyxEGHEQVNzpA8+cQ1Jp+4oOju8Q3NQKVqqn85gjek/ctu8d2e4fMTZkQsYUaQ+dwgaOoGruRbWbusUtQPfoRvS9YdX8RxH6Xsbqh0XfOCIyg6dKtCUkqxZr8fpZju0M71M1FOiBwmwwLuMwQwK/E4n/U3GjeJrPnItMTh1Mwh5Js6XtsxyzflYgHve9/7sLW1hXg8josXL+Iv/uIv8Pzzz/umZHXDL//yL+M7v/M78dM//dN48cUX8eEPfxhf9mVfhsXFRUxMTLQ9/lOf+hS+/uu/HpcvX0Y4HMaP/uiP4l3vehdu3LiB2dnZvt57GOwRPpgxVIQQXL58GaFQCAW5RXaGJXyCIEDX9bb22dxTaufa4AmBQanzediL/YFkGJuEoKxouLEtO9FeLMI8h4vjMcdbzw9+Ld1KpYL5+XmEw2Fn+9poizHrsE04joOqqj1bxqz1yzHL+mW70cr9tf3nANPPaanadM2wSRwBh+AXo75Uui5bltZzelmxGIaBu3fvYmlpCSeeOYfHRhhlZl7vSMpUp312owKFmhcTjgDncjHMdtnHZM3ApkXqwzzxrTa/mVu61CJ0DqlzyJzh/H1QsNYl3kzXEE+s+K0m0uMTzndJCEF6bAwUBDU+DGRmgMwMFBjYblax9mgZevU60skkcrmcGf0WjeJOWcWyJjgbeyzE42ymv+QM+/3tzOsDcfP4KDIG1d3av7YNiJ3/O0rlOwvXobKLLV0/YcaMJcwYVXxbTTXwer7hvIdAgPPZsEv05IXfDB9b/Zr1IUMuH74RbC+drSiSwb33vK9pw1vhy7OV52oRkZk517/7mSgTmKbiImfGENqYCJvHRqft4OdjyK7t9KlTWFxcxK1bt/CN3/iNyOfz+Kqv+irIsowv/uIvxjvf+U582Zd9GU6ePNnzM/+7f/fv8N73vhff9E3fBAD46Z/+afzWb/0Wfu7nfg7f8z3f0/b4X/iFX3D9/tGPfhS/+qu/ik9+8pN4z3ve0/P9RoU9wgcgHA7j/Pnzzu9uH77hXtuuTm0wYo3JpyTWcK3D+kgGpagoupO0EBc5ZEICaDKH1/KKr53KeETEhbFYzzkgrzhkZWUFN2/exMGDB3H06NG2EzybG5sLC4h1EFk4LV3mb0F4lshxmI5JmI5JoJSiqtrtXwV5WWv7rIpB8efrFUgcwZgt/oiIHS+AfUWr+cSUsbODPAFmPARNURRcvXoVsizj+KUXcLuqQzVairNzuRhkneKzG9VWC0RT8Mr+sa6RcICnstqh2vxGEz7Kiygqum/bVdbpwGuyrUvCDJFjf+92YW1Y82Al1cA7vuLduP6ZP8cf/dqvIJ0bxw/8x58BT9zVbRkcEEoC00lwABpUxUqthHs3boHm5mBEWzPCnZIzBgFHCLIhAVmn/UuRVzTsyO3tX8XT/o0LjPlzaHTt390Wbey2MMNGoaljPt9qv4d5govZMOI9RGLeGT5WKWvPXLY9h9loo9haW3LLsmQyLIyEAHezZWGTPLjyDgjZ5/zuZ6Ic5QnOpEPYbuousjcbFXAq1bkrZhJZy3uPmJ/Nuzb7+nTq1ClMTEzg67/+6/He974X165dwx/8wR/gE5/4BK5du4af/dmf7fp5FUXBa6+9hu/93u9tfTaOwzvf+U58+tOf7vpcG/V6HaqqIpvNBnr8qLBH+NDdlmXYCp89E/ek0mobBrXdGCXMz0ShU2Cp2lrLXDyEW4UGdCbUm8XxdARHU/4tXC/Yg71YKiH/+DYuXLiA8XF/lXNQKxLfaLU+L/eEECQkHgmJx+FU2DScllVc2az6Er/VmoJVq5JmW79MRESkGeuXvqLVfNrR7OzgdExytXNKpRKuXLmCZCqFyTOXsMBkasYEDhfG4nhYkZ01AkCKpzBWHiB5dKrrWoKaPLsI34gZH6UUqgGHvNnVOTbX1Th6AZ/b9vd97AaRwE3mPJ50g6odNxoabhZb/moCz+N7P/RhfOu/+XFwHIdXJqII8wQlxXDEH6xQwABQIyIQHzP/a20MkI3HKGh13LesX1KpFHh+NK1HAJB4gqmIiKmI3f6lyFtrzHvav2bmtYHHNRUcgIxV+cuFeMSHaP96b45GSfjqVmIG2xJMSxyeSfdujfeDjYaG6wXZOWckBA4XcuFA4g9vS5dVys5E/ZWyo27puu1fRnP577RG1aDYtEiYQABSLzv/tt5QcavYdFkjzUVFHEuIuFNRXEKWQ3ERR3rcCG3Lui+RdVcf21W6HMfhwoULuHDhAr7ru74r0Ofd3t6GruuYnJx0/X1ychK3b98O9Brf/d3fjZmZGbzzne8M9PhRYY/w+cBF+EYg2qCi5ESHRQQOY13aorsF+zPpBm3l38JU4hZ8YmpCHMGF8TjG+pjxcB3smo4vuHy5Y0C1Nzd2sosVyW5Eq/Gc2eK2T9wTERETURFbDRU7DdV1InJbvxDkIgImIiJ0Thhohs++8HVqZzuV0SNHUIqN4y5D9iYjIo5lwri6VUOFsco5kgojp9Vx2/CPHGLBVlbHwkJn+xrX+bX/Da4a3hxXk9jZbdhBu668rXRlxBBh5vdRte1s6JTiTqnpZHMC5jzYuUwYj2sqymrrIs4RgkyIRybE4yjMmwebWO3I7sqaA0JApw5CgY5tuYbVh0+gV0vIpFKO918sFhsZQTLbvwRxUcJ+T/s370NS7fbvXbTavzYB7Kf9uxsVvqchzLDf53FNxV2m6pSzbFeC7m/sqEgQpSyl7ir2sC1d2eO9lxnRLGOnpI2NRquLkhMoyjwH1TAVzaxNkcSZVb1siMdCQcam3DqHnUhK2B/ANYFt504zRFb3qfABrSzdNwIf/OAH8Uu/9Ev41Kc+NdJIxyDYI3wW2PYcewD3Vux1B8/zoKnWEOfTFGuwcFq6AAxmWMKP7GXDAi6OxftuO29vbQEwT1zJVLoj2QPMlqJ9MpjrkRvrW+EbQcmJJVyHkmGMRUQcSIRhUIpCszX7V3ZZv9CW9Ut0AqKhQc/XMB4RkQ11tn5xqXQBVBXd8UCMizwyIZM83r59G2trazh5/iLuqwJqjHjmeDqClMTjM+utaDueAOfH4piOSdjZaQRqMXuTXjqhV0tXN7zzc25xhDbgV8QRIESARrmIfRPj7lxXgTOrBU/pGKppBq7lW3mogDn3dDplzYPV2sVNLCSuVVlbqiq4Xe4cidYAD4Rb7d86VdGolXD/2nUIhubK/pWkYNZBQcC2fwGm/etDUodp/46a8PmRh1ELMwCTeC2W3Z5wM1aLsR8Sxlb4gihlvYfPsPcxay6xxnDeeyw6tXRZEpblNJSiSXx6s+7anybDAk6mQ+AAXNmRkVdsi6nuAhgWbSbSzHfvV+GjlKJeryMej/f1OW2MjY2B53lsbGy4/r6xsYGpqe7dlR//8R/HBz/4QfzBH/wBzp07N9D7D4M9wueDbtmzfYMQ0LTZvnkjxBo2/E7EfsWGo6kwjqU7Kzv9YBgG7ty5g6XlZeDoJfNvXR7fJtbo0eK21bCjrPB5EyZyYbefYC5sevedzKCr9YvKCXhYbuJhuQmOALlQa/Yvxli/eFu6Tzwt1Wazifn5eRiGgaOXXsDNsgrNMgAXCMGFsSgqqoHPbVad58UEDs9OJJwYtiAzhWxlVexRWWX7uOsNDesNzVWt88tTDgICtM/QMSIJiSNoNpv4i5t3cOLY7BtmILxaV12VI44AJ5IhzHZov3WCQSnulBQsMRfAsRCPM+kQqpqB5WIVWw0VhtS6QfK2fwkoSloD+a08mrfvIBmLOOQvlUoNlALUCd72b12jTou6oOiuqom3/ZuWeOTC/u1f9645HOErNnUseIUZEdP7bpQVXt2guF50V50OJyQcHqB6yBI+P4FB2+M9h9cwPnxmJZStgo2uy+Qn2mC992ICwZZKIE8ddj6UQICTqRCmIgJUA3gt33Aqy96otF7oZiLdySNwGONlSZLw7LPP4pOf/CTe/e53AzC/209+8pP49m//9o7P+9CHPoQPfOAD+N3f/V0899xzA733sNgjfD5w2ZgMKdrYqKuAYF5U3wixho1e50BiaDgSojiR6W+IVJZlzM/PQ9M0XH75ZfzxlikG6FaBKzQ15+42GxJ6DjvvRoUvaMIE0G79UlJ0bDVUPMmXIRPBYXMGBbZk1fRaLJhtR5v8ucmqgdVay3srrtXx6devIpvLQZo7guul1toSIo/zYzHcKzWwzlwkJiMizo/HXJ6BQQjfSq0lzJmNSWhqBurWfw1Nt/5voK7pjsgIAB5Vu1eyWBCYOb7eHFeb2IV8vOjaXuMNTInQrMoRG9EUEzicy4R67qteqAbFtYKMPFNJPxATcSxpziRleQ4Gr6Gx8QAXn3veaZ/uNHX3jQUIVCEK5KJAbg5N6NiSq1i+/whGtYxsJu0QwGg0OtL2b0wkiLnav4bTpva2f/OKORNot39Z8+dRVPgMSvGwouCBR5hxKh3C1Ih9TRWdYj7fcIgLAXA6HepI0HrBVul2Ehh40Ub4hvhKvZYl0RFeh/wqfGvMuUo1KGpG6zNmJR5nLNPrhmaqnetaiwhezEWQDlih7dUaN3wqfMDwSRvf+Z3fiW/4hm/Ac889hxdeeAEf/vCHUavVHNXue97zHszOzuJHfuRHAAA/+qM/iu///u/HL/7iL+LgwYNYX18HAMTj8YErjYNgj/BZ8F4sBUKgMDYmg8It1ni6/fqgSIcEkOWHiM90L0d7sb29jWvXrmF8fBynT58Gz/Pgts2KSLf5LFfaSAABi0342PPdMBW+YSxyCCFIhwQztWJrGY2mgvFDx3ytXxq6gSfVJp5Um661F5mLeQIqrr5+DUeOHcd2OINlZl5vOirhSCqM+e2aK9quk5DGuw+b1iVGi8SpOh4yr//IMqUeBL2sS0ZhIWF/hqdJ/iqqjmsF2bkAAWb77uQAWas1zcD8TsNJziAwicmsD2EghHT31Wvqrqq52f5NATMpcABqhoJ6rYR7T65BhOFq//brMdYNZvvXnOGzZxTZhBK24qYY1KkMA6aYxgYlvUm/F6xC2sZuCDMAUwTy+k7DSVzhrapTLmDVyQ+2SjeoUtYrTBuG8K2w9i8jrO4B7RU+LwlzYqWpgROpMPbFzOpoVTW3sd3iDXEEl3K91c4sKkxrPCW2t8bZgo1dfbRbusMQvq/7uq/D1tYWvv/7vx/r6+u4cOECPvGJTzhCjidPnriq7v/5P/9nKIqCr/mar3G9zg/8wA/g/e9//8Dr6Bd7hK8DHFXrEMyiruqOWCNEaOAS9aiRl1X8/Ed/Br/5sY8ilRvDP/nBH8P+YycAtMx5X1+hgQUIbJbrqVOnMDfX8lbiCIFOaccKnKIbTm6syBFM9ciNBUaj0mWx6bHIGdR3jBACGLrH+kV3yB9r/cKutsjMBNYKeZy48CweNjnUGZPYU5kIogKHV9crzhypQAgujMecNiylFE2dOpW5gkzRzM3hM+tlh+QNY10CwCGmB+IichIfyLrkrQjHD6zUmi3lCXAqFWyOCHDPPOabGq7mZSY5AzifiSATMKTe66unU4oiU/1jZwoNADVOAhLjQGIcHKEoKQ3kN3cg37qNZCy6e+1fjmAyImAyIpgXUt1q/8rt7V+V+ZnuP4nXd2RTABLmkeih/l2z2uv29iQwW6uHRijMsFFUTNsVm1eGOIKLuTASfVZ3vbBbukGVsu0t3cGgU4oNi3TzBJgY8XXIax2z2tDaxElh6Ijkl7F/9gwAaxvvNJx9woxKi/RN3FnbF7/Kq98MX7PZhK7rQ1fWvv3bv71jC/dTn/qU6/dHjx4N9V6jwh7h6wCeI4A+nGiDndMaE55edqQNSikeVZr4ld/+fXz0h74PALC5/AQ//I//IT7yh5/FhfE4pmImefBm/naCoii4du0a6vU6XnzxRSSTSde/t/z+/J/vbSkGqZrYhM/r8zcovPNzg8JrvGxavwhISAIOpyLQDYod2SR/G3UVDZ/5AC0ziRs1wJ56rGxv4rP/67/jNxQVL331P8TEnOlbFeY5zMQkbDZUPK40UddMf7q27ZDMOTcZ3cATICbyiAocIoL5f/ZnniO4vl3BY6t1Nh4SApOVUeBpHiumkbJ7TishcjiXCfdsffnthks1FYulls9hTOBwsUtyRhChDU8IcmHBqTDZg+p5n/avQgkU0W7/7mu1f+89Aq2XkUmnW+bPkcho278CQUyQsD9mVtI7WdSAcE77FxXz5o81f7ZtTvza6xGe4JlMOHDbrx9sNjQsFGXnuIoLHC4GtF3pBUopDF50BAaRHkrZ9pbuYN8TW1GcGJH3Hgt7nRyA5bqpmGZxOC5CLBVQpObn3pY1XC20tnFC5HApG+4779mg1Blz4eBvIu2n0q3XzejJYSp8b1XsEb4OsHcOnQ7WVjIoxbLdLqMUWdL7IjxK6AbFwk4NKzUFyw/uttZlGNhaXcaLY2FkYq3qWhBPuWKxiPn5eaRSKbz88su+rSK7MupX4aOUuuO8AvoR2sSK/Q4GneFraLoTG2fP2A2KXtFqPEcwEZUwEZVwIKHjj1dLXV9PVZr47q//KmytLAME+PVf+SX8xCf+DLFEErJu4EHZP9vYDwKBQ94iAocQz+FusQEDAA/gnfsyPU/8xMcs+mljmHi1ICgpZguXbUXui4k4npT6vsBSapITVs05aHJGL4R4DjNRDjNW+7eqGY6pckHRXd+X0/6dTYEHRd1QUKuWcPfxPEIETvUvk8mMvP3LWtQs5BtYt0m1pjizzYBJutn2b0zgEBcICoreagnCHMo/OWJhho0nNQWLpZaKOmPFeHnjzgaFYRioiy2SMR3tXp0cVUvXXVEcvSWYXUWjQBvZey4XRiYk4HHBzGlfb6i4XmjdDHWLSuuFLVl3KoQTPrF07NqAVoWvVqsBwBtmy/JGYo/wWWgzX+ZYcuEfCt0NG3W1NZug1MCJT0+sUVd1vLZVdexEzr70DgiSBEPXQSnF5VfegUzcvbOzmb9eUErx+PFj3L17F8eOHcOBAwc6nqjsi6Tf7GOxqTnecZmQWQkLglH68C151MHDVDf6iVYLQplWHz7AxtJj5/fSzjYe3LiGsy+9o/29CVwVuYjAgdNU3LmxgL/yyssQPcKIJ5VWq3I2HuyC6X7EG0X5dge2r9q9ciunUyDAmXQYE/2kMjCb5UapiSLDTlhxRi8Msx8SQpAQeSREHgcT5s1egYlVqzHtXx0EVS4EJCeA5AR4UBTVOrbXt9G8eQupeMwhgMlkcqTtX/YzCst38MILL7TMn5vu9m9NM1Bj7pEJzGit/TGx73NxL1BKcbes4DFD1KcjAk6n+7Nd6QXdMFAVW+fdmR772SgqfKz3nllRHP11yFbre88Qc1EBGcvqR9d11MNJrBZa59+JMI9nMuGBk1xcquMO27JThS8SiYx0336rYI/wdYDA7IQapeD7lMSzYo1oswI9/HSUOFsNFVe2qi7LjNnDR/GBX/g4/ujXfhmpbA7/+rvbHcV5nvetVmmahoWFBRSLRTz33HPIZDJd379bS/dJwGSNttcckUrXTJho3cEPa5ETNFpN0zTcvHEDf/7qFWw8eYzn/spfxf7jZl4jAXA6E4FKKWpT0xBDIWiKSUI4wmFy7oD7PWH6JJpG0ZIr+L5WM3CnUfVtjbDpKr1scFxvZuFp073dbOkqOsWNooxtRjmbEjmczQw3/G+TvW7iDD+MuorJcwRjYcGZGZZ1A/mmju2mGanIdlabIGiKMWAsBoztRxMaNhtVLN25D9qoIpvJOARw2PYv+yk5mFW8mCBhH9P+3WioWG1obaIvCmBD1rEhNyByprrfbgEP027VKcWNQhMbzBhEkGSHQSATARpnfidZie+5r41ihm/No2Ad5WeyfRBZv02zv2PC3v8ppdjhoyiKrWtgr6i0XlB0A9tyK5Yu12HchC082NemWq02UiX7Wwl7hK8D2tI2+hgXqTFijajAIWKogebjhgGlFPdLMhaL7VFUBMDRs+dx9Ox5AEDEZ3bBr6VbqVRw5coVRCIRvPLKK4HMXm1SRuFuhauG4cSACYRgOoBYw7u2YSt8rIp2IiIOrewL0gavVqu4cuUK/tvHfh6/8PMfA+E4/PJP/jh+5Jd/E6fOnsP5XAzLVoxbLJXG9/6n/4b/+sH3Q9c0/JN/8T6cOHLIMWgGzO26I2vYkTXcKjQQESzrl7CIaIdtUlE0FC1ykxD5wKa0/WYX7wZGTYbyTR3XC7JrqPygdYEfpIKieOYy+xVnPA2EPe3fitpS/xY97d86BCCSBubS4EFRMxTUqkXceXjFNLUdov1LPcSABUcIZN3AmofsJUTOSmxhLGoMM8Vhw2n/EuRCgqkelvjAamrVMG1XWKJ+MhXCXGx3kpBqTDs3SKyZd9/vt+tpqmUZv78R5gnvNDXcKDRdxxEPwL7KxQUOCZGzxhwUF9kbBaF2ee918cVkPTTtx7yRKRtvNPYIn4X2lm7r536tWbw5pY1CMEHEoNAMivntqun550E2JCDfdM8P+n0ejuOgKK3q1/LyMm7duoVDhw7hyJEjgQ9Or7DC/n21qjgkbTYeTKzBrs0wDBcBGUR/+iRgwkRQ9Jrh29jYwMLCAub27cNv/dZvAQCoYcAgBK//3m/i6//KZVzP11BjSi5/9Z1fivOvfBEA4EQ6gqPpCFTdwLZsJ38orotfQzPwpNLEk4pp/UL3ncDdYh0TEQlJiQchpC1ZI/CJ9i/RHTClFA+qKh5UWvu4xBE8kw4NbLWxXFNRYL67KE9wMRcZyOPsaVUbCCFISjySEo9DCfPc0Wr/ai47mlb7dxJITkIjBopKA9trW1Bu3kLSav/mcjkkEomeLTI2KIz9uH7CjLCVmJGWzCzyhk6dNRaauquqVNMoapqKJzUVBJb5syX+SIr+6t+GZuBKvuF403EEOJcJY3yXnBR0g6IhmSRDCKiU9V4x+r0hKamGYwmUCVBRDALdoLhbcaeO2OC5lg3KdFQABXDdUz09npRwIEBUWi+4vPe6zGHbnSA/D769Ct8eHLAt3X4yPw1GmEBgtg0fBFTADoKqouPzWxUXabDf+2wuhpVau8+an5m03dLVdR03b97E5uYmLl68iLGxsfYHdwHn2m5mK5xSOnA7F3DPytktg34rfLJmYNMixCGeYGIEJq2dWrqUUty9exePHz/GiWfOYgkRZCanUS4WYBgGDN3A8YP78fnNirNvCYTg3FgMPAE2G2aahv3KIs8x1i9RVFUdm1bqR5v1SzSJO0UZd4qy2eqIiNiot7KT52LBT7aE9fTrb9MMjVGejGXdwPVCEwXGDicr8XgmExrIksegFHfK7Re9IKreNxsEjmA8LFhEJ4SGxqp/NRexalLObP+Ox0DGD5jt33oFS4t3Abne1v71wm3fYX6/JUXHQkF2/O4AYMoSZthD+IQQRAWCqMBhX0yEQSnKqmFWupu6y5ePAigopnDFVP8CWclq/4Z5XPnsZ3Dt1iLSZ19EdtZUwEscwYXsaOPYvNiQNVBi7huTESHQDa/31NLvIeFO8xj+Ul9SdNwoyg5JBoCMyDk3PfbXQACMh3hcyTOG45RiUq/iQHx66HVU1JYtUVLkEO8yH2/vVm+WHN03GnuErwPYA1Lrg11s1FvRW3ayRlDLk36xXlMwv11tI6QxgcOliTh4QnBtx1QkSRxx1uU3/2ZX+F599VXwPI9XXnlloGBnv7ZrSdEdAUla4pEMKNZg1wbAaevqtH/Ct1xtKcPm4qMZxvYTbbC2NaeefQG3qwaaho5/9qGfwI//s/diY+UJvuDLvxKnv+Jrne8tKfK4NBFHTOQdBTHg/z2x1i9HUhFojPXLVl1x7ugBoGlQp40OmPv0g7KM8YiIdEjovQ3YGb63aEt3W9Zwvdh0zbQeGcK/TTUoFgqyMwjPQhxQTbDbSuR+EBE4zAkc5mJm+7fstH81lJRWXZ3Cav9GM0A0AwEUVV1BpVzA4oPXEBF4V/tXEDzHPAEeVBQ8qLREM0F9DzlCkJZ4pCUeR2B+J6z5c8Pb/pU1bMgafvunfg4/a9lTSeEIPvjLv4lTZ07jUrZ//7d+MYhS1nv897NC3WilefCkc5pH0HU8rKp4yHxXHIBjSQlTEQF/vGHanNj/lpF4XC82XVFpydI6MvHRBA/0sy11nwpfrVZ7W1qyAHuEz0FbS9dTqQoKv2QNnudd7dJhQSnFYrGB+6V2m46ZmISzuRgEjuB2vu78fSwiOHFefhXLWq2GnZ0dHDhwAMePHx9YwcRuN/uE1U9urh/chK+7sbMfTLEGU2EcUZ6xd4avXC7jypUriCcSmD37LK4xXmz7j53Af/ydP2l7jX3xEM5ko84NBrsXBvmEgpWHOxmVoCREfPJP/xwnn30R200dO7LqNr41KO6VZNwryRAIwVhEcKLfIkJ7deOt3PAwKMX9iuKKhAtxZptw0Pm6umZgnmkDEgBxgaCiDU/Y3oztJUIIUpI583k4IUEzqOP7t9PUXMRKA0GVDwGpKSA1BQ0GCkodWysbUG7cRCoRR2PyEMCZFebmxEHcZ9rrKZHDMwNWSDkAUYGAEAExgUNZNVBRTeLH7v+/8V//S2u9qoK/+I1fwTd80YdGZrvSCXXNcKrLEnSkAjo2DKPS3ZRbs5BBK4p+qGkGrhdkl4diQjTTTeIi50oWaj1HR9P6s0CAi9kIHm3UwCWHr6oZlDqtfwKzGtwJlNKOFT6/CvTbAXuErwPaRBsB4BVr2Cq5UVb4FN3A/HbNVQkCzJ3/TDbq5MIaDMkhAMYjkkP4WLJkGAYWFxexurqKWCyGkydPDrU+9ryiU7M6umq1lXkCzMSGJXzWuvu4xu7IGupWC2AsLCA6pGO+Dbalu7q6ihs3buDg4cOoJSddflRsddUGR8yWu1cpzA1RVSOEgKhN7ItLOJQWUFU0/PFq2fw3uAmkZpmW2salcZF3yF82ZF4g3kgfvmEIkF8E11iIx5lM2EkQ6Rf5poZrednx/RI54FwmgqWagoo23LH9ZqrwdYPAEUxEBMu2JoS6Zjit37xnrk4GB1mKAxNxkImDqCg1/Pj/+3/js3/0+5g7ehz/z7//L5iYNassh+MiDnURzRh2ooxuoKFZ/9cpGpr5f++x1QmJdAY7ayswDAOUUpyYHt91sge4c2UzRAu8b3upVD9LdVXBBhhfcZJnyk3nXEtgCi7Y78pv09tkT7Ki0hKiOS7E88Ofd7ebulOtnwj7e+/ZYLffXoXPxB7h6wD2RjPoDbzL4y3eGo4fFeErKxo+v1lFQ3OfCsI8wbMTCTPf1QLbWp6KSq5ZJbtiKcsy5ufnoes6jh07ho2NjaHX6LVOWa01nbus2dhghqn2dmxZs/RX4Ru2wthtXbqu49atW1hZWcGpcxfwUJdQZtqo++MSnlTd1V0OwCvTSd/WtrvC1x8RYLcTYKaa2DiejmAuHnJi37Zl1dXmrKo6qqqOh2UZHAFyYdEzw/fGkJJ+ydBGQ8PNouyK4DqWlLA/NrglxXLNjPWyVxITOFzImtWopdpAL/mXAnY6y1yAubpf+e//FX/62x83xTM3ruE//6vvwvs/+j9AVh9i02hCyY0hmspAiMbRpMRF7pr6YHsfARDiAAPmDde3/uCH8IF//A9R3N7C2edexD/91m8d1aboCEppK/6LUuT4YPGVgE9LN+Du29AMM8EEpvdeuk/vPVk3cLPYdI0tRK10E++co0EpittbkBt1TM7td46xCE/wLBOVpuv6SHzvWPI83WMu0S9HF8DQObpvZewRvg7ot6XrraixxGIUhG+l2sS1nVrbHdVkRMT5sRhEz/C5u7Ucaqu8bW9v4+rVq5icnMSpU6ewvb0dOEu3G9wqXeoiW/2KNWwQK2idVeoGrfApuuGIFiSr/Tkq6LqOZrOJnZ0dnHj2RdysaFAN83vmCXAqE/Vtu8dEruMcoztNpL/1sCdU7/44Fw8hLHDYlwhhXyIESimKiu4of4vMyd2gaKsgr9RUcCDIhvhdSTkYFjqluFtSsMRcECKW0nPQYXzDMuR9wogzclZyxqgrQ2/Glm4/8Jurs6t/W7KOzZVlEI4D1XUYuo6NpcegnAA6dwxVUFRBAA1AuV392Q0SRxDhCSJWxrPzf54DT4CFQtMhP4fPnMNH/uQKmvU69udSSCR2v61XUHRHVS80a5D62BfbffiC7SNrnnzZfvat9YaKW0W3t95c1Eye8WsL/8xP/zTe/33vAyjFC1/61/Bd//EjSIdFXMyGXUWGUVT4FINiy/Lek7p479nwS9kA9gjfHtBjhi/AlbdbRW0YwmdQilv5Oh5V2tW2pzIRHEqG29bubS3nwgJKjEIxXyhi5cENnDp1CnNzcwCCecoFAXtSKiu6875JiUcqNPju5jVfDmrLslx1J0wM6uruRbFYxPXr10EBTJy+iGtMCzcqcDicDGOx2HBV0Vpt1c5r6HeGzw+GYWCroaJpXWgmIqZ4yPU+hCATMp3wj6cjlpGp6lQAm55Bz7xiIK/ILtuLsTCPeI/Q+0HRz2vWNAMLeRkVpvI9GRZwKh0amJj5iTP2W5Fro/68b5WWbjcYlnWK3WaVdQN1zUBJMaAYFJf/2t/E7//yz4PjeBiGjr/yt76WeXaX7alrEKiOiMAhGZaQCIkI8xwiPIeIQDoez7Ju4LUd2VFz2scex3GIxOMjTdDoBra1KlTz4FKTgZ87SEvX673XKYHCC9tEeZ0hixJHcCYdckaTvKhWq/jBf/UvndmTz37yE7j76U/hn3zNV7Ydd6Oo8K031Jb3XqS36MwvZQMwCV8qlRpqLW9V7BG+DmCrGEEqfI89FTUW3WLLuqGpG3h9s9rmoxfiCC5NxJEN+89meH0ACSGuHb7WaODySy8hkUg4fxtV25k9zjeYKtGwQglbEdvPDF+bHcyIxBpLS0u4ffs2Zub24Yku4m659R7jYQEJicd1RjADmIbHDc2A1kNwMuwMn7PGPtvYEs9hJhbCTCxkmfPqWMzXsSm79z3W9uJepXWnbf4nQBpx7lUvMrRWV3Gr1Bob4ACcSIUw28WMtRf8xBm7acj7VgClFE2DtmboLGJnt16bPQ7Isy+9gg/84sdx5U//CPuOHsflL//KQO8rCjzCmgajsIX1nQ2UJRHZbBYkm0UkkwF8qkYVVceVnZa5tsiZx5IrEeIp8D3VoI4HnUAAvlYGxwW3JRmkpVtUDEdMEyTNA/A3UQ5yw/S4LLcVCfaF4PucUVT4XN57AWxm3Ckb7grfzMzMUGt5q2KP8HUAe93qZctSU3XseCpqrtcagEwVmhpe26y0VVrGQgIuTsR947MAfx9AAKhWyq3XGB93kT1ghBU+5sDasQgfT4CZERA+s8Lnblt2u8srNDXHnzAbEhAf0mfLntfb3NzEqQuXcFcmMJiv9VAihLKq40G5vRp7OBXGrXwdoN0rdy6hRJ+MzyY4DcunDzDnO8f7HNo2zXnNaC6b8O2LCQAl2PaoMxXDVM2ZbaQmkiKHsRCPXFhAUuR2rZKiWxWJVaYiERPMFm5iCFFOmziDAOeyYWSHqE6/FUAphUZNsis7lTq3OGKYOmSYIzhz6TmcuPgcAIrE9hIunDmJEEegUqDQ1LFtiT9cqRqUQOXDQGYGyMxAg4F8s4aNJ6tQr19HOpl0zJ/j8TjyTR1XC7JzAxDhCQ7GRdwqtc/R7jY2GppzYzodEbFj6H3dhAzS0l1tBPfe8zNRFoh5czMV6XzDZJuYryKMv/mN/z/8n//2MwCAU2fP48ve9S7/z2IYQ1X4qqqOinUuT4hcoGPc6FLh2/Phe5ujPWmDrfB1f653Tq3ttfokfE8qMq7v1NtOsMfTERxNtbdwWXh9AEM8waNHj3DnwUPg8HkAAPV5/qgqfC5bFuv/0zFp6JknP8JHKbp2g0Yp1mg0GpifnwcAHLv0Am6UVGgWIRMIwZFUGI8qsoug220kO0rudqHeWncHsF/NIPSbEII1uRU7NIznIPu0uMBbFS5TnbnT1LAt68gruuvEWlYNlFUDD6oqBALkQgJy4f4zT7vt4xXVNOtlDWBnogJOJkMD208AfuIMggvZ4MkZw+zhT2OGTzdoqyrHKl41swU7qLuMyAERnkOYJ6hrBqrMC4U44KwVNfcXm3VomjmHK2mysz9IxLQOmYwIoJSirlHHU8+7fzXAAaEEMJUAN3UYMlWxVivh0fWboJE4tPH9zo6bEjlcyEZwy2eO9mlU+FY9AoOtPklPuy1L98frBnXi5nqlefiZKGclHmcyoa7HKaUUi4zp+Dd89w/gHV/xbtSrFXzlF7+jo93JsC1dt+o4GG1xzfAxG29vhm8PbQgq2jAoxXK1vaLmeq2AZEqnFDd2aljyqDolAlycSGAsQKWGFWvMRgTMz8+jVCrh0oUL+EzZ/Bx+hbzRVfja/2b7EQ71up4ZPsDc9nyHy6yqG1izxBoC1192rxc7Ozu4evUqxicmIM4cwrUiU8FrNrB/PIM7xYZDFEI8wUxMwkOr0mdHyRGLAnabP2QvRAONdhGCtUZrX9s3RGWVdNi2pjqzFXpfVHRsy6Y/W5WZo9Noy/QWMPM17cSDjMQHIqJslZNSipW6hsVSay4zqFlvNwwjzhjF9N2oZvhGZV/iBUeAqEXoWFFERDD/L3AEJcXMKGaNv9vbgszNUIfvnhCCmEgQEyXsj7f2Lzv7t8Kofw0ANSIC8THzPxbVIoziKh4Us9iKTQIgEAgY9fbuMr6aZjhK5bjAIWnlyvZF+Dx7Vy/CtxHAe6+bifK+Hkp2g1JcLzYdUgmY39fRsxcAAJGw/7mGUgpK6cAt3XbvvWDHercZvr0K3x5cvmpBRRvrdaWjWMOGHVtGKe14QDU0HZ/frDqJFDYyEo9LE4m2oXs/1BmxRpgDFq98DrFoFJcvXwYvikC5YH6eDkkbvdYYBN6LeEI0lXvDwi9PV6dAp0N/pdbK7p2L9Zfda4NSikePHuHevXs4duIkNkNpPGHatTmJYKci40G5RbJzYQEXxuL4/GbF+ZtNuuwldLu+s22bgZpo0QRk65o4rOegi3x2eAxHCLIhwWl5yrqVzCC3R3NVNQNVzcDjmgqOmBUFs/onIMoT137n3QdVg+JW0Z3LmRA5nM2EERsiJaGTOONYsrMv3BsFSk3SZpM4Waeo6wZki9zJQ9iXhD0kzvk/TyBypGt772FFwX1PYsbJVAjTnrZgy88t+DmG3b+OAVB06vj+7TT1zrOD8TS0eAKbmgpqHVN8vQwtknTWsJvwxprZLgP9nFvbotV6vmf3BIpOJspn02HEephB6wbFVc9x0hKhmeh0irWLHYNW+HaaunONHQ/zgeeEu6l04/H4QGt5q2OP8HUAK9rQulyhg9iO8Dzv3OX4HfA7DRWvbVVdik4AOJoK41g6EvjCwwoU1M0VHJydxeHDh9syX/0In333Nexwrfeg92txD/S6NuFj3qBTpYwyc4zAYO1cTdNw/fp1FAoFnL70HO40COrMfMzBRAjrNQVIZJy/HU2FcTwdcamTU4w62V55tzrqsBU+IzXu/DxsG9utGA62mDDPYTbKYTba3ZvNoKaJ6nZTB6AgwhPkQgLGrOqfffxRSn3zVvdZitlhSNmbSZxhHyOa0blC19CNvq16bHSzLwnxZKDt6JdRnLRIuF8bnDI/DHpOkHiC6aiI6agIVTcwn5dRVP2PqAZ4gE2QCbeqOqurq9BXGk78Wyg0On9OSinW6q2KlK2U7XeOzZ093H2bNZg0jyhPXGkeQU2UO0ExKOZ3Gs7xy8Eksct1t6Crk2La7hwNSvjWXGKN4MfmXoWvHXuErwPYHaRTS7eXWMN5LYtAeecYKKV4WJZxq9BwPV4gwMXxOCb6aEMalGLZJjmU4tz+acxMtNochFaFA9EAAQAASURBVBBwxDyJ+F002DSLYQgf8fw8GxuN751D+JildSJEJUVHWR08u7der+P111+HKIo4fPEFLJSazj4gELNt/6TSaiuKHMGFsZjzfXlV0jbsE3a3Fh67/fptsCu6ASOWdtY0Ss/BQQoiXm82xaDINzXsyCbRY1uMDZ1iua5iua461i9GdgoP6jpWm63jQyDAmXTYSnsYHPmmjmuFhhP4/rTEGbZ9icyQuDwNo56Zw6fWq+jAXXpCIGir0AWxLxkUXoNrwCQQh7sQCMqQjWFvApu6gSt52WnxEgCn0yGEeGJVl93jBQDQJK3vlqbHUdEaKG7ncXPxDhLRiEP+UqnUUOdAtvI4FuYh8a3M7UFbur2etdrBe68fE2U/yLqB13daN0UCAS5kI7jnYxO2GxU+1aCOcEzkCMb6iEX0q/BRSvcqfHtoB0uQfOICAfQWa9hgCZ8omncomkFxdbvqRFvZSEo8npuI+2abdsOTQsU5yYyHBcxMtPsM8VbkWqeWrneNg6CotE48cZFvM4QeFJ1m+PzgFmv0Nz+4tbWFq1evYmZ2FpjYj+vMvF5C5BAReLcnYqOKlw9NIRE2yZVuUKxYM5hedXKQlq67wtcfy1qpKYD1Pc7FpaEv8u4K3/CQOIKpiIipiAhKKaqa4ZC/oqI772Fbv2BiP1aZTR3hCc5lwkgOOSKwUjOtXAYVZ3RDm30Jq3jtZF9CJHM2oQvZI4CrzWpW6Fo/P42IMMDcvxfLTawwVZcQR/BMJtSTLDPTmEMRvqpq4Eq+0TI0tkiInZGcs9ZxoyA7RIgn7oqPAYKKEAVyUSA3BxU6tuUqVh88gV4tIZNOOQQwFov1tV6/WLNBqlzsrtLt6zUriu0JFP2aKHtR00yyZ29nOyqNJwRFxfw8IoGjaO/0knZlc5DvfL3REqAF8d5joXfYfnuijT0AQFvrUyAECqW+Ld0gYg32dVkvvpqq43MbFdQ8d6AHEyGcykb7bq+sr6/j5k4DiJkk71DaXynFE0CFP1GyD8hhhRvbTNtz2AszC5vwuVSsPtfO9uzeYFUuSinu37+Phw8f4vjpM1jj49hhiN1kREBVNRy7E8CMTVu+fQuhI1PO39bqirO/eNXJQVq67hm+4GhrY4/Ic3CQtQQBIQQJkUdC5HEwYX5vecWc/duUNV+BQUOn+Mx2AynRFn8ISInBLySUUtwZMjnDti+x26x15hj+3HYDTZ0OpK4GpQgLHDNL5xZHhLrM0T0tlK3WOivMmAjzOJ0Otv3sZw1T4cs3NVzNtyqLYZ7gYjaCuGcGzaAUW1ZliAPwjoko1hsaFsuKswZ2D6uDB8IpYCYFHkCDKliplnD/6gJEqjvkL5vNQpI6n1PaKlLh1qgM+vzc7Hm62+YtMN57uRAPnhAsFOS+TJS9KCk6ruRbFfAIT3ApZ94U3WPmmGMi55C/bi3dQSuma/XgNjNt7+uq8LX+vkf49uAL3spt9RNtBBFruF7LUupu1BVc2aq67z5gtnCn+mx/GoaBxcVFLG9sgR48A8Bs64x1MGS2c2g72cwMahBto6q4VXSjrDrYhM8b3ebFINm9qqri2rVrqFarOPPci7hdNdBQWzM4MzEJ63XFeV2BAOfG4piMCFgBdd0kPOlCutiTfad5zkFn+EqKjorVxo7zQKLPNrYfhlYM9wGBIxgP8aiqhovsEes/lkSVVFMB2Y/1i2aJM7YDiDN0ylboWrYl9t862Zc0Oh1YFmz7Eq8oorS9ifLOFi6cP9/1+W8UKKV4XFVxzyPMOJEKYaaLX5vf69gYhPCt1VXcKLYqswmRa4vwsrEl607laSIiQOI51+MOx0UkJd60fvG0f3UAVSIBiXEgMQ6eUJTVBgpbedy4vdi1/dspDWKglq5nhq8TWFKUEDl8erPet4kyix2LVNu7c1zgcClnbmfqUcxGeA5F6+jsVeHrFzXVrXTu11/TPcNHnLU0Go29Gb49tIPnCKD7z/D1mxHL8Twe1jQsN6uuv8dEDi9MJPpWU9q+cJRSTJ8+j8d180K2r1tr2fp7p5lEW008KFjRCDDaqlArS7dd9edaQ59ijUqlgitXriAajeLA+edwtdiazZM4IB0SzVaphYTI49mJOGIi75zE7W1WVXQUrFSUuMgj42lxsac8Cv+T+KAzfGx1b0IczZZ/mvWkpiUAyDMCAFIv47mpFBKxqGnN0Yf1y1jYnB28f+8eHi6vQDj8DHSx1d4/kpCQljisNbSWKGJY+xLAVxTB2pf4oQHjqW7rfiDrBm54vpekyOGZAdTRToWvTycASikeWYTTxphVme20TVd8KkOs8IjnCMbCglPxknXDUf7uNDXXLGWTEjQ97d8duYqV+49g1MrIpNMOAVxpcG3vCwxY4WN+5jsQJo1J8yAAHlXbTZT7ETpsNDQsFGRnS6Ul08vQJot5JhvYm2XbySJL1/WBKnz9mEj7vi9zHNvXvlqtBgB7M3x78MvTNf+vU3dFJqhYw4ZqGGhOHsayZ851Li7hmWysb8uQra0tXLt2DZOTkzhx8iT+eM20ACHo3sqzP49B/StMw3jx6UyLm/3bqOCNVgPaVbplRXNn9/ZoKa+vr2NhYQEHDh5EMzODG+y8nsQDFK4W7r54CGeyUef7IoS4xgCe+ETasfC2o/2+dm8VMAg0g2LFamPD0JEdUbzZqGf4OmFb1nC92HSp1I8kJDy+cwfi9PPgiangzbHWL3Lr4tzJ+uX3fulj+C//+nsBSjG57wA++Cu/iWQmBwC4X3F7XQYBQbt9yUZDRcVawDsmoggNOAf4Rrdr/bBpCTNUZvsejIs4EkDZ6Qd2Hwr6eQ1KsVhquhShs1EBJ1OdDcVtayDA/L6y1nmg20xcmOcwE+UwExWtaEHD8f5j50sBpv07a7V/DQUr1SLurd2Bvu84ACACHSGqA2i1dO3zRVAEmeHbZLz32DUGMVH2YtmabbUxHjZJNduqXfNYv7CefKOs8HVSOvcDP5VuvW6a3++1dPfQBpaIGbS10wQVawBARdHxmY0y9EjrjoIAOJeLYq5PQQGlFPfu3cOjR49w+vRpzM7OYr2uOOkOE1Gxq1+fW/DgnmsAhmvpbtSUNluZQS0k/NCa4etc4fO2Uzt9L4Zh4O7du1haWsLJs+ewRCMoMGRtLCyg2NSdWTyOAM9kY74VQ7vyqFOKFes1OJhkvu0ztMWm+a+Pg3l3H3TzrdVa7WaxXgaXSAZ8ZnDsBuEzKMX9iuKqSoQ4Mx4tE+LxpMPzwjyH2RiH2VjL+mXbsn5hPcZ+/t/+sNOL3lx+gk/9+v/GV37TP+66pn7tS4qKjopmHjODkrZRGS+PCsMIM7qh9TGDVfh0g+Kapw1/NCHhYLy7QbDLxoNpObsIZ5eaqhktyCMp8TiUMNeRV3SrAqi50il0AFVOApIT5n8WtGoJf3rnCpKxGLLZLCKRSN/7h2uGr8O/e29cgpoos6CWGTP7WjMRsw3M7u9sNVEgpgKZ9RvsdJ85SMpGnlE650J8xyjRbvBT6dbrdfA8P1IbnrcS9ghfFwjszm6lOrCVrF5ijZVqE1e3a64TTYTn8MJkou9c12aziWvXrkGWZbz00ktOFq6LfPYY1HfFnvmkVAzT0vW2c+33GBVswid0EG2w6liOmOkWflAUBVevXoUsyzj17Au4VdXR1Ft3krmw4JhXA0BM4HBpIt7R2sWuPG66Iu0k3xNUECNj53E0+NwcawMj1QqgNNHl0cExSLUxKBqagYWC7PLmGwvxOJMOO8aqQS5YrPXLUZjGvBsNFQ+qalsbyft7mCNISByyEm8GzYvcyO1L3mooW7F1dYbUTIR5nEqHIQ05k9uPaEOxbFfKjO3KmXTv9iSl1GN6LDL/1npcP18zzxGMhwWMhwUAITS0Vvs339RcFVAbajwLcjwLBTq2GxXIy2vQDQNXr1512r/RaLRHskXrZ++NRk0zcI1RKgNAXCA4l4n0NFFm4Y1KA4AD1myrd21sNvBURLRcHzqv0fkcA4g2vDYzg6BTha/Xdv/LjD3C1wVtaRs8sBFArEEpxcJO3XUhBoAkVFyenei7hVsoFDA/P49MJoOLFy9CEMyvraHp2LJajhGew3iPyBn2JssvpWLQlq6rxc0TR8W3GxW+TrYsrDp2JipB9LmjLJVKuHLlCpKpFGbPPourxdasSogjkHjORfamoxLOjsW6DjvbLV020q7TTGcvhbHzOEtDGMTsuKJoztxgQuTB68pIyJmiKLh/7x6QngFgnii1KO/se8Ngs6HhBuPhRmBWJfb7VCX6/SxlVcf9qgrVoPiWf/UB/Id/8R0wdB0HT57Gl/ztv+t6rGxQyLKOLVlHiCNO7FsuJAwmOBriGvJGX4AopXhcU3GvzERuEeBEMoTZaHBhRrfXZ37p+no1zcCVnYYjghEIcD6gR2JJNZzzT0biXVY7/fjadUNE4DArmBVmalWYn1RVrDPnDsAkuHXwQCQNzKUBXUOD6FiuFnHv8TwkApf612uH5VqvtblME2UVd8qK6xySlThczAU36QfM8+eNYtOl5j2WlHCww82y30yd3xq96LfCpxoUm9aaRGK2lgcBW+Gz11ar1fq22fnLhD3Cx6Bths9FkKw5rR5iDUU38Op6xVFM2khWt7Ev3l/EFxvtdfz4cezfv9+1Rm+aRK+d2Fvha/v3gJm/XrDrmEuEcKdokp9Rz/Cpquqe4WNevpdYY3l5Gbdu3cKhI0dQTUzgVrFF0BIiB1mnzndGAJzORnEgwDblOM6KtDMX022mM2hsml3hC0KYXSbPiRDWMHw1rlKpmMbT6ZZxd6FQxJ/emkcqZfqT5XI5xOPxvk6cOjUza9lqQoQ3W7hBTGC7waAU98oKHjOv/SV/4904+9I7UNrZxsUzJ3EuF3PacttN3VUdaRoUqw3Nqiw0TeuXsICxEI9kH9Yvb0XIuoEbxSbyTOt0FLF1LKjnt07bs6jomGfsQEIcwcVcOLBC00+s4bzrgBW+biCEICXx0NFqhx6Oi1ANU+1ad5WZBFQgAMlJIDkJgVCUlTryGzuQb95CMh5zqX+9M3x+Jso2zmTC/XnUeaLSCIBT6RBmO1TT6prh2K/ErGxgoFVFI+he4euH8G00NEewMhUVB07TsbcfR1rX9rdzygawR/i6wt3SBao9xBoFWcVnNyquIXKJI3hhMo5Ht5eg68EvaqqqYmFhAeVyGc8//zzS6bTr3w1KOyY6dAJLlrrl6fYDdh12i9smfLtS4UM7aa241LGcSx1rGAZu376NtbU1nD5/EQ80EWVGdZuWeBQZBWKEN1u46YCzSoQQbCitD9ptdjCozYn9sF6bzxwvsNrYMFNN1j1ekv1iY2MD165dw8GDB5Ga2YfPbZlDztMzM9h3cAr5fB47Ozt4/PgxeJ53yJ9fhYJFzWrhsrY9vewigpKsuvXaZU97+EhCwmfoGFK5MQi8AIEjmIgImIgIpuO+TrEjm+SvoOiu/dW0flHwoGJWGbJW7FsuxHe0YBqUQ7yRM3ybsiXMYA77AzERR0ecJUw9v/h9txsNDdcLsnOxjwscLubCgYUHukEdEQFPzP2LhYtAjVAXregGtmXzHCJxhIkrM9u/O00da5UGihoFGxUkUwJZjAFjMZCx/VChYatewfKd+6ByDfrRS85JQ9ENfHqz7msJ1M2OyA+qQXHFE5V2NhvGRBfxoV82MNA6B3erY/Sr0l1jKomDiDWc97XWxhY6arXaQPOUf1mwR/i6gK3G6QY1s1MteMUaD0qNtoi0bEjAc5MJiBzpaz6uVCphfn4e8Xgcly9f9jX63GqoToViMtJdrOF8HrZF7XPiGKTCt8HMrk1FJUQE3jE13Y0ZPrdK14Sb+IZbsUKyjPn5eRiGgRPPvoAbZQ2qYcX8wDYNbX3eiYiI82Ox/gaECcGmYgowes10sqeYrubLTvum+1tv1FtCmamYOTdozxT2C0opHjx4gAcPHuDs2bOYmprCTqO1v1MAkUgEs7OzmJ2dhWEYKJVKDvm7efMmEokEcrkccrkcEomE8z2s1U31n73PcTA93IK0Cnt9Fm+aANselrv44hFCEBMIYnEJ++PmxaFoZfvuNHWXKbpK261fbPI3qn38aV+AdIPiTtmtfg1xBGcyIUcNPUq4qms+Fb7HVQV3yq39LSvxOJ/tbLvihw1GsToZEdq6KW6VcOCX7Yk1Jg1iJupOg4gIHOYEDuFGCfce38fJi885s38lpdUQpQBqEIBoBohmwIPi5uc/iw9/17ehUszjr//Db8Y/+M73gRACiTOrbAWr4taPZYkZlSY7+7c3pcQPrPce4CZhzjHdbRaxjwpfrUMlcRDYa9szXW5hj/AxaLdlaf2uGoavWMOgFK9tVl32HQBwPB3G0VTrTiIImaKUYnl5Gbdv38bhw4dx+PDhjheCfv3mvJ+nU9pGvxU+dnbNXgdHzIPtaczwsSIaVh1rzz1mcznE9h3FVaaFG+IJKIWr2nQiHcGRVLjvC68RTUKh5nMmehBvdu3d83SDzfB1Stbol/Bpmobr16+jWCzixRdfRDLZW+XLcRwymQwymQwAU1S0s7ODfD6PpaUlEEKQzubQzEyjwEyLxgSzhduviaoXfkrS9ui14NuBJwS5sOBU7WWrarPT1JBv6u3WL1XDpS4GTCGKOMJ0md1CxRJmsGrTcSsxY1hhRid4vwk2V9qbfjIdEXA63dl2pRNWXdYt7dVml/FzX6/cGaZIpD1KzQvDMMBzXCtbOiFBNSgK1ojBTlN3GXdrFPjQd3wzqsUCKKX49Y/8FE4/+yJeeOllqCv3UTj0DMBx4EGRk4KTKb+otF7HIuu9N+apcBs+pMr3swes8HmTNYa5EepU4dsjfHvwBbuj5Jm4J1us0dB0/MVa2VVJ4AnwwmQCWU/aBc/zUFX3BYKFpmm4efMmtre3cenSJeRyuY6PbWi6QzDDPIeJHmING+6Wrs+/92nLYs6umSe7iMA5JqYcMdXMo57ha6vw0fYql8gRPH78GHfu3MGRY8dRjGaxWGqRvZjAoa617qxDPMHF8ThyHdJJekGNZ52fexFvV4WvW0s3QIWP3fbseEG/Fb5Go4HXX38dgiC0VZPZ9fZ6xVAohJmZGczMzMAwDKwXy7hTB1TmFJPQGjgWERHj/aP/vOh0sjcJS9NVhZuKCDiVCpasEgRhnsNcjMOcbf2iGNhutlu/sPjMdgMR3jT0zYVM5W+Qmd2n1dKllOJJTcXdXRJmdH9v9y/EOkdcL8jYlFvnnMNxEYcT7QrRXqhrhpm/DCAqEKR8KkPstzYqXltRDccIPCVyHRWyflUukRkxAMzPsNM0j+u1SgOVQt71+O31VejhGHDknPM3Winiz+++jmwm41L/elFWdLyel51zJRuV1gte7z3X5wrY0g2Sz96tktgvKKW+Fb63c8oGsEf4uoI9FrbYDNVECBs1Ba9tVV0XwqTI46WpBESfliDP85Blue3vAFCtVjE/Pw9RFHH58mWEw939+ZaqrdZHELGGswZXS9dftNFPhY9tpe5nZtfsg/9pVPjYSudsVMTCwgJ2dnZw5uKzuNfkUWHuGGMC5yIJ2bCAi2PxQO1wP8iaAS1s+iuGeNJTJR3YlsX6f7ft553fHMRCJZ/PY35+HpOTkzh16lTbBSnozCELSilWGzoWZQGG9XIcgBkiw6hs4ubjPCilzsUpl8t19cRiPwulFCt1DYulVhoKR4BTqZDLb81v/cOAIwTpEI90qGX9Yldl2HB3wIxXW6qpWKqpIDCVorkwj7EQj5jwxok/mpYwgx34TwhmYoY3h3Y34K5WUxiEw2vbrTkyAvN7nI0NduPlmjGL+HvQudvKo/kegtqHdIpSZBEVOKgGxZOaAVGS8MqXfyX+/Hd+A4TjEInF8NwXv7PtOUYiAz55CXWtiVq5gDsPXkNY4J252kwmg7IOzHeISusFP+89Fg6p6rI9g7Z0C10qif3ClVKy19J1sEf4GHRr6dpEIcoTrNcUPPZYrhxMhHA629nfp1NLd21tDdevX8f+/ftx7NixngcGpdTTyguev9vJ0sT59z5aun5iDRt2BvFuz/A1dcMR0UR4grtXXwPPcTh28QUslBRo1NzePMx5TJbsHUmFcTzdn42BF8vVpsMq9sV7t6A4F4HqPl8GdFby0i5ekEErfE+ePMHi4iJOnDiB/fv3+6/D/a49X1MzKG4Wm84FAjAvLueyYcSEODA9ZqYYVCrY2dnB6uoqFhcXEbPMaXO5HFKplO8xoBoUN4vualBc4HAuEw7kOxbE4iYoJJ5gOipiOiqiqdeRV1oVnrLqnsvKKzryio67MGfkTPInIBviHbFKEDIwDLZkDTc8SSa7IczoBnbrGxRYEtNQLbLHE+BcJux0CPp+bW9lqMNM26grfAalWLeIJkfMucGOj+1BegzL/Pghk1f8f/3YT+L8O74I5fwO/s5X/22cPnIYGw0VG7L7OqJSApUPA+lpID0NgxgoNuvYWl5H8/EKjOnDADHfOyWa9i1BbYc25HbvPRuUUleluNtnD9LSZVvjnb7DoPDL0QX2Wrp7hK8L/ExYdcBF9jgAl8ZjmIx1b+d526W2enR1dRXnz5/HxMREl2e3sNlQIevmqWsiIiIiBJ8ZYu90dB9ex/M8ms12A+VO6+iU8NGq8O0C4WNoSJkRXKibK5hMpyFMH3TP63EEikGdXEWRI7gwFsNENDhR9gN1qaRpIJU0W1UYRrTBCna8c4Ns1JsfDMPArVu3sL6+jmeffRbZbLbjY+GykemOkmLOhbFzSPuiIo6lJNdxRAhBMplEMpnEoUOHoKqqo/y9ceMGdF1HJpNxjTQUrddmRyf2Weawb7RRMkvULuYiIDBTAuz2b5v1S11zLmy29YtKhF1JMtEpxd2SgiWm+iVxBM+kQz3jIEcNdpdUxIhzoyRZtivJIWY6vfmunRSro57h25J1x3R5Itzdu5FS2pHw1TQD1z0q87hAUIWAL/3qrwcA7E9ImIwIlnWUed4bD/GgMCtjLMFpUA4NKQ5MuvNiSaOC+v17uM1k/0Yi3ccrvOpcFp1IlRdBfPi8lcTxIfdPvxxdYM+WZY/wdYHfPFCT2csjPIeXpxOBSJcgCA7hazQamJ+fB6UUly9f7msHXOrhA9gN7qi44Sp83RI+7KpBF5Fk37CJDPuVOF6HlOLoRAZ5KYlNZl4vzBPXBTct8bg0Ee+LJHfCjqyhblUM48RANMAFa1S2LE+qnQU73QifoiiYn5+Hqqp4+eWXe+53QWb4/ObCBAKcToe7VjxsiKKIyclJTE5OglKKarWKnZ0dbGxsQFFVvL60ATU95Ww8gQBn0mFn7unNhq7WL03dRfRt6xeIaXCpBIyCjLFQd+uXoPCbc/QmmTxNuPYf67uMCQQXsxFEhvT66yXW8FvDKO4Tunn+eeGNhQT8TZQJgENxEeNhAZ/Zbrk+cHALRAhM37wQz8GgFEXFQL7HjCmNJICjF1DTmqiWCli8/wARUXDIXyaTcRmru733SJtiNkjWr/3Ze1X43JVEYegbuU5rq9frgYsrfxnx5jxrvllg6Pjkr/5PbK+u4KV3fQUOnDjl/NNUVMSl8eDGs3aFb2trC9euXcPU1BROnjzZlz+RrBnYcMQavWfG2tbgEm34E74goo1eCR+c05IcXbvKf4bP/H9KJFhCDLWGu5LBkr2DiRBOZaMja2GxM3RZ0lmMw4I9XfY0Xob/9pM1A5vWhcZvbrAT4bPNlJPJJC5duhQoMYP0YHyKQXHDk3Wasgx7B7mIE0KQSCSQSCQwvW8//uzhOtRoSzFMGhWk6nk0tSTqudybzk/LuxI/65eCZfvizWQ1OB4bDc3xkUsInJX6Yao6g+63lJozhHfLSmvOEcDxVAhzuyzM6AZWfQkAUarh+bHUYIkmDPpJZQgSAxYUsm4485BhniDbQ53tben6mShHeYJnLBNytnthrtesZLL5svZNAUcIsiEe2RCPI5TiVsmtXmfhbf/qxECxWcPW8jqUGzeQSiSc8YpNtG4m/eYig6RsAMEqfGsd4vAGhV+OLmC2dOPxuN9T3hbYI3wMvDv0+77rO/Gx//pz4Dgev/aRn8SHfvV3sf/YCZzNRrE/2V1Y4QXHcU5l78yZM5iZmel7fd5B/X5PWkF8+IJU+HolfLAFBIN2l+wHhd8Mn42KBhhozQNRCkdRLRDg3Fgc07HhWrgsFN1wPBmJoSNB/E+uXhAfsur7OE8rlf3IK7Wmc5qd67APeAnf+vo6FhYWcOjQIRw5ciTwRb8b3ys0zTZrk/kgB+MijiSGnwvbkTVcLzZhMGTvUFzEVDKBfF7F9vY27t27h1Ao5Pj+ZTKZvvM6R4F+itg8MRW8Y0wm605Tx5N8GXVOBCWti2JFM1CxrF94AmRDZuTbWIjvSKb9hBlxwSTgT0OY4QdKKe5VFJeFDaep2M/XIXLpoV9/vY9UBleFb8j3ZZWrfoIhL1jC5/WOBKzxh2Qricl7FuYIcdu/+JAig5oztOw849GEiPGw6IiMvAbjZvs3AUwmwE0egkJVbNTLeHTjFrSZo4AYAkCR4dsLAUFbur3mFxua4XgKRn0qiYPAL0cX2FPp7hG+Lvhfv/RLAADD0AGN4rOf/AROnzoFWTdQbGpISXygi2ez2cTdu3ehaRpeeeWVge4w2sQafbZzgdH48Jmzay2VsJ/RsFcc0k3BFRT22vLb29B1DnKtimgiCUKIc3IUOeIaTE+IZgs3PqTnmxfL1Vb1JKpUgXDAKm/Qlq73cc5MH+3aSgfcog1KKe7du4dHjx7h3LlzmJycDLROPzhCBGu4/AEzXC5ywDPpwYfubRiU4r6HHIiE4lw2YuWohhCPx7F//37ouo5CoYB8Po+7d+9ClmWk02lHnfhWGMy2TXnVzTLqjQZmjpxwYt9Yj0idmvNiW9awfpS3PAMZ65ctWcPNYtO50QGA/dac49MSZnjhl9UKAKJaBy+MSCXbT1vVJ1t1EJhK9P4qUpRSgOOxUJBd2yPEEZzxman0np8pulcydYPimqfafpqJSouLEg7EYbV/rSqzrKPCtPwNAFUiArGc+Z8FXm3itc9dQTQkOe3fdDoNg7Y24jAtXZfSuYPCul+4K3ytv++pdPfgAtsS27d/H+7dvQvDMGAYBiZm96GqGbhbknG3JCPEEYxHRUxEJIxFRN/2RD6fx9WrV5FIJCDL8sDl5K2GioaltBjvU6xhYxQ+fO2ikfa7Me/7DF+gN78XRVHwGx//Nfzrf/2DKBfyOHnpBfzLn/l5ROOJNrI3F5fwTDbWV3ZxELjFGkBMqYGGgp1AgszEAd7Wbwv5ZmtuMBcWOs4NUkqhaZoTzffSSy8hkUgEWqNrvR7i2dQNXC80kWfaTRmJxzOZUF/RTn5oWPFoJYbocPUyzuSiFtlzg+d5jI2NYWzMzPut1+uO+OPBgwcQRRHpsXEg0X8lvS+MaE6VIwSZEI+MY/1iWK1fM/2D3bfrOkXdsn7hYN7osJVWySIRwxLwYaAaFFfzDadyw4JQCkKGr+JUVcOZV4sLXE/hx6gqfCXVQN0qz6UlLpCXXQ0CtmNj0BlyM2l5R/pdN7wdgIpidKxk+kalZfznXM32r4BsSMCxpHlM550xA911w2BDF8PAsUvQiYGCXMXmkxUoC9cRG5sAcvud9+yEbi1dSqmrnTusOtd5T7bCx2zfPcK3h4742M//D/ydv/8PsL22ind99dfhy9/91ah5VHfLVQXLVQUEpq/bRMQkgFGB4NGjR7h//z5OnDiBTCaDV199deC1sIP6/Yo1bPSq8AVp6QYRjfR6n36hKApu374NwzDwsx/9WVRKRQDA4vzn8ds//7P42n/6fzsXRI4Az2RjA1VAg6DQ1FC1xCKZkACJ6oGFLiTgdmn31DN/X+pR3QNM0q4oCl599VVIkoSXX37ZN5ov0HqZy2JTN/DqVsN1QTickHA4Pvwd+UbDzHP1xqMtP3oEIXeq63NtRKNRRKNRzM3NQdd1lEolbOQLzr8XiiU8Km8gl8shHg8+e/s04DdzKfEcpqMcpqOiaWWjWqa8nkguA3CRPQ5ANsRBpyYRGHZGbhA0NANX8q34Lo4AR+IS7laszsCI5nrZ6t5sAKLg8uEb4v3d79v9dlY3KO5WFGxEWhUzgQAnUyFMd3mu94zCRkDOMERO1g1c2ZEd82eeABeyYd+bJD+EPPtZVTOwKWt4UGmfS65TDgglgakk+ClAoS3yurqyDG1ZdiqArJdstwpfQTEcZX+/mcDdsFfh88ce4euC82efwYf/zx8BMBWer8yknJSLrbqKbVl17iQozNmjHVnDrUIDvK6Cq2k4fvF5zGZTUJoydF0fSMTgHdQPmqzhBXtXOIhoQ9YMJ+Gjm9GwNw1jGJTLZVy5cgWRSAQ0NYatfAHUIliEEFRLJec9YgKHSxNxJKXd262XPMS7sB082aJT5c4Ldu+wT/yqbmCtbl4wRY5gsoOtjB1xNjc3h5MnTwbOsPTD0uPH+IFvfi/WHj/EF37lV+Pv/fPvAcdxCHHmcHm2S/5mEOiUYrHUHo921hpcXxnwdXmeN9u6qTSWN+oAgHAohPLOJh4/fuz8u93+DZIC8EaCEIKkxCMp8TiUkKDqBu6UFVcrzIYBYL2hY72hgwBISRxyIbP9mxR33/i5rOq4siM7NwYiR3AxGzb394r1oBHcBBqM9x6B6RHX+zmtnwc9KnSDOsIanph2LJ1QUnRcL8pONRAwZzHPpHtXxL2bqG5daOICh4Q14+YXlTaMxQ0hBAmRd6l8bcPwnabukErANIbRCfPZM5OoaTLK+Txu373nav9qmtbxPOSq7o1Qee83X0gp3SN8b/QC3mxgW7qEEHDEPFHYO1BE4HEgweNAIgzdoMg3VWzWVWw2VKfdBgA6L0JPjuFG1cDtWgHZEA8jNY66oiEW6u8Cs1RtDeoPItaw4RVTtP17jwpf0HWwXnnDxKutrq7ixo0bOHT4MKrxMRgNHe/+ln+Kj/zg+wAAohTCl3z13wUATEclnB2L7WpFQzUo1iyxhkAIpqMSioT0UeFr/RwkWg1onfhXai3rhtmY1B4MTymWlpawvb2NXC6H06dPB1pTN3zLN38Tbr72Ggxdx6995Ccxe/go/tbX/V2cS4cRGtJKo6rquOaxDZmMCDg9wng0FuFIGOfOnYNhGCiVStjZ2cHjx49x8+ZNJBIJR/yRSCQGJkXDrDroeyqWMGPbo+4cDwuoaobL+oUCKCoGioqC+xVz1tImf6OwfvFiW9ZwrdBKdIjyBBet+K4Cs16Kzp50gd+LaT+Oh/lAVjOsMn5Q3rspa04lejIs+O6rfibKoAbGtBouTE8F+q47dQDsfFkvsQ5bUWmxIY9LwF3BPJyQkLIUyLKn/cuOGeggKAsRIDsLZGehQ0ehWcPG42UYlOLWrVsYHx9HNpt1Kuy6x3uvG3nuF91Uum91wvfo0SMcOnSo7e9f9EVfhE996lNdn7tH+HpAIAQKpdD8WqAcwXhEwnhEwinDwL2lFTzYzCM0NoUGEZ2D3R66xvQhfGqtgqTIW7N/IjKh7gqv9mSNwVuVrgqfD+PoJtrwzq51a5kOW+EzDAOLi4tYWVnB6XMX8NgIoWDdVf+1v/eNOHTqGaw+eoBnXryMiZk5nMpGcbCPiLlBsVptOhez2bhJuvrJrnWpb7s8h3OpdGlPwY5hGLh58yY2NzcxMTHR00w1CEpNDbcX78CwKr4cz2P14X0UFQOvbjcwFuIxFnYnRgSBE49Wbjr7Bme1uGY8asdeJtKDgOM4ZDIZZDIZAK2KaD6fx9LSEgghrti3Qdvh/SDoZ9y2EjPYtrrXgFo3KAqKv/WLapiqVls0kBA5i/wJSEvcUOKOlZqKW6XWDWFK5HAhG3GImMuGaAQt3dUBbDxGUeHrpZT1M1FOihxCWyvIxMKBP7ffeZPArILlm1pbVNrFXHgk7dBu3nthnsNMlMOM1f59WFVw36f1CwB18Gb7dzoJTGhQiY61ehkPr10Hb2jIZrMgmQnoMM9VkxFhpPPW3Xz43uoq3X379mFtbc35fX19He985zvxhV/4hT2fu0f4esCOCfMjSDY0TcONGzeQz+fxwvnzyGazUA0D2w0Nmw0Fm3XVdZIuqzrKJR33SzJEzmyNTkREjEdESJ6D1ivWCGLw2/GzMC/dKUu3U0t3W9bQ0Jh1dBGNDDPD12w2HXPgM8+/hBtlFU3dOslSChCCExefw4mLz4EAeHk6iUzAeZVh4bXFAUxSMkiFr2tL11PhKyk6ytbcYFriXS1re3vpuo6XX34Zjx49GpokrdUUXN2u4qV3fQX+4H/9IjieAzUMPGtleSoGxWpDw2pDc9qGYyEBuTCPRJe8WNWguOUTvbZbtiFBLh+hUAgzMzOYmZmBYRhO7Nvy8jJu3bqFBONLlkwmh65MDQKdUtwrK3hSc/tM+gkzeM7f+sW25WBbXRXVQEV1W7+MWRXAoD6KlFI8qCh4wCirJ8I8nsmEPTFcricNRfgU3cC2pViWOIJcwNECl2hjgPdvaIYjWIrwBGmptY26mSgfSki4sa6A44ITDcPnDDEW5lFUTHGTfcZJSyaxHlVnYy1AJjFgbj+JORZOJiVErNbvTlN3Ve7BC6hCAOLjQHwcHKGoqg1UVeIo+vSddezoCaTT6ZHYK3Wa4Ws0Gm95Hz6e5zE1NQUAkGUZ7373u/Hyyy/j/e9/f8/n7hG+HuA5AuidW5PVahVXrlxBKBTC5cuXnSB4keMwHZMwHZNAKUVJ0fHp67cRm5xFxXXXTbFaU7BqtQozIUv4ERWREHm3WGOI6h7gJWLt/96twvek0kqw6FVldFX4+pAxFotFXLlyBelMBhMnzuJKQW5lNQIwPCefCE+eGtkrNTWUrJN9SuKRst43qFk1ELzy6Z3h61TdK5fLeP3115FOp3H27FnwPN/XeryglOJeScadounw/97v/2HsP3YCG8tP8KV//Svwri96BTuymQ1rr59tG96rmBfgsRBvmQa34qZKio5rnni0uaiI46nO8WijrNgG4cAcxyGVSiGVSuHw4cNQFMVR/i4sLIBS6sS+5XI5hEKhkUWidfqsVSsxg52fyllzYEFasrb1y1xMhEEpSorhxL51tX4RiEP+MiHe9zsyqEng2VnC/TERx5NSe6qE65fhCN9aQ3NebyYqBK5MskRs0Pe1MRNtkaFeJsqAf9JGkLWyCHEEVwut8/BYiMe5THhklTHTbqb1Gaf6sLkRXDcaLWPqrbqCrboCCK1qaJMSNIUW+SWgqBERNx4+gV5dQDqVcqrsgwqs/Gb4VFWFqqpvecLH4h/9o3+ESqWC3//93w90M7pH+DzoZCKs0/bUA3vG7MCBAzh69GjHDU4IQTokQCpu4PzRfQjFEthqqNhsKNhuqC4DzkJTQ6GpYbHYQIgnTpSbxJmZtUN9NubnTqINwzDaPmdTN7Bhi0Y4gske63CLQ4KtbWlpCbdv38aRY8dQiY3hJpOHS+CfPUtHkogZcH0d2tl9Vfg8rdqOj2M+lqZTrNbM9+YJMGNlNq+treH69es4fPgwDh8+7Hxfg7ZBNYPi2nbNEYYAgCCK+Ir3fAsAs/qzPyZhf8ydGLEta85AOeCt/jWRFAl4wqGg6ANFrw1XrRxu/5AkCVNTU5iamjKVslb1b21tDYuLi4hGo1BmjgJ8aKi38/uMZsVIw51S05WYcSwpYV9sMGU0a/1yDOZxvdNstX/ZRK66RvFEU/HEsn7JWHN/uZCA4sYq/uLVV0EnDyJ75KTznONJCQfi/i1wd4FvcMLHxosB/aUyODePA7y1+b7tnn9BTJSB3ubDXngJHwdg2WP2fDo9+Dy3HwoBM4ltsOd27zrCPIfZKIcMVOQX5vHsK19ozf9pKCruMgAFQSWcAmZSEAjQNBSsVYt4eO06BGpma9sE0C6o9IJfha9arQLAW36Gz8YP/dAP4Xd/93fx2c9+NrDt1h7h6wF3/qy587AB9OfPnw+czWe3TMMCh32JEPYlQjAoRV7WsNlQsVlXXKVwNrdXNYDPb1Yt25fBWruEEPDEPFA7iTaAdhn9MiPWmEv0Psl4jZe7Qdd13Lp1C5ubmzhz4RIeqAJKNcX1GO8r2J57o7B8CQLdoFixzKZZ0gWgrxm+oMbL7AzfZkNxLiYzsRB4Aty5cwdPnjzx3fcGIXwNTcfnN6uuOCf2ZsNccOtHNjHiRCqEumaYhsE+1b+SSmGHvQOmcOBwXBpa4fu0QQhBMplEMpnEoUOHoKoq8vk8FputDXN94TrGcsFC6btB0SluFN0mujGBw9lMCIkRmoiHPDNZZbXV/vVav9jE8PHiVbzv7/5NyI06QAi+44P/AV/yVV+DZzLdCby7pdtftYtFWTWcamdK5PoSKThivAHel7UPyVoVz6AmyvZ790f43Mcwe0vZqYo6LNxEujc1MHxIVdtjDAM8x5ldEUZl/hceiycbGgUqRAISE0BiArzV/i1t7+Dm7UUkYlGH/KVSqY7tX53tKFvbqV43Fft/GQjfr/7qr+IHf/AH8Tu/8zs4cuRI4OftEb4eEJiDSqMUzboZj0YICRRAz8JvRo4jBGMREWMREaezUdRU3SF/28ysE4U5z7fVUHEDQFzkMBGRTOFHOHhbgyMEOqUdK3yAm/B50x2CiEZ6qYFt2FFzAHDy2Rdxo6RAMbq3I0XCEL6eKxkN1uqKI9qZjkmueZl+CJaf3Yrv45gHrrtmanhcuXIF1WoVL730km9rol/CV5BVvLZZdbzceAIcT0dwq9BwPa5bRTIqcIgKEvZZ1b9iU8dyXcWm3P5dqgawWFawWFaQEjmTOIZ4JHwsQ95MXnleiKKIyclJLG030LSIcjKVxMbGBu7cuYNIJOLYvgSZS7I/qx0r102YsRsghDgX5cMJCapBnYrMTrNV+fm9X/55KMr/n70/D5MkPatD8fPFkvueWXt1dfU+vW+zdAuwZEsgIYEtLuaHuOaCdGVkjCWMZQNC1wZkCXMBgQHBRXAxNrLByMZYwLUtEMMmwWik6a7eqrt6re6uvSozKzMr19i+3x+x5BeRkZmRS81oRJ3nmWeqqjNjyYzljfO+5xzjekApPvNrn8AP/p//BxJdCnhnS7df9MvuAc1zrh9WjGX3YgKHlzarNv/DTibKQO8t3Z1yGV/+0z9HPJXB0XMXrb8fjvowOwTvSycUh2J2xINilr2GtWNN3Tz4Kgq1ju+Uj8eJhN960Mg3VBtbWqcEdSEEpEMg6X1QoCJX38Hqw8dQKyUkEwmrAAyHw9bn4qbSrVarCAQCr0kE4zBx69YtfNd3fRd++Id/GCdPnsT6+joAvSORSqU6vnev4HOgtaXLsC1bWdybv4mJiYm+PM46iSJMhEUeB0QeEZFHtq4bV+nUOrXNP5VlDWW5jkelOgRiCD9CuvCj02wPTwhkdC74VFW1vMlydXu6Q9gDw+CF4cvlcrh+/TpGRkcRnD6Ia8y8ni6TaSIdEJAzLkZjfg5FlXRc9rDRqeD1EkdnvbbFUNkd7BG4Y4g1wjzBnblXEPD7cenSpbbq0V4KvuVyAzezlWZMnMDh2dEInjD7a22vpyXq256XVFuxxxOdoSormu0BoChrKMq6ZYg5fJ/280gHBPiMO8hALd1XpV5sbt/MzAwO7N8PRVGwvb2NXC6HhYUFyLJstaXS6TSCwaDrjNvdYsMmzBANxsjLzXfYEDmCsaCAsaBgsX93Cg0EwxGrYCMch9FkomuxB9gfGHplu0yolGLd8AHlCDDeo2+beSj1elgoGsVmven595j5jryYKAO9tXS3t7fxrm94E1afPgEA/P3v+wF8x/f/EI7H/ZgO745n5EZdsc7N8aDg6eHCS5auW8oGG0s3ERJsc6admGYKoAIeCCSAqQQEAtRVCavlAh4+vQ4RtOn9xzdbnCYBUalUXM+91xteeeUVVKtVfOxjH8PHPvYx6+97tixDAFs73b57F2dOnMDExER/y/KQZGGCFUmcSIUwHhKxI6uW5992o/mkq1CKtapkzV8lfDxGQzr7F3Pk/ZoHfzvRhnMmzWk07AWdItwopXj8+DEePHiAo8eeQT6YxF1mXg9o3kJFjuBsJow721Xr30Z9QKnefh+GjR1JtT7riMi3iET6Zfg6vcXtgtTYWMJMOo1jx451vHF42R5KKe5s17BYan7uqYCAiyMR8IRY7WsOzad4L7voFo+W9vM4lfDDx3PQqG4Zkq23WoZImm6kqw/GNxAXOTRiI6hoBOkhJTPsNswtFAQBIyMjGBkZscxec7kcstksHjx4AL/fbwk/EokEGuCxFUxDZgqJXoQZu42irFuN1FSKv/d/fi/mPv+neLxwG+FYHD/78Z/xtIxhqHS3PHjgdUKT4ettvRt1xWawb8KriTLQW5H7e5/5jFXsAcDv/eon8JEP/8iuFXtAvzY3zU/DK8OnUrtx9Vig9XrqZJq3Gaa5xtxQFArscD4gNgrERiEQih25isJmDl+4/nks3LqJo2cvIHJwHOfOnkWlUnndW7IAwLvf/W68+93v7uu9ewVfNzDFz+kzZzGRjPW9KJ7noSit7vhO1JVWkYTuti8g5hNwOBGEpGqG8ENv87ImmAVJRUGq4Z4h/Bgx4t5Ggs0MxnaqY1bl2VA1rBvzdL4O6Q4ty2jD8CmKglu3bmF7exunLjyL+3UOO455PRMJH4/zoxHUFQ0VMyOyXkYgHgVn5HBSDDYA7gVOKxa3tmNfxssdXtdyW9A0HBtLYXbftId1dC74ZE3D3FYFW8xT9kzUj5OpEDhCsFxuWO3r8ZBga6F1gls82uGYD/sZgQFHiGH827QMyTKtHPbhoChrQHwU9xRgcaOqK38d7F/Xz8LTqwZDtzqYEIJwOIxwOIyZmRmoqort7W3k83ncu38fNX8U2ugMYBQDBLowY6ZPYcYwoRmWK4uM5UoilcInfv9z2NjcQjSewIXZzi0kE/Z6r78Zvl5nzFq2oY8ZPvMzYNGPeMZrS7ehalhX7Psm+vyYCO+eH2Qn771OsHvdeWP4Nmv2or2bwljkCEaDgpULXDVshvJt279hfP6Lf4yf/xf/BBzPQ1NV/Go6jXK5jAMHDqDRaGBhYQHPPPNMX8fgL//yL+NnfuZnrPn9T3ziE3j++efbvv6//tf/in/1r/4VHj9+jCNHjuCnfuqn8Pa3v73n9Q4Lr/3j41cY2IMgl8thfaUZ8OQLDGZo65Xh8yKS8PEcpiJ+nB+J4C37Erg8HsWheKBlqLuh6nm/V7fK+OOn26gpejGnUfd2GbuNK+WmQnA64vc8Q+Q2w1epVPDFL34RjUYDRy88jxuVZrvSidmoH5cnYggJvK2d6isX9NaIxxnBQaFSihWj4OMATLsoEHsTbXhs6To+5oyf81Ts6e9tX/BVZBV/tVayij0C4FQqhNPpsLVtdpPvZh5mu61VKcWdQh03tpvFXpAneC4TxGyk82B5UOCwLyziXCqIN42HcSEdwP6w2DKILxvs361CA3+xXsGXtqp4uCOhKKmeP/tXp/nfHTzPI5PJYPbQEYSOnYM2PmsVe2jU4F+5i+rSQ2xtbXl6ONwtVBUNr2RrtmIvLnK4PBKCj+eRHBmFz++9CNHsFV/v8ZKGohjQUyWSvt7nsKyREY/rrigaXt6q2kZpogLBpZEQZroc2054aelWFQ1fztZw/uvfgQt/6+8AAHhBwD/+6M9A2MW5M3u8mfcitp3XHQvnfrPWNt3a4G4IGdeMs6kg3jgexnOZIA5GRMSZIvXz/+Mz+roN4uLEiRP47Gc/i2PHjqHRaODixYuYmZnBe9/7Xnz6059GNpv1tO5Pf/rT+OAHP4gf+7Efw9WrV3H27Fm89a1vxebmpuvr//qv/xrf8R3fgfe+972Ym5vDO9/5Trzzne/ErVu3et7vYWGP4XMBpRSPHj3Co0ePkD56GhvGcT1ITBjgbYbPmWjhxXuPIwSpgIhUQMQzSV11abZ+s3XZpppkn4j+bLmAsZAPoyEfUgF9boO1ZnnaId2h2/aYUCnF1tYWrl+/jsmpKQjj+3Ftu+76PoEAZzIR62mWzY8VOAJffUdvETDP6Bqltt+HCdYwezzsazHFBnq1ZWmi0zs0xzFyKOVNcm9uj1sRlK3JuLpVtphgkSO4MBJBhskgrcj6kzOgz9wl/bw1T+l25JdlvYXLesSNBQQcT7QfXm8Hlv07Cr09/MrdB/ClxlAB38L+FWUJj5i4sIxhGeIlYuu1Rq6h4Na2XZgRlSu4sC+NcpxHLpfD4uIi5ufnEYvFrPZvv55kvcC0PblbaqbKEOgRW7MRvUPAztr2tQ6t94LPKdbo53Owkl26vM7NRBkAUj4O59PBvkQf3Qq+HVnFVSMqTfT58OFf/Y/Ib6whGIkiHPF+/vcKp/feRA/MqReGj23pskV7kCdI+gbjmzhCkPDxSPh4HAKwUZVxq9DA2NQ+6z7GcTwOHDiAixcv4hu/8RuRzWbxJ3/yJ/irv/or/NEf/RF+8id/Eu95z3uQz+cRCAQ6ru/nfu7n8D3f8z14z3veAwD45Cc/if/xP/4HfuM3fgMf+tCHWl7/C7/wC3jb296GH/zBHwQAfPSjH8XnPvc5/NIv/RI++clPDrTv/WKv4HNAkiRcvXoV5XIZzz//PHLwY8OYIeuUtuEFXgo+ViSRCQh92a8EBR77Yzz2x/S831xdL/42a7KVlgEANZXi8U4Dj3ca4AmQCYpQY2nUZBVaQ7EsYlJ+AZEetoO91+e3t7H08DaeOXESG0IUG0X3Yi8q8rgwGrGtx5kfW+KI0Rppvm83lbpezKZ7ilbzYMtSLBbxdGUNiOt2Kz6OuNo8tF+HveCjlOLJTgO381XrRh0ReTw7GmkR4Di9BgkhzYKPdWgxioIFRzzasZgfU6HOUYFeERQ4BKpFzI4mkc5kUDBm/7IOF397XFgDMZGzYt+CX2HFn2YkZjyxCTOARCWHsCbBJ4xZQ+eArmLP5/PI5/N48uQJeJ63hB+pVMoSVg0LkqaztazgJsgTnGYMhIGmAKOXT9cerdZbS7fFA69HsYa5jCbD1/51bibKJk4lA3373nWa4cs3VFzP12wP44QQpMcnAexuG65X7z0WNtFGu9cwLd01h4/gsB5eFI3iXqmBFWP57/r+H8T608e4/crLeOb8RXzkIx8BoKt0w+EwAoEA3vzmN+PNb34zfvqnfxqFQqFrsSdJEq5cuYIf+ZEfsf7GcRze8pa34KWXXnJ9z0svvYQPfvCDtr+99a1vxWc+85kB9nYw7BV8DlSrVfA8jze84Q0QRRFF5qbvlqfbC7wUfCyrNhPtfBB6WidHdAFHSE/8eHljx1K8slCp/oSE1BTmqoBYL1v/tq+NmWrbdTIncrlSxZlnX8BCRUOl5p67OB3x4VQqbJvncObHzkT9uG0+tTFXl91S6lZl1bLFCQlc26KrF4bPmZHrhGnk7Tt8BuY3lAn0xmawBZ9GKeZzVVtay2hQxLmRSAsDp1GKZeN1BHoL3/qF2VRZo7hTbFiD14DOBp5J+nt6KPAKSqnOYPsFpBj2L9dQkXWZ/SvJGkqyhkdlGcKr1Pr3goqs4Wahbku3SBmClielVRCXYiAYDGJqagpTU1PQNA3FYtEq/lj2L5VKIRaLDXQDdbODmQwJOBbzt4gj+lG7Oh8YekGB9cDzeY99s62f+bkd+exmomwi4+cHEtC0m+HbrCm2qLQgT2zChE7bOwwMMhfZi2iDUoo1mzp3OA8rubqC28WGre0ejsXxf/3afwJg5EWndaFGO9FGIpHoup5sNgtVVTE2Nmb7+9jYGBYWFlzfs76+7vp600bltcBewedAMpnEuXPnrN95W3tysGXzPI9Go9XywkRD1bBeZUUSw32CJ4TYLlpfOxFFRdGwWdWFH+zFnhWB3M5Xka0ruu1LQITY5cJXqzZVtdH0KK6VFNfPjiPAqVTYtV3slh9r0fTMnXy3buTdxBom+mX4NMcN8N69e1haWsLZs+cwVxOsO2SqR0sOs+CTVA1XNstWixYADsYCeCbpbkuwVZMto+WxkG7to2madVOn0L+Tm4Za08R0SMDRuPf5zmHAGRdWsJS/qq29bEuwkVS8vGWIPwIC4i6+f7sBSilWjBYpG+3FCjO8HD8cxyGZTCKZTOLQoUNoNBpW7NvS0hIIIRY7mE6n29r2OOGW0ytywIl4wBqUb4teZtjYX3pk+NwSLnoF+wkTR6nq9hDj5whCAsG2IWbo1fOvZf0uDN9KVcbtQvM6k/bzkNTWh8fdKvj68d5jYV4GOLSfizQZvpKsWar8hI9DqI+inYWT1WsH9qGvWq1+Vah0B8FewdcFLOs0aEu3W84pK9bYFxlubI4J9sbMEYLJsB+TYb+V9zv34DHkcAIy00iQqd5eXalIIDDyfkN64kdEtNu+rK+v48bCPWD2FABYYeNOhAUOF0YjiPncD0G3+UGr4LMVTsOv+DRmjtLGdrmgX5WuudmyLOPGjRuoVCq4dOkSqpwPSrXJrvZqPUEIgcyJ+MJayWrfcwBOZ8Id96Od16C5dknTB8rNT7uXeLR+4aUoYNk/QG/JmbYv2bpqKzRY9s+c/Uv7eWT8vOt85qBwa5GGBT1jNTYgG+r3+zExMYGJiQlommbFvi0vL+POnTuIRqNW8ReLxVzbiTuyilsuOb0nuliN9DXDR+0/e7UocRYlo316ErKXCfawytUVzBcaLSbKh6M+vLSpP7iKBBgJ9P99UUpbCr7HZQn3S03173hQwP6wgJezekeJI95nDvvFZh/eeyzMa2+nS5Q5u9iP7Us75BoKbhfsrJ6JAEdQZ75Ldp8qlUrfKRuZTAY8z2NjY8P2942NDYyPj7u+Z3x8vKfXvxrYK/i6wJm0MQg6tXQHEUn0gnYeeWbeb6RWQDEct/6eDggoNOw+VLokXsHCdg1BnsNoSEQmIGB7+TFWlpZw5ORp3G5PZGI8JOJMprWtaELR3PNjzeLKbvvS2/57Act2jQZFBDo8jfak0nW0dCuVCq5evYpgMIjLly9DFEXc3dyxvafX3StSHoXkNKhxE/fzBBdHoy3+gSzqioZNo90SMGx8rPWbhSlTOcVFDqeTgb5aa72i1/ZfgOcwHdbZP0nV8Bcb+k3bjBQ0YZ/9A2Iipxd/A7B/7DtyDQXz2/ZCYspokbpZUQzCNnIch3g8jng8joMHD0KSJIv9u3nzJiilSCaTVvvX7/fjaUXG/ZLUzJeFd6uRvlq6jt+87i/rgTcW7G7j0Q62VAjoD+/3dyQstTFRXq7I1nvGQ+JAD9/mA6HJ5t53zHGaUWlsASgSgobxQfN9mFR7waBFmJfkEk3TQHjeOs840uq95xWKRnG/1LBlCrPYHxZtn6u5PhO1Wq3vgs/n8+HixYt48cUX8c53vhOAvm8vvvgi3v/+97u+5/Lly3jxxRfxAz/wA9bfPve5z+Hy5ct9bcMwsFfwOdCatNH8eTdFG/0kWvS1DQ4FrROaL4iGMYKb9Au4NB5j8n4lbFZl29B8TdXwZKehpzOIacSeGcHtiozf+41PYPnhfVx801vwNd/4dwHoN4jjqRBmo+1bpACwWmkqBCfDzRkii+Fjt3cXCr6lHgrvnoyXmV2uNyS8dGMO+/btw9GjR0EIQUNt+i+a8FrvUErxsFjHoiJaV7m4j8fF0WjXwmyZaV9PM+3rXF2G82idjYg4FPXtCvs8bLDbGPfpJrm5enP2j235muzfojH7l/YLyAR0779Os1vO76edMMNTi3RI8Pl8GB8fx/j4OCilFvu3traGhQePgOnDUAPNWL6IkdPrdQbTi/jBCXtL13vBNyxmiD1HVUrxxWwVVeYAcJooD6ONbMLqABCC24WGTRV7KOrDgYgIiqZlCYH9vrMbLd2qolnt6l6891iY949O2ihVVSH7wgMZZgM6yTDfhtUDgGMxn+vsJXu/q1arGBkZ6XndJj74wQ/iu7/7u/Hss8/i+eefx8///M+jUqlYqt3v+q7vwtTUFH7yJ38SAPBP/+k/xRvf+Eb87M/+LN7xjnfgd37nd/DKK6/g137t1/rehkGxV/B1ga2lO4QZvnYF39Od3hMt+kE3D7tqoGksbW6HPe8XtrzfXF1pPr1zHEoK8Os/+eP47G//BxBC8Be//7vgOB5/++3fhAtdmCYTTrFGc/FcK8M3ZIe1TmyXG3qKVmN+LpZKOHfiBCYnJ62/sS19E50ybE2oGsWNXAWrFQkm7zIR8uFsJtyVEXHaAO2L+KFRivuFGh44FNUXUoGeFMODotdc4I6gOvs3FeYwZcz+FSUNWaP165z926grVisxaip//QJiPq5tsVtRNNwqNOzCDB+Pk8kuLdJdjAgkhCAWiyEWiyE0vg8lxhwbALjtDYTUKgpSErwR+9YNfal07aoNTwVfxWEIHO+jKDHBXuvMQgcwmM24D/sYq5eyrFlpMRGBQ3RAJptSCkoI5ksKsoz6l41Ky9YVa4Z6JMDbjqHdKPj69d5j0VTod2b4doTmMdVr8axo+gPUUtVd8AcAJxJ+TAYF/NVmteXf2GLUVOn2i2//9m/H1tYWfvRHfxTr6+s4d+4cPvvZz1rCjKdPn9ra9m94wxvw27/92/iX//Jf4sMf/jCOHDmCz3zmMzh16lTf2zAo9go+F7A3mm6MWC9oZ7zsFGuMe0y06GsbOuyPrGmoifrJKRCCiTbbYeb9iqUsig/uYvTgURT9UZSNi9TVv3ixObfC87jx13+Jr33bO7BYrKNizP61m5kqSQoKZhi9yNvsINxn+Hr/DDrBZnrtYY6yl6KE/e5j8TgmJ5spBU5VsvWeLouuKxpe2dxBkZmVDJS2cH7/UU8XcacNECHAF9d3bNF9AOAjeFWLvd0GRwiSfh5JP48jsaZHWLbeyv7tyBp22rB/O8UCbly/jon9B/AymbYJM5xJI52wmwISRaO4W2rYFJl+juizerEx5HI5bG5u4v79+wgGg9bsXyKRcA2af7VaumsOdm+Qz6iqtF53YyKHU4kAwo5C0snuDfrdSIoKbd8xq9gjAE4n7fOvTibzDiPm4IbsMzqI9x67DEu00WHzJA2oEr2o7dUwO99QcbtgF4mJRJ8pBwzj+KQf40ERBSZ2LSpw2DG+byfDF4k0me1+8P73v79tC9ctx/bbvu3b8G3f9m0DrXOY+Oq5gu8ShCGKNtoxfL0WGQNtA8uOOfZnpSyBGrFlUxFfW3ZI0zQsLCxgbW0Np8+cxWPVhzJTIBw4eRpbayvQVBWaqmL/MyegUtjzfv08RoOteb/OOUb2YuvK8A2RHXFju7rBq2ijXq/j6tw1YOIoAIDn7adenvE9jIicVTx32rtCQ8ErmzvWvCFPgAOiiuxOFoQc67pNgF2NHPXx+MvVEhStyeBwxuzbax3ztdsI8BymQhymQnb2L1dXrZsHYGf/1p4s4ke+/ZuwU9gGLwj4wV/8dTz3d74BIcO7Lubx5rabDF9BUq0cXBOjAR7HEwEjoi6CSCSC/fv3Q1EUK/bt7t27kCQJiUTCmv0LhUK246DvQ8LD7ppej4B+HE702Q6nlGKpKuNe0R6PdjAi4oDLaIJGqa21OtGF4e+GhqrhRkkFQnrnhCfA2VTAiBfUIakUW4awx8cRpP287bo27FNvEO89E+xX2KmlW/OFrR3w6r3nNl9JAIQEYil9CYAzyeaYxCpj+ZL080zB11zuV0uW7iDYK/i6gC2QdkO04WR2dkusYYKd/2Vb1G6+d26o1+u4du0aNE3DiWdfwHxJRkO1s0Hf+5GfhiCIeHpvAW/4hm/Ed7/nvchJqlVIAEChoaLQaOb9jgZ9yAQEa56MI7rZsn3bOcOXrfm3YTJ8/ZheexFtFAoFzM3NIZVOY9v4m/Md7GefCYgoy/rv7Za9Um7gRrbC+HdxeHYsgkZxG1sej1OZyUrmACyWmtsQFDicy4Qxt1WGqnppLA8fg7Z0+71POtm/hmpk/hrqX5P9+5//8d+hslMCoKej/Odf+Gn8ra9/K2YiIvyvsemzRikWyzIWd5rCDJ4Ax+J6+8vtxisIAkZGRjAyMgJKKarVqiX+ePjwIXw+H9LpNLToJHRzE+/7aD9PuzN8uYZqCV66zVG2QzsT5RE/j0Mx9+tbrqHaWquDJLdUFQ1XczXUjJNU5IDzqaCtawHo/n/mxzMRFMARYpt5HPahNGgmMeAtZYNSinqgmRLixXtvu6Fi3sHqxUUCCoKSmalOgHPJ5niJSqllqcMT2OYRnQzfIC3drwbsFXxdsNuijXy9yeykA70lWvS1DW1auqzvnU+VXO1Stre3ce3aNd3qYf8RXNuuuSZd7B8bwQ/+21+BolGEBQ7PGsKP7YZiRb6VmRzdhqozaza2SeT1mCHm4zBtbXaL4evH9Lobw7eysoLbt2/jyJEjmJmZwfLTAgB7IcdGyIkcQdIv4LGxLS0zfZTibqGGh8x8Xcov4MJoBH6eQ7aHImmlIlnfH7sHEyEfTqdDEDjC+PC9FiXfVwb8DvavIKl4UJLAOVhaXhBQUykWihIWihKiAod0QJ/9i3eY/QOGy6BWFQ23tuvWHBqgK6tPJQOe/c8IIQiHwwiHw9i3bx9UVUWhUEAul9PPOUJQq9Xw5MkW0uk0wuFwx32w13vdCz5nlFqv6GSi3Kl4ZFurg5gDs1FpAAC5geemki050QBs7VVzX9lbzTCPDUWj2BzAe8+ElxzdHVmDKuqFdcLHue67tTyN4sGO3Q+SA3AgKiJbV61ijyd60Zz0N28MmzXFJgqxsY/MKvd8+PYKPlewzAIhxPJE2g3RxtMec3MHBd+mWGKLnbBUtr2HUoqnT5/i3r17OHL0GErhFOa3a67LPxQP4GgiiD9dLkABY85JCNIBEemAiOMAqkzeb47J+zVRlFT8+UoRYYEzPP98IBwHTZZ3RaUrqRo2mDnKUY8X+3YMH6UUd+/exfLyMs6fP49MJgOgGVzBFljOCDm2lc7un6JRzG2VLVEJoLedT6VDVjHhlRXTNA0Pi/bvkCPAyVTIMpqmlDY5nL+59Z4NNVW31SjJGv7ue96Hlz/3P7G1ugxfIID3fujHbK/dUTTslDU8Nmb/Uobti7ONNqyWLjXakQtFew7uAUMJOsioCM/zVqbv09UyKABR4FHIFrC4uAhRFK3Zv2Qy2RL7ZvPBQ+ciRtYotoyiROR688BrZ6I8GxFx17A9aTdz5mytZvz9PXxvN1RcY6LSgoSCrj5AeP8LLa/dkVVLoBETOUREzhYDBwzXh2/TaXPT5zFhY/jaML22OcEOrfGCwepVbaweh6NxPxYKDas9KxDgQrqVIV2zzSOKNhcJc/8opajVagPP8L3esVfweYBACCRKh9LS1TRNv5ESAolpqYkcwVh498QaJtx8+FjfO45S+JlYNVVVMT8/j1wuh9MXLuJhg0ehbJ+HAfTtP5sJY8wQeug3F9qWgQsJPGZjPGaNvN/lcgO38q0qq4qiYbHUwGKpAU5IwY86VGZecFgq3eVyk+2ainhPjjALI8qwFrIs4/r166jVarh8+bKtjWDOxLEfizPDts5csMyXVWUVX94s25jREy4WN14KPlmjmNss2ywOIiKPCyNhRNsYYb8eW7osBl2KOeh+lymmMuOT+NU/+jweP3qEzMQk/u6xSZRkDdm6rsZklZYKBTbrqmXCHBE4Q/ghDOWzlTWK2y45uKeSASR6GJT3AnN7fT4fzp49C03TLPZvcXHRFvuWTqcRiURsDHG3M2u91vTAmwh6L1TbmSgfj/utmdhO63drrfaKrbqCG/lmVFpc5HCAb+A+dXdncGMyncfDMFW6w7K5seXoumyfRinWjXURUFeDdreUFw662GkswONqvmEVbz6O4EI6gKijA2aKrQBTFMJhh7lGsp/dXkt3r+DzBN4oXobR0gX0IkoQ9Hk188Iw3UORMdA2uDB8rO9dgiiApp8w1WoV165dA8dxeObi87hZkCBprReuhI/H+dEIQkLzZDQvAl5arjxHbE9lB2MB+HiCzaqM7UbT9kUjBDUxiOVKs+Bcr+jt54SP77v14RRr9MK0mjJ8s+Arl8u4evUqwuEwLl++DEGwn2LE4PjMQrXYUFCS7BFyktq8AFJKkavJuLJVtuLuBI7gwkjE1TKmW5FUaCiY2yrbVItJP48XxmJtDIGN7fDwWXzFYUink6xR3Ck0LJsWAAgZxdRCkcP+Y8cB6A85CR+PhI/HYeizf3rmr4p8XbHUhQBQVjSUDfaPxKcR0mSIFRmZQO9D9G4mz5NBAcfirTm4g4I9tswlcxxnxboB+pxvLpezcn95ngeZOgz4I/Y3tsFKjzNmqqazrqx1B2uiDNhHEtpdJuyt1d5vjatGVJq5prSfx9lkAMVC3TVZhBWIcNDTLoDWTtKwRHys915oYJub5ka6HWJbddU63lMCWkz2C5KK+e1WVu9kMgAOwCu5mjXH5+cILqaDLWpqAFhnjxVjNtVejO7N8LHYK/hc0GK+zBFAHY4tC6AXfDzPv2reeyzcGD52O9K8gqKmIZvN4vr16xifmEBgchZz+brrTX826sfxVKjlomT+7qVGVinFiinWgN4W9vEcDsWDkFUNW3UZm1UZ65U6VEeDI1tXkF0rwcfpnnle835ZbDcUizlL+gVEemBEzGNF0zTkcjlcv34dMzMzOHLkiGsBajw7WAzf03KrYId9V6Gh4GGx+dmHBQ7PjkXbznq2K/gopVgs1bGwXbN9jwTA822KPXZbXpcF3xCQN9pNLBs6aSRmdCum/DyHyRCHyZCoRxca7F+u0ZxJAgBKOFR4P+4UG0CRZf/04rHdDV8zUhueOtIidjPyznbstNn9QCCAqakpTE1NQdM0FItFLOwwrLyq4tGjR1bsG3uesC3OqMi1MDpOFA0VMls4OE2UAWcLshWtrdXeWFG3qLSTCd1xQdPcs4OzddV6iBsJCFZR5Dx/h9XStdnc9Om9Z6KbaGONGTsZ9dnnxh86jMk5AIcMC6OqSvFKrmadbwFeL/bcZk9b7WVEax0mTOLBFCHtFXx76AozgFlvxXl3iXfCfJ+qqjYbjpR/98UaJpyijWJDsTzcYj4eERCsViqYm5vDM8dPIOuP43Gh7rIc4EwmbMWeOWHeCzV0/8w2qpI13Dwe9tk8+kSes/J+n1TzWNkuIjA5a7t4AXpuqXverw+RLlFZNnavx8LbfHJfXFzE48ePcfLkSZuZcsvrjf9TarTSjfa4PUKu+foswyqNBEWcz4Q7FrNuBV9D1XA9W8FWrdW8dCri61K4mBVqh5fsEoZqvNzjDmiU4tGOhMXycIop4mD/JFP521CxUWmAcs3zn2X/eKIzRab3n1nElGUVNx05uF5MngeF82GhGziOQzKZRAR1lK14LYJqtYrl5WUAsGb/UqkUVplLTSeWTaMUi8b3Y24TR4x4OBfPPnuh2rrl/YpEKNXFBo+Z42RfWMSxmM9ajzNH11pnzT3NwykBGwZJOwzvPRYqWosqE5KRZw0AkCUkDeFGQdJ99SqMkiYmcjiZCBhWVCquMEKXEE9wMRNsezyXZM26hyZ8nFUUujF81WoVlNK9Gb7XegNeD3CmbQh9noCEEEu48bTSPK1fLXYPQIvClWWYpkMintx5gkajgXPPvYC7NYKdSuu8XlTkcWE00rFIdebddrIWsNnSdGin8jwHQaphX9RvFXwjxqxNtia3z/sVOIwGdcPndEC0fZ+yRrFm7GMns+l2MBW6y8vLeP755xGPxzu+npizjaBYr0rWXOhEuFl4KS606IFYAMeTwa4PG84iKVuTcS1btrz6AP2p2XyC7uY1+Hpm+Pq9T1YVDTe36zYWLunTVa7DKqZ8DPtHVh+Cj8ThS44g62D/VHb2rwiEeQIfT1CQmtOrBHqhM+PR5Hkg2MQX3tfF1u0cx+HUqVOglKJUKiGXy+lq9jsLoEfOA7ygz321EU1UDBUy+znFDBVyOyVoJ4ZPb63K1r+NeyzoNaoLRNhi0YxKY78HTdNaCj62KPIb3ntu2woMp6W7LWkDe++x6MTwrdWaYziklAU3NoP7pYatKCbQP6v9hpioJKm4mq9Zmd0RgcOFdKCjonrN1s5tFuluDF+1qs+H76l099AVTlZMGGA4iOd5NBQV60bBJ+5yskbL+plNl1WKXL15oVu6NQeeAGJyBNfLFLKL3ch0xIdTqe6RXc5ZQb7NZ1aVVYvFCglcxzSHZpZuc1kxUcAzqRBUM++3KmGzJttm1GpKM++XI7rP3ajR/t2sNgvFTmbTbqjX67h69SoA4OLFi4jFYl3ewczEUYcNjFF47UgqbuQqtvecSYc9+zOaBZ9bPJqPIziWDOJmTr/4RUSua9TdaznDN8zixcv2t1O5Hor6MBvZvWKKAAhBxf6YH4egq0VzDcVgABUwdQ0qKkVFtd/QZsIixjya2g4K2+fYw+rYGTrzFk4IQTweRzwex8GDB7G6U8e80fol5QK+eP+qjf3z+/1Yqsq4X2qq2gmAA21MlNut3/kyvbWq/8y2VjtBpRQ3t+uWqhfQZwb3hVvZQbeWLlsUTTjSPJxzz8Ng+NaGmA0MdLZlYQtg1Cu4WlRtLXeW1QN0le4co2qOiRwupIMdvweNUqybRTqBjXVXmfPFvA9VKhUQQjxFB341Y6/gc0HLDB9b8GkUGKD7yvM81usqNONqOd1jkTEo2HXVFK2pPC5lMTqSgRTNoNBAy2MmR4BTKe+FB/tcplKgXZPkqSPZotNNyzVazbhs8kSf4RsJijgJveWl275IyDN5vxqFngNck4G8/WI63YNKent7G3NzcxgdHUWpVGqxoWi7D9Z2UCu+LCLySPgFbFYlzG2Vbd5hY0GxJzNuQgg0XmiJR0sHBJzLRLBYahaA3T5vJwYZZ+gXu5lCwcJNmBE0EjOcNhBuGORTce6jjyeYCImYMGb/SrKGJ2UZm2xutQGVQjdYLssIC0bmb6Dz7N8g6LWl6/q+Nm/ckJqvOrNvHP7xOPL5PNbW1rDw8BEwdRhqoNmSM4UzXr4fmy2MY/0rPRZDskZxPV+zBBAEzYgvN7gxfKtt2CnAheHrukWdoWjUOq4H8d5j0Y7h25GbudQ+AkiTh61iz8nqAbrg6Fq+bi0v4eNwPhXsOh/LikJGA4I9EculGK3Val29Iv8mYK/g8wCWVR5UuMHxPDaYLum+iDeD32GBPTmrSvPp9FA6jpIYwkZVbrmShwUOF0YjrmbMXtbTTqmrUWolaxDoSuWOy3SJVmvnjRgReUTiPA7GA5A1imxNL/62arKtvcleuL60WdaFH0bh2C7vd3l5GXfu3MHRo0cxMzODlZUVT/FqADPHyax3X8SHR4agwol229AOOUmDPHPCKvYIgKOJIA7FA6CA7fOe8hId19PaX5/Ybqi45RRmeFS5DqscbXcjUqlekLCFqEB0FmRH0ezsn6LPND2p6LN/Kb9u+pz28wh6NFzuBqef3rDe12DsNfwc0XOdgzHEYjH4R6dQKtpNlLnCJiJKBTtyEr50uitzw56dbIfAud50F++9hqphLle3RXc5o9KccM7wlZiiKC5yLerT1hm+wc7CYXnvsWhny8IWshKFVV1HRQ6nEn7bGJDTwibl53EuGfBEgLCikElHC16zbVuT4XNGA/5NxF7B5wECc5C4Obf3AhqIoE715aX8AqJD9sjqBvbktIxBOWCF+lCttg71j4dEnMlEPLU52q2nnVJ3s9osvkZDIgJdbkpu0Wpe6m+RI5gI+zAR9umMiaRisybjcYlxwof+5L5akbBaMfN+BWv2L+bjLTPl1dVVXLhwAel02rZdXmCJNoz/E+gq4XXms88EBKvN7XW5qkZxZ7uKJzsKYCRABHkO50bCSAV0BmGj0hTHjIVET3FV7PWR4tUtAHf74txOmHE80Z6teTVRlFTcdOTgjgR4nIjrtkUm+6fHvim2ZA2V6iyI2XI02b90gEdyAPbPi72J+/uacFd1NtnLSaPF2c5E+UTCh0BsFLlcDpubm7h//z6CwaDV/k0kEpYjgrX+Ngxfp9aqEzVFwxXGLqRdVJoTzpZuN4HIsFu6g6aWuMHNlkXRNCw77yFUw6FYALMO4++NmoKb2033gZEAj9PJgKdiVFKpbf4x5SjSVZdt20vZ0LFX8LnA1ZbFwKBefFI4Yf2827m5bnB9utYAzbFfBMBxF2Nfr7AxfG14kF5TRtwYvl6j1QghiBuq6EfGfBuBXnDmaorNXLvQUFBoKHreL0dAKkVwlQaev3QJUdZM2dgub+u3/y5wxFbsHYkHMBn24S9WjYxWD8ssyyrmNstWNB5gFOppu6J3qexNHGPbXuaIeS3m+HarpesWP5bwcTiVCAyNDfMK5z5qlOJxWcYjZw5uzG8VQ4BxLPt4xH08DkV9kDSKnGH7km00LT8Ad/Yv7ReQ6ZH967ulayu4iOPfqK0omQiJHU2U9YdPEZFIBPv374eiKNje3kY+n8fdu3chSRISiYQ1+xcKhWzXIK7NejsVQ86otABPcCHl7g3nBNvStc2eAa6Kb+ctZpB6r6Zo2DZcGEL8YN57LJwt3ZKk4jrTmgWAEEehPLmLgy88Z3vvalXGfKF5LRoLCDiV9Ht+CLEZZLsU6c10p+axtsfw6dgr+DygXf5sr5BUDQ1jBkXkeleEDgNra2uo7UhYW3qC8ZlZhCLR1qJCbuDSvozFDPUDN78/FjVFtWxCgjznaiLcsky3Gb4+v441RiE7FfHhbCaiz9XVFWPGT7K58zc0CgRjQDCGL2w1kNpRMRryYdTws/JamDivN+ZNmSPAuUwEE2GfrdXebbHL5QZu5SrNixwAur6I88+ft7WRaopmRbIFPH7egONm82pTfLuAdsKMgy7qytcCNUXDrUIdBcm7AtWEj2ud/cs1dFFUZ/aPWMVf0t+Z/bO3ZnuY/+zwG2uvERc5LJXljibKTgiCgJGREYyMjFh+a/l8HrlcDg8fPoTP54M4PgMEEvp2k9b1dsp6dUalhQWCC+n2diEt+860dLcYgcho0F0g4rymDdKCdeb0Duv4Zu+D61UZm3XV9q2OBwVMkwZuK3aXh6WKjIVis9ibDAo4keiNVOgW2WZuG9tl2vPg07FX8HkA29IdhOFbqUgA0U/8V1usoWka7t69iy9+8Yv4oR/5MHYK2whFovjIb/5XHDx5xnpd2s9j+9484gf/9kDr68bCLTHxbNMeWUSz4GNvNL0yfCaeuljBcIQgHRSRDoo4jhCqsoqHm3ksF8qgoRioabIMw/C5ruA2ADL9DB5WVMz4ZKQC7SOZVFXFL//rf4U//cP/jskDh/CB//sXMTo1jQDP4dnRCOLGHBBnY9Xc90/RKG7lKvoxZSAicjgV9+PLC1str1+2sXs+7xdYR0v31cSgNyfnu2WNYqHYwHqtP2HGroIQrFZlWyEK6ArUg10UqO6La7J/B6M+yJqh/K3r3n+Sjf2jqCgynlZkcET388sEPLB/PbV0mVaw499Y0URN0WzFqZuJcicQQhAOhxEOh7Fv3z6oqopCoYBHpebxv/hoEY2IH8VQ2vpbu6xX55xZTORwPh2Er4drN9vStUWbtbF/cXZE+j0NKKU2de6g3nss2NvgRt2eviRywMmEH4Xtqq217jSndvoVeoFb9rAT5vnDFsomw/c3HXsFnwtaW7rNn/vN06WUOoqMV0+s0Wg0cO3aNciyjD/+kxdRKentwnq1gt/5xMfx4U9+CoA+3D8bFvCiplhpIP3CPsPneL6n1OG9543pNAs+27L72LYdSbUpZN2sSSilWHv6GOuPHuH86dMYGU0hW9fVvZtVGXVG+099AaxJwNrGDgQCZIK64fNI0D6X+Bu/8Rv4vX//awCA0nYen/jQ9+MT/+UP8OxoxDZPZ5ubczncig0FVx3xaPsifpxIhaApsrX97L6w7dzpXlS/7Gfi+V3Dw7BauooGfHGrahNmTAQFPLML8WO9QgXBKgljh2lzBXmCU4kAEl1EBF4hcgTjQRHjQZ392zFn/xqKjU3UKJA1WsKAHsGVMdi/hJ8fektXpdQ2o2cKdTuZKPcCnueRTqdR9Eko7BizufEYCvktbHJx3fOPauDL25B9SZva3i0q7Uwy0PPxYrZ0nQIR5+yZ9XqnSrfP3d+WNGvecBjeeyY0Sq02sRsmjfxjc78ppXhkjCiYmI2IOBztrdgDvM0jtmP49gq+vYLPE+wt3f6WwcZ3BTT5VRNrFAoFzM3NIZVKYeL4GWzWJJi3bkoBVVHg5wjOjUSQMW4GADzPpLWD03iZxVatWTCNBEUEBW+fxTBm+IDWWTbnRUdRFNy6dQuFQgEvvPCC5a83FvJhLOQDTVHsWLYvMrbrslWlKVRvcZhzeXEfbxk+f+H6PDieh6aq0FQV64sPcWk82tKyYX9jvwVKKR7vNHAnX7VuQgIBTqfDmDRYSplx9zeRqyuoGcVhJiDYMo+74bUu+IYFNpFiqMKMAT+UfENBLjENjWteine7ECWEIObjEXOwf7m6Xuix7F9VoXjKsH8x5gGmp4KP+Yk9f5fKcosQzmsLuxew58NIJgMlncbmtn4dCKsNPF1exMLtecRiMaTTaTQiKTyVmusfCwo4lfA+Z+ZcN8dxrsIUN7TasvR3HNjYvSFF7e3IKm45El6CPAFHYCVomNY2qqqCcBzuO6LU3MypvUCff2y6D7gZZFNKXRk+05blbzr2Cj4PGIZog2X3InKlwyuHh6WlJSwsLODwkSOoRkdwM1/DO//hP8HVv/hT1CpliH4f3vsD/wJfOxm3mChCiO7lNnDB1/zZOffYq1jDWqalhnW3VfECZ27vtINdrNVquHr1KgRBwOXLl+H3t26ffsMUEPMJOJwI4i//6q8xevAoakIAWzXZNixflFQUJRX3i3WcfOM34L/8u1+1ir5v+7a/7zqfw14IzRuVZMSjbTJ2BHEfj/MjEYQZqwPiUvDZo+MGYJbpqzvEN2hLt6a0HsOvlTDDCY1SPDBvhIaq+rVSCLewf4pmFH8Kikyih0aBAtNu3awruFtsIG3M/nWaNWNV6ebM61JVxv0d+4yXOUs5bA9Bmy0LAVYrTabo2FgSqZkXUK/Xkcvn8aSqocIUeylIOBbqf5s0TQPH87ZkiHbziEDrGEc/db/Te290wIJPo1T3e2SERCaOxny4bhTPUSaHWFU11BPjKDDF3tGYD/s9dnScYEcRRgK86/yjXQ3e/LlSqewVfNgr+DzBbsvSe8EnqxrWqvqFjaMaAtLuFnyqquLOnTvY3NzE6XMXsKiIyBsF58ETp/H//MlLeHrvLqYPHcG7LhwB7zAF5TgOqtqesveCdgxfXdGwaTx5+nmC0R5sAiwRAmULvt6+j82q3Da31zRTHhsbw/Hjx13zL93AgyLFaxgdiYAahsqbNRlbVdmmnD353CV85FP/DV9+8Y8wMXsA3/qd342HxVpL3i+7VgogV5cxt2WPRzsYC+BYMthyE3IWfJKqYd2Y8xO53j5vfXn2bXm10W9Ld60q4w7TIgWaiRnDLCbYQsYryrKuEN5hCtIQlXFxLL6rObheQAhBTOQRE3kcMNi/vCH8cLJ/KgWeVuyzf+mA7v3nDLtnv0aNF3E1X0e+0Tw3CIBn0wEkuiS/9At2/bIKq7Ua4AmSRrfF7/ejGEqhgmZhlpTLUDae4q8WyojFYpb1SywW8/xAomkaZN5nsWKdBCLAcFq6w/Te25FVzBca1uwcoLdLzeXnmO/RZPc0SrFM/agzwsTjcT+mXZJIvGLNUzu3+TO7z3stXR17BZ8LuiZt9IjlSjMKKA4ZdMBiqhNqtRquXbsGADj57Au4WZDQ0BTba2LJNE698Abjt9YLAc/zAzN8zmg1E8vl5kzMdKS3FollbWAodTXaO8P3dMeeNGHCZEOPHTuGmZmZnpbJ2rIQQpAKiEgFRISEBm46YtJOPncJJ5+7BADYUSgWtmtY2K4hJHCW6XPSL6BcLGBz+Slw5AhyjOmujyM4mwljtI3C21nwrVQki92Yjvh6vvC/3lq6iiHMWKvZj/mwQHAw+uqr4llYrFax+Z0QAOFyFtMhAQE++VpunitEjmAsKGAsKIAa83Y3HYU0YJ/9uwsJIZ4gHWgqfyvlMh49fICJ/bNAZj9ow34NnI2Iu1bsAXaGLy+xKRd6a1WlFLe263pmsQE9Ki0C7B9Ho9GwlL/Ly8sA0BL71nbdmoYq3zSGbicQsV7fUvD1XqwNw3vPzR6IQP+uirJmFezmZ6a3WUVolOLWdgNF0jzfTiXaq6y9QNYoNo3roNjBILtd5FulUkEmk+l7/V8t2Cv4PMCetNHbe50ChTRRUN6lgi+Xy+H69esYHR1FdOYQruRrXW/SqkvO7XAYPnYd+v+d4gGvXnDsdgGw8nQ10J4YPrfcXk3TsLCwgLW1NVy8eBGpVKqnbQKaLSoTGqW4k6/iMfO9hwTOJrJo2TYm73fhlZfxr7/nf0ejVkNyZAw/8Z9/H2PTM1Y8WieDarbgaxXH9O77aBd/9Pz2gdCL3Q0AFCQVtxxGxSaEIbcIe0VD1TBfaNjYkLDA4XTSj0dbRXDhr/ybESHE1gqfDAnI+AVkjfk/1jOvqlJUKzKWKjJWHtzD//Wd39LWGQDAQMyPF7DHUbbOMlIiFI3iWr5uCREIWqPS/H4/JiYmMDExoVvelErI5XJYWVnBnTt3EIlErOIvHo/bugMapdjh9OKHI+6zZyxajJd73NdheO+VZRW3HKxeWOBwMuFH3Mfjy9mq9Xe2zcoT4Hq+bol+QCnOpIKufoO9YJ01yA52cELowPDttXT3Cr62YG82NluWHu96hYaCHaOtl/QLCKsEpQHZMycopXj8+DEePHiAo8eeQSmUwq18a0yXCZaOd2PIhsHwuQkrcnXFKnrSAcE2e+YFZjFjefHR3lS6zmJTlmVLvXz58uW+KX925lFWNVzdKluFJQDsj/qxVZVa3vfcaETP/K3JtrzfT/3sT0Bq6NtazGfxB7/xK/jhn/gZHIkH4HcmlbtsC6AfE0VJtY69hF9AtIdoPEBnPbOFBhDT7Su2trYwkUl5zg1+teA2X2R6t91yYaNebWwZJsLsbOe+sIgjsd4Z168k8MTO/pUVDVmX2b//8is/j0qpCACoVSv49C/9LH78V38TDePkHaaCtB3Yy1zd+B6SPr1AeSVXswobngBnkwGkO+TNEkIQj8cRj8dx8OBBSJKEfD6PfD6PW7duQdM0pFIpiwGsCUFohh3XmCP31Q2t0Wq97esg3nsapXhSlvHQMas3GxFxiLEHcrtvjAUEXMvVkTcLZ0qRruUwFpztbQdcsOYx75jtwO2pdFuxV/B5ACvaUHrsIdoEClE/+B1+YPaMhako3d7expmLz+JBg0OhbL/J8QRIB0Rr4D8s8igZJ6VbAdtLckQ7uJkjLzk+i17BCkr0C493hk9j2EUCIEFkvPTSlxCLxXDhwgUIQv+ngikmKcsqXtnYscxcCYBT6RAiIo8nBtPm4wkko9oOChxGQz4cjAcha/ps44NCTf/sWcZQo8g3FHxxowyRI13zfq2h+D7ZPTNCbmVlBcmjZ5E3DteV1VU8XLhtKRnT6TQikchralbsZlQcFzmcTurCDLPg23Vy0uUjUDWKu6UGVqr2lvzJhB8ZpqDYrTSR3UC7TFxCCKIijygz+5etK1jckVquJZqmWcUeoLOfT8uS/hC4S2Iat8t2xs/jy9kaqmZUGgHOp7tHpTnh8/kwPj6O8fFx/TpQLiOXy2F9fR337t2DOnXEeu14oPuyB2npDuK9V5Y1zBfqKNlYPYKTiVafSuc2ihzwtCKhKDctUTK1PIK0Na6zV1QYb8aIwCHagSjYY/g6Y6/g84B+kzZkVbNyWQWiJ2vkqsMr+CqVCubm5iCKIo4/+wJu5OuQqH3ZUZHHuZEwXl7fAaBfpCMeCr5Bt9E5w+cUD4z1mTLizNP1Wn9v1Zq5vXFOw9yXXsaBAwdw6NChwQ1+CUFRJZhfLVmiHh9HcGE0gnRAxLWtsvXaqMgjpxo5ucwyGirFo1IdZUXDd3z/D+Lf/OPvhiJJCEdj+Kbv+ofW65x5v0kz7zckIiryVlGsaM1jjyfAZNjb560oCq5fv45qtYpLly7hblkFDMbgzNmzEFQZuVwOuVwOT548sXzOMpkMksnkQIWzE91auus1XZjB2nrslsqzV5SMHNxqmxzc1yu8+vBVFQ2PdiRUVYpv+Z5/grm/1J0BfH4//v4/+n7ba8sKxd2SBJQkBHnd9y8d4JHy8UMzp3ceRTzRjYCN+gR+Tk/PcDPy7QWEEESjUUSjUczOzqJcl/BSznjQVCTcfPkVpJJJ64EpGAy2LGOQlm6B8d5LeWROO7F6B6PuLLTbfcMs9gSjcN4o1cEN4Xqw6pHdc24Xe5rt2bLo2Cv42oC92bAHTi+ijRVGrDFlJGvw/HAKvq2tLVy/fh2TU1MITM7iSq61hTsd8eFUKozNGqNMDflsLvG719Jt/qxSYLnMigf8fbeynF58Xhk+lu0qLz/C2dOnMT4+3tc2sKCUohZMYIMGYN5WoiKPZ0cjCIm8TaEtcARhgUfOUAGan70zHu3817wRv/riy1h5vIgTp07iLUf2YcuIe8vW7L5l2w0F2w0Fdws1BHgOo0ERNJLAek2xXjcZ9ubpVqvVcOXKFfj9fly6dAmCIICUd5h91WeZJicnMTk5CU3TUCgUrAirWq1mZZhmMhkEg8FdYf/chBkBnuD0EI2K+wU1Bt3ZmydH9BzcqTbea5TS1zzSzStsiRkum6xRisUdCYvlZt7p4ZOn8at/8hIe37+H/QcPYiIowDyqONhbmDVVF7YsVWVwAJJ+Hmm/nvwR4knfn5PzOqFRwLwKhwQ9F3c3rHqyCqwPajYRxvizzyKXy2Frawv3799HIBCwir9EIqFfex3L6KXm9ZLkwaIdq3ciEUCiA9PpvG+Ybxc54EI6iJjIY1VV4fMNJpTSGcvO3nss9hi+ztgr+DyAEGKpQr2KNpzJGmYLc9CCj1KKhw8fYnFxEcdPnETWF8Pitr3Y4whwKhXGPmOdrDJ1Juq3MmyB3WP4nDN8S2VmG/oQD7DbZi/4ur+nzuTIEkXG5VPPWGbKg0ClerxZKdwUeowFRZwbiVgF1ipb9Id9tou3omq4tlW2xaOFBQ4XRiP4IkeQGBlDSOAQEDjsi/qxL+qHRinyZt5vVbLaxwBQVzV9hGDyMO5Xmn8f8ZCJXCgUcPXqVZslDaXUJUy3CY7jrFmlI0eOoFqtWuzfo0eP4Pf7W25mg6JoMGesMGPcMCp28+V6NTFIDu7rBZ0Yvoqs7z9bPJj7/2UCnExehkhV1NXm9ediWk+uyDZUZOsqClIzk1WDbvmRa6i4Z7B/ab+ATB/sn/MyYf4eEzmcTwV3hXWllDrYKREhwY9IJIL9+/dDURRsb28jn8/j7t27kCQJiUQCjcw+gGteI70WuS3eex3mECmleFKR8bAk2QrM/WERhzzMlpZKJWxtrGNs336IRlHn4wguMiyppmkDn/N5qSkGSvt5WyKRG2wMn+XiRfcKPgN7BZ9HCIRAotSzD1/BNjDPI2YMzA9S8MmyjBs3bqBcLuPscy9goaJhp2IXA4QEDhdHI9b6WGVq0FCm5uvNi5AbQzYcW5bmzzVFQ9m4CaT8AiIDpIw0Cz59GRTdGZJH22XrAj+bCCEWi/a9fhMNVcOVzbIV0QYAh+MBHE3YWS3nDOcKkyF8PVexRX1NR3w4mQpD4IjVxnF+PRwhyARFZIIiTqRCqBiij82qhHxdcRWxXM2WESlyGA36dNsXR97v2toabt26haNHj2JmZsa2/b3YsoRCIYRCISvDdHt7G7lcDgsLC5Bl2RpiT6fTCAS6G0CzLDs1hBmsRQRPdG+vTnYPxMN2DwJz2ZTq0W0s+9pvDu5XMtxm+CilWKrIuF+y280cYNrr5vsopVAE/buPCBziPn0MISLymI3oRUu+oQs/cg3Vdn7UVIrlqoxlg/1L+Hlk/KbvX3v2T9M0/PrP/hT+9H/+f5g+fATv+7H/G/FUGikfj7Op3qPSvKIka1b6RIRoLd6EgiBgZGQEIyMjeqegVtMfliQZCBgFH9WwtbXlaVyixXuvzX5VFA3z23VbZnGIJziZ7MzqmfjCF76A93zrt6JRq2F8ZhYf+63PYGJ8DBfTQds+qqrq2cu0Hbx477FgCQD2vKtUKohEIgNty1cD9go+j+ANis9rS9fGqjG5uf0WfDs7O5ibm0MoFMLRC89jLl9riSQaD4k4k4nYmA5nqoXOVrK+gq3rGo5oo7mOMpO7uK8PsYZtuWbBxxy6GrUXmCxyuTweFxqAqK93Nj64UqskKXhlo4ya8eERSjFBKziWtFu6FBuKNSsZ9+lF/wqa34d5M+OJHo82FWGf6vX/O133nQiLPA6IPA7EAlA0ilxdxpWlLVC/fTaoLGsoy3U8KtUhEF34MRIUUF5fxsqTxzh37hxGRkZalt+vDx/P88hkMshkMjh69CgqlQpyuRw2NjZw7949hEIhZDIZy8S2042hnTDjVDLQchNth90q+qyCFLDOx4CRg5vsob38+mnpNkEIQd2wm2FNlEOCvv/soL/F2hG7rYtzvwWOYDQoYNRQ/lYUI/O3rmLbwf7lGyryDRX3ICHAE734Cwgt7N+nPvUpfOoTPwcAWH38EHKjgV/4D7+NU8n+otK8gmX30nzn6ykhxHpgyuZqlq0JAaxxiXg8bj0whcPhls+um/deO1ZvJizicA+K8R/64Q9Bquv3t82VJfyv3/xV/D8//ZMtLfFBGT4nYzniQfDSboavWq26zkv+TcNewdcG7cyXvYg2ZE3DGivWYAbmzVaZGSztBevr67h58yb2z86CG5nGVce8HgFwPBXCbNSeC6tRimVGmTptFBS2qLg2DN8wffiqRmEkcLpwZaDlWgxf828aALdLwdOnT3Hn6Sro9FEARo5sj1YwTqxVJFzPlq0naT9PkNzZch32dqqSJVXDRtWuWnOLRwPM44/25H0nGApeyjABh+MB5OqKjYlUKMVaVdJnC4Ukos+kURAD8DUUxAzGxdwGwpZ8fVZNhBBEIhGrlSXLsmVie/PmTVBKbewfO/dT5vwtzNnBiIgDXwHMWb6htnj+TQQFHOuxvfy6UukyP+/IKl7alGzfzb6wiCNRXwu7ZO6iZhxPBN3zXU3mzwv7V1cplqsKlqsKCHTLFbP1+1dXr9syrJ8uzON0sjVDe5hQmdxXaCrSPTgZscWYwHG4dOmSxf7l83k8fvzYEkul02kkk0kohO/ovefG6gWNB5Ne5l53ZBXFWt12HKQF6jr/OCjDt1FXLMZuPOhNiNVphm+P4dsr+DxDMI4dlXZvIa6WJevAm4r4bC0D84nHy8mgaRru37+PpaUlnDx9BqskiI2CvdgL8AQXRqJIusxrbFabytTRkGgZ9rJPPm6E5bAZPhNT4dYbQc/LdczwAWZbmvld03Dnzh1sbGwgfuwcckaNNUiOLKUUD4p13GM+/4SPx8XRKB6WVqFp9s9f1ajVvuUJ4Oc5fH61hDpDqY4FRVwYjbh+VuZfev0WNqoywOt3l4mQD8eSOqMpqZoh/NDbv9ZNmhDsKBQ7hRruFWrw86btiw8jQXFXotVEUcTY2BjGxsb07NadHWSzWSwvL2NhYQHRaBTJdAZZfwJ1X9RacT/M2W5AoxQPdyQ8LtuL99PJVz8H91UHcxCwqRR+w26mnX+d9TbjgMoEeFdLoU5oZf+oZfrMsn8U+uyX6Qd36NIbof2HfweO40Gphm9++zfuOqO6VW+KpvhKEWIs4fm97JiNebkMBoOYnp7G9PS0JZbK5/NYXFzE/Pw8xMkDQFQ3755gmFNKKZ5WZDxwY/VcCvNOKEgq5nI1fPsHfhA/98++FxpVEY7G8L3ve5/7fvRAarihF3WuCTeGT1EUSJK0N8OHvYLPM+ysWLMAdKKdWMNaDlPwdTKwlSQJ169fR71ex5lnX8DtsoKKYo+LGgkIODcSaXvhdLZzTdhauq+CLYu1DQO2cwGm4GOOXLZobTQauHbtGhRFwcUXLuGvt/TWg48jGOsz2kfVKK5nK5baFtBtTs6kw+A50hQ4MFirSta8Z1jk8cpmGU50ipazWro9Vlk2c2nm8/bxHKYifsSohML8DaRGxhEe34dsvWkMDuj2MMtlCctlCQSwKbp3g4cihCAWiyEWi+HgwYNoNBpYzhXwRPVB5ZvfV4IoOJUMIzjA/OcwUJE13CzUbQkEgK42HaTYe720dIty63VhLCjgeBdW03nsTA5YGOvsH0FE9DXZP0lFzsj8Zdm/i296C37ol/4dvvziH2HywCG8633fh8dlCRk/j7DA7cpnz7ZXuVIWZDLp+b3sOe/2kbJiqcOHD6NWq+Hlbdl68/LNOdTiUURSGazzEZQYCjbI6756vT405RsKruXrUClw+a3vwCf+6AtYe7yIFy6ex+HDU67vGaSlW1M0a4QjLBDEPNrluDF8lYoeb7nH8O0VfG3RMU+XUghtXKiKkoqSKdbwNcUaJjiOsyUzuC6jWMTc3Bzi8TgOnXsWV3M1OC+zRxNBHI4H2l6saopqqXGDvJ7T2m5fnOB5HoqjuOwVzguV22fR13JdGD6z2CqVSrh69SoSiQQuXryIp5WmiGGqx9xeEzVFxSubZWsWDwCeSQZxMBawtT6dBR9rA8O+l41Y61RAccbx1W2Gz7mt5nfuI9Rm7gsAm5ubuH79Og4ePIiDBw9a219TVGxWdfYvW5etApoCtrisG/k6RoMCRox81GG3VCmlWJUIFhEGNe4ThGpISyU0NlfwxYUq4vG4NfsXCoVetUKJUr1leK/UsD4fAkDgdEuKQTbj9dDSVTWK+yUJSwzrwgE46YHVdO4fR1VkPMxj9QKBIxgNCBgNCJBVDXN5e/vyhbd8I154yzcCAHYA7JQk3IfOGqcN4UfKzw9FwFFXNStCL8ATKJVST0yXZitaur+vzvkgG3eIlJ/HwePPYLFYxaoatFWPY4KGE+kIhB6Z1WxdwfV83cYQju/bj/F9+5Hq0JYfpKXLpoVMBL2nhbgxfNWqHgO3V/DtFXyeYSuSNOo+NAbY2L19bVqInWbklpeXcefOHRw8dAhyYgxzjnk9kSO4MBJBpstF1pay4Jjtc0vBYDGMlq7z9BxUrGHCbYZPpc05R7OYAYClcsV6TT9WMNt1BVc2d6yihyfA+ZFIi2k0IcT2fZZlFflGa8F8NBEET4A7ho1OJw/Bfhi+ZUYBPCJSW1vHjN477eI/GBR47I/x2B8LQDWEH5tG+7fG2L40NF2NuVSRwRP95pIxbDIGjcaqqxpubdexzQgzfKqEUamI44cOAAemrTkm0/bF5/NZnn9dbV8GqKkkQ5iQteXg6u3lW4U6ZI12NCF+vaNoZBRXHfOKs1HRE6vp/OgjSh0ciQ9xC5uQVIqr+SYD202lXVcpVqoKVozZv4Qx+zcI++dUlj6ltLeCj9liL/Un2/rMBAQ8qAMF5uFahIbYziYKG6v4a8Cal02lUvD7O18XN2sKbmw3Z/YEAtvMZqft65fhGyQtxI3hq1ar8Pl8QzWFf71i7xPwCKGL0AEwUxD0Qksg7dMN3Ao+c+5sfX0dp8+dx2PVh1zJHpGW9Au4MBKxZvHagVKKJebmP+0odrwwfIO2dJ1+hZPhIRd8zC328ZMnWH/8EGfPnsXo6CgAIF+XUWYyjHu1glkuN3AzW7GeakMCh2dHI655tGxLV6XUlqwBAAGew/mRMFIBEY9LTfV2pxtRrzN8tig1SpHh9aVrmobbt29ja2sLzz//POLxzjdaniMYDfkwGvKBUorrW2WsVFvjkVQKbNVVbNVVoAhEBU6/UQYExMXebpQbNQW3C/UWSxNlbQUCc8Ng55hY2xfTwyzpkmAwqC3LVl3B7ULDMi4HgOmQiKOxwedRWXwltnTdTJTZz9PnsYhxXmJiavuc70FQUzRczdmj0vw8QZk5sAQCPD8SQrauCz+2G6p1jlEA25I+D9gv+0cpxSrjczoR4PGk14LPY0EF6OSDqWTlANwv2dMyLBHNZAz06CGUSiXk83msrKzgzp07iEQiVvEXj8dt27lWlTFfaFjLS/t5i7k00UnZ2y/D109aiLVOlyzdSqXyqnYDvpKxV/C1QWtLt/mz0w7FxGqlYRU6k5H26QbOgqper+PatWvQNA2nn3sBN4sy6qqdIToY8+NYMuSpjbZZky1xwGhQbFFQ2Rk+9xm+QRm+VcYfUCBkaF5XZvuUXVw2l8OlS5cQjTb99frN7aWUYmG7hkdMYZYKCLjYYVbSbNFXZBVXt+zt35GggHOZ5nvZ7e7E3hFHy7rbxSpbVyybGKFRgS8cgCRJuHbtGmRZxqVLl3q2JSCEwM8c+GeSflAA2bqKbEOFzFxcdxQNO2UNi2UZIgeL+Uv7hbazXYqRNcvOO7HCjHvr7feZtX0xjVVzuRw2Nzdx//59hEIhpNNp0NAYANJz0adqFPdKEpaZYtfHEZxI+DHC5uD2uFw3fCW2dNuZKI8EBDzc0c9tr2d0iZn7I5oGf89SpO4oyyqu5uoWG+/nCI4n/LiW189js1DlCEFY4BCO+LA/on/P+uyfrv6tOZS/Leyfn0c6wCPShv0ryhqqxg0i6ePhNy4ZvRQbtoKvy6e8wXjvsZ9qgNdFNCl/81glhCAejyMej+PAgQM2tfz8/DxUVbVmA6VwEg+qzSVOBAX4OSBn5yDaxr716kTBgi2YvaSFsHDz4TMLvj3sFXyeYRNttPHis4k1OrQQ2YJve3sb165d0+X1s4fxSt4ueW/XRuyEpQ6iEX2ZdgGKE8MQbSwxPoQDdvtsMItRlSmIT5w8hWi0Wcy02OJ4/OxkTcPcVsWWRDIT9eNkqnOhzXEcKkIQn18t2j7PmMjjudGow8iYURN3KBfYj8yuQXYH+537q0XUghQLCwuIRCK4cOHCUNoZAiFIBwSMB0VQSlGSNWTrCrYaqk3EIGvAWk3BWk0BQQNxH4eMX8BIoNkmc2sTjgUEHE/Yh/+9FEOEEITDYYTDYczMzEBRFOTzeWSzWdAABTiCer2OtbVii+2LG0qSiluFumWaCwAZP4+TCX/PytLXG7qZKLPFuVewEXg8VYbOtJjqUfPrCvF6Li5brPNGK9K5Zp4jGAkIGAkIoNSHqkot4Udb9m9HLyjTgSb7Zx6zTmWpefz2UviwXZdOz8nUYGCdmA4JOBLrHqfoVMuXy2Xkcjk8LjVQJc3zOcOreCYasDKBWbTzP7ViSXts6aoaxYZxvPCkc1qI6/vbzPDtFXw69go+j+jWBnWa7Mb97T9aUxTx5MkT3Lt3D0ePHsNOJIUb+brtdWwmq1ewMWIBw2Kj075oLsXroEkbJUlBgWG5hklgcByHcrmMtVIDSOqzaLyjmHHa4nhpvVVkFa9s7liJIATAiVQIs7HOVi6KRrFKQiiGfC10zzOp1jaCzeakI8PneF2HXdD9/fQLv48j4CpF3MutY2ZmBkePHh3oBsu+k91cQoh+nPt4HIKePKLHY+mtMvPzp9BbNAVJwoMd/Zj0ccTGHPEEOBb3YzLonjXbKwRBwOjoKEZHR7G2WoYG/bhZWVmximBz9i8ajdpnHV1ycI/G/Jhuk4M7LOnyV0K7yauJsgkvm6zR5g0cADh1uAVftq7g+nbdYnbMqDSRgy2D1bC17LjNhBCEBYJwxIcZlv0zjmuW/WtoFKtVBasG+xf3cUj5eMt7jyf6A4yq6NfiXgo+9pBqd+mqKRpuOB6Y/BxwKhmwsXpeQQhBNBrFFvyoMkVkpFFCZXURf/k4AHXfMQBAmAPM5MZ2D8ImYdArw+c1LaQdzPdypHlOmQXfV8I59lpjr+DzCIE5WBSXIqmTFYsTHMfh6dOnqNVqOHvhIu43eBQcT2ozET9OpEOe3c9NLJWbMxftbD/Yc7AdwzdIwceyTYC3vFsvoJSiUqmgUCggc/wsNjRz+Q6FLGtN4kGska3JuLpVtlqUXoUxJUnB1c0yKqSVMQryXItKFnAwd50KPubndsbSJlbKTTYmRiVsV8rYt28fjh071uFd3tCu4HPCz3OYCnGYConQKMW2pGejZuuK7aZUV6nNMkMg+pxRijF8ttY9jAu0caP3+Xx49tlnIUmSJfy4du0aCCFIp9OIpjJY48Moys1ti4ocTicCCHu0hOgXXwkt3bWqjIVio6uJsq3o97DcrbpqWyZB9/EEr3DOmLFRadm6YstgNR9Ae/kmWfYPcT8qitaW/dMfahjBkZEPHKZGYka/LV3H+0y1+P1Sw9FN4HAxHex7dIZSigcOb8mDEREHJyaA2Qlcy1aQNf6pml0HUvrDdq1agRriW5g88/7Ra8HHqnP7se4xyRhnysaeB5+OvYKvDVpm+GxFkv0CrWgUK4ZYgyedBQrVahWlUgmiKOLks8/jWl6CTJtP1ByAMxl7zJZX2Ab30V4Z242tHKSlq2oUy458305qVK8wxQfFYhGjo6OIxePYsNSuzdcVGwqKHplWSime7DRwO1+1bhoRkcOzo9GW5Au3993JV5ttL6phLOzHutHScSqjTdiSUDqUUM4Zvna3V0qpzW+x9OQ+IpEIkslk22X3BJZp9PgWjugh92m/njpRVTQs7khYqykty1AosFiWsViWERY4jBhtsrhPP+GGXQz5fD5MTExgYmICmqahWCziSaGCBcXfPJAoxaSf4JlUAPyAWaBf6ZA1ijuFhjX4D3Q2UWa/Dy+lxapT8EMBMoR53qcVCXeLzevMaIDH6WTAKpDY1vNUSLRSKAYpNs3Zv5mIft3cbqgWq+1MXKmpFDe2jY7NzHE8LsvIdJj9M0Gp3YiJPfpqiobbhYZlKM3iTLL/TGBKKe6WJCxVmt/VkZgPsxH9QVbRKPLGxykQ4ODMNO6V9T9sbWxg8851JBIJS/0bCoWgqqoe49nD+VNXNYtdDvIECV/v5575NbD3uL0Zvib2Cj6P6DT3xoo1psLtZyey2SyuX78On8+H0PQBfNkxExEUODw/FkWkz/ivbF22BvdHgiJCgvtyWlMq7BikpbtWlSwGVOQIZI1CgzfhQTs0Gg3Mzc1B0zRMT0/rog2470M742EnNEoxn6vaiqXRoIhzI5GOBrKSquFGrmKLSAtCQ2B7GUVh1vrbdMR9TsyraMM5w9cOBUm11Mh8o4I3XDyP+fn5oRVKtk+ij0WqGsXjsmR7cheIPgC/I2s2n7+KoqFS1vC4LEMggM+fQFCpQ1IpfO2GhQaACoJlBLHlbzIJAtUQKa5ha3MNRcP2xYyvGiQXtBtei3ZT1lAgs9/BeFDAMx1MlO1t/c7LrxttfucSBtlXSike7Uh4xDBRUyHd+NlcrqxRbBkFrMjpqR7mLg6rfOcJQSYg6Cx+3I/thoJXcnX3F4eieLCjjzT4OCbzl5n9M+G86nJE3+cVwwPSrSOT8vGu0WZeQCnFnWIDK0yB/Ezcj33h5jlhjzgTwDHsx5FDB5E4PGPFvpl2SeaohKIonueHWTubiZB37z0WewxfZ+wVfB4hdBBtdGvnUkqxuLiIhw8f4pnjJ/CgqmGDsx+AEyERZzORgawePItGmFUMu6XLMoxBnoOs6Rd8jbYf8O0E04Q6mUzi1KlTWFxcRK1Ws91szC11xpm1Y1olVcOVzbLNK+9gLIBnksGOF5l8XcbcVsUWj3Yg5ke0WsBjwtuK7WCbYttri9TrrN9ioek1+MxYGuFwyNUIul+wIpNel1iSVNws1C3VIqAzMScSAYicvo07ima1flmjXIUCihBEVQjiLzYqiIuccYPlEe3BH818lXPbtxu6MINtL1vFzlQM6rHDKBQKyOVyuHfvXlvbF/Pdr6fpIDcTZYEAxxMeTJSZn0mXvV5zE3gM8OBHKcVCsYFlZrkHIiIORX22Za7XmobrE0YGq/U97dIXxfpHHoiISPh4ZBsqtqoS6rS5UkmjWK0pWK01Z/8yfgFp47h2jr9oFLiar9vmKv2crjQ2mT6vsWNOaJRivtBoZv4COJnwY9KRSGQXojTZUgDgOQ6hYAihUAj79u2DqqooFApYW1uDpmn4/Oc/j3g8bp034XDY9funlGJtAHWuuQyrsHfk6O4VfDr2Cr426JS0oTA3U7aFGHNpISqKgps3b6JYLOLss8/hdgWo+poXBwLgZCqEmTYtQK+oK5rFOvk5gtEOMWIcIZZNQTuGr5+WbllqGg5HRE5nZYxzWAMF3+NtcW1tDbdu3cKhQ4dw4MABq0XgnqVrjzObCPtcWYodScGXN8uWoTAH4HQm3OJVyMItR1fkCM5mwhgL+bDWKKEejFn/1qnYJl3YVet1HtS8ue1trFUUgOPBE2A6FrTWsRtzYV5TPyileGLkd7Lih2difkwy4gdCCGIij5jI42DUB0nVs1GzdRW5hmKb/SrKGoqyhIeGQjIT6C8dQTMYosWyvdh5Ju7HBHPOsOH0R44csWxftra2cP/+fQSDQaTTaWiRcQxa7r2aM3xu6ui0n8eJhN+T3xm7qZ322ulHxy6gn+ucRilubdtbz8diPsy4MOntlLLdtrlfUEpt65wK6VZYmYCACdRx/c5dHDh9Dtm6nu/LJtmwgiYfR5D0cdhaXcbv/eonINXreMd3vRcHT56x7c+hiA9/vaWnR/SjZAX0z/PGdl330YT+uZxySU2pukScsV58zlPPPG84jkOpVML58+ct65fHjx/bzqtkMmnFi5ZkzVLFJ3xcX4wlRfOBxMnw7bV0dewVfB7RkrRh4GkHv7dyuYy5uTkEAgE8c+F5XM3XbRFpPo7ghfHoUCLHllmxRrR7jBhHdHZvmLYsTx1iiTxzce5FuEEpxb1797C0tGQzUza3zZm0YS7blnLiUnRtVCXMbZWtffbzBBdHo0h2mPOrKxquZcvIMfuS8usZxuZFSQGB5Ndje7oW27b9bPuyrgzf2toarj9dA8ZmAdhHCYZZ8HltQZuoqxrmt+1zRlGRw+lkAOEuF3EfTzAZEjFpCD/mF5+iQnzQwnFUHIkfrD9a0s9jxGiThTqso6LoaR6sQjjh43AqEeh4g2ln+5LL5SBJEiD6oagqVldXkU6nu6YXtFvHbsLNRFlXIPsw3Wf7rFP1xPrRxUSu+Zn3UfApGsX1fN06pgh0JmrC5Twry6q1rqjIISrynm1O+kWRNQp2tFcppRA0BfvCPuwL6y3Hgjn711Bs7LekUazs1PGj/8e3Iru+ClDgpT/+//CJz34BkxOTOJHwIxMQsFqVrWvYeD9KVo3i+nbdKtw4AGdSAZu/pAlb4oURcaZ5+DzNlI1gMIipqSlMTU1ZM7O5XA6Li4uYn59HLBZDKpVCKZyBeUA5GUbP+8Vcn5wzfHsMn469gq8D2Bsn76JsVTSK1bK7WGNjYwM3b97E9L594Eb34YrDcsWv1PHGg+MQhzAUridr9KZM5QmBSmnbpA1KaU9zdyqlWDG2gYOuEC4wT4Lt0kmcUBQF169fR6VSwaVLl1ryD90LPoodScW2xS7ytiKOUoqHxTruMgxd3Mfj4mi0441+syrherZiS1k4kgjiiCPDeFvjrQqtnTLahFsr2g3tZvgopXj48CEeP36M4NHzKBsLYecVu2U194Qebs6bNQW3i3Uw9RRmjZZbr7m7HCEIUQU+uY5jByZQU5q2L3mHQjLfUJFvqLhbkhDiidX6Tfp41CoVrC8vYd/sLL6oarYc3ENRH2YjvRc7rO1LbqOCmqqfJ6urq7h7965l+5JOpxGLxV5zO4h2JsqnPBThTnhV6bKM10iAZ9ZNQTzkw5qQVIq5fM16P0eAs8mAqwJeXy+r8tRfY2Mld+G7WKnZGUUWmqbZ1skbXpbpgIBj0AVNpu1LXlKRXVvB5sqS9fpGrYZH8zcwPj6B9ZoChVJb8k2vSlZF0z9Pk7XjCHAuFUDa5aFXb7Oyc3X6a9oVVizcUjY4jkMymUQymcThw4fRaDSQy+WQzeWwKSQBXgChGlDMQRJSXf0yW9bp4sEH6AxfKpXqaVlfrdgr+DyCtWUxD6zVimS1nSbDfmsu6f79+3jy5AlOnjqNpySEXNFe7I3QOsTyJkRucijblqsrqBoMSCYgdFSYmuANY6p2SRtAb1mIG1XJKozGQj74eK5rZq8TlUoFV69eRTAYxOXLly2637ltrS1dR7JGpNkeVzWKG7mKLfljIuTD2Uy47ZOxZqRtLDJpGwGe4NxIBOmAfZsopdhSmhe2bpnBrepb769TVRW3bt3C9vY2Tl18HleK+sU4KvI2n7Rh3tS8zByqRmIGO/jt5whOJf19eYKxMPc9KHDYJ3DYFxYtf7SsYZHBzuFVVYqnFRlPKzIW52/gR9/9/0N1p4TkyBg+9lv/HeMzswjxBKeS7t5y/YLnOcv2xWT/rl+/btm+mPFVbsf0brV0u5ko91qEm8s00e7dqkZtfnQJHw9rtqOHh8iaomEuX7NafQIBzqeDxvJaoTEFCgGs9iT76DNszXU3o+BuaRMhgUPIUKff3q6jNjqGSCKJaqkIzYhk23f4GGTaNDM3IRIA8P5gLmsUV3PN4lkgwLlUEEm/++e5zTCXaSbizCvD102h6/f7MTk5CT45ig1D0RxWG1hdXcLdO7cRjUatcycajXZdXrtCtFar7TF8BvYKPo9giwNThcqmScxE/ZAkCTdu3EC1WsW5517A9R0VDSYRgifAc2NRVDbL2BowyYLFUw9WLE6Yu6O6EEHmiaWqqueCzy3dw2bw3OWmls1mce3aNUxPT+Po0aNtT+5mlm4TiqZZYg0OutkyoLdjX9ncsWYsAeBoIojDDoaORUVWMbdVtr1nNCjibCbsmrKw3VCsoeyUv3uxzS6hEwfHbp1GdaXy1atXQQjB5cuX8bCiAtCPLacFzHBFG024LbEk6zNhFYcw43giAN9u9M/gTEegqBjCj62GgqLUnHj8jz/3k6hV9FzjYj6L//arv4gP/dTP42jch9gueev5fD6Mj49jfHwcmqahVCohl8vhyZMnuH37NmKxmGX63G6AfRhwa613MlH2Ci8q3Q2nea5jPsHLPpdlPReXjUq7kA50dDDINVTroXMkwFvKbluROuSPmzUKdmuvUto5R9dk0e4aHoj+QBA//u8/jU/9zEfRqNfx3g/8AE4dOWSb/TMhU+DLuTp8nJ75m/bzSAcE1/NOUjVcydVRNogB0SieOx0L9nZus1SwFVZtyv5eyAKWDT46lkR6ZsTyy8zn87hx4wYopVbsW7uxCbccXWBPtMFir+DzCKd3XbHRTJOI+XiQegUvXbuGaDSKg2efxZe37RFpUZHHpfEofDyHep+iCDc0VA3rTMrCuMcYMXN/2ok2AHhuC1ZlnW0B9CdW07/LC8NHKcWTJ09w//59nDhxAlNTUx3XZbYrWXairGjWhX48rLOLhYaCVzZ30FCbMv1zmQjGw+0/n5VyA7dyFYu15aCnZcx2ENR4tYFpbn/zZ68zfJVqBXPXm0plcBxWNgrWNk459mmoBZ+NaQTzs7sw41jMj6l2qRR9rLvbfhBCEBF5REQes1GfZcmxWJagyFJzoymgKgp2FP3GJ1r2GJ3zfnvY2pa/cByHRCKBRCKBQ4cOoV6vW6bPT548gSAISKfTUBRleC14eDdR7gdeWro2D7ygaD/OPRR8RUnFXL5mjQaYUWndBvmdatJetrlf2FvIreyts6XLoq5quFNo2KxrBAIcOH4KP/YbnwYAHI/7MR3WZ1rzDQU3txstWe6SRhn2r4G4qF+DM34eMZFDw2D2zIcyn1E8RzsUz6pGLYGMQIBRpuCzG0O3eb9LS9cNDVWzZgn9HEHKKEBZv0xKKXZ2dpDL5ayxiXA4bBV/8Xhcnzvfm+Hrir2CrwNsM3zMga1q9pm5uFrHl750AwcOHkQtPobr2/YW7mzUjxNMzFa/Klg3rHhI1nCDeS66eeQRQnqaA3OKNcxlcY4i2QlVVTE/P49cLofnnnsOiUTCw3Zz+lMzs5tF5oK5L+LHSrmBG9mKxaAFeQ7PjkXaimMUjWI+X8Fyudn2DQsczo9EOho3s5m9UFVPmb12m5P2xQy7fzdvzePwvn04ePAgCCFYq0gtBa5tHbvE8JloqBpuOSK4vAozdht1VffxqyoU3/Z9/wwfe993QpEk+INBfPO732e9TmZukgQNJHyG7YtfQFggngvWXj7lQCBgG2AvFArIZrOQJAnz8/OW6MM0r+0VvZoo9wO7Srf1M6oqmmXbEeIJ4j7OZllCu/jw5YyoNPPmHRU5XEgFumYYSyq1FKcm42WiU3LFIKgpmsWgmvvqhFtr08nqmZgIChgNCLb7h3kd4AgBTzjr9QmRw3hIRK6hz7SyxY6paH+0oxdrFE1Wzs8RXMwEu56nnVjadrNyzv32wvCtM2bsE20eFAkhiMViiMViOHDgAGRZtsYm5ufnoaoqkskk/OkxgIRbtqtarbbMgv9NxV7B5xGEEPCGslVh/N4Ipdi4N49TZ87hgeJDiSkaCIALI2GMO/zghlXwUUr7aucCznZr64nrdRs1SrFsFHwEsNmbdGL46vU65ubmAACXL19GINA5s9ZapssMn+mLFxI4bNUkPCo1P5OUX8CF0Qj8bW4YJUnB1a0yKsxA+1TYh1PpcFe7Dzazly/nwXMj3be/R9UrABw8eBCHpsat35e6qJGHKdqwMZIAtuoK5gt2Ycb+sIjDsd6FGcOEG+N49tLX4lf++K+x9PA+jp86hTcf3ad7/jlukhT6vNK2JOE+JD2D2m8IP/y8p3jDXvec4zirRZXP5zEzMwNVVZHNZvHgwQPL9iWdTiORSHRlS/oxUe4H3diyNQfLRgixP9h0YPjWazJubTcfYJM+HudS3hIk1mpN9fFEULAdi16tZHoFO0832Ubp7GzpNlQ9LYNl9XwcwfG4H6NBweqUmGB3nbW5mQ6LmAiJ2BduRhnm6rr6l1W0O9lAH6cXWSb71+67YD0UnapZLwW0V4ZvtcN62kEURYyNjWFsbAyUUpTLZeRyOawVikBSL/gePXiAm0/v4+u//utRrVYt38xhIJ/P4wMf+AD+8A//EBzH4Vu/9VvxC7/wC22Lynw+jx/7sR/DH//xH+Pp06cYGRnBO9/5Tnz0ox9FPB4f2nZ5wV7B1wNMZWtDo5bfm1At4PTF53CtKENlItKCPMHl8RiCLrT5INFlLPINxTq5UwGhp4QOJ/vmnMXwar68WZOttuloSESAeXJsN8NXLBZx9epVpNNpnDx5sqcEAzeVrvVvgK3Y2xfx41Q65HpRMovl20w8Gk+AU+nOnnwsWJaXL+U8vcc5m+cGTdOQy2YBXxQAkEylrX+rKiq26vqFP8i0z23rGGbhRSmkRh2aqmHdx7XkhZ5K+l0VfsOAV6bS1QpG0FWoXyaTSI1PIsQTBHgO02HOapGZ0VhbjmisukqxVJWxVJXBEd1qIxMQMBLgPXnV9YNAIIBUKoV9+/ZBURRsb28jl8vhzp07UBQFyWQSmUymZX5pEBPlftBphk/33mtVdTpk5q7H51JFb0ObGA3wOJUMeM4S71Q4sD6Ww6p9nd57E23Mj02Gj1JdyOJstY8H9fhBc+7OeU0wE4U6iUPYKMOj0JnHlaqMx4wFj4kdhWJnR2f/RA5I+/XWb9ovWDOPLcylY97Vy+fpRbSxI6vWTGFc5PrqDhBCEI1GEY1G4a/KuFXQj6HNjXX8qw9+EKVSCYQQvPjiizh9+jQOHz7c8zqc+Af/4B9gbW0Nn/vc5yDLMt7znvfgfe97H377t3/b9fWrq6tYXV3Fxz/+cZw4cQJPnjzB937v92J1dRW/+7u/O/D29IK9gq8DWvN0CaBRS7QBABOjo7hSsBuMjodEnB+JtH36EQRhKAWf12QNN3hJ2/CyjUsdtsGN4VtdXcX8/DwOHz6M2dnZnosTN4bPRJl5sj3RYfZONuLR1pkLdszH4/xIxHPRzBpuRwQCqV7p8g5j+1nmwaUhKMsy5ubm0AgkrIKPfdXyjnv7nMUwGb7f/vf/Dv/6//oQNE3D//Y978c/+OCPANCH4k/EA7sSedYLNmoKbhfqtpuoF8aRY+0x4n5D+KGbPm9LqvWZaxSGZ5qKhSIQETjL9NmthTcMCIKAkZERjIyM2BmMtTVrfimdTiOQzOCxLPRtotwXOtTfeampmLapOm3vtxd8XqLSuqHkKBwiorOF2vx5WEdroY2C1QlN06BxepvWbDkDdlbP9nrHB2xeQzedLdZO8Y+ars42lxTk9Rb3tqTZ2D9Z09m+dWP2LyZyyPh5G0vsFnFmbgdBe4bPS0t31RGlNijY+9ib3vi38ODBA8zNzeEd73gHXn75ZZw8eRL79u3DN37jN+Jtb3sb3vSmN/U823fnzh189rOfxZe//GU8++yzAIBPfOITePvb346Pf/zjmJxsdd44deoU/tt/+2/W74cOHcJP/MRP4Du/8zt7ip4bBvYKvh5gPm1S63fgacVe7J1MhTAb69yeHAbDJ6ka1o35MbEHsYaJbgpaL3m6NUXDptFmCPIcRhyMgo1F1DQsLCxgeXkZ586dw8hI9/anGyzmUdPw+T/8Paw9fYxn//bX4+CJ0wD0CLwLI5GWbTGRr8u4tlWxYtAAfcbymVTIM5sA2Nm9yQCPRY/92U6ijUqlgitXriASiWB6egoPDbbSZLkopbY5w3ZM5LAYvs3NTXzkR37IWv/v/doncPkb3oE3Pn8Bh2O+vsPahwFF02O22LbaIFYwYYFDOOLD/oi+7JxhjJutqzYfxrKioczk/VrucgPMTHaz5zEZjNnZWciyjGw2h8dVBeUaBxD9vQQUhyMi9g+Y2NN1W5mCxLkam1ijjWiC0qaIgVKKu0U7O+kWldYN3dqCdlZyOJ/NahsFq229lKIIAdnEFChT7I0FBTwT87s+LLUwfMRcX2dxiInthi54MYufuMjhfDpotfXrqmYl2eQcs38lWbN5NQL6PU5SNdsMpXm/6HT6q6rasZBhLXQ46EznoHDOFnIchwsXLoDjOPz6r/86Dh06hD/7sz/DZz/7WXzgAx/Av/k3/wbvete7elrHSy+9hEQiYRV7APCWt7wFHMfh5Zdfxrd8y7d4Wk6xWEQsFntViz1gr+DzDFVVIdVrAN8srNiTReAILntMzTDn43oxNnZipdL01pqO9K6+6yao8NLSXWaKnmmXGw27jkePn4AUtnD58uWBFFPmdn3sIz+On/+5nwXHcfjdX/l5/Jv//Ac4e/4Cnh2LurJ0pvnyvULNugGw8Wi9wJnZOx4U8NAjo2Zr6TI/53I5my3NQ8a70dzebF125PW6swrDYPgopbi5stlSjOyUCliq6lmgKb/OdGV2qdXZrqVbMOLB2DbsWEDA8UTrvJr5Wy/lmMARjAUFjAV125cdWcOWYY5bkt3no2QKfGmrihHD9DnSQ94v4L0QkcDjqRBDOdjcDr8mQ9x8gsXiNnKG7Us6nUYkEhl68dduhk/WKDaNG7hIdAbYeo9LS9ctKu1ozIf9LlFpnaBRajH1HPRiqvU1zZ+HcZQqHRSsJhqqhoViA5tCM3JRNFg9t21021ZAv4ayLdYgT5Bowyzn6gqubdetZSR9HM6lgrYHM+dYQ0FSDeNn1dYhMXGvJOFeSUJM5JA20mysueUOx1a3lm6uoUK2LHSGoZJ39+GjlFq2LJFIBN/8zd+Mb/7mb7aCBXrF+vq6LfkJ0Bn5VCqF9fV1T8vIZrP46Ec/ive9733dXzxk7BV8HlCr1XDt2jX80V+8hD/5w89gZHIa3/1DP4rkiP7FJ/w8XhiLQvCYmmFS3f0WfC1ijYg3wYNtG7q0dLuJNiilDvFA64Xa9gDLEVy6dMnVeLYXcBwHVaP4zd/8TQCw2rtzn/sf+L63vwmiS+HhJR6tF7Rk9hrr9PJ92ofJ9WUsLS1hYWEBx48fx/T0NABHIofx/Xht4Q+q0tUoxY1sBbXEBC78rb+Dq3/5pwCA2WdO4PjF5wHox8xWXdXbVEVdTWnGm3UaBh8Ebjm4PDFycIPDsYJxghCCmI9HzMfjUNQHSTUTP9rn/T5w5P2m/XzHBzIv31VnE+UwuOmklVxg2r6YuaWZTAbJZHIobEK7gm+jpljbNR4S244uUEqhgeBavhntRQCcSPj7itTaqquQjcWPBt0Lh06sZD9oaa86Frpe0+cRWbJsLKALaLqNQLS0dOFNHLJVV3A937QCS/t5nE0GOh53HCFI+QWk/AKOxHT272a+joLcWviZ7B977lFKW9g/E908XL3MP/YKN/VwvV6HpmktggrTicLEhz70IfzUT/1Ux+XfuXNn4G0slUp4xzvegRMnTuDHf/zHB15er9gr+DqAEGI55j98+BC/9OMfBgDcu3YFWytL+Inf/n0cigfwTLI3CwXzRPCqZHJiu6GgLOsXy6RfQLQPI1VbUoWLeqAbw7dVc7JNrdtQ3ikB0P8+NbVv4GIPAFQQKFOHkZ6cRrGwDU1Voakqnj9+2LXYc41HiwdwOBHsW1XqVMlynL5sL3MrTtHGwsICVlZWcOHCBaTTadfXUVA0VA0bxkXS1yWvdxCGT1I1XNksI99QQAjBD//yv8fqy3+OOKfi69/6NlQ5H7INnRWQmcNmR9awI2t4VJbhM4qdEb+AlJ8fSuu3qmi42UcOLgh6o/e6wMdzmAxxVt7vX25U4HJ/bMn71dnQ7nm/bvBqomwmF0xOTlq2L7lcDg8fPkStVkMikbCEH/2GybeLKbN54DkYLJt/IwgW6hwqmpHjSoAzSfccVy/otF4Tw2b42vn9SSrFnWIdm0z7lqMqUvUizkzOeFq281JMQLu2j53q5tEAj9PJQM/XN5EjFsvHE+B0MoCC1J79kynwFxtVRI3Zv0xAQNx42OvE8ElaewudQeDG8FWrVQDo2lX65//8n+Pd7353x9ccPHgQ4+Pj2NzctP3dzNYeHx9v804dOzs7eNvb3oZoNIr//t//+1Duh71ir+DrgOXlZdy8eRPPPPMMvvSlL1lFkKaqeHDrOgBgvSqBUmAsJCLp98YysAVfP1+6LUasBysW2zbYGD73Gb5ODJ8zyowFpRSPHz/G47UtYFJXRQ1DQrAjqXgl3wDCcXz/T/0ifvaf/SNsLD3BG9/+d/E9//Af2l6rUYq72zU8YuLR/DzB+UwE6QHUi2VZRd7I7A2LHJJ+AYqi/+6FqWEPj51yGcrWFi5dutRyQXIaHvfit9hvwVeRVXx5Y8ca7OYAPDsex/h3/H3rNSkA09CP3e26bAkayo4Q+NWqglWj2En6eYv966XYMVt/KxUZd0sN27D4QSMH97W0guEIMVSUFD6O4PlMENmGgq26im1H3m/OKJLvliSEBIKMX1f9tosJM9GviTJr+3LkyBFUq1WL/Xv48CH8fr/N9sWrUt6N4SvLGopG1RsROESdognmZzU+goqmv1MgwPlUEIk+b/gNg20F9OjDVJvlDHOGT/cZNG2gmgrWjZqCO44c6dEAD19u3YhA8wbnJaSsUGt0IeXjWx5uVqoybhea1+LxoICTCe9+rCw2a03GesxIshkJNNm/nGFpxBa0QPNhb9GYa037BVR9EWice3mx0cFCZxC4MXyVii6m62bLYoqkuuHy5csoFAq4cuUKLl68CAD40z/9U2iahhdeeKHt+0qlEt761rfC7/fjD/7gDzzbkA0bewVfBySTScsQ+Gu+5mss13RCCE4+dxmAHkz+SK7jUaluMS9jQR8yQbEts0EI6Vu4IaualQsrEOLJ7NcN7M3CzR6kE8PHsk1+3s42sWbKz5w+j1tlzVjHYDTLZlXC3FbFaqVOHTyMn/v9FwEAcR9vK5yrRjxawWM8Wi9wqpLZ1oCXIsvO3KFtm9sWwUZpT4ke/dzUcjUZV7bK1lyNjyO4kAkh0UYAwfM8MmEembC+3zVFxWZVLwC3Jc1W7OQbKvJGsRM2ip1MQEDCx3W82Ksg2I6MYJ2x69iNHNxhgMDM+/VhXxid834ViqeKnvfLEwAjM8iqHEKqZvlFDttEORQKIRQKYd++fXqxvr2NbDaLhYUFyLJspRak0+mONyO3go9loNxSVmxnvqAf617SHrqB9Yrr1NIfpkrX5jMYFCFrwEKxbvueRE4fMxgLCLi7qYD08FDvvE5u1dl2rv17X6pIWCg2RVy9qpudcLaOWQR4DlNhDpMhAX+yphdRfo7YWEFAn2vdqCtAYhwLFFjZqursn19AzDjf7erc4ZUg7Ri+UCjUVyfNDcePH8fb3vY2fM/3fA8++clPQpZlvP/978e73vUuS6G7srKCN7/5zfjUpz6F559/HqVSCd/wDd+AarWK//Sf/hNKpRJKpRIAvdDsxZZsUOwVfB0QiUQsz6uv+7qvw8/8+m/idz/9aWQmJvEvPvRhwC9YbA+gMxvLZQnLZQkcgHRQxHhIxGjQZ/OnA/o3X16pSFaBNtWHWMOEF9FGu+1bbsM21et1XL16FRzH4Q1veAMqlAPKOwDae851A6UUj0p1LGzXmn9UFYAXmNc0/2m10sDNbNUqDAmA48kQZmODqxedJtNTBrNpXky8MHzFYlHfYEIQCoXbMrzsplZkDWWDOkj5u/st9srwrZQbuJ6tWN9pWOBwcSTsmY3jOA5hH4cDPhEHAMiqimxNtoqdBrMpFYWiosh4UmmyASMBuw8YoA+gPxYSUElzG6ZCAo7G/D22iIfc0/UIZ95v2cj7zTYUm5ehSgGEE3gsAY83qoiJHEI8aWmZD9NEmed5ZDIZZDIZPYu4UkEul8P6+jru3btn2b6k02nEYjH7zdLxUbJqSwK4ev9VHT3vAAc8m+keldYJuuefe2vViWH58Dl9BkWO4KWtqm1cZDTA45m43yrcvfjR2bfVDpPBdHrvPd6RcH+nWezNhEUcjfWmbmZRZyLOOglD2Ot4WOBwMRO03put64bmLBvtZP/iIm+NZURFbqCCv3XbWr/nSqWCUCg01Pne3/qt38L73/9+vPnNb7aMl3/xF3/R+ndZlnH37l2rnXz16lW8/PLLANDiA7i4uIjZ2dmhbVs37BV8PeDr3/HNOPi1Xw8AODIWRSYoQlJ1a5KNqoStmmw9ZWjQ59y2ajKAKuI+HmMhH8ZCIqIi31fB5xRr9NvOBbyJNtyKhlbBiL4NhUIBc3NzyGQyOHnyJDiOQ40pht2Kym5QNYqbuQpWKs0L20hAwFbVvl0qKFSNYj5ftTFhIYHDhS7xaL1gsypbF/exkGhd1L0yfGtra7h16xbIkQug6FyGsLFVuUbzxuYtr9fbxY1SivuFGu4ziuC0X8C5TGigwkLkeUxEeExEdMZ3R1KxWZeRrasoMXcDkw3Q2REjA9TPo6pqWK+pgFHsiRxwIh5wVUO+HkAIQVTkERV5HDDyfs1iOFdXbIWdPhzPvBfAvrCAg9HhJmaw2xaJRBCJRLB//35bbNXNmzet0HqzAHQKIHKNpm3NSIBvESXkGgqesNZVcgOn013mLj2gJGtWNmzCx3V8OLHPHfa/zm3GZ9DHEdxhmGeRAMfifow7mEZn0kY3OB+Mnd57lFI8dAiX+rGycWLN4YnXblnsvcI8HAM8h6kQhyljrrUoabj+8AmE5AhqtLkchQI5pusiqRQPSg2kDU/LQVu7jNNWC8M3TKRSqbYmywAwOztre/h/05veNLSoy0Hx+ryCvkZwyxP08RymI35MR/xQNYpcXcaGUQA2mLOjKKkoSjXcK9QQ5Dmo6SnkGyrilHo+0IuSih1DrJHw8Z4sYNrBJtrowZYlV1dQNSj8dEBAWOSxvLyMO3fu4MiRI9i/fz+Tpdt8X68MX13RcGVrBwUmguhIXHfeN9schg82FI3iC2slS8gCAJNhH057iEfrBU/bzE6abd12JzWlFA8fPsTi4iLOnj2LuRoHhdIWRR4L9pAws4IF4s1v0QvDp1KKm1l7MT0dFnEi2b+YxQ08zyMR5JEI+nBY09BQNWxVJWQbKvKS5qJytW+3oDTw/GQCIRdRkBeYe/KVcbnVIXIEEyE9GotSis9fuYbovkPIqVzLdlIATysKlioKEj7eUv72kvfb07Y5YqtKpRJyuRyWl5exsLAAMvMMEIwaG0fbChgAfa7t5nbd3gbOrsI/OnjawUqH9TrBHlHcAE1dthXJsnojAR7HGVbPtm5N6+l7ajf6MhnUj5V7Jcnm/Xo46sOBaH9jPSZa2NJOtjFd2FKOECT9PIT8Kk5PpRGIRI0HG50BZCmOhkaxWJZts3/pgC5uaheF2QluM3ymJctuelO+nrBX8HWA8yBhiwfFpYLhOYLRkA+jIR9OpUIoSSo2qhI2ajJKzJNNTdWAaBoLdeDB0wJGgiLGQiJGg6Kr0tSEPTd3sKHPdmHYJtq1dG2zZGEf7ty5g9XVVZw/fx6ZTKbtOnqZ4Ss2FLyyWbYycjkCnMtEMB4S8ZerpebyoV/MGypFQ222Pk6mwpiODPbE60RNUQ22VjeZzgTsN5l2RZaqqrh16xa2t7dx6dIlRKNRkKfbAO2cpcseBebLJiPezI672bKwSlwTx+IBzA7IEnQDx3EIchxm4gJmACiqinxd1hnyumZjukwogh8vbdWQ8vGWx92upUi8BqAA1GAUWbX5uRPo7bKqqlkPShQ6w7QtqbgPCUGeIBPQY7G85v32CkII4vE44vE4Dh48iEajgau5KszS4EuvXEFj33GAEPg42NSWzqg0C5o68DGm0mbMGEd0gUEnDIPhqyqakUjRhED0WT0nq8ei55auyzkQ5Anios4orjBF57GYDzM9+ha6oSRrqBpPXkkf15F9dZuTc4PpWOBn2L+tuoxref2YEIjdx9LO9uvRiGkm0cbLQ6i5bRya9+7dYPhez9gr+HpAN2UrC0II4n4Bcb+Ao0k9A3WzqjN/ubpi3cQVSrFWlbBWlXT7hoCgt36DIkLMfIOiUaxWmifLZHiwE70b+8bzvKU+NWFP9wBWFm5CajRcVaZe1uGG1Yo+T2a+PsBzeHZUb8vm67LF4kV5wNHZRUw04tF2YaCfTbjY52YybeRlsmg0GpibmwOlFJcvX7bmQc3LaadDyO0Gss9jfF6nG2pFVvGljR2LpeUAnEmHMD6EaKNeIfA8YgGCJxUVMm1+mTxgYwLYeDMU9ZtBJmC3gXitMAhzWJE13CrUoSSbdg4xUc8ADgscVCbvN+vI+62pui/fUqWZ97vbBbHf74ffr6FsMM7pg8ewquifvby1hmurO0hnMqiFU1hiar2YyFlzWwT9m82bcKpJuz0E2drQ/ayvruCWg6nMGBF23ZioQWf4AF2Qcrso2UQVJ+J+TIWHc87aPfG6sKUuc3JucLMcW681z+oTiQASPs4yfXZ6Wu4oGnaYRJuUofLvFGNn3pPZf65UKgMZ/X+1Ya/g6wF2Vqy394YEHrMxHrOxAGRNwxdvLYCLZ1AmosUWUugt01xdwW0AUZHXVb8hH0qN5nzgZKTXwfVu++KN4VspN01fUciC5zhcunSpraFrN2EIC0op7hVqeMDMkyX8Ai6ORCzBC8su1jT7d7A/6sfxZKhvEUu3bWPVudMuT9VOVm1nZwdXrlxBMpnEqVOnbEos/YbXpaXr+D0m8p6Vqe3Yxl6VuLuN9aqM+e2atT0AMBv14XDUh+XVVdxf2URsaj8qnAhG52DdDBbLMkSOIOPXi530kDz/+kEvNYybiTJAcTDqxwHGaoYnBosXEEBjPlQVii0j7q3QJu8XxWbe74jBjgyzIGaP2CIE6y/nD0yhWsjjSR2oMYfTGK8g7PM35xIHSBcysdpBTeoGmw9fD6uWNYq7jvg+ADgYEXHQIxveq7m+WyekKKvINcyCGTiZ8A8lexbQr8vrPbClXhg+M8WCvebZklg4vQ3OEWLztCzJmjXbuuNItNmsq5YdjDPP2jxf3BJAqtVqV0uWv0nYK/h6AHszUfuVnQIQOQ5hpY4UrWJmZj+26wo2ahI2qrLFvADAjqxip6jiYbFuKwCmBmT3ADtb6SVLl1Jqm2GbDPA4efpCx4tZtzlBE4pGcT1btiKSAGA67MOpTNg6eWVNw6rJslEKhflECIBT6d17itPZlc4m0+zM4+bmJm7cuIHZ2VkcOnSo5TMyf+3M8Nl/d2MV27+39XXLO3XcyFWtG3bEUOIOOjzfDxSN4k6hhhVmFsnPE5xJhZDy83j48CGWlpZw8exZpFIpqKqKQkM2VK4qdhgqQNZ0lehazfD8M+fcAgLCr8G+dYObiTKR6jgR92GywywWIQRhkSAs+jAb0fc732javrTL+xWJPmtrGuMOLPxgjllTNBEXOSTDQazKGdS4ZnGUqBdRXn+CrUgayExZ7x+k4KspGvKMmjTZRk1q22SbLYu3dW/VFdwuNGyfK6DbAnkt9oDBW7oiga3YO5Mcrnhpq94bW+qF4TOJAna/bUkswVb/TI4QJHy6L+Vh6NZfOeMhJu8QNjnzrFN+HjGi4dOf/EUsP3yAr3nLN+DrvvvbAewxfE7sFXwd4Dyp2ScHpQtj1Q2mSpcjBOmgiHRQxPEkRVlWsVGVsVGTbIIFdm0vb+xgJKAzf6OMWrQX2Ng3lz6CU7SxXW+me4SJhlNHD3XfRw8t3aqi4pWNsiVGAYDjySAOxAK2z/9JqdFkQywGRH+qo+g/ps4LnMkabjBZtcePH+P+/fs4deoUJiYmXF9rtXQ7rNP5b70U+SzDt1tK3H5RaCi4ka/ZHmzGggJOJoMQCDA/P4/t7W0899xzVhwSz/NIh3ikQ8ARTUNdUbFZ0wvAvNPzT1KRl1TcK0kI8aQvdfhuoZ2J8uaja4ikzvS0LNGR91uSNav1y6aRyBRYrykGi9NAwsdZ+ce95v0C9vaoifGg0CYqbQr0wCTu5itMi5fiypUrVuJHPB7vqSDyEjPmhE200eXlbqyezsfrmAp7W6eJnlW6zu0x59IIcDYZQKbPRJJ2YNW5Tp8/N9hVuu3nFgF7wbdW65wW4oSfSbShlKJosH+5htqSZ71ZV/Gxj/wI/vh3PgVCOPz57/9XnMpE8I53vAO1Wm2v4GOwV/D1AFsbdACGD3C3PSGEIOoTEPUJOJwIoq7oli8PijXUmBukRnW38o2aDOT01udYUC8AIx5nmtjWZ7eWrqqquP50DfDrN+DD6ainfWS3wo3hy9dlXNksW0/RAiE4PxLGqEOJulWTca/A+PBRikkfRY2I2DaYEor+5nO6oaFqWK/qzKKPIxhr00ohhGBxcRHFYtEy624H8/vpJKwoMoKKiMh1FPO4LZ9SCtXIxF21KXF9ONFH7NKg0CjFo1IDD0tND0ee6MX9VEiEoii4ev06FEXB888/b807OsFxHEI+DrM+EbNxXfiRrcnYMm4GdeaUqjJ3p7pKcT1f0+fc/PzABty9oK2JctKPtF/A1oAPK4QQxH16y/9Q1GexI1suvmgFSUNB0vN+A7weazUSEJDydc77NeE8Yjnohaxpt8MBOJNqRqURQiCIImBaC1GK2dlZ5PN53Lp1q8X2xedr/2BDafeYsXbvM9FpD7fqCu4UGmgw1/aUj0NFoWhoFKSHdZroVaVbLBawcHsBE7MHEU/pUYs80RNJkkOKIDPhTCpJehgZYW977WKBnQVfVdEs78mwwCEm9nbuEQf7Z+ZZ5xhboyt//idGK1nP8H3xxRfxjne8w1Lp7kHHXsHXBexsFnuP6HWGzwk3UYQTAYHDZNiHO3nd2ZwDMBH2IVuTbRelQkNBoaHgbqGGkMBhzJj7S/rbx9Z0Y9/MgrRWq+HKteuojutWCr2kexBCLOsU5+f1dKeBW7mm2W9I4PDsaNSWC6xRinvbNTxk4tEIgHBuCZP7JrBIfcxrBzNVbQcvkWayLKPR0CmMy5cvd50ZMZfQyThli3kijoq9naaEEKggeHl9B9uvshLXDVVFxfVcDUWmjZnw8TiTDiIk8KjVapibm0MwGMS5c+fazoS6QeB5jEd4jBuef2XT86+houiQ/bJzQHGRQyagmz73w3R5RdZoDbLnq9NEedgeXX5H3q+Zh5ptKFYbFtCLYDPvl4MegWfORrXztXNuKiGwij2BAOdcChPq+G10dBTj4+OglGJnZ8eyfblz5w6i0ajF/kWjUdv3UpC0jjFj7WCzhXH5mmWN4l6xYZsNFAhwNO6HnyOYy+vXn3QfdiG9tHTv37+P73rL16O0nYfPH8C//H9/C2dfuIwL6eCuJMuwLGanpBIWXlu6HNc8p9YceceDnmtmnvVoQMA9UKzUVBw8cQr5zXVoqgpVVXHq1CkAeks3mUwOtL6vJuwVfD1A6EGE0A08z0OW5a6vW6tI1hP6VMSPM5kwKKUoNFRr7o/1n6sqGhZLDSyWGhA5glGD+csERVsLz0vShiRJeOmllxCcnLVMcHtN9+CInodqXig0SrGwXcViqdkmTQcEXBiJ2FiXqqxiLlu2tbUB4FgyiK31unEhdc4IDvemTT1EmlUqFVy5cgWEEBw9etTTgLC52e0Ooaqs2oqjQLtH6TZogEMhtQ9aozmMfSb16itxKaVYqcq4s12z5eAeivlxMKYXz6VSCXNzcxgdHcWxY8cGikDieR7xII940IdDmgZJ1fCFjYqN4TKhe/5JeLijs22ZQG9MVzeoGsX9koQl5mYnEOB4wu+aRrFb4AhByi8g5RdwFH5UleZgfL7BCD/A5P2CjcDTmRXzeuH8KM3vtVNUmu04Z9hMQghisRhisRgOHDgASZKsvN+lpSUQQpBOp5HJZJBKpWw+eF7ajyZsog3HNcKtIE8bCtwAz+HmdvNh04tApGXdPRR8//YXfgHlUhEAIEsN/M4v/gze+0f/a6hpFCZ0ttRutuwFNtFGm+utaclirYcpLMeHFKWmf291K8Xn+z72s/h///WH8fT+Xfydt38T3v3udwMAarUapqenh7LOrwbsFXw9gL0RuPnw9bQsnke9Xu/6uqfl5mtMs19CCJIBAcmAgGeSutXGpjH3l2csX2SNYqUiYaWiW76kTcuXkAiRuQi5FXz5fB7VahXPPHMcS2ICMIrKXtM9eAIo0C+6sqrh6lYZWaa1NRv143gqZCtA1yoSbmQrLXOSHICZaAA5Y76QY66DA34drthuKB0jzfL5PObm5jA1NYVcLuf5wm6JNuA+e8gWmebrvCJXk3BP9kET9GWKBLg4En7VlbiSqmF+u2b5pQE6i3smFbS2ZWtrCzdv3sTBgwdtht3DAMdxCHAceI5AUSn8HMGphM9o/WqoMHeuhmZnukwLiIzfO4vEoiipuLVdt7WU2SLCDa8W6xoSOMxEfJiJ6EVpzsz7rau2oscZgZcyWr9f/PMX8cpffwEHT5zG17z974EQgiBPcCEdbM8KOn5pt68+nw8TExOYmJiApmkoFovI5XJYXFzErdt3oB4+D3AceOgqT69wY/hkjeJeqWErengCHI35rTxgWaPYNK5VIultnda6Pc7w1RTNlpsLozuyG8UeoEeeVYwxoYSP8yxw8sLwsUXutqRZ6SSdLFW8op1yOppM4YP/9pMAdLbSXL8ZrbYHHXsFXxfYWrpDZvi6RauVJMViuKIdbDnCIo8DcR4H4gHIVtSbjK1akx2kgHFhVzCf13MMTbAnsaZpWFhYwOrqKnw+HxITU5hf082O432ke3CGBYlCKf5qrWRdZHRlbQgzjIG0qlHczldtamAfR6wZv8mIDyJHLFFCv8bOXtGJ3TNbUMePH8f09DReeuklz/m1rFLQyUtSSm2ef+ZrvKCpxNWXKCgS6NMF3HpMMDIygpGRESQSiaEFibdDtq7gZr5qS5qZCos4nghaKsClpSXcu3cPJ0+exPj4eLtFDQ8EGAkHMBLWj/GqbAg/Giq2Jc3GdFkWJ+huccJ+NxqlWDRir8y/c0YRMR1q38p6rWKXeI5gNCBg1JH3u1VXbIkn5mD87//+H+Dj//R7wPE8NFVFfmMd//v7vg8X0oGOrc5uLVU3cByHZDKJZDKJw4cP43GhgvtVo0tQ2MKXHq9Zc3/JZLJjAL2d4dOtr24XG1YhAugt4hMJv63A36gp1nvHQ63KUi/wMsNXUTRczdXwTe/5x3jpc581Wrp+/MN//qGe1+cVq7Z2rnfm0otog/Xgs7VzB2D3KKXYrKtYKLYqp51gGyJ7M3x27BV8PcBmvDwEhq9bwbfkyM31wgKIPIepiB9TET80SpGrK9ioStisypa1CACbz1GhoeJmroK0SLC0cAuyJOH06dOYn59v2YZeYV4+ZY1afmsiR3BxNII0k1axIym4ulVpiUeryioko71pKmRNBbFNFNLzlnWGrFGsGWIHdm6RUop79+5heXkZFy5cQDqdtrbJ642bfTJ2dqK3arKVMGJ7TQe4eRimAwLOpWPgZt6AXC6HbDaLmzdvQtM0pNNpjIyMdB2S7xUapbhXqOMxU7CKHMHJZNBqJ1NK8eDBA6ysrODChQu7Pl/jdsZwHIeIn0PEL2JW06CoGrJG1m9WUm2efzaLEw5WmzPtt1ucUErx5WzNpiBkTZS/0uHM+5U0/dphKn8VCrz0R38IwnHQjOvWS//r9/FzH/7nXdXeXkUTnZBVmlrZCwemQKsx5HI53Lt3D5IkIZlMWgWgc6yCVRYvliVrjhNoZfVYrFa9xY11QreWbllWcSVXh6RRTB44hF/+3EtYfngf4zP7cWB8tK91dt0mSi0LLA66Sr6X95roJNrgeR6qRi2hkkBgCXl6RV3VsFBsYKvufr803Rqavzc3bC9pw469gq8HEEKsg2sYoo1OBZ+qUSwbBQdH+vPe4wjBSFDESFAETVHsmJYvVck2I0ahiyieAiAjBzEa8mGHp1AIjxUj3YMnwGS4t4KPUtrSlo2KPJ4djVgpIuac3Hy+aj1Nm/FocR+PzxvsYkTkkTRagWbB59Xnrx+sVRrWd2zOLSqKghs3bqBcLreki3jJr7Vey/ysQU+WMOFs5+qvab9vbkrcfWEfjltKXB6jo6MYHR21slGz2SyePHmC+fl5xONxjIyMIJPJDJQ5uSOpuJGv2h4k0n4Bp9NBq42jqirm5+dRKpXw3HPPfUU8eXMcBx/HYVIUMBnVt7HYULBlGsDaPP/AeP41QMrb+NH3/yPcv3EVJ567jB/4+C8jHI2BADgY9WE24p0V+krL+vQxeb+5uoJbhTrGZw5Y/87xPM4cO+LJ2mfQM7OqaNg2qvCQQJAMiCBBvbg7cuQIqtUqcrkctra2cP/+fQSDQWv2Lx6P2x6Y2GLPjdUzUVGauc4RgbN1RHpBp5ZuSVJxNV8DGx8dikRx9OwFALvjOgAAW3XVsnsZDfbmzejF4sZk+DbqinUNHQsKPcf/6TPACu6XGq5zuAAwHRKwXLW3d9ntqlarlr3THvYKvp7BE93ba1AfvnZZtSbWqpI1JzgZ8vVky+EGQghiPgExn4AjhuXLn68UjBOySTNRwmGjpmADAGZPWVfr0aDYU4qBSilu5Sq2tt5oQMD50ai1HFnTcDNbxVq1WaxEjXi0qI/H7XzV+vtMpMlwNgu+5vqGPcP31OG9V6vVcPXqVYiiiMuXL0MU7W2QXhg+9uZOGYqvoWrYMJ68RQ7WjaDdYiVVwyubZc9KXDYb9dChQ6jX68hms9ja2sLDhw/h9/ut4i+ZTHpq/VJK8aQs4V6hbt0MCIBjiQD2M3nGkiTh+vXroJTi+eefHyqz6Akejw+e55EK8UiF/Jbn30ZVZ4WKMrV5/n3iJz6C+S+/BE1Vce3zf4ZPf+Lj+Mf/8qM4k/S/Zuklw4RKKR6UJDw1DLK/9R99ABtLT3Djr/8Sh06ewU//9E97Wo6tpdvHdtiZNrsPHiEE4XAY4XAYMzMzUBQF+XweuVwO8/PzUDQK7cApgG+erzwBjnRps686WpH9FORm4oTbewuSirlczSpk2PPdxG7ZZLKeeL0yl16SNkxW0+bx16NQqapouFOwG5RzsBecJxN++9yjy3btMXx2vP6vSruMFvNlw2dkt1u6toKjj1ZqNwQEndmoqRqgKDgYBCRfGBs1uRl1xQopqjL+fKWAsaAu+kj6218EG6qGK45CBADOj0asYm+7oWBuq2zzF2Tj0VRKsWKwXRx0ls3EbjN8JUmxGNCYjwfqFXzx6lWMjIzgxIkTroWQM1qtE9h3s4fRMmMBMxH24emOXgi7LbUsq/gym4lLgLOpUFufQDcEAgFMT09jenoaqqoin89ja2sL8/PzUFXVYkkymYxrgVZXNdzK12winIjI4WwqZLPXqVarmJubQyQSaYmZ+0qBrFFUFQ1VRUVV0VBTNON3zTbrxWJj6anV3tQoxebKEhoaxdV8HWlG+NHNyuO1muHrhKKk4lahjipDrYzFI/iRf/srqGtUb29nvDEntqSLHosYSqndPqTLHJggCBajnasruLVdg0qbK+UbVUyhilgoCSDWfp1GsUKg2+j0AzcDYgDINxRcy9et4ikucpY4jMVueGU2VH1OE9DV6akevf08J22IPqtYC/IEcQ+JKIDxAFmR8XBHsl0bQzyxiaBOJvzIBATcLjQ7UFa0Gtdc1h7DZ8dewdcjTGuW3RRt7EiqVSyxrcxhQlEUyFID4EXwoojjUykA+kmy3VDwuFhrUUJVZA2P5DoelerwcUTP+Q3qli9mIVeSFLyyUbbNC5qg0IuiR6U67m7XrEJG4AjOpMOYYNrWm1XZGs4dD/tsli0mm7ZbDB9bbMe1Or70pRs4cuRIRyWpM5mkE9hFmJvtzOudDPmbBZ9j33I1CVe2KrZM3IsjIcR7FNSw4HneEnaY/mhbW1tYWlrC7du3EYvFrH8Ph8PYrOk3UzYHd3/Eh6OJgO0Ju1gsYm5uDhMTEzh69Ohr1rqk0G92VcX9P7mPA+iNf+9bcfuVL4LjeGiaiq/7pm8BoN94WM+/mOn55+cRbWOM/pXS0tUoxSNDeGKCA3A45sNMWMQXNnXW3WtEGTAYw5eX1J5VnophibNclVvWeNhPUcqXcX3pqWX7kk6nkUqlLNY+32gqljOB3r33TJiFPFvwbdUV3Mg32fCUj8d4kMftotTy/t1g+NZrTReHiT6YS3sucXuGrxFsFtNeE1F2ZBW3Cw3bHKyf07s+Wcae65SRJbxUkax9iYu8VWDuMXztsVfw9QhzUFWlg8V5dSr4llgrloj3DFWvMNuTdPQAwIu2k5gQglRAtNg1ABgLipA0amPsJE1Xky6XJXAA0kERQZ5gudJ8MvPzBGGBR954X01RsZCvYavevJkk/QLOjYQRcuTTPt1pfgbOOLPdZPhUw8oGAAilWL87j3Nnz2J0tPMAdU8MX0tLV2c8TQVzyi8gzNgxsDN8LZm4IoeLmeFm4rL+aGzrN5vN4uHiY2B8Fko0Zb3ezxGcTgeRCdjZxc3NTdy6dQuHDx/GzMzM0LavHTRKUVepxdJVFc16aJA0ij9b3el5mSJHEBI46z8C4ElZgqxRvOXb/gFGR8dRvH8DX/e1X4NTL3wtsg3d9oX1fC7JGkqyhEc7enE+Ypgbp/x8T2MSu40dWcWt7QbKil14cjIRQMSYYTMP8V62ehCGj7VNmfLAXucbuq9ejWGDRNKMKBsfG8XM5Bg0TUOpVEIul8OTJ0+sh5p0Oo18KGO9t9dWJAvzAdC8fm/UFNzcrlvnbsbP40wqgGt5d3sup2fgMLA6QJsVsBMd7UQbqqah7o9bv3dLJ3FTtwP6fJ5G7Ypis9gD7PsSFTmm4GsuY4/hs2Ov4OsC15auAZXq6qN+4BatBhhiDUPl6GxlDgOmd9zExAQQDqMgqS1+cKrWjDDiAJzNhCHyHBqqhq2aLvrYqskWha7BngwB6GbBZzJhPMrtYOHqK4glU3iZO2yT1B+OB3AkEWx5UqzKqtUmDAkc0g51lzn/yP51WCrddWZ2kq9s4/LzzyEa7R4l1xPDx/xsvsNpAWNjAam7EjcTEHAuHdr1osFs/UZGxlHMVW03U1LeRkLegUTSkJjW79OnT/HgwQOcOnWqa7HcC1SNoqrqLdeKo/VaUzrJW9ojwDeLuqDAISzo/nshgbMNtGfrMuayVeu4DwscPvCudyIo/G/Wa6aht7S267Ih/LB7/kmM5x+B7m+nxkdQVyleKx5CoxSP///s/XmYZGteFQqvdw8RO6aMOXKsyprneTrnIK0oo604gF6wG5X20ogK14+r8gF6rzYXB/hAJkG+TxThCo7Px6De24rQDdL2cE5lVlVWVVbWnPMQQ8a4Y8/v/WMP8e7ImDPr9IHO9TznOVVZGbF37NjDen+/31qrruNlrVUx6SY88f59iFOOVckOc6bqFsVOk1V5dm8/mhbFs5qG1QZTmSTA6ZjtvVjSXPLl/BvHIZFIIJFIeIuaYrGIfGkXRSEFcBw4ywTqZZiB3rYv3cC2dDdkHY/KzCJaEnApGYRmUZTceDMOvmjAg76sa7rpkfm4yCEyghBlkAqfTDkYzsxksk8iSlkz8bis+BJgIgLB+XgQm02jK9mr65ZXCYyJnO8e6Fb4TNOEoiiHFT4Gh4RvSLR78QkjrsLcCl97lXBL1rz2Unsrc79YWVnB0tISzp49i6NHj+JzW1Xv31jyygpGssFWjmuQ5zATDWImGrRNWxUdmw0NG7K2p6WqmBS/82oHf+ejfxKvFh8BAP7i9/zv+BN/6TsQ5AmuZaLIdFlh+shPhwonx3HQdb2tpXswFb7laiuz99rsFGKxwW4Ww1T42smcbll7LGB83oiU4l6+gQ25mxL3zcKiFK+qKp635eCeS0iIx1MoFCxf6xewDU9v3LjRM1O4G+x5OrNj61Xdhzw+Iwm+ap1L8AZRD240NCyUWmMIiQCPG5lwx+uT53lkIjwyjudf07CN0V3PP1b4UVRNYHwWd2sUkabsVf/iAe59+W4buoWHZcXXRosKHC4lg51TM5z/D1XhY/48TCt4u2l4x2oy1F3xvKuaeFRWfAuRRMCuTIYFzqfM7UaiJEnC9PQ0aCKHfMW+/0SMJl6svsJjVUUikfDav4MSCPfevi4bWKww4xohARcS9n2N9anLhURPINNrX0fFKMka7fAnbXRGlWt1ZLp57xkWxYua5vu8BMCxqIjjURFPqpq3vwTApaQ/oaZdeMKahrsVvkbDjiQ9rPC1cEj4hgS7kjAt2v2s7wN3xcjG0ADwmQ6P4nvXCZZlYXFxEVtbW7h58yZSKbsdt9e42P47O0s2Eex81+E5gliAx1LZ9JG9IEe8i+9/fPI/emQPAP7VP/4H+IaPfRyn4rGuJtIWE2dGYOfXtqNzS7fHARgQO+WqZ/8QETjkov1j0lwMY8vCtmooKDYa+h4LGMq8VVk1fLYEZxMSjkXfn0xc2bDwoCijzKjl4gEeV1Ihp+0cxNjYGE6cOAFZlvHgwQPIsgxKKRYWFjzVbyqV8maZKKVQTdoicqYFWXeqdOZo83Q8QRuZ4xEWODxwDKADHMGt7PA2MJRSvK5pWGIqq7mQgKup8EARbBzHIRLgcDwgYtayYFgWiorhJH6YXjQUYFuBNBzPP4HAE31kpOGsMwb9XCsNHc+rmq86fiwq4mQs0J1sjrCwGrWl266UbUevqt6RSGtubJgKI7vNi9NZxI5NeLYvhUIBz58/92xf0ul0TyNzy7JAUxM+snckLOJsPOAtENnt5STeT/j67OswsBjxC4d9CFH6iDZMStEQ7PsmT2xnhnZ0Mr4eEzlcSAQRFTg8LrdyjTuRvb2iGhEvGe9P97nWbNqL9w+C/dMHBYeErw/2tHSZv+/HmsUleaZpen+u6yZKTiszInBIHYBYQ9M0zM/PwzAMfNmXfZnPlJS9YN3ZjLpuejN3RFMQ5TqvZncVA3d3ah654wlwPRvFeDgA2TDxrNzccyMkhINqAY9KMh6XZKTcqLeQ6Pny5Zu6V8XJhURIHdoBb8KWJZ/PY24tDyTt1IcjAxpds/s0SoXPon6C7c4rslt2yR5P7EzcYZS4o8J9GD1mcnABOwf3pJODy0LTNDx8+BA8z+PLv/zLQTgO26UydspVPFjbgbFRghiJAYEgdPAjteADnL/1yhK8gJPA0o79PDQppXhSVrBc91dWLySlkci26/k3GRUwGbUfSHcfLcIMxyEms6gyrN6g9oD9VtMAoCIR4JAJCshKPCJCZ+HHoGgaFh6VFW9xA9gqyItJCYkuCzEXo7V0Wxj0+2jovX3wulX1LiT2Gl37ZpR7bLPObDMmcF6FMxwOIxwO48iRIzAMA7u7uygWi3j8+DFM00QqlfIIYDBoX7+UUqw0LZjZI977H4uKOMVYJlV0y1OeJgP8nmrxQVZ4C6rpLaSy+1hAuIebQ2ehUV4xQJ3c9Zwk+AokukXxtKL62rQcAU7GbEEQAfCo3IpNIwAuJ6U9xtDtopoATzrOFsqyDEEQvO/kEIeEb2j40zZGfx+XDLHCjdVa+xzX/i74arWKubk5JBIJ3Lx5E4Lg/7r97em9+yDWS7AyEtqxVlexUGh4D+2QwOF2LopYQIBpUbyoKFira3jn6/44/su/+UU8vXcXIAR/6fv+XitUG/ZKr6gYeAxbiZULi9hlBB3d7GgOUrRBKcXy8jKePnsGcrpleNqpstgLoxov1zXTZwETd0h+SfGr9mwlbqRrZfQgoVsUj0pNbDFtkxBPcCUd9inGDYuiaVgoNWS8WF2HkJqCNJbAZwsKFJOCQgRCacBZY+y1lN4Ldp7OrdK5/402q0jgr/EMBpNSLBT9x+B0PIgTB3BdAvbDaG5uDvF4HBfPHQcAqIaFnaaGgmqipFk+ol3WLJQ1Dc9r9jHKOokfySA/sKGta2T7tKr63vtoxCYig1QsWy3dIVS6I1T4NpqdffBMi+J5WyuQVRF3+m7YNnSv726z2buiCNi2L6yavV6vo1gsYnNzE0tLS4hEIkil01DGstjUWwTuZCyA41H//rVXMNsXjAdZ1GVbx/2sbXrBvc922zef9x6zne2msScWLekYX4cFe7E8CNkDOsfCdZotdHN0PygK+A8CDgnfkPCLNkYvKxFCfEpdi1Ks9WllDoOtrS0vmP7EiROdqx9thIndBw5AoFmFZbVyTimleLLbxMtqq72VkgTczEYR4DnUNBPz+TpqTjxaUArhx//tr2Nx8TFiiSS+7soZcIRgp6lhS9Z9Hnw13USt4o88otT2O2x/ELnkar8VPrfVvb29jZPXbuFJw36T8bA4tBVDPyNt3+8yx327yVSPnO981VHitn4feGc8eqBK3G4oOjm4bLslIwkYDwkoKgZW65onkGDnZpCchAZAVnsfAwKbPPKmDlORoVbLEKiJdDSMiXQK6dRoA/IHCd2imCs0sOt8FgLgYjKEmQMSUFWrVczPz2NiYsJnVRMKcJgNCJgFYJgmSk1b+FHULJ8HmWJSrMo6VmV7jjUd5L3It262JYpp4XFZtWcGHUg8wcVEcKhOwkgqXebPgxBFi1Lf/Jar8ixrJh7tKr5jERc5XOwTX9fBVrTvNicGULASQhCLxRCLxXDs2DHouo5CoYhXTQsNhuxNEBVHJP9CwbQoth3iwhNbxNEw/AvGg6rwaSb1YskCHEF6SO89Fu4edto31bS880ugFpIBHqoTi8bOUQrENr524+wopXhYVp1qtn38ryQl5DqQPcOi2FH2Cnk6VfgajcZhO7cNh4RvSAjkYAgf4Ldm2WZ958KBfXk/PX/+HK9fv8aVK1cwPj7efftt1Up2H8bDATRBvf3TLQvz+YZPjXs0FsTFVBgEtnfdo1LDu7lyxI5HU00TzXMX7X0DkAmJyIREnE9S1N2ot6aGchtRMClwN98ARxrISiLGwwHkHCLmVfjaZuGGga7ruHfvHjRNwzvvvIOHVQOA/dnabWAGwVAVPua4u8eTI8BURMTSruxT4gJ2e/9NkT3qWJnUdRPLNQ2FNrNsACgohs9cuR8EZ54u1KFKJ/Fs6zUNy5pGqVRCoVDA0pNFaJrmZf1mMpl9t2OGfWYqhoX3Cg3PCJcnwLV0GNl92HOwKJVKuH//Po4fP97T11HgeeSiPHJRe2FS15y4N8VAWW+d7Ra1o7LyiglUbMViJsgjKwkYc9qgW051hZ0DnQ4LODMWHLpqum+V7gCvK6qmdx/KSDx4jmCpou6p6p0cC2C2S1XPt323KtXjd0rMNrNOm3BYCIKAkpRAgxruhiHkV9HU6vjdJw3P9iWdTqPOS973MS4J4DmyZ9F6UFf8VrNldzIZEvZFJN1nXqfDs8l4/CWIjo2mgadt511W4nEuHvQWJpZT2RuE7AHAtmJ4x2mCEfKw3Ta34n3owbcXh4SvD3rZshj7HBxjq0Ks79yoYg3DMLCwsIBqtYq33367r51Iu+K4fR+eO9YxDd3Eezs17yFIAFxIhXFsTIJuWXhYlH1Zrmw82stKS/Xa7vcXCwiIBQScSoSgGCZ+Z6O6Z2DfosB2U8d2UweKQCIoIERFaEQAYR4kw3wVjUYDc3NzCIfDeOutt6CDw44z4Cvx3EgP96Fm+Jg/m97NK4CHRdnXerGbkfuHRanPvkRuszIZZTKBpxYsRUYyEkIqGvaROrHLPF0ncBznpXmcPXsW9XodhUIB6+vrWFxcRCwW88hfLBZ7o+2Zmm7ibr7hVTdFjuBmJnxgMWlbW1t49OgRzp8/j6mpqYFfx3EcxqQAxqQAjlsWdMceqaCaKKqmz/Ovpluo6RZe1XWIxL7GFebiCHDESykYBSOpdNuu+35g24JxkcfnduS9Vb2ENLCtSIukdt/2fhWsFqV4uKtim1kYzQo6dtUa7rz1FlRV9YQfy8vLMGbOACH7/jwedMhP29V+UC1dtgXarVU9KFoLev/OsUIKAJDRSsEA7GvpXDyAcanVnrecyt42S/ZSUkehh4vNLkKebhW+UCh02NJlcEj4hoSvKrbPCp8gCDBNs6/v3CBwZ4ICgQDeeeedgbJKOeaO0jT27sNLjkNZp1jYbBExkSO4kbUtVcpOPJrMtCKOxoK4kGwpGLkBK6J1vaXOTAd5HI+H7OqfrPnmPsqqgTJEIHsMC0zWrjFgdc31IZyensbZs2dBCMGrcouUHhlR/Tqq8bKLqm744pXOJSQ8qyiOwXf/9zQs2oHMmWj0iAbrhxBPfBW6kMAhzBOsvXqB/PYWrl27hng8PtJ7dwLbIjt+/Dg0TfOyfl+/fu3NT7mq34Ns/e6qBu7mG141IsRzuJUN+wyw9wPXl/Dq1avIZDL9X9AFHMchyHGYEQXP86+s6sg3DRQ0C3WmnKJTQKd+snckYlvTjAL2/B6tpUv7Vpd0pmXHAXheay0kOdizcLPRwZIbXHgkZYBtBjiCzJAtT5NSPCgpXhqEO3/G1ZuoOLPawWAQU1NTmJqagqwb+EzevucQXcODz7+LZCIBKTMB8K1F+kG0dOu6iRrjVxfdx/lMKW2JNtp2raZbLcNuSiGT1nYmQwLOxIMIMC9qJ8gEwNWUhGyPZ1/TsBgXBeJVsIHOYhJZlg9bum04JHxDopPQYVS4Fb6VPr5z/VAsFnHv3j1MTU3h7NmzA4XeA37yusO0at2WphJOIG8F4d6yoyKHW7kYwgKHl5UmnrDxaMQ2Wmbj0QAMPGfHxpnNjoVs9W44AErDKKsmtpsatmUddb3V+mU92V5XVagmxXjYjnrrpEJbW1vD4uIizp07hyNHbPUcZWxggNFzi0c1Xnb/zrYQr6TDGA+JXmvXcvZTc0hdp2qdts9qM2A/7E6O2dWfkLDXB840TTx48ADNZhN37tzxKb7fBAKBgPeQtCwLu7u7yOfzePLkCTRNQyqV8gigJO0VFw2KLVnHg6LsVTrHRA43s5GRxypYuCMW6+vruHnz5oESZMAeC0mHeaTDduu3qhl4vKv4FL8uNIviRU3Hi5qOsNASfiQC/Bv1/BtUNAHYwgmvXc38vD3xY6Ttd9k0Gzc2MWTL07Qo7u0qnnkyB7tKlZUEbFetjp93W7Hg3gWOp6KYzL6FYrGIjVodSLQIX71WQzYYH/h+3gkbXUQUo4A9o9pbustMh8c90BJvGyi3V5MtSrGwq3hzfYOQPWCvWIN0KCawl+xhS3cvDglfH7RfsMIBtnR5nodhmFjTRxNrUEqxsrKCp0+f4vz585iZmRlq++yNrcistKYidnuxFm1VInIhEdeyUViU4t2dum+WLxHkcT0T9axVum2jm5JWMy1sO6bCAY74bEcIIUhKApKSgHNJoKGbeJnfxXq1CVNqrd4sAOsNDesNDQRA2rV8CYuQeA5Pnz7F2toabty4gXQ67fvcrngkGxIREkZbAQ9rvLy1ugyOcMjNHPFupAECXEqHwROC1XrLH61pWPhv69WRFhj2PJ1/jk41Lbyua772+dFoAGfjUlelpqqquHfvHniex+3bt73c0fcLHMd5809nz55Fo9FAPp/H5uYmnjx5gmg06qknh2n9LtdULJbfTHqJKwoqlUq4ffv2G682FFUTD3cV30IoLnII8bbKl01xkA2KZUPHcsP2/Es75C8TFLrOr/nEF8PM8A3Y0jWdiC0WBK2q3qik1FOWdvn3fn5/3WBYFPOlJsoaM++ZkjwRjGVZe8hau/feVEhASAggHA5DbOpY2G0tPtfXVrC2WEYymfTO/WEWNqz33qBClF5g7z/ud2FRipdVFVtNZgabUuREiouZ2J7rqJ3scbDJXr8RA7tl3F1p7O5be47uYYXPj0PCNyTa59729V48j10TUGlLHdrJd64TLMvC48ePsbOzg1u3biGZTA6/feZadB/+mZCI+4WG58UHACfGJJxLhlBUDNwr1H0PlJNxCWc6xKO1ttGf8K0x5GY6utfjjUVE5DEtcSg9e4lLb30ZPrdl56Oy824ULaHBoxIgGCo4heLyzTtIxf2u6ysdPPBGwaAVPkopPvG3vhv/7hf/JQDgj/2Fb8Nf+v4fAAe7BTdXkPe+Br2rycG2vFfWo4719jIsiqWyglVmNR7kCC6lQj3nFuv1Oubn55FIJHDx4sV9VRwOAoQQRKNRRKNRX+vXnY8SBAGZTAbZbBagLV80FpRSPKuoeMl8/1NhEZdS3c/lYeBWQxVFwe3bt/dVgewHw6J4Um5ijRE1CAS4kAxh0gmuN00TVdVAQTVQUE1UmME/g9rD8HZ7TUVc5JCVbAIYZTz/fMRtGFsW58oktDvhq2gmFnYVMNaATlUvuK82pL19G522XddNX0RXp3SRTtAtirli03utQIDr6ZDPx5BSuudaaffeY8VY7fWDSxcuImDYOdZbW1t4+vQpIpGIR/7GxsZ6XovFdiHKPhcx7P2bJ/Z39qis+tTFPAH49Wc4ce70gZE9AKholue5mArsVaO7+9aeo3tI+Pw4JHwDgK3e+GxZDqDCV6Ktr2BQwqGqKubn52FZFt55552RW2udHmwV1Wi1BynFhFnH2WRyT45rkCO4mo32FTj4zZ33/nt7S/XoAMfAJVdB5mY3FRExHZWwLdutX4WRbRlCEIjncLesQ6pVMB4WMR4WERP5rpXFYTFohW9hYcEjewDwn3/x5/C13/wXMH3iVM/XhXgOYZFDmPcbDocFbiD/tIpm4n5R9s1b5kICLiVDPeP7XFXpkSNHcPLkyQ/kAHSn1m+hUMDS0hLkydNAQIJFKRRFgSTZf35YavoqLSdiQZyOH4zHnqZpuHfvHjiOw61bt95oNbSoGHhY8ucbZyT7e2UXjzzPIxnmkQwHcdKyoJkWduSW5x/bAa7oFip6y/PPTftgZ6ZGE23QPcfXonbE1nJd91UQM0EeV1MHEx3Yy0pmlJanalqYKyrezJrIATdSIYy1eWRa1t6Wbq9q4h6VLtda2Li2L6VSCcViEQsLC6CUIpVKeTOt7XPbmwcQpdZt/xq6hS8Umnt+51IiiMWntT1E1KIUD3YVzx6Gg10NHXRevd2XsR2t2cLDCl8vHBK+ISH0ITDDgAoB1KkAEPuBPog6tFKpeNWWy5cv72twvZNhq0v2gjxBqlFEgACf26phl6n4ZSQB17LRgWac+rV0d1XDm8tLBgVEBzAW7pS0QUGQDYnIhkRcTFFslCp4tLIBMpaCxrduhIppYbmmYrmmgkNrTmgy3CNOagAMYstiWhQPd6p7f87494kcEBV5pIMCVuq2YCXAEfyhqd6K626glOJlTcXzSnsObggzfSwtNjc38fjxY5w9e3bocYEvFtjW75kzZ/A7G1U0LYBaFn73d38XkVgM+sQJyFzrnDifkDB7QDGGzWYT8/PziEQiuHTp0hvzFDQtiqcVfwrIoN8rx3GQOA5H4wKOwvH8U3S7Kq7u9fxbkw2syYaPMA1jg9Rthq9Thcj9vUsHmBPd8o5r+/kILU/FtHC30PSOUYAjuJmWOlYh21u6JvV777WrUfupdEVRxPj4OMbHx0EpRbVaRbFYxOrqqqdoT6fTtp1ROOIJUcQRhCidwD7v5A4PP9fjzzRN3+e2KMV9RtQyLNnre9wo9d3bXLjGy4do4ZDwDYmDbOnKwag3DDNIssbm5iYePnyIkydP4vjx4/uuRtQqu/hXP/r/Qa1cwlf+mY/gzFU7aWIswONWLobHr8pYFWKw1NZN8WwyhBNjg0dLsRdgp4Lo6gjZwf2SNra3t/F4YQFnTp/G7Ow4FJNiR9aw3dRRbOreA4B9zCzXVdR006n+BYZWZ/azZVFNC+/t1BA7cQ53vurr8IX/9kkAwJd/+E/iyKkz3u/plh0btaua3gPWpNQLYh8GTcPCg5LsGQgD7Tm4nUEpxevXr/Hq1at9q0q/mCCE2A8eJ6/67S//EO7mG2i6AdiWhYy6i1AwCjOc3jc5q9VqmJ+fRzabxblz595YNbSsGlgoNX1EKRnkcTkVHkmBK/A8chEeuYhNUhqO51++zfOPPbt3NQuf3ZGRlezqX1zsHvfmn/0j9txXTcPrtqqei9wBZgf3UhYP2/KUDQt3i01P9S7xBDfToa7HvL2lu9M0fN57e1ue/tdzPeqohBDE43HE43GcOHHCs30pFotYWVkBTeRAnVi38eBeAdaw0C2KZzV/Vg4HIC3xXtVuMiR4e+xlxbeTPWfOMT2E1VFeMfZ4FrJguWf7DN/ExAQO0cIh4RsSB+XDZ1GKuthaffRq51JK8ezZM6ysrODq1avI5XIjb5fFt37Tn8W9u+8BhODTv/rv8Y9/7Tdx69IFXEqF8bTSxJbYUhSGBA7XM1Ekh7SM6VXh0y2KTWeeTCAEk+HBkgy6ZelSSvHy5Uu8fPnSd5xCAsHsmITZMQmGRZFv6litKci3mQmXVAMl1cDibhNRkcN4yDZ7TgaFvg/vXhW+mmbg3e06mqa94v/en/o50NePkQ4FcP3GDVR0ip2mjp2m7mvNuX8yKfCpjRpyIQHZkIh0cO/Doh0bDQ2Pd5u+Vt2JsSBOdcjBZWFZFp48eYJCoYDbt2/39XL8vQIKYG5X88ieQIDTYQpF0fH06VOoquq1x7LZ7NAzd7u7u7h37x5mZ2cPZDHWCRaleN42d8gBOJOQMDuinVA7OI5DTAogJgVwzPH8Kzief4U2z7+6YaFedzz/OHhpH+mgn7C1WqoUuhDE5/PNloUH7NxagYNnubFfNSkL9opsv2T87dXe1b2GbpM9N10m5JC9Xobo7S3dzWbvFusewjfE18navliWhc9t173vanPxPpRQ0Kt8Dxs31ikWLcgBNzNhLOy2xnymwoLXreA4bo9dDUeA64yoZVD4PRI7tXP3evABNuGLRqN7fv9LGYeEbwD4ZvgOqMKXb+owHa+i8VB3sYZhGLh//z4ajQbefvvtAzuBi5Ua5t79gvd3yzRRfDyH03/gBj63XfPi0QC73Xk5HYY4gk1Frxm+jXor03M6OliWJ9CqprG/bVKKhYUFlEqlnqbTAkcwGQlgh4k0y4ZEyLrpq5jUdQt1XcGLqoIAR5ALixgP2ZYvnchWtwpfXtYwl697xCvIEdzIjiF+9A94v5PmbVXxuYSEumE55M/wMnYBu9W+1tCx1nDjtATkQiKyIcE3wKxbFI93mz5Fm8QTXG3Lwe0EwzDw4MEDqKqKO3fuvFGhwfsNk8KbX5R4O5c4JvJANoUzZ85AlmXk83lsb29jaWkJ0WjUI39jY2M9H5A7Ozt4+PAhzpw588Za31XNxEJJ9jzVALtaezkV2reooRtcz79pUcA0gIam479v26IigcC3mNAtm9BsNg0QqEgEeK/6t/x8Cc8XH+PMlWswZmYBo2XgfjwWwHRIwO/u2O8b3Gf0Vzu6CU00a/C4sZpu4m5R8YRtEYHDzbTUd6SFbekqTOxYiCdIBva+tn1BPGqRUzaBBrXfPypwuHb9qlf9e/nyJQKBADKZDNLpNBKJRNfKdqdYNBeTYRGU0j0ef6rTDaKE4EFJ8T7zqGSPjWuTeIJkh5GfbhW+ZrN52NJtwyHhGxL+OLLRCZ9PHdqlldloNDA/P49gMIh33nnnwIa/y6qBuYqOzOQ0SttbsCz7grp44SI+s9Wy/yCgGGuUcH321MjVg14VvtX6aApZr01CWw+/SrUK2mjgnXfe6RvH1V5ZvJGNQuCIE/Vmiz7YmUXNolira1ira+BgK5nHwyJyoYBH1DtV+FZqCh4WZa9SFxM53MxEupJ7QghiIo+YyOPkGPC7W610E460KgB2nJbdcsOu/eDPSgKCPIcXVcVntDwVFnE+GerbIlMUBffu3YMoim9caPB+on1RFhU53Gr7DgghiEQiiEQiTCaqrfqdm5vz0kCy2SxSqRQEoXXbXFtbw9OnT3Hp0qUDq7yzsCjFq7YZTALgVDyI47He1dqDBse1HrbpoICz8QB2mjoKiold3fLuGxTArmZiVzPxr37l1/HD3/VtoJYFMRDAJ37hP+Ds9VuIChwuJYOIiTyW61or+ivcv5o+DLpZyWzJg8WNVTQTc8VWpTwmcriRCg0Uvca2dNsFFJ0+Y/vTpFdLtxc22wQOoVAAMzMzmJmZgWma2N3dRbFYxJMnT6DrOpLJpEcAJUmyrWM6xKLFBA41w7WgIX7BixOFZpomwHFYKGttZC+E1AhE3lcVDXU+N7pV+A6zdPfikPANCUIIeGKvKjp4mw4ExaniAABnGh3FGoVCAffv3x/aTLkf1usqHhQasAD8bz/3y/hnP/D9qJaK+IaPfTv4Exe9m3ZU5DFp1FBTqvu6AXeb4auorQpWPMAjPsTKzz0WlCFYhONx586dgeawNhutyuJUNOBV7KIij2g8hJPxEFTTwo6T81to6t7vW4DXfgVkJAI8cuEAgpTzCC2lFEu7TbyottodWUnA1SH93djV6h+ZjKGkmdhpGsg3da+1BNgPJbYaaL8WuJgMYSrSv03uzp6l02mcP3/+i267clBYa2g+8psM8riRifQlv6IoYnJyEpOTk7AsC+VyGYVCAc+ePYOiKN4DstlsYmNjAzdu3EAikTjw/a/rJhZKTd93GxM5XE6F9yhC3w+0z+JJooAcxyESsJDSDOyqBmq6BdVq/e6v/fN/6lW+TcPA//1LP4/rt27jSERAgCOOLx2rlD3YhQa7yGS/9kHixnZVE/Olpnftx0UO19P9F0/etp2Wbifvvc776v/7KBU+NuKMwCZJLHie96IMz5w5g0ajgWKxiO3tbTx9+hRSLA5jfBYK31o0u7FooMBC2fWM7Sx40U0L1vRpj+zxDtlLjkD22uPauimN2XX2oUq3Nw4J3wDYk6dLCExKR27pspUtSamCI63KAKUUy8vLePbsGS5cuIDp6enRdroNlFIslZt4wVirzJw8jU/8wr/f87tHo0FcSIWxtVlH2dxbzh8G3Sp8+0m3cAlJoVAAaAAgHELh8MBD96u1/jYwQZ7DkVgQR2JBmBZFUdHtqLem5vMhLGsmyloTAAcyeRoPCw3UdMNz3re3EcC5xPCqQ/a3eY4gFxKRC4mgVEJVt8nfpqxB7rDyMCnwaLeJ7aZut34loaP9SrFYxIMHD97o7Nn7DVeZ/KzS+p4JgFvZSEdlei9wHIdUKoVUKuU9IPP5PF69egVN0xAOh+3zEEA8Hj+Q40cpxXJdw9OK4iMBJ2JBnIq/v1U9k8lhLjNV77yi4zfWOosuWISjMXCEg0VNgBCEojHIJsViRcNiRUNEIGg4529c5BAZMfatG3wk1fl/jYkbG+sSN1ZQDNzfbR3/ZIDHtZQ01ILNsiyIotjTe8/3+wfQ0i2qprcYzEh8T8sl1s/y6NGjeF1V8LJhwGLuPCG1jtkgkOJTKBitnytmy9HB3g6BaVE8kSloxJ793g/ZA/xxbb3OjV4zfIeEz49DwjcCeKe/NkpLl1LKEA6KQKPs/ZtlWXj06JE3MH9QVQPDoriXr2ObKfWzliQu2uPRhokL6wb/DJ+z0rco1h07CZ4AU5HRLDEePnwI7sxNWOgd28aiqhkoOxWTsQErizxHkAsHkAsHcImGUdFarV921pEKASzX/Uq2qbCI0/HRLCbYl1C0HliEEIyJPCqa2TMn16T2wLVraZAM8shJInIhARGRx8bGBhYXF3H+/HlMTU0NvX8fRFBKsVhWsFL3JzZwpLMN0bCQJAmVSgWiKOLmzZuo1+vI5/OYn5/3Wr9ue4xt/Q4K2bCw0KasDgscrqRCSAw5/zQoDMsmdQ1fXJ8JuUcOcy9LKo4AIiFQLYq/8D3/O14tfhN289uYmD6C/+k7vsv3uw1msdIwLDwuK8hIAtIBfuCZ3l5g7wvuNdivorjTNPBgV/HIYibI40pKGvr8cWf4Bk3yaL+HjfLpN9vixwZBXTfxuKyiorci34IcwbGACUORsbVexPOlRQTGjwAJW/VaZe57UyHRjpgrKaia9ut5YnsTJvYxj7nZHKzy22mGj1J6SPg64JDwjQDBOalGqfDlmzqajinwGEdBDPvBpCgK5ufnAQDvvPPOgQ3My7qJ93bqPmIyEwlgreF/IAoE+NDUmC8ejed5n0fcKPBX+Oz/b8oaDOfYTUYCQ1kwuHFVAHDlyhU80DhYFu2a4tGO1X0maxBCkAgKSAQFnE3ax3e7qWOlItvB9R2MVjdlHakgj6xToRvUOoP9LYu2yLNqWnhYavpUxhGBw9W0bctRUAzsNHXkFcMXn+bavSxVAJEasMp1nL58DRPZ1NDH4YMI06J4UJI9ggvYA/kHkTMMALqu4969e6CUevFy0WgUExMTsCwLlUoF+XweL168wMLCgk/1288cnVKK1YaGpbLie4DNRgM40yPybuB9d3KYXSIn6y1yp45wfAjseUjb/LsV3RcROGw3dS+u7sipM/j3//1drH/h07h65QqOHz+OXdWePy0oJmRmPWlQYF02sC4b4GAvULJO3FsvNWwvtFf49nrv+R+Bm7KOR+XWvGRO4nF5RE9ASikoIT095FiwS2uC/rnD7dAtip2m671nW830gkUpXtV1vKppvuN0JCzi1Jgz6pIaw4kTJ6BpGpYKVbg5QFXNrtjyoIjxFuZLOnbd0QPLxI1c1Jc6MizY74kDMN6lDQ4czvANg0PCNwLck8p0rECGuTDZVuZ4ANgyDFQqFczNzSGdTuPixYsHZtZaVHTc3al7D32BIzgVl/C0vNchPRrg92ThHkiFj/mzS8pGjTNzH7iqqoLjOESjUXC7uvPe/V9vWhTrDtHlCDA9wHxbP4RFHlHdRNOCR/YIKDhCfEPsRdVEUTXxpKw4li8icpKAsQDf9fxhf+5+vJ2mjoelpo/EtOfgToRFTIRFWJSirJk2+WsaPhWyTgQgOY4nKvBio4asZKt+Mx38wX4vQDMtzBVkr3pLAFxKhfCqph4I4XMXZJIk4cqVK3uuUY7jkEwmkUwmfarffD7vRWK55K+99asYFh7uNlFgCHyIJ7iUCg9sTksphW7Rtipd6z99hGMgtkX2cQCeVe1rdyoi4nLKr4Ds1ErPChbKi/dx5/ZtHD161PmZgGzEVuk/cGw9Apwt3mU9Mt1rBtAQFTgv6zceGNxXzufDR2BbyzjHot3vb72h4zGz75MhARcSo7fQLcuCzEs9vfd8v8/OG46wve2m4R2/iVDv7OGKZlf1WHucsEBwIS51bMEGAgFEY2OAm3XsvDdXK+EzsggaHrP/TilChRUkZi6P8AlaYL+nbB9fRl+Fj/k9WZYPVbptOCR8A2DPDB8br0b96Ru9oBgWtp3yfpAnSAc4rOo6vvCFL+DUqVM4duzYgc1QLdcUPGIUomGeIBMO4Mmun+wR2GSi0/OA47h9V/gIIZ7C1KJATTM9BWxU5PtahbiQZRl3795FOBzG22+/jd/+7d9mzJcHq/BtyZp3E5kMB0aymWnHSlXBw1LrOAcsHcGtV5BrVcRzk+ATGch80Bdcb1u+qHhRVRHkiFP5E5AO+k1F2TPBMC08q2i+VmWAI7jcIweXIwSpoIBUUMC5BFBuqlh4tQYlEIIZbK18dcseKt+QdRDYFjEuARy1svJ+omlYeC/f8AgtT4DrmTAykohXzuJiP5Sv0Whgbm4OqVRqYFFLOBzG7OwsZmdnoes6isUiCoUC7t27BwBO6zcLPTyGparmE4DNROyZz3ZyQCmFalFfdY6t2o0iIgu0kTq3Shdqy2EG7KqOS/jaFaSU2skfr2qt83OcN1BavI/z5851HBlghROXkyHERQ5FR31e0Exfrq7r+fe6rkMk9jnqRr71IgM+Hz50jzZbqWtYqrb2fSYs4Nw+o/YopahxrQVtv3gzf/t5+O0NIgwxLYrnNQ0rTO4yAXAsKuJ4LNCzbd2poxVMZqA7Jx6xTJDVJahKA0tLS0in00gmkyMVMFhbqU7ee932i63wNZvNQx++NhwSvhHQ7sUnDDhtsVZvtQpmIkGsrz2Hruu4efOmHfR+ALAoxeOSjGWmipYKCrAo9VXWALu6ttmw26udLmae5/dd4QPsh4MFChN0jxXLIDfUUqmE+fl5TE9P4+zZs16CgmVZ3kp4kALGfoQi7aCU4sluEy/3KHHHIMxmWhWenRXo5TJiiTQC6XGowQjqDIdWLYq1hoa1hgbeeZDlJNtfj1ILG69eIJZM4V2B8+XgZiUBl1KhgeLtALtCtXhvHpFgEO+cmYVFONvapWkgr+i+amRBMVBQDCyWFcREzhGLCBgTu1cjv1ioaSbeKzQ8IU2Asz324gekYi2Xy7h37x5mZmZGzhIWRRETExOYmJgApRTlchlbhSIeVjQYOkvggUupMKLOfGbDbb8y/41SrJR4ltTxPnI3TDW3m8UJpRSPdptYY0jEBNFQerKAy13sahTD8iqaEk+QCdlWJZOigMmYbe9RUQ0n7s1ElWGzOgW2mga2HM+/eIBDVhKQCQqICMRfGWd22gJQcDzlWL+/VzUNzxmiejQi4szY/o2sdRA0iP2I7ea9x2I/hK9hWM4Mnj3eERM7CLRUA4tl1WfuHhM5XEzY9jj90ElFXHe+F4EAN3JR1DCFjY0NEELw9OlTaJqGZDLpmT4PkvuuD+GRCHSe4dM0DYZhHBK+NhwSvhHA3iRNiwIDPFso9ZOdyvIzKNUyCCEHRvY008Jcvo4i0xrKhQTsMuVxFsfHJOzIdnWhE687iJYuYK+63G2s190KATAT7d9SXVtbw+LiIs6dO4cjR47s2TfOMa9uz6FsR0M3veMSEbihDUBZmBbFvUIdW8wqdNZR4roPifYKT6FQQD6fR+3VE4SCEkK5aZjhMdQszqtCmNQeGN9pGlDWZXziY/8Tnt6fAy8I+O4f+Rm883V/HBwBziUkHIkM/kBybVcymQzOnTvnVaimIwFMRwKwKEVJNZxt675B/ZpuoeZWI3mCrNS5GvnFQFExMF9oeJWtsMDhVjYyUrxYJ+TzeSwsLOD06dO+c28/IIRACUSwHuJ8FTnONKCpOubyFkCG3/8Qz1TpxFaVLsxzB/Y9dTIWtyjFg2ITW4wgbJLKKD5bxLVr15BKdZ4P3ZBbBGu6w7nM8zxSYR6pcBCnLAuqYY8mFFQTJc3v+VfWLJQ1Dc+gIcQTZCQB2SCPZJD3kZSmYfn8/gDgeVXFq3pr309ERZyIHUxqiRKMwq3Td/PeY8Hew4bd+mZb5ZLdlm5RPK2qPrEKB+BkLICj0d6tXxbtQh332AoEuJEOIR7gUaUUkiThzJkzOH36NGRZRrFYxM7ODp49e4ZQKOSJmuLxeMdq+VbTGMgjsbVfeyt8jUYDAA5n+NpwSPgGQCdbFhfGAK1EwH44uRUaXqmDN3XcuHEDn/nMZ0bKSW1HTTPx3k7NVwVKS4I3xAvYq1p3QDsZFBAL8F5LtFOF7yBaugC8beiUenF0E5FAT8sASimePn2KtbU13LhxA+l0es+++Qhfn6+hvbo36vFWTQvvbde8WTEAOJ+QMNujYtju67a7u2tX/16ugDcMxMengbEU6hC9OKRP/+q/w9P7cwBs/7L/79/7f+MPffjrcTYuYTLS/+HholAo4MGDBzh+/HjXkQGOEGQkERlJxPmEhJpuId/UsaP40z5Us3s1ctBK40FhU9bwoNj0HgzxAI+bmfCec2rUq2p9fR1PnjzBpUuXMD4+PvTrWTuThiOSqBsmqprZUeFq8QLAd78dE2BP69X9LyTsPyt1ELQLIEyLYr4oe5U6AmDCqGF3+Tlu3ryJeDze+X0o9VUD+83SchyHUIDDbEDELADDNFFs6nb1T7N8FaumSbHa0LHa0METO2nCBTuvNhkS8LTqb22ejgVwLLb/uV7A/oyKNOb9vVuLlUUnRfGg22KFKKz33k7TwGJbLFoiwOFCQhraAqdaqeDe57+A3PQRTB0/CcAmezfTIc8X0nJyqwG/ofnRo0dhGAZKpRKKxSIePXoE0zSRSqW86p9rmL8xRDsX8B8399l8SPg645DwjQB/2sZgr2HbqVnexI2bN2EY9kVqmuZIFg4udmQN8/mGRz5FAog856v0TYRFcATYcG5wRx2CwnEAzL0eUIC9yqaU7puQugUG1saml1jDjfiq1+t4++23O160LcLHqoBpxxulRSnW6q5hKDAzgjoXAKqqgfd26p7KmifA1XQYuQHtD9z9dm9wZ8+eRb1ex87ODvJrz2HV6xjLjMNKTUDXNF+kn6Hr0CyKhd0mnlSUgUQWa2trWFpawoULFzA5OTnQ/hFCMBbgMRbgcTJuR0LlncpfUTW8mytbjXTTPnIhe5+iAvdGW7+vayqelIc0tR6wFUopxevXr/H69Wtcv369a4UKsO1MOs3S9bIz6QWOMKSO50B0FUqtjHqxALlaRtgxfM5mswiH9zeSMApo25/fzTe8hQ9HgGyzhPLGCm7dutWzlVbWTG9hmgzyQ1dkBZ7HeJTHeNQmGDXNHk0oqAYqOvVlUFeYKDr3jxGBYLmu+2YIz8UDOHIAIi4XFd2CJdrfUTLADTQL6yMuQ1RlS4w9UzrII8hzHWPReAKcGQtieoQ0k42NDXzzV30FittbACH4az/4o/jaP/PNuJEJYYxpB5um2XXGVRAE5HI55HI5UEpRr9dRKBSwsbGBJ0+eIBaLIZbJoRq0F/cxgRuo1cwWK9zDJssyJEn6fWMif1A4JHwjwC/a6H9jVwwTmw0VIAQCKK6fsist7kpoVMJHKcXLquITYkg88SwYALt0fyEVxmRExG+uVQDYtjKTYfvm5q6IOj2f3Itlv4TUJWGegETguqoPFUXB3NwcBEHA22+/jUCg8024RfhaP6OsWR2DfFP3ZrzGw+JI1ag9mbg8wc1MZF+JB4QQ+yZFWOTrAAEAAElEQVQXi+HkyZOoy00sFOuoI4A/+Ce+Ef/X//nPsbO+CgD45r/+Pd7rOoksciG72iYJdqbvixcvsLq6ihs3biCZTI68jxLP4Ug0gCPRAAyLoqjaSR87TcNXNXDTPp5VVIR4ziN/ySB/YNUnSimWKgpeM/NWMxERF5KhA9kGpRRLS0vY3t7GrVu3EIvF7GvJyVlu96rbj/o3LvJIBXlERN5rwwY50vYgDgG5BHDyGJrNJvL5vJf4EQ6Hfarf9+PBxt7qtmTNE1UIBEjVd9AobOP27dt9lZHrDfb72x/J4jgOcSmAuBTACcuCZlooOJZEJc3yKuYsGgZFw2DI3tjBkj2gXRwy2IJwVJWuL40iJGBD1rHUFouWCfI4nwj6creHwc//y1/Abn7H/gul+OUf/yF8/3d8bA8hY/ODe4G99x0/fhyapqFYLOKV3CKoXK2IbVpDKpXqGfXYaYav0WggHA5/4GaOv9g4JHwDoP2kEcjghM80Tbz3fBmQEgCAo2OthxMh9g1+lLapaVEsFBu+m6fEE19lISpyuJ6NYiwgYLnaco2fjgY80sozZKy9QuYS0v3O8bXHTnYTa7j2NNlsFhcuXOh54/AIH/PmFqXgOzC+UW1gvNe3KXHHRA43emTijoKSauBBWYcC+8ETT6XxU7/2G1iYv4tUbgKnohxichFWNIEa5TuKLB7DFlmgWoK+u4vbt28f6NCywBGMh0SMh+zg9IoT9baj6F7mLwA0TQvLdQ3LdQ0CsbOHc5KAbEgcynORhUUpFkpN36zSybEgTo0N1p7vdpVSSqFZFA3NxNPlFcgGj8T5G3goE8jV6r7sTHhiK1vZB286yONyKjz0uRMKhXD06FGvNeaqfu/fv2+/bzqNbDaLdDr9vuQgu2RP5Ajiu+tQqru4detWX/9Q06Led8gTYHyI6ng/cBwHieMwIwqYGbPvvS+rCl7UjZ6vW6pqyKump/rd7wyoSannvceB9vTeY+FTFA9IVAyLYltp+fytyzpKjLxZ5IBz8SDGpdEzinWLYscgrSxnQhCRAh2rb2xLdxgEAgFMTEzg2bYMWBQEFAnoeP16A48fP8bY2Jg3+xeJRHyfpdsM36Ely14cEr4RwFb4jB4PBEVRMDc/j1r2uPezo8ysl6s2HZbwKYaFu/kayowbv8j5yd4RJx7NbXOtMDNs7D6wz1/W3BdoVfj2S/jabzSdWqpbW1tYWFgY2J6mRfhaPzMp0P74YHOLJZ7ramHSCbYSV8bLKtOOHyETtxcsSvG8ouIlQ0oFAlxIhrAbCUD40B8GAJwNWZBLeey8egyiaUjkpsDF02hwAajM11PTLSCUAEIJvFe1kNObyIVsa5aDnPNiDajPQILsHOd8U0dJNb2Hg0HtoPotWQdB0077cFS/YWGwB4NhUcwXGl4+J2DnBB8ZQPTDouTM0Tba2q/eZRPJAAB21P7ne5C1M2kzIOYAPK0oWGYsdHgCnEuEMDPE/GU3CIKA8fFxjI+P28S7UkGhUMCrV6/w8OFDJBIJZLNZZDKZA51hkg3/fUriCcL5ZZiKjFu3bnWtxrPYZnKpJ8LiG/V85Hke0aAI9CF8rE/mUtWOe8sEbWuiYTz/XOQVwyP5SZ4O/BlHUeluK60xC4vCR/YmQgLOjgURaF9xDwHdopgrNvEVf/Zb8Ju/9v/HyrMnEEQRP/IjP9Lx9/fTDSpprVi4dFDAmakTwMkTUBQFxWLRrgC+egVRFD3yl0wmfWNVbgGj2WzuIYaHOCR8I8E3w9elwlculzE/P4/o+BQswb4RpiU70oqFIAhDEb6KM0emOGe5uyueuTIBLqcjmGJIVUU1bGd02LNWY4HW197LYmY/FUgW7OxeVhJ81Q1KKV6+fImXL1/i6tWrHS0cOqHTDB/tUMfx28AMrr4bRIm7XzR0E/eLTV9MUTLI40oqjJDAORm9NmKxGGYySU/5ls/nkd96DaNSQSyZgZDMomJxsIKtVa1iUqzUbe8+nsBT2Ga65OruB2GBw7FYEMdiQegWRUGx2775pu49/CiAkmqipJp4UrYH6l0PwkQXA2rFtHA33/CyTzkCXOswN2lRCsWkPiInGxYazusogC/kG0N9ppadiT9JItTDzqSsGnhQavrEU0mnqndQ6mEWhBAkEgkkEgmcOnUKzWbTU4S7qkiX/CUSiZFbv1XNxBIzNykSILjxHBwsXLt5c+CHPNuROAjj835YW1nBz//kTwMA/vhf/DZkp2bAEeBKUgKl1LN9YTm+3fLVsdzQITjipGyQR1oSEBiAibFq2NwQBUyrwyxaP6wyohP31UGO4HwiiOyAlcVu0C2Ku8UmarqFaDyBH/mV/4rN5VdIZLL4o+c6Z7wP2tLthM0ukXeSJGF6ehrT09MwTRPlchnFYhHPnj2Dqqqgxy8Com334j6bD02XO+OQ8I0AX0u3QzFgfX0djx8/xunTp7EbzgCOBUGnduIwFb6Nhor7hYa3omvPw40HeNzIRvckZrAtzaNtalKW8HUTbuy3wqcwB4klopZl4eHDhyiVSnjrrbcwNjbW6eUd0WmGr73Y2m6FM6hYQzUtvLtd8ylULySkPcduVLgqxSflplftIABOx4M4ziiI2Xu+ewRZ5duxY8egaRpWVlbw+uUiOABSJIpQbgpGaAxVk/gG2LeaOraa9txfwq20dViE7BciZ8+IToZty5dd1fSi3lgiVDcs1GsqXtVUBDiCrDOHmJYErK+u4MXKGozpU7BEu03oVj4JbOGGzMzVsZYbw4DoKgKwkEuMtebpHFI3THZqp0otR4AzcQmzQyw09otQKIQjR47gyJEjnirStZexLMvL+s1kMgO3fkuqgbl8w9eaJpU8JJ7gypXrA7fwmoblVWnDAofkAXkldkO9Xsef/fDXoFgoAAA+83//On7mk7+LDx3Leobvk1G7KlVVDeRVO+6N9fwzKJtHrSIR4JzqH49IB3GSYrY+I3QVY0NUof0m0b3PF4tSPKtq3kLIxUxYxGk3Fm0fYMmeC14QMHPyNDh0j30zTXOkli7bmhZI91g4nuc90RulFM1mE+/tajAAwLLwFV/xFbhw4QIikciBxZMCthfsd33Xd+E//sf/CI7j8I3f+I34iZ/4iYFGZiil+PCHP4xPfvKT+JVf+RX8qT/1pw5sv4bFIeEbAL2SNlhbFsuyPCuR69evYyyZwuJqGYD9EJwI7734ByFUlFI8LTfxvNJaYRP4bxAnxiSc7TC8blgUGw37IcQTYCriJy3sfaGbcGM/hE9pG253b7SapmFubg6UUrzzzjueJH9QuArWdpUui6JioOkQjIwk7CHCnWArcWue1QPvVJSGaQX3gmbaMVqsXU5E4HAlHd5jFrxHkNIBlUoFKysrOH36NKanp1uWL2uvIFIgOjENGk2iBsFXafNydZ3t5/pU2kYFRwjSkoC0JOActaO/XL8/1tpGsyjWGzrWGzo+/av/Hv/k+/5foJRi4ugx/MN/+x8RT6ZhUOBBaW8s4KCYjQY8QmcpMh7fn8f01BROnz69r89c1Uw8KMm+OcZ4gMflVAjRAybTw6BdFVmtVpHP5/H69Ws8evQIiUTCE350a/3mmzrmi/KexZQkirh6/upQ1Rx/dW//re1+mH+wgPz2tvf33Z0tjJVWkDzrV6zzPI9kmEfS8/yzkG9qKKgmioznH9Dy/HtecwyjHfKXDPLgCfFVqbhqEXymcyWsE9hrvBdf6xSLJhLgairUMRZtWGgWxVyhiRqTXOMXRnR/7agVvh2mNT0xgPceYD8DwuEwuBoFTAqB5/Dt3/7t+OQnP4lf/dVfhaIo+IZv+AZ8+MMfxoc//OGOaS+D4qMf/Sg2NzfxG7/xG9B1HR/72Mfw7d/+7fjlX/7lvq/98R//8Q9Ma/mQ8I2A9jYo0Mp5VRQF77zzDiKRCF5VFI+UzTBCCd978XzPCp9hUdxvay0CrfJ9gCO4mokg14FMAnCSNOw/T0WCe1Z+vs/SYR6x3/71w1pd3fOzWq2Gubk5xONxXL58eaQV4SAVvlXf3GL/1Z5tb9NS4ko8wY19KnFZ5J0cXDas/kgkgLMdYrQAgDCr/E58b3V1Fc+ePcPFixc9r7hsNotsNut7wOdXn4I2GojnJiEkspD5oJ3966BhWHjVXmkLiUgHDzZXlxCCqMhD4jlkJAEVzURB0VFhbCUA4Bd/+P/w7Gi211bwm//hX+NPf/w7u74vT9o96lqVuvlCA1XdAgFwPmm3fYrFIhbu38fJkycxOzs78uexKMWrqorn1VaCDgFwyqnUvh/eeIOCEIJ4PI54PI5Tp05BURQv6/fFixeQJMkjf27rt93rMMIDDedWMDExPtSDnVLqI3xTXe5XBwXFsFCK5iCIIgzDAAEgiCIunDze83Wu59/RgICjsD3/SopdnS6qFmTmPFVMijVZx5qsgyNAKsChysiCSaUAQmYG2l9K/QMpnS4706J4UdOw3ND3/NudbGjgmdhe0Ey7sueSyQBHQEB9hK/XeT2qaGOjSzt3ELj7JnAEH/3oR/HRj34UP/ZjP4ZPfepTuHXrFn7+538e3/Ed34HLly/jIx/5CP7W3/pbQ73/4uIiPvnJT+Ldd9/FrVu3AAA/9VM/hQ9/+MP4kR/5kZ5E8t69e/jRH/1RvPfeewNbY71JHBK+AcF6ovlsWSzbT2hubg6RSATvvPMOBEEApdQnlDgS7Uw4ehEq2TBxd7vum/FikZYEXMtEeyr+VuqtqmCnlqSfMHU2Xx61wtfeUgWAQqmEZwv3MTs7i1OnTo288ulM+Fr7r5kWtpwHTIAjGO9zE1muKnjUrsTNRka2MWBhWradSHsO7qVUqKeHny++inkcUErx7NkzbGxs4MaNG0gkEh1e63/Ay7LszHatQt/dRTSeRDAzAS0YRY05vdhKG0fs4elcyDZXHuZYaGZ73uvgdibEV9oECEMsOGLP/iWDthVNVOTth1LX88j/883NTTx+/Hgob8JOqOsmFkpNX9s/JnK4nAof2ALhTUKSJK/1a5qmp/p1W7/S5CwqkRTc45cWgcrqa2DiGIDuLb1uKKmmVzVPS8IbzWiWDQvv7jQQTGbwvT/zL/F//ujfBwD8vR/4PwaeEXYh8DxyER65iE1m6pqT9asYKDOefxYFCswgIA/AGkujYRGEBvAxbb/DtpOqkmrgcVssmot0kH9jZO/MWAAPyy0PU4re1cdePnzd0DQs7DrXUZgnGOsQC9cL7n2f3a9ms4np6Wl8//d/P77/+78fxWIR/+W//Bfs7u4O9d4A8NnPfhaJRMIjewDwVV/1VeA4Dp///Ofxp//0n+74OlmW8ZGPfAQ//dM/jYmJiaG3+yZwSPhGgMCcWHW5ic/N38PRo0d9raFd1UDdIWpuqkUndCN8JUXH3Z16x4cjAXAmEcLJeG8BQU0zPCVvTOQ75ov6PQUH379BUGyb2QKAJ0tPcfnChX2V1wGG8DEPdPZQrTc07yY6He1ebemkxM1JAq4ckBK3qpl4UJR97ZdBc3DZrbtc1jRNPHr0CNVqFbdv3x5YhRkOhz1bDzbqrf76KUJiAKHcNKxIHFXK+VR/eSfM3meuLImICAQ6hV8g4SRKyIbfimRQuDOpH/u+T+An/tZ3wbJMzJw4ia/6Mx/xfseiQFW3UNXtxI+MY0Cd7SNEoQCWl5fx4sULXLt2bU9yy6CglOJ1XcOzstI2UmFbxHyQqnqDgud5X+t3MV/FCrNOE+u7qGy8QOrYaThObEMnmPjauUNWcIZBQzfxbr7hVYyvf+gP47qjdL+W3t8QP8dxGJMCGJMCOG5Z0B3Pv4JqoqCaPs8/EwAy07hXNRGoy57lSzrId7yv7Mmpdf6vWxTPqirW22LRIgLntVwnB0jx6IdOZO9WJuRTmrvoNds6SoVvs+mv7g27mHCfW+x+NRoN370xnU7jIx/5SPtLB8LW1taehYIgCEilUtja2ur6uu/+7u/Gl33Zl+FP/sk/OdJ23wQOCd8IYE+sUrmMaxcv7qkWrPYQSvjeqwOhWq2pWCg2OrbxQjyHa9kIUlL/m2a7WKPThdRPtLGfCh+7fRfnzp/HVLZ7esGgcPeLnSdxx/Yppb7j3817z7Qo5gt1bL8BJS6lFK9rGp5WFO975AhwLi4NrBYmvs9mzz3eu3cPAHDnzp2BbDA6oXvU26oX9UbGUqgTEYzLg89ceVQEeeJrv0YEHhJPsFLXPLPaL/9jfwpf+4f/ICKNXVy6dAkmJyDvqH6LiuETorQG6oFkgPeqkXsG6inFq1evekZ+9YNsWFgoydhl7GEiAofLqRAS+8hm/qCAUoqnFdVH9rJEQ2n9OaKRCIrFIjBpHzu50YAVEQeq5hgWxbZjjSSQg/XeY1HTbLLXrYJ8kA4wHMchyHGYFgVMA9AMA7+91ei4aNYsio2mgY2m3VpOBnhkJB5ZxvOv/d7Lke6xaGfHgnivaM+yCsTOS98PNNPC3aLikb0gR3AzE4LEE8ZPsFWFPMgKH6V06Cg1FhbTCmefBc1mE7FYrOdrv/d7vxc/9EM/1PN3FhcXh9ofF7/+67+O3/qt38L8/PxIr39T+L1/l3qfwLZ0CWWGs1MpTE76CYxuWl44uMC1Ui06gSV8llNtelXt/EAdD4u4ko4MZKlhWq2ZGY50t0AYRLQxSoVPMy1suwHptBUIH4n2vggHBcdx0HUdItlb4StrJmp9qquKYeG9nTYlblLC0RFj19rf+0FJRokhBmOiLcwYZoifrV4qiop3H99HNBrFpUuXRpqT6QhCEIonkYmMITR9HJWmgkpTQ1OzYPGWk703HEI88c3Rsf+1z7GaFsW9omxXER2cS0g4duQ4gNa81dFoEEejQRiWbaXhqn5ZY+RdzcSuZmKpYs/05UICDOZaHaYiyoJSitWGhqWy4rtGZqMBnIlLQ8VgfVBBKcXjXQWrTCVuktORf/IAly9dwsTEBFZrCh457b3NjQ1sL95HOp32VL/dFiBbcst7bzLceZZ5v6hoBt7Ly9750G5CD4yeqzwIWHFHLkBQe/EIUnoCfCKDkmZ5ZInC9psraSaeVjWEeYKMJCAu2gvYZ/fnYJompNt38Iq29pgnwOmxIGbCAjabhret8ZAwlJq8HapD9hptZC8icNhiLJXGJR6bTkzbQYo2KnorCzkV4IceoemUsgHY7dR+Gdh/42/8DXzrt35rz985ceIEJiYmsLOz4/u5q4Dv1qr9rd/6Lbx48WLPuM03fuM34kMf+hA+/elP99zum8Ih4RsSrpkyJs8CALgOgefrDc0jHzOR3jc4l/DppoX5fAN5Ze9ALgfgfCqM2S5Vuk7YkjXv5jcZDkDsciF1EqC0798oFb61equlKhoadMdaY5AoukHQS7TRr7pXVQ28u1PzHggHqcTdknU82m36iMjxWACn49LQ7T72158/f46ZTAZnzpwZuvpo0fbM19Z/He1MuECfbCeKbo9PAiAs2K3fbEjs6T2nmRbuFmSPdBMAV9KhngskgSOYCIuYCNtpH2XNtnzZaRreQwuwq3FsBBsIQZWICFqDG+ECNnlf2G36cqlDPMHlVBipffqcfVDQKcVkEgqKS49w7epVZDK2ITUhre/y9OnTSNCjyOfzWFlZwePHjxGPx32qX/c8bVfnHjR2VQPv5VvVtXiAh0AApW2h+ibb7euMkKK68hzjyQTOnTkGSikMy0LJGY0oqiYU5nYqmxQrDR2UUvzk93wX/vt/+hUAwI0/9JX43p/5l+B5fk8sms+vbh/3LJvsNdFwWF3QaeO616zPTzAkeITvIEUb+6nuAZ1TNgCb8PVb3LkCt3545513UC6XcffuXdy8eROATegsy8Jbb73V8TXf+73fi2/7tm/z/ezy5cv4sR/7MXz91399322+Kfz+uGO9T9jd3cX8/DyyuRzKzs/ala2UUn+UVx/vNp7noVjAZzarvgeWi4jA4UYu6jNLHgS9vPdY9LI1AUZr6VJK8boie3+fSce9quU+4kc77hdp23/WhkYgwGRbZbOTEvdmJtJ1xnJQGBbF492m7wYmOcSgW25wP7C31dz4OM4e7S4yMCyKZts8XdOwM2DbKx2DgCNAmG9V5iQO0OU6GqUCdvPbAMchOj7jRb2xli9F1UBRNbBYtqPeXL+/McbyRTYsvJdveDOeAgGuZyJDHStCCJJBAcmggLMJe35rR7HNnneZtA8X94tNEDSRcgQfvQip22pa3G365hF7qap/L6K9wkoATFh1lF4+xfXr1305zH4VKcFYbAxjY2M4efIkFEXx5kJfvnyJYDCITCaDWDqLXc3+TiMC13GOeD8oKAbmCy2ylwzyuJgM4TNbdQB+S5E39Y0phoWCe/x0DRNjEZx1FmaEEAQ4DuMRHgkpgAlNR0mxK9F1w/LOrY1XLzyyBwBzv/2beLFwD1/+9h0cj4oIOudb07BQchZIIZ4gHhhN/NJO9iSe4Ga6RfZYP0GJJ3Zko4NeFb5hWrpsBB1PMHAEnf89Wn9ur/AdVKzk+fPn8XVf93X4+Mc/jp/92Z+Fruv4zu/8TnzzN3+zN4u+vr6Or/zKr8Qv/uIv4s6dO5iYmOhY/Tt69CiOH++tFH+TOCR8A2J1dRWPHz/GmTNncPToUayv7MKk2DOcXmHaiYkg35eoNfkgNgJR0A5kbyYawMVUZOiHS103UVLtCykicp73XSf4U0M6/PsIoo1na1toWjbJTAb9EVqdSOUo6DjDR21zavdztNvQ7FXi8riRDe9biburGnhQlH0KuomQiIup0MjZsQCwWyoBnD1onkynoVtupc7cU6lTRyB1fjsTf5pEkO+gfI2HgMksKD2Hcrlsz/29XgQUFcnxSXDxDBpcwFfBqOkWarqKF1UVQY4gGxIRFTm8rCjQnF0OcgQ3s/u3v4mIPI6LPCYEC3dfPISQzKIRzfiG6TsR0qxDSOMOIVVNC4/avBKDPMGlZOjA/Bg/CDAsiruFhjeTyAHIaWXsrtqzju1G6KxSvP3UkCQJMzMzmJmZgWmanuHz4lYRSNittZipQNeDI8+etmOnqeNeQfY6CRlJwPV0GCt1zdvTqMi3KshviPGxi7wxYiBz9ATWGrp3nTaca7TXYlfocEwEUcSOYmJHMe1rR+J9z5tRBA6ATfbeKzYhdyF7ALDFVPcmQwIoQ5d7CeAopQNX+NgIupw0mgVUt3QSWZYRCoWGfr9u+KVf+iV853d+J77yK7/SM17+yZ/8Se/fdV3H0tISZFnu8S5ffBwSvgFhGAZu3Ljhqft4QmBSuqdF6ausdbFiAdyhfhXrfGzPnUggwKV0BNMjzpP5BCPR3m3gg6zwUUrx9OlTvFQJMGbv+9FY0Pe+I/CSjugUrWZR6vP9c6urlFIsts1G5kICrqT2p8S1KMWLqk1mXPDEToMY5WZMKYVuUTR0Ey9WN1AyAURswre428TDEUyHRY50nKULC1wfO5PuIIQgmUwimUzizJkzaDQaXtSbXqlgLJmGmJ6AGgijzqwVVItireFX/QU4ghuZg7MycT0ex8fHcfbsCXxup+E98I9GA8g3dR8xdwnpS4eQRkQOVc3c82A9n9wfef+gQTPtCmtVb5nrZhoFVLfXu846sreHXkeC53kvzm1nswbDpAClaG4t43eelDE2Nua100bNO233CMyFBFxLh0HgbyFHBM77/g/i66NehJ9N4uq6gdV6i/BVhDDeKwz30BcIMD5zFH/q2/4afvXn7Bi4r/umb8HxC5e931EtijV5byawYlpDLVgV08LdQtPzE5R4glvpkM8mh1JbZOJiKiz6nnPdjqNbGBi0wuePUhuNinTK0QUOtsIHAKlUqqfJ8rFjx7wZ/27o9+/vBw4J34A4ceKEr9LFcwSwqK+lq/dpJ7qwKMXDomx71LXd7OIBHtez0ZHjrljSQ4C+pLFfhW9Q0YZhGFhYWEC13gCOXABgR9BNhgPYlFs34IOu8LFHTzYsL71hLGDb0JgWxXy+7qkEAeBYLICzfSxt+qGhm3jQ5sOWDPC4nO6dmUophepW6vT2mTqGaEgJ3+t6EeVAB1LnZr4edGZuJ7RHvdmtvR1UCwWEQmGE3ag3i9vTZtUsis/uNJBwFLa5TgrbAVEqlXD//n0cO3YMx44d2/Me5xMSzick1HULO47ql/3+VItCZYQ2BPYM7ql48PcV2VMMC+/mG94IicgRJCqbkHcLuH37dtfKCPvdDfL1FFXDGyfIhkTcvH0Lqqoin8+jUCjg5cuXCAQCHvlLJpMDkYW1huZb/EyGRVxO2SlDFdXw1KbJIO8jJ/3iyrzPyZC6BltNd67XYSea7bnWzouuZSfrGgD+/N/82/i6j/xFzIQE/KFLp9FgPP929b1J4S9qGl7UNDuTWuI98Ue3a2cQsgfYtkfuuZEI2PvJXifdRCJuYWCQ71BtaxmPGrPXbYav0WgcZul2wCHhGxFuni4breZrJ0b3ploAzuzETh276t7V2vExCec6xKMNg21Z92T8E+FAX683ny3LiEkbiqJgbm4OgiBg5tJ1PHFsO6addJF+1i+joFOFb1dtkboj0SBUk/qUuATA+X0qce3EAB2LbTm4p+JBnHBENe1VALa10zSskaqcArFJbKcW7AdpniwQCGBqagpTU1Nea28nn8dmvQGabsVMEfgJRFkzUdZMPGUUtjlJRCLID3Q9bG9v4+HDhzh37hymp7vHWRFCEAvwiAV4nByzH4Ivq6pPZOSCAlhtaFhtaD4PwmiPh+oHHe0+dUGOIFpcgdao4datWz0jDv0Vvv6fnxUyuC4BwWDQ1/p1LYEeP34MXdeRTqe96mCn1u9KTcXjcstMfiYi4mIy5H0fa+w2wwHffdbv0kPRNJkRCd3yXaOjGFEFOIK4c41GBA5h0b5OJZ7sOYc7qaIBIDs1gyNjQXAch5gUQEwK4JhlwTAtzBeb2NX37lndsFCvW3hV1yFyQCYoICPxSAcFb6GimBbeKzS96nbIaeN2MsBmffEmnREG9tHQ7YkyDOHbbLbslSZDwsjXU6cZPjdj9yArfL9fcEj4BsTePF37/xa1TzBCSFs7t4M6VDPw7lYNShuxIqaBm5MJjB9A3NBKrXeyRjs4n/Fy55auru9VDruoVCqYm5tDJpPBxYsX8T+2at6/uQrZXvFno4IQskely7ZuYiKPz2xWDlSJqzmzXdvsbBdHMBkWoZkUcwXZI3mjfEyiawjARDYeQyQgQDVbStNTcQnHBvg+P0jgeR6ZTAYFIQqDTRmpl2Csv0A8Owk+mUFTCPkiq1yF7euaBpEjyDrmypkucz5uxNyVK1f2qO56PUYMi+J5RfGRBJ7YVfa6ZnozhoDfg1DiiVONFJEakJB+EFDVTLzH+NSFeAJp6yWooeHWrVsQxd7XxjDntM5474kc6egV554fmUwGlNqJRfl8Hmtra3j8+DHGxsY81W80GsXrmoYlJk+83TPTpNTrJvDEtizZYSr7L6sqMwc7/DXqVuoiAgfO1LGzvgKaOwoKAp4Af3AyNtDii1KKR7tN33l3NBrwKn3tb8FxHHgQX7bt1WQQu47hc42ZP9Atm0xtNg0QqEgEeMQDHLaarWprL7JnUYot55hxsI8h0L2SxsIVbPQjb5RSXzt3ch9G3PtR6X4p4pDwjQi/nQnQ0AxUHcIRD/CItwklthq2OrR9fRbjLJDNVxg/2VnePQxk3fTUYmGBG0jxuJ+W7tbWFhYWFnDq1CkcO3YMVeehCPiPAUd6k8pRwHEcKKVtM3z2/5MBAe/u1LzPM6oS16Qt5Wu+qWOD8RNzoVp28sIg6NbaMeQ6niw8wMz0lC9uzs5Ptt/7AzD+MTRMSrFQbHoPEAA4HQ/ixMwxKMcmnCzXNWhM1JsejKLKnG66ZatlN2QdBHYsl1tpC/IEL168wNraWteIuW4oKgYWSrJPwZyRBFxKhiAJ9rlV0UzkHc+/GlNZUUyKFacVJxAgI9mt6EyftI8vJnZVA3fzDW9kICIQCGtPIfIcrt68OdCgPdtU7MdrNuWWNdVUWOxLigkhiMViiMViOHHiBFRVRaFQQKFQwKvXr4HsDPREy1ftRCyI0/EgKGzlakM3sSW3fOMIgN/aqPlI3YbcfeHqfS4416joNwcPCxwkR8hULBZxf+E+ps9cxKrjlTceEgcmew9LTawz+3IlFQIhwErd2YcOx2qb8cSbCIvIRSTkIsBpy4Ji2NZEBcXErt7qIFC0vCldCAQ4GQsg2IW1FRQT7qmeC7UqhL4KX4+W7iDnUd2wvLZ7XLQJ9KjopdI9JHx7cUj4RoTQRmK62aBQalcRnpb3DtyfSYSQNGQ81kdPLmCxWvf7zw1SJu/Xbu3kw0cpxcuXL/Hy5UtcvXrVi51Z7SCYAN5Mha+TD5+LItPGGRN53MyGu7a2Davdo641szOynckeUmc/MEIdlK9bW1tYdNTfMzP+oHV/0sbvLcanWxRzjAKUALiYDGEmalexQ6GQL+qtWCx6UW+SICIy7ka98b4HWMGZaXoMBaKpAbKJi9duIh4frH1jWhRPK4ovMoonwLlECDORltCGEIJEUEAiKOB0XPJI/07TQElttaMMCmw1dWw1bUKaCPKeDc2oc7gHjYKiY74ge8dxTCCgrx8jHA7h8uXLAw/ZD7Po6NTOHQbBYBDT09OYmprC4q6MlQbTmm3WsK7JWKtJ0LF3LhTY657Aov0ajTDjEVIndTqDQqGABw8e4Pz581gXooCzwB7kM7b7HRK0fCdZoUmnb2O9rVXt/S7HIRzgcCwg4mjMgkUpio4p+Y7ir1ID9nF5WFaxWFGRduLeMkHeuz9uMIszNrJtENHGoKbLG7JfELIf+Cp8btfNsg4JXxccEr4Bsbel2/q7alieWIMnth0I4Hhc5eu+CgdgV5yuZ6NISSLKZXXkrFoWFqUe4SIAZgacU/MnbXRu6bL7Z1kWHj58iFKphLfeesuzbjAtivV6q53iHgP77+/PDF87xh0lrgXbib+TUEIdgYFyAKKif47O/a+jnUkHUEqxvLyMly9f4vLlyx0NQDnf7w+9m180KIaF9woN1BkFaK92uiiKnm+VP+rtEYiuIzU+DRJPo04Cvu9L5wNAcgL3ahYkueaJPlJBoeN5sasaeLir+PKdk0Eel1O9hTaATRBmY0HMxoLQLYqCoiPfNHxpHxTArmpiVzWxBFshmgvZ7egE40H4fmJL1nG/2LIiSogE+osFpBIJXLhwYah98ok2evxeXW9V+mMiN5AC22Kq6a6NScN5n3byRkMx9FsiE9iWVJpJvRb2tXQYiQA/8DXajp2dHTx8+BAXLlxAIpPD/U17fEXiCVLB3p/RohQPmGo3AXA1HcZEuMOMXNu+KYblLWJDPEGyy7Y4jrPbsFEeMclCYafulcDYaDTA/rFr+QLYSUDJAI+C8/cgR5BmtsO+tptoYxAPPotSb0aQbRmPik4VPtca5ZDw7cUh4RsR7Em/JWveTcn1fmsaFr6wXfUeei7GQyKuZFrxaKP43HVCvql7Xmy5sAhpwDJ5e2t6z78zFT5N0zA/Pw/LsvD2229Dklq2M5uy5glYJiMBn6rxTVb4Xj1/hr/98W9HYXMDX/1N34Jv/Mv/CwghiAgcFJPi05s1X+rFwO9P/PtKYM/ZnIgFEOD3N7RvWRaWlpaws7ODW7du7fE787bJDpmPvLX3F3XdnhNzq6MiR3AzEx44a5bjOKTTaaTTaZw9e9ab68qvv4BRqyGWzEARQ7AicZiBlpqUbbPyBMg6bdanDx/gdz/9W5g5eRr0j3yt971xBDgTlzA7YK4xC9GJS5wMB2BRirJqeqpflkw2DAuvahpeDTiLeNBYq2t4uNvqLKRFoLF0D5MT4yMltrDo9VJ/skarGtWJ1PVMfOkDntgEiDd0yLrhpfnEtDpOxwJIp1OYKyleSkpaEkZWW7uioMuXLyOXy+ElY8U0Hel9DlmU4n5R9mZ/CYDrmTByzAKom58cAKwzLgdTfbYF2DOwX9ipe9dgROBwMxMCByDf1FBQTBQ1y0ekq7rlWfQAgMgBecVEOsiD50jP/fM+wwAt3aJqevfj7D6+D2+bHfbrkPB1xyHhGxHsCARrO3I0FsSuYuAL21XfBUUAXOgQj3ZQhK+fYKQbBvHhM00T9Xodd+/eRTwex+XLl/dc2Cs94sze1AyfZVn41o9+BM+fPYVlmvjXP/5DOHLqDN76qj/aMbWkHUHWzsSZ2REI8Kqm+XJwY04ObuwAWnSufU2z2cSdO3d6moOySsjfCxW+9jmxEM/hVjY8cmuzfa6rUqng3r17EFCBkV+DFIkhlJ2EHoqhahKPMJhOm/XTn/kM/rc//422Iaxl4aPf/X34hr/8XYgHeFxOhYbKNe4GjhCkJAEpScDZOEXDsJBv2nN/7OxUr1nEQRdnw+BVTcUSo2bNikBlcQ7HZmdx/PjxkcjeICpdw7J8YoSaowqWdQuKOfpgwpjIIS2JtvrVuV6Djo8kpRS/u1WH7lzzY4aMpaWX0DQN5PhFQLSvsVGP8ubmJhYXFz1RkK3UHywuzqIU9woydpRWVet6Zm+1u1uFj1KKjSHa453I3u1cxPPqOyIKODJmV+N2Fbv1W1AtNNpW+3WD4v6uAg577W32U+Hbb5Tanm12qPA1Gg1wHOcrSBzCxiHhGxFsS9et4o2JPCqqvscgN8RzuJmL7hFyADbho5QOHTrNomlYnhpN4rmhlKiDJG1omobPfe5zmJ2d9YkKXNQ007M/iIr8nmSPN1XhM4QAXj5/Dst0nfQ5rL987vs910yXnaVzPeraqyxbso4HJX8O7rFYAGdGyMHtBFVVMT8/D0EQcPv27b6qSHaLe124PljYknU8KLZSD/rNTg6Ler2O+/fvI5vN4vz587AsqzX3t/oCAcIhMj4NGkuiTnnoFF5UFXUq1L/x738J3/xX/hckAzx0i3rq+oMCIQRRkUdU5HF8LAjNtDzRR0Exus4ijrlpHyERY/u0fKGU4nmbGfi4YKH0eB6nT53C0aNHR39v5hxUTPueY7deW/OvzbabCDt71g08gUPkbAuTgtLy0iOwW7HjPWa9KprpLfBSQR6Xj5wGPXMKjUYDd0st0vvuu19A1lH9xmKxgY7z+vo6lpaWcPXqVc90n91eMsj7koRYmA7Zc2PrOALcyISRkfZ+FquLIGbvtrpfT7Jh4gs7DR/Zu5OLdLwGeZ5HJsIjE7Erc/mmhvnS3ka5BXh+eS62mrpjQcP5CwZ9nmG6RZF3WsaBtpbxqOik0m02myMbev9+xyHhGxDtJ4/Q4WQiBHvI3mRYxJVMtGsLx62UDZNB2A5fusSQLSpCiDff0anCVygU0Gw2ceXKFS83sB39xCJvYoZvV6fQp8/i1ld+DT7/X/8vEOfYXf/QH/b9nmpRCCZFPGDPvnSapTIsisVy0/dwCvIEV/aRg9uOer2O+fl5JJNJXLhwYaDvmrwBovwm0O6NlpHs1IODaluWy2XMz8/j6NGjOHHiBAgh4HkeuVwOuVzOVtRWKsjn89h5vQjLAviZ00iPT3lkj+N5ZKemoTmq6td1DQGOIOvM2GWCgm8RdxAI8BymIwFMRwIwKUVJMTwCyAqC7HaaEz/HE+ScdnRKErpWUzqBUorFsuLZewDAJG+gsHgf58+d63r9doLZ3n7VLeSV1vWxMGTqC0vq3Gq6W61zE18MR+jjkj2OANcHsFJa61ABI4QgGo0i0ACaTqX1yMwRFAp5LC8vQxAEz/IllUp1bEW6dj/Xrl1DKpXyft5NQMHCtGybJnf2jifAjR5Z0f4KX+vPg2wLsP0Vv5BveGM9UaeyN8iCi+M47DL5g2diAUg8UFBNFFUTaluzxJ79azoKdVv0kZEEmKbZs6W7xXjvTYQ6z9kOi24VvnA4fEj4OuCQ8I2ITg8H1o2cALicDuNIrHdZ2X3wm6bZt+LTCZRSX5TakRG82jhiz2iwqSGWZeHJkyfY2NjwzHQ7waQU6w7h4wBPhel7f+bPB0FcXlcVPK4aAM/jr//wT+G/XroCq7iFb/zmj+DolRvYbuq+2Ul2lirgeIKNh0SkJAE1zU7MYGevJkIiLiSlA7PYcBMgWMIyCHyijQPZk4MFpRTPKipeMuffVFjEpdT+zMNZuIPyp0+fxpEjRzr+DiEEiUQC8XgcwvhRPK0ooAD+2F/8Nrx4dB/vfeo3MHX8JP7mP/gR3+s0yzbRXm/o4AiQDgqe8OOgKpMueGLnCGdDIs4nJNR0u0K20zRQ1Zm0D5N6Zs+880DNSiKyffbJcuw+2JbZFFFRePIQly9d8pT0LEyLQjatNjGTXVEaRaHOA3A/CU/sZJOIyA8U46dbFHfzDS8phyfAzUwEqT4LLtOi2PJ57/nvoW6cFQEwPT2F6ekpTxhUKBSwtLQEVVWRSqU8w2dJkrCysoIXL17ssftp9/qb6FB5dImrOxbCE+BmNoJUjzlW3yyaU9sfZFvA/sieu223bUwAzMSCCPAcpmL2c6miGnhSUVFtU8/YCnUDW47nn0Qi4MMW6rqFiLD3+95kz80DaOcCnSt8siwfpmx0wSHhGxE8IShtb0FVmpg46o9xkniCtyfGBppdco0qR53jKyg6mk6gYDYkItSlvdALPAcYZouM6bqO+/fvQ1EUXL58GY8ePer62h022SMS6EiSDmqGj1KKxZKMVwzBGA8H8Ff+3J9BMb8D01ChrDzD6VwOoWwSJd02f91lWhKaRbHW0LHW0PekPewnB7cbNjc38fjx474JEJ3A7sMHbYavE8FwvdEO6titra3h6dOnuHjxIsbHx3v+rmyYWCg1fd91KhrBJ37mn6PuPKjE53MQV2SExqdhhu2oN/ect6gd5p5XDDzaxRtN1iCEYCzAYyzA41TcVmHuOKrfomJ4bXGTAttNwx7234UTP2eTUjZ+zqQU95k5MQJgksooPFvEpStXERpLYFvWGbGEObLtkIt0kEciKPii/DYampeycyQaGNgpoD3XVyDArWxkIKFPuz9de1XZPZa+iDVGGORmQRcKBWxubuLJkycIBALQNA0XLlxAPB73vd8Os71O3nuGRXGXsSPinc/SPubSjk4Vvn7bAmyR1Ls7DU+9HhU53MlGhlqsFhXDu4fnQn4vSZ7nkQrziCsWqoZNPo9HBNQNCyXN7/nXJCIQSeGzeRkhnnjVv2SQh2JSVJzvNypwBzIPDXTO0j2s8HXHIeEbEf/in/wE/tEn/ncAwJ2v+jr8zZ/4Z+B5HhNhEdey0aFaMZ287gbFqGINFjYhozAphSzLmJubQygUwttvv41ms9lz39hkj3axRuv9W38edWzbcCxu2Ezc4858HZlKgp47i2q1inw+jxcvXkCWZaRSKUzncriQyaBicd4slcXcpFjERB6GZceihYT93SwopXj16hWWl5dx7do1b/5nGHxQZ/gMi+JeUfZMvgG7mjN7QEkg7LG7fv06kslkz99dbWhYKiu+9s5s1D433is07NUMgA996EOolsu26vf5MgTLQjQ3DYwlUScB76EH+JM1QkyyRvINJGtIAoej0SCORoMwLIqiYngEkN2nVvycirDAobmxjB/7u9+Hja1tfM1HP4av+jMfAQEQsjRsqSaEMzcx1wTQrA+1PwKBV5ljW6+rdc0zDD6TCCHeZrfCmgnPDOi9p5gW3ttptXEDHMGtbGQgKxegf8vTXSh1+8bc1m80GsXs7CyePXuGtbU1JJNJLC0t4dmzZ17lL51O9/QXbK9SDkNcO4k2+nkZtpO9mMjh9pBkb5DtAP6F+nRMQlTkYZgmis49taBZvvnNpkmx2tCx2tDBE3uW2sVBVffa9+uwwtcfh4RvQLCrhUqlgh/6gb/r/f0L/+2TePA/fgd/4o9+HS6kwkORPWB0pa5qWth2brJBjiA3oomle6EYFsVnP/tZTE1N4dy5c96sVLd9GzTZwz8nOPz+KYaFd3dqXpIJgV2JO8K0jwkhiMfjiMfjOHXKHtjO5/Peqn1sbAzZXA6xWAqvZNoxK9N9oC6WFYyJPMadasqwFR7LsrC4uIhisYhbt24hFosN/6HRnv050lscOFTTwt287LUhOQBXGD+x/YJSiidPniCfz/c9dk3DwsNS02e0HeIJLqfCHVuBbJTXuXPnvAVCfvUZzEYDiewEhGQWTSHkUy02TYrluoZlJ1kjG3KTNcR920q0Q+AIxsMixsMiKKUoayZ2HNUvqzyXDQt/7Vu+CTtrq7AsE//07/xNTB8/ifM334LMBYBQYI/pLguRUah7yld3pq4LYWBn5do/dVUzvTSSeIAfSAHdNCxbwet8riBPcDsbGVg93fT503Ed/enc+80gcV8vXrzA5uYm7ty5g2g0CsuyUHYWCE+fPoViWDBOXAEIQZCDz3tPtyjeyze8sR7RIa7tpLgb2u1FFNPy7q2dfP4OiuyxEXgBzq7Kdd6/1p/d55vA8xiP8hiPAi9evMDy1g4mTp1DlfKo6NSnmmejE9dlHYZFkZGEfYuU3Lfl0PqOG43GoSVLFxwSviHgWgAYhuHNhrgwdA2rdRXrdRWZkIiJcADjYXGgC3BUwrdWV72LaiYWHLny4L7OohSnT5/2KfncCLNOisZhkj28OcEhmUtF1fEeYzMgEOBaJtL1xuQiEokgEong2LFjUFUVW/kCXiqAKre2HyTAiXgQskGx09R9K9SqbqKqm3hWVRHiOZv8hUUk+xjoGoaBBw8eQFVV3LlzZ1/WAP4K3xcfDd3EXScvGLC/ixt9ZpOGgWmaePjwIer1Om7fvt3VsoZS2+Jkcbfpsz46EgngbELytb583xRt/aB9gdBsNr2oN3V3F7GxBILZSS/qzd2MQe1ZpE1ZB0ETqaBtr5INiX3Nm/uBTX1pMIkvsr7XIFzXNGytvPb9bHlpEedvtiIaXVLHEjpXoT7KfCpbZW6/BAa1KXHRcOxa2HzX27noUMdwQ/Zvs9N16e5zL15OKcWzZ8+wtbWFW7dueWSB4zikUimkUimcOXMGS8U6XjcdT9KddXx+dRGZTAaJTBZPFc5rSYucTVwHrVICfmNjjgCbbVU39rPVdVuNq+2T7AG2pZj7rU72iMDrlbTx6tUrrK6u4vbNm4jFYrAsC7ppJ9MUFAN51QL7dGsYFC/rOl7WdYdk8sgGBaSC/NBCL5cot+foHlb4OuOQ8I2AdDqNj/+Vv4Z/9k9/GgBw5tpNXPvyrwBgX7j2MLYOFIGUJGAiHMBEuPt83SiEb49YY8R2LqUUmqIAnAgQgpm2wXhWVCIIrdPFotRTBxP0T/bgnIG5YSp827KdP+zLxM1Ghp7/qFEeL7kY1GBr42GtDmP1OV4TIJvN4kI2h0A6jrxi51KyJqRN0/KUnSIj+ki3KTsVRcH8/DyCwSBu377tO16jgL3Jj9bwPzhUVAN3C7L3kBn1u+gGd27Usizcvn0bgUDn1pJqWni028ROs1XVC/IEl5KhoeyI2tEt6q32+imCTNRbjfIeyaSwY/yKqoHFsoKYyHmijzGx88LAJXXthG7Y1BcxEMD5m3ewNP8eQOwB+Qu33/H9jm7ZCyyJ55CRBMT3mfbh9+FrwXIIOGBXWiZ7qEkB25vvPaY6FRZswhIaguzZXnj9W5Feha/H+ywtLXkV5V5EIc84zLx97iTkcglbhSJeFGTQoP06ARS30qGhyJ69nwyZpn4CzcaP1ZzKnnsdjokcbo1I9oDBI/AsX+u0dTTd0YubDtkD7GdGkOMwIwqYGQPuFxpeuobEAQpzM9Msig3ZwIZsgMC2nsk6qt9ByL9X4WP2ybVlOcReHBK+EfH3/9E/wqk/8sfRbNTxlR/6MhxLjWFL1rAta55aCgBKioGSYuBxyW51jIcDmAgHEGNuCKMQvpJieC2e9Ii5na4JsC6lgVAr4sdnsunI7Nvn+PKMtUQu1N88lnfmBAe1ZXldbeIRY/0QD/C4kRnO182kFM/KCl4zNhUiR3AxGcJEOA7r+CTK5TJ2dnbw5MkidF1HJpPBiVwO4WwSuzo80Ye71zqj7OSJfezHQyJChoKH9+8hnU7j/PnzI1vssPBHq33xanz5po57xVYWa1TkcCsTOTDDYJcoS5KE69evd7V22JJ1PNr1+yROhUWcT4YOtLXaHvXmtvV2Xj4CNB3J8Slw8TQaXBAKsy813ULNsVcROYIx0Y7ao9RuC8uG5ZvJGxQBpv0qENu81qDA9/3TX8Cv/7N/gvrGa3z1h78eX3b1Aoqqf5aqrluo67aSmrWhSQf3l/bBvnKn2YqXy4V7t7krmp3E4v5+1KlODauKLmumV2lOBfmuZNE9Ep0qV5RSLC4uolQq4datWz1N0Nv98OKhIKTAOF6QKKgbIUhNBDZf4r2nFSSTSW/2r9f7umBPi4ZheTONiQDv3dtrml0VbZE9Hrey4ZHJ3jAReOx8rPv1vn79eg/Za4dhUU9MJBDgD0xEoRom8k0DBdXErmZ5i1kKoKSaKKkmlqoaIgJBJiggIwlItHn+tfbLqfAxh+Cwpdsdh4RvRAgch1OXrwIAeDHgWS5cSoVRVk1syRq2ZM1n92EPgjfxtNxEROAwEbHJHzcC4Vup70+soSgK5ubmwPM8khNxFBxVmUkpBOZ27hKXdsI3rBWMe5Po97yjlOJxScZrVonrZOIO45NW00zcL8k+e5Z0UMDldMhznWdbNmfPnkWtVsPOzg5evXqFRuMhUqkUJrNZnE9nUKM8ttsMdE0KZ77KAChFaPYCwskoFAsIHwAX+iBEq601NDwqNb3tJ4M8bmQiB0awGo0G5ubmkEqluhJlzbSwWFZ8tg4Bh7j3MuRtxyjHsL2t586Gbm++hqbqCCWzILEEND7gay/rFt1jWNsLAY74UiRco/AIYxBedqqs7nZyqQT+yrd8EwRQXLt2DYIggFKKutGyfGGtorrZ0GRDgndN9AJ7/NhKIVuNmunRzm1PYtkPYfFvs39lqv1spZTi0aNHqFQquHXrVt/Ri3ZxiGJaeHen4ZHAIE9wJxtH5Oit1jmyvY2lpSVEIhFks1lks1mMjY11rLKy90U2e92tutU023pFZ8je7dz+rkM2wWOqj8iGPY4cIXj9+jVevXrVk+wB9oLZvV9OhgMQeR4izyMaDGDWsmBYFoqOCXmhzfOvYVA0DB3LDR2Cc75mJR7poIAA7yrU7d9lq46HLd3uOCR8Q8Cd4QP8PnzsfAMhBElJQFIScC4ZQl03sSXr2JI1T3QA2Ku4FxUFLyoKuPQsTMOC1NSRkvobUmqmhS3nhidyBOMDKuJcVCoVzM3NIZPJ4OLFi7hXkOE6aLXP2BFCvHg1FwqT7BHkyUCtNPcz9ZrhMyyK+Xzde28AOB4L4swQVh+U2gP2T8tKy5IBwJlE79xUQgjGxsYwNjaGU6dOQZZl5PN5bG1tYWlpCbFYDLlcDiczGSh8EDuKTfS8ig0haBIRSxUVSxXVa++Nh0TERhxM9s3wvc+Mj1KKlzUVzyptxDs9vCipGyqVCubn5zE9Pd0xwQWwxyMelZq+dud4SMDFZOjAfBK7QbcoZN1sy30FGoE09EnbiNerQQ/x/QQ4grEAh4wkIuVYm/SrthUVA3OFhveAGxMI6PIigsEArly54lVFCSGIiTxiIo+TY3YLPN+0Vb+sQp21ocGuTSBcy5du52unlq7aJi5Id5nnbN//ZIDHjexohMWwqEf+eQJfJm23ffY5BViWNyt669YtBIO9F6ztfniJAI8v7LTEJhJPcCcX8RI32PlhXddRKBRQKBQwNzcHjuN8hs/u2AfrXuBm7nKO917Vqey5ZC8e4HFrxGPXOi7Um4Ek8LeNOx8DePu0vLzskb1uOeAufK3ptsUAx3EIcBwmowImo/bYUFU1kFcNFBTT5/tnUGBbMbCtGABUxEUOgWYN/79/8IPYXl3F1/7pb8Db3/YXANiEL5vNDngkvrRwSPhGBJu00Y3EEEIQCwiIBQScToQg6ya2HfJXYpSFFiegBODz2zWbwIVEjEcCyEpix6rWekPzyMxMNDDUA3hrawsLCws4deoUjh2z/QN5381w72vc3FoXrFjkSHQwsQhb4eskAFEMC+9u1zz1Zyclbj8opq3aZO1CoiKHq6mwr4U+CMLhMGZnZzE7OwtN05yB/jxevnwJSZLsFbumYbvaQObEGVSp4Kvmsu09ybH1GB/S1sPnwzfU3u8PnRIbjkYDOJ+QDszbqlAo4MGDBzjVJe7LsCielJs+ZahA7HNi8gB9EjWTJXNMsoRh+VrHg4K3TFiqDKKrCEoS+GAICnhf9U+zKAqKiYJiIixwHtHqJgjalu2WuvsWCZHAePkI8VgUFy9e7Dk+EOQ5zEQDmIkGYFoURdVeqOSbuo9EuyKl58z5mgsJSAVbC1CfaMP5/0ZD9346Fe68oMo3dcwXZY9spoMCrmdGT2LZ8VWNOvvTuXCvSDf717IsLCwsQJZl3Lp1q+usaPv23O8vIwm4W5A979N+YhNRFDE5OYnJyUlYluUlwjx79gzNZtMzfDaEuPca97wbD4mekvkgyR5gx6W5IzkZqb/RuDeKY1l4+fIlbty40ZfsNQ3LM58OCxwSfe7BPM8jGeaRDAdxyrLsxYqsoaCaKGmW7xqq6BZ+8K98O+5/5ndgWSbm//tv4fbsJL76q78ajUYDx44d630AvkRxSPhGBHu9mQM+GMIij+NxHsfjkmOpomFL1pGXNa9/p1sUaw0Na47TftZR/OZCIkTeVsyu+MQag6lAXW+zFy9e4MqVKz4j237GyOyMIaV0jzp3EPBt5IW9XY2qxGWxLet42DbfNRsN4ExC2ndFKhAIYHp6GtPT0zBNE4VCwbthi6KIQGkT5zJZBJMJFBwbDbaVppgUK3UNK47oIys5cV5S7zkqf4Xv/aF8pkXxoCR7VQYAOBOXcDw2XGRfL2xsbGBxcREXL17ExMTEnn8vKgYWSrLPGDgjCbiUDA09N8ju8aasQTGpj9yNQuqCPNN+7ZDPTGnSe7DnV5ZBZRnJ3CT4ZBYyL/ksKmTDwuuahte1zufGekPzxZilRYLm8wfIptOeddKg4LmWnyClEqp6y/Klxow+sOerm/aRC4m+OS5CXOFEb3XulqzjPkNWs5KAa5n9VYn92+xO2NhrhiN2BclV0N+6dWvgZCO29VlSDbiHalixCcdxSCaTSCaTPsPn7e1t1OICIIXtkqRzbJIB/o2QPfszDXYMXXhjLIaOOzdu7DGk7r+NwRZphkVb5uC6hYYBaLTz6xbvfgGW5dhD8Tw+97nP4au/+qsPW7o9cEj4hgB7wrqVMZMCxgjP4iDP4WhMwtGYhIePF6EIErhEFjtNzTcjZreD7VSItCRgLMCj7lTBkkFhoMqV28IolUp466239qzM2MVdJ1EFW+ErKoZXycpIAsIDikV8LRVGGNKuxA056s9Bvbg6VYKCHMHldKhjSPl+YVkW1tbWIAgCPvShD3mt36WlJ9B1Hel0GsdyOcSyKZQMe8avqBg+0ceGrGND1sHB/k67xXn5DavfPDTTwlxB9oxjCYBLqdBAD4RBQCn12kGdzKhNi2Kp4q8s8gQ4lwhhpscDg1IK3XtQ+P9jxyge7SodX98JEs/61PE+n7p+s6Ru1FsikcDp06e9ma781jK0SgWxeBLBzAQ0x/LFBXtuENiEgvXey4pA9ckcjszM4OTJk/si4IQQxAMC4gEBp+MSmu7cnyMyc89XX9oHA9mwoACeuCDJiAtctJPViZCIK+n9xe7Z3nuDVY1o29/u378PwzBw8+bNgcmeYlp229sBS/buZPcnXHJbv7Ozs/idjapvIQBDx+OSCXD250s4ZO8g8qkNxnvPdR3o/xoLAIEUDA5E9iilPiPuKUa53dF+SLcr68OIms5ev4WFz/4uLMuEZZq4ceMGDMM4FG30wCHh2wd4QmC2ZdCOApHnQHQZF3NRmBZFQdGxLevYljXvAqCAPdjK3HwknkNDN3sqdDVNw/z8PCzLwttvv91xONlf4dv7HuwMH1vdO9onJ7j7NmxhyKtKE493R1fillVjTw7um5zvajabmJ+fRygUwq1btyAIAiRJ8gb66/U6dnZ2sLy8jPqjR0gmkxjP5XAunUENPLadVpp7jC3447wSAR7jDvmLiPz7OsPXNOx4K5dg8AS4ngkfGGmmlOLp06fY2trqOPuzqxpYaPsuU0Eel1JhhAW7sq2Zlo/UNTxLE3OkRVeL1PF+wQTfn9QNA3amS9M0FAoF5PN5VItLCAclhJmoNzaqiiV7AqEobW3iyLGTODk7c+CxUSGBw2wsiNmYnfZRUOzKX14xOlZBP7/TABtG0z6ftVJX8Zgh2NNOxvJ+97u9otjr/XzK11odvEMKhrFLYv3wXEQEDneGyKodBN6uOp+HCAKoeweQa+DzO9hQ7dm/QVS/vbAlt+5BE6Hu3nsuVldXYdEoQAjEAT9ziSkMhHgOL6qKd+2qnR4yfRB0r1WeoG5QVDQT3/2jP4Nf+sf/EPLWGj7yTX8WX/M1XwNZlnHv3j3cvHlz6G18KeCQ8O0DAkegWcObCbeD53moqk2keI5gPBzAeDgASsMoqQa2Ghq25VZmrotNWcOmrCEm2pFu4+EAxpg5oHq9jrt37yIej+Py5ctd7S74AVq6lmX5xCKBIZM92lvgj8oNnxJ3IiTicio00IPWohQvq/Z8nLu3dlh7aODWwbCoVquYn59HLpfD2bNn98xNEUIQi8UQi8Vw8uRJz8jXVepFo1HkcjmcyGahCpLdSlN0383PTfpYqth5k1mmpf0m+V5NM/FeoRW+HuDsKuugKQH9YFmWp4i8ffu2r91iUYpnFdWXj0xgD6tLPMHTsuJlv45C6tyEFwA4NRZELGCTu9ABk7pBEQgEMDU1hampKZimid3dXS/qjTNNxMenIccyUOA/9gYlQHoKrwFsbdY6ztgdFASOYCIsYiIswvLSPnSs1jXfgpD9PpbKCnZVE7mQiIZh+sQ+BzX/2e69N9XH78/nbQeKGzdudL0HdtveKkMwgdFtZPqhnVO7ZC8Z4HE+lUS5aHmJH+Fw2FP9xuPxoY/rujy4Sfba2hqePnsGnLYJFPussChTqdP9FTt2HKNpWlhr9O9ReEp1cW9l3R6VoHhSVlDR7P2PJZL42Z/+J17Kj6qq+PjHP47x8XF87GMfG/yAfAnhkPDtA+7JbxwA4euUV0sIQVoSkZZEXEhRLO028aK6ty1V003UKiaeVRSEBA4T4QBCuoznC/dwbHa2qwLSRXu7dc+/Oy3dtXpLLDIdDQ41h8M+lO4XGj7RyolYEKcHVOLKhoUHxVbbEbArg1dSoZG8CAdBPp/HwsICTpw4gdnZ2YH2kzXyZas6r169QjAYRC6Xw9VMFiQSs1WUTd1rjwF2q6zOtDZlw0JB0Q/8AV9UDMwXWlYZYcE2ct1vaoQLwzBw//596LqOO3fuQBRFqI5QotA0sNLQ9lSQKOCzYOmHEE+8Wbqw2EqWCAkc5vKyF781GwseeBTaftAp6u3hruIje0G9CdW0AKnVomqfsctKbtSbcOCVbY4QpII2saxpZqudyhNfC9Kg8NrRLI5EDk7ss6ua3qI3HRT6zs5peuseE4+PDUX2APscZCvO+0m06IflF8+w/OIZzly5gWTOnq9OBnnczNht3LFIxDMFL5VKyOfzuHfvHgB4qt90Ot23eikbFnad7zAicD0XdWtra1h6+hRnr97AQ9n+WdOxo5EN0+f3OChYT8kWufPbD3UCpRRPKwqWmXvilVTII3u6ruNbv/VbsbGxgc985jMjZZd/KeCQ8A2B9puWe913U54OikGMlwkhyCutm+nNbAQNw664seSnaVh4VVUAcBBOXUczKiHf1JEOiV0JWr8KH8dxMAxzJLFGp224ZI8AuJgMYWYAJa4bp/V4t+mrMpwcC+Lk2Oixcv2wtraGpaWlrgKDQdBe1XFTHB48uA/ATvo4m8shmEqgqFrYbuq+7xRwszplCATIhESMhwRkpd4KxX7YlDU8KLY89uIBHjczoxu5uqCUQrUoKk0VT16+BiIpxNJZvFtSIRvNjmMD/RDiCcIivyf3NSx0NmT18MHhdz1hAXihC6jxrTGJRKOA2upLCIRAio0hlJ2CJsV8UW8mtX3btpq6l1TgVv/CXZJ99rOPLkICB9m5ZyUDPCqa2XHOdLWhoawZfRNIBsEwlSlN0/DgwQNg8jSAzsbLvVDVTDxk5g8lJ+f3TZC9X/3VX8V3/vk/D2pZCEWi+Pu//Gu4fuUSbmT2zuyJoojx8XGMj4+DUuqJg168eIGFhQWf4XMn4cJGm00KcSIvFZOt0lko1WXUNRE4fQMP5dY+qCaFahp73peFO9sO2CT5eCyIiEPsRl1wPa+qeFVr7fulZMjzDjQMAx//+Mfx/PlzfOpTnzokez1wSPj2AT9Rgm+mZaj3GYDwVVTDG0CPB3hMRGzCdTIegmJYntFzsal7cyAGCFbrKlbrKgRit2AnwrZJNHsjaS/Td9q/ugXUzeHEIiyMtgqmQIDrmQjSAyhxdYviUanpMyQN8QRX0mEkDyjHtR2UUjx//hzr6+u4ceMGksnkgbwvz/PI5XLI5XKglHpJH0tLS1BVFZlMBkezWVzKZrBrAI93m752ruET8jQd0Yct/BjEPNfF65qKJ+VWtTgrCbiaHtwqwyV1ss5ambTiwjxSl5wCADSV/ibE7USOVb++KUL/QYBhUcwXGl71jACYMusobK7g1q1biEaj3iKhuvwMQV5AdGIaViSBGuWhM3N/blLBk7I9FuASrf3GqnkbcODua4gnuJ0NY7GsYLXDvBvgtygKcrZvZy4k7Ikm7AXDothyqocCsS1LukFVVczNzSEYbc2JDvPZK5qBd3caPgL7Vi76xnwf//4//Eegzv1RVZr41L/9BfzPf+Rn+l6L7eIgWZa9TgLb+s1kMhgbG4NiAatMhayoGFhv1NA0rA4jIwIQ6H5vFQjsqjpTUXf/v1BqekKXc4nQQPf4XnhRUfCi2io2XEhKXpHANE381b/6V3H//n18+tOfRi6X29e2fr/jkPDtA+1efMKI5YRBCJ8vWaMt2UISOEyHeBSePkVM1TBz7jJKpu1/5XbLDEqx0dCw0dDAwa4STYQDGA+L/vm6Li3dkiV41ZL27ffDVkP1btYAEOCAO7noQErcThYdU2ERF5KhA1GsdYKraq5Wq7h9+/YbU3wRQnw2DfV6Hfl8HisrK6g/foxEIgGSOwlKOAQ5grQk+DzBWCHP410F8QDv5fxGhG7mubYS9nXNn45wIblXPUkphWqy6lfTI3dNltTtAxMhASfHgoiIg/sTDoMPOk3UTAt3C7Jn48MTYFwto7jqN7btFPWWf/UYVFWRGp+2o974oD9WzbBQr7Vi1XJMrNoo84udvu6pSACPyopvtu5CQkIiKCDvqH5ZiyK1zXYqLQnISXbaR6+5ODaxYSIc6Lr/boJQLBbDsTNnkd9pAPDHFPZCWTXwHpMGAtjzxcPk/A6DXdWAFZBAOM4jfUeTYyPd20KhELJTM4jkppBWdZTqMtZVHS9LKmitChD/Zyj1SYLhib0IC3IcCk5XJiMJuJwKIcCRjveXdiPuVHB/VeZXVRXPGLJ3PiF5yVKWZeGv//W/js9+9rP49Kc/jcnJyX1t60sBh4RvCOxt6bb+blgUo57b/QifYVFsOISPJ8BUxE+4ZFnG3NwcJEnCl711B4Ig4ARscUS+aRs9bzd1GA77swAnekkHivYgsotOFT7CC6jAXlELhPQNR2fRrsQFgPPJUF+yZzkzGywxaeXgHrzdigtd13Hv3j1YloU7d+4MZMx6EGBFHydOnPBEH0VqAYSDrqmIKHnczmahiyEn6UP3EWE7us8emA8LHMadB3wiwINSitLuLtaohK0mOz8ZwEwkgF3V9Egdq4QdVoBOQAFNRVjkkY5FEBE48ARYqWuoMl5vEYHD5VQIiTdUof29AMW0ldFu/J9AgEwjj/L2RteFRreot/zmK2jVKuKpDMTUONRAGDXmlqJZFGsNHWtMrNp4qD/RYtHpVKiopkcGAOAyY+MzFuBxMu5YmzhzqkW1lfbhiybchbdgyYVERNsWLP38/gBbRX/37l0kk0lcuHDBF6s4CH/adche+0JmGPP3YeBu72Pf9wn8wP/859CoVjB59Bj+1//1u7u+hq2sN9oWYXuvVwEQe19fHOC0WzlYShOlrXWcnj2CiVQCQYfUVTUThe06ANsZotf5siH3N+IeFK9rKpYqrS7E2biE2ViL7H3P93wPfvM3fxOf/vSnceTIkZG386WEL9277QGg3+zbwO/Th/BtNjRvxTkVCfpWf7u7u5ibm8PU1NQe9SjPETuvNxKARSmKimGTP1nzqUPZG+OrigKL2qtot23bDERAnc86He2+umZBKcWjkoxlRn3p7Vefm0BdN3G/KPvMYFNBHldS4X35XvWDLMuYn59HJBLpqWp+P+CKPl5sVKGaFLwgoF6qY3l5GaIoIpfL4XImCz4SQ14195jnyoaFVzUNr2oaCiuv8Hc/9k3YWl/DkVNn8Xf/xb9BMjeOIEfwuq7hZU3rsSd7QWDPcLXP08nlEp49fogL589jamrcUzkulhXfQ/RYNIDTcel9V8naRrwfjJqfbNjD764IIcARJMobaJSLuH379kDWG4QQRKNRRKNRHD9+HKqqOokwW1BKJYRDYYRztuVLxSJdY9V6ES0W7bc4kSMe2SMArqbDHRdjEs/hSDSAI9EADCftI+9k/bK+a+yCJcS3EkiCPPGqUZEu3nvNZhPvvfeeJ4AhhPizf/t87yXFwN3CXrJ3EFWqjttzcoVNCpy6fA0/99/nUc7ncXp2BuPjcU/Y1K5+lUeorHOwW++yaWelcABm0ECjmEe5kAdCISAcRrlUwvWrV5HJpHyvZ59tfJ/Lp31GcFSs1P0jJ6fjQRwfa5G9v/N3/g5+7dd+DZ/+9Kdx/PjxkbfzpYZDwrcPsNxjP158/QjfSr114rPt1PX1dTx+/Bhnz57tGE/FgiP27Ew2JOJSKoyyanpzf6wSTbUonpabeFpuIiJwmIgEUAtEvX8fRKzRKRM3FeS9m3a3Q0WprT5cckgnYD9IzsQlHDvApIdOqFQquHfvHsbHx3H27Nk3uq1h4O4Fx/G4evUqTNP0VHoPHy6AUopsNotTmSz4dBzbioWiqkNmelI/90M/gJ3NTQDA+qvn+Hc/82P4y3/vH/mitTptt32WzlXUSTzZ035dWVnBi+fPce3qVWQyGTQNO+auyFR/QjzB5VQYqX3O9PxeR0038d5Owzv+Ek8QyS9DlQfLdu2GYDCImZkZzMzM+MRB+bWXEADEJmaAWBI1iAMRrfYYQNpW43PV1Rxsz8ZBMrUFNzoyJNqiAyeZZkfRfQvPpmlhua5hua75qNpEh1i9RqOBu3fvYnx8HGfOnPH+3WfL0uNyLjpkzz0kYYHz7onTkYO/73Qil4GghNzMETQs4L+tV4cmdXuuV0b9KvEEm7KOB44IZTIi4kJqCjgyBcMw8OLFC6yuroLneSwsLHjK8UwmA1EUfffrXmMXVc30Fp3xAD+weX471uqaz8PRFubZYiZKKX7wB38Q/+bf/Bt86lOfwunTp0faxpcqvrTvvPtEu2hj5PfpQfhqmoGyQ5RiIo+405579uwZVlZWcP36dWQymaG2RwhBUhKQlAScS4aw0dBwr9DY83sNw8KLigJw9mkS4Ah0i8KitOuF33QycWtMJu7FZAgmpQzh23uwVNPCQnsOrsDhSjqMsQPyg+uGnZ0dPHz4ECdPnsTs7Owb3dawsCsTFBacdg4lILEEoqExkMnjqDZVbOkmVlUO0DonSdTLZS+CiFKKRrXs/RtPbGPURJDHWID37E1CfOcZnXaw4hZ35my9oWFxt+mbgzoSCeBsQnpjc5e/V1BRDbxXkD2yFBEIApsvQA19qLivfmgXB3lRb8tLMJmotyYvodHmmeYSLZEjTqyagIwkQpYbWH75GrnpIwhF7UUgT4AbA4qv2kEIQSIoIBEUcAYSZCftI9/UUVJNj16yd4sXVRW7akv1ayl2G3dqamqP/RT7um59gfac30yQ981BTu1zfES3KBp6q+26qxo9Z+d6eU26lfVwW3U9InZehLFgUy+mmZGcQqGA9fV1L/mmWq0in8/j9evXePToERKJBKTMBMDHAPSu8A3Sdu+HjYaGh8wI0PFYEKecyh6lFD/8wz+Mn/u5n8OnPvUpnD9/fqRtfCnjkPANgT0zfMzf9+PF5yZZdLJ2YXNzj8aCsCwLDx48QK1Ww9tvv41oNNr+dkOBEOJT3E6GRSSDIrZkzeeVB9hzQJ/frkF0V+mRALKS6LXmyk4mrtsuZpW4rDqsvbC009SxUPLn4B6NBnD2fWj7rays4Pnz57h48aIvX/iLBdsigdqzdLoF3Rnk1i2K/7pW7TBHRTxC3hGU4uu/9dvxZO4LoJSC43h87Z/7Vu+fTeoM9xsWxjTbODfIif17N7BbK4uLiyiVSrh9+zYEKYT5gowdhrQHeYJLydBA1Z83gQ8SvSwqBuaYyk5MIODWnkLkOVy9efONjRB0inorFArIb69ALZcRiychMVFv7jmmWxSbsm7/9+oh/s63fAPKxTzCsTF84l/+O5y5dAU3s5EDU8qHBQ7HYkEciwWhO4lDq3VtD0FilchEayIxewaZib2LXvY+02nxstPUMV9o5fzmQgKOx4L4vCP06BQX1wls/mvDp1ofLau53YKI9ZUcRdikGBaKzjUZ4gmSTot6e3sbjx49wlWnKg8A8Xgc8Xgcp06dQrPZRKFQwGqlAcRtwlcs5JEyI0gkEr7xIYtSzzuTwBa6DItNWfOqkICThe74s1JK8ZM/+ZP4qZ/6KfzGb/wGLl++PPT7H+KQ8O0LLBnZb0sX2OvlZ1qtcHKOAGmB4vOf/zx4nsfbb799YIIClrgSQnA8LuF4XIKsm/jtjYp942RCvfU2pV02ZKcisE787Zm4fnNn+5cMi2KprPjc7AMcweXUmycIbtTX5uYmbty4gUQi8Ua3x6Ld94qNCutskeDsc5efcwQI836H+oaqYVk2QAnBW1/9R/Gj/+4/ofbkHv7wH/oQjl28gryTj8qmt1R1C1VdxfOqihBPkHNab4ngXgWtG0SvKApu376NssXj0Vbd94CbCos4nwx9oMyOv1jYaeq4V5A9q4+ESGC+eoxwOITLly/vSW55k2AzXDVN81q/lVdLCAUlhHNTsCJxVC3Oqzj9h5/9SVTLJQCA0qjjX//ED+M//dqvHlgaSztEzhaH5ZsGAJvwZYI8ZJP6RlBoIIRdAJ/PywhwBNmQrfpNS4KvBd1+Cm4734f7G+Mh25aInRtjM6T35L/qLVI3TP6rtz8ARA5Q28wLpyMiLqf2+uftBxs+/0K7Rb29vY2HDx/iypUrXTtEoVAIR44cAZ9qETFqmlhYWIBlWUin057ty64B7zjkQsMbgG/LOh4UW2TvaDSAc45hN6UUP/uzP4sf+qEfwic/+cnD2LR94JDw7QMHKdoAbANJlsRtya0UgrRI8N7nP4dMJoOLFy8e6AOCfZiz7dYSo6gLaQ2cmxnHVkPHTrNF7EzHF45FiCe4ngn7Zjh81i+wva7uF/3ZqbmQgEtvKAeXhWmaePjwIer1Ou7cudPRoHS/sChFsz331fmvF6nrhajItnJ4b/UfbGu/rtY1vJZNwItn4nDp2lmUZlIoFAp4/O7nkM1mcSmbgxCNIa/Yc1RVnTHwNqmvtZeTBOTCIjJBAaZhK5k5jsPVGzfxpG5gS25VogOOmnr8Daqpfy9ho6FhodTyU0yJBOqLBaQSCZw/f/59JXvtCAQCmJycxOTkJCzL8uZD889XQAwTyckZyNEMTNPwVBsUQJSjb4zsuTAsiu1my3vvejYCDsDWbhUPl9cRSI+jSVqPMM2yo9fWGzo4+N0HWL63Jeu4X2yRvYmwiCupEEyLeqIDAqCk6liXNci61XPetRuCvB0VxhGgqLRa1BlJwLV0CL+zWUf7Mm6Y9KJBsCeOLhLwRliuXLmCbDbb9z3YcaWZqSlMn571Wr/Ly8t49OgRuKPngJBdBRy2Db7T1HGP+T5mIqKXzkIpxc///M/jE5/4BP7zf/7PePvtt4d670P4cUj4hkB7W4A1WjY62cwPCJfwtcerse3c3RdPcHp2FsePHz/wIWK2e8de3Oz2pWYFU5GjmIoEYTrtli3H16/9ozdNiv+x3UAiwNut37AdB2YaBgxdQyHI42lZ8eXgnkuEMPOGcnBZaJrmRRLdvn17X1VSltSxhG5UUuf6XrGE7lVNhWxYIAC+fCLW8/WUUryo2hU6F5NhO6OYIzHMTLUe6vZN316pZ7NZnMxmEcmlUNQs7DQNlFTD19pbl3Wsy/aDlJOriMTSmJqZxucLiu9hOB4ScPF9IO2/V7BcU7HIGlwHCGpP5jE5MeETGHwQwHGcL+rtdamK5w0LJjj8ib/0HXjvU7+BZqMOQRDxt7/ve9/4/mzJLe+9yXAAPCHY3d3Fk/v3cPbkSRw9moZqWrbiuKmjoBje71uAzwZopabin//Uj+Pf/sK/wFhmHH/17/8ojp4+i7DAQTUt/M5mzWdxRAFsyL0TJQAgyBGmst4SSoQFO6u5oOiYa2sbX0uHUVBaCuVkgMeu41V40FdNRbNtlgA7haVeKmBhYWFgsgf4ixkcsZ+DbOu3JjfxP4rOPcfQ8XRuAWUn67e99duOguKvtE6FRVxMhjyy90u/9Ev4vu/7Pvz6r/86PvShD410DA7RwiHh2wd8Ld19VPgIId4cn4u6brZm6LQmrp4+gYmJNzNj1ilpo66Z2HW2L8ECr7XK7TxnZ/wu1xQf2WMjdQCgrJkoayaW/h/23jw+rrM+F3/ONvu+arFlyfu+SbYTIEBKIIE4iQPlQtoCLUtZSijNTS+lUO4ltGW7txdCoLT8aGm5bYHYYU8JS2JIgAZbkndbtuRFtpZZpJFmnznL+/vjLHPOaGY0MxrZTpjn8+EDyLOcmTnnPc/7/X6f55kHBn/6JP73ww+imM/hVW/8Pbzn458BTdNwcQx2+JcvB1ePTCaD4eFhuFwubNmypa6ZKX1AuKH9ykvIi0sndVrFjqM13ys9rikVB7mrXj2+TyIEZxI5XNPt5nud8hyk/jn6m7p+mH90dBT5fB4+nw9doRA2BwOYFylEKtxIJZsL8wDm50rEkqWAzV4rOiuoKG8WtMAnuv73IgQXy0xjwxwwd3YIq3p6lmXj1ioURAlnEjlEctDMetdt2YYv/fg5XBo5h5Wr+kBLSVy4cAHBYBBut3tZPkt5lNrs7CyOHTuG9evXY8WKFQAAM0NjhV32khQJwWxeQKSC5cuvD/8Mj37yEwCA2PQUPvUnf4gv/fjXyvVc+zgM+a+6sQnbIvmvMWVGUF0jVbJHUxQmddep38KWCF+Lv0d9trFTzOPkmZPYtm1b3WQPwKIq3YREgyg11B63DQH7esTj8QWtX7/fb9hgyzOtpe+nw8phq8+qnUsHDx7EQw89hIMHD+L2229v4FO3UQ1twtcg1J0H0LqWLrBQqTueLFUF+tx2dIQ9S3r9WjAmbcifQ5/s4Wck5HTHJitxk5oEnwKw1WdFl41DkpeVdpEsj7SysxR4XiN7APCzx/8de25/De7bfze2eC1grkNLa25uDseOHUNXVxfWrVtnuEFVInXyfF1zAeEqqVNvCiqhk13r61O/qtA/spqLnCgRHJvJanFGALDRY0HvIokolYb5o9EoJiYmcPbsWbjdbgSDQawLBhHLFnEhMgu4fJCohb+XQIBLqQIygoSQlYOLq+7n9mIHIfJs6mWdUKmLkxA7M4x1a9cuaqF0o0CUwfuzc3nDLGbIymKz14pfUxRc/hDMNIU1rGwMPjw8rG0i1Jt6K8QnGV5EQue9xyfncPLkCWzcuBFdXV1Vq+sZXjLMpaqYvDQmzyATAkmSEL06DkmStOoTjVJWMEvJiQ4ORbXezAxqOdlTZwRpikJRlLRWtYmm4NS1nls57moUUhBMnjuJ7du2NRw/tpgPn75lvMJhhstk09ThyWQS8Xhca/2qawrn8eNMumQUHbay2O4vpf1897vfxfve9z78x3/8B+66664GP3kb1dAmfEsA2yLRBmAkfPlCAZfnMwAth7WtCbhqP3mJoChKW/AkSb7AJxTCRwMImoDLSrt5Ls/jaKyyEheQ/ZfcJgbr3BZkeBGTWR7nozmN7KlIz89hMitXj9Q4ML+FXZZ4rUgkglNnzmDV2vVwBUK4nC5qGbBLIXVqC8fY0qGrxg41A/0NoNJRlkdzUQC2+60NpaGosNvt6OvrM5j4RqNRjI6OQgIF88q1yFUgeyr0makWneij3M/txQxCCE4lcoabYDcjIHbmODYpZOVmRE6Qq3r6TQNHU9jstaDDyhmMjGkKCIfDCIfDhqi38+fPo1AoGIb5m/UU1FemrBKP4SuT8G3YgSnOgtGpavmv1bHzZa8E+3/+BpIkgUgSBm5/tVFlqnusy8TAbWab9pGL5YxtXD3ZA+RWtfpvnTYO+m1cKwlfNCeUiHtyFts2b24qa1YytHSNB5jmRW3tcXK0wUJL3/pds2YN8vk84vE4JhNJzMIFKBsDFyVgg92kvfaTTz6Jd77znfiXf/kX3HvvvQ0fbxvV0SZ8S4B+t7MUWxagRPjS6TSeP3sBJCj7wXXYTHVHHy0FNE1BkghEQhDN8lo7JGwzwUxLkCQJ05kCjulsJcqVuOUoiLLKmLFY8TtveABPH/oPAIC/oxMDt78agDHyiVUUv2Erh4CFbdizTdRX6nhZTTebziIrUMDaXRgFBcSzdb+eFhCua+XYloHU1YI+IaA8KCIryNFcqvClnHwvBaqJLyEEM7kimBXrkNPZv1jEAtbbGThdLsQKIiI5Y2ZqXpRNtMfTRbAUFN+05n7XpeB60kyJEByfySKii65bQRUQOSu30W7GYHdC5Ovv3FzOMI7RYeOw2WMxzGKq/1w+IlAp6k2tErtcLgSVeS673b7gmiGaDVFJ/ZrmRczorFjiEgOEVyEuAcjX7r/qN2ICIZqv58q16/G3//F9DP/o29jY043f/cN3IQkWsbywwDpltiDiuek0bKxiQm2prFSvhHKrlw4rZ6hcAWWeeHYTMkLps7ZyY6T3xVvtcyIcrr+Nq4f+vCiv8OmJeZe99ibTYrHAGepEEk7tZLIIeTz7+L/g3s98BrfccgvWrl2Lf/u3f8NXvvIV/O7v/m5Tx9tGdbQJX4Oo2tJdgmgDkAlfIpHAlStXwKzeqv29Z5G2XKvAUIAAeV5jPGVM9qBzReTtXgzGSubMHhOD3QFbxeF8iRBcmC/gkk708f5PfBZ7X3Un0vNzuPt1r8WazpA2H6autwKB5vtFQ55tCSsGq+r7iJKx/arPk8xXqtRRHFBDNKaSunJCZ2dpcNeJ1NWC/u31ny5ZFDEYK6U1mGkKA0G7wVNxKSCEYPTiRVzOCBB7NkJUqBMNYAUnAukZjI7HIIoiAoEAVodCcIS8mOEJojkBM/mS6EMg8o1hUve7qsa5y76ZuU4/nyARDM9kNb8zCkA3ySB64ZxmanuzISuIODWbM/jcmWkKW3xWhCrYIqnrXrWvtFLUWzweRzQWw9j4VbA2J+xePziHExJjkq9hsfG8Zv0crDY2oSjY9Rux4TIz+TtuHcD77nqZ0ZyZyBZTpxMLTcuzgoTLqSIup2SlelA5b6ttWhaQPUX9qydxlSpiKV5P+Br7LqpBFrPwAChwkLC2gk9hvZAMLV3jd6dXNS+mzk0WRRyNZTSrH5+ZQX93CC9/+GG89CUvwZe+9CV89atfBQB88YtfxPj4OPbv348tW7bc8HX4xYI24VsCWiXaAGRLlosXL2Ldlm04K8g7JStLt6RaUw/kC5lAkCTE8zJ7tbE0vGYGxxJA0VdqRXXa5OHaShYCaV7EiZmsQSHnMzNY57KD/M5rAAAuK4duuwnddpOi+FUHrXltMZBgzPtUFdG1nOirgaUAO8cYyJz6v28GUlcLhhk+pcQXzwsY1lVa7SyNgaAd1hblDBNCcHxkFBHOCeItZbq6TQy2+axyRbfDB7Jxo2bPMDY2hmw2C7/fj45gEJsCASQJjWhOVlBW+l1PJ6ApuUNW9roId5YDvEQwGMtgThu8Bzr5JGKXR6+7x2M9IES23DmvizAEZGHERk9130StwlflNYuqATGv24gxLmQDDoh+eUOZBwAeAL+4AhYAbLSEsN1SEjhVETeV41KyYKi0hqws1pcJmACZpOozqNe5zKBpCrEcj4Qu7YOXiLZpoQD4zKwWQWdlaUSyRmuRkjre+H6GVr9SETOIIlq0QxmNzQGQr6eVTuuS1jj9Plp/aswWRG2THbDU3ryleRFHYhmtmuo1M9gdsCv3UAoMw+Dpp5/GY489hnvvvRdPPvkkfvCDH+CRRx5BOBzGF77wBezfv7/pz9CGjDbhWwLYFiRtSJKEc+fOIZfLobe3F7zdA8zLu80eh/m6kRF1YdITqi67CYPRNGKlzgDMyRjsRQpZUwgOh0M7PkIIrqaLOFeWg7vObUGf02RQzEkgECR56FoduKYp2TcrI0jgK1RLFyN6nKKks1AE87EIWCJiY98quCymF7RFiMGwGgs93WpVWpsBLwh4fuwa0ragVl6Uf0c5AUF/Ayu3Z1DbeZOTkzh37hxcLhdCoRBWBwIosGZEczKxL+juIHolt52lNfLnNjEtP/eXQ6VbEOW2ukoaWAoI5WcxOzGOgYEBOJ21rXSuN9K8XNWb07XfLQyFrT4rApbaFRr1+xOJPKqhkrusIFt/NDwKSwhooQCSz8HCUPDYzPA5HTiTEkBAgQHBy7o8Dbc5x5J5XJgvGP7WZauciasXNtCU3NHgaAp9TjOKooR4XkA0JyCeL21aCICZgoCZgoCzc3lYGMrQXahG9gghmgkyBXV+r3xGrqGPWhEzMzO4li4CZtlftKvJmDMV1Sp8+pZxrffI8CKOREtkz21i0B+wa1XSo0eP4g1veAM+8YlP4D3veQ8oisK73vUuvOtd70Iul8MzzzyD9evXL+kztCGjTfiWAIO6tQnRBs/zOH78OPL5vCxZN5sxpoglKMiKp+sFdTZDv4ufyhSQEUptnE1uE0ycA9FoFEeOHIHJZEIoFIInEMJVkTMMfNtZGlu8VrA0hUhOQFK3o4/lBPx0ItmS47Ywcsxbp40Dy+cxPHwMfo+n5ebUNwr6Gb7xVBEXdW3ykJXFDp+tZfFziVwBR6fmINq82t+cHI3tPltdrWI1waG3t1cTfajVP6vVimAwiF3BEGC1I5oTEM2VlNyAnN18MVXAxVQBZprS2r7LJeZZKnKChCO6GUoTTcGbnMZ8PII9e/Ysi6F3s5AIwaVUAaPzBQPx7XGYsN5tzDguigsNwzN8qfWaEwlOzhpFWNVAQe5UGGLCOHnGTs1rzmaz8rkSuYYzUyxIZx8A2bOwkV+dEILRpCwaKke1S0QvbAhbOUN108TQ6LKb0GU3QVKywGNKJ0Iv9NKTPRoADblr4Tezhmsznhe0zU5QVxFbzPakEczOzmL47HmQVZsByOSqWfGJikoVvnJT7EojAIA8NvAb3eiJi2MwECyRvePHj+O+++7DRz7yEXzgAx9YQMqtVite97rXLen42yihTfgaBFVW4VC95xrd3WazWQwNDcFisWDfvn04c+YM5kUa6nIcsnKwtKhFVw/KFxoK0MgeS8kB6T4LC7is6OjogCiKmJ2dxaXZFC7OCwYXahNNgZcIfhMzztCoqPVV6T2vSv+hQEBhJi+TBH27OK9LhIBQhHvlOnSG/cbhtxcw9B9DT/ZW2k3Y7F3YomoGhBBcSGRwMc0DnEV+XwCrXWascZmbugmpoo8VK1ZAEATMzMwgGo1ieHgIDMMgGAxiYzAIs9+DeF5EJMcbqk4FieBqpoiranyfRTbwDli4hmwylussUFtU6g3cwlBwzlxFLjWPPXv2wGKxLNM7N45kUcSpWeOYhZWhsdolmxlfVsy9m81/VUld+ciEnaNhYRbPf7XZbFi1apUsECqWiEN89CyeHSlqog+fz1d1E0eUuWH9NeI3s5gplGYqK0FfpequITqgKQoBC4uAhcVGjwVpXsJYKo/pMhM/CcBEVsBEVgBNAQEzi6CycZmoInBoVYVP9Sn0rN+OOFE/09LTbipV+CK5kil2h2KKXY6cIOE30dI14uRoDARt2vV75swZ3HPPPXjooYfw8MMP39SjNS8WtAnfEsFSFERCGqrwJRIJDA0NoaurCxs2bABN02AYBnGqdHGuvE5iDRUMBeQyGZgsFjAMo9kUWBkKO/w2UBSFqWxRp4CVkORNkGwLh9EXy5akIO88y3f86kxdNXjNLNa6LcgKitefMmejgTVhHsDReFYbsg4rcWCtqoLdDFjnNmO1szXt/gwv4ngsjaQIzWTXztLY7rPCbW7N8sCyrMHGI5FIIBaL4cyZMxBFEX6/H72hEJwhPxK8XDmYyQvaOSgSYDrHYzrHg0IOPguLsKKebGhT1KKe7rwyfK4SIxtLwRq5BD6fw8DAQMsyrpeKoijh/HzeYMYNyFWonChVFCrUAxNNYbXLrF2/VnZxUrcYLl68iMtTEZAeuTLl4GjcessezfLl7Nmz4HneYPmifs+EEIzM53E5VSJvGz0WFCVSInwVji+vtGwBmbD7zfVVwiiKQloQEdGRPY+JAUcBM0VRq9hJBIjmBUSVeVUVLAUELaX30k+wNLtMqWRvw4aNGIEJILIVckcLMskrVfiMRHnhe+QVsqdWPx0sjT1BuzZ6MjIygv379+Pd7343PvrRj7bJ3nVCm/AtEQxNAYqdST2YnJzE6dOnsWHDBoMBK2E4ZCh5AbMwdNUS+XKA53n81Xvejl/86AewOpz480e/gh0vebms3CXAf0UrV+pqgSEiUMhDKuRg5xj47FZcJRYQyDu9W8KOpo/XxtLodZqxymHC6OUruDwzD0dnD5ISXXHImqHkoeKwlUPQ2liF6EaCl4im+lSx1WvFCsfSCQUhcgXtXCIHSVf/6HWasM5lWTaCTNM0/H4//H4/NmzYgFQqhWg0ikuXLiFz6hR8Ph9CwSA2BAJIExbRHG+wziCQHfpn8gLOIA+3idF8HO3s8ps9z+YFDOoEM06WAjsxCgoSBgYGwLLXd0lVVeuqSEKt0qWLIvgqS1ItQwELQxnUr6p63cpQ+MlECkDp+msFCCEYGxvDtWvXENq8C9eUAl23zQSGYQznSjqdRjQaxfj4OM6cOQOPx4NAMIiUzYeJfOlTbfZY0OM0Y2Su1HautC2YypT88LrslWf8KmEqW8SJmdIcbbedw1YlDkxUSGY0xyOWEypm8AoEeG46jZCyHumLBc2INhKJhEL2NoDzBVFUrKf07gZLgVrhoyGT3ZwgacpuG0vDUzbukRcl/CaW0QywbSyNPaES2RsbG8P+/fvx+7//+/jEJz7RJnvXEW3C1yDKT061lL2YaIMQggsXLmB8fBy7du1CIGCUyWc4m9a/W+mof/FpBf79P/4Dv/jRDwAAuUwaj/75g/jqL48rrerFiazHxCBoYQ1KWJaW7WvU9IbotUsgHesBhkGB51EoFJo2ZQVKYpd4PI5bdu2C0+mEIBHE8jwiWQGxfKnlIBIgkhMQyQnGCpGVg+UmFXTkBQlH4xlDtXSTx9ISspcTJJyazSnVD/k8szI0tvmt8LWoqlcPKIqCy+WCy+XC2rVrtVmu6elpjIyMaB5ufcEgiqxFq+rqZ6bmi7LNxYX5guabFrZy8CyD6EMNeVd/EjdHAVfOwWTisH37rpYkTFSC5i/JSyW/OoXkFRpWSgBmjdSVxfsp+a+VoG/rteprVdfEqakp9Pf342iKAEpIV7kIgKIoOJ1OOJ1OzcQ3GovhUo4gR0vqC6LPIq+f8jHrn7/wvQ1VqkUsRVRMZoo4oZtfXGEvZb8CcgFA9ZwkhGC+KCKWF3ApVTAcT043iqI/tEbdHhKJBIaHh7F+/Xp0d3cbrGhqtagbgXqKqafGZNb4vemvs6Io4Wi0NNdqY2nsDdq1ecUrV65g//79uP/++/HZz372RTFn/UJCm/AtESpfkEj1rFNRFHHixAkkk0nccsstcDiM1S1CCJJMaeZnxXVs5/ISwfHxqZK/ICHIpOa1f6cg7/odHIM0b0ylcHE0tvttVYeC9b5cq1evxs+uzYMnAC+IePbZZzUVZygUamjAXRAEnDhxAoVCAXv37tXmpViaQqfNhE6bnKupzvzpczUNFaJE/qa0BUnzcsuw3FfQs0QyRgjBRJbHuUTOoHpeaTdhg8dyXQ2RK0Gd5Vq1ahWKxaIm+rh48SIsFgtCoRB2BIKgbQ65VZbjDZYaet80E00hZGWbIkSVUK6O9nEUihdPwe10tkQgpI/3K1e/VvSXrBMcTaHTxsJn5gybsUah5yGtOEsIIRgZGUE0GsXAwAByjAkFUa5MLWbxAcgzokm7Hzmo7WoCb24WUxfHMU1RCAQCyHs6oVqTlH/kJC9pgiGPianr2l9I9kzYUmOOlqIoeMwsOJrShCRmmoKdpZEolixf9L/uYDwLn5mR5/4stdekubk5jeytWLECRVFCVLGiMdHyzGEroJJ9RrlH6K1lOnWksijKIib1e7UyFPYE7drYxeTkJO6++27ceeedePTRR9tk7wagTfiWCGOerkG7AADI5/MYGpIH1W+99daK8z3xvACeki/soJWDjb0+xCMniDgSSWHnHXfD8djnkZqbBQDsf9sfa48hkHejOdHYWuxzmLDOY2lodoehKfAiAWcy4yW33WaI7rLb7Rr509u9lCOfz+PYsWPgOA4DAwPguMo7c4Yy7rQTBVkYUF4h0tuCODjZFiRs5eC8QVmwiYKAQZ05qSoKAkrGt82gIEo4PZtDVB+dRRHsCNgXteO4ETCZTOju7kZ3dzdEUdREH8eOydmtwWAQG0IhWHwexAsiojneYCCsJrjoMZUtotveuE3PeLqAM7p5t6CJQub8CQQDfmzcuLHu86RS/qtM7pqL9+MU8mBh5DbbvI780gDWui3odZpaonDWH91SX40QgrNnz2JmZgZ79uyB1WrF6EwpAWexyhQhBKdmcwYRxHafDV0rPZDW9WJ+fh6xWAxT83OAU54xjkaisIT8WlehXrGGigmF8KtoRDSlP85epxl9LjN4iSCel9u+U7qoNUD2t5stiBiBPE+r+v3pq9Yq2Vu3bh1WrFgBwBjZ1mXjWqZsL1X4KMwXRa165zPLHR1ALhzo7YksDIU9IYfmDTo9PY27774bL3vZy/D3f//3bbJ3g9AmfEuEwYtPIobdczKZxNDQEPx+f80qgD7ZYuV1smJJ5HkMRtMoSAT+ji489sNnEBt8DutWrcCe216JaF7AdJZHRqg88RPJC8B8HmErV7dnGq2YO0swqjh5npcd+aNRXL58GWazWSN/brdbe+10Oo3h4WF4vV5s3ry57kWDoij4LCx8isIuySuij6zRFiTNS0grWbBWNQvWxsG7DO3BSpjO8jgxUwpcd3EM3CYaVxXi0izdm87yOJ3IGdSXQQ7YHnK/IOYZGYbRzgc1uzUajWqD/IFAACuDQWwJ+TEnQJv7Kx+fGpkv4Px8AV6zWtXlFjWrvpjM47zO0y1sAubODmFFdzfWrl1bMSosJxJkeHGBtUmj+a9AyV/SoH5ladg4BpxiEHw6kTNsYjwmBltVg+wWwXDcS7gWCCE4c+YMEomEpmbmdRYfnFKZrQaJyJYwqnceBWN2NE3T8Hq98Hq9KMxkNbIVj0VxZeQMXC4X/MEgJjmf/HhKTsSohXKy1+MwYZOnPrJXnkbRqbSqOV03QiIZTOdK4hH9b5kRJFxKFXFJl/bhIDwunzqOdWvXYuXKlaXjzC40dW4FShU+o3G0qjQWFLKnqsDNtFzZU8lgLBbDPffcg127duGf/umflm30oY3F0SZ8DWLBDF+VtI1IJIITJ05gzZo16Ovrq7o4FEQJEXXxEgWE65wlWQqmlExc9YZoY2nctqUP9p1rtceIMO6Cy5HVLURmxQsvbOXgrZE5qX5VUlmliuM4dHZ2orOz01DNGR6WqzmhUAhWqxUXL17EqlWrsHr16qYJGEVRcJsYuE0M1rktyPCiMt/HG7Jg9TM2answbOWWzRNuPFXAmbkS8Q9YWOz02zCWLP2t0QJfUZRwZi6Pad2NgBIFbPZYsNJjX/Ix3wjos1v1g/yXL19G5vRpeL1ehEIhrA8EkAGLs4mcoXpGUKqgnJ3Lw8XJAqmwlYNDV9UlhOD8fB6XdMrPTo5g5sww+vr60LGiBzMFUW678iXfumwTpE7LbObKSB1LV61GFkUJJ2ZyhixThgLWuy3oWYYZYH11udnajCRJOH36NFKpFAYGBrRRjKlsUVuLalWmJEJwYiaH6VyJ7O3w26oSNv1Wdfu2beCIiFgshqvzGQjKnc/K55CaE+HxeCpuIK9lijjVJNkDFqZRVJoZ1p8vt4QcEAhBTPGpTOjWJFWIBgDU6h2IWDiQdAEhCwdBmRcEZFFcKyMW1cuHgvxbAfK51mHlNLKnvreJprAnZNda0bOzs7jvvvuwfv16fP3rX7/uoqY2jGh/+0uEsaVLQAjBpUuXMDY2hu3btyMcDtd8/rV0yQjVlJ0HTS1fwDohBBeTeZxLlBYwr5nBLn8pqUEiBKNlflYsBWz2ygP9altU3z4riATj6SLG00Vth66SI/33oyrQxBrzjuXVnEQigUuXLuHatWtgGAa5XA6xWAx+v78lO0U7x2A1x2C1y4y8ZvciYLZQyoJV24PXMjxYCghYOYStLIIWbslzb5X8w7qU6DqaMkZINUIkojkep2dzBpUgl0tiX08IDsv1tfxZLpQP8udyOUSjUUQiEYyMjMDpdILp6ANo+fOusHGYKYiaehCQZ7mSfAGjSlXXnE/jHz/1CM6dP4+BO+/Ba3//j+RZVErCdCIJ09oduAAGI1Opho5VzX8tz361leW/1oOIUrHVC3r8ZhZbfFatqtJqLHUSUpIknDx5EtlsdoF1TaW4sQXPJwTHZ7JaXBoFYFfAVtPNQL9BoikKJk4eE5g2ZQBltMFWzODkyRFIkoRAIIBgMAi/3w+O43AtXcQp3Vq5ymHCxgbInvzZFm8dG42XAQcrmyX3ueS0j1i+pPpVz1xCyRGLcUWtbtL97Itl2jYC/e8uoZR4FLZyoAAMxkuRgpxS2VMry/Pz8zhw4AC6u7vxjW98o+r4TRvXD23Ct0To11delHBq5Czi8Tj27t0Lt9td87mEEFzV3ei59OxyHSYkQnBqJoOraV0cjo5YAGoObg5JXZi318xgu8+mtb5WOc1YpcQOqVFZ8bxgsEOZyPCYyPAGw9yghdPSPAB5IVls2aQoCnNzc0ilUti1axdYlkUsFsP58+dRKBQQCAQQCoUQCARasphYWBo9TjN6nPKMjaoKjevagwKRW6TTWR40cvArdi/NWCBIyiySvkqz2mnGOnfJY48qe/xiECSCs3M5w02UkkQ403HsWd/3ol50rVarQfQRj8dxPssDytwWNTuJbX4/WIcTMeXc1ZsR50SCv3rwvRj+xTOQJBHHjzwPTyCIl9x1D9KEBhweLMxwKIHWSF2Z+rXO/NfFUBAlnE3ktQoXIG/GNnqs6LZzyzp2YJjha/BtJEnC8ePHUSgU0N/fbyB7aV40VKZcFSpTEiE4Fs9q86c0ZLIXXMS6iuiOWj3mQpn33u71q4H1q7VM6EuXLuHUqVOwdK5C2lXafDdD9gSJaL8VSwHBKq1qo/Gy8fVNDI1uuwlOMY/EyWGEV68D5fIhWjaLXNSVMy+lCsgKBCGrPMZSyRS5XuhHS/UbjA4bh6F4Vtv4sxSwJ2jXKoupVAqvf/3r4fV6cejQoSU5MrTROrQJX4OoZssCAGfOjYDJpXDrrbfW5bQ/WxC0GTkXA4iF+uKKGgUvEQxFU9pCBwBrlRQFVZ17NVPEyFzeUL5f5zajr4rBr4mhscJhwgqHqaYdimqYSyNnaH9LpLbJqCRJ2mC3PpPU4/Fg7dq1hlbe6dOnZf+2UAjBYLAliwtHU+i2m9BtN0GU5KikiBKrpO5yJQCxvCBHyiWgzYaF65gNEySCYzNZw2+yyWPBqjKFtv5VFqN7M3kBJ2ezhhsBk00iJKSwbdPG36pBaZPJhK6uLkTjpfmoJDhMXouCcPNgrHaIDIfybceF40OQJPkmRjMMLhwfwkvuukf7dxrQSJzBr46lYWaWTuoqgSh5r2fn8sY5TAuLLV7r9UnkaVKlK4oijh8/Dp7n0d/fv2DDsVh1T1TInhrbSFPA7oCtLqGRoXKm/Pek3ntPl6+rz4Qem03jQqa06TWnZ8AVCVJMEE6ns+7feDrLa8fQWSWNYsFxVnhIMpnE4OAgVvf1oXdVNwB5rUgps8iTGR5ZXdW6KMGQUhOwsJrqt5lNqQr13DMzFMZTBcwoZI+hgIGgXSPrmUwGb3zjG2EymfCd73znpkqd+W1Hm/AtEfqLmOE47Nu+r+5W47iuutdpoXBFFGs8ujlkFSVuWqlkUAC2+azawG1RlD3Z9OpNOyvbrbjrnAOpZIcSyfKI6gxzJQCSbmU7Gkuj02ZCuEKEnCAI2k1Cb7uioryVl81mEY1GMTU1hXPnzsHtdmttYavV2uhXtgAMTSFskwUcaqamKvrQt0wTBRGJgohzc3m4OAZhW2VD4IIoYTCW1SqpNIDtVWaR9PeIagU+QZLnzcZ11VsaAB29gpVOC9Zv3vSiNzdV818zZdYmKV21et7iAZRTqZr58NZ9L8Wvf/xDEEIgiSI277nV8O8SAI6h4DXLv+1ytVBV5AUJpxM5Q041R1PY5LGg07a8VT09jCrd+t5TFEUcO3YMkiShv79/wfwWIUTzdKOwsBUpSgRD8ayWlsFQcsSjv067Ef1vrG5sJ7K1EyLG0wUD2euxsfAwVsTjMQyOj2uxgItFvQFY9L0qHmfZv6VSKQwNDaGvrw+9vb2Gz+MyMXCZGPlczyqFA45GmpcMKTWqBykgC3rUjOp6jMoriccZCoiXkT3VMiqXy+HNb34zRFHEj370I9jtL8xZ4Rcr2oRvichnM1D3jz2reusme0VRwrQy38HRFEIWFpekWh74jSOR53E0mtZK8RxNYVfAppnrxnI8Ts4aZ4GW6smmt0ORyuxQCgY7FAlzxTzOzslpCWFlLo4ReQwPD8NsNtedXGCz2dDb24ve3l4UCgXN7uXChQtwOBwa+bPb7Uu+QeozNTd5LJgvqp9P0OwKACDJi0jOlwyB1c/H0hSG4lntsSwF7A7aqxoe62+ulfheoiDg5GzO8N5OWkJ+7DTWrlqJVatWLenz3kzgJYIsLxpJ3RLzX82QIBZySBEWhOXwvr/5OwS7upG4fAEDt7wE++96DRICZbhGVGI/MpfXrHxCVg6uFlr5ECLPjY7MGT0TO6wcNnkti/rUtRqV2qO1IAgChoeHQVGUNo5Rjnhe0NaEYNlIhCARDMUzWsuQoYB+Nc+73mMuE5okeUnb+Fby3isXTvU5TVjvtoCi7Ojq6jTEAtaKegPkjbYa+2hn6ZqbZy3JgjJ2kFKpFAYHB7Fq1SoD2dNDKFM43xJ2QCJytT+q2L7oz13Vhur8vFypDlpky5dqYrtKYyRZoXS8/QE7vMraVSgU8Ja3vAXJZBI/+clPtK5MGzcP2oRvCRgfH8e1qTgQ7gVQO7KoHBOZovb4FQ4TOJaGKIpVxQyNopIStz9gg51jIEpy9qS+ImSiKWz1WVsa6UZTFPwWFn6FHA3GMtrOUA81LeH8PEAVc3AGV2DNyo6mRBnV7F4uXbqkmfeGQiG4XK4lf8+qsarHzGK9myAtSIhm+QWzYbKiuYBLKeMEmJmhMBC0w1nDPsNQ4dPddEVCMFqmIqUpoIMqInruBLZs3ozOzs4lfb4bAUEiWkyYmtmskrtGSR1g9DFc7TTBa2blqDAl/zUnSDgSo0EUwuywWfHHv/9m8Kk52O12uDMzWBMIQDTZEM3L5F5PrvVWPhamtNnx1VCrL4asIOH0bFZrmQGy1cVmr/W6qPgroRHjZZ6XN20sy2LHjh1Vr+Nq7VxBIhiMZzTCpFaRvA0ajxuOmaotoLiSKuCsgeyZsd5tHGcpjwVMp9OIxWJa1Jvb7daqf5MCo3uv2pVY9bTWU3g92evr66v6XGPbWFY40xS0jgQhBHNFEdGcgFjOaEOVFSTNiUCeMZQrfwFLKX6ymj0kDbnaqhJwnufxh3/4h5icnMTPfvYzeDyeqsfcxo1Dm/A1CIqiIEkSRkZGMDk5iTVbd+G8MnpXxbJuAQghhnbuSocFDOTFTZKkJalPCSG4OJ/HubnKStxkUcTxmazBXy9oYbHVZ13WqgFFUTCzNKAs4rv8VqR4CZGytARisiIJK34dzcLK0FpbtJmorGp2L6oRtkr+qlkyNPr5nBwDp5vBGrcFWU3xy2s3rnKIEsGlZAFhG4eAma0Ya6X/i3oDmy+KODmTNSzebhMDfz6Ba2MXsGvnTvj9/iV9nuWEIOlTJUQtNiwjSIZqRL2wMJQmlNCrX20sbfBsW+EwG1qwGV7EEV2iiZmh4JmLICMUsHvfPu2GfunSJZjNZgSDQWwLhcDanYjl5TaZ3sonr1OrqzfQsJVDwMLWVTEnRLYCujCfN9xou20cNnqtN9QzsV7j5WKxiKGhIZjNZmzfvr3qWqb33jMp/nLq3wdjJeUnW9YybAT65VidgwQWeu9dThVwTkf2yoVTlaAfK1m9ejXy+byWDHNhdBTSmh0AawJA0LkISS9V+Ep+o4ODg+jp6alJ9oCytnHFkRB5/MBrZrHBY0FWkMlfVFmX1N9VIMBUlsdUlpfjJ5W0D0rk8ez3n0ChkMetd+6H3enSFNJqkocgCHjnO9+JsbExPPPMMzf12vPbjjbhaxBqqyKXy+HWW29FCiyQSwOoPwdxriAgrcwWec0snCYG6vieKIpNE75aSlwKwKVkAefn89pFTlPAhmXy7aoE/byjhWUQtpmw1m3BxWuTGI3OwhLsQhalz54TS1FZZnWObhGvv6rvXcHuJRqN4uTJkyCEIBgMIhQKwefztcTuRQ2Y73WaF9xQVAgEmMzymMzy2nB1WAlUV2/u+o8pSnJVbyxZsvKhIAtwhMg4Jicn0d/fv6g6/HpAlMqiwoRSK7bZ/NeSRx1jEE7Ur0IsvW+yKMfXqQTTxlCwx8eRz6SwZ88emM1muFwudHV1QRRFzM7OIhqN4vjx4wCAYDCINcEgHGEv4kVZsT6jU6sbb6Dyb6vOTlXaWKV5EadmcxrRAWQiu8VrXVSNej1QXi2rhGKxiMHBQdhsNmzbtq3mJmoqU9S+K7UypaY1zOtsPgaC9rpniRces/wOFIBYXtQqxGHd9bWA7LnMWOeqTfYqwWKxYOXKlVi5ciWimQKGZuXXpLMpPP/cMa3yV8lOSqvwUTLZO3r0KFauXInVq1fXfM+sIBnaxpUUzuWwsQx6nQx6FSeCWE6etY7rxGgEwExBRDwv4BPvfADHf/kLAMB3/78v4bNP/Bgv6Qlo56Qoinjf+96HEydO4PDhwwgGg/V+ZW3cALQJX4NgGAZutxvbt28Hx3HI6iwS6iV84+lSda9HUWWqi6PYpHCDlyQMRdMVlbh5keDkbNbgnefkaOyokYO7HNAv/5LiWTg2NoarV69iYMcO+Hw+nRee7PWnfqMFyej1F7Sw6LBx8FepjNU8Dl1rZuPGjZifn0c0GsXIyAiKxaLmxxUMBpdkFEoIwcVUARd0SQ2yRyGLWE5coGhWh6vlHTaLsI1FocjjyNNPQRRE0L/zKkhsScXr5Ghs9Vpw9cII5ubmsHfv3oYyiZcKQ/4rb6zYNZP/aqYpnfq1ZG1ibTL/tRrK4+scLA3T1ChEga8Y16cf1CeEaOeLag/k9/vRFQphc9CPeYnS2mf6G6iq5j6dKA3Oh60srCyNy6kCRucLhopUj0OeH7vR+cYqjL/mwmMqFAoYHByEw+HA1q1bF62Y61MhVthNKIqSIa1B9XSrh8RUg/p90gvaufLvW0721rjMWNsE2StHJF9aZ7d0h2ALOQx2Uj6fTzufzGZz6XcnBIODg1i5ciXWrFmz6PuUt6gbPW4Ksg9pmALsDIW5oogUX6qyxyauaWQPACYvX0R+ZBihDa8DIHej/vRP/xS//vWvcfjw4RfkCMlvG9qEr0FQFIV169Zpu0f9gizU0Y7iJYIp5UJlKUqLBKIoCgzDNEX4sryII9HKStypbBGnZ42D331OE9a5G8vBbQX07yeIEk6dOou5uTns2bMHDocDgNELryhKiCqK35l8yXRUdZxXK2N6r79Gb5AURcHj8cDj8WDdunVV7V5CoVDFHORqIITg7JxxTlLv5dVtlwnTjGb3UhqulnfYAuJ5Hn/z7rdg+BdPAwDWbd+FT/y/b8NkMmG1y4xVNganTp5EsVjUqlKthpr/qhdIyOSuufxXkz4qrMzaZLnJDSGyUGl4JqtVVdwcDYyfA8PQ2Nnfv2h1t/x8yWQyiEajuHr1Ks6cOQOPx4NgMIi1wSByNKd5VRoFS6XBeRrG1qONpbHVa21InHA9oP+ly3+mfD6PwcFBuN1ubNmyZVHikdJ577k42c7miC6H1aSQvaWmRWj7bwKD957fzOJSsoCR+RLZW+syY6176fYh5d57HTYTGNoMr9eLdevWIZvNyjm/iqOA0+mE0LkBoCgU8jms6e5etLInf7ZSZBtQ3WxZVK9fvqzSzksGh4FKsDmdoBkGku6etH5FBwCZ7P2P//E/8PTTT+OZZ54xRLy1cfPi5lpVXoDQmwnXU+GbTBe0qk63w2SoTjVD+CopcXcHbHByDE7MZA2mvhaGwjafrW5bg1ZDf6O4MDoKJpfF3r17qxIVE0Njhd2EFfb6vP4o5LS2aDNGyNXsXiYnJxuyexElghOzpVQAQI686nMad+E0RSGotHBJmaI5LxJMXBrVyB4AXDgxjAvHh/DqV94GHwsMDQ2BY9m61czVIBGCvKiv0pXI3VLyX/WzdDK5Y27oHFosz2NkrtQO93IUhEun4KijBVkJFEXB4XDA4XAY5rhUhbjdbkcoFEJ/MAjJbEc0LyBalt+sJ3sMAK+JgUgIJEKu+4asFkiVtS2Xy2FwcBA+nw+bNtVn/6OvTIWtHH4Ty2ibVbMSzdWKzoPKZwhVIn9dNhMup4rLQvYAIJIrrU0dNs6wvlMUBbvdDrvdjt7eXs0cPKEuExKBIApIJBKLzhUnCqUNl9/MQILcns20YFNmYRRvALcHf/I3f4d/+J8fgijw+NCHPoTdu3dDkiR89KMfxfe+9z0cPnx40TnDVuKLX/wiPvvZz2J6eho7duzAF77wBezdu3fR533jG9/AAw88gPvuuw/f+c53lv9Ab1K0CV8TUD2dgLJotTpEG/p27kqHkeg0Svgm0wUcj2e0m4aqxC1KBL+cThku9g4rhy2+Gzv4rb+BUQyDgYGBuuflKnr9KZUxXlcZ0xsh+xQj5FAdRsiVoLd7Kb+Z6+1e1OokINvtDMWz2iwWBWCrz7pomDlFUfBZZGf8DW4zLswXMGt3LHiczelUkkwAJrwWK1xWJEXAy9RWdxNCkBNJRfVrM6ROzX+1c/QCctco0V5O6L+Rc3Olay9gopC7cBI+rwebNm1qiSm1fo5LVYjHYjFcuXIFHMchGAyixx/CZcIiW+FGLEJudU7oKtchK2uY6bxRqCTayGazGBwcRDAYxIYNG+oiexIhmMyUsnAnMkXtuzAzFPYG7QvsUpo/ZmVd0B28RAhGdCMW61xmrGkR2QPqi1JTYTKZ4HK5gIS8VtisFkjJBE6ePLkg6o1lWRREWcGeEUSM69T5MwURv5hKN3ScJlqZieUWJsNcThVwISl/R6888Ea8562/j24bC46TN6Z//dd/jW984xt45plnsHbt2kXeqXX45je/iYceeghf/vKXsW/fPnzuc5/DnXfeiZGREYRC1SNJL1++jIcffhi33XbbdTvWmxUUqbZ1a6MqeJ6HpHjmFUQJP706BwAIWTnsCVf3HpovCHhuKglAVlW+rMs4XP/cc89hw4YNiw6+EkIwNp/HSJkSd4fPiqsZHmPJ0oLGUHIObtd1NGmthpHYPC4pG+ttdZCgelDL608PvdffUm8oPM9r5G9mZkaze3EHQhjJ05oCmqFUNVv9Q/c5QTbCVs1mv/fP/4B//ewnQAjBf3vPg3jTn/5FxeeZlAxjj4mFmaGQU4yI9eSu0QudoVBR/WpnaXAtiAq7HiivcgNA2ERh/twwOjs6sH79+mX/HJIkITYzi9FkHinOoVM9EKyyc7BzLGJ5wTC2oAcFwGdhEVaEH9clWaMMiYKA56MZAECv04SVnITBwUF0dHRg3bp1dX+H0RyPoXgWgNEyx8JQ2Buyw8a2bqb46YmkQfVtYSjDbOk6txlrXK0jezlBws+VjGUbS+O2DkfN7yWbzeLI4CByvdsByBvUnX4b0ryImVQWs+kMUkURAs0CZgtANfa7s5Q8o6ffkC1WaS9vdevTfwgh+MxnPoMvfvGLeOaZZ7Bt27aGjmep2LdvH/bs2YPHHnsMgHxdrVy5Eg8++CD+4i8qr4uiKOLlL3853v72t+PZZ5/F3Nxcu8LXRvNg9XNpi3DnSmINPeqp8FVT4vY5TRieyRlsIrwmBtv8tmVPA6gHsVgM41emgLBsBNyqbUa5159shCws8EvTe/05WFpT/DqbMMvlOA5dXV2agjMej2MinsDYXFGxYgA4iqA/YIenTrInpwDwOJcwzlu+/T1/gte86S2QJBHrvXZEzp+Eu2cNihaHweuvKMlGvdcyfIVXrw6GglaZ03b5CrkzvUBIXTUQQpAsGq+nThMwe3YIPYoK8np8vrmihBHBjKypdC6YJB5s5AomU3Pw+/3oCAaxORRAUqQRyfGI5Y2V6xmFEJ5RjMpDVpn8OepIS2gF9NcrX+Rx9Pgwuru7sWbNmobeX18BU7mXlaGwJ+Ro+TpVvsToyd56txmrW0j2gLLqXo0NtiARzKSzOH1hDNbu1VC37YmCiKcnU6UHsva67tCOsiqdWnVv9Pq9nDKSvQ1uI9l79NFH8YUvfAE/+clPrjvZUxXgH/7wh7W/0TSNO+64A7/+9a+rPu+RRx5BKBTCO97xDjz77LPX41BvarQJXxMwzmGV/i7WGIIVJIJJhfAxFNBlX0j4aJquSfh4UcJgLI0ZvRLXaYKZpfFf0YwhB3et24zVVXJwrzeuXr2KCxcuoHvjNowrH6/xetPiMBohm5FWfP7Kvf7SgoR0UjbLtTIlu5dmvP4YhgHr9mOWt2h3GFYSQF87j2OjhbrsXgpKvJ0+PstMA70uM/ICgUVR3l7LFUH3bUUcFMDXafqovR4Fp4mGk2Pkit0y57/eaBBCcCaRN8zLhVkJ8dPDWLd2LXp6epb9GKpF3q11m9HrdIFeFdBEHxMTEzh79qw2J7omEECeMWuKdT1ZUTcvaoqLrPxu7vytF/qrdXp6CmvqsA0pR1GU7Wv0sLE09gTtTY1cLIZq6/F6twWrXa0VOMkxcaXNVtjGIcXrxycqiCVCq1DUv0aV16Ygp8LYWRoWGohmiygongemyVH4nFY56s3ZvKXUeNqoWF7nNqPPVSJ7X/7yl/HpT38aTz31FPr7+5t6j6UgHo9DFEWEw2HD38PhMM6dO1fxOc899xy++tWv4tixY9fhCF8YaBO+JYKiKK01UWs+dipT1Co3XXZzRUVirQpfuRKXBrDRY0G8ICCqm+ewsTR2+KxwN2FU2moQQnDhwgVMTk5i9+7dyJlsGJ+R97NN+Os2BIqi4DQxcJoYrFWMkCNKCobe6ywnEoPXX8gqK359ZrauofmpbBEnZnLaYu02MegPOMH13IK5uTlEo1GcO3cOPM8jEAggFAohEAiAYRjwEsF4uoBLqaLh3KEAFCRgZM6YzAHWVDPNxaycU7xEFjyuIBEU8iJEApgZuQJwI1qD1wMSIQbDZRUzF05j88aN6OrqWvZjiOV4nE7kDETNY2Kw1Wc1CBLsdjv6+vrQ19dnNO9VRB/BYBC7gkHAYlfMno2bl6xQ8qpU2/oha3N2RbWgT3nxuN1Yvaqj4de4kioYSI2NpbE3aF+W85DneRz8hy9g/MI59L/iVbjtntcDkKtWfS0ie6qCPStIiOVL0Yo0gOemG5upA+TigdfELpiLVVNhALltfDUrk2YrQ2HLml7E4zFtjakW9VYL19JFnEkY7WnUVjchBP/8z/+Mj3/84/jhD3+Iffv2Nfy5bgRSqRTe8pa34Ctf+QoCgcCNPpybBjeeFbwIwFIUREJqVvgMYo0K7VygOuGrpMRd7TRhLFkwSOtX2Dls9FhvCu8uURRx+vRpJJNJ7NmzB3a7HYUmPAtbBRtLo88l71rzouL1lxUwWxAMXn9XM0VczZS8/mqlYJT7eAUtLHb4bdr37/V64XB7EOpdg9lUBvFUBqfmChBTUcBkAaEr78ZrfTPV1K9WXaVOIgSzBVH5jLzhHFFzYM/N5eHiGC3JpJ4g9RcCRIng2EzWUC1VsX79BnR1LK8xLC8RnJvLGWLDGApY57Zg1SIG5+WiDzUZZnBwUBN9bAwGYfG5EVN+X31agr6trxp5h6wcgpbGFevlSKUzUOUa3iZis9K8iIu6jalVmdmzLJPA58Mf/jD+/ctfBigKz/7g26BZFm9/4L+hr8raWw2EEINYQj8TW20uttamjBJ5mCAh4HTAzjFgKGiRbh1WDtv9tX00J7NGUUjA7UIgYIx6Uy2C9FFvdru98utlijiVKM2C9zllL0L1s//bv/0bPvzhD+N73/veDRU9qJvkSCRi+HskEkFHx8LNx9jYGC5fvox77rlH+5s6d8+yLEZGRuryOnyxoU34WgCGpmRJfRUSkyoKmFOG8J0cA08VfymGYbSTUsUCJS4jty31SjNOycEN3wSO/IA8b3H8+HEQQrB3715tp2k0Xr4xxwYAFoZGj8OMHofs9RdTvP7iBUE7rnKvP9XuxSYV8cxPf4I52ozwzls1dWdIIYeXUwWDtYkh/7XOmRwrQ8PGUiik5pHP5SC4ZZKyymHCJm91OxgVNEUhYGERMMw18ojkBMNcY5IXkZwvtQZVUYt7GVuDy4nyDFYagIXwyFLydeHz+5b1/SNZHmcSOQPB9pkZbPU1PkfLcRw6OjrQ0dEBSZIwOzuLWCyGU6dOaQrOVaEQtoZ9SPAE0RyPeF6oYuQti7pCStRbo+3T2dlZjI1dArpkRWajZ0aaF/F8JG1I+Lkl7Fi2KEdCCL7/5I9kJwVCQDMMrhz5Jfr++C1VH89LKqlThU6idh03ulYxABwmo1iClXicO34MIYWcqddXStdtWGyfTggxbCS6dKK3SlFvqkp8bGwMFotFI38ejwcURcndidkS2VvlMBnygw8ePIiHHnoIBw8exO23397Yl9BimEwm9Pf342c/+xkOHDgAQCZwP/vZz/D+979/weM3btyIkydPGv720Y9+FKlUCp///Od/a30D24SvCZTfDFVrlmpVK0Nubo25On2Fr5IS18XREJU4LhUBJQd3uXbKjSKbzWJ4eFhz3NfPlOhbpDeS8OlhYmh0203oVrz+4prdy8IUjCszSfzFm+7G1QsjAGTLggc/9XkAkD3WKlSVFgMFwIUiyFwcmdkZOC0cgoEAZmdnwQgCtm3dgeG5xoQYhtc3zDUSpAUJUaW1nSxrDV5KFXApVYCZoRTy11yM3Y2AnNSQRVKJLGQooJOfx2RWAFzLm+1ZFCWcSeQ1w11AVkhu8Fixwr50dTxN0wgEAggEAti4cSOSySSi0SjGxsaQy53Skhs2BAJIE0YWfZQZec8WRMwqlV0nR2t2RYuJlmZmZnD8+HF0r9+MK/o8vzqRKsp5xbzuel/rMi8r2buQLGDV5m2YvDoOSRIhiSJeOrALgkrqeNGwKcvwokEoVQ9oTcFOgxBo136nlcV2v83wnebzeRwdHkbQ719gXyPp7hmLXWfzRVHbsPnMTM1NhMViwYoVK7BixQoIgrAgGtDeuRIzNj/UH7NHZwoPAN/97nfxvve9D9/4xjdw1113NfDNLB8eeughvO1tb8PAwAD27t2Lz33uc8hkMvijP/ojAMBb3/pWdHd345Of/CQsFgu2bt1qeL5HqUyX//23CW3C1wKoa5dE5AVHf0GLEtHUWzQlxwhVfR2F8EmE4ORMBtd0w94ujkaKL7UQaAAbPNcvB7cezM/PY3h4GJ2dnRXtLvQm1dJ1bunWAwryIq62OBMFwRA1dPyXP9fIHgAc/s7jeOv/+BjcvsqEwsJQmvoVACK5okFrEbSw2KKS9ZVBFItFTE9PY2xsDIIgwGazIRaNAiYvgNqt3ro+H0XByTFwuhmsUeYaVVFAQhe7VxAXxtjVam3faOQFCUdiGc0Oh6MphLJxzExeRWDjTkSLi7xAkyCEYCrL4+xc3lDJDVpYbPFal2U2jaIouN1uuN1uLekjFotp5uAulwuhUAh9gQB4zqJ5VeoruyleQoovYDRZgEUh96EK5D4Wi+HkyZOyobLbjyszsp0KVSfjS6pkT/fdUKi9Bi4FhBCMzOVxOV3Euz/+abAmEy6fO4N9r3oN1rzuTfjpRLKh16NQUrCX1OvMArHTEcWuBpC9VReQvaNH4fP5sHHjxgVror6fs9jZUq26txhYltU8QwkhuBSfw/kcBZXsWfNJHP7+92F73evQ29uLJ598Eu985zvxr//6r4aW6I3Gm970JsRiMXzsYx/D9PQ0du7ciR/96EeakGN8fLwlfpovZrQJXwtgMF8m8u5exXS2qC14nTYTuBo7W4ZhkCsU8ZtIyqDEtTKUoRrj5Ghs98tpGjcLotEoTp06hbU1FJA3Q4VPixoyeNTVl/9qdRiNkGmGgclUmgmyMBS8ZgYdVg4Bi+yyX0mpyVDAJo8V3WXVH0mScO3aNe3mMDc3h2szCUBZ2xOJOSSQ11oyS4WNpdHrNKPXaUZBUVCqrUH1m6jW2r4ZzIABIMPLpEL97cw0BW9yCnPxKPbs2YOxPIBi8xXSasgLEk4njMpqjqawyWNB53X0vNQnNxQKBU30MTo6CpvNhlAohO2BIBibXYkpFLQqKCBblVxJF3FFT+6tHKRUAmdOncTWrVsRDocxpZsdq+ejzRdFHC0je4CcrLHUeUK9WEKt0qWLIuZ5UavK211ufODTj2rPqVV7tzCUTORqiCWqIS9ImmemVbn+tX/Tkb1qKST6r6fWe4mEaL8BQ8nzfs1gpiDgQp7WqrQhEwVTMol/+Zd/wYc+9CF0d3djenoajzzyCF7/+tc39R7Life///0VW7gAcPjw4ZrP/drXvtb6A3qBoU34mkD5hWvw4pOIQTRRj1hDhchwmLK6ICg3EQpyVVCfmNHrlEPVb6Y22/j4OEZHR7F169aajud6frCcFT6JEG2ouhQzJM/lLEbqKoFTVNjbbnkZXvW7v4efHfx3MAyDP/n4pwwkMC8STGUFTGUFONgCXCYGswXB8J4+M4NtPtuCOap0Oo2hoSEEAgHt5hAOh2HzBhCLpLXPpbZk1B27z+drya7WzNBY6TBhpaN2jF1pLiwHn5lF2KaYAd+AkQK1XahWYK0MBefsNWSTcj6zxWIB8tmWvqc6R3VuzuiX2GHlsMlrWbZWZT0wm82GNp4q+hgeHgLDMHLbNxSC1e9GPC/7VepFS3pyD4mDe+Mu8HYHiqJk8OFbbOWZKwg4Gsto3w9HQWvpdtvr96XMi0S7bvWxf80kw5hpamGqhELwmCWspRNlIgr13qDmC3u93pqRc8aWbvX3ieUE7fsMWxvPDAdkL8eheFb77jpsHHb4rKDCW/D888/j29/+Nt7+9rdj27Zt+MQnPoF//Md/xL333ot7770Xt912Gzju5pgRb6N5tAlfC6Bvc+nn+DK8iFmFvNlZGr4aVimzeR6XaQdEpbBPQW7hqTdbM0Nh+w3Mwa0EQgjOnz+Pqakp9Pf3w+1213y8nqQ2lhi8EJV2+Sq5y9WTcVeG8vxXVf3KixKOz+YgKa36hz75f/DFz/4tvDYr7HY7Mjq7l2S5159gPI5VDhM2uM0LCNrc3ByGh4fR09OzwAxYf59wezzYtvoVmt3L2bNnwfO85vWnRjAtFfoYO6ksxk4/FzZTEDBTEHAmkYfHxGgZxq2KxqqFREHAoI5UOFga5shFFPM5DAwMVLSkWOoWIytIOK1LQQHkhJMtXivCVcLrbxRYlkU4HEY4HIYkSUgkEojFYjh9+jREUUQgEMDKYBBbw35F9GEk96BpzEvAfCIHJACbrm1Ri2okFLKnvo7bRCNZLOXk6tcvg1hCtylTr+dmuwDq2qkiZGGxO1hZpboUEF1MHFBqsxYKBQwODsLj8WDz5s01q731VvgaiWyrhERBwFA8o71f2Mpiu8+qHduvf/1rvPe978XnP/95vPvd70Y+n8fTTz+N733ve/iDP/gDrFu3Dj//+c8bft82bi60o9WagCRJ4PnShX4insFVpZJ3W5cLLpO8qJ2dzeJiUpbcb/RascZdWWFZrsQFIYY7fcgiK/1upoxSURRx6tQppNNp7Nq1CzZbbTsBAMiLEg4rTvIhK4vdgdqLsD7/Vb0hLDX/VY0aMpK7ylFD0RyPYzNZbZF0cjT6g9WtJLKChCupAq6mi1WtGcq9/uKK8nL9+vVYsWLFgsdneBHPKp5enTYOO3S2DYQQpFIpRKNRRKNR5HI5+Hw+hMPhhny46gUpi7GrVi11cLQm+mgmyWQxxPM8huNZjVS4OBrMtfOgiYRdu3YZSO+p2ayWPvLSsAPOKgr5WiBEnmk8P583+CV22Ths9FhuqutyMRBCkEwmtdZvJpOBz+dDKBRCURBwcToO76o1SEqMQW2sh5mmsMJhQsjKwsWVFN2zeQGD8RLZ85kZBCwsziuOAkGLrABfilhCTYaxK1ZESV7EjG7+dKXdhKsZ49Bmh43DzkXsTprBXEHAfynze14zg30hh0b2XC4XtmzZsui5P5Ut4rjiTbrRY0FvhS5QQVk3CeT28ys6nQ1dU3MFAUd0JDxoYbErYNMI5tGjR3HvvffikUcewYMPPrhwzlCSEI1GK9qftPHCws1TLnoBQ9+dE5RFUiIE1xQSSAFY4Vh4IRNCMDqfw3mdl5v8BPmCo4gES2IKM7FJnPb7EQ6HEQwGb3hpvVgs4tixY6AoCnv27KmbWDAVZviqtW5q+VzVfo9S/qs6k9NM/uvVdBGndf5UfjODXQF71VaKHAovCx3KzWX15FTv9UeDAMk0ejdtR2e4svBDv+sv35pRFAWXywWXy4W1a9dqqQ2qD5fX60UoFEIwGJTbm0sERVHwWVj4LCw2eixI8pLm9aevZqZ5CWm+lGQiE1wO3hbYvUxneRyfKbWlvCYa0uUzMJlM2L59Z9NJA9WQ5kWcns0hobPPsDByVS94k9ggNQK96GPt2rXIZrOIRqO4fPkycrkc7HY7fPk5bAgGIXAWRJS5zozu9y1IBGNKUo2FofDr73wT//h/Pg3GbMG7Pva32PHSV8DMUJAIcEFnHxXLCxX9ERccI1DmM7lQLEEIwbm5vIHsbfVaEc0tnNdcLjquF1F020wNkz2gvMJX+TGTGV4737vsjYn01FlKlewFysje8ePHcd999+EjH/lIRbIHyCrxNtl7caBN+JpANVsWoNSCjWR5rf3VYTMtmO2RCMHJeAbXMpUlhB4Tg+1+J2w9XmQyqxCNRjE+Po4zZ85oO/JQKNTyKs5iyGQyGB4e1ha1em6wqnlpSjcsPl8U8dxUClmxCZ8rSq+eYww3hqXmvxJCMKrczFR02jhs81mrtlxSvIiTM1lDS9fF0djms8FpkhM1VDVsPF/y+pNAAS4/LgrAlclkRUGE/h3JIvRXn9qQy+UQi8UQiUQwMjICl8ultX6rmbA2Aoqi4DYxcJsYrHNbkOFLGcbzZUkmqihATYIIWzn4LfUlmehxLW00iQ2YKORHT8LtcmLLli0tVehJRE5gGZ3PG6q1K+0mbPBYbgpz81bAZpMtRHiex86dO1EsFhGNRnHx4kVYLBaEQiFsCwYRgxljqYVr1flz5/DX/+PPAGXk4dPvfzu++twJwG5HYZFccCtDwcYxpUq7ch1bmNpiCUIIzs4ZhVBbvVYEray2SePoUvrgcow7l4sofCzB4OAgnE5n3WRPfR0VdIVmuZyxbczorRdJhewJuorrLn+J7J05cwb33HMPHnroITz88MM3jdtDG8uHNuFrAQyET7mbX01VF2vwooTBaNowC6SCghxts9pl1i7M8ht5JBLRbBg8Ho9G/lpRxamFubk5HDt2DN3d3Vi7dq1hgSCEoCARZHn9XF31eRxeIgsUfHrQVHmqRGnQ2rxEUlcNEiE4k8hpLUBAFslscFsqvh9RSMH5+bxGxSgAq11mrNH9fhxNaV5/vCjh+NgVJEQKcHi1WcZyQYTfouajlkhMI7zYarWip6cHPT09KBaLiMVimnebqt4MhUJwOhtrD1WDnWOwmmOw2mVGXrN7MYoC9EkQLAUEFKPnoGXxIfTyVJOwiULq/HEEFW+6Vp4PqaKIk7M5g5rVxtLY4rXeVDO0rcClS5dw5coV9Pf3w+VygRACX7gTqQKP6HwKkWwel6aTkMw2gF1INiJXr2ilZ0IICrkckokZWMs2FR4TjbDVpG3OrE2KJSqRvW0+K7rtJlzWRbcFLZzmV1qJSC0V0RyvEamgmcGxocbJHrB4hS/FS1qcpsfE1D0fm+aNljheM4PdAbs2bz4yMoL9+/fjPe95Dz760Y+2yd5vCV5cq9cNQrloI8uLiOXlxcbK0gjobhJZXsRvIilDi0SFjaWx3WeFp4a4w2q1ore3F729vcjn89r81vnz5+FyuRAOhxEKhWC1Lp7I0AgikQhOnT6N1evWwxPqwESW15E72dakUQGs2rrRK+bUip2FWR5SVw2CRHC8LJKr2kwNIM/WnZzNGXJ57SyN7X4r3KbKv58oijhz6hSKmQxetmsXzBZLVUFEPC8gXtb+EpqcYjeZTOju7kZ3dzcEQUA8Hkc0GsXRo0fBcZxG/lpl92JhafQ4zehxmqtWNwUit2enszxoHcENWY0xYBUrriZg9uwQVlTYeCwFEpFblReTxszXXqcJ61yWm9KDsBnIFXcJo+PXMJ1IIbx5F8aKDDLTqbLNGQeYOaCGucDG3Xvg8vmRnpsDAUHvhk0IdHYveJxE5PPaztGGLOFGj/tMIm+Y0VPJHiHE0C0JWliN8C3HMqJv56aujsHtcDRVZSYGwrfwQPVija46Fc4ZXsSRaInsyfnepXGUsbEx7N+/H3/wB3+ARx55pE32fovQFm00iUKhdAMaTxVwckYe3t3mtyEnSBidl6sR6z1WrPPI5Gs2z2NQl4mrx1JzcFUPrkgkgkQiAafTqd3IG23hFcVSlS7Di4jNp5Eu8qAtNogN7pYpyKRXrdSpggYbS+O2DsdNsdgURQmD8azWiqQAbPdb0WmroPSsMsDf6zRhndtStWrB8zyOHz8OSZKwc+fOBa34egUR+vzbZm+cKkRR1Bz4Y7EYKIrS2r6tsnsxvF9Zkkm1gX2vWVH8WlhcVgygVawwEUTPDKOvtxd9fX2Lvuep2ZxGBGqJNuYLAk4mclo1BZCVv1sX2YDdzOClkuCpJJSQK++NiiX0ylcfC4iFHOZpC0BRiE5cw3OH/h9WeZ144J3vRp6zYSprNBnXw87SSsxb/TF+lcjedp9VU8YmiyJ+pdgXuU0MNnoseF4RVPQ6TNhYRyRhvdCLzyihiI7UFLZt3drU9TI2n8cFZTOzO2BDSDcXKhGCw5MpFCUCGsDt3a5FvS+zgojnoxkUlPXDxTHYE7Jrz7ty5Qruuusu3HPPPXj00UfbRsW/ZXhhrmQ3GfRGy7woGcQaKxWxxoSixC1fZznF1qFjibYOeg+u8hae3W5HKBRCOByGQ/GN4yW5EpkRFlqbLGi10ibAYqpqpaKSuoXq14XzOFPKbKMsRL7xZC8rSDgay2hJBCwF7ArYK7bucoKEU7NZw6C4lZGret4apCCfz2N4eBgWiwW7du2qOPe4UBAhIpIVMJ0tIqsjf/r8WztLI2yT1bCuJtSwqjdbMBiEJEma3cuZM2c0645QKKQFly8VDE3Jx2vjIBGC2YKISFYmf3pFaKIgIlEQca7s+StZEZHTx6oqmhdDJY4jSgSjyTwu6ebTKrXlb1aIElkwQqEKnyptLGuhvOKun4+dyhS1/G6nhcO4rvi8tiuETW96A+bn5hC7NCqPClh8mFUIn4WhDBuYjD7Gj6YQVMhftblOQghOl41a6MkeUG5bwhlapa1eZ6Z0x2Hns02TPaAsaaPsMOP5UtU/VIfReU6Q8Bsd2XNyNAaCNu15k5OTuPvuu3HnnXe2yd5vKdqEr0moSjHA2NJN8qXEhpCVg5mhcGEuu1CJC8BvZrHN3/ocXLWFF+7swny+iEhiHlPpLEYvR0BbUiAmCySq8fe0MlRF9Ws9jvQq1K+qcf1t66EONauLqpmmMBC0L6gCVTPb7XHIJti1qrKZTAZDQ0Oa2349i6wsiGDhNrFY6zbjx9fkSCiGgqGqmBEkXFRakGpEVoeNg6cJNSxN0/D5fPD5fNiwYYOW1zo6OopTp07B7/drit9WqMRpikLAwiJgYbGZWDBfVKubxhgwPa5meYQ2bIcj4FkQYVgNtR4xWxBwajZneD8XR2OrzwZXE/YtywXVc7K8SpepIx1mAQgBJRThsVngNHMGayILQ9W4jkt/v5LWq1M5bPW5QPXI0YDxeBxTsThmGS9AUWCIiB1WGiaHU86bLo/xk+RW7LVMEQwlz96FrKwmXKpE9naUVd8lQnTzenKi0XyxxEhb2YmXW8el7s6O3u4lESephmijnMTWQl6Q8JtoWjsfHCyNPUG7Nh4xPT2Nu+++G7fddhv+/u//vk32fkvRJnwtgL6NN6cTYqxwmHEsltYWIxU0gPUeC1a1IAdXkIjOn06epVMjw0o7fDNgkyuNixkeWxgKFppCdm4GrCRg7cpuuCzysHUrqh3ya5AbFq2motzLzc7SGAjaFyRgFEQJp2aNEVoWhsJWnxUBS+1FWM0WriRyqRf6Zzg5Btv9Ns0KRW8Vkl+ghq1dNan5nmV5rel02qASXw67F4+ZhcfMYrVTwlFde90AkwVRCYhGMzArBDdcIQN2MVSKu6MArHWb0ee8MVU91Z5Iq9QtNVmCKRmJy5U6ClNXLiE1E8dA/+6GZ3wrHcEKO4ct3pJ5r8lkQldXFwpOP2LKBtdWzOD48TFtXGB1MAhH2IuZoizsiRdKc50iAaZzPKZzPCjk4DUxEIFFRy1iOUHrSoRsMlE0VPga+qS1MZsrIKPs+jwmBs4q87r1oppoo6hEHQILDavLkRcl/CaW0RKZ7CyNPaES2YvFYrjnnnuwa9cufPWrX225dVEbLxy0CV8LoK/wqNUCM0NhbC6LubJBFgdLY4ff1pABrGggdUb1a6HRHb5ybDaGAi3wEDIpZOZmwEkCQl433E4nRs+PIuTzYfPmzS3fCWoVvhs4OjqZKeLkbE67hXlMDHYHFhpbT2WLOJPIG1rcXTYOm7zWRdsr8XgcJ06cqJktXA8MSmgszL9Vq2Kz+XI1rFw1YSko5I9DwMI2JTxwOBxwOBxYvXo1crkcotEopqenNbsXdVa0HvPtWiifpWQoICSkEZ1NwBZegZRUOvaCKM9SjuszYG0cAubanzGe53FqNmeojHlMDLb6rEueiVwMhBAU1RYsv7iSfTHo02HK27D6NUmSJJw5cwaZ+XnsGehviqTPF4wEvMdhwibPQvW6XA0vEekdq7pgW92Nubk5xGIxnDt3DjzPw+/3ozMUwuagH/MihUiORyxfIm4EwGwZ6Q9bWThYZkF111AJU0ZjSBUitRTwPI8T49OA3Su/VxOJF+WolrQxlS1573XauaqbkIIo4Ui0NJJiUyp7qg3Y7Ows7r33Xqxfvx5f//rXW5LE08YLF+1fv0kYWroVrkVBJJgrI2OrHCas91Qe7Nfnv2bK1K/N5L+aaKqi+rX8ZgD4IEkrMTs7i/HxcVwbHwfDMGAYBnNzc/B4PC0lfWrb4kZU+AghuKTYqKgIWVns8NkMJKEoSjiTyGNaZ+Jqoils8VkRrsNsd3JyEmfPnsWWLVtaYliqDsyX66vMDI0ehxk9DlkNG1MEH7EyNayaj0pTsnqx3OuvEVitVqxatQqrVq3SPNvU1q86KxoKheBwNCbIyYsSjkYzmoEzR1MI52cRv3oZ+3bvhsvlQkGpekQVxa/6begzYBkKBj9DAMimU+BMZozO5xHNG1t9692tqbTroZ+PXapYQp8sUTIhVjwn6xgFkSRJS8QZGBiA2Vw7z7sSrqQKhu8tZGErkj1AHmnR24ioJFodF1i/fr1WMb5y5QpOnz4Nr9eLYDCItcEg8hSH6WwRE1l+gep/OidgOpeGjaURssoZzjaG0qrvZobSHBH0T6VaUOPjeR6DQ8ModqwFIJ87S527Bsp8+HSHWW7qXAlFUcKRWEZzfLAyFPYE7bAoXYr5+XkcOHAAK1aswDe+8Y0bbtjfxo1Hm/C1AJUInH5vytEUdvit8JlZwyyO/kaQa4LUcSqpM1ibyH51jah9aZoGz/NIJBLYtGkTrFYrotEoTp48CUIIgsEgwuFwS5Sb6mERyCT3erXPVGf+K7o23kq7CZu9xhtXNCdXgPQD72Eriy1e66I3WEIIrly5gkuXLmHXrl3w+XwtOXZamd2rlRDM0RS67CZ02U0QdGrYmE4NK1Xx+gtZ2QXG4PXAZDJpQiGe5xGPxxGLxXDkyBGYTCaN/Lnd7pqEKitIOBJNa9eAmabgT0cxG5nEwMCAJjQyMzRWOkxY6ZA/YyzPI5I1ZsDq/QwlMY0v/sWf4vD3n4DJbMEH//cXse/VrwUgm9Bu9VlhY5ur6unFEhlB1MYoliSWKEuVWKrnpCRJOHHiBPL5fNV84cVQ7n8IACtrEOTFMl8pioLT6YTT6cSaNWs0g/BYLIbz58/D7nBA6lwNkS4RUytDGdbHrCDhcqqIyyl57k+rhFk57bj0HYSlLjGCIGB4eBjE4QGh5fMl3OSGqRxG0Yb8emle1DwgXRxdsRvESwRHYxmNXFsYCntCDm0kJZVK4fWvfz18Ph8OHTrUFNFv48WHNuFrASRRwLe/8hiujJzFzttuxyvv+13t3yzKLM2ZRL6pWRy1bWNQv7I0bFXyXxsFIQSXL1/G5cuXsXPnTvj9csSX3+/Hxo0bFyg3VdsOv9/f1CyIvhoqkdYOVFeDSAhOzuQMFbt1bjNWO83aDYKXCM7N5Qw7a46msNlrQYfuRlINhBCcP38e09PTmoltq6C+c71dcJam0GGTBRwSIYrXn1wZq+T1dzpRskIJW7kFc4z1gOM4dHZ2orOz02D3okbwqeTP6/UaNg0pRTijqnStDAV3YgLJxAz27NlTddaMpSl02kzotJkgKp9RNXtW24LP//RHOPz9JwAAxUIej37oA/i3V41grceKNS7zor9pJbHEUqruVoZeUKWzc3ImbKuVpKIo4vjx4+B5Hv39/U1Vdy4lCxiZXyg2q7ZJkwjBlCqeqLMCpjcILxSLGI6mkCLKbYkQhIpz6PO7YXa4DKIP9dvX/wzj6SJyooSQlTN4Vi5ljREEAUNDQ2BZFnSwC1Ba24uJKOoFMYg2ZBi99xaSZkEhe2qyj5mWK3s25brNZDJ44xvfCJPJhG9/+9vLbsjfxgsHbcLXAjzysY/h/33hUdAUhWd/8G3QNI2X3/N6APIwfX6RiCGWAmwso8zgNN62aRaSJOHcuXOIx+MYGBiA0+k0/DtFUfB6vfB6vVi/fj2SySQikQjOnz+PYrGIQCCAcDjckG2H/mYh78KXl/HxEsFQPKMpAykAW7xWrHCUFtKZvICTs1nDTTxoYbHFV5+CWpIknD59GvPz89izZ8+SZ9nKQVEUQBYLVqsMmpJtL4JWDoRYkCjKVijlXn+aFcpcfslef9XsXk6fPm3YNLBOD4ZnSzOSdpaGLXoZuWwae/bsqbsqwVCySCVk5bCFEMwWBFxKFZBJzhkeV8hlwQsCRpMFTOd4zeuPoylkxYU2Rc2KJbQsZ13VrlWip3ogiiKOHTsGURSxe/fupsjeWDJvyMH1mBjNZLzap4jqyHajFTCJEJxLCZhTyB4FYLVJQDGVwfHjlwEAwWAQvcEgtnf4MFOUMJEpYlY3WyihVN3Vo1aiTy3oyd7GrdvwbCQLQP6N/S3yZiwXbRCd4piCPDNsOCaF7Klzriaawp6QXUvgyOVyePOb3wxRFPGjH/2oJTGKbbx40CZ8TUK/I3/qqR8BhMgtSprBiV/9QiN8KvSzODZtwLo1+a/NQBAEnDhxAoVCAXv37l10F1iu3EylUgbbDtWzLRgM1hwMpssqfMuJvCDhaLzU9mAoYKffps12VVJrMhSwyWNFt33xqh4gf49qJWXv3r3Lkm1cqvAt7QujKAo+MwufWfX6kzTyp09+WeD1Z5W985rx+qtm93J2fBK5IAsoLTInS4GbvABRFDAwMND0vFFBIriSKiKeF7H3jrvwrS/+HWampwAAd/3+H4FTfp80LyHNGxM86oVBLFE2I3ujM3bV9iNFUdi9e3fDQ/qVkk3WueUZUY3wVfmIi7Vzq0EiBCd0FXgKwC7VhLgjAEKIJvo4f/48CoUCAoEAaH83APk88ZhoZAVSsZ1+Yb6A6SyviZecdZzH6vfIMAx27NiBq9nSzGiXrXUznwZbFopCPC9oQrxgWeqMqGxe1d+BUyp76qasUCjgLW95C1KpFH784x8v2MC30Uab8C0RhBDs3r0bo6OjEEUREpHQu2mr4TFmWt7xdtpNTXmktRr5fB7Hjh0Dx3HYs2dPwzcFiqLgcrngcrmwZs0aZDIZRCIRXL58GadPn4bf70c4HK7o2Wao8C2jF1+KFzEYy2hVLBNNoT9gg1vZmScKAk6WebD5zAy2+Wx1tzQLhQKGh4fBcRwGBgaWTQGnfmWt/LZkrz8GbhOD9R4L0rzig5cVDBmyGUHCxVQBF1Mlr7+wjYO3ifNY3TTkORsuWrLa35l8Bpnxs+BoGqtXr4Yk1ZpWrAxCCMYVQY569C6vH3/3nZ9i8BdPw+X1Y+fLXlH369EA7CwFO8c2JZa4EeB5XiMpO3fubHjkghCCC/Pyb61ig9uCPpcZZxO5ms/Ni5IWBWhhKPjN9b13TbKnQN9pWLdunbzeRKMYFSiAAUAkhAvzCAcCKDAmRHI8JjK8obKX4iWkFIKvnsehKpY+KtmjaVr7HicypfO1Ve1c+fOX/jdNARPZymINkRAMxbNaRZOlgD06z1Ce5/GHf/iHmJqaws9+9jN4PJ6WHWMbLx60Cd8SIEkSJEnCZz7zGTAMg2PHj+Nlr3oN3vj2d2FeKLXgChIwnuExnuFhZih0LOGmuVSkUikMDw/D7/fXbQRcCxRFabYdKvkr92xT831NJpOhwtfEGFRdmC0IGIplNLGClZEd5+0cA5EQjM4bkxVoSr6x9TSg1sxmsxgaGoLb7W4qQ7MRNDrD1wwcnKyoXOOSh+LV/Fu9SW4rvP4mMkWc0lni+E00ilevwOr1wufzIRqN4sKFC3C73VrrV98irySWSPEiUnzl7YPD48Ur7n1D1eMpN7NWIQHIiQQOk+x/GLCwN7x6Vws8z2NoaAgmkwnbt29viuydL7su9FnSRtXrQkxlSjYiXfb6riOJyPnVaguWghwvFqyhhFfXmwxtBpmRSZiLEjEbjWHs/Hk4HA4Eg0F0uQK4oowf2ljasLHTn8eqpU9IsS2iiIRjx44ZyF6yKJ9fgBzb1kr7Hv3WRlBypwG5ehe0yrdniRAci2cxo3i8MhQwELRr5uCCIOCd73wnxsbG8Mwzz7RMLNbGiw/tLN0m8cMf/hC7du2Cy+UCRS1syarGmdM5HjM6Cwk9zGrUVBPmsc1gZmYGJ06cwKpVq9DX17fsZFP1bItEIkgmk/B4PBBDPUhQ8k3k1rAD7hYnGkxneZyYyWoLqYtj0B+0wczQmC+KODmT1aw/AHk2aZvPqs3A1INkMonh4WF0dHRg/fr1y/49/mJKDrXnaAqv6m6dGKQeqFYokRrnMUtBicfiahKjK6kCzuoUnyEzhcz5E/B5vYbNRy6fx2RsBtH5FFIFHqzNAcbmgMiYUFzCatVhZeE1qxW7kliCV260EcXupdKoAQ0YVM03U5WvWCxiaGgIFosF27dvb3jzUUnBvsljwSpnaYbyTCKnjT6UX7eEEPxyOq1dV7d1OBa9nsrJHg25sleL7OkxFM9oxsT9yvP0SvGIyEIMdAMA1plFdHpdiBfEBZ6VetAA2EIapnwG/ev7YDXJx3I2kdO+m81eC3ocrVO8/nI6hRQvgVZGSU4rldQehwmbvVaZ7M1ktc+qkj01ylEURbz3ve/FkSNHcPjwYXR2drbs2Np48aFN+JpAsVjEnj17MDIygle96lU4cOAA7r777qr2E+oNZTpr9A/TQ62YdNjkGatWkz/VG27Tpk3o6upq6WvXg3w+j2g0iotZCXnFuHSVlEJvyN+w6381lBOKgIXFTr8NNAWMKRFk6ndPAVjntqDP2dg8jkqa+/r60Nvb25LjXgzPTqWQESSwFHDHCvd1ec9KqOb1p0e51x9LyU7/cZgxrhuX6zABs6Nn4At1wNvRZchzbkYsAcg3bJ+Fhd9casOq5swAcEvIDs8iw/aiztImqrO0KcdSVc2tQqFQwODgIBwOB7Y2kelKCMHZOeMc6xavFSsdxhm807M5XFVm9F4Sdhii5+YLAn4dzQAAvCYG+8KOmu+5VLJXECUcnkyBQBZQvLLTueAaPj+Xw0WlWmmaGgOdTWpzxi6vDwleWmDpUw6viUHQwuJiqgCByMd5e7erJe4IKtTNHEvJVXZ1Pu/WsANOjja0u2kKGAjY4VO8BiVJwgc+8AH84he/wDPPPIOVK1e27LjaeHGiTfiaBCEEZ86cweOPP44nnngCIyMjuP3223HgwAHs378fXq+3KvmLKfFB8ZxQ0VuNoymErfJNs5lorPLjvHjxIsbHx7Fjx44bXu4/P5fXZoTciQlkopNwOBxa27cZVVml2aMuG4etPisygoSTM1nNwgCQva22+RpLOwHkPMrTp09fd9L83FQKaUECQwGvvoGET496iFExn8Nn3/eHGPrVs7DYbPjzR/8/7HzZK8FSgCBKQIPkhKMBE5FQ5AXwNGt4/gobh41e64Lqor46Uw/h00MiBLMFWdUczfGadUw5lqpqbhb5fB6Dg4Nwu91NpeJUyqndWqZgV3FqNqs97qVhh+Ha0ZPBas9XUV6xoim5jbtYTKEeem/APqcZGzwLBWfn5/O4qAhPBgI2sIUMYrEYotEo8vk8/H4/gsEg/IEA5gXg7LUICmY7CFP9/LCzNLb7rHC1cBTn8GQSeZGAowBeOb0cLI2XhO04mciXbG4A7A7aNWNpSZLw53/+5/jP//xPHD58+LptPtt4YaNN+FoAQgjOnTuHgwcP4oknnsDp06fxile8Avfffz/2798Pv99fcYFQzWOns9UrJmo0VodNbpc1Qv7USKVEIoFdu3ZpBrY3EqPzeYwqC3F/wAYPK1eAIpEIZmZmtLSGcDgMu91el1faqdmcIa94tdOMtS4TrqR5nJ/PG6p6q11mrHE1npc6Pj6O0dFRbN++HYFAoKHnLhVa2wfAa1beHIRPj4IoYSpTRDQvYL4oahWTH/371/CVT3xEHj6kKPhDHfjHnw/WfC2GQsnWRKdkt7E0CiLBydmcQVTCSgLo6cugssmKHpFLIXx6EEIwXxS1KDv9TJgedpbWZhvdyzijm8vlMDg4CK/Xi82bNzf8PkS5bvQige0+a0XfNwA4OZPVHvuyDodGbEVC8MxEEgKRf7vbu1xVW/oSIRiOZ7VkDJnslUhMvVCvh/Jj0WNkLqfNI+4NlqpihBBkMiXyl0qlwDAMWJbFjh07IJlt2ghDpspvbNZEH0vvxjwzkURBIoZZ0vVuMzKCpHmCls82SpKEj3zkIzh06BAOHz6MtWvXNv3+jeKLX/wiPvvZz2J6eho7duzAF77wBezdu7fiY7/yla/gX//1X3Hq1CkAQH9/P/72b/+26uPbWH60RRstAEVR2LRpE/7qr/4KH/3oR3HhwgUcPHgQ//RP/4Q//dM/xW233Yb7778f99xzD4LBoLY4681j1XQEmfyV2gz6aCx1VqqjjsxQnudx4sQJzS7kZnFa1y+OIpENe7u6utDV1aXN4ESjUVy+fBkWi0Wr/DmdC9s2giRXC+K62KdNHgsCFha/iWW19ggg75q3+a1wNxh2TgjB6OgoJiYm0N/fD7f7+hMuNRrqRu7MBEOes6iL/5Oq+pxl06lSBCEhyGXS2r/RAKwsDY+ZgcfEyLYmVZIlJEJwUbEK0b/TKocJ69wuMD0+zM/PIxqNGmw7QqEQJFNrZh4pioLHzMJjZrHeTZAWJK3yp68eZwQJl1IFXEoVNGLQ6hndbDaLwcFBBAIBbNy4sWGyV75JogBs91vRWSXCC6gu2tBXd8NWriGy1x+ww98g2atXQKE/JfVfj15k1tPTg+HhYeRyOdhsNvzmN7+B3W5HMBjEjlAIosmG52PZBa+tz3FW1+SQlUXQUv3zV4N65uiPN12UMFmmWlbJHiEEf/3Xf41vfvOb153sffOb38RDDz2EL3/5y9i3bx8+97nP4c4778TIyAhCodCCxx8+fBgPPPAAXvKSl8BiseDTn/40XvOa1+D06dPo7u6+bsfdRgntCt8yQm2nqpW/oaEhvPSlL8WBAwdw7733IhwOV1ys1XbZtNIuqzRjwqjkz8ohaDGSv3w+j+HhYVgsFmzbtu2mCszWt2NqVRREUUQ8HkckEkE8HteiusLhMFwuF4oSwWAsq1V7aADbfFYUFW89/XfW6zRhnbtyhnEt6Cuku3fvvmEmpr+OpDWj1TtXuJatalSe5yzP1MlmxIUmJNUz05N4+P7XIJmYBQD8/kMfxuv/+MEFjyt5/bFwccaq2HxRts9J60iVnaWx1WfVBtf1IIRoWa3RaBRJmw/EJ+cZ7/aaEHK0Zl5Uj2qqZj1UNWi4js1aLWQyGQwODiIcDjclGJIIwYnZHKZ1ZG+H37ZoKsbxmazWXnx5p0OLpDsay2gbrj3BygROVFSmSyV7QP0CCoPIJGTX7JhUSJKsxhUEQfMr5HkeMzMziEajiMfjgK8DRb9MTFbYOLjN7IIcZz0oyMIeNee3HtP2n1ybN6xVFobSrKTKfxtCCD7zmc/gS1/6Ep5++mls27Zt0ddvJfbt24c9e/bgscceAyB/hytXrsSDDz6Iv/iLv1j0+aIowuv14rHHHsNb3/rW5T7cNiqgTfiuE9QIs0OHDuGJJ57Ab37zG7zkJS/Bfffdh/vuuw+dnZ2VyZ8SGzWdrT4rpQbGd9g4WPgcThw7hmAwiI0bNy6rXUgzGE8XcCYhE77F5n1UiKKoLcSxWAy0xQa+ay0EWl7EWQrY4rPiWrqIGd0N18bS2FaFGNTznmoO6e7du29ohfT5SBoJhfC9ZoVryTOdOZHIRE5XpcvwEnJi4/53anSgajxsZihcShW0Kkw6MYNrv/opOJHHff/tzSiY7Qu8/spfT1X7zuQFXNaJCSgAfUpLvl7yfjKWwkReMd6+cgYeM6vFvLVKLKSHqmquRQzU61UVttQrAkin0xgcHERXVxfWrl3bFNkrt0HZGbAhXIdY4lg8q4kHXt7phI2lkRckHJ5KAZB/t1dUEE+ISmVPJYWM0sZthuxJhOCZyRR4iSwqoDg1m8O1KiITSZJw/PhxFIvFqkkkkiThuckkskR+fW78DMJuJ4LBINxeH+YELMiqLofbxCCskL9qlcinrs5XrdzrN8SEEDz66KP47Gc/i5/+9KfYvXt3lWctD4rFImw2Gw4ePIgDBw5of3/b296Gubk5fPe73130NVKpFEKhEB5//HHs379/GY+2jWq4eUo/L3JQFIW+vj48/PDD+O///b/j6tWrOHToEA4dOoQPfehD2Ldvn0b+VqxYoS2c+tgoNRdVrvyVYoz0gfGQJDj6NsPtd0MChZuL7sFwo65Xi8kwjHaTTuR5DMYyENTGklCEXczj1AyBqGs29ThMWO+2NOWdViwWNS+upaQ+tAr6e2g9aXSEEBQkgmxZlU79/83kOZeyX3VpMWXJEnlRMgS6sxSwycnCv2Eddu3apZnBrnEBOUFS5uGqe/3p4WApbPfbDTfueiBXt+XX2r5jB4pzM5rXn8Ph0M6reuZF64GZobHSYcJKh0mb0S1Xg+qvVwo5+CysRgyqVYVSqRQGBwexcuVKrF69uimypxdLVDI4rgV9sJ96hPq52e4K3nuiRDA0k8WMjuz161SmjSKmW/NCixBlw/HqHlYP2QOAjEA0sufiaGzZuhnRaBRjY2PI5U7B5/MhFAphQzCADGE08ZI+rnC+KGK+KOL8fAE2ltZ+Y9V8n9SIS9xaRva+/OUv49Of/jSeeuqp6072ACAej0MURYTDYcPfw+Ewzp07V9drfOhDH0JXVxfuuOOO5TjENupAm/DdAFAUhZ6eHvzZn/0ZPvjBD2JiYgJPPPEEDh06hL/8y7/EwMAA7rvvPhw4cAA9PT3aQqrPRZWUzNDprDEwHjSNNEw4OZvDKeS0yt9iC+T1wlKi1WI5HsdmshqxszEUWJrFvFSa02IkAastQJ/bCbqJz5vL5TA0NKTZXDRqYLscoHQMT/+VFUXJYGciV+xkctdoB1YTS3BKBqxG8Ji6zpusIJM9VcxgoikEs3HEJ69WzGm2sjR6nWb0Os1aVWw6y2vmsuXIiwSXUoVFvf5qwWQyIbxyJVauXAme57XB/UuXLsFisWjkT/XWXCr0M7pqpT6qbNbUCDACOct5Ji/gTCIPj4nRBAGql938/DyGhobQ29uLvr6+ho+jUkt1l79+GxT1ODVQMgmpFaUmx4AZzYL7g3b4lpBBO5HVv1/tY9f3rdRfUpIknDhxYlGyt/C9THA7zVqspCr6mJiYwNmzZzWT8D3BIATOorX39WMIWUHCpVQRl1KqaTkLv4nG4e8eRGziKva+6i6s2rAJgJL1rSN7//zP/4yPf/zjePLJJ7Fv3756v66bCp/61KfwjW98A4cPH140xrON5UOb8N1gUBSFFStW4AMf+AAefPBBTE1N4dvf/jYOHjyIj33sY9i5cycOHDiA++67z2CWTFMUAhYOPhMDLj6Ka7Pz8K5ahzmJNtxMYnkBsbxcSQjcBMaxtI68SA1ME1xLF3E6UUposLMUCiKQJaXPEWAJ7MkZTFyZxvgZsaJqsxbUFJJQKIQNGzbc8Ag8QBZLiLrv6dRsFnmR1BRLVAMNaFU6rQ2rKGGXkuec5kUciWW0OT8LQ8E7P4W5eBQDAwOLzj6aGRpWlkZWqNzmBWTx0lSWx1SWB61riS62kan2L3qxkDovGovFMDQ0ZKgoezyeloxF6Cv1hBAkCqJW4dRXheaKIuaKIkbmAQdHw02JiI6ew5rVq9G7alXD71upytZMS7WcQM0XRU3F6jXLFV/De1ZIhmhmtEJFUZQQU6qTZoZaVNlrFG1QGtnL5/Po7++vSfYkQjCpU8h2ls032u122O129Pb2olAoaBuH0dFR2Gw2hEIhbAsGwfodiCnWRfoqdlEiuJbh8fG//Cs8+fWvgqZpHPz7z+PTB5/Ea/ft1jwQCSH4t3/7N3z4wx/G97//fbzsZS9r5CtrKQKBABiGQSQSMfw9Eomgo6Oj5nP/9//+3/jUpz6Fn/70p9i+fftyHmYbi6A9w3eTghCCSCSC73znOzh48CB+/vOfY9u2bThw4AAOHDiANWvWIJ/P4/d+7/fQ2dmJz372s7Db7drNZFq5mVQatqcgG9R2KPYR15P8xXI8BuOy8m2Ny4x17tq7PaIoNC/owtz1g82AXE3a6rNq7SlCCJLJJCKRCKLRKIrFIgKBAMLhsLZwlSORSODYsWPXLYVEj4ViCVGr3DUqlqAgV89shiqdTO4sTPOkrhrmCwKOxrMa+bSzNBzxceRS89i9e/eiu3leIhiZM3rB0RSw3m3BChuHGYUYVZtfpQD4zCzCtsot0XOJnDYHuC+0OOmQJAmJRAKRSASxWAyEEG3j4PP5Wl7xJYQgySuijyxvSIHRw8ooUXYNRDIKEsFQPKPlry6lpToYy2gVwt/pcuLCfKHkvecrVaREiWCw7D2XSvaA+rz39BiOZ7RZxZd32HHhzGnkcrlFyR4gK4+HlDUqbGWxK1CfWEsQhNKs8WwClMUGhy8Ak8MNgeGQEiTDuvUHAxuQS8szkDTN4I//9CH8n7/+X9q/f+tb38L73/9+HDp0CHfeeWddx7Cc2LdvH/bu3YsvfOELAORrpaenB+9///urijY+85nP4G/+5m/w1FNP4ZZbbrmeh9tGBbQJ3wsAhBDE43F8+9vfxqFDh/DMM89g3bp1SCQSsFgsePLJJ9HT01PxeXNFUWn7GisJevjMDDqUiDfzMpO/mbyAIzHZlX+xhZsQgjOJvHZjAWQyoN+9d1g5bPZaqpJWVbWpkr9cLqdZdgQCAXAch0gkgtOnT2PDhg3LZhegiiUyvLigDbtksUSZX91yR/SpmMkLGIpntPaxk6NhnhqDUJCFLiZTbUFONMfjdCJnILU+M4Mt3oVRd+oIQyQrV0yKVaqbHhOjxRXaWBrn5nK4nKqf8OlBCNHsXvQbB/XcWQ71e4aX478mUjlkpMq/o9oSrGXMLijEK9Ei4qVX476yy4nnplILvPcqEcxWkD2gPu89PfQENZQYRyGTRn9//6LnJGAki7trzDmKpGxOllcznuurvv/ZPb+Da2PnIUny5/rSl76Et73tbQCA73znO3jXu96Fb3zjG7jnnnsWfa3rgW9+85t429vehn/4h3/A3r178bnPfQ7f+ta3cO7cOYTDYbz1rW9Fd3c3PvnJTwIAPv3pT+NjH/sY/v3f/x0vfelLtddRbXHauP5oE74XGAghGB4ext133w1RFDE3N4cNGzZoM3+bNm2quPtXjWOnlUpCrgr585oZufJnq89WoFHMFQT8lxLDtMphwiZvZaWkKBEcny0NmZeDoyls9lpqeodVgp78ZTIZ2Gw2ZLNZbN68ecnpGapYoqR+FXWzdY2LJUw0pRgOS9rvNRCwwbsEW49WIZrjcSxeyiz2cDSoa+dBEwk7d+6sWUUpihLOzpVSBACZHGzwWLCywvB/OdSNTETZyFQ7l50cDYaiND/GRglf+Xvq7V4ymQz8fj9CoRCCwWBdRKJexONxnDhxAms2bALl8sn5r4X6c4wFieBoLKN9blYhXs2aTgPAkWhGa9Fu9VpxSsl87bZx2Oa3LSCYrXhPFcmiiF9FZA9Ht4nBrYtEtwFGguqaOIeB3bvq+o2KooRnlNg2E03hFZ0OFCQsIHRZXqx63lUFIaCFIiRRACx2jJ8/h//zZ+/BzNQ1/N4DD+D//t//C4Zh8OSTT+Jtb3sb/vVf/xVveMMbGnuPZcZjjz2mGS/v3LkTjz76qDZX+MpXvhK9vb342te+BgDo7e3FlStXFrzG//yf/xP/63/9r+t41G2oaBO+FxiOHDmC/fv3401vehP+7u/+DqlUCt/97ndx6NAh/OQnP8Hq1atx33334f77768at6S2kdTKX7XUAI+pVPlrVV6ofvFeaTdhi28h4SuKEobiRuNkPYIWFlt81iURUkIIRkZGMDExAYvFglwuB6/Xi3A4jGAwWNOGpZJYQiV3zYklGN1cHa2JJ9TZNKMHmtMwL3UjMJkp4uRsaZ7Sb6IhXDoDi9mE7du3V217EkIwneNxNpE3VOgCFhZbvNamzjFCCFK8ovit0RIFgE4rh16nqSXRWPq0hmQyCY/Ho5G/pdi9RKNRnDp1Cps3bzbMRql53BHF7qVijjHkDVtWKG0QOJrCQNDWsOF4OX4TTWuVO7+Z0eyP9gZl5fRykT2gfu+9asf7ipAF1hrXMyEEvCTPxY6niphS7Gc4GhAlVIy/rAUzQynXsfG6trI0prI8Ts7mtMdSM1P49pc/h0AggDe+8Y2Ix+N44IEH8JWvfAUPPPBAg+/cRhu10SZ8LyD89Kc/xf33349HHnkEH/zgBxfctObn5/G9730Phw4dwlNPPYWenh7cd999eP3rX181WF29YU7n5Ii3auTPbSpV/pZCONK8iOemZcKnVgf0yClqz0qxRgwFbPJY0W3nlnTDliQJ586dQzwex+7du+FwOJDL5RCNRhGJRJBMJuH2euEKhmF1ecFTTGln36xYQmu7Mgqhq18scWImq1lg3NbhWNDuvJ64kirgrDJLBQAhM43shRNwOZ1VzzFAtmw5k8gZKrYcTWGjx4Iu29J+Tz3SvKgQI0Ezqy6HRZ2Ha1ECRj6f18hfIpHQsqGDwWBDratIJIJTp05h27ZtFZMLVNSTYwzI842rHCascpqXvGF7PppeYCptZSi8JOzAUDyr+USylGzAXG503Cwa8d7TniNJOHwlhiIrj4uo3pWikhaT0aXFNHtNsxRgVxTt5XZF1RTkU9kijs+UyN4qhwl9Vgr//M//rHmziqKI1772tfirv/or7N2796bzUW3jhY024XsBYXx8HENDQwbjy2pIJpP4wQ9+gEOHDuFHP/oROjs7NfK3Y8eOquQvrZC/WtUSFydX/jpsrOa4Xy+ygoRfKGatHTYOO3WEL1UUcTSeqShU8JkZbPPZlnzjEkURJ0+eRDabxc5duyCxJp1HnaiYEIsoNritV8USdr1gQrkhLFUscXI2q+Vq1jO/tBwghOBiqoAL8yXxTKeZwvzIcQT8/pqjBBNZHucSOQMxCVtZbPZal3VmNCdIODmb1So9lcDRFMKLzMM1gmKxqMUDzszMwGq1aqKPWnYvU1NTOHv2LLZt24ZgMFj3+8mzjSImM0VMZfmqYwMujkHYJn9OO0s3fD7+VyS9oOK+2mnGbEEwtI73hOxLribqEcnxGFYEFB1WDjsDtpqPlyQJx8+OIGr1g3ByVc9nopEVSdUZ5mqgAMPmTF+xa1TVHsnKllLqEfQ4TNjksWiv8atf/QoHDhzAAw88gEKhgB/84AewWCy49957ceDAAfzO7/xOS8cG2vjtRJvw/RYgnU7jhz/8IQ4dOoQnn3wSoVBIa/vu3r276i4yzZcEHym+MgNycrRM/qxcXZWnvCjh8KRM+PQKuJm8gKFYBuW3ZpoCNrgt6HEsPttVCXqxRKrAY3w6CpE1gbE5Gr4BAAAl8LDSgMtqgsdqNrRrlkssoU8NeGnYAWeD5sNLBSEEI/N5TfwAACvMQOzMMFZ0d1dNfcgJEk4ncoasYxNNYbPXumiUV6swMpfDJeW4+xwmpAWpZgJGqGwebinQqzbj8ThYltXIn9fr1b6ziYkJjIyMYMeOHfD7/Q2/T0GUcERneM1QMpGtdn7b1Cg7Kwt3ne1tfbyfCidHa+uC3Dq2w93ic3MontGqwv1KpiwhBEWlBWvcqMmbNTR4HVoYCnaWAS9JWi7yapcZ61zmllSeowppVX+NFXYOW7xW7bWPHj2Ke++9F4888ggefPBBUBQFnufx7LPP4jvf+Q6+973v4b/+678WtT9po43F0CZ8v2XIZDL4z//8Txw6dAg//OEP4fP5cO+99+L+++/Hnj17qpK/DF8SfCSrkD8HR6PDyqHDVj1KqChKeFohfAELi4GgfUGrQ4XHxGCbb6FisxyEEBQUbzpNLKFr1zQrltD71dlZGhxEzCr5vjMzM7Db7Vq+b6uSGirBkAsadrT8ploLhBCcThhtU3rMBJHTw1WNgAkhuJouYqQs07jLxmGjp7qiejmgJ3x7g7IlCS8RxHTzcJV4EQ3F688mZ1Uv9ZglScLs7Kwm+gCAYDAImqYxOTmJXbt2wefzNfy6eVHCkWhpBMLMUNgTtMPO0kgLEiJKJGO1a9asRNkt1t7+1XTaEIfHUNC+N46W37PRFJTFkOVFPDudBlHeL2hhtc1btTZ2NXDqNa1rv6rVeIaWUy8OT6VQEAkoyErkVlSf43keg7ES2euycdjmK5G948eP43Wvex3+8i//Eg8//HDVKvnN4AnaxgsfbcL3W4xsNounnnoKhw4dwg9+8AM4nU5N7btv376qw/dZQcS0Yo9RbU7KzpYqfw6u1EISJYKfTCQByG3aoIXFiK5NCMitlHVuC/qcpaqefrBar3xtVizBUpDn6WqIJWpBEARtbisej8NisSAcDiMUCsHpXJgpuhToh9ZvCbVuGH4xlGevAsAqTsDUmeNYt24dVq5cueA5GV7EqUTOMO9lZihs8VrrjvFqJUbm8riUks+vPcGFhsOiRBAvCIhkecTyQsVZrsW8/hoFIQRzc3MYGxtDIpEATdNa5a8Ru5e8IOE3unQTi0r2KmyQsoKkiT7KZ/FUcDSFoEJyA2VKcL0tSvlzlkL2JEKQE/Tq11LFrlEPShAJdpaBw8RgtiCClwgYCnhFp3NRwq73Bw1ZWOwO1ue9VwszeQGD8YwmsOmwcdihI3unT5/Ga1/7Wnzwgx/ERz7ykTapa2PZ0SZ8bQCQB89//OMf49ChQ/j+978Pq9WqzY/ceuutVW9CWaGkkKymqrWxusofS+HHE3KFj6MAvuzsc7AU1rgsAAUdqWtSLEEBZoqgkJyHy2JCd9AHB8c0NYNTC2pSQyQSQTweh8lk0pIa3G73kt9nKV5yzUKQCIZ1CQ0UgFVsERNnTmDz5s3o7Ow0PJ4QgsupIi4k8wYF6Qq7CRs8lhsW67cY4dNDnYdTq2KFWl5/SxQwXb58GZcuXcKuXbtA07RW+cvlclpOay27l5wgt3FVsmdlKOwJOeo6HjXKLqpUOKu1t9U0k6CVwy/GY7h0ZRzBzm6YrfIcXb1krzzbWS+YyDVRgbcyFOxcKc95ZvIasokZDOzYpimkfzGVQlaQwNEUXtXtWuQVgWMzWUwrwqhdfhvCSxw5mC0IGIyVPCrDVhY7/DatgjoyMoK77roL73rXu/CJT3yiTfbauC5oE742FqBYLOInP/kJDh06hO9+97vgOE5r+770pS+tSv5yOvKXqEL+cjMxfPx9f4SxU8exeWAfHv78V+D0eAEY20T1YoFYQqeWS83O4NSpk1WrUcsBURRLbvuxmBbTFQ6H4fF4mlrY9aRFbUsuJ3iJYFDn40ZTQA9ymDx/pqKoIMWLODWbM1R7rQyFrT5bwxFerUYjhE8PzetvEd9KJ0drLVF9JbsWLl68iPHxcfT39y/IGM5kMhr5S6VSmt1LKBTSUkuygoQj0bR2TFaGxt6QvSlBkyARxPI8IlkBsTxf8fqLjF/GR//g9ZiNTsPh8eLjX/sW1m3eir1Bu2GeVFAq8Ble1FXim8t2ZilobVsLQ2GTxwqbUo1ndFX/s2fPYnZ2FgMDA4ZUl8OTSeRFAjNN4fZFCB8vETwzmYREZBJ7e5dzSfO4cwXZXF79zEELi12BEtkbGxvDXXfdhQceeACf+cxn2krcNq4b2oSvjZooFot45plncPDgQXznO98BRVG45557cP/99+O2226rarCbFyXNGFevkvzcw3+CX/7n9yCJImiawV2/9za846N/vehxWBRvq/I2bDWxxMTEBM6dO4etW7ciHA43/wUsAeVzWxRFaTdvr9db90J/fj6Pi8nGSUszKIiyLY7avmMpoFtMYfriBezYscMwZyYpsXdjyYKhSrPKYcI6t2XJoodW4PxcHhebIHx6GLz+crwmjiiHLIaQq2KVxBCEEIyNjWFiYgL9/f2LWrbk83nt3Jmbm4PT6YQn1IFJkwcFqfSee4N2WFrgzSgSgpm8XPmL5gTNK/GxD38QP//eIeWapbHrttvx9W8+DolAa79mealqRbQaaAqa+rWkhJWv7bFkoab3Xi2yBwDPTCRRkAgsDIVXdtUmfFeVnG5AVs9urmIGXw/miyKORNMaWQ1YWOzWkb0rV67grrvuwr333ovPf/7zbbLXxnXFjd1+t3HTw2Qy4c4778Sdd96JL33pS/j5z3+OgwcP4h3veAdEUcT+/ftx//334xWveIWh/WRhaKxymrHKaUZBLFX+4tOTkESZABIiYSYyrT1HvQG4OJXUGQer6wEhBJcvX8bly5ebHoRvFWiaRiAQQCAQwMaNGzE3N6d5rakZreFwGD6fr+bCr//k0jLuz8rbhCaaQjg/g8jVK9i9ezfcbrf22PmiiFOzWcNcl52lsdVnvS4t5+sJiqLgMjFwmRisc1u0+LPyGdasIOFSqohLqeICMQQF4MKFC5iensbAwADs9sVnxCwWC3p6etDT04NisYhr0ThGBTOUJC5wkoDNVhZmpjXEmqFkf8KghcUap4Rr2SLGU0XwxSKgnHeEEBQLRi/GxaC2Xu1lFfhqdkUSIZrROAUsSNMhhODcuXOYnZ1Ff39/xbxm9aysp1I3oYtu7LY3b32SLIo4GstoZM9nZrBL18admJjA3XffjbvuuqtN9tq4IXhxrcxtLCs4jsMdd9yBO+64A4899hieffZZPP7443jve9+LfD6P/fv348CBA7j99tsNSRVmhkaPw4wehxkPvuOP8L6jz4OiKBAArzzwu9rjJAKkeAlFkYChObhNVN1tMqCUnhGJRDAwMLCgXXYjQdM0fD4ffD6fRv6i0SjOnj0LQRC0oX2/379ALKO/LSwX3Uvz8s1KtfKwMBT8qQhmIlMYGBjQqlEiIRidL+ByqlTVoyDnIq9xm7V224sZdo7Bao7BapcZeaFU+dNXsgsiwXi6iPF0ERxNwVzIgE9msae/vy6yV44ixeAK5YDEKL8PJLiTUzgxFgXHcVrluJGxAV4yZjtXS4y55w/fjSNPP4VCLgeGZfH6dz+44LVMNKWQuYX5zo22R+P5UnUxbOUM85/qNR6PxzEwMFA11URtXC32zhle1EYXHBwNF9ccCUvxIo7EMtqcsdfMYHfArm1Up6encffdd+O2227Dl770pTbZa+OGoN3SbWPJEEURzz33HB5//HF8+9vfRiaTwd1334377rsPd9xxx8J2yzPPYHBwEHtvvRWrd+zR7DEqnYgmWq6UdNhq20ZIkoRTp04hlUph9+7dS4q3up4ghCCZTGopH8ViEYFAAOFwGH6/HyzL4mKygPPzckWlFQPl5ZhXKhPqzcrG0nDNXkM6MYP+/n7tu0wUBJyazRlSUJwcja0+23W1imkErWjp1ouiIoaodT7L9iIcwjYWQQtXV9s7VZTJhEqCnByNPUE7TAwNURS1sYFYLAaKorTNg8/nAyhKF/9ntCwqNtCCTUQjuHj2FFat24Cta/u09msjyvZ6MRzPaMpw1XsPKJG9WCxWk+wBwI+vzUMiMol7WUf1jZ/+/NjgtqDPtXhsWznSvIjfREu/j8fEYCBo137bWCyG173uddi+fTu+/vWv163CbqONVqNN+NpoKURRxK9//WuN/M3Pz+O1r30tDhw4gFe/+tVVF2ktKzSrZIVWeEy1VASe53H8+HGIoohdu+oLSb8ZQQhBOp1GJBLRFJt+vx9UsBtTkvyZdvptLTUtns0LGIqX2lBOjoYlcgnFbAa7d++G2WyGIBFcmM9rM1WAXDlZ6zKjz2VeNsPpVkA//zgQtCNwnUQkgnI+X5ieQY41A/RCQkwD8Cs2KKEqXn/JorFy5OIYDARthscSIqdIpIsC4qkMZjM5ZHkRImcGWFPDRsR6eEw0+pxmnFbyj+uZiVsKiqKEZyZTIADMNIVXKAIKQgjOnz+PaDS6KNkDgKeuzoNA/r5e0lF5VpIQgp9PpZBXvPde0eVs2HInK4h4PlpKB3JxDPaE7BoBnp2dxd133401a9bgm9/8ZtWZ5zbauB5oE742lg2SJOH555/XyF88Hsddd92FAwcO4M4774TNVjkmSb1ZRnKyN1qlQgRHUwhZWfhZ4MqZEzCbTNixY0dV78AXItLpNKLRKMYzPPIe2WV/JZXHupC3JaQ2luMxPJPVvl8PR4OZHAUReOzatQscx2EmL+DUbNagUnWbGGz1WeG8gZm+9eLCfB5jN4DwqRXndDqNnbt3I00Y2e6lhtef18xoc3/T18Zx6sIYpJUbYLLLFSonR2OD24KCRLT2q6qGbVAvAbNOBAXI54JedGFjaWzxWrWK6NMTyetC+C6nCjinzAf2OU3Y4LFqZE8d1ai2bqgghOCpa7LXp9vE4NZwZcIXzws4GssAkJW0/Q167+UECc9H09oYhL7yCsjZ5vfccw86OjrwxBNPvGA3om28eNAmfG1cF0iShKNHj+Lxxx/HE088gUgkgte85jU4cOAA7rrrrqqKxXpsIygiocNmQqfdBL+FfdHNkV1JlYbkbYlJFKMT8Hq9CIfDCAaDhnnJejGVLeLETE5rO/pNNMQrZ8ExDHbs2AFCMxiZMyZs0BSwzmVBr7O5mLsbASPhsyFgWf4KiyRJWl5zf3+/4UYvEYJEoWT3UknZ+usf/QB/99B7IUki3P4APvXNHyK8YmXD85sMBS3/lZME8JkUUjMx5OZm4fO44QuFMWd2I1Io1dMpyLFiq13GecyfTSTBSwRWhsYrupZvNvZX0yktFeRlHQ7YWdogdlmM7AHyd/xjhfB5zQz2hSqvLSdmsphUxCGNVs7zCtlTN0IOVrbGUcleKpXCgQMH4HQ68b3vfa+isKSNNq432oSvjesOSZIwPDyskb9r167h1a9+NQ4cOIDXve51VcUWokQQywvazbJS21fNQ+1Q8lDrVffezBhPF3AmIRO+rV4r/Iyozfwlk0m43W4t5aOeG4v+9QAgaKaRHz0Fh92Gbdu2IV4QcTqRMyQdeM0MtnoXj7m72XC9CZ8oijhx4gQKhQJ2795dsaqj5juniwJmCyJmCgIyvKSdzw/e9TJMXr4IAKAZBvf+0bvxloc/WvH9KEBTwNp0kWF2rrq5eDabxWh8HlPEDKJrNbtYYHvAUTEWUSV8NpbGyzuXh/AliyJ+FUkDkCtzt4TsGB0dxdTUVN1kD5A3iT/VpfnsrUD4BIngaZ333iu7nHVvFPOihN9ES2p2u0L21Ci2TCaDN7zhDaBpGj/84Q+bEum00cZyoD092sZ1B03T6O/vR39/P/72b/8WJ06cwOOPP47PfOYzeN/73oc77rgD9913H+6++264XC7tpsXQFDpsHIrxKcTHxtC1ej0khxfRHK/NoIkEmMrymMry2oB8h00mfzeDL1wzoHVaQwLAarVi1apVWLVqFfL5PGKxGCKRCM6fPw+Xy6UZPVeac7qYzOO8Lsqu00IjOXIcXo8HazdsxMlEXrPEAGQCvcFjwUr7C6eqd6MgiiKOHz8OQRCwe/dugGGRUMic3HoVtfSYyk5+MhiWlVXshAAEoJnSMs1SgMskRxIGrVzDKtgML+J0WsIsZdMkrDQI7Kk4MpOXcVLJhw6FQnA4HNpvLtWpel0K9PYoXTYOo6OjmJycbIjsAUYle7XvZjrLlyLPrFzdZK+gZBerZM/Gym1clezlcjm8+c1vhiiKbbLXxk2HdoWvjZsGhBCcOnVKq/xduHABr3rVq3Dfffdh//798Hg8+Id/+Ad88pOfxNNPP401a9YAkG9G8bygGT1XClanlfD1DhtXtzryZsFEpoiTs7IxbCUTWhXFYlEz6p2dnYXD4dAqfzabDefnC1rqBACsMFOInx2WU0BWrsbZubxBuRmwsNjitTaV4HCzYLkrfIJEkBUkpAo8xq5NQGBMsLg8yApSxfOwFmjI/nHHf/lzfOp9f4RiIY/Onl789b9/F55AcMHjy73+ahG/aibZHTYOmzwWmBkagiAgHo9r+dAmk0nzijySpiDWoXptFhIhODyZQlGSBRS9hTimJ67V7VmoR0ERfgDVZ/Oej6a1TOF686mLopxdrBpvWxkKe0MO7fooFAr4vd/7PczMzODHP/4xPB5PQ8fdRhvLjTbha+OmhOqkr5K/s2fPoqenB1evXsXnP/95vOUtb6lq2jqjtn1zlQfkaQABK4sOJSf0RuW81ovJTBEnFMK3yWPBKufiM3s8z2uVv/jMDJjuNSg6SibUPWYgemYYnSt7kHGFEVUycwG5irTJa0WXjXvBV/X0hE9v8dEIJEKQF3XWJrxSrRMkbWC/XlCA1nK16dqveUHCydmcVvmzFNLw5xPYsH49JJrVvP4SBbHiLB9HUwgpit/yOdbZgoDTZXY6VobCZq+16vdRbveS79sB0DSsFMFtXa6W+8hFczyG4lkAgEMsQLxytimyB8jzdYenZMIXtrLYFTC+RlYQ8YspuXVsZ2m8rMOx6HnOSwRHomltvtCikD01u5jnebzlLW/B1atX8bOf/eyGGr630UY1tAlfGzc9RFHEu971LnzrW99CV1cXLl++jJe//OW4//77sX//fgQCgarkb7YgapW/Sr5jFJSQeBu3wOT1ZsFUtojjMzLh2+CxoK8OwqdCIgTH4xlE8oopMCHgZiYgzUzB27sOcxaPoRIVtrLY5LU2bE9xs6JewkcIQVHLgi0ROrUF2+giKUcBGmMA7RwDa4V0iViOx3A8q5G9kIXFTl0clx56r7+ZKvZF6ihDwMJitsBjMlsi8xSAXqcJa1z1R99JkoSfTCRBQIEqZGG6eg6BQAChUAiBQKAlyni9955pagx7N69fNHquGrKChF8ohK/DymFnwNgO1p8T690WrF7Ee0+QCI7EMlqqipmmsDdk1+ZZBUHAO97xDpw9exbPPPPMgqzpNtq4WdCe4WvjpgbP83j729+OX/7ylxgeHsbatWsxOjqKgwcP4mtf+xo++MEP4rbbbsOBAwdwzz33IBQKaTdUmqIQsLAIWFhsJhaZ/JWpIwmAWF5ALC/gNHLwW+TKX8ha2RftRoDSz/A1wDxEiWB4Jou4QvYoAD0sj4nkLKhVmxA3O7SBJ5Yi2OKVlYov9KpeLQgKqVPn6fQEr9EWLEcBUj4LjohYEfLDwbENRwFGFbKnvnXYymKHvzLZAwATQ2OFw4QVDlNVBbtIgOkcj+kcb3iuk6OxzWeDq0GTbJqmQZRz0OlwYMvu3YhGoxgdHcWpU6fg9/sRCoUQDAab8plTSSwAQOCxZ9O6pskeUErZAORRjvJ/myybFawFQSI4qiN7JprCHh3ZE0UR73vf+3Dy5EkcPny4TfbauKnRrvC1cdNCzeqdnp7Gf/7nf6Kjo8Pw74QQXLp0CQcPHsQTTzyBwcFBvOQlL8GBAwdw7733oqOjoyJ5IYRgrihiOivfFAsV2nIUAJ+ZRdgmGz2bbyD507e71rnNWONaXInLSwRD8Yw2p0RTQA/yGJ+OAOEeSDoSaStmIFwbBUtBE3w0EtF1s0EiBDklLuxKuogZpV3N0oBQSy1RATRVUsHqK3acJODksWHYbLKyuZkW53SWx/GZEtnrsHLY7rc2ZWQtKqMME5kiornKKR+ArFpV5/4sdc5m6n3tPCYGtyi+doQQZDIZbW40nU7D6/Vqoo967YL03nvdZgrbQkvz+UvxIn45Lbdsu+0ctvlKFb6ZvIAjivfe/9/em4dHVd79/68zS2Yy2dcJYQub7IusgqIokSUCGUBriwpVf/Xpos9TtX3ErbalVbG0BYuP2MVvS1svMQmgIiJr1CoiCcSFTQXDnklC9sw+5/z+mJmTmTATEsgG3K/r8mp6OGdyZ4G8cn/uz/uTatQxvoXsPa+sUFzZqI7M02skJqbFEOcXZlmW+e///m8++OADdu3aRe/evS9p3QJBRyOET9CtWbduHbNnzyY+vuUfAoqicPz4cQoKCli/fj179uxh8uTJ5ObmkpubS2ZmZovyZ/XLX6QzWckGrW/nz6Tv9HJnhd1NsV/4BsYbGJjQsvC5vDJFFY3qeSOtBBmKjTM2L4qp6cC9QSsxPCma9Gg9siyrZ7bKy8uRJEn9wZ2UlNTtZn8qiqIGEPtGh/lLsB4Z+0WUYKO1EjF6rbpDF+OPODGGKcE6HA727dtHXFwcw4cPv6jPTfMcxB4mPSOTL072wCe5x+tdfF3nCAlhDjSChCMhKiB/uhbjdkJy7aK0TIoQZGy329Xvn9raWrVjPNA0FIldJ87hlHzFpuszYi850Ds43qV3TBTDk5u61b84Z+O0vwt9VHI0mTHhw5C9isK+ChvnnP5fFiSYmB6r7o7KsszPf/5z3n33XQoLC8nKyrqkNQsEnYEQPsEVh6IonDp1SpW/jz/+mIkTJ5Kbm4vFYqFXr14R5a/O5fWVw2zukOkSwQQmImS0YZfkUqh0uCmq8AnfgHgDg1oQPrvHJ3uBA/o6CeI8dqolAwSJSa8YPYMTo8OeWZRlmZqaGnXEm6Io6nzWlJSUTpU/Xwk2qPzqkbH55a6N/RLoJIjVa1WZC2TXmXSa1mewORwUFRWRlJTEsGHDLmoXNLgJB6CnSc+I5OiL3lGtcXo4UG2n3t2kdgatxLDEaNKjddS6vGoTky3CFmesXqPu/MXpNSFr8SoK21oRZByM0+mkoqJC7RiPiRD3crj0JKVa3y9zLU3FaAu1Tg+7y327eH1ioxiW5BM+j6yw60wdXsX3vXBzZnzY0rusKOyvtFHhaJK9CWkxJPg7eWVZ5sknn6SgoIDCwkIGDhx4yWsWCDoDIXyCKxpFUThz5gzr16+noKCAjz76iLFjx2KxWMjNzaVv376R5c8tqzt/kX5QJkZpyfA3fHRUfElwGapfnIHBieGFr9Htm7sa2KWM0gAeNy5N0zmlaK3E8GRTq0eMKYpCbW2tKn8ej4fU1FTMZjMpKSntcmBfVnzRJjaPHDIyrNEth220aQmNREj5td7tVc+HXWyXbgC73U5RUREpKSkMHTr0ogTtVKOLL4Nkr1eMnuFJFyd7Hlnhq1oHJ4JmHINPcq5JOL8pQ1EUGtyy2vEbLIjBRGs16lGGxCgtXoULBhm3hNvtDol7MRgMpKen4/V6OeXW4k0yAzAs0UifNjQkRaLa6WGPX/j6xkYx1C98wfFGvWL0jEg+f9dRVhRKztnU7xmt5BvJl+SXPUVRWLZsGX//+98pLCxkyJAhl7zetvDSSy/xu9/9jrKyMkaPHs2f/vQnJk6cGPH+vLw8nn76aUpLSxk0aBDLly8nJyenE1cs6E4I4esmVFVV8dBDD/H222+j0WhYuHAhq1atatXhZUVRyMnJYcuWLWzYsAGLxdLxC74MURSFsrIyNmzYQEFBAR988AGjR4/GYrFgsVjo169fRPlrcMvqzl9jBPlLiPKVfc0mvRrX0B5UOT186v8BlhUXxZDE8wOV61xeiioaVUHSayTcXhmCPp6+sVEMCiMCrUVRFOrq6tQpHy6XK6RbU6eLLJGKouD0+rtggwKIA7Ng24IERAemSwSVX2N0GgzNSrDf1Dr4xt+ROTbVRPpFCl9jYyPFxcWYzWauueaaixK0kw0uDlQ3yV6f2CiGJhov6rWsNjcHa0KnocTpffNvW5MpB754EqvN1/Fb429KaI5B42t8CpRBUww6JqRffJiw1+vl3LlzfPvtt9TW1SMPHAM6PRIK03rEYdBd+i8QVQ4Pn6q/IPnm8QJ8Wt6gnseblN4kcQFkReHzc3a12UUjwfjUGJKNTbL3wgsv8H//93/s3LmTkSNHXvJa28K6detYvHgxa9asYdKkSaxcuZK8vDyOHDlCenr6efd//PHH3HjjjTz33HPMmTOH1157jeXLl7Nv3z5GjBjRqWsXdA+E8HUTZs+ezdmzZ3nllVdwu93ce++9TJgwgddee+2Cz/7xj39k27ZtvPvuu0L4WomiKFRUVLBhwwby8/MpLCxkxIgRqvwNHDgw4g/ienfTmb+GCLsk8XoNZpOv7Hup48hqnB4+CbNjEaDa6aG4olHtMm1+bsuk0zAyOfq8H3CXgqIoNDQ0qDt/drudlJQUUtPNGBOScKIJ2bGzXUQJ1qCR/OPCQhsm2jJd4mitg68vUfgaGhooLi4mMzOzxe+LljhR7+RgTdM4u76xUQy5CNlzeGQO1tibulppmnHcNy7qos8AOjwy5f6dv6oIWX/g+5oMT44mxXDxYwuPHz/OsWPHyBp5LUfs/ik6DTXoyo6FHB242N3jcEcg7B6Z9/1RLSadhqnNsvcUReHzKrs6ZUYDjE2LUXfCFUVh1apVrFixgu3bt/smqXQykyZNYsKECaxevRrwlZZ79+7NQw89xNKlS8+7/84776SxsZFNmzap16677jrGjBnDmjVrOm3dgu6DiGXpBhw6dIgtW7awd+9exo8fD8Cf/vQncnJyWLFiBZmZmRGfLSkp4fe//z1FRUX06NGjs5Z82RNoSviv//ovHnjgAc6dO8ebb75JXl4ev/3tbxkyZIgqf4MHDw754RCn1xKXoGVggpEGt+98VJkttERW55apq3Xyda2TOL1G3fkLN6f0wmtterv5D+IKu5v952whB/UDq/BlrhkYGG9o15nCsuKPNtEa0aT3Ji45ExxuKjwyZV4NVDkv/CJ+tP4SrMnfMBEcStwdMhHr6+spLi6mV69eDBgw4KJkL7gLFXy7tIMT2iZ7iqJwosHFV7WOEHFONeoYlhR9yTvKRp2GPnEG+sQZfDEp/sk1zbP+nLLCvkqbmvVnNunaNLnmxIkTHDt2jLFjx3LMrQN84jq6bw+ieiRQUVHBV199hdPpDNk9bkvcS/AWRmBVwWPbesboz5O9L6ubZE8Crk01hcjemjVreOGFF3jvvfe6RPZcLhfFxcU8/vjj6jWNRkN2dja7d+8O+8zu3bt55JFHQq7NnDmTjRs3duRSBd0YIXzdgN27d5OYmKjKHkB2djYajYY9e/Ywf/78sM/ZbDYWLVrESy+9dF5kiaD1SJJEamoq999/P/fddx/V1dVs3LiRgoICli9fzqBBg8jNzWX+/Pnnnd2K1WuJ1WsZEG+kUZU/D3XuphJZvVum3u3k6zonsTqN78yfSU+sTtOqH/qRcviad3oGE6uTGJkSQ0IbM9ea3o+CwxvaMBHoho3UzIIUQToUhShJJi5KT5xBR4xOq5ZiDZrzu2DblUt46bq6Ovbt20efPn3o37//Rb3Gt3VOjtQ2yV7/OAODEgxt+pjrXF4OVNvVLDjw5cENTTKSEd3+uYlRWg29YqLoFePL+jtrc4eUoiE060/C7gsvv0B+5cmTJzl69Chjx44lOjaOcv/4M4NGIjVaj8aUSGJiIgMHDqShoYHy8nJKS0s5cOAAycnJatbfheJeggVVkvzneIPmQ2eamjpzFUXhYLWD042hshc466koCv/v//0/fvWrX7F582YmTZrU2k9ju1JZWYnX68VsNodcN5vNHD58OOwzZWVlYe8vKyvrsHUKujdC+LoBZWVl553B0Ol0JCcnt/iX8+GHH2bKlCnk5uZ29BKvGiRJIjk5mfvuu497772X2tpa3nzzTQoKCvj9739Pv379yM3NZcGCBQwbNiykYzVGr6W/Xkv/eF/af6DsG/yDusEj802dk2/qnMQE5C9MZ2TImoLeVvx61/w8WNMNCv390S2tKe+5vMEy19QwYfPItLFfAoNWUsuvgVKs1uum/lwFgGWFbQAAO0FJREFUFVZfVAcJCZjMZmLS0zFqL5wn2FXU1tayb98++vXrd9GRG0frHHxd27TbOSDet9vaWkHzyApH6xyU1rtCpL6lDuv2RqeRSAtq8EmM8pXWy4PGFgaHl1PdlPWXHtTIdPLkSb755hvGjh1LQkICx+ubZvr2iNGHfK9KkkRcXBxxcXEMGDAAm81GeXk5Z8+e5fDhwyQkJKgdv9HR559nVUJiaSRqXF71nGiKQauuSVEUDtc4OOnf/ZOA0SlNZX9FUfjXv/7F448/zttvv80NN9zQHp9SgaDLEMLXgSxdupTly5e3eM+hQ4cu6rXfeustdu7cyf79+y/qecGFkSSJxMRElixZwpIlS6itreXtt9+moKCAadOm0atXL1X+mofvmnQa+sUb6BdvwO6R1bJv8OH4Ro/MUf9Ae5POF4uRYdIT30z+gv1AVs7fNQqg9zgZn5lEgiG0/OWVFbVBonnDRLhZwy2hk/DNgNU3lV8DO3bhy3p6UmL7ktW3Lw6HQ53v+9VXX6k5bWazOewP7q6iurqakpISBgwYQJ8+fdr8vKIoHPVLfYDWBmYHqLC7OVhtD9lNjdFpGJ4cTXI7nsVsDcHfIUatb1qHrChUBybXNAsvr3J6qXJ6OVTjICFKi8HVSPXxk4y79loSEhKAZiVWU/gsvAAmk4msrCyysrJwOp3qfN+vv/6a2NhY0tLSMJvNxMTEIEkScpDxSVLo+wrk7imKwpFaB8eDOpxHJkeTETR5Iy8vj0cffVT9+96VBEbYWa3WkOtWqzVidScjI6NN9wuufITwdSCPPvoo3//+91u8p3///mRkZFBeXh5y3ePxUFVVFfEv586dOzl69CiJiYkh1xcuXMjUqVMpLCy8hJULwpGQkMDdd9/N3XffTX19PZs2baKgoIDs7GwyMjJU+RszZkyI/EXrNGTFGciKM+AIyJ/drU7BAN+O4Lf1Tr6tdxKtldSdv4Qobch4qBqnJ6Q8BYAsk+CqZ2TfTOxehdJ6Z8iOXaQw6UhIENT9qgkRvKhLKMEajUZ69+5N7969cblcakjvN998Q2xsLGazmfT0dGJiLr4L9FKpqqqipKSEa665hl69erX5eUVR+LrOybEg2WvNvNYATq/MoRoHZUFfYwnf7mD/eMNFN2VcCsHfPYF3r5EkUow6Uow6hiYa/Vl/vo7f4K5r3+62EfoO50u7BrPkIFanUUPB4/VadXJFazAYDOr3UHDcS2lpKUaj0VcpSQyulijq2TytBGb/7t3XdU5K60NlLziEeePGjfzkJz9h3bp1zJw5s9Xr6yiioqIYN24cO3bsUJvyZFlmx44dPPjgg2GfmTx5Mjt27OCnP/2pem3btm1Mnjy5E1Ys6I6ILt1uwKFDhxg2bBhFRUWMGzcOgK1btzJr1ixOnToVtmmjrKyMysrKkGsjR45k1apVzJ07l379+nXK2gW+Ls7NmzdTUFDA5s2bSU1NZd68eSxYsIBx48ZFDCp2ept2/qqc4WMxjFqJKEcjv39uGWUnjnN9Ti63LLiz6QavB50EXo2uzdMljP4SbPMdO6O29V2w7YHb7VZ3/qqqqjCZTGFDei+G4LLqtakm9Qd+OCorK/n8888ZMmRIi41SkVAUXy7et0EiMSTRSFYrsuUUReFUo5sjNfaQmb7JBi3Dk6IvudP7Umh0e/nQP6os06RnVErkqRnBWX+n6mw4aHndF9ut3JxA3Et5eTllThlPel8AUrUylV7f37/AmLXgqB6A4UnR9I5tkr3NmzezZMkS1q5dy8KFCy9pXe3JunXrWLJkCa+88goTJ05k5cqVvPHGGxw+fBiz2czixYvp2bMnzz33HOCLZbnpppt4/vnnue2223j99dd59tlnRSzLVYwQvm7C7NmzsVqtrFmzRo1lGT9+vBrLcvr0aaZPn87atWsjBm1KkiRiWboYm83Gu+++S0FBAe+88w4JCQlqw8eECRMiRk24vDJWu8cvf6GzUJ/94WL2f7ATWfbtijz+8j8Yf/OtrVqPTkIdGRZcfo1cgu1aPB6POqGhsrJS3bUxm83ExcW1WQyO1Tn4qhXCV1FRwRdffMHQoUMvqts9cB4suEQ4NNFI31bIXoPby4EqO9VB5X69RmJwopGepvZvymgrDW4v/2ml8AU4ffo0R44cYejoa3HoTRfM+kuP9nX8Jht0l/zLxvE6B4f8X3PJZUeJ8h0XGKR3gTGWr+sjf422b9/OokWL+Mtf/sL3vve9S1pHR7B69Wo1eHnMmDG8+OKLaiPJtGnTyMrK4u9//7t6f15eHk899ZQavPzCCy+I4OWrGCF83YSqqioefPDBkODlF198UQ1eLi0tpV+/fuzatSvieRIhfN0Lu93Oe++9R0FBAZs2bSImJoZ58+Yxf/58rrvuuhblr9zuoczui8W4Z8IQGut9kw40Wi259/2Iux99Qr1fQ1MJ1qQLljsN+o7ugu1AvF6vWrKrqKhAr9erZd+EhIRWfVwhwpdiwmw6X/isVitffvklI0aMOK+rsTUoisKhmtCJF813jcLhVRSO+cu/wf8IZ5r0DEk0Rux27Wzq3V4+8gtfYJesJc6cOcPhw4cZM2YMycnJ6nWHV+ZorYOTje6Iz+ok/PKnJ/Uis/6ax+AA6GQPUk057uSmndtBcXoGJDZ9LB988AF33HEHq1evZvHixZft3xuBIBJC+ASCTsDhcLBt2zYKCgp46623MBgMqvxNmTIl4pQKt6wwf+FC3t++HVn27ZA03+HTS5BhisJs0pNs0HbJOa+Oxuv1UlVVhdVqpaKiAq1Wq5Z9k5KSIv5wPlbn5Ct/g0s44Tt79iwHDx5k1KhRpKWltXldiqJwoNrBqaDGgBFJ0fS6gOydc/jm3wafdzPpNAxLim712LvOot7l5SOrT/gijSQLEEn2AuyvbMTqD43uGxuF3SNT6fSE7QjXSqhxL2nR+lZ3JYdrakoz6tTZuACGWiv/WPEsJ06cYM6cOQwcOJAHHniAFStW8IMf/EDInuCKRAifQNDJuFwutm/fTkFBAW+++SY6nY65c+cyf/58rr/++vNCZmtqavjVr37FgYMHGXv9jVju/zF1soZwMz70GglztO+HZIrx0stj3RFZlqmqqlKbPiRJUjs1k5KSQs5MtiR8ATkZNWoUqampbV5HILD3dNCO1ahmh/+b4/LKHKlxqKPKwNeU0S/OwIB2DshuL+pcXj72C1/vmCiGJ4fvqD579iyHDh2KKHsur8yuM/Uo+HIEp2XGoZEkPLJCpcPX8FFud4edyCIBKUFZf4YWdj+bx+E0JzB949ChQ7z++uusX7+eY8eOMWDAAH784x+zYMGCi47iEQi6M0L4BIIuxO12s2vXLvLz89m4cSOKoqjyd+ONN6ry9+tf/5qamhqeeuopkpOT8cgKFQ5fw0eFI/wOSaA8lmHSk3oFy19NTY0631dRlJDxXKUNblX4xqSY1NiNU6dO8dVXX0WUkwu+X0Xhyyq72jEtAaNSoukRIWIkEP57uMYREoWTGOVrymhLp2pnU+v0sNs/2q9PbBTDks4XvoDsjR49mpSUlLCvc7zeySF/qTXSTGhZUTjnlz9rUNZfc5L8WX/moKy/AM2bMoLpF2fgmqDg65KSEm677TZ+8pOfkJmZycaNG9m1axcjR45kwYIF3H333UL+BFcMQvgEgm6Cx+Ph/fffJy8vj40bN+J2u5kzZw4VFRX85z//IS8vj6lTp57/nH+HxCd/4XdI2uNsVHdHURRqa2vV+b4ejwdDz37URScBTcJ34sQJjh49ypgxY0hKSmrz+5H9c1fLgmRvdJBMNqfR7eVgtYNzzqaSok6CaxKN9I6J6vblwwvNci4rK+PgwYMtyh7Ax2UN6gSa682xF5Tc4Ky/crs7YrxQvF6L2eTb/YvVa/m61sHRMMKXFRvF4KCO4AMHDjB79mx++tOf8uSTT6rXq6ur2bRpE+vXr+fee+9l3rx5La5TILhcEMInEHRDPB4PH3zwAT/96U85cOAAMTEx5ObmYrFYuOWWWyKOl/IG5K+F8phWgrRoPRnRetKMV6781dXVceRcA1V6X+NTUkMFJo+diooKxo0bp4YAtwVZUfjsnE09hyYBYyJ0/8qKwrf1vmDt4I2qjGg9Q5KMGLtJU8aFqHZ62OMXvqzYKIYECV9A9i5UFg8+Bxiv1zIlI7ZNa1AUhTqXl7IwWX/BxOo0vPPa33njr6+QkJzMf/3qBfoOHkqf2CiGBsnekSNHmDVrFg888AC//vWvu710CwTtgRA+gaAb4vF4uP/++/noo4947733OH36NPn5+WzYsIH6+npycnKwWCxkZ2djNIaf4OD1l8fKbD7580SSP6MvEiPNqO+WUS2XQvAB/rias9jKTqqzkwOzWZufmYyErCiUnLNRHiR716Y2jeIKptrpa8pocDeJiVErMSwpOuz93Zkqh4dPK3zC1y8uisH+Umygu3n06NEXPAN5uMauBh23Nq4mEoqi0BAYXWhz0xAkf4eK9/DUXb7Z4xqNhsS0dDbv/ZwRySZV6o4ePcqsWbNYtGgRy5cvj5iTKRBcaQjhEwi6GQ6Hg+9973t88803bN26NSQXzuv18sknn5Cfn8/69euprq5m9uzZWCwWbr31Vkym8B2UgbNRvp2/8GejNJKvmzEwB/VKkL9g4dOXfcvEIQOQJElt+GhoaCA5ORmz2UxaWhpRUeHP4HkVhZJKm9rpqZF8TSBpzeTNLSt8FTSfNUBWbBQDE4yX5ef0nMPDXlX4DAxONKqy15ruZllRKDxTj0tWkICbM+PaFDkjK0rorGd3YEzg+aMBt73xb9b84uch18rLy9XpLaWlpcyePZt58+axatUqIXuCqwohfAJBN+Pw4cM8/PDD/Pvf/26xoUCWZT799FNV/ioqKpg5cyYWi4WZM2dGHFEmKwpVTg9lNl95LJz8SfgiMTJMPvlrbSRGd+PbOgdH/B2bQ2I0ZCXHhfy5zWZTGz7q6+tJSkpS414CZXOvrLDvnI1zQbI3LjWGlKD4FEVRsNo9HKq24wz6fMbrtQxPjiahGzdlXIhKh5uiChvg63BNcNbxxRdftDrKptzuZl+l73lztI5rU8//vlQUBaeshEhdYN5zpPJtOM4e/5aH596C1+sBRWHy5Mls3boV8IVBz5w5k1tvvZWXX35ZyF4z1q5dy8MPP8yZM2dCjoxYLBbi4uL45z//2YWrE7QHQvgEgisAWZYpLi5W5e/MmTPMmDEDi8XC7Nmz1QDv857zH4wvs7mx2t24WpC/QCRGdwkEvhCKovDp0VNUG+KB0C7dcNjtdnXnr7a2loSEBNLMZsqiEqlx+z4vWr/sJQfJnt0jc7DaHpLzppVgUIKRPrFRl313dIXdTbFf2DK0Hs4dKmHkyJG+ubWtIDh7b0xyNCa9NnSnzi95bRz5rI4GDIydO9XgQgaOHfic3W++weCeZv7nf/6HuLg4ysrKmDVrFlOmTOFvf/tbxNDzqxm73U6PHj34y1/+wh133AH4dkd79uzJ1q1bufnmm7t4hYJLRQifQHCFIcsyJSUl5OXlUVBQwKlTp8jOzsZisZCTk0N8fHzY55SA/Nl98ucM8xNYApKNOjKi9Zi7sfwpisKhQ4coc0u4/NMVRrcQm9Icp9PJ2fJyvnHp8ET5yuQaRWFkgo4eCT55lhWF4w0uvql1hMhKmlHHsKTo8+JCLleCd+g0lacZ0zO1RdlTFAWHV6HR46XW6eXrCBEprUEroUpd8/GAgfJ4jdNXcg58DdKMOq5NNamiXVFRQU5ODqNGjeKf//xnxJBzAfz4xz+mtLSUzZs3A/CHP/yBl156iW+++UY0tlwBCOETdAlVVVU89NBDIaPkVq1aFXEnqqqqimeeeYatW7dy4sQJ0tLSsFgsLFu27KK6La8WZFnmiy++IC8vTw2Yzc7OJjc3l9tuuy3iiDJFUahxNe38hYvEkIBkgxazyZeH1lIYbmeiKAoHDx6kuroa87AxHG30RYG0Rfg8skJRRaM6/1WDQkL1aerLzxIbG0t8eg+qjIk0BI2HNWgkhiZFY47WXVE/HIOFr4fWzehMX4OGW1ZodHvV83SBt20eOWwuZEtEa5vGAQakLkanwaBteTRgrcvL3vIGtSEp1ahjbJDsVVVVkZOTw8CBA1m3bl2rG3SuVvbv38+ECRM4fvw4PXv2ZNSoUdxxxx08/fTTXb00QTsghE/QJcyePZuzZ8/yyiuv4Ha7uffee5kwYQKvvfZa2Pu//PJLnnnmGb7//e8zbNgwjh8/zg9/+ENGjRpFfn5+J6/+8kRRFA4cOKDK31dffcUtt9xCbm4uc+fOJTExMaL81br8O382N/YItbckg9a382fSd1nkiCzLHDhwgPr6esaOHUuZW1LnqrZW+Nx+2av1y55OggnpMSRE6bA7XRyoqKNS1kHgc6UoZBgkhqW2rRnhckBWFA6XVXHC49sVi9dr0GokGt1y2PJ/S+gkztup881/1qC9CEGuc3nZW9GonkFNMWgZmxqjxgzV1tYyZ84cevTowfr16yM25AhCGTduHLfffjszZsxg4sSJlJaW0rt3765elqAdEMIn6HQOHTrEsGHD2Lt3L+PHjwdgy5Yt5OTkcOrUKTIzMy/wCj7y8vK4++67aWxsFGWaNqIoCocPH1bl7+DBg0ybNg2LxcLcuXNJTk6OKH91blnd+Yt0oD4pqmnnr7NKm4HdTJvNxtixYzEYDJTWO9skfC6vTFGFTQ0I1mskJqTFEB+lpdzu5mC1PWS304hMTJ2VurLTGI1G0tPTMZvNxMXFXVa7fC5v6Hm6wNs2jxdfb23rkPDNBI7RadBr4LTNd3YvTq9hijm23T4n9W4vn5Y3yV6SQcu41Bi1zFtfX682G7z11lsRo4sE5/Pyyy+zcuVKbr31Vr7++mvee++9rl6SoJ0QwifodF599VUeffRRqqur1Wsejwej0UheXh7z589v1ev89a9/5fHHH6eioqKjlnpVoCgKX331FQUFBRQUFPD5559z4403YrFYmDdvHqmpqRHlr94tU2b35aFFkr+EqKadP1MHyZ8sy3z22Wc4nU7Gjh2r7ua0RfhcXpm9FY3U+7Pzovyyp9dKHKq2q40H4OvUHRhvICvOgEaS8Hq9VFZWUl5eTkVFBXq9XpW/SGXzzkZWlFCpczd1wUYaYRaJKI3UVIL179TF6DRE6zRqObU9s/eCafDLXmCHMTFKy/i0JtlrbGxk4cKFaDQa3nnnnYjd6oLw1NbWkpmZicfjYe3atdx5551dvSRBOyG2RQSdTllZ2XmHvnU6HcnJyZSVlbXqNSorK1m2bBkPPPBARyzxqkKSJAYPHswTTzzB448/ztGjR8nPz+ef//wnjzzyCNdffz3z589n3rx5pKenq/IiSRLxUVrio7QMijfQ4Jc/a7Mw3FqXl1qXlyO1DuL1WjJMejJMOky69umU9Hq9fPbZZ7jdbsaNGxfxnFZLv9o6/bLXECJ7JqpdHr6qcYSEVqcYdAxPNoasX6vVYjabMZvNeL1eqqqqsFqt7N+/H61Wq0a9JCUldaj8hYs3CUie3dv6eBMAZBmjBqL0Our8n5es2CgGJBgvGNMjKwpnGptGz/VooTu6Ldg8vjJuQPYSorSMC5I9u93Od7/7Xbxer5C9iyQhIYGFCxfyzjvvYLFYuno5gnZECJ+g3Vi6dCnLly9v8Z5Dhw5d8vupq6vjtttuY9iwYfzyl7+85NcTNCFJEgMHDmTp0qU89thjlJaWkp+fz+uvv86jjz7KlClT1J2/Hj16hMhfXJSWuCgtgxKMNLibGj7qg6ZN1Lm91NV6+arWdx7MbPKNeAtEa7QVr9dLSUkJsiwzbty4iyrtO7wye8sbafRLqkErMSzRyIFqh9q0AT4JHJJopIdJ36K0abVa0tLSSEtLQ5ZlqqursVqtfP7550iSRFpaGmazmaSkpIvOgvPI/jDido43Mek0yPZGvj18kKEDB5CZ2YPTjS6+qLIDvnJtazIZKx0eVcraK8rH5pH5tLxR7R6P02sYnxajrsfpdHL33XdTX1/P1q1biYuLa+nlBC1w+vRp7rrrrogjHAWXJ6KkK2g3KioqOHfuXIv39O/fn3/9618XXdKtr69n5syZmEwmNm3aJM7mdBKKonDixAkKCgpYv349n3zyCZMmTcJisZCbm0vPnj0jSlCju6nho84dYQaqXkNGtJ4Mk57YVsqfx+Nh//79SJLEmDFjwspecEl3VHI0mTGhJV2HR+bTika1HG3QQHq0nlONboL/YewZo2dwgvGSxEWWZWpqatSgZ1mW1Z2/lJSU8+RPURTsXiWk+zXwdriu6ZbwxZtoz+uEDY43AV9Xa0lJCUOGDFHP0p5qcPFltU/4hiUZ6RN7YQkIzt4bG2H8XFuwe2Q+LW9QG4Zi9RompsWoXw+3280999zDyZMn2bFjR4uB5YLIVFdXU1hYyO23387BgwcZPHhwVy9J0I4I4RN0OoGmjaKiIsaNGwfA1q1bmTVrVotNG3V1dcycORODwcDmzZsjjhETdCyKonDq1CnWr1/P+vXr+eijj5gwYQK5ublYLBZ69+4dUf5snqaGj9qg3bNgYnQaX9k3Wk+sXhP2tdxuN/v370en0zF69OiIQbrH650ciiB8do+vjBuQPb0GtJIUIlMxOg3Dk6JDgpbbA0VRqK2txWq1Yq2oxK3REZuciiE+EVlvwOZV2i/eRK/BoGk53gTCyx7AyQYXB/zCNyIpml6xF2582XWmHgXfrui0zLhLCp92eH07e4GvU4xOw8T0GDUGKDB3+tChQ+zatatV0z8E4cnKyqK6upqnn36an/3sZ129HEE7I4RP0CXMnj0bq9XKmjVr1FiW8ePHq7Esp0+fZvr06axdu5aJEydSV1fHjBkzsNlsbNiwIeRsTlpamkjO7yIUReHs2bOsX7+egoIC/vOf/3DttdeqO39ZWVkRRcPuaTrzVxNB/ky6pp2/OL/8uVwu9u3bh8FgYNSoUS1+7SMJn80jszdox0grEVIKlYD+8QYGxBvaZVKGrCjYPeE7Ydsab6LXSGonbLDUxQQ1TLSV6upq9u/fz+DBg+nZs2fIn51ocHKw2vc5HJEcTa+YloUv+HOeFRfFkMToi1oT+M5WfhpUbjf5ZS8Q++P1evnRj35EUVERhYWFZGRkXPT7EgiudITwCbqEqqoqHnzwwZDg5RdffFENXi4tLaVfv37s2rWLadOmUVhYGHG0z7fffktWVlYnrl4QDkVRsFqtbNiwgYKCAt5//31GjRqFxWLBYrHQv3//iPLnCMif3U21M7z8RWs1pBk0nPv2K+L0GkaNHHnBM3DhhM/m8XV5RiqLJhm0DE+KbnVpOYCiKL4w4gidsG36h1ZR0HhcKE4bJq1Ekikac1I8CcYo9K3YrWsLLckehH4ORyZH0/MCwvdxWYMaa3O9OZa4i5wj7PL6yu2BRpporcTE9Fg15keWZR566CE+/PBDdu3aJbLiBIILIIRPIBC0O4qiUFlZyYYNG8jPz6ewsJBhw4ap8jdo0KDI8ueVsfrLvlUR5M+oldSyb0KUNuJrNRe+hCgtn1Y0hh0bp9dIDE4w0jOm5aaMzow3aWhoUOf7NjQ0kJycjNlsJi0trV2ChGtqati3bx/XXHMNvXr1CnvPhc5BBlPv8vKRtQGAeL2WKRnhJ+dcCLessLe8QT3zafTLnilI9n7+85/z7rvvUlhYKH7hEwhagRA+gUDQoSiKQlVVFRs3biQ/P5+dO3cyePBg9czfkCFDIgqW0ytjtbs50+CkxiU3TbcIwqiVMPvLvonN5C9Y+AYlGDhe58QV5l+8HiY9QxKN6rkwRVFwev1id4nxJhqJoBKsf9KE/+3WdLwGsNlsasNHfX09SUlJatPHxXRT1tTUsH//fgYNGhRR9qBtWYbtkb3nkRX2Bk06MWgkJqbHqJ3csizz5JNPUlBQQGFhIQMHDmzz+xAIrkaE8AkEgk5DURRqamp48803yc/PZ/v27QwYMIDc3Fzmz5/PsGHDzpO/06dPc+zYMRJT00js3Q+r3cM5hydsidSgkdSolySDlpMNLg76ZUULNN8vNGqgX7yRKK0UJHW+83UXF29yfies8QLzYC8Gu92u7vzV1taSkJCA2WwmPT29VZ3rAdkbOHDgBUuh39Y5OVLr+xyOSTGRESFTT1YUCs/U45J9szluzmz7qLnmM4yj/LIXKK8risKvf/1r/vGPf1BYWMiQIUPa9PoCwdWMED6BQNBl1NTU8Pbbb5Ofn8/WrVvp27cvubm5LFiwgOHDh3Pw4EHmzJnD448/zgMPPKCKk8srU+7wYLW5qYwgf1EaiZLCrbyy/DdIGg1L/vcXXDu16Rxo80aN1tDaeJPOxOl0qvJXXV1NXFycKn/hOtlra2vZt29fq2QP4Fidg69qnQBcm2LCHEH4yu1u9lXaADBH67g2tW2hx15ZobiyUS3j6zUSE9Ni1DOAiqKwfPlyXn75ZXbu3MnIkSPb9PoCwdWOED6BQNAtqKurY9OmTeTn57NlyxbS0tKoqKjglltu4bXXXosYquyWFcr93b6VDg+Bgus561l+NH0SsteLAuj1el4pLCYhOeWCa7mUeJOuxOVyUVFRgdVqpaqqitjYWHXEW0xMjCp7AwYMoE+fPq16zaN1Dr72C19LmXqXkr3nVRT2Vdg45/Q9HzzDGHyyt2rVKlasWMH27dsZO3Zsq1+7I6iqquKhhx4KaTpbtWqV2nQW7v5nnnmGrVu3cuLECdLS0rBYLCxbtoyEhIROXr3gakVM2hAIBN2C+Ph4Fi1axKJFi9izZw8zZsygd+/e7Nq1izFjxqg7f9dee21Id65eI9EzJoqeMVF4AvJnd3P41Am8nqb5t26Xi4rTp1Th00oQq9cS20zqTJcQb9LVREVF0bNnT3r27Inb7aaiooLy8nK+/fZbDAYDDoeDPn36tKmjVWkWVxMOl1em3C97URqJ1DbkFsqKwv7KJtnTSTA+zRQie2vWrOGFF17gvffe63LZA7jrrrs4e/Ys27ZtU2OlHnjgATVWqjlnzpzhzJkzrFixgmHDhnH8+HF++MMfcubMGfLz8zt59YKrFbHDJxAIuhX79+/n1ltv5X/+5394+umnaWxsZPPmzRQUFLB582aSk5OZN28eCxYsYPz48RGjWapr6xh77bWcq6xAAZLTM3jx3Q8wGJty4XSSb7JGhklPilGH9jIVvQtRXV3Nvn37MJlM2Gw2DAaDWvaNj49vcdfy61oHR+t8O3zjUk2khdm5C8nei41iSFLrsvdkRaHknE2VRa0E49NiSDL4hFFRFF599VWefPJJNm/ezA033NCmj7sjCATH7927l/HjxwOwZcsWcnJyWgyOb05eXh533303jY2NFzUSUCBoK+K7TCAQdBuKioqYMWMGS5cu5X//938BiImJ4Y477uCOO+7AZrOxZcsWCgoKyM3NJSEhgXnz5jF//nwmTpwYEsKclBDPB+8XsmbNGiRJw+33/n9IifGU293q2T2PAmdsbs7Y3GgD8hetJ9WoQ9tFZ/Lam7q6Oj777DMGDBhAVlYWXq+XyspKysvLKS4uRq/Xq2XfhISE8+QveEcgkhiesbnVty+U0xdAVhQ+ayZ741JDZe9f//oXTzzxBG+//Xa3kD2A3bt3k5iYqMoeQHZ2NhqNhj179rQ4GjKY2tpa4uPjhewJOg3xnSYQCLoNSUlJPP/88zzwwANh/9xkMrFgwQIWLFiA3W5n69atFBQUcPvtt2MymVT5mzx5Mlqtlt69e/Pb3/425DW8isI5h4cym5tyuxuPErgOZ21uzvrlL83o2/lLNeq6rCHjUqmvr2ffvn1kZWWpWXVarRaz2YzZbEaWZc6dO0d5eTn79+9Hq9WqUS9JSUlIknTBkm6926tGqMTrNa0KWlYUhS+q7OqZP40EY1Nj1BF2iqKQl5fHo48+yvr165k2bdqlfBralbKyMtLT00Ou6XQ6kpOTKSsra9VrVFZWsmzZsojf5wJBRyCETyAQdBsGDBjAgAEDWnVvdHQ0ubm55Obm4nA42L59OwUFBXz3u9/FYDAwd+5cFixYwJQpU0J2UbSSRHq0nvRoPbKiUOnv9rU2k78yu5syuxuNBGlGHRkmPWlG/WUjf/X19RQXF9O3b9+IwcQajYa0tDTS0tIYOnQo1dXVWK1WPv/8cwDS09NxJfUAfGXzcBt8Zxpd6tut2d1TFIUvq+yc9e8KSvi6f1OCzv29+eab/OQnP2HdunXMmDGjdR/wJbJ06VKWL1/e4j2HDh265PdTV1fHbbfdxrBhw/jlL395ya8nELQWcYZPIOhAXnrpJX73u99RVlbG6NGj+dOf/sTEiRMj3p+Xl8fTTz9NaWkpgwYNYvny5eTk5HTiii9/XC4XO3fuJD8/n40bN6LRaFT5u+GGG9DrI+fInXN4sNrdWO2esFMzNEBqtI6MaD1p0fo2BSd3Jg0NDRQVFdG3b1/69evX5ucVRaG6upry8nJOeXR4EtIAGBzlpm9asnpuUlYU3j9Tj7OV2XuKonCw2sFJvyRKwLXNOnrfeecdvv/97/PPf/6TBQsWtHntF0tFRQXnzp1r8Z7+/fvzr3/9i0cffZTq6mr1usfjwWg0kpeX12JJt76+npkzZ2Iymdi0aVOrMhMFgvZCCJ9A0EGsW7eOxYsXs2bNGiZNmsTKlSvJy8vjyJEj55WEAD7++GNuvPFGnnvuOebMmcNrr73G8uXL2bdvHyNGjOiCj+Dyx+12U1hYqMqf1+tlzpw5LFiwgBtvvDHieDJZUahyetWdP1cY+ZOAVP/OX3o3kr+A7PXp04f+/ftf8usdrLZzosEnaMYzXyM31pGWlkZ6ejpKbCIlVb5mjQtl7ymKwqEah/paEjC6WZDz9u3bWbRoEX/961/57ne/e8lr7wgCTRtFRUWMGzcOgK1btzJr1qwWmzbq6uqYOXMmBoOBzZs3h81IFAg6EiF8AkEHMWnSJCZMmMDq1asB30io3r1789BDD7F06dLz7r/zzjtpbGxk06ZN6rXrrruOMWPGsGbNmk5b95WKx+Phgw8+IC8vj40bN+J0OpkzZw7z589n2rRpEceTKQH582f9OSPIX4rRt/OXHq1r84SJ9qKhoYHi4mJ69erV6tL4hQgWvuvSY5AcjeqIt8bknihxyQCMTjLQIzb8jpWiKBypdahj1+D8ubwffPABd9xxB6tXr2bx4sXdOu9w9uzZWK1W1qxZo8ayjB8/Xo1lOX36NNOnT2ft2rVMnDiRuro6ZsyYgc1mY8OGDcTENIlxWlpaSLORQNBRdM2/SgLBFY7L5aK4uJjs7Gz1mkajITs7m927d4d9Zvfu3SH3A8ycOTPi/YK2odPpuOWWW3j55Zc5deoU69evJz4+ngcffJB+/frxwAMPsHnzZhwOR8hzkiSRYtQxLCmaaZlxTEqPoW9sFAZtk5AoQKXDw5fVdnadqWdveSMnG1w42zh391JobGxsd9mD0Bw+jSSRkJDAoEGDmDB5CvhlT/J6OLDnY0pKSjhz5gxutzvoeYWva50hsjeymex9/PHHfOc73+H3v/99t5c9gH//+98MGTKE6dOnk5OTww033MCf//xn9c/dbjdHjhzBZvNNHtm3bx979uzhiy++YODAgfTo0UP97+TJk131YQiuMkTThkDQAVRWVuL1ejGbzSHXzWYzhw8fDvtMWVlZ2Ptb2/knaD1arZZp06Yxbdo0Vq1axccff0x+fj6PPPIIdXV1zJ49G4vFQnZ2NtHRTZlykiSRZNCRZNAxJNFIjctX9i2zu3H4s14U4JzTwzmnhwPVkGzQkhGtx2zSY+ignb/GxkaKioro2bNnu5Rxg1GCglmCNcxqc6t/0jfBRO/rJmG1Wjlx4gQHDx4kOTmZ9PR0Gk1JfNvYFIA9PCk6pLlj79693H777fz2t7/lBz/4QbeXPYDk5OSIIcsAWVlZBBfPpk2bhiimCboaIXwCgeCqRqvVMnXqVKZOncof//hHPvnkE/Lz83nssceoqqpi1qxZWCwWZsyYEXLuKlj+BicaqXN5fZ29Njf2oCG9VU4vVU4vB2scJAXkL1qPUdc+8heQvczMTAYMGNDuwhSaw9f09ulm2XsxUVr69+9P//79sdlslJeXc7TWgV1pkr1BsTp6xzbJXklJCRaLhaeeeooHH3zwspA9geByRZR0BYIOIDU1Fa1Wi9VqDblutVrJyMgI+0xGRkab7he0PxqNhilTpvCHP/yBY8eOsW3bNvr27cvTTz9NVlYW99xzDwUFBTQ2NoY8J0kSCQYdgxOjubFHHJPNsfSPM2BqJnXVTi+HahwUnq3nE2sDpfVO7J6LL/sGyriZmZkMHDiwQ4Qp3MbUhbL3TCYTpPTAHp/WdK2unOWPPcx1113Hb37zG959913mzZvHz372Mx599FEhewJBByOETyDoAKKiohg3bhw7duxQr8myzI4dO5g8eXLYZyZPnhxyP8C2bdsi3i/oWDQaDZMmTeJ3v/sdX3/9NYWFhQwaNIhly5aRlZXFokWLeOONN6ivrw95TpIkEqK0XJNoZGpGLNebYxkQbyCmmfzVuLwcrnHw/tl6dlsb+LbOia0N8mez2SguLiYjI6PDZA+a7fD5/zc4ey8zTPbeiXonh2uazkJek2DgxuGDeOqpp1iwYAFvvfUWt99+OwaDAb1ez7ffftshaxcIBE2ILl2BoINYt24dS5Ys4ZVXXmHixImsXLmSN954g8OHD2M2m1m8eDE9e/bkueeeA3wH12+66Saef/55brvtNl5//XWeffZZEcvSzZBlmc8++4z8/HwKCgo4fvw42dnZWCwWcnJySEhIiPhsvbvpzF+DO7zcxeu1ZJh0mKP1xOjDd2/abDaKioowm81cc801Hbo7VnLORpm/fHtjjziMWqnF7L2TDS4OVNvV/z8w3sDAhKbu3W+++UY9IzlmzBg2bNjA9u3bGT58OAsXLuTOO+9k0KBBHfbxCARXK0L4BIIOZPXq1Wrw8pgxY3jxxReZNGkS4DvInZWVxd///nf1/ry8PJ566ik1ePmFF14QwcvdGEVR+PLLL3njjTdYv349R48eZfr06eTm5jJnzpyws2kDNLh9US9lNjf1EeQvTq9RGz5i/fJnt9spKioiPT29w2UPYH9lozoC7aYecTS4vRRX+rpPm2fvnW508UVVk+z1jzMwKMGgrrG0tFQ9E7ly5Uo1wLmmpoa3336b/Px8pkyZwmOPPdahH5NAcDUihE8gEAjaAUVROHjwIHl5eaxfv54jR45w8803Y7FYmDNnjjqbNhyNqvx5qHN7w94Tq9eQopco//og6YnxDBk8uFPOvQUL37TMOA5XOyiz+3b8xgZNyThrc/HZuSbZy4qNYnCiUV3j6dOnmTlzJrfeeisvv/yyKnsCgaBzEMInEAgE7YyiKBw5ckSVvwMHDnDTTTdhsViYO3cuKSkpEWXN5pHVsm+gMaI5MToNGSZft2+cXtOh4revopFyh0/4bsiI5aOyBhQgSiMxLTMOjSRRZnPz2Tmbet6vT2wUQ4Nkr6ysjFmzZjFlyhT+9re/iaBhgaALEMInEAgEHYiiKHzzzTeq/H322WdMnTqV+fPnM3fuXNLS0iIKm90jY7W7OdPgpM4T/p9qk66p7BvfAfJXXNFIhV/4rkkw8FWtE4C+sVEMTYqm3O5mf2WT7PWK0TM8KVpdR0VFBTk5OYwePZq1a9ei04k0MIGgKxDCJxAIBJ2EoigcO3aM/Px81q9fz759+5gyZQrz589n3rx5mM3m84StsrKSw4cPk5CaRlzPLKx2N9XO8Dt/0VpJ3flLiNK2i/wVVTRS6Re+eL2GOv95w+vNsTi8MvuCZC/TpGdkcpPsVVVVkZOTw6BBg3j99dfR6/Xh3oVAIOgEhPAJBAJBF6AoCqWlpRQUFLB+/Xo+/fRTJk+ejMViITc3lx49enDs2DFmzpzJ448/zn333aeKlNMrqw0fVRHkz6iVMEfryTDpSbwE+dtb3sg5pyfkWrxew+DEaIorGwmMFu5h0jMqSPZqa2uZM2cOmZmZFBQUEBV1fnyLQCDoPITwCQQCQRejKAonT55U5W/37t2MHj2ao0ePMmnSJPLy8iKWQp1emXK7xy9/HsL9g27QSmrZN6mN8vdpecN5UtknNorTjS4CA0XM0TpGp5jQ+F+3vr4ei8VCXFwcb731FkajsfnLCgSCTkYIn0AgEHQjFEWhuLiY2267DfCVdMePH4/FYsFisdCnT5+IwuYKyJ/dzTlHBPnTSJj9Zd9kw4Xlb095Q0gJWfL/FwiSSTfqGJPaJHuNjY0sXLgQrVbLpk2biImJOe81BQJB5yOETyAQCLoRZ8+e5eabb2by5Mn89a9/xWq1smHDBgoKCvjwww8ZPXo08+fPJzc3l379+kUUNresUO4v+1ZGkL8oja/sazb55E8T5rU+sTZQ4woVvsBrpRp1jA2SPbvdzne+8x2cTifvvvsucXFxl/jZEAgE7YUQPoFAIOgmlJWVcfPNNzNx4kReffXVkPgSRVGwWq1s3LiR/Px83n//fUaMGMH8+fOxWCwMGDCgRfmrsPuiXirtHsLFPOs1EuZo34SPFKNOlbjd1oaw8TApBp/saTX+c4VOJ4sWLaKqqoqtW7e2OHFEIBB0PkL4BAKBoJvwxRdf8Oc//5mVK1e2mFWnKAqVlZWq/O3atYshQ4ao8tfSBA6PrFDh8O38VTg8atNFMHqNRLpRh9mkp7DkIMV7P6Xv4KH0HzYSgCSDlvGpMarsud1u7rnnHk6ePMmOHTtITk6+9E+GQCBoV4TwCQQCwWWMoihUVVXx5ptvkp+fz44dO7jmmmvIzc3FYrEwdOjQFuWv0uHxy59bbcIIcGR/Eb9YvBCP2w2SxCO//z9usyxgfFoMOr/seTwe7rvvPo4cOcLOnTtJS0vr6A9ZIBBcBGK2jUAg6BBeeuklsrKyMBqNTJo0iU8//TTivX/5y1+YOnUqSUlJJCUlkZ2d3eL9giYkSSIlJYX77ruPd955h7KyMn72s5/x2WefccMNNzBhwgSWLVvGl19+iSyHFnN1Gl9u35hUE7dkxnNtiokeJj1avx++9/paZK//GUVh099fYVyQ7Hm9Xn70ox9x4MABtm3bJmRPIOjGCOETCATtzrp163jkkUd45pln2LdvH6NHj2bmzJmUl5eHvb+wsJDvfe977Nq1i927d9O7d29mzJjB6dOnO3nllzeSJJGUlMSSJUt4++23sVqtPPHEExw6dIibbrqJcePG8ctf/pLPP//8PPnT+rt3R6eYuKVnPGNTTZiTk3xdGoBGq6V3eip6v+zJssx///d/s2fPHrZt20ZGRkZnf7gCgaANiJKuQCBodyZNmsSECRNYvXo14JOD3r1789BDD7F06dILPu/1eklKSmL16tUsXry4o5d7VVBXV8c777xDfn4+W7ZsoUePHuTm5rJgwQJGjx6NRnP+7//l5eXMnTuXL7/8kp49e/LWW28xZMgQZFnm5z//Oe+++y6FhYVkZWV1/gckEAjahNjhEwgukYqKCjIyMnj22WfVax9//DFRUVHs2LGjC1fWNbhcLoqLi8nOzlavaTQasrOz2b17d6tew2az4Xa7xeH/diQ+Pp7vfe97FBQUYLVaefbZZzl58iSzZs1i5MiRPPHEExQVFYXs/KWnp/PJJ59w6tQpDh8+rMrek08+yaZNm9i+fbuQPYHgMkEIn0BwiaSlpfHqq6/yy1/+kqKiIurr67nnnnt48MEHmT59elcvr9OprKzE6/ViNptDrpvNZsrKylr1Go899hiZmZkh0ihoP2JjY/nOd77DG2+8QVlZGStWrMBqtTJnzhyGDx/OY489xp49e5BlWS0TazQaFEVh2bJlvPHGG2zbto2BAwd29YciEAhaSfhZPQKBoE3k5OTwgx/8gLvuuovx48cTExPDc88919XLuix5/vnnef311yksLBQjuTqBmJgYFi5cyMKFC7Hb7bz33nvk5+czf/584uLimDdvHvPnz2fSpEn87ne/49VXX1VjYAQCweWDOMMnELQTdrudESNGcPLkSYqLixk5cmRXL6lLcLlcmEwm8vPzsVgs6vUlS5ZQU1PDm2++GfHZFStW8Jvf/Ibt27czfvz4TlitIBIOh4Nt27aRn5/P22+/jdfrxePx8OGHHzJ27NiuXp5AIGgjoqQrELQTR48e5cyZM8iyTGlpaVcvp8uIiopi3LhxIecXZVlmx44dTJ48OeJzL7zwAsuWLWPLli1C9roBRqORuXPn8o9//IOysjKeeeYZVq1aJWRPILhMETt8AkE74HK5mDhxImPGjGHw4MGsXLmSL774gvT09K5eWpewbt06lixZwiuvvMLEiRNZuXIlb7zxBocPH8ZsNrN48WJ69uyplr2XL1/OL37xC1577TWuv/569XViY2OJjY3tqg9DIBAIrhjEDp9A0A48+eST1NbW8uKLL/LYY49xzTXXcN9993X1srqMO++8kxUrVvCLX/yCMWPGUFJSwpYtW9RGjhMnTnD27Fn1/pdffhmXy8Xtt99Ojx491P9WrFjRVR+CoBtSVVXFXXfdRXx8PImJidx///00NDS06llFUZg9ezaSJLFx48aOXahA0A0RO3wCwSVSWFjIrbfeyq5du7jhhhsAKC0tZfTo0Tz//PP86Ec/6uIVCgRXBrNnz+bs2bO88soruN1u7r33XiZMmMBrr712wWf/+Mc/sm3bNt599102bNgQcr5UILgaEMInEAgEgm7PoUOHGDZsGHv37lXPeG7ZsoWcnBxOnTpFZmZmxGdLSkqYM2cORUVF9OjRQwif4KpElHQFAoFA0O3ZvXs3iYmJIQ092dnZaDQa9uzZE/E5m83GokWLeOmll8T4N8FVjRA+gUAgEHR7ysrKzmuC0ul0JCcntxjo/fDDDzNlyhRyc3M7eokCQbdGCJ9AIBAIuoylS5ciSVKL/x0+fPiiXvutt95i586drFy5sn0XLRBchohJGwKBQCDoMh599FG+//3vt3hP//79ycjIoLy8POS6x+OhqqoqYql2586dHD16lMTExJDrCxcuZOrUqRQWFl7CygWCywvRtCEQCASCbk+gaaOoqIhx48YBsHXrVmbNmhWxaaOsrIzKysqQayNHjmTVqlXMnTuXfv36dcraBYLugBA+gUAgEFwWzJ49G6vVypo1a9RYlvHjx6uxLKdPn2b69OmsXbuWiRMnhn0NSZJEl67gqkSc4RMIBALBZcG///1vhgwZwvTp08nJyeGGG27gz3/+s/rnbrebI0eOYLPZunCVAkH3ROzwCQQCgUAgEFzhiB0+gUAgEAgEgiscIXwCgUAgEAgEVzhC+AQCgaADeOmll8jKysJoNDJp0iQ+/fTTVj33+uuvI0mSaCoQCATtihA+gUAgaGfWrVvHI488wjPPPMO+ffsYPXo0M2fOPC9HrjmlpaX87Gc/Y+rUqZ20UoFAcLUgmjYEAoGgnZk0aRITJkxg9erVAMiyTO/evXnooYdYunRp2Ge8Xi833ngj9913Hx9++CE1NTVs3LixE1ctEAiuZMQOn0AgELQjLpeL4uJisrOz1WsajYbs7Gx2794d8blf//rXpKenc//993fGMgUCwVWGGK0mEAgE7UhlZSVerxez2Rxy3Ww2R5wJ+5///Ie//e1vlJSUdMIKBQLB1YjY4RMIBIIupL6+nnvuuYe//OUvpKamdvVyBALBFYrY4RMIBIJ2JDU1Fa1Wi9VqDblutVrJyMg47/6jR49SWlrK3Llz1WuyLAOg0+k4cuQIAwYM6NhFCwSCKx6xwycQCATtSFRUFOPGjWPHjh3qNVmW2bFjB5MnTz7v/iFDhvDFF19QUlKi/jdv3jxuvvlmSkpK6N27d2cuXyAQXKGIHT6BQCBoZx555BGWLFnC+PHjmThxIitXrqSxsZF7770XgMWLF9OzZ0+ee+45jEYjI0aMCHk+MTER4LzrAoFAcLEI4RMIBIJ25s4776SiooJf/OIXlJWVMWbMGLZs2aI2cpw4cQKNRhRYBAJB5yFy+AQCgUAgEAiucMSvmAKBQCAQCARXOEL4BAKBQCAQCK5whPAJBAKBQCAQXOEI4RMIBAKBQCC4whHCJxAIBAKBQHCFI4RPIBAIBAKB4ApHCJ9AIBAIBALBFY4QPoFAIBAIBIIrHCF8AoFAIBAIBFc4QvgEAoFAIBAIrnCE8AkEAoFAIBBc4fz/meO4zWqCWDAAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Step 4: Extract edges from the boundary surface (boundary of the boundary = wireframe)\n", + "boundary_edges = boundary.get_facet_mesh(manifold_codimension=1).clean()\n", + "print(f\"Boundary edges: {boundary_edges}\")\n", + "print(f\" Manifold dim: {boundary_edges.n_manifold_dims} (edges)\")\n", + "print(\"Wireframe of boundary surface:\")\n", + "boundary_edges.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One immediate application of this facet extraction we just performed - where we converted a volume mesh into a wireframe - is that this is actually an undirected graph data structure. In fact, a 1D simplicial complex as represented in PhysicsNeMo-Mesh is just a geometric embedding of an undirected graph! Because of this, Mesh can be readily used to generate and manipulate graph data, such as those found in MeshGraphNet-family architectures." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One interesting edge case is the boundary of a closed surface mesh - it is empty. So, if we take the boundary of a sphere (as distinguished from a ball), we get an empty mesh:" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sphere boundary: 0 cells (should be 0 for closed surface)\n" + ] + } + ], + "source": [ + "# For a closed surface mesh, the boundary is empty\n", + "sphere = sphere_icosahedral.load(subdivisions=2)\n", + "sphere_boundary = sphere.get_boundary_mesh()\n", + "print(\n", + " f\"Sphere boundary: {sphere_boundary.n_cells} cells (should be 0 for closed surface)\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Facet Extraction\n", + "\n", + "While `get_boundary_mesh()` extracts only boundary facets (those shared by exactly 1 cell),\n", + "`get_facet_mesh()` extracts **all** sub-simplices - including interior ones shared by\n", + "multiple cells.\n", + "\n", + "The `manifold_codimension` parameter controls how many dimensions to step down:\n", + "\n", + "| Parent cells | `manifold_codimension` | Result | Per-cell count |\n", + "|---|---|---|---|\n", + "| Triangles (2-simplices) | 1 | Edges (1-simplices) | 3 edges per triangle |\n", + "| Triangles (2-simplices) | 2 | Vertices (0-simplices) | 3 vertices per triangle |\n", + "| Tetrahedra (3-simplices) | 1 | Triangles (2-simplices) | 4 faces per tet |\n", + "| Tetrahedra (3-simplices) | 2 | Edges (1-simplices) | 6 edges per tet |\n", + "\n", + "In general, codimension *k* extracts (n-k)-simplices from n-simplices, producing\n", + "C(n+1, n+1-k) candidates per cell (before deduplication of shared sub-simplices).\n", + "\n", + "For example, extracting the edge mesh from a triangle mesh gives you an undirected graph:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Triangle mesh: Mesh(manifold_dim=2, spatial_dim=3, n_points=42, n_cells=80)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n", + "\n", + "Edge mesh: Mesh(manifold_dim=1, spatial_dim=3, n_points=42, n_cells=120)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n", + " Each edge is shared by 2 triangles (interior) or 1 triangle (boundary)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Extract all edges from a triangle mesh\n", + "sphere = sphere_icosahedral.load(subdivisions=1)\n", + "print(f\"Triangle mesh: {sphere}\")\n", + "\n", + "# Get codimension-1 facets: triangles -> edges\n", + "edges = sphere.get_facet_mesh(manifold_codimension=1)\n", + "print(f\"\\nEdge mesh: {edges}\")\n", + "print(f\" Each edge is shared by 2 triangles (interior) or 1 triangle (boundary)\")\n", + "\n", + "edges.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tet mesh: Mesh(manifold_dim=3, spatial_dim=3, n_points=64, n_cells=162)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n", + "All triangular faces: Mesh(manifold_dim=2, spatial_dim=3, n_points=64, n_cells=378)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n", + "All edges: Mesh(manifold_dim=1, spatial_dim=3, n_points=64, n_cells=279)\n", + " point_data : {}\n", + " cell_data : {}\n", + " global_data: {}\n" + ] + } + ], + "source": [ + "# Extract all faces from a tetrahedral mesh\n", + "cube = cube_volume.load(subdivisions=3)\n", + "print(f\"Tet mesh: {cube}\")\n", + "\n", + "# Codimension-1: tetrahedra -> triangular faces\n", + "all_faces = cube.get_facet_mesh(manifold_codimension=1)\n", + "print(f\"All triangular faces: {all_faces}\")\n", + "\n", + "# Codimension-2: tetrahedra -> edges\n", + "all_edges = cube.get_facet_mesh(manifold_codimension=2)\n", + "print(f\"All edges: {all_edges}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 6: Data Conversion\n", + "\n", + "Sometimes you need to move data between points and cells:\n", + "- **cell_data_to_point_data**: Average cell values to vertices\n", + "- **point_data_to_cell_data**: Average vertex values to cells\n", + "\n", + "These methods convert **all** data fields at once. If you only want to convert specific\n", + "fields, construct a temporary mesh with just those fields:\n", + "\n", + "```python\n", + "# Convert only \"temperature\" from point_data to cell_data\n", + "from tensordict import TensorDict\n", + "temp_mesh = Mesh(\n", + " points=mesh.points, cells=mesh.cells,\n", + " point_data=TensorDict({\"temperature\": mesh.point_data[\"temperature\"]},\n", + " batch_size=[mesh.n_points]),\n", + ")\n", + "result = temp_mesh.point_data_to_cell_data()\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Before: point_data keys = []\n", + "After: point_data keys = ['cell_value']\n" + ] + } + ], + "source": [ + "mesh = sphere_icosahedral.load(subdivisions=2)\n", + "\n", + "# Create cell data\n", + "mesh.cell_data[\"cell_value\"] = torch.randn(mesh.n_cells)\n", + "print(f\"Before: point_data keys = {list(mesh.point_data.keys())}\")\n", + "\n", + "# Convert to point data (averages from adjacent cells)\n", + "mesh_with_point_data = mesh.cell_data_to_point_data()\n", + "print(f\"After: point_data keys = {list(mesh_with_point_data.point_data.keys())}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Before: cell_data keys = []\n", + "After: cell_data keys = ['temperature']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Convert point data to cell data\n", + "mesh = sphere_icosahedral.load(subdivisions=2)\n", + "mesh.point_data[\"temperature\"] = mesh.points[:, 2] # z-coordinate as temperature\n", + "\n", + "print(f\"Before: cell_data keys = {list(mesh.cell_data.keys())}\")\n", + "\n", + "mesh_with_cell_data = mesh.point_data_to_cell_data()\n", + "print(f\"After: cell_data keys = {list(mesh_with_cell_data.cell_data.keys())}\")\n", + "\n", + "mesh_with_cell_data.draw(\n", + " cell_scalars=\"temperature\", cmap=\"coolwarm\", backend=\"matplotlib\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 7: Topology Checks\n", + "\n", + "PhysicsNeMo-Mesh can check topological properties of meshes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Watertight Check\n", + "\n", + "A mesh is **watertight** (or \"closed\") if it has no boundary - every facet is shared\n", + "by exactly 2 cells." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sphere is watertight: True\n", + "Hemisphere is watertight: False\n" + ] + } + ], + "source": [ + "# Closed sphere - watertight\n", + "sphere = sphere_icosahedral.load(subdivisions=2)\n", + "print(f\"Sphere is watertight: {sphere.is_watertight()}\")\n", + "\n", + "# Hemisphere - not watertight (has boundary)\n", + "hemisphere = sphere.slice_cells(sphere.cell_centroids[:, 2] > 0)\n", + "print(f\"Hemisphere is watertight: {hemisphere.is_watertight()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Manifold Check\n", + "\n", + "A mesh is a **manifold** if it locally looks like Euclidean space at every point.\n", + "Non-manifold meshes have edges shared by more than 2 faces or \"pinched\" vertices." + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sphere is manifold: True\n", + "Hemisphere is manifold: True\n" + ] + } + ], + "source": [ + "# Valid manifold\n", + "sphere = sphere_icosahedral.load(subdivisions=2)\n", + "print(f\"Sphere is manifold: {sphere.is_manifold()}\")\n", + "\n", + "# Also valid manifold (with boundary)\n", + "hemisphere = sphere.slice_cells(sphere.cell_centroids[:, 2] > 0)\n", + "print(f\"Hemisphere is manifold: {hemisphere.is_manifold()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If a mesh is watertight, it implies that it is manifold, but not vice versa." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Non-Manifold Examples\n", + "\n", + "Here are two classic examples of non-manifold meshes:\n", + "\n", + "1. **Non-manifold edge**: Three triangles sharing a single edge. In a valid manifold, each\n", + " interior edge is shared by exactly 2 faces. When 3 or more faces meet at an edge,\n", + " the mesh fails to be locally Euclidean there.\n", + "\n", + "2. **Pinch point (non-manifold vertex)**: Two tetrahedra that share only a single vertex\n", + " but no common edge or face. The neighborhood of the shared vertex consists of two\n", + " disconnected pieces, which violates the manifold condition." + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Non-manifold edge mesh is manifold: False\n", + "Pinch-point mesh is manifold: False\n" + ] + } + ], + "source": [ + "# Example 1: Non-manifold edge - three triangles sharing edge [0, 1]\n", + "non_manifold_edge = Mesh(\n", + " points=torch.tensor(\n", + " [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [0.5, -1.0]],\n", + " ),\n", + " cells=torch.tensor(\n", + " [[0, 1, 2], [1, 0, 3], [0, 1, 3]], # 3 triangles on the same edge\n", + " dtype=torch.int64,\n", + " ),\n", + ")\n", + "print(f\"Non-manifold edge mesh is manifold: {non_manifold_edge.is_manifold()}\")\n", + "\n", + "# Example 2: Pinch point - two tets sharing only vertex 0\n", + "non_manifold_pinch = Mesh(\n", + " points=torch.tensor(\n", + " [\n", + " [0.0, 0.0, 0.0], # shared vertex (pinch point)\n", + " [1.0, 0.0, 0.0], # tet 1 only\n", + " [0.0, 1.0, 0.0], # tet 1 only\n", + " [0.0, 0.0, 1.0], # tet 1 only\n", + " [-1.0, 0.0, 0.0], # tet 2 only\n", + " [0.0, -1.0, 0.0], # tet 2 only\n", + " [0.0, 0.0, -1.0], # tet 2 only\n", + " ],\n", + " ),\n", + " cells=torch.tensor(\n", + " [[0, 1, 2, 3], [0, 4, 5, 6]],\n", + " dtype=torch.int64,\n", + " ),\n", + ")\n", + "print(f\"Pinch-point mesh is manifold: {non_manifold_pinch.is_manifold()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "In this tutorial, you learned how to manipulate meshes:\n", + "\n", + "1. **Transformations**: `translate()`, `rotate()`, `scale()`, `transform()`\n", + "2. **Subdivision**: `subdivide(levels, filter)` with linear/loop/butterfly schemes\n", + "3. **Slicing**: `slice_cells()` and `slice_points()` with masks or indices\n", + "4. **Merging**: `Mesh.merge([mesh1, mesh2, ...])`\n", + "5. **Boundaries**: `get_boundary_mesh()` and `get_facet_mesh()`\n", + "6. **Data conversion**: `cell_data_to_point_data()` and `point_data_to_cell_data()`\n", + "7. **Topology**: `is_watertight()` and `is_manifold()`" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/minimal/mesh/tutorial_3_calculus.ipynb b/examples/minimal/mesh/tutorial_3_calculus.ipynb new file mode 100644 index 0000000000..04bc8daa17 --- /dev/null +++ b/examples/minimal/mesh/tutorial_3_calculus.ipynb @@ -0,0 +1,1207 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mesh Tutorial 3: Discrete Calculus and Differential Geometry\n", + "\n", + "This tutorial covers the mathematical operations available in PhysicsNeMo-Mesh:\n", + "\n", + "1. **Gradients**: Compute spatial derivatives of scalar and vector fields\n", + "2. **Divergence**: Measure the \"outflow\" of vector fields\n", + "3. **Curl**: Measure the \"rotation\" of vector fields (3D only)\n", + "4. **Curvature**: Gaussian and mean curvature at vertices\n", + "5. **Intrinsic vs Extrinsic**: Derivatives in tangent space vs ambient space\n", + "6. **Vector Calculus Identities**: Verify curl(grad) = 0 and div(curl) = 0\n", + "\n", + "Each operation has specific applicability requirements:\n", + "\n", + "| Operation | Restrictions |\n", + "|---|---|\n", + "| Gradient | None - works on any mesh dimension |\n", + "| Divergence | Input must be a vector field with `n_spatial_dims` components |\n", + "| Curl | 3D spatial dimension only |\n", + "| Gaussian curvature | Surface meshes (codimension >= 1) |\n", + "| Mean curvature | Codimension = 1 only (requires a unique surface normal) |\n", + "| Intrinsic gradient | Only meaningful when codimension > 0 (manifold embedded in higher-dim space) |\n", + "\n", + "---\n", + "\n", + "## Why Discrete Calculus Matters for Physics-AI\n", + "\n", + "In physics-informed machine learning, we often need to:\n", + "\n", + "- **Compute PDE residuals**: Requires gradients, divergence, Laplacian on mesh data\n", + "- **Extract geometric features**: Curvature, normals, gradients as model inputs\n", + "- **Enforce physics constraints**: Conservation laws involve divergence\n", + "- **Loss functions on fields**: Compare predicted vs. actual field gradients\n", + "\n", + "PhysicsNeMo-Mesh provides GPU-accelerated, differentiable implementations of these\n", + "operators, enabling gradient-based optimization through mesh-based physics." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import math\n", + "\n", + "from physicsnemo.mesh import Mesh\n", + "from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral, torus\n", + "from physicsnemo.mesh.primitives.planar import unit_square\n", + "from physicsnemo.mesh.primitives.volumes import cube_volume" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 1: Computing Gradients\n", + "\n", + "The gradient of a scalar field tells you the direction of steepest increase.\n", + "\n", + "PhysicsNeMo-Mesh supports two methods:\n", + "\n", + "| Method | Mechanism | Strengths | Limitations |\n", + "|--------|-----------|-----------|-------------|\n", + "| `lsq` | Weighted least-squares polynomial fit | Robust on irregular meshes, supports tensor fields, differentiable (works with autograd) | Approximate - discretization error, boundary points have one-sided stencils |\n", + "| `dec` | Exterior calculus: grad = ♯(df) | Exact for piecewise-linear fields, preserves Stokes' theorem | Requires simplicial mesh, vertex-centered only, higher-order fields have truncation error |\n", + "\n", + "For most applications, `lsq` (the default) is the right choice. Use `dec` when you need\n", + "exact discrete-topology properties (e.g., verifying Gauss-Bonnet or Stokes' theorem; replicating an FEM solver exactly)." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gradient shape: torch.Size([1089, 2])\n", + "Sample gradient values (should be ~[1, 2]):\n", + "tensor([[1.0000, 2.0000],\n", + " [1.0000, 2.0000],\n", + " [1.0000, 2.0000],\n", + " [1.0000, 2.0000],\n", + " [1.0000, 2.0000]])\n" + ] + } + ], + "source": [ + "# Create a 2D mesh\n", + "mesh = unit_square.load(subdivisions=5)\n", + "\n", + "# Create a scalar field: T = x + 2y\n", + "# The exact gradient should be [1, 2]\n", + "mesh.point_data[\"T\"] = mesh.points[:, 0] + 2 * mesh.points[:, 1]\n", + "\n", + "# Compute gradient using least-squares\n", + "mesh_with_grad = mesh.compute_point_derivatives(keys=\"T\", method=\"lsq\")\n", + "\n", + "# Access the computed gradient\n", + "grad_T = mesh_with_grad.point_data[\"T_gradient\"]\n", + "print(f\"Gradient shape: {grad_T.shape}\")\n", + "print(f\"Sample gradient values (should be ~[1, 2]):\")\n", + "print(grad_T[:5])" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Expected gradient: tensor([1., 2.])\n", + "Mean computed gradient: tensor([1., 2.])\n", + "Error: 0.000000\n" + ] + } + ], + "source": [ + "# Verify the gradient is accurate\n", + "expected = torch.tensor([1.0, 2.0])\n", + "mean_grad = grad_T.mean(dim=0)\n", + "error = (mean_grad - expected).norm()\n", + "print(f\"Expected gradient: {expected}\")\n", + "print(f\"Mean computed gradient: {mean_grad}\")\n", + "print(f\"Error: {error:.6f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparing LSQ and DEC Methods\n", + "\n", + "Let's compare both methods on the same linear field:" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LSQ mean gradient: tensor([1., 2.])\n", + "DEC mean gradient: tensor([1., 2.])\n", + "Exact gradient: [1.0, 2.0]\n" + ] + } + ], + "source": [ + "# Compare LSQ vs DEC on the same linear field T = x + 2y\n", + "mesh = unit_square.load(subdivisions=5)\n", + "mesh.point_data[\"T\"] = mesh.points[:, 0] + 2 * mesh.points[:, 1]\n", + "\n", + "mesh_lsq = mesh.compute_point_derivatives(keys=\"T\", method=\"lsq\")\n", + "mesh_dec = mesh.compute_point_derivatives(keys=\"T\", method=\"dec\")\n", + "\n", + "print(f\"LSQ mean gradient: {mesh_lsq.point_data['T_gradient'].mean(dim=0)}\")\n", + "print(f\"DEC mean gradient: {mesh_dec.point_data['T_gradient'].mean(dim=0)}\")\n", + "print(f\"Exact gradient: [1.0, 2.0]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "DEC recovers [1, 2] exactly because it operates on the piecewise-linear interpolant\n", + "(which *is* exactly T = x + 2y on this mesh). LSQ fits a local polynomial via\n", + "least-squares, and boundary vertices with one-sided stencils introduce small bias.\n", + "We'll analyze these boundary effects next." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Understanding Gradient Error: Boundaries Matter\n", + "\n", + "The dominant source of LSQ gradient error is **boundary effects**: vertices\n", + "on the mesh boundary have one-sided neighbor stencils, leading to biased fits. Let's\n", + "quantify this on a nonlinear field where the gradient isn't trivially constant:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total points: 1089\n", + "Boundary points: 128, Interior points: 961\n", + "\n", + "Mean gradient error (boundary): 0.061494\n", + "Mean gradient error (interior): 0.006355\n", + "Boundary error is ~10x higher\n" + ] + } + ], + "source": [ + "# Nonlinear field: f = sin(pi*x) * sin(pi*y) on the unit square\n", + "mesh = unit_square.load(subdivisions=5)\n", + "x, y = mesh.points[:, 0], mesh.points[:, 1]\n", + "\n", + "f = torch.sin(math.pi * x) * torch.sin(math.pi * y)\n", + "mesh.point_data[\"f\"] = f\n", + "mesh_grad = mesh.compute_point_derivatives(keys=\"f\", method=\"lsq\")\n", + "grad_f = mesh_grad.point_data[\"f_gradient\"]\n", + "\n", + "# Exact gradient: [pi*cos(pi*x)*sin(pi*y), pi*sin(pi*x)*cos(pi*y)]\n", + "exact_grad = torch.stack(\n", + " [\n", + " math.pi * torch.cos(math.pi * x) * torch.sin(math.pi * y),\n", + " math.pi * torch.sin(math.pi * x) * torch.cos(math.pi * y),\n", + " ],\n", + " dim=-1,\n", + ")\n", + "error = (grad_f - exact_grad).norm(dim=-1)\n", + "\n", + "# Classify points\n", + "is_boundary = (x == 0) | (x == 1) | (y == 0) | (y == 1)\n", + "\n", + "print(f\"Total points: {mesh.n_points}\")\n", + "print(\n", + " f\"Boundary points: {is_boundary.sum().item()}, Interior points: {(~is_boundary).sum().item()}\"\n", + ")\n", + "print(f\"\\nMean gradient error (boundary): {error[is_boundary].mean():.6f}\")\n", + "print(f\"Mean gradient error (interior): {error[~is_boundary].mean():.6f}\")\n", + "print(\n", + " f\"Boundary error is ~{error[is_boundary].mean() / error[~is_boundary].mean():.0f}x higher\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Visualize the scalar field with gradient arrows overlaid\n", + "pts = mesh.points.numpy()\n", + "fig, ax = plt.subplots(figsize=(8, 7))\n", + "mesh.draw(point_scalars=\"f\", backend=\"matplotlib\", show=False, ax=ax)\n", + "\n", + "# Subsample arrows for visual clarity\n", + "step = 5\n", + "points_np = mesh.points.detach().numpy()[::step]\n", + "grad_f_np = grad_f.detach().numpy()[::step]\n", + "\n", + "ax.quiver(\n", + " points_np[:, 0],\n", + " points_np[:, 1],\n", + " grad_f_np[:, 0],\n", + " grad_f_np[:, 1],\n", + " color=\"white\",\n", + " scale=50,\n", + " width=0.003,\n", + " alpha=0.8,\n", + ")\n", + "ax.set_title(r\"$f = \\sin(\\pi x)\\sin(\\pi y)$ with $\\nabla f$ arrows\")\n", + "ax.set_aspect(\"equal\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gradients of Vector Fields (Jacobian)\n", + "\n", + "For vector fields, the gradient is a matrix (the Jacobian)." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jacobian shape: torch.Size([1089, 2, 2]) (n_points, n_output_dims, n_spatial_dims)\n", + "\n", + "Jacobian at point (x=0.5, y=0.5):\n", + " Location: tensor([0.5000, 0.5000])\n", + " Jacobian:\n", + "tensor([[ 5.0000e-01, 5.0000e-01],\n", + " [ 1.0000e+00, -3.0744e-08]])\n", + " Expected: [[0.5, 0.5], [1.0, 0.0]]\n" + ] + } + ], + "source": [ + "# Create a vector field: v = [x*y, x^2]\n", + "# Jacobian: [[y, x], [2x, 0]]\n", + "mesh = unit_square.load(subdivisions=5)\n", + "x, y = mesh.points[:, 0], mesh.points[:, 1]\n", + "mesh.point_data[\"v\"] = torch.stack([x * y, x**2], dim=-1)\n", + "\n", + "# Compute Jacobian\n", + "mesh_with_jac = mesh.compute_point_derivatives(keys=\"v\", method=\"lsq\")\n", + "jacobian = mesh_with_jac.point_data[\"v_gradient\"]\n", + "\n", + "print(f\"Jacobian shape: {jacobian.shape} (n_points, n_output_dims, n_spatial_dims)\")\n", + "print(f\"\\nJacobian at point (x=0.5, y=0.5):\")\n", + "# Find point near (0.5, 0.5)\n", + "idx = ((mesh.points - torch.tensor([0.5, 0.5])).norm(dim=-1)).argmin()\n", + "print(f\" Location: {mesh.points[idx]}\")\n", + "print(f\" Jacobian:\\n{jacobian[idx]}\")\n", + "print(f\" Expected: [[0.5, 0.5], [1.0, 0.0]]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Computing Multiple Gradients at Once\n", + "\n", + "You can compute gradients of multiple fields in a single call." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computed gradient fields:\n", + " pressure_gradient: torch.Size([1089, 2])\n", + " temperature_gradient: torch.Size([1089, 2])\n" + ] + } + ], + "source": [ + "mesh = unit_square.load(subdivisions=5)\n", + "mesh.point_data[\"pressure\"] = mesh.points[:, 0] ** 2 + mesh.points[:, 1] ** 2\n", + "mesh.point_data[\"temperature\"] = torch.sin(math.pi * mesh.points[:, 0])\n", + "\n", + "# Compute gradients of both fields\n", + "mesh_grad = mesh.compute_point_derivatives(keys=[\"pressure\", \"temperature\"])\n", + "\n", + "print(\"Computed gradient fields:\")\n", + "for key in mesh_grad.point_data.keys():\n", + " if \"gradient\" in key:\n", + " print(f\" {key}: {mesh_grad.point_data[key].shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Autograd Compatibility\n", + "\n", + "The LSQ gradient operator is built from standard differentiable PyTorch operations\n", + "(`torch.linalg.lstsq`), so it composes with autograd. This means you can compute\n", + "PDE residuals on mesh data produced by a neural network and backpropagate through\n", + "the calculus operators:" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "field.grad shape: torch.Size([1089])\n", + "field.grad is not None: True\n", + "Autograd flows through LSQ gradient computation\n" + ] + } + ], + "source": [ + "from physicsnemo.mesh.calculus import compute_gradient_points_lsq\n", + "\n", + "mesh = unit_square.load(subdivisions=5)\n", + "\n", + "# Simulate a model output: a scalar field with gradient tracking\n", + "field = torch.sin(mesh.points[:, 0]).detach().requires_grad_(True)\n", + "\n", + "# Compute the spatial gradient - this is differentiable\n", + "grad_f = compute_gradient_points_lsq(mesh, field)\n", + "\n", + "# Use in a loss function (e.g., PDE residual) and backpropagate\n", + "loss = grad_f.norm(dim=-1).mean()\n", + "loss.backward()\n", + "\n", + "print(f\"field.grad shape: {field.grad.shape}\")\n", + "print(f\"field.grad is not None: {field.grad is not None}\")\n", + "print(f\"Autograd flows through LSQ gradient computation\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 2: Divergence\n", + "\n", + "The divergence of a vector field measures the net \"outflow\" at each point.\n", + "\n", + "For a 2D field v = [v_x, v_y]: div(v) = ∂v_x/∂x + ∂v_y/∂y" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Divergence shape: torch.Size([1089])\n", + "Mean divergence: 2.0000 (expected: 2.0)\n", + "Std divergence: 0.000000\n" + ] + } + ], + "source": [ + "from physicsnemo.mesh.calculus import compute_divergence_points_lsq\n", + "\n", + "# Create a vector field with known divergence\n", + "# v = [x, y] has divergence = 2 (constant)\n", + "mesh = unit_square.load(subdivisions=5)\n", + "velocity = mesh.points.clone() # v = [x, y]\n", + "\n", + "div_v = compute_divergence_points_lsq(mesh, velocity)\n", + "\n", + "print(f\"Divergence shape: {div_v.shape}\")\n", + "print(f\"Mean divergence: {div_v.mean():.4f} (expected: 2.0)\")\n", + "print(f\"Std divergence: {div_v.std():.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Divergence of rotation field: -0.000000 (expected: 0)\n" + ] + } + ], + "source": [ + "# A solenoidal (divergence-free) field\n", + "# v = [-y, x] is a rotation field with div = 0\n", + "mesh = unit_square.load(subdivisions=5)\n", + "x, y = mesh.points[:, 0], mesh.points[:, 1]\n", + "rotation_field = torch.stack([-y, x], dim=-1)\n", + "\n", + "div_rotation = compute_divergence_points_lsq(mesh, rotation_field)\n", + "print(f\"Divergence of rotation field: {div_rotation.mean():.6f} (expected: 0)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 3: Curl (3D Only)\n", + "\n", + "The curl measures the \"rotation\" or \"vorticity\" of a vector field.\n", + "\n", + "curl(v) = [∂v_z/∂y - ∂v_y/∂z, ∂v_x/∂z - ∂v_z/∂x, ∂v_y/∂x - ∂v_x/∂y]\n", + "\n", + "Curl is only defined in 3D -- cross products are, quite interestingly, only well-defined in 3D and [7D](https://en.wikipedia.org/wiki/Seven-dimensional_cross_product)." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Curl shape: torch.Size([729, 3])\n", + "Mean curl: tensor([-1.8164e-08, 6.3354e-09, 2.0000e+00]) (expected: [0, 0, 2])\n" + ] + } + ], + "source": [ + "from physicsnemo.mesh.calculus import compute_curl_points_lsq\n", + "\n", + "# Create a 3D volume mesh (curl needs full 3D neighborhoods to recover all\n", + "# Jacobian entries; on a 2D surface the normal-direction derivatives are lost)\n", + "mesh = cube_volume.load(subdivisions=8)\n", + "\n", + "# A rotation field around the z-axis: v = [-y, x, 0]\n", + "# Its curl is [0, 0, 2] (constant)\n", + "x, y, z = mesh.points[:, 0], mesh.points[:, 1], mesh.points[:, 2]\n", + "rotation_field = torch.stack([-y, x, torch.zeros_like(z)], dim=-1)\n", + "\n", + "curl_v = compute_curl_points_lsq(mesh, rotation_field)\n", + "\n", + "print(f\"Curl shape: {curl_v.shape}\")\n", + "print(f\"Mean curl: {curl_v.mean(dim=0)} (expected: [0, 0, 2])\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 4: Curvature\n", + "\n", + "PhysicsNeMo-Mesh computes two types of curvature for surface meshes:\n", + "\n", + "| Curvature | Formula | Properties |\n", + "|-----------|---------|------------|\n", + "| **Gaussian** (K) | K = κ₁ × κ₂ | Intrinsic, preserved under bending |\n", + "| **Mean** (H) | H = (κ₁ + κ₂) / 2 | Extrinsic, depends on embedding |\n", + "\n", + "where κ₁ and κ₂ are the principal curvatures." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sphere radius: 2.0\n", + "\n", + "Gaussian curvature:\n", + " Expected: 0.2500\n", + " Mean computed: 0.2503\n", + "\n", + "Mean curvature:\n", + " Expected: 0.5000\n", + " Mean computed: 0.5000\n" + ] + } + ], + "source": [ + "# For a sphere of radius r:\n", + "# - Gaussian curvature K = 1/r²\n", + "# - Mean curvature H = 1/r\n", + "\n", + "radius = 2.0\n", + "sphere = sphere_icosahedral.load(radius=radius, subdivisions=4)\n", + "\n", + "K = sphere.gaussian_curvature_vertices\n", + "H = sphere.mean_curvature_vertices\n", + "\n", + "print(f\"Sphere radius: {radius}\")\n", + "print(f\"\\nGaussian curvature:\")\n", + "print(f\" Expected: {1 / radius**2:.4f}\")\n", + "print(f\" Mean computed: {K.mean():.4f}\")\n", + "print(f\"\\nMean curvature:\")\n", + "print(f\" Expected: {1 / radius:.4f}\")\n", + "print(f\" Mean computed: {H.mean():.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Visualize curvature on the bunny\n", + "bunny = torch.load(\"assets/bunny.pt\", weights_only=False).subdivide(2, \"loop\")\n", + "\n", + "# Gaussian curvature: positive=convex (sphere-like), negative=saddle\n", + "bunny.point_data[\"K\"] = bunny.gaussian_curvature_vertices\n", + "bunny.draw(\n", + " point_scalars=\"K\",\n", + " cmap=\"turbo\",\n", + " show_edges=False,\n", + " backend=\"matplotlib\",\n", + " vmin=-1e4,\n", + " vmax=1e4,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Mean curvature: useful for detecting ridges and valleys\n", + "bunny.point_data[\"H\"] = bunny.mean_curvature_vertices\n", + "bunny.draw(\n", + " point_scalars=\"H\",\n", + " cmap=\"turbo\",\n", + " show_edges=False,\n", + " backend=\"matplotlib\",\n", + " vmin=-100,\n", + " vmax=100,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gauss-Bonnet Theorem\n", + "\n", + "**Why this matters in practice:** The Gauss-Bonnet theorem provides a topological invariant\n", + "that must hold regardless of mesh resolution or deformation. This makes it useful for\n", + "**mesh validation** (if total curvature deviates from the expected value, something is wrong\n", + "with your mesh - inconsistent orientation, degenerate cells, missing faces) and for\n", + "**genus detection** (the total curvature immediately tells you how many handles the surface has).\n", + "\n", + "The theorem relates total Gaussian curvature to topology:\n", + "\n", + "$\\int_M K \\, dA = 2\\pi \\cdot \\chi(M)$\n", + "\n", + "where $\\chi$ is the Euler characteristic. For a closed surface: $\\chi = 2 - 2g$ (g = genus/handles).\n", + "\n", + "- Sphere (g=0): $\\chi = 2$, total $K = 4\\pi$\n", + "- Torus (g=1): $\\chi = 0$, total $K = 0$" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sphere (genus=0):\n", + " Expected total K: 12.5664\n", + " Computed total K: 12.5669\n", + " Error: 0.000483\n" + ] + } + ], + "source": [ + "from physicsnemo.mesh.geometry.dual_meshes import compute_dual_volumes_0\n", + "\n", + "# Sphere: genus=0, χ=2, total K = 4π\n", + "sphere = sphere_icosahedral.load(subdivisions=4)\n", + "K = sphere.gaussian_curvature_vertices\n", + "dual_areas = compute_dual_volumes_0(sphere)\n", + "total_K = (K * dual_areas).sum()\n", + "\n", + "print(f\"Sphere (genus=0):\")\n", + "print(f\" Expected total K: {4 * math.pi:.4f}\")\n", + "print(f\" Computed total K: {total_K:.4f}\")\n", + "print(f\" Error: {abs(total_K - 4 * math.pi):.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Torus (genus=1):\n", + " Expected total K: 0.0\n", + " Computed total K: 0.000353\n" + ] + } + ], + "source": [ + "# Torus: genus=1, χ=0, total K = 0\n", + "donut = torus.load(major_radius=1.0, minor_radius=0.3, n_major=64, n_minor=32)\n", + "K_torus = donut.gaussian_curvature_vertices\n", + "dual_areas_torus = compute_dual_volumes_0(donut)\n", + "total_K_torus = (K_torus * dual_areas_torus).sum()\n", + "\n", + "print(f\"Torus (genus=1):\")\n", + "print(f\" Expected total K: 0.0\")\n", + "print(f\" Computed total K: {total_K_torus:.6f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 5: Intrinsic vs Extrinsic Derivatives\n", + "\n", + "For surfaces embedded in 3D, there are two types of derivatives:\n", + "\n", + "| Type | Description | Use Case |\n", + "|------|-------------|----------|\n", + "| **Intrinsic** | Gradient in the tangent plane | Surface PDEs, physics on manifolds |\n", + "| **Extrinsic** | Gradient in ambient 3D space | Feature extraction, ambient flow |\n", + "\n", + "Intrinsic gradients are perpendicular to the surface normal." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Intrinsic gradient shape: torch.Size([642, 3])\n", + "Extrinsic gradient shape: torch.Size([642, 3])\n" + ] + } + ], + "source": [ + "# Create a sphere with a scalar field based on z-coordinate\n", + "sphere = sphere_icosahedral.load(subdivisions=3)\n", + "sphere.point_data[\"height\"] = sphere.points[:, 2]\n", + "\n", + "# Compute intrinsic gradient (in tangent space)\n", + "sphere_intrinsic = sphere.compute_point_derivatives(\n", + " keys=\"height\", method=\"lsq\", gradient_type=\"intrinsic\"\n", + ")\n", + "grad_intrinsic = sphere_intrinsic.point_data[\"height_gradient\"]\n", + "\n", + "# Compute extrinsic gradient (in ambient space)\n", + "sphere_extrinsic = sphere.compute_point_derivatives(\n", + " keys=\"height\", method=\"lsq\", gradient_type=\"extrinsic\"\n", + ")\n", + "grad_extrinsic = sphere_extrinsic.point_data[\"height_gradient\"]\n", + "\n", + "print(f\"Intrinsic gradient shape: {grad_intrinsic.shape}\")\n", + "print(f\"Extrinsic gradient shape: {grad_extrinsic.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Intrinsic gradient · normal: 0.000000 (should be ~0)\n", + "Extrinsic gradient · normal: 0.4985 (non-zero)\n" + ] + } + ], + "source": [ + "# Verify: intrinsic gradient should be perpendicular to surface normal\n", + "normals = sphere.point_normals # (n_points, 3)\n", + "\n", + "# Dot product of gradient with normal should be ~0 for intrinsic\n", + "dot_intrinsic = (grad_intrinsic * normals).sum(dim=-1)\n", + "dot_extrinsic = (grad_extrinsic * normals).sum(dim=-1)\n", + "\n", + "print(f\"Intrinsic gradient · normal: {dot_intrinsic.abs().mean():.6f} (should be ~0)\")\n", + "print(f\"Extrinsic gradient · normal: {dot_extrinsic.abs().mean():.4f} (non-zero)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Intrinsic gradient magnitude (tangent to surface):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Visualize the difference: intrinsic gradient magnitude\n", + "sphere.point_data[\"grad_intrinsic_mag\"] = grad_intrinsic.norm(dim=-1)\n", + "sphere.point_data[\"grad_extrinsic_mag\"] = grad_extrinsic.norm(dim=-1)\n", + "\n", + "print(\"Intrinsic gradient magnitude (tangent to surface):\")\n", + "sphere.draw(point_scalars=\"grad_intrinsic_mag\", cmap=\"magma\", backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extrinsic gradient magnitude (includes normal component):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Extrinsic gradient magnitude (includes normal component):\")\n", + "sphere.draw(\n", + " point_scalars=\"grad_extrinsic_mag\",\n", + " cmap=\"magma\",\n", + " backend=\"matplotlib\",\n", + " vmin=0.9,\n", + " vmax=1.1,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The intrinsic gradient is largest at the equator (where height changes most rapidly\n", + "*along the surface*) and zero at the poles (where the surface is perpendicular to the\n", + "z-axis, so there's no tangential component). The extrinsic gradient includes the normal\n", + "component, giving a non-zero contribution everywhere - it points straight up in 3D\n", + "space at every point, since height = z has constant extrinsic gradient [0, 0, 1]." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 6: Vector Calculus Identities\n", + "\n", + "The discrete operators satisfy the fundamental vector calculus identities:\n", + "\n", + "- $\\nabla \\times (\\nabla f) = \\mathbf{0}$ : The curl of any gradient field is identically zero\n", + "- $\\nabla \\cdot (\\nabla \\times \\mathbf{v}) = 0$ : The divergence of any curl field is identically zero\n", + "\n", + "Let's verify these numerically." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grad(f) shape: torch.Size([2562, 3])\n", + "curl(grad(f)) shape: torch.Size([2562, 3])\n", + "\n", + "|curl(grad(f))| mean: 0.000215\n", + "|curl(grad(f))| max: 0.000712\n" + ] + } + ], + "source": [ + "from physicsnemo.mesh.calculus import compute_gradient_points_lsq\n", + "from physicsnemo.mesh.calculus import compute_curl_points_lsq\n", + "from physicsnemo.mesh.calculus import compute_divergence_points_lsq\n", + "\n", + "# Create a 3D mesh (surface in 3D)\n", + "mesh = sphere_icosahedral.load(subdivisions=4)\n", + "\n", + "# Scalar field: f = x² + y² + z²\n", + "f = (mesh.points**2).sum(dim=-1)\n", + "\n", + "# Compute gradient\n", + "grad_f = compute_gradient_points_lsq(mesh, f)\n", + "print(f\"grad(f) shape: {grad_f.shape}\")\n", + "\n", + "# Compute curl of gradient\n", + "curl_grad_f = compute_curl_points_lsq(mesh, grad_f)\n", + "print(f\"curl(grad(f)) shape: {curl_grad_f.shape}\")\n", + "\n", + "# Should be approximately zero\n", + "print(f\"\\n|curl(grad(f))| mean: {curl_grad_f.norm(dim=-1).mean():.6f}\")\n", + "print(f\"|curl(grad(f))| max: {curl_grad_f.norm(dim=-1).max():.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "div(curl(v)) mean: -0.000000\n", + "div(curl(v)) max: 0.000102\n" + ] + } + ], + "source": [ + "# div(curl(v)) = 0\n", + "# Create a vector field\n", + "v = mesh.points.clone() # v = [x, y, z]\n", + "\n", + "# Compute curl\n", + "curl_v = compute_curl_points_lsq(mesh, v)\n", + "\n", + "# Compute divergence of curl\n", + "div_curl_v = compute_divergence_points_lsq(mesh, curl_v)\n", + "\n", + "print(f\"div(curl(v)) mean: {div_curl_v.mean():.6f}\")\n", + "print(f\"div(curl(v)) max: {div_curl_v.abs().max():.6f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 7: Worked Example - Calculus on a Nontrivial Field\n", + "\n", + "Let's tie everything together with a realistic example: defining a physically meaningful\n", + "scalar field on the bunny mesh, computing its derivatives, and visualizing the results.\n", + "This demonstrates the kind of feature engineering that feeds into physics-informed models." + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pressure field on the bunny:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load the bunny and define a \"pressure wave\" - a smooth oscillating field\n", + "# that varies in both x and z, producing interesting spatial gradients\n", + "bunny = torch.load(\"assets/bunny.pt\", weights_only=False).subdivide(2, \"loop\")\n", + "x, y, z = bunny.points[:, 0], bunny.points[:, 1], bunny.points[:, 2]\n", + "\n", + "# Oscillating pressure field: ~2 full oscillations across the mesh\n", + "k = 20.0\n", + "bunny.point_data[\"pressure\"] = torch.sin(k * x) * torch.cos(k * z)\n", + "\n", + "print(\"Pressure field on the bunny:\")\n", + "bunny.draw(\n", + " point_scalars=\"pressure\", cmap=\"RdBu\", show_edges=False, backend=\"matplotlib\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pressure gradient magnitude (high = rapid spatial change):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Compute the pressure gradient and visualize its magnitude\n", + "# (where is pressure changing fastest?)\n", + "grad_p = compute_gradient_points_lsq(bunny, bunny.point_data[\"pressure\"])\n", + "bunny.point_data[\"grad_pressure_mag\"] = grad_p.norm(dim=-1)\n", + "\n", + "print(\"Pressure gradient magnitude (high = rapid spatial change):\")\n", + "bunny.draw(\n", + " point_scalars=\"grad_pressure_mag\",\n", + " cmap=\"inferno\",\n", + " show_edges=False,\n", + " backend=\"matplotlib\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Full feature set for a physics-informed model:\n", + " _cache (scalar)\n", + " gaussian_curvature (scalar)\n", + " grad_pressure_mag (scalar)\n", + " mean_curvature (scalar)\n", + " normal torch.Size([3])\n", + " pressure (scalar)\n", + " pressure_gradient torch.Size([3])\n" + ] + } + ], + "source": [ + "# Combine field derivatives with geometric features for a full feature set\n", + "bunny.point_data[\"gaussian_curvature\"] = bunny.gaussian_curvature_vertices\n", + "bunny.point_data[\"mean_curvature\"] = bunny.mean_curvature_vertices\n", + "bunny.point_data[\"normal\"] = bunny.point_normals\n", + "\n", + "# Compute the full Jacobian of pressure as well\n", + "bunny = bunny.compute_point_derivatives(keys=\"pressure\", method=\"lsq\")\n", + "\n", + "print(\"Full feature set for a physics-informed model:\")\n", + "for key in sorted(bunny.point_data.keys()):\n", + " shape = bunny.point_data[key].shape\n", + " trailing = shape[1:] if len(shape) > 1 else \"(scalar)\"\n", + " print(f\" {key:30s} {str(trailing):>15s}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The gradient magnitude plot reveals where the pressure field varies most rapidly. Combined\n", + "with geometric features like curvature and normals, these form a rich per-vertex feature\n", + "vector for downstream ML models - all computed on the GPU in a single differentiable pass." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "In this tutorial, you learned about discrete calculus on meshes:\n", + "\n", + "1. **Gradients**: `compute_point_derivatives()` for scalar and vector fields\n", + "2. **Divergence**: `compute_divergence_points_lsq()` for vector fields\n", + "3. **Curl**: `compute_curl_points_lsq()` for 3D vector fields\n", + "4. **Curvature**: `gaussian_curvature_vertices`, `mean_curvature_vertices`\n", + "5. **Intrinsic vs Extrinsic**: `gradient_type=\"intrinsic\"` for surface PDEs\n", + "6. **Identities**: curl(grad(f)) = 0, div(curl(v)) = 0" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/minimal/mesh/tutorial_4_neighbors_spatial.ipynb b/examples/minimal/mesh/tutorial_4_neighbors_spatial.ipynb new file mode 100644 index 0000000000..af749c9947 --- /dev/null +++ b/examples/minimal/mesh/tutorial_4_neighbors_spatial.ipynb @@ -0,0 +1,1017 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mesh Tutorial 4: Neighbors, Adjacency, and Spatial Queries\n", + "\n", + "This tutorial covers how to find neighbors and perform spatial queries:\n", + "\n", + "1. **Topological Neighbors**: Neighbors based on mesh connectivity\n", + "2. **Adjacency Data Structures**: Efficient sparse encoding\n", + "3. **Spatial Queries with BVH**: Point containment and nearest-cell search\n", + "4. **Sampling**: Random points on cells, data interpolation\n", + "\n", + "---\n", + "\n", + "## Why This Matters for Physics-AI\n", + "\n", + "- **Graph Neural Networks**: Need adjacency information for message passing\n", + "- **Data Augmentation**: Sample random points for training\n", + "- **Field Interpolation**: Query values at arbitrary locations\n", + "- **Collision Detection**: Find which cells contain query points" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "\n", + "from physicsnemo.mesh import Mesh\n", + "from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral\n", + "from physicsnemo.mesh.primitives.planar import unit_square" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 1: Topological Neighbors\n", + "\n", + "Topological neighbors are determined by mesh connectivity (which elements share vertices/edges),\n", + "not by spatial distance.\n", + "\n", + "PhysicsNeMo-Mesh provides four adjacency queries:\n", + "\n", + "| Method | Returns | Description |\n", + "|--------|---------|-------------|\n", + "| `get_point_to_points_adjacency()` | Points → Points | Graph edges (mesh skeleton) |\n", + "| `get_point_to_cells_adjacency()` | Points → Cells | Vertex star (cells containing each point) |\n", + "| `get_cell_to_cells_adjacency()` | Cells → Cells | Cells sharing a facet |\n", + "| `get_cell_to_points_adjacency()` | Cells → Points | Vertices of each cell |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Point-to-Points (Graph Edges)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh: 42 points, 80 cells\n", + "\n", + "Neighbors of point 0: [12, 13, 14, 15, 16]\n", + "Neighbors of point 1: [12, 17, 18, 19, 20]\n", + "Neighbors of point 2: [21, 22, 23, 24, 25]\n" + ] + } + ], + "source": [ + "mesh = sphere_icosahedral.load(subdivisions=1)\n", + "print(f\"Mesh: {mesh.n_points} points, {mesh.n_cells} cells\")\n", + "\n", + "# Get adjacency: which points are connected to each point?\n", + "adj = mesh.get_point_to_points_adjacency()\n", + "\n", + "# Convert to list-of-lists for inspection\n", + "neighbors_list = adj.to_list()\n", + "\n", + "print(f\"\\nNeighbors of point 0: {neighbors_list[0]}\")\n", + "print(f\"Neighbors of point 1: {neighbors_list[1]}\")\n", + "print(f\"Neighbors of point 2: {neighbors_list[2]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Valence distribution:\n", + " Valence 5: 12 vertices\n", + " Valence 6: 30 vertices\n" + ] + } + ], + "source": [ + "# Check vertex valence (number of neighbors)\n", + "valences = [len(n) for n in neighbors_list]\n", + "print(f\"Valence distribution:\")\n", + "for v in sorted(set(valences)):\n", + " count = valences.count(v)\n", + " print(f\" Valence {v}: {count} vertices\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Visualize point-to-points adjacency on a 2D mesh for clarity\n", + "viz_mesh = unit_square.load(subdivisions=3)\n", + "pts = viz_mesh.points.numpy()\n", + "\n", + "# Pick an interior point and get its neighbors\n", + "highlight_idx = 40 # at (0.5, 0.5)\n", + "adj_viz = viz_mesh.get_point_to_points_adjacency()\n", + "neighbor_indices = adj_viz.to_list()[highlight_idx]\n", + "\n", + "# Build a point scalar: 0=other, 1=neighbor, 2=query point\n", + "highlight = torch.zeros(viz_mesh.n_points)\n", + "highlight[neighbor_indices] = 1.0\n", + "highlight[highlight_idx] = 2.0\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 6))\n", + "viz_mesh.draw(\n", + " point_scalars=highlight,\n", + " cmap=\"RdYlBu_r\",\n", + " vmin=0,\n", + " vmax=2,\n", + " show=False,\n", + " ax=ax,\n", + " backend=\"matplotlib\",\n", + ")\n", + "\n", + "# Overlay adjacency edges connecting the query point to its neighbors\n", + "for ni in neighbor_indices:\n", + " ax.plot(\n", + " [pts[highlight_idx, 0], pts[ni, 0]],\n", + " [pts[highlight_idx, 1], pts[ni, 1]],\n", + " \"b-\",\n", + " lw=2,\n", + " zorder=10,\n", + " )\n", + "\n", + "ax.set_title(\n", + " f\"Point-to-Points: {len(neighbor_indices)} neighbors of vertex {highlight_idx}\"\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Point-to-Cells (Vertex Star)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cells containing point 0: [0, 4, 8, 12, 16]\n", + "Cells containing point 1: [6, 9, 20, 37, 78]\n", + "\n", + "Mean cells per vertex: 5.7\n" + ] + } + ], + "source": [ + "# Which cells contain each point?\n", + "adj_p2c = mesh.get_point_to_cells_adjacency()\n", + "cells_per_point = adj_p2c.to_list()\n", + "\n", + "print(f\"Cells containing point 0: {cells_per_point[0]}\")\n", + "print(f\"Cells containing point 1: {cells_per_point[1]}\")\n", + "\n", + "# Number of cells per vertex\n", + "n_cells_per_point = [len(c) for c in cells_per_point]\n", + "print(f\"\\nMean cells per vertex: {sum(n_cells_per_point) / len(n_cells_per_point):.1f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the vertex star: cells containing a point\n", + "adj_p2c_viz = viz_mesh.get_point_to_cells_adjacency()\n", + "star_cells = adj_p2c_viz.to_list()[highlight_idx]\n", + "\n", + "# Build a cell scalar: 0=other, 1=star cell\n", + "star_highlight = torch.zeros(viz_mesh.n_cells)\n", + "star_highlight[star_cells] = 1.0\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 6))\n", + "viz_mesh.draw(\n", + " cell_scalars=star_highlight,\n", + " cmap=\"Blues\",\n", + " vmin=0,\n", + " vmax=1,\n", + " show=False,\n", + " ax=ax,\n", + " backend=\"matplotlib\",\n", + ")\n", + "\n", + "# Overlay the query point\n", + "ax.scatter(\n", + " pts[highlight_idx, 0],\n", + " pts[highlight_idx, 1],\n", + " c=\"red\",\n", + " s=120,\n", + " zorder=10,\n", + " edgecolors=\"black\",\n", + ")\n", + "ax.set_title(\n", + " f\"Point-to-Cells: {len(star_cells)} cells containing vertex {highlight_idx}\"\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cell-to-Cells (Shared Facets)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Neighbors of cell 0: [3, 4, 16]\n", + "Neighbors of cell 1: [3, 18, 25]\n", + "\n", + "Neighbor count distribution:\n", + " 3 neighbors: 80 cells\n" + ] + } + ], + "source": [ + "# Which cells share a facet (edge for triangles, face for tetrahedra)?\n", + "adj_c2c = mesh.get_cell_to_cells_adjacency(adjacency_codimension=1)\n", + "cell_neighbors = adj_c2c.to_list()\n", + "\n", + "print(f\"Neighbors of cell 0: {cell_neighbors[0]}\")\n", + "print(f\"Neighbors of cell 1: {cell_neighbors[1]}\")\n", + "\n", + "# For triangles, each cell has up to 3 neighbors (one per edge)\n", + "n_neighbors = [len(n) for n in cell_neighbors]\n", + "print(f\"\\nNeighbor count distribution:\")\n", + "for n in sorted(set(n_neighbors)):\n", + " count = n_neighbors.count(n)\n", + " print(f\" {n} neighbors: {count} cells\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize cell-to-cells adjacency\n", + "highlight_cell = 55 # near center of the 2D mesh\n", + "adj_c2c_viz = viz_mesh.get_cell_to_cells_adjacency(adjacency_codimension=1)\n", + "cell_nbrs = adj_c2c_viz.to_list()[highlight_cell]\n", + "\n", + "# Build a cell scalar: 0=other, 1=neighbor, 2=query cell\n", + "cell_highlight = torch.zeros(viz_mesh.n_cells)\n", + "cell_highlight[cell_nbrs] = 1.0\n", + "cell_highlight[highlight_cell] = 2.0\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 6))\n", + "viz_mesh.draw(\n", + " cell_scalars=cell_highlight,\n", + " cmap=\"RdYlBu_r\",\n", + " vmin=0,\n", + " vmax=2,\n", + " show=False,\n", + " ax=ax,\n", + " backend=\"matplotlib\",\n", + ")\n", + "ax.set_title(\n", + " f\"Cell-to-Cells: {len(cell_nbrs)} facet-adjacent neighbors of cell {highlight_cell}\"\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cells-to-Points (Cell Vertices)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Vertices of cell 0: [0, 16, 13]\n", + "Vertices of cell 1: [11, 34, 16]\n", + "\n", + "Compare to mesh.cells[0]: [0, 16, 13]\n" + ] + } + ], + "source": [ + "# Which points define each cell?\n", + "adj_c2p = mesh.get_cell_to_points_adjacency()\n", + "cell_vertices = adj_c2p.to_list()\n", + "\n", + "print(f\"Vertices of cell 0: {cell_vertices[0]}\")\n", + "print(f\"Vertices of cell 1: {cell_vertices[1]}\")\n", + "\n", + "# This is essentially the cells tensor in list form\n", + "print(f\"\\nCompare to mesh.cells[0]: {mesh.cells[0].tolist()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 2: Adjacency Data Structure\n", + "\n", + "Internally, PhysicsNeMo-Mesh uses an efficient sparse encoding:\n", + "\n", + "- **indices**: Flat array of all neighbor indices\n", + "- **offsets**: Start position in `indices` for each element\n", + "\n", + "This is the same format used by PyTorch Geometric (CSR-style)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adjacency object: Adjacency(\n", + " indices=Tensor(shape=torch.Size([960]), device=cpu, dtype=torch.int64, is_shared=False),\n", + " offsets=Tensor(shape=torch.Size([163]), device=cpu, dtype=torch.int64, is_shared=False),\n", + " batch_size=torch.Size([]),\n", + " device=None,\n", + " is_shared=False)\n", + "\n", + "Indices shape: torch.Size([960])\n", + "Offsets shape: torch.Size([163])\n" + ] + } + ], + "source": [ + "mesh = sphere_icosahedral.load(subdivisions=2)\n", + "adj = mesh.get_point_to_points_adjacency()\n", + "\n", + "print(f\"Adjacency object: {adj}\")\n", + "print(f\"\\nIndices shape: {adj.indices.shape}\")\n", + "print(f\"Offsets shape: {adj.offsets.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Point 5 neighbors (sparse): [67, 68, 69, 70, 71]\n", + "Point 5 neighbors (list): [67, 68, 69, 70, 71]\n" + ] + } + ], + "source": [ + "# How to read the sparse format:\n", + "# Neighbors of point i are: indices[offsets[i]:offsets[i+1]]\n", + "\n", + "i = 5 # Example point\n", + "start = adj.offsets[i].item()\n", + "end = adj.offsets[i + 1].item()\n", + "neighbors = adj.indices[start:end]\n", + "\n", + "print(f\"Point {i} neighbors (sparse): {neighbors.tolist()}\")\n", + "print(f\"Point {i} neighbors (list): {adj.to_list()[i]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Converting to PyTorch Geometric Format\n", + "\n", + "For GNN libraries, you often need edge indices in COO format." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "edge_index shape: torch.Size([2, 960])\n", + "Number of directed edges: 960\n", + "\n", + "First 10 edges:\n", + "tensor([[ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1],\n", + " [42, 43, 44, 45, 46, 47, 48, 49, 50, 51]])\n" + ] + } + ], + "source": [ + "# The Adjacency object provides expand_to_pairs() for direct COO conversion\n", + "adj = mesh.get_point_to_points_adjacency()\n", + "source, target = adj.expand_to_pairs()\n", + "edge_index = torch.stack([source, target], dim=0)\n", + "\n", + "print(f\"edge_index shape: {edge_index.shape}\")\n", + "print(f\"Number of directed edges: {edge_index.shape[1]}\")\n", + "print(f\"\\nFirst 10 edges:\")\n", + "print(edge_index[:, :10])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 3: Spatial Queries with BVH\n", + "\n", + "For spatial queries (which cells contain a point? what's the nearest cell?),\n", + "PhysicsNeMo-Mesh provides a Bounding Volume Hierarchy (BVH).\n", + "\n", + "BVH enables O(log N) query time instead of O(N) brute-force." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh: 512 cells\n", + "\n", + "BVH: 127 nodes\n" + ] + } + ], + "source": [ + "from physicsnemo.mesh.spatial import BVH\n", + "\n", + "# Create a 2D mesh for clear visualization\n", + "mesh = unit_square.load(subdivisions=4)\n", + "print(f\"Mesh: {mesh.n_cells} cells\")\n", + "\n", + "# Build BVH\n", + "bvh = BVH.from_mesh(mesh)\n", + "print(f\"\\nBVH: {bvh.n_nodes} nodes\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Point [0.25, 0.25]: 32 candidate cells\n", + "Point [0.5, 0.5]: 32 candidate cells\n", + "Point [0.75, 0.75]: 32 candidate cells\n", + "Point [1.5, 1.5]: 0 candidate cells\n" + ] + } + ], + "source": [ + "# Query: which cells might contain these points?\n", + "query_points = torch.tensor(\n", + " [\n", + " [0.25, 0.25], # Inside mesh\n", + " [0.5, 0.5], # Center\n", + " [0.75, 0.75], # Inside mesh\n", + " [1.5, 1.5], # Outside mesh\n", + " ]\n", + ")\n", + "\n", + "candidates = bvh.find_candidate_cells(query_points)\n", + "\n", + "# Use the counts property for efficient per-query candidate counts\n", + "for i, (pt, count) in enumerate(zip(query_points, candidates.counts)):\n", + " print(f\"Point {pt.tolist()}: {count.item()} candidate cells\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Point Containment\n", + "\n", + "Find which cell(s) actually contain each query point." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Point containment results:\n", + " [0.25, 0.25] -> cell 103\n", + " [0.5, 0.5] -> cell 239\n", + " [0.75, 0.75] -> cell 375\n", + " [1.5, 1.5] -> outside mesh\n" + ] + } + ], + "source": [ + "from physicsnemo.mesh.sampling.sample_data import find_containing_cells\n", + "\n", + "# Find containing cells (returns first containing cell for each point)\n", + "cell_indices, bary_coords = find_containing_cells(mesh, query_points)\n", + "\n", + "print(\"Point containment results:\")\n", + "for i, (pt, cell_idx) in enumerate(zip(query_points, cell_indices)):\n", + " if cell_idx >= 0:\n", + " print(f\" {pt.tolist()} -> cell {cell_idx.item()}\")\n", + " else:\n", + " print(f\" {pt.tolist()} -> outside mesh\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Barycentric coordinates:\n", + " [0.25, 0.25]: [0.0, 1.0, -0.0]\n", + " [0.5, 0.5]: [0.0, 1.0, -0.0]\n", + " [0.75, 0.75]: [0.0, 1.0, -0.0]\n", + " [1.5, 1.5]: outside (NaN)\n" + ] + } + ], + "source": [ + "# The barycentric coordinates tell you where in the cell the point is\n", + "print(\"\\nBarycentric coordinates:\")\n", + "for i, (pt, bary) in enumerate(zip(query_points, bary_coords)):\n", + " if not bary.isnan().any():\n", + " print(f\" {pt.tolist()}: {bary.tolist()}\")\n", + " else:\n", + " print(f\" {pt.tolist()}: outside (NaN)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135832/3654304560.py:16: UserWarning: You passed a edgecolor/edgecolors ('black') for an unfilled marker ('x'). Matplotlib is ignoring the edgecolor in favor of the facecolor. This behavior may change in the future.\n", + " ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize point containment results\n", + "contain_highlight = torch.zeros(mesh.n_cells)\n", + "for ci in cell_indices:\n", + " if ci >= 0:\n", + " contain_highlight[ci] = 1.0\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 6))\n", + "mesh.draw(\n", + " cell_scalars=contain_highlight,\n", + " cmap=\"YlOrRd\",\n", + " vmin=0,\n", + " vmax=1,\n", + " show=False,\n", + " ax=ax,\n", + " backend=\"matplotlib\",\n", + ")\n", + "\n", + "# Overlay query points: green=inside, red X=outside\n", + "for pt, ci in zip(query_points, cell_indices):\n", + " color, marker = (\"green\", \"o\") if ci >= 0 else (\"red\", \"x\")\n", + " ax.scatter(\n", + " pt[0].item(),\n", + " pt[1].item(),\n", + " c=color,\n", + " s=120,\n", + " marker=marker,\n", + " zorder=10,\n", + " edgecolors=\"black\",\n", + " linewidths=1.5,\n", + " )\n", + "\n", + "ax.set_title(\"BVH Point Containment: green = inside, red = outside\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 4: Sampling Points on Meshes\n", + "\n", + "PhysicsNeMo-Mesh can sample random points on mesh cells and interpolate data at those points.\n", + "\n", + "**Common use cases:**\n", + "- **Upsampling model predictions**: An AI model predicts values at mesh vertices, but you need\n", + " values at arbitrary points (e.g., sensor locations that don't align with the mesh)\n", + "- **Data augmentation**: Generate training samples at random locations within cells, not just\n", + " at vertices, for better generalization\n", + "- **Field comparison**: Interpolate predictions from one mesh onto another mesh's points for\n", + " error computation\n", + "- **Monte Carlo integration**: Sample points uniformly over a surface for numerical integration" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Random Point Sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Random points shape: torch.Size([320, 3])\n", + " (one point per cell, in 3D space)\n" + ] + } + ], + "source": [ + "mesh = sphere_icosahedral.load(subdivisions=2)\n", + "\n", + "# Sample one random point per cell (default)\n", + "random_points = mesh.sample_random_points_on_cells()\n", + "print(f\"Random points shape: {random_points.shape}\")\n", + "print(f\" (one point per cell, in 3D space)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize random samples on a 2D mesh\n", + "viz_mesh = unit_square.load(subdivisions=3)\n", + "random_pts = viz_mesh.sample_random_points_on_cells()\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 6))\n", + "viz_mesh.draw(show=False, ax=ax, backend=\"matplotlib\", alpha_cells=0.3)\n", + "\n", + "# Overlay sampled points\n", + "rp = random_pts.numpy()\n", + "vp = viz_mesh.points.numpy()\n", + "ax.scatter(\n", + " rp[:, 0],\n", + " rp[:, 1],\n", + " c=\"blue\",\n", + " s=15,\n", + " alpha=0.8,\n", + " zorder=10,\n", + " label=\"Random samples (1 per cell)\",\n", + ")\n", + "ax.legend(loc=\"upper left\")\n", + "ax.set_title(\"Random point sampling\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampled 10 points\n", + "Points from cell 0:\n", + "tensor([[-0.6136, 0.7725, 0.0976],\n", + " [-0.5540, 0.8127, 0.1021],\n", + " [-0.5883, 0.7935, 0.0775],\n", + " [-0.4886, 0.8535, 0.1248],\n", + " [-0.6026, 0.7819, 0.0873]])\n" + ] + } + ], + "source": [ + "# Sample multiple points from specific cells\n", + "# Sample 5 points from cell 0, 3 points from cell 1, 2 points from cell 2\n", + "cell_indices = torch.tensor([0, 0, 0, 0, 0, 1, 1, 1, 2, 2])\n", + "random_points = mesh.sample_random_points_on_cells(cell_indices=cell_indices)\n", + "\n", + "print(f\"Sampled {len(random_points)} points\")\n", + "print(f\"Points from cell 0:\\n{random_points[:5]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Uniform sampling std: tensor([0.0529, 0.0364, 0.0506])\n", + "Centered sampling std: tensor([0.0253, 0.0168, 0.0245])\n" + ] + } + ], + "source": [ + "# Control the distribution with alpha parameter\n", + "# alpha=1.0 (default): uniform over the cell\n", + "# alpha>1: concentrated toward center\n", + "# alpha<1: concentrated toward edges/vertices\n", + "\n", + "cell_indices = torch.zeros(100, dtype=torch.long) # Sample 100 points from cell 0\n", + "\n", + "uniform = mesh.sample_random_points_on_cells(cell_indices=cell_indices, alpha=1.0)\n", + "centered = mesh.sample_random_points_on_cells(cell_indices=cell_indices, alpha=5.0)\n", + "\n", + "print(f\"Uniform sampling std: {uniform.std(dim=0)}\")\n", + "print(f\"Centered sampling std: {centered.std(dim=0)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data Interpolation at Query Points" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Interpolated point data:\n", + " Temperature at query points: tensor([0.5000, 1.0000, 1.0000])\n", + " Expected (x + y): tensor([0.5000, 1.0000, 1.0000])\n" + ] + } + ], + "source": [ + "# Create a mesh with data\n", + "mesh = unit_square.load(subdivisions=4)\n", + "mesh.point_data[\"temperature\"] = mesh.points[:, 0] + mesh.points[:, 1] # T = x + y\n", + "mesh.cell_data[\"pressure\"] = torch.randn(mesh.n_cells)\n", + "\n", + "# Query points inside the mesh\n", + "query_points = torch.tensor(\n", + " [\n", + " [0.25, 0.25],\n", + " [0.5, 0.5],\n", + " [0.75, 0.25],\n", + " ]\n", + ")\n", + "\n", + "# Sample point data (interpolated using barycentric coordinates)\n", + "sampled_point_data = mesh.sample_data_at_points(query_points, data_source=\"points\")\n", + "print(\"Interpolated point data:\")\n", + "print(f\" Temperature at query points: {sampled_point_data['temperature']}\")\n", + "print(f\" Expected (x + y): {query_points.sum(dim=-1)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cell data at query points:\n", + " Pressure: tensor([ 0.0630, -0.2767, 0.1286])\n" + ] + } + ], + "source": [ + "# Sample cell data (no interpolation, just cell value)\n", + "sampled_cell_data = mesh.sample_data_at_points(query_points, data_source=\"cells\")\n", + "print(\"Cell data at query points:\")\n", + "print(f\" Pressure: {sampled_cell_data['pressure']}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Handling Points Outside the Mesh" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Temperature (with NaN for outside): tensor([1., nan, nan])\n" + ] + } + ], + "source": [ + "# Query points including some outside\n", + "query_points = torch.tensor(\n", + " [\n", + " [0.5, 0.5], # Inside\n", + " [1.5, 0.5], # Outside\n", + " [-0.1, 0.5], # Outside\n", + " ]\n", + ")\n", + "\n", + "# Default behavior: NaN for points outside\n", + "sampled = mesh.sample_data_at_points(query_points, data_source=\"points\")\n", + "print(f\"Temperature (with NaN for outside): {sampled['temperature']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Temperature (projected): tensor([1.0417, 1.3333, 0.5417])\n" + ] + } + ], + "source": [ + "# Alternative: project to nearest cell first\n", + "sampled_projected = mesh.sample_data_at_points(\n", + " query_points, data_source=\"points\", project_onto_nearest_cell=True\n", + ")\n", + "print(f\"Temperature (projected): {sampled_projected['temperature']}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "In this tutorial, you learned about mesh queries:\n", + "\n", + "1. **Topological Neighbors**:\n", + " - `get_point_to_points_adjacency()` - graph edges\n", + " - `get_point_to_cells_adjacency()` - vertex star\n", + " - `get_cell_to_cells_adjacency()` - cell neighbors\n", + "\n", + "2. **Adjacency Format**: Sparse `(indices, offsets)` encoding, with `expand_to_pairs()` for\n", + " direct conversion to PyTorch Geometric COO format\n", + "\n", + "3. **Spatial Queries**:\n", + " - `BVH.from_mesh()` - build acceleration structure\n", + " - `find_containing_cells()` - point-in-cell test\n", + "\n", + "4. **Sampling**:\n", + " - `sample_random_points_on_cells()` - random point generation\n", + " - `sample_data_at_points()` - data interpolation at arbitrary locations" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/minimal/mesh/tutorial_5_quality_repair.ipynb b/examples/minimal/mesh/tutorial_5_quality_repair.ipynb new file mode 100644 index 0000000000..dd3ac720de --- /dev/null +++ b/examples/minimal/mesh/tutorial_5_quality_repair.ipynb @@ -0,0 +1,950 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mesh Tutorial 5: Quality, Validation, and Repair\n", + "\n", + "This tutorial covers mesh quality assessment and repair:\n", + "\n", + "1. **Quality Metrics**: Aspect ratio, angles, edge lengths\n", + "2. **Mesh Statistics**: Summary of mesh properties\n", + "3. **Validation**: Detect common mesh errors\n", + "4. **Repair Operations**: Fix mesh problems\n", + "5. **Topology Checks**: Watertight and manifold validation\n", + "\n", + "---\n", + "\n", + "## Why Mesh Quality Matters\n", + "\n", + "Poor mesh quality can cause:\n", + "- **Numerical instability** in PDE solvers\n", + "- **Inaccurate physics** from distorted elements\n", + "- **Training issues** for ML models (garbage in, garbage out)\n", + "- **Visualization artifacts** from degenerate geometry" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "\n", + "from physicsnemo.mesh import Mesh\n", + "from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral\n", + "from physicsnemo.mesh.primitives.planar import unit_square\n", + "from physicsnemo.mesh.primitives.procedural import lumpy_sphere" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 1: Quality Metrics\n", + "\n", + "PhysicsNeMo-Mesh computes per-cell quality metrics that help identify problematic elements." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quality metrics (per cell):\n", + " aspect_ratio: min=2.3094, max=2.5981, mean=2.4087\n", + " edge_length_ratio: min=1.0000, max=1.1661, mean=1.0622\n", + " min_angle: min=0.9483, max=1.0472, mean=1.0081\n", + " max_angle: min=1.0472, max=1.2450, mean=1.1172\n", + " min_edge_length: min=0.2532, max=0.3249, mean=0.2921\n", + " max_edge_length: min=0.2952, max=0.3249, mean=0.3093\n", + " quality_score: min=0.6606, max=0.7565, mean=0.7201\n" + ] + } + ], + "source": [ + "# Load a mesh\n", + "mesh = sphere_icosahedral.load(subdivisions=2)\n", + "\n", + "# Get quality metrics\n", + "metrics = mesh.quality_metrics\n", + "\n", + "print(\"Quality metrics (per cell):\")\n", + "for key in metrics.keys():\n", + " values = metrics[key]\n", + " if not values.isnan().all():\n", + " print(\n", + " f\" {key}: min={values.min():.4f}, max={values.max():.4f}, mean={values.mean():.4f}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Understanding Quality Metrics\n", + "\n", + "| Metric | Ideal Value | Meaning |\n", + "|--------|------------|----------|\n", + "| `aspect_ratio` | 1.0 | Ratio of max edge to characteristic length |\n", + "| `edge_length_ratio` | 1.0 | Ratio of max to min edge length |\n", + "| `min_angle` | π/3 (60°) | Smallest interior angle |\n", + "| `max_angle` | π/3 (60°) | Largest interior angle |\n", + "| `quality_score` | 1.0 | Combined metric (1.0 = perfect equilateral) |" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quality score range: [0.661, 0.757]\n", + "Ideal equilateral triangle: 1.0\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAn0AAAJ8CAYAAACLLxdoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd8XNWZ9793qkbSzKj3Ltmy5d5t2QYTDKaXEEoaCWxI2ZdNNmwau1mSl+yG3c2bhBQSkl0IyYZdCC1ATGgGjMEVjHqxLMnqvWuKptz7/iFmUBlJM9KMRrbOl48+WKOZc860e3/395zneSRFURQEAoFAIBAIBBc0qnAvQCAQCAQCgUAQeoToEwgEAoFAIFgGCNEnEAgEAoFAsAwQok8gEAgEAoFgGSBEn0AgEAgEAsEyQIg+gUAgEAgEgmWAEH0CgUAgEAgEywAh+gQCgUAgEAiWAZpwL0AgEAgEAsGFid1ux+FwhGVunU5HREREWOZeqgjRJxAIBAKBIOjY7XYM8SawOsMyf0pKCo2NjUL4TUCIPoFAIBAIBEHH4XCMC77PbASdepEnd9P5xxIcDocQfRMQok8gEAgEAkHoiNAg6RZXbigqaVHnO18QiRwCgUAgEAgEywAh+gQCgUAgEAiWASK8KxAIBAKBIGRIKglpscOtKgllcWc8LxBOn0AgEAgEAsEyQDh9AoFAIBAIQoYkhcHpk4TT5wvh9AkEAoFAIBAsA4ToEwgEAoFAIFgGiPCuQCAQCASCkBGuRA7BdITTJxAIBAKBQLAMEE6fQCAQCASCkCFJEpK0+IkcgukIp08gEAgEAoFgGSCcPoFAIBAIBCFD7OlbOginTyAQCAQCgWAZIESfQCAQCAQCwTJAhHcFAoFAIBCEDBHeXToIp08gEAgEAoFgGSCcPoFAIBAIBCFDOH1LB+H0CQQCgUAgECwDhOgTCAQCgUAgWAaI8K5AIBAIBIKQIcK7Swfh9AkEAoFAIBAsA4TTJxAIBAKBIGQIp2/pIJw+gUAgEAgEgmWAcPoEAoFAIBCEDOH0LR2E0ycQCAQCgUCwDBCiTyAQCAQCgWAZIMK7AoFAIBAIQoYI7y4dhNMnEAgEAoFAsAwQTp9AIBAIBIKQISEhSYvtvAmnzxfC6RMIBAKBQCBYBgjRJxAIBAKBQLAMEOFdgUAgEAgEIUMkciwdhNMnEAgEAoFAsAwQTp9AIBAIBIKQIZy+pYNw+gQCgUAgEAiWAUL0CQQCgUAgECwDRHhXIBAIBAJByBDh3aWDcPoEAoFAIBAIlgHC6RMIBAKBQBAyhNO3dBBOn0AgEAgEAsEyQDh9AoFAIBAIQoakIgxO3+JOd74gXhaBQCAQCASCZYAQfQKBQCAQCATLABHeFQgEAoFAEDrCkMihiEQOnwinTyAQCAQCgWAZIJw+gUAgEAgEISMcJVsWPXHkPEE4fQKBQCAQCATLACH6BAKBQCAQCJYBIrwrEAgEAoEgZIjw7tJBOH0CgUAgEAgEywDh9AkEAoFAIAgZkiQhSYvs9C3yfOcLwukTCAQCgUAgWAYIp08gEAgEAkHIkKQw7OkTTp9PhNMnEAgEAoFAsAwQok8gEAgEAoFgGSDCuwKBQCAQCEKGKNmydBBOn0AgEAgEAsEyQDh9AoFAIBAIQoZw+pYOwukTCAQCgUAgWAYI0ScQCAQCgUCwDBDhXYFAIBAIBCFDpRr/WdxJF3m+8wTxsggEAoFAIBAsA4TTJxAIBAKBIGSoJQmV6L27JBBOn0AgEAgEAsEyQDh9AoFAIBAIQoZaJaESJVuWBMLpEwgEAoFAIFgGCNEnEAgEAoFAsAwQ4V2BQCAQCAQhQyRyLB2E0ycQCAQCgUCwDBBOn0AgEAgEgpChUoFaFGdeEoiXRSAQCAQCgWAZIESfQCAQCAQCwTJAhHcFAoFAIBCEDLUkoV7sxAqRyOET4fQJBAKBQCAQLAOE0ycQCAQCgSBkCKdv6SCcPoFAIBAIBIJlgHD6BAKBQCAQhAy1SkK92L1wRe9dnwjRJxAECUVRcLvdyLKMWq1GpVKJqvACgUAgWDII0ScQBAFZlnE6ndjtdtxuN3a7HUVRiIuLQ61WCxEoEAgEgrAjRJ9AsAA87l5nZyfNzc2sW7cORVHo6enBZrNhMBiQJAlJklCpVGi1WiECBQLBskINqMWhbkkgRJ9AME8URcHpdOJ2u3G73VgsFk6ePIlarZ4k9FQqlVcculwuIQIFAoFAEBaE6BMI5oHb7cbpdCLLMpIk0d3djdVqJT8/H7VaTVtbGzabjSNHjmAymYiNjSUmJgaTySREoEAgWFaIRI6lgxB9AkEAKIqCy+XC5XKhKAoOh4Py8nIsFgsGg4GcnByv8zc8PEx+fj4DAwMMDg7S1taGy+WaJALNZjOSJAkRKBAIBIKQI0SfQOAnsizjcrlwu90A9Pb2UlFRQWJiIllZWdTV1Xnv6xFukZGRREZGkp6ejqIo2Gw2BgYGGBgYECJQIBAIBIuKEH0CwRwoiuLNzvX8+8yZM7S3t1NUVERaWhq9vb0oiuJ9jEe4TcSXCLRarQwODk4SgWazmZiYGGJjYzGZTEIECgSC8xpVGDpyKOJY6BMh+gSCWZiYrAEwOjpKWVkZarWa4uJiIiMjAd8ib+rvU5EkiaioKKKiooQIFAgEAkHIEaJPIJgBj7vndruRJInW1lZqa2vJzs6moKAAleqjLoYeIeYRWfMRW8EQgR0dHYyOjpKfny9EoEAgWBKEI5FDEYkcPhGiTyCYwkQXzbOPr7KykqGhITZv3kx8fPy0x3jElMfd8+X8BcpMItCTGNLa2orb7Z4kAt1uNzabDUmShBMoEAgEgkkI0ScQTGBqOHdgYIDy8nLMZjO7d+9Gp9PN+tjZfl8oE0VgRkaGTxHocrnQaDQ0Nzd7S8SIcLBAIAgnamnxizMr4lDmEyH6BAImJ2vIsgxAfX09TU1NFBYWkpmZOasgmursBcPpmwtfIrCxsZGenh5GR0dpaWnxOoET6wQKESgQCATLEyH6BMueibX3AOx2O2VlZbjdbnbu3InRaJxzDF+ib7GRJAm9Xk9ERARr166d5gROFYGxsbEYjUYhAgUCgWCZIESfYFkzNVmjs7OTqqoq0tLSKCwsRK1W+zWOLzEUaqdvJibuK5zqBFosFm9iiBCBAoFgMRCJHEsHIfoEyxKPqGlpaWFkZIS8vDyqq6vp6elh/fr1JCUlBTReOMK7gSJJEtHR0URHR88qAmNiYryJIUIECgQCwYWDEH2CZcfEZI2xsTEGBwc5duwYERER7N69m4iIiIDHXArhXV/rmOu+c4lAWZYnZQfPJgKtVitms9krBIUIFAgEAGpRnHnJIESfYFnhdru9yRqSJHlboq1YsYK8vLwFiZSJdfo8v59PLFQEnjp1iu3btxMREYEkSajVajQajff/HnEoEAgEgvAgRJ9gWTAxWcPj9JWXlzM8PExMTAz5+fkLGv98CO8GykwicGJiyEQRCKBSqVCr1d7X2+l0esWeEIECgUAQXoToE1zwTC3F0tfXR3l5OQkJCeTn59PT07PgOaaKl3CGd0M5tkcEZmZmThOBACdPnvS6gDExMZOcQCECBYLlyXidvsUO7y7qdOcNQvQJLlgm1t7z/Luuro7W1laKiopIT0+ntbU1KI7cfHrvhorFmneqE/jmm2+yfv16b0i4qakJRVEmZQdHR0cLESgQCARhQog+wQXJ1M4aFouFsrIyVCoVxcXFREVFAcELw/py+s738O58iIqKIi4uzqcT6BGBE7ODhQgUCC58VCpQq+a+XzCRF3m+8wXxsgguOGRZxuFweIstt7W1cfz4cRISEtixY4dX8EHwxdnEGnnLHY8TmJmZybp169i7dy+bN28mLi6OoaEhSkpKOHLkCGVlZbS0tGC1Wr3lXyRJwuVyYbPZsFgsDA8PMzo6is1mw+FwIMvyshTVAoEgdDz00EPk5OQQERHBjh07OHny5Iz33bdvn/dCdOLP1Vdf7fP+X/7yl5EkiQcffDBEq/cP4fQJLhg8ZUQ84Vy3201lZSWDg4Ns2rSJhISEaY9RqVQhcfo861lswiU2/XmukiRhNBoxGo1eJ3B0dNSbHSycQIHgwiQcJVvkAOd78sknueeee3j44YfZsWMHDz74IAcOHKC2ttZn3dZnn30Wh8Ph/b2vr48NGzZw8803T7vvc889x/Hjx0lLSwv8iQQZIfoEFwRTw7lDQ0OUlZVhNBrZvXs3Op1u1scuFI/Y8DhQ4RQf54sDFogI9CSG+BKBY2Nj9Pf3k5WVJUSgQCCYFz/5yU+46667uOOOOwB4+OGHOXjwII8++ijf+c53pt0/Li5u0u9PPPEEkZGR00RfW1sbf/d3f8crr7wyowu4mAjRJzivmZqsoSgKDQ0NnDt3jpUrV5KVlTXriT/YTt/E8O75Ir6WCjOJQM+ewHPnzk0TgUajkdHRUVpbW0lLSxNOoEAgmMTw8PCk3/V6PXq9ftJtDoeD999/n3vvvdd7m0qlYv/+/Rw7dsyveR555BFuu+22SduHZFnms5/9LN/85jdZs2bNAp5F8BCiT3DeMrH2HoDdbqesrAyn08nOnTsxGo1zjhGqRA7P+pYbwRRVE0VgVlbWjCIwKioKl8uF1Wr1vuciHCwQLB3C0XtX/nC+zMzMSbd/73vf4/vf//6k23p7e3G73SQnJ0+6PTk5mZqamjnnOnnyJBUVFTzyyCOTbv/3f/93NBoNX/3qV+fxDEKDEH2C8xKPu+d2u5Ekia6uLiorK0lJSWH16tWo1Wq/xgllIsdy2tO3GMwkAtva2hgdHaWkpMSnEwhCBAoEy5WWlhZMJpP396kuXzB45JFHWLduHdu3b/fe9v777/Ozn/2M06dPL6njihB9gvMKT4JGY2MjiYmJaDQaamtr6erqYu3ataSkpAQ0XrCdPs9+PrGnL/R4RGBSUhKDg4Ps2LFjmhMITEsMASECBYLFJJyJHCaTaZLo80VCQgJqtZqurq5Jt3d1dc15TrFYLDzxxBPcf//9k24/cuQI3d3dZGVleW9zu938wz/8Aw8++KD3+LTYCNEnOG+YmKxx5swZNBoN9fX16HQ6iouLMRgMAY8ZStG3XMRXuJnors4UDh4YGKCxsRFJkoQIFAgEk9DpdGzZsoVDhw5xww03AOPRpEOHDnH33XfP+tinnnqKsbExPvOZz0y6/bOf/Sz79++fdNuBAwf47Gc/600WCQdC9AnOCzylWGRZ9gqqiooK8vLyyM/Pn/fJOBSiz8NyCu+GW+D6et6+RODIyIg3O1iIQIFA4OGee+7hc5/7HFu3bmX79u08+OCDWCwWr0C7/fbbSU9P54EHHpj0uEceeYQbbriB+Pj4SbfHx8dPu02r1ZKSkkJhYWFon8wsCNEnWNJMTNbwOH0VFRW43W7WrFkzbZNuoITKkRNiYPHw9/2TJMkb6hEiUCBYPNTnQUeOW2+9lZ6eHu677z46OzvZuHEjL7/8sje5o7m5GZVq8qC1tbW88847vPrqq8FadsgRok+wZPEka8iyDEB/fz/l5eXExcWh1+snpcbPlwuxDVu4XbdwMB+xNVUEyrI8qU7gRBE4sU4gfCQCLRYLdXV1rF27Fo1GI0SgQHAec/fdd88Yzn3rrbem3VZYWBjQ8TZc+/gmIkSfYMkxsfaeR/DV1dXR0tLC6tWrSU9P58iRI0ETa8ESSVPHEuJrcQjW66xSqXyKwIGBAfr7+2loaJgmAtVqNQMDA6hUKuEECgQzoCYMiRyI75ovhOgTLCmmdtaw2WyUlZUBsGvXLq/TEkyHLpiir7+/n7GxMQwGw7La0xdOQtUBZaIIzM7O9ikCPfO3tbX5dAKFCBQIBEsJIfoES4aptffa29uprq4mMzOTlStXTtpPIUmS1wVcCMESfZ72a2fOnMFsNtPU1IQsy5SVlU1rISYIPovxuvoSgT09PVRVVfl0AmNjY71bEIQIFAgESwEh+gRhx1N7z9NKze12e0+kGzduJDExcdpjgtk+baHi0WKxUFpaiqIorF+/HpPJhN1u58SJE5jNZq8gUKlUkwRBZGRkSE7yyy2sHK7nq1KpiIqKQq1Ws2HDhhnDwR7RL0SgYLmiCkNHDvciz3e+IESfIKzIsozL5fKGc4eGhigrKyM6Oprdu3fPWD19qYR3Ozo6qKioICMjA4vFQkREBJIkoVKpkCSJ7Oxsrys0MjLCwMAAPT09nD17Fo1G4xWAsbGx3seej4RbaC6FUjW+nEBPdnBfX98k4S9EoEAgCAdC9AnCwsRkDc+Js6GhgYaGBlasWEFOTs6sJ7hghnc96wnkhOp2u6murqarq4sNGzaQlJREe3v7jIkcKpUKs9mM2WwmJycHt9vN8PAwAwMDdHR0UFtbi16vn+QKRUREzPv5LCfCKThn+9xMfM+FCBQsZ8LRkWOx5ztfEKJPsOhMrL0HYLfbKS8vZ2xsjB07dmA2m+ccI5jhXc+a/D2Bevq8ajSaSZ1AJrqGc42rVqu9Dh+Mi0hPqZDW1laqq6uJjIycFA7W6XQLfr4XIqFK5Aj23DOJwIGBgWki0CP+hQgUCATBRIg+waIyNVmjp6eHiooKkpKS2LJlCxqNfx/JYIV3Pckh/ozlydKsrq4mOzubgoKCacklU0Wfv6jV6kkV3F0ul1cENjU1UVlZSVRUlFcAxsTEoNVqZ1xnuFhuomMhgnOiCAQmicDe3l7q6+vnFIFnzpzBYDCQlpYmRKBgyRKO4syLPd/5ghB9gkXBk6Dhcrm8ma41NTV0dHSwZs0aUlNTAxpPpVIFPbw7Gy6Xi8rKSvr6+ti0aRMJCQl+jzufE69GoyEhIcE7j8Ph8IrA+vp6rFYrRqPRKwLNZrPfgvlC43xx+uZiLhF49uxZ1Gr1JBE4NjaGXq9HkiThBAoEgjlZnmcJwaLiqb33wQcfkJGRgU6no6yszBsejYyMDHjMUPbMncrw8DAlJSUYDIaAk0uC5brpdDqSkpJISkoCYGxsjIGBAQYGBqitrWVsbAyj0UhERARutxu3241arQ7K3IKZURRlWmumYOGPCFQUBZvN5hWDIhwsEAhmQ4g+QUjxlGKRZRmr1UpHRwednZ3k5OSQn58/7xPmYog+RVFobm7mzJkz5OXlkZeXN2dyyXzDu4Gi1+tJSUkhJSUFGC9iPTAwQFdXF2NjY7z99tuYzWavE2gymUImTsLNheL0zYUvEXj69Gm0Wq03I9yzV9TjBnouqIQIFIQTkcixdBCiTxASpiZruFwubDYbNpuNLVu2EBcXt6DxQ5G9OxGn00lFRQWDg4N+r3emRI7FwGAwYDAY0Ov12O12NmzY4HUCW1tbcbvdk5JCoqOjgyoCRcmWxUelUnm3AaSnp/ssCyREoEAgmIgQfYKgM7Vvbn9/P+Xl5QDk5+cvWPBBaLJ3PQwMDFBaWorRaGT37t0LypoNVyu2yMhIIiMjSU9PR1EULBaLVwQ2NTWhKMqkpJDzuVvIUi3ZshjIsuwV71PLAsmyzPDwMIODg0IECsKKWhr/Wew5BdMRok8QNCbW3vMIvrNnz9Lc3ExhYSFdXV1B22cWivCuoig0NjZy9uxZv2oFzramcJ0cfc0rSRLR0dFER0eTmZmJoijeenGL3S0kVCyH8G6g80+sAShEoEAgACH6BEHCk6zh6axht9spKyvD7Xaza9cuoqOj6e3tDUpIFoIX3vWMNTY2RmVlJRaLhe3btxMTEzOvccIV3p3IXHNKkuTtHJGVlRXUbiHhEAHL2ekLJJFkJhE49X2fmB0sRKBAcGEhRJ9gwciyjMPh8IaaOjo6qKysJD09ncLCQq+7Fyx3DoIX3vVw+vRp4uLiKC4unrH+3VyEMns3lCxWt5BQslydPlmWF1Qn0CMCPWN53vfu7m7q6urmFIGlpaWkpqYSHx8vRKBgRlSShGqRPwuLPd/5ghB9gnnjqb3naaUmyzKVlZX09PR4W5NNJFi19SA4Tp+iKN6yF5mZmRQUFCzoJDXxsefzyW4+3ULC7XaFc+5wP/dgJeTMRwTa7XavuBNOoECw9BGiTzAvZFnG5XJ5w7nDw8OUlZURGRnJ7t27fTpBwQzJqlQq79zzwRN+HhsbQ61Wk5KSEpQTUrjDu8F0Uz340y3E4wD19vYSFxc3b7d0PiyXki2+WIjTNxezicCuri7q6uqQZZmWlhYcDgexsbHeloQiHCyYiCoMiRwq8dHyiRB9goCYmKzhERfnzp3j7NmzFBQUkJubO+vG8mAJkoWIm56eHsrKykhMTGTz5s0cPnw4aOVfzsfwbqD46hbS29tLTU0NjY2NVFZWLnq3kOUq+ha7TqBHBObm5uJ2uzl27BgRERFeEejZC+pxA4UIFAiWFkL0CfxmarLG2NgYFRUV2Gw2v5Ifgh3eDVRQybJMXV0dzc3NFBUVkZ6e7h0rFGsKheu2FNHpdF4BuG3bNlwul89uIRNFYDC7hSzn8O7Eki2Ljec9zMjIwGQyefeCDg4OChEomIRKWnznTTh9vhGiT+AXHnfP7XajUqno6emhvLycxMRENm3a5JeTE+zwbiBjWa1WSktLkWXZm00c7HVNPUGF44S1FE6SM3ULGRwcpLq6GofDEfRuIcLpCw8Tw8sT94J6nEAhAgWCpYUQfYJZ8SRruFwuZFlGURSqq6tpb2+nqKiItLQ0v8da6D68iQTionV2dlJRUUFqaiqrVq2a5jIFs+bfUgjvhtP58nVS9nQLSUtL8/aKDWa3kOXs9IWy968/zOY0ziQCPXsCz5w5g06nm5QYIkSgQBBahOgTzMjUcK7HLVOr1RQXF3s37/uLSqXC6XQGZW3+CDW3201tbS3t7e2sXbvW6zz5WlewhMPU8K5gMqHoFiISOc4P0ekrK9wjAjs7O6mtrRUi8AJFdORYOgjRJ/CJ2+3GZrPx9ttvs2fPHrq6uqitrSU7O5uCgoJ5uQvB3OM2V0jWYrFQUlKCSqXyS6CGwukLx56+8+2kd753Cwm36Aun0+dx/uc7fzBEoOfzkZmZKUSgQOAHQvQJJuE5mLpcLiRJwul0Ul5ezsjICJs3b/aW7ZgPwUzkmM2da29vp7KykszMTFauXDnnSSmYfXyXQnj3fGY+3UKWq9PnaR0YzvmBoInO+YjAsbExdDqdqBO4xFGpJFSLnFmx2POdLwjRJ/AytW/u4OAgMH5w3717NzqdbkHjh7o4s8vlorq6mu7ubp/FoWcbK5h9fGf6fbG4kPYR+tMtRKVSodfr6ejoWPRuIReS6AoUz/cvVPPPJgI9771nu4DBYJj03otwsEDgGyH6BJNq73kO5A0NDZw7dw6A1atXL1jwQWjbsI2MjFBaWopWq52xOHSo1+UZx3MiWS4lWxYTX0KgqqoKm802Y7eQYHx2ZyKcos/zXV0u8/t67z1bODwiUKfT+WwXKESgQDCOEH3LHF+198rKynC5XOzcuZPjx48HVagFu06foii0trZSU1NDTk4O+fn5ATsPwRRnnnGm/n+xWG4nLbVajcFgQK/Xs3LlSp/dQqKioiYlhgSzW8hScPrCLfrCWSdQo9EQHx9PRkYGbreboaEhBgcHhQhcYohEjqWDEH3LGFmWcTgc3rILnZ2dVFZWTiptEu6CyrON5Xa7KS0tpb+/f0H7DYPt9HmEwHI8YYTjOU9873x1C/GIwPr6eqxWa1C7hSwF0RfO8G44y8XAuNvnKcGkVquJi4sjLi7O+7eZRODExBDPd1aIQMFyQIi+ZYin9p6nlZosy1RVVdHd3c26detITk723jfYyRfBGstutzMyMuIN5+r1+nmPFao6feEK7y7HkPJMJ2OdTkdSUpJ3f+fY2FhQu4Us9/BuuEXfXHUCfYnAgYEB2tvbqampQa/XT8sOFiIw+IiOHEsHIfqWGbIs43K5vOHc0dFRSktL0ev1PvfCLTXRpygKTU1N1NXVodVq2bp164IPvKFK5IDlKcAWm0CEl69uIR4nsLq6GqfTiclk8rtbSDhLpoTbUQ53YWgITHgKESgQCNG3bJiYrOERIh7xlJ+fT15ens8D1lIK7zocDioqKhgeHmbFihW0tbUF5SB7ITl9y/GksxDx4ekWkpqaOq9uIeF2+sJdGHopiL759nEOlgisqakhPz+f+vp63nnnHb71rW8F8yleEIg9fUsHIfqWAVOTNRwOB+Xl5VitVrZt2+bNhvNFMLtVLERADgwMUFpaislkori4mJGREVpaWoKyrmD2BHY4HDQ0NGAymYIy3vlCuB3NYIn/QLuFhFN4hbsw9FIQfZ5e4MEgUBEYGxuLXq+np6eH/Px8KioqeO6554ToEyxpwvuNFYQcT7KGp9hyX18fR48eRafTUVxcPKvgg/CHdxVFoaGhgffee4+cnBw2bdrkLcYazKSQYGC322ltbcVisdDY2IjNZqO2tpazZ8/S19cXtL7Dc7HUeu+GmlA9X0+3kMzMTNavX8/evXvZvHkzMTEx9Pf3c/r0abq6uuju7va+74v52oc7vLoURF8o1+ARgfn5+WzZsoW9e/dSWFiIXq+nra2NY8eOcezYMU6fPs3vfvc7mpqaAmpN+fbbb3PttdeSlpaGJEn8+c9/nvMxb731Fps3b0av11NQUMBjjz027T4PPfQQOTk5REREsGPHDk6ePBnAsxZc6Ain7wLFk6zhcrm8QqumpobW1laKioq8B5q5CGd411M+xmq1sn37dsxm86SxQlnoORBkWaampoaBgQGSkpIoKioC4Pjx4yQkJHhDQA6HA7PZTGxsLHFxcRiNxrCfNC8UFkNsSpKE0WjEaDR6u4WUlpYCzNgtxNM2LBQshfBuuLcTLCS8Gyie8jCeKgEul4u+vj7++te/8vTTT1NdXU1ERAR33nkn+/btY9++fWRlZc04nsViYcOGDdx55518/OMfn3P+xsZGrr76ar785S/z+OOPc+jQIb7whS+QmprKgQMHAHjyySe55557ePjhh9mxYwcPPvggBw4coLa21u9i9aFAJUmoFvmzstjznS8I0XcBMjWca7VaKSsrQ5IkiouLiYqK8nuscDl9fX19lJWVERsbS3Fx8bTaasEMOy/ENbRarZSWlqIoCikpKZMSYTzFZBMSEnzuF5NlmZiYGOLi4oiNjSUqKiooSSnLjXA5myqVCq1Wi9FoJDs722fHCL1e77NOXDAQTl9416DRaDCZTFxyySXcf//93H///bz33nskJyfz61//mjvvvJO8vDyqqqp8lgW68sorufLKK/2e7+GHHyY3N5cf//jHwHjR/HfeeYef/vSnXtH3k5/8hLvuuos77rjD+5iDBw/y6KOP8p3vfCcIz1pwviNE3wWGpxSL5yq8vb2d6upqv/vQTiXUrdOmIssy9fX1nDt3jlWrVpGRkeFTyAQ7vDufsbq7uykvL/fWNaypqZl2n4kFdKfuFxsdHWVgYIC+vj7q6+u94aTFcIkuJMJdK88zt6+OEZ7M4La2tqB3Cwm30xZu0SfLctiFr6dOoOcYUlBQwAMPPACMdwkqLy9fUB3IiRw7doz9+/dPuu3AgQP8/d//PTC+n/j999/n3nvv9f5dpVKxf/9+jh07FpQ1zBcVi59YIWIovhGi7wLBk01WU1OD0WgkPj6eqqoq+vv72bRpk7dYbaAE2+mbTVzZ7XZKS0txOBzs3LkTo9E4432DHd4NRPTJskxdXR3Nzc2sXbuW1NRU79/8zd71FSocHh6mv79/kks0UQT6KxDCnVSxnJhNcKrV6mnhwGB2Cwm34FkKog9YtPDuTGvwzG+xWCZFUYxGI8XFxUGbq7Ozc1INVYDk5GSGh4e9UQS32+3zPr4uSAXLEyH6LgAm9s21WCw4nU5qa2sxGo1BKVy8GOFdj2uWlJTEli1b5rw6Dld41263U1JSgsvlmhYq91WyxV9UKhUxMTHExMQA4wJhaGiI/v5+r0CIjo6eJBCC5SAEg3AKzaXi9M1FsLuFhNvpWwqiE8LXkQQmdwSxWq3e769AsFRZOmcNQcD4StawWq10d3dTWFhIdnb2gk8KoU7kkGWZM2fO0NLSwpo1a0hLS5v3WPPFXwHZ09NDWVkZycnJrF69eprD4Esgz3eNUzeNOxwO737Auro67Hb7pCLCZrMZlUq1LPf0hZOFCM6FdgtZ7iVbPHuWw/kaTCwZY7VaA9ovHSgpKSl0dXVNuq2rqwuTyYTBYECtVqNWq33ex1OMPFyIjhxLByH6zlOmJmuMjY1RXl6OzWYjPT2dnJycoMwTivCu52TlSYKQZTngBJOpfW4XwlwCUlEUzp49y7lz5ygqKiI9Pd2vcYIpTHU6HcnJyd7QzcSkkPb2dlwuFzExMURFRQXtdQmU88FtW8pzB9otJJg16uZDuJ1GT2g13KJvotMXStG3a9cuXnrppUm3vfbaa+zatQsYP0Zs2bKFQ4cOccMNNwDjr9GhQ4e4++67Q7YuwfmFEH3nIZ7ae54r7a6uLioqKkhJSSEqKiqgfUFzEWzRB+Pr7+npoaKigrS0NAoLCwPel+MZK9Sib2xsjNLSUsbGxubcZ+hr3FDh6SSRlpY2qYhwT08PsizzzjvvTMoMNhgMF7QLeCGIvqnM1S3E5XKhVqtpamry2S0k1CxmuZSZ5g939vBCRN/o6Chnz571/t7Y2EhJSQlxcXFkZWVx77330tbWxh/+8AcAvvzlL/PLX/6Sb33rW9x555288cYb/OlPf+LgwYPeMe655x4+97nPsXXrVrZv386DDz6IxWLxZvOGC7UkoV7k7+hiz3e+IETfeYQnnOtppSbLMtXV1XR2drJ27VpSUlKora0NahHgYId3gWlrXshYoWif5qGvr4/S0lLi4+PZvHnznHvofI2zGHvdPEWEo6OjiYuL4+TJk6xfv56BgQG6uro4c+YMOp3OWx/Q00ngQmE57Cf0lf197tw5urq6GBoa8tktJDo6OqRrC7fTF26nEyYL30BF33vvvccll1zi/f2ee+4B4HOf+xyPPfYYHR0dNDc3e/+em5vLwYMH+frXv87PfvYzMjIy+K//+i9vuRaAW2+9lZ6eHu677z46OzvZuHEjL7/88rTkDsHyRYi+8wRZlnG5XF5BNzo6SllZGTqdjt27d3vLe6hUKpxOZ9DmValUuFyuoIxls9kAGB4epri4OKDq9b7WBcFxG6aKNU8XkIaGhlnLxsw1Trh670qShNlsxmw2k5OT420n1d/fT0tLC1VVVZOyRmNjY30KWlmWOXr0KH965k8cOnoYsyaS2268matuuI68vLywn3AnciE6fbMhSRJarRaDwcD69esnlQDq7++noaHBmxzkeY8jIyODutal4PSFc35Y2J6+ffv2zXp88NVtY9++fXzwwQezjnv33XcvuXCu2NO3dBCib4njcfQ87h5Ac3MzdXV15ObmTjv5BtOZC+Z4bW1tVFVVAbBx48YFCT4IvtPneY4Oh8PbBWTHjh0B9dBdSPZuMJn6mkztKep0OiclhdTV1VFRVUZlTSkd/X2MSW7suLGrFJw6FU6jDgoNtDlcfP8v/8n9f/wF0qgDg10hR2MkPSkZfVwMEYlx6HQ6tm3btqD6cwt9votJuPcTer77vkoAjYyMeEP+oegWIstyULeSzGf+cF94eMK7iqJgtVqJjo4O63oEgrkQom8JMzVZw+FwUFlZycjICFu2bPGexCey1ESfy+WiqqqKnp4eNmzYwOnTp4NykgxFeHdgYICSkhJiYmLYtWtXwCe0qc8rHE7fTDQ0NPDW4UOcfP8d6urraOvpx6lScKrBrVfh1qsZi9ah5OqnPw/PP/QalOwY3Nnjvw67Zcr7rJzp7SCqoQlduZOyF18hCS1qvR5VlAGNKRp9fAzx2Znsvupy9l58EYmJiUF/fsvN6YPZw6sqlWqa2xvsbiHhFl1LIbw7dU/fQi9mBYJQI0TfEsXj7nkObH19fZSXlxMTE8Pu3btnFCQqlSroe/rmK1xGRkYoKSnxhqAjIiKCJko9J7tgCdzh4WHa29tZuXIlWVlZ8z6Re0SA5zVbTNHX0dHBq6++xKHDf+UPT/ySxoZztPYM4pBkZL0GDBpceg1jkVqU1TFIPuIfgTxrSa2CpGjGkqIZY/y5doyOcbbDQtSwk8jRAeJb+9jY0I321Fleffo1/iTJOHRqJEMEGmMkulgzUckJbNxbzEWX72fVqlUBn8jD7badD3OHolvIUqjTF27RJ8uyd2vE1OLMgo9QS4vfkWOx5ztfEKJvieGr9t6ZM2dobm72a3+ZWq0Ou9OnKAotLS3U1taSk5NDQUGBd83Bcr88e9cWOpbT6aSrqwu73c62bdsWVFx1McK7vb29HD78FidPv013bzsd7e30DQ7S3TOEVqPCZI5EVhRkQNJpiE6ORAFkBWRFRnHJyIN2lCE7CtL43z78USRwuRVciowbUCQJUHAjoUgKikoF0oebc1SApBr/v2fDzod/G8swMqZS0a+CVrdCVdcohkEnkaMujKNuVtkUcsacqAZHoGUEmRaqX3uPd+/7KVYNYNCjjjKgMRvRx8eQu241F119Jdu3b/fppITbTQ2n0zdf0ROMbiHhFl1LZU+fTqfzZlcL0SdY6gjRt4SYGs612WyUlZWhKAq7du3ya79IuMO7TqeTyspKBgYG2Lx5s/ekEor1LbRbyODgICUlJajVahITExdcTT9YiRzDw8Mcfvswr79xkLMNZ+gb6kdWudHoVWgNagzmCGS3TH1NN06dBpfdxZriLFbvzab+SDPpcUb2X7VmxvHH94l+9KPIMrJ7/N9uWUaRFe/vH/2M3+5yybjcMm6XjEse/7/b7flRPvxx43Yp3tvltLhx1akoDPdZqGvso9NkoKqmC7XNTa5dTTRqFAAXMOJAGRlG6exCAZqPnuLV3/wepwQqtRq1VssYMhmb1vL0wRe9r3U4OF+cvrmYT7cQkb37UXh3bGwMt9st9vTNgEo1/rPYcwqmI0TfEsFTisVzIO3o6KCqqoqMjAxWrlzp9xVtOEXf0NAQJSUlREVFUVxc7LMsSKg7fPiDoig0Nzdz5swZCgoKvJveQ7Ge2dbndDr55GdvpqO/HZVWRhepQW1QoYmQ0EXqMCVHkrMmgbVxmai1alqru6l4t5X2rhGGVSpsRcmkdI2w7bJ8sjaMl75Zf30h/a1D/O53R9m0Np2N27J9rlOtllhMk2Ro0Moz//s+SckmvnTLJtQaFWUnmnnltRqqVBA16CBqxEXqqMJ6twGdr3bpCuOi8MNk8oGj1exNyGQs3shjzz3tdzeXYBJO4RPK8Ko/3UI8HWAMBsO0biGLQbidRvhI9FmtVgDh9AmWPEL0hRlFUXC5XN6yKG63m+rqavr6+ti4cWPAm97DIfoURaGpqYm6ujry8/PJzc2d8UQYjvZpE3E6nVRUVDA4OMjWrVuJjY2lsbExJCHCmV6DtrY2/s83/4ZhqZ/Vl+ewInGNz/vKLpnytxo5W9XLqBus0VrciVHjoVSHi9yOEYpvXE1MymR3IS7DTNwnzLRVdvPBI++yf/8qMrPjp42/GFitDv70x1OYYgzc9Mkt6HQfHXLW78giZ1UiT//hfcqNOobNEXRYHVS1W4gcthM96mK1VUsmWlQ+RGAsWva6tdi73Xx1zwEGjDoeevJxdu/evWjPb6kmcgQbX91CPvjgA1wul89uISaTKeSCbCmEdz1rsFgsACKRQ7DkEaIvjMiyTG9vL1qtloiICIaHhyktLSUyMpLi4uKAs+lgfK/OYhZndjgclJeXMzIy4hVRCxkvEAIVkMPDw5SUlGAwGNi9e7d3o3qwTpxzOX1vvf0G//qz+4hM17Lypky0+unOlG1kjPf+WkdXr5Vht4ItzoCSM/k1VfdbWa2C3X+zGY1u5pNe2pokUlcncvSdZiwvV3PLJ7cSbQr8MzUfXA4XT/7xPTQ6Ndd9fAOGSN9JASazgTvu3s3rr9bw9getjKQZsRfosAN9skLzgA19tw3TiJ34UZnNjgiipxy2IlCxXYnGPazwwJW30RahcMd37uGrHxa7DSXhDu+Gy+kyGAxoNBqysrJISEiY1i3E7XZPSgoJRbeQpRTe9WTuhns9SxXRkWPpIERfGJiYrFFbW0tKSgpOp5P6+npWrFhBTk7OvE8kwXb6Zts3NzAwQGlpKSaTieLiYr9qswW7rZs/YymKQmtrKzU1NeTl5ZGXlzfp9V3o3sCJ40zd0+d2u/nJL/6Dvxx+huR1cWz9/Ipp721P0wDvvd7IoN2JRVJhT4yCjBifc5haB9m8KoGii/z7jEgqiZUXZeNyuHnqpVK0Vpnbbt+BRhOak5Msyzz/xGlcTpnLrlqN0TR3LThJkrjswGqKVqfw7DOl1EVpUEVoxrOL4yMZi4+kB+h2uqnvGMUwOEbUiItci0SRHOF1AdVIrMFAkV3h3e//jP/+1//Hqkv28Ps/PRGyk3G4nb5w1snziE5f3UI8bQE9iSGh6BayFJw+j/C0WCwXfKtDwYWBEH2LzNRkDYBz584BsGPHDsxm84LGX4zw7sSOFYGWOAlmeNefsTx1Ant7e30mlgRzTRPHGR0d5YGffp/WkXMUXpzFzs9/lFghyzJnT7VT/UEHIy4Zi16DMyEK1LMIE1kmtXWI4ssKSCmYXp9xLjQ6NRuvXsnooI3//N275KbEcMW16wIeZ+blybz+YiUjw3Z2XpxPXELgG9rTs2L5yt/t5a9/Ludocx+2hMn7oyStGmeWGWcWDCkKnaMOTndYiBoZwzTiZr1dSzJ6JCRy0JPj1NP36il2x2egzU7lpXcOB32jfbidvqWYSDGxLWBmZmbIuoWEW/TCR06fxWIRod1Z8CT9L/acgukI0beIyLKMw+HwbkDu7u5mYGAAo9HI9u3b5+zt6g+hFn1jY2OUlZVhs9nYvn17wCJ1McO7njqBer2e3bt3z9hvdiG1CKeup7GxkR/89F6GVYOsvTyPrOhxYeWwuyh5tZ5zDQNY1RJWUwRyqsm/I9PoGCssDvZ8ej2RCwzPRscY2HnbWvpahvjtfx1h89oMtu7MXdCYR16robN9iG2780hOW9hFi0aj5tpPbGRFWTsvHarlXKx+RmGhGPXYjXrsQK9bprnbgqFvjKhRJymjChtckcSj5SK3FmvDINekFzJsjuCxvzzH+vXrF7TOqWsJB+Guk+fv/KHqFjKxMHK48LiNnnItwukTLHWE6FsEJiZrKIqCoihUVVXR0dFBTEwM8fHxQRF8EJrizB6R1tvbS1lZGfHx8WzatGleaw52IsdMAtLT9i0nJ4f8/PxZT07BWNMTf3qcR576Jfo0DStvzESlTmG4x8Lx52sYsjgZdMmMxBogLzCXLqJrhPWJkWy5eQ2qIF4qx2eaib/VTEtlN7/57dtccXkR2TkJAY3x3rsNNJzpZuP2bLbuzgva2gBWrU8jIzeO558q4YNRO645xK6kVuFONTKaamQU6LQ7qfYkhIy4WGVRs00xIA9KfGfvVbRHwNf+5fvccdcXFrTOcId3wyky5ps9G6xuIUste1c4fTMjijMvHYToCzGyLONyubxCzGKxUFZWhlqtpri4mMbGxqCKNE8fyGCdjDwi8syZMzQ1NbF69WrS09OXxJ5DX2LNk/3c1dXld/bzfEWfy+Xi+w/8EyeqD5O4JoYNn8ynpbKL135XwohLYVglYY03gHF+7lxCyyDbd6STuyl0pUgy1ySRsTqR48daeP21am6+ZSsm8+wuS1VJG2XvN7NmYwbX3ro5ZGuLNkbwqTt2kHv4LG+ebqUnwf9esVKEFkdeDA5gQFFoG7AR0WUjatRF3IjMTlsEL/3DD3jo3vvYfu0V/Op3j85rjeEO74a7OHIwnvt8u4WEW/R5+qJ79vSJci2C8wEh+kKE54DgdDq9gqK1tZXa2lqys7MpKChApVKFpIMGBG+Ts6d2YHd3Nzt37sRoNC54faESfRaLxVtsubi42O+G8oGKvvb2dr77wDdoGW4gZ2cKigk+ONLE22+dYzhCgyMhamEbWBwusrtH2XPD9HIsoUBSSazcnYXL4ea5V8vR2mVuuXUrGt3kw0NjXTfHD9ezsiiF627bvChiR5IkivetIH9lEs8/V0aFFlQRgfdEVuIiscVFYgN6XG4aOkaJHHATOSLxwXMvseO5VEyrcnnxrTcCypoXTl/wRZe/3UKcTqf3/+HY2+e5WBdOn+B8Qoi+EDA1WcPTpWJoaGhaMoFKpcLhcARt7mCKvu7ubsrKygDYuXNnUELQwU7k8AjIjo4OKioqyMzMZOXKlQGdjPxd05uHD/Gr//4xA64e+gds9A+PUdY2wIjZgJyyMDHsQT1gpUgtUXzH7OVYQoFGp2b9FSuwDtn53RMnSI8xctV162lvHeC15yvIW5nE9Z9cHLE3leQ0M3/zpd288mIFR5v6GI3z3/WbiqRR48o0M5wJw0Dn6BgR7RY0vc1k52QSr43ihTdfp6CgYNZxgumoz4dwz71YTuNM3UJqa2vp7u6mpaVlWreQYG2XmQ3PsceTyCGcvplRhSGRY7HnO18Qoi/IeNw9T2Zbf38/ZWVlmM3mSbXhPITS6ZsvsixTW1tLa2srhYWFVFVVBe3gHuySLW63m6qqKtrb21m/fj3JyckBjzOb6JNlmZ/+8v/x/Ot/oqGlC9kYgVWrwp4UBbHBvbI3tg6yKT+etZfOXNw61MiyjG1kjIhoPfUNPfzw3udxqyAjMw6r1UFb8wBpmTFhCaupNSquunE9BZUdvPRaLQ0mHapglJ6J1mNfOZ7ko8gKHR0jXHzgIiI1Gn74Lz/m5ptv9vkwz2fmfOy9G4y5gbDM7+kW0tjYSH5+PkajcVq3kKkiMBQJH263G0mSUKlUwukTnDcI0RckJtbe8xwQ6+rqaGpqorCwkMzMTJ8nh1AkXnjqw80Hq9VKSUkJgLf2XlVVVdBOMMF0+mRZ5uzZs+h0OoqLi+d90PW1pqGhIT7/5c9ytPwD3EYtdpMe19rk2cuqzBdZJrF+gOID+WSsDqwDy3xx2F20V/cwcG4QtSJhiNASGaEjKkpHRpqZi67dyMvPl7Hxxo0cerma7EsysVucvN/cxeHTjbjtbiQZNCqQ3KBVq0hPiyF3RSKJKcaQioGVa1JJz47jhadLOD1sxelHLcC5kF0yhvZhUqP15OQmsOmWzVhHHXzvB9/ka9/8Kv/nrrv5p3/6p0mPCbfoC7fTB+ERfR480Qxf3UI84eBQdguZWLLGarUKp28WRHHmpYMQfUFgajjXbrdTVlaG2+2ecx9csJ0+mL+b1tHRQWVlJWlpaaxatWqSIF3sgspz0dXVxfDwMLGxsWzdunVBB/GJos9qtXLg+o8xqhqif9DGSGoUcmp06Lp3j4yROWjl0js2EmUOfreMwY4R2qt7sPXZMeg0RBp0RBq0mEwRFK/IIPOydUT46Jbx1O9Psm5zJvkrk0hLj+HR37xD4dX5GON9C2u3081ov43jdW3YTtnBpYD7ox+9Rk1GZiz5hUnzquE3lahoPZ/8/A7yjtTzxqkmuhICF/yyLKPtGCFNpyUjxcTmmzZhjvlIQBoidVz3yc0c+kslTzz3KD9++Od84prr+e2vfztpnOWYyBFOp8/DTHUCDQYDBoOB1NRUFEUJWbeQiSVjrFbrgmusCgSLgRB9C8TtdnuTHVQqFR0dHVRVVZGWlkZhYeGcYYVgO32eMQMRVm63m5qaGjo7O1m3bt2kEGkwwsULWdtUZFnmzJkztLa2YjQaSUlJWfCJx+OMfvVbX+Xou38lYU08l9xSjOyW6WkYoK2qh8F+O53do7Sr1chJkUERgZr2IYpiDez+4rYFlWNxOVy01fTSdbYfHAoRERoMETpMUTrSU2PYdWA9CclGv+d4/sn3yVmRwMrV486JIUrHLZ/Zyp+ePM3qK/J9PkatVWNOjsac7FvQOcdcDPVbOVx6DseIA8UlM2ZxodOowK0QFaklKzuevJVJc2YPT2TH3nzyViTy52dLKVcrqAyzd4WRZRl1t4UUJNKTjGy+ai0JSTNflMUnRLP/2rW89VotF69O5tA7r7J250befukNTCYTEN7wbjjnhvA9d88a5vruh7JbyFTRl5YWuix7gSBYCNE3TybW3oPxA1BlZSU9PT2sX7+epKQkv8YJt9M3OjpKSUkJGo3GZ8arJElBa1PmGW++Y9lsNkpLS3G73ezatYva2tqgrOu5vzzHv//sh+zenU10RjTbbi4CQKVWkbwinuQV44k3slum80wfHbV9DPbZ6Oyx0KZXQ2LgzpWxvpftOzNZtT3D78cM91horehmuHMUjUZDlEFLlEGH2RTB1pUp5OxbQ2S07wLU/vLy82UkJBlZu3HyuhKTTFx5oIjX3qplxb6cgMfV6jXEpJqISTX5/LvD5qS7z0r98bM4LA5wKShuGUkG3DJmo4Hs3HhyC5KIjJ4s7BJTTNz5pd289pdKjjb0MOzDjVR6LCQ53aQnGFm/byXpGTF+C5a4+Cj2XVbIu4fO8InbNnHsSANrd6zjS3d+ib079ixbp8+zlSRczCdZLZjdQibOL/b0zY5I5Fg6CNE3DzzJGh7BMTIyQmlpKREREezevTugkg9qtTokTp8/Y3oKGGdlZbFixYoZTyDBTr6Yz56+np4eysrKSE5OZvXq1ajV6gV30iivKONTX7sDvWzhm9/dzzNPn2bX7etnPJGp1CrSVieS9uG+O7fTTUdNL51nB+juGKWte4SBmEiYLdTocJHcMsQln1hLfNp0h8nlkums66Wjtg/ZLqPXjYs7Y7Se5GQj139sDSlpJlQh2Ft4+NVqdHoNm3fk+Px73soktg5YKT3VTs624LoaOoOWuAwzcRnTQ2SKojBmddLSa6X6SDVOm+vD8LEMbpBkhbi4KPILEsnKjeO1N+qoN+mQRsfIGJNJjolkxZZs8lYmzlukxMVHcdHlhbz7+hkuvmwlhauTefrZP/DHp/6X5x9/hqLVRQt9CQIm3E5fOAXfxBp5C2Eh3UKm7ukLdos/gSAUCNEXAFOTNSRJoqmpibq6OvLz88nLywv4QBjstmkwt3s4sR+tPwWMQ5Fx6y+eZI2mpiaKiopIT0/3/m2+SSHDw8Nce/uN1DSf5dIdOXzxa1fxix8fYu0NhWj1/n8l1Fo1GeuSyVg3Hg53jrloLOmk6Uwffb0W+ofGGE2Igg/3iUm9FgoUhY99eRt2i4Pqt88x2DaCTqvBoNcSadBhNupZvyKR64tXET3Pos7z4cTbZ7Faney7fNWs99uyI4ehARsdNT2krlqcpBNJkoiI0hERpSMhO2ba3xVFwT7ioK53mNFuKxGRanRlHWQkRvOJT29Fpw9ODTdzTCR79q/kyGtn2HvZSm64dRMlp5q45hNXsHXTTn7wzz8gISFh0UqGLAWnL1yEak9hIN1CYDxSAvNz+h566CF+9KMf0dnZyYYNG/jFL37B9u3bfd533759HD58eNrtV111FQcPHgTg85//PL///e8n/f3AgQO8/PLLAa0rFIiOHEsHIfr8RFEURkZGaGtrIycnB6fTSXl5OVarle3btxMTEzOvcUPl9M0k0oaHhykpKSEiIoLi4mK/XMlgh3f9FWp2u53S0lIcDge7du2adiUdqOiTZZnbv/I5DpYfIytazz/es49tu/P47/98l8QtyUTHLywLVKvXsHJHBit3jIdGHTYnZ99vp7muj/oTrSTHR5OzJoWe450kJUZzzd5VpKSb0WjC2z+09L1mOjqGOXDtWr/u/7ErVvPM/7zHQOcwsSm+w7WLiSRJGEx6DCY9w302zvXbGFuTzEjXKK++VYvKLrP7ogLMQSixY4qJZO9lhRx5rZa9l61k844cCotSOPp2JVd+/Eq+/bVvs3LFSkwmE3FxcUHNFp1KuJ2+pSD6Qt17d6ZuIYODg7S3t/OpT30Ks9mM1WqlrKyM7u5uv7b2PPnkk9xzzz08/PDD7NixgwcffJADBw5QW1vr8/HPPvvspHqufX19bNiwYVo5oSuuuILf/e533t9n6jcuWL4I0ecHnmQNm81GQ0MD0dHRlJeXk5CQMO8etB5C4fT5GlNRFFpaWqitrSU3N5f8/Hy/TxjBdvr8Gauvr4/S0lISEhLYsmWLz9c4kHV971+/z8MvPo4jTsu+wiS+/LWLMJoNvHawkl61m9UFgfXE9QfZrTBUN0BuVBR1SUaao3UkWBz8zV3FYe8Z6uFsdSc1FR1cd8umgB53421b+MNv38VgjCAiavbkicXi1ItnaBiwY/+wUPagUU9GhJr0zakcK2vGMWBn7Zo08lb4t992JkxmAxddVsjbr9ay9/KVRBkjuOzqNTQ39PHzh/+drJxV/OrHD2GxWGhtbUWW5WnZosEQa+HuBrIURN9ir2FitxCNRsMzzzxDc3Mz3/jGN3jhhRf4xS9+QVFREZdccgm33HILe/bs8TnOT37yE+666y7uuOMOAB5++GEOHjzIo48+yne+851p94+Lm3x8euKJJ4iMjJwm+jzla5YaKklCtcif1cWe73xhaZx5liieUiwOh8N7kHO5XJSWlrJq1So2bNiw4DDOYjh9TqeTkpIS6uvr2bJlCwUFBQGdLILdOm22sRRF4ezZs5w+fZoVK1awbt26GV9jf5w+i8VCWlEuP3rvOaKNGr506Sq+ed8BjGYDZ2s7ebusmdUX5yzkKU1juNfCyT+UYXm/h3/45uXUdw7jKEqC/HhOa+Duf/gzLef6gjrnfGg518exI/Vce/PGgB+rUkl8+s5dNL3RhOwK7kVLoMgumdd/X8IZqxP7hE4dDnMEZxoGcTlcZKxPJveiLJqGR3nhhVJOHG1Y0GfaaDZw0YFCjrx6xjtOVl48N962GYVu9l+1j9LKUvbs2cOWLVuIjY1lYGCA06dP884771BRUUFbWxtWq3Xe+1LDGd4Nd99fT2HkcO4r9JR+ueWWWzCZTDzyyCN0dXXx/e9/H1mWqamp8fk4h8PB+++/z/79+723qVQq9u/fz7Fjx/ya+5FHHuG2226bVhvwrbfeIikpicLCQr7yla/Q1xf+44xgaSGcvhmQZRmXy+UVZFarldLSUgCfocb5Eqo9fZ51Dw4OUlpaSlRUlM+OIIu9xtmSL8bGxigrK8Nms7Fjxw5vSYyZmEtAvvXmm9z893diKzKzVVLxte9dSWr6eKLA6KidX//uGPu/sHn+T2YK3Q39NL/bRlFhCt/8zgF0Og1vvl5DvRok7YdhKFMEA+uT+f6jx7goJ4HP3bkzaPMHQk/nMK/9pZJbP79j3idOrU7NZ/5mF4//7jgrr569ZVmosA7befn3ZYykm8BH27rR5GhOvVrPnhtWI0kSiXmxJObFMtJr5S9/rcAgqbn4Y4XoIgI/FBpNBi4+sIrDr9Sw97KVqNQq1BoVO/bkUViUzE9/8QN+9ssHef3gIbKysryJAp49Yl1dXZw5c8a7Ryw2Npa4uDi/v6PLPbwb6tDuXEwt2RIVFUVCQgI33XQTN91004yP6+3txe12T+selJycPKNQnMjJkyepqKjgkUcemXT7FVdcwcc//nFyc3Opr6/nH//xH7nyyis5duxY2F8rwdJBiL4peLLCnE6nV5y0tbVRU1NDRkYGFosloOzcuVCr1UHLRPPgSZZobGzk7NmzFBQUkJOTM+8TxGKEd/v7+yktLSU2NtbvkPlsTt8993yNR9/7K7GJBm4uSuPTn9/uff6yLPP977/Evjs2BuWk2VzWRV9ZL5s2ZXLbP16B+sPMWpdL5r/+dBpn4eSEB0mSsOXF8dqgharvvsg/feNSTDGLV+5heNDKc//7Pp/6wq4F1QeEccfr+ps38eLzpRRclhekFfpHa20PR984hy07Zub6DGoVvdERVL3TTNGeLO/NxoRIjAmROGxOXnu7Ftewg+K9+SQmB7ZHMdoUwcVXrOLwy9XsvazQm1UdExfFVTeuo66qi+17NvDZT3+Bf/r2P3nLgcTExJCbm+vdIzYwMEBzczNVVVVERUV5BWBMTIzP70K4+/6GO3s33KITxkWfVjueJLSYHTkeeeQR1q1bNy3p47bbbvP+e926daxfv578/HzeeustLr300kVZ20yowpDIIUq2+EaIvglM7azhcrmorKxkcHCQTZs2ERcXR1NTE263O2jZeROLHwfzIObZS7Rt27Z5J5l4WGhplIlMFWqKotDY2Eh9ff2s7epmWtfU0LjD4WDP/ouoihxma4SeO/9+LwWrJ19R/8v9f2XrTavQzsPdmcjZd1uwNgyz++ICdvzTlmnrfuCHr9CfGTPj4+UYA81GPf/wH69z465crrp23YLW4w92q4PH//MYn76r2CtOF0pqegz7Ll7JkSMN5O7NmvsBQaDkUD3VTcM4Znl9PSgmPec6hsnotWBKmHxi1hm0ZG9LQ3bLnCpvY/hQDRvXpbNqXfoMo00n2hjBvitX8+Zfq7logvCTJImVa1LIKUjg0OE/8cRTj3Pw2ZfJyvroNZq4RwzGt2J4CgfX1dVht9u9fWTj4uIwm82Tvo/LNXt3pm4ci4nHbZRlGZvN5rfoS0hIQK1W09XVNen2rq6uOffjWSwWnnjiCe6///4558nLyyMhIYGzZ8+GXfQJlg5C9H2Ix93zHEwGBgYoKyvDaDR6w6KeK+tg7sHz2O7BEpL9/f309PRgMBgoLi72XokuhFA5fQ6Hg/LyckZHR9m+fXvAbYymhncrKsq54jMfxx2v5tO5qXz663vRaCeHNX7763dI3pxMTNL8wvOyLFPzaiMGu8Lei1aw9tO+iyufrenidO8IZMfO/hzUKiwrE3iipoOTH7Tyj9++DF0AZWMCwTnm4r8ePMxnvlyM1kcodCGsXJPK8KCdqg86ydgUuo3ksixz+MlK2mQFdwDv4ViKkVNvNnLJTUU+xYJKrSJrYwrKhmTaGgYof+p9UuKi2X3JzPUrJxIVHcElVxbx1l+rvaFeDzq9hr37C+nuGOL6W/azeeMeHnn4UZ/jaLVakpKSvBmcdrvdWzi4srISl8uF2Wz2XsiJ8G748IR3LRYLgN+iT6fTsWXLFg4dOsQNN9wAjD+fQ4cOcffdd8/62KeeeoqxsTE+85nPzDlPa2srfX19pKam+rWuUCISOZYOy170Ta29B3D27FnOnTvHypUrycrK8h5YJUkKets0z9gLHVNRFOrr62lsbMRkMhETExMUwQehEX2Dg4OUlJRgMpnmLU4nOh4P/vQn/OB/HyInQc8XP7+Ddbtzpt3/tZcrGdS6Wb8m8OxN2SVT8eIZYrV6brhyDdn5s9eo++GDb2IriMPfw44rMZpah5uvfu8gd1y/nh27cgNe46zju2Qe/fnb3PaFnegjgvO5mMrW3bkMvGiht36AhPzZxe58cNhdvPL7D+iPiwJDgM9BkhhOMvLBoUa2XOa7ldz43SSS8+NIzo9jtN/Ks8+XYkDFpQdW++xRPJGoaD2XXLWaN16qYs/+QjSayaIoKdXMtZ/YQMUH1azbUshvH3qMXTt3zTpmREQEqamp3j6yVquV/v5++vv7ATh+/PikwsEzdY8INktB9IXb6fMYBFarFfBf9AHcc889fO5zn2Pr1q1s376dBx98EIvF4s3mvf3220lPT+eBBx6Y9LhHHnmEG264wesMexgdHeX//t//y0033URKSgr19fV861vfoqCggAMHDizwmQouJJa16JsazvUkEjidTnbu3InROL1jQrDbpkmStOAx7XY7ZWVl2O12duzYQVtbW9DCsRD8ZBO73c6pU6cWvNfQ47p+/BM38E5bBZcWJvGl73wMg4+Tc+PZHg6fbmLPrf7VovPgsLuofP4MqTHR3P7JHST6UZfuPx8+Qldi4CdfSadmeFUiv36zhneONvL1r+8LyolNlmUe/dlhrv/0ZqIW2KZtLi67di1P//dJRs1WomfrTBIg/e1DvPHnWixpZtDM8zUxaOkYGaOnaYDEORxYgOi4SFbty8E55uLlwzXIwy527cklNX3mx0ZG6fnYVUW8+VIVu30IP0klsW5LJvmrkvjWd7+IKSqd55/5i997WKOiooiKiiI5OZl33nmHdevWMTQ05O0eodVqJyWFhKpOW7hF11II73qcPqvVilqtDui1vvXWW+np6eG+++6js7OTjRs38vLLL3uTO5qbm6c9v9raWt555x1effXVaeOp1WrKysr4/e9/z+DgIGlpaVx++eX84Ac/ELX6BJNYtqLPU3vPc/Dq7OyksrKSlJQUb5svX4SzbZovent7KSsrIyEhgc2bN6PRaOjs7MTpdAZ1fcEQfU6nk+bmZux2O9u3b/cWPJ0vnZ2d3PnVu9BEubjn01u56OrVPu9ntTj45W/fYf9d/mfqWgbtnHnpLDlpcXz5yxdhMvtXuHlwwMqrpW3IBfFz33kGHGlm3rc6+dq9L/K1O3dSUJg894Nm4bFfHOGqmzZgXqRkkY9/ait/+M276PZmzCsrdip1p1o5/UEX9swYWKCL5UyM4oOT7ezPNPstGrR6DQU7M1FkhZKqLt59t4FVBUms3Zzp8/6RUXo+dvUa3jhY6VP4ee9z1WpazvWxY8867vnqP/HpT80dsvPguajz1P/zdI8YGhpiYGCAtrY2qquriYyMnOQEBsv9D7foC/f8njV4RN98HNa77757xnDuW2+9Ne22wsLCGS/mDQYDr7zySkDzLyYivLt0WHaiT1EUXC4XLpcLGP/iVldX09XVxdq1a+fcSBsK0Tcfp0+WZerq6mhubmb16tWkp6d7DzrBduaCMZ6nE4hGo/GeiBbC7x97lHt/fD8bVsRz970fIzbB9/4uWZa573t/4eI7NiL5kc7V3zZMy1stFBYk8dWv7yciwDDiP3//JUZyYv0O685IpJbeVQn88H/fozg9li/cVTyvYf7wqyNccuVq4ue5h3E+qNQqPnnnTv7z52+z6vqCBZ2cjz1fTePgGM60IHX+kCQsqSaOv3SG4mtmbzk37aEqicy1ybAWeluGeOrp08QbDey7tBDVFGFniNTxsavXcOhgJXsuXYFG6/tQm5kTT1pmLP/73M/57aO/4i/PveIzwjAVz/dxotBQq9XExcV5C/k6nU5vZnBDQwNWq3VaUsh898WFu07fUtvTFxUVFdZsZoHAX5aV6JuYrCFJEqOjo5SWlqLT6SguLvY20p6NpeD02Ww2SktLcblcPmsGLiXRN7ETSF5eHiaTya9aVLNx++c/w4nyo3z25vVc95nNsx5s//VfXmbLjXPXYeuo6aHvgx7Wrk3npm9dNi0BxB/++mI5TRFqpPmGH6cgSRL2nFjeHLRR8Y0/88/f3k98ov/i7b9//S7b9+aTkhETlPUEgj5Cy6f/ZidP/PEkhVcFXsNPdsm8+ocSeiJ1yPFBLoWhU9On1dBU2U32PPZ3AiRkmknINGMdsvPcX8rQuuFjl0/ul2yI1HHp1Ws4dLCKPZcWzCj81GoVW3blMDxk48rrd3Ppxdfxf7/3L7PO74/o0mq1JCYmentrj42NeZNCqqurcTgcmM1mrwg0Go1+C7lwO21LJbzr2dMXaN/d5YaKMDh9C7/0viBZFqJvarKGJEk0NzdTV1cXcEuycDt9XV1dVFRUkJycPGMYOtiib769dz0lb/r7+9m8eTPx8fH09/fPe219fX3sO7CPxAS4/z+uJTNv9tZpj/z2XRLXJxKbMrNzcu69NuwNo2zZmsVnv7Np3lfrDoeLP/ylAufKhHk9fjaUGANdpgj+6edvccXGDG64aeOcj/njI8cp2pJOdn7w1+MvsfFRXHPdel56uZIV+/1PTLEO23n9fyoYSIr2WXA5GLhiI6mu7iU1P25BIehIcwSFF2fjcrh54+hZnIMOduzMJiN7PLxviNRx2bVreP3FSnbPIvxgvL3bpdesor7mHfZcsoU/PPIUeXm+ax/Op06ep0VXSkoKiqJgs9no7+9nYGCAlpYWFEWZFAqezb0SdfomO32LlUAjECyUC170TU3WcDqdVFRUMDo6ytatWwMOM4bL6ZNlmdraWtra2lizZs2safjBXuN8ROTIyAglJSXo9XqKi4u9m4n9aZ3mi7+8+AJf/87fccWBldzyt3PXmHvztRp6cLJxne99V7VvnkM94GTXnnw2fiI74PVM5Qf3v8xgVsyCx5kJSSUxnB/Hn8/18sH3/8q3v3EpkdG+s0mfevwUeSsSKFqbFrL1+Etmbjx7duVz4lgTObt8vxcTaavt4cRbzYykmUJeXdWWbuLI8zVcGmByjy80OjV529NRFIXKml6On2giLzuezTuy0Udo2X/tGl5/sYJdH1uBTjf7YTd/VRJZefH87ddvIT1lDY/85vfT7rPQwsySJBEZGUlkZCQZGRkoisLo6Cj9/f309fVRX1+PRqOZJAInRkJkWQ7a/sD5sBTCu1P39AkE5wMXtOibmqzR29tLeXk5cXFx7N69e95lQkLRNm22MS0Wi7cFXHFx8ZwHmFCEdz17IP2hra2NqqoqcnJypvX5nc/avvSlL1Ba/Q73/uAAqzbNXTS3qaGX10/Us/eTk4sdy7JM5V/OYkbDFZevomDVwhIkPFSUtlI+aoPYmKCMNxuO+EjOmNx884cvc/Mlhey7rHDS3//ybCnxidFs2ro4RZL9Yc3GdIb6LdSXd5G+bubXvPyNBmqah7GmB2n/3lyoVQzHGqg42sza4uC8XpIkkb46EVYnMtA+zNNPn8YcqeeSy1ez/9q1vP5iJbs+VjCn8Gtu7GFw1EpnzXH2XX4Rb7369qS/B3tPnSRJGI1GjEYj2dnZyLLsTQrp6OigtrYWvV5PXFwcsbGxuFyusGaFhju86+miNHFPn2BmxhM5Fvf9EokcvrkgRZ+iKNjtdlpaWrwJDrW1tbS0tExLegiUxXb6Ojo6qKysJD09ncLCQr8OdOHa0+d2u6mqqqK7u5tNmzaRkDA9tBjI2qxWK3sv3s6a9TH823/ePOeJEsY7Tvzs129z2Re3eG9zOVx88HQNabHR3HbjFtL86OIQCP/v10ewF8Qv2g4SSatmYGUC/3W8gTePNfDP/3gAjUbFob9Wodaq2LVn5jp04aL4YysZeLqE/pZB4qa8/rIs8+6fqmiVFRwJi3zyjDFwtmmAnAEr0bHBdWti00zEppmwjYzxwkvlqB0Ku/cVcOzNs+zaVzCtCHdH6wDlpW241RJRSZEkb0hCkiQ6zvRx7z/fywM/+KhmW6jDqyqVyuvwwfhWDU9SSFNTE6Ojo+h0OlwuF7GxsTO2iwsV4XYaPcdrsadPcL5xQYo+t9vN2NgY1dXVxMbGUlFRAeAz6SFQFmtPn9vt9mYVr1+/3luh3x9CIfrmCsmOjo5SUlKCVqtl9+7dM/Yn9je8e+Ttw9zzrS/x+S9vY8vH/EsEGM/UPci+z21AUknYRx188FQ1+RlxfPmLe4mbIcN3IfzyZ2/SkxIdlv08cqaZWpuTL33jOS7fnIneoOXA1WsWfR3+ctVNG/jfR49jNUUQaR7/fDjsLl7/71L6Yg3IISoaPRdKZgxHXq7nyk+Gpg2ewahn5d4s3C6ZY6VN2J0uDj5dwtWf2IjN6uC9E03Y3S4iYiNIXJ80rR9yyoo4nnvlKa647Aouvuji8TUvcvasRqMhISHBeyFXWlqKVqvF5XJx5swZxsbGMJlM3qQQk8kU0vWFe0+f5xygVqsDasG2XBElW5YOF6To8xQ8Bjhx4gSZmZmsXLkyKAeJxXD6PAJKo9H4nVU823jBWN9sIrKjo4OKigqysrJYsWL2tlX+CNK//+r/oaXrPX74nx8PqJjwv/3rK2y8fiX2UQfvPV5JYV4i3/jWZURGhSYM1ds1wlu13cj5syeUhAq5e4S48n6SB9wcLyulc7WZp46fQ5JApYxviVMxfvBTS+PZbGoVqBn/XS2p0EmgV6vR61RoNWoio3QYI7UYjREYTXqMxgiijHqijOP/1hu0CyqmfcvntvPYr94h69IshnstHH7+DMOppvkXXA4GKgl7cjSnXj3LtssDzzT2F7VGRe6WNBRFoeFUG0//4RQx2SZSViegnuX5S5JE3rYUPvfl2yk5WkpMTEzYEykAzGYz6enj2y1sNps3M7itrQ23201MTIw3HBwdHdwLI08SRbjwVIBQqVQivCs4r7ggRZ/L5aKqqgqAoqIi74EpGKjVasbGxoI2nmdMWZZRFMVbVDU7O5uCgvnVOAt215CZhJrb7aampobOzk42bNjglxvpcQ19bUR3Op1cf+0lFO9P4ZavXxXQGh975CiKWUv1Sw2sX5XKvfdd6Vc4eCHc9y8vM5oTs2hhXVmWiWgYILvZRkKfizyrhnVyNE9o+rnVncTvWodpvmK8zuR8JL8iK+B2w7AT+kfBraByyajkD//v/vDfTBSSH5ZjYDyMHqHXoAbUKmmyyFR9JDTVKnj5Z8exRuiw5cQsuOByUIjW09Y2RE7rEIkZgfWADpTm0k5i1FpWHVjFO2+ewZxmJDp29gs7XYSWrPUJbN2zlTNlZ5ZEnbyJ8xsMBgwGA2lp46LWYrF4RWBjYyMqlWqSCDQYDAsSgeF2+iYmkojw7twIp2/pcEGKPrvd7j0omM3BPYAH20XzjOl0OikrK6Ovr2/G/XCBjBdq0We1WikpKUGSpIDcSM+Bfqroczqd7L98E/k5MbTU9PCbHx5C41JAUVAUUACZcbGoSOPZrHq9Bk2UlnNNfQxbHOzbv4rLvrxmzszeYPDcUx/QHK1FCvFc8piLmKpecvvcpI4orB7RkuY2IH0oNU9jYZViQI+Ka4Yi+f0HnVg2zV5gfCYklQQqNUyoUagwLiCD9YlXFAVtr4Vd6zLo6BlGBwz2W+lxuLAnRIfV8VPSTJx4u4mrblsbEkEhyzJ1bzaxZnUquQXjtfPO1HTh7rQxYHMSO0cB6rh0EwMdIxy44Soe/68/hL1kykzzS5JEdHQ00dHRZGZmIssyIyMj9Pf309XVxZkzZ9DpdF4BGBsbG3BSSLhF38REEqvV6m2fJhAsdS5I0Wcymdi8eTNvvPHGkuieMRcul4vu7m7MZjO7d+9ecFZcqEVfV1cX5eXlASWXTBwLph+0t+9az3d/dICc1f7tXXS7ZZwONy88eRp7XTebt2TTVNdD09le8grnV3DXX8ZsTp58vQZ3CGryAcgDNjKq+skagbQRWDeqw8j08iwuZGq1Y3zcOb7ZPkPRseXcCG/l21CZAtsSsFgoFicXmaO4+bPbeOaPp4jbmoRKo2K0z0pHbR/DA3b6Bmz0alUoMQZYzBO7JOHMMPPuX86w97rAunXMxWi/lfb3Otl3aeGkAs4FK5OwWRwMDdnoqe8ncY6tArmb0yh7vYr/ePD/cdvHbwnqGgMhENHlufg2m83k5ubidru9SSEtLS1UVVURFRU1qTzMXEkh4S7ZMjG8LMK7gvOJC1L0eVCr1QGVGvF3zGAJSUVRaG5upqOjA6PRyNatW4Ny9R4q0TexVqA/Let8MdHp8/DJT9/Gxu3Jfgs+GO9i8NR/n6DeNsrGLVl86gu7cLlk3n6lmsOvVJNXmMTFB3z34l0o933/JQazgxfWlWUZXdMQWecsZFklsoclVtn1aJn9pPqcZoj9zsnu0OVj0TS920XTlTlBWl3wkJ0uto+5uenzOwG49Koinn72NCv25RAdH8mK4vEQmeyW6WseoufcEEODNnpHHAybIyDSd13CoBKhpVdlp6mqm+yi4Fw8tJZ3obPKXHnd+mlJGrkrEnntLxUUX7yCuppOWip7SFuTOONYKpXEim1pPP704+RmZbN169agrDFQFuK0qdVq4uPjiY8fL2DtdDoZGBhgYGCA+vp6bDabt11cbGysz3Zx4S7ZMlH02Ww2Ed6dAxHeXTpc8KIvFE5fMMb0FIkeHBwkPT0dl8sVtHCNZ40LLeDqwVOn78SJE8iyzK5du+Z9ZTvR6QN45umnqWx4j1897n+zeYCHf3SIsWQ9cp+L/TeNZ6xqNCo+dvUaPnb1GqpK2nj8N++iVqv4+O3bgra/79SxRmqcTiT9wg7yssOFqbqPnB4X6aNQOKIm0/VR2HYuWnEQiwYTk0+GKiSuGY7msfc7sWyZX5g3FMiyzJpuK5/5272oPgyJx8RFkR5nwmF1oJsg6FRqFYm5sSTmjjuYDpuTzto+BrotDPTb6HHK46VdQhUKTjJSVtpFekEcmgV8bmRZpu7tJlblJVOww3f4T5IkcgsSaW3qZ8WqFAwGHTUlnWRsnPm9i4o1kLkijh/85N+4+eM3B5TZHyyCGV7VarUkJSV5n4fdbvfuB6yqqsLlck1rFxfu8O5Ep1E4fYLziQtS9HmEzlIVfYODg5SUlGA0Gtm9ezft7e309/cHaYUfCatgib7h4WFGR0fJzMxk1apVCwqreNYjyzLt7e3cdd/fc8+XdmMIwMX56XdfImprIkVb0qh8vJKk1Ol7oYo2plO0MZ2ezmGe/e/3GB6w8vHPbiUhef6Ff2VZ5hePHWdsxfxq8snDdlIq+sgZgdQRWDuiJZb5hWHf1I7wCafvbjLpipZtzXbeKLCiMi8NByKvdYTP3rkT/ZSyLB+7qog//u4YBZfN3KZNZ9CStTGFLMY/06O9VjrOfBgKHrTTq1NDkGvsubJjOfx8DZfePL9uHbYRO81H29m7bwXmOdZWsCqZ116sICM7jozsOCIMWk6faiZjS8qMwia1MJ7BHgsXX7ufymMliy6AQim6IiIiSE1NJTU1FUVRsFqtXhHY3Nzsnb+vr4+IiIiwtECb6DSKki1zo/rwv8WeUzCdC1L0edBoNEtK9CmKQmNjI/X19axYsYLs7GxveZlgl1iBhR+YZVmmrq6OpqYmdDoda9YsvAacJElIkoTb7WbHVRexqTCJK25Z7/d6/u0fXiDj6lxSCxMYszrISI2Z9TGJKSY+f/dexsZcvPRUCQ1neii+pIBNO3MCXvuP/+N1elIDKz0htQySXT9KlkUic0SiyKZHv8CD0auqQYpd0bM2FN8/Fs25oz2cu3LhLeYWSmrrEJ/6xEZi46efGPURWgpXJNPfPYo5ae46ipIkYUyMwpg4PpbslulpGKC3ZZjBATtdg3ZsSdGwgH66AGhUDBsjqD7RyuodGQE9tL26FwYcXHndOr+SiiRJIjsvnvbWQdIyYkhIMrKrOJ/jR+pJ3ZqCxoejKUkSBVvTKDvSxBU3XcOrz70U0BoXymJlD0uSRFRUFFFRUd52cSMjI5w+fZqhoSHa29u97eI8iSEz1QgNJhPDu1arVYg+wXnDBSv6QiGmYP6iz+FwUFZWhsViYdu2bcTExEwaM9h78IAFjWm32yktLcXpdLJmzRrq6uqCtTxUKhXX3XQdSpyaL969xy8R5XLJ3P93z7Dm9rXEZYy7dWXPn+Gu23f5Nader+HGz2xFURROHqnnD796h9j4SK6+eaNfJ6+25n6ONvbBHMkbsksmurqXnG4n6RZYMawmx2mYVaAFwigurGrIcM7ujKqQuHY4it+938Holpn7NIcac/swH79kJZm58TPep/iSFfzhP49i3h948WyVWkXyiniSV4yPP2Zx0FLZw2CPhYFBO31uBXdy9PwSQuIiOXOun5yiBAxG/4RE9RuNrMhOYPX+mZ1LX6xck8prL1aQlhEDgNEUwcX7C3n3rTPEF8VPCn970Bm05KxO5HRFGd/4x2/y/374o4DmXAjhCq9KkoTJZEKSJFavXo3BYPC2i2tra6OmpgaDwTApKSQUnTs8os/jRArRJzhfuGBFHyx+y7SZ6Ovro6ysjNjYWIqLi6cdhEJRTBmY95i9vb2UlZWRkJDAli1bGB0dDaoo/d//+SMnI3r5RF4qBWvm3ndmszj4wT3Psf1vtxAV91E4NFpWE59oDGhuSZLYcVEBOy4qoLmhlz/97gR2m5ObP7+dqOiZT+zf+8Gr2Fb6DuvKow6SKvvIHpJJH4E1IxrildBkz/5ZPcQNzhi/7pvqCfPmWZGCHP70B23nMJevSmXt5sxZ76dSq9i4OZOaml5SVy0sI1ofpaNg+3hdTkVRGOwcpbmqh4EBK4NDY1hMERDj/3sjZ8Vy+C91XDFHtw671UHdm81ctG8FCYmBi1dJksjIiaO7Y4ik1PEyUzq9hov2r+LY4bNEZEYTHTd93QmZZlK7Rnns4FPs2raTm268KeC558NS2VOnVquJi4sjLm4869nlcnmTQhobG6moqJiUFBITExOUrN+pe/oW2unpQkcKQyJHuIuXL1WE6JvHmP4KIEVRqK+vp7GxkcLCQjIzM31+EIPt9HkqxQc65sT1rl69moyM8bCWP23Y/OXNQ6/zTNMJ8tUq/uYb++a8f3/vKD/67kvsvmcH+siPxLJtZIzMD12R+ZKVl8Dn776IkWE7rz5XRnvrIJdes4a8lZM3xj/+uxN0JxnG69h56Bgm68zweNh2FNZY9ESEeA9JiWRlNYY5s3onculYNOeOddN4VU7oFuYDecjG7gQjH7vSvwzqjduzOfWr5gWLvolIkkRsqpHY1PELA7dLpq22l85zgwwO2hmyu3AkG0E/y2FQJWFLiub0Gw1s/liez7t01vVha7Nw3Y3r0WjmLyhWr03jlRfLvaIPxrPUd1+ygvePnaPf6iDOR+Ho3E2pjL7dxFfv/zbbtmwjKytr3mvwB0VRwtoRxFPI3pfo1Gg0JCYmkpg4ngE9NjbmFYE1NTU4HI5pSSHzEa9Tw7uBdk0SCMLFBSv6POHdUJVsmStJwm63U1ZWxtjYGDt37sRonNmRClXB50BE39jYGGVlZdhstmnrDVYJmL6+Pm759pdgZQy3bs0jMmr2EGVTXTe//dnbXPStnWi0k0+m5c/X8rd3XbTgNcF4KO2mz23/sORLDW/9tZrcFYlcclURllE7zx05y9jqBCKre8npGCPdAnlDEgVOA+pF6sfhQqZOM8Z1frp8HlRIXDcSzaOnOhjZtjhhXnnMxWYn3PKpwMqJXHr5Kt44dpYVuwLbQ+cvao2KrDVJZK35MEt0dIzGsm76ukcZHLAzolEjJ0VNDwUb9TS3DpLTMUJc6uTvcc3hc2Qmmdl7VRD2u6ok0jNi6e0eJiHpo4QjSZLYWpxLZUkb3XX9JK2YXMtPpVaRtz6ZitMdXPaJq6k8+sGcde4WgucCMFxOn+dY5M/8er2elJQUUlJSUBRlUru41tZWZFkmJibGKwKjoqL8ErNut9sbsbFarcLpmwNRsmXpcMGKPhi/6gtFyzSYvThoT08PZWVlJCYmsnnz5jkPwKEo+ByIUOvv76e0tJTY2Fg2bdo0bb3BEH2yLLPj8j1Y92Swq3mEyz+5cdb7l55s4tmnTnPRN3dOq20GYFZr58yKDJTxki9FfOzqIso/aOF3vzrCG8+UkeXUkXemg6JhDclyeK7o/2oYYZ9tfieWZEXL9hY7r+dbkOJCu/dIlmVWdlq48+v7AnaC8goSeeetOmSXjGoROnNEROtZXTweelYUhf62EZprehjstzA04sBijgDz+PutpJs59mYjV37YrcNhd1H7RiPFu/NJSQ1e1581mzJ4/S8Vk0Sf928b02k408258m7S1k12o43xkWSmGznTOcKl1x3g8EuHgramqQQiukI5f6BhWkmSiIyMJDIykvT09PFM8NFRrwhsaGhArVZPSgqZycFzu91ERETgdDpxuVxC9AnOGy5o0Req8C74bvjtyXZtbm4OqOdvuJy+idnEs4WfZ+uX6y/X3XgNnRtjiD/Tx11fv2TWcd5+qZp3Tzay+++2+bzfaL+VrKzZOxcslLSMWI5WdZA5qkHvdJPn0JNM8DeE+0MbY5jdGkwL+Lpe4oim8XgPZ68whPRkndk4yBf/z0VotfMLc15z43qe+NN7rLksP8grmx1JkojPMBH/YZKQy+mmrbqXrpYhBgbsDDncOJKiOXawjhVrkxhuGOLa6zag1QW3K4RKJZGaHkN/7yhxCdOFRN7KJPQRGqrf7yRjSh3G9NWJDPXZKOlu5P/c83c89JNfBHVtHsIt+jzHyoWGlyVJwmg0YjQaycrKQpZlhoeH6e/vp6Ojg9raWvR6/SQRqNONRyc8F/2jo6MAIpFjDlSSCpW0yCVbFnm+84UL9lUJVfbuTEkSVquVEydO0Nvby65du/wWfBAap2+u5+5wODh9+jQtLS1s376drKysGQ+iC80G/tF//Dtvq9qRIzXsy0mgYP3MYcYX//ge71W3sfVvNsy4nrI/14as2wbAi8+Vcce3/0xzfhzZ6PikI47BKHgpagQXwX2f/OGUcYztjoU5jCokrhuOJvZkZ5BWNZ3k2j7u+Mw2jOb5l8yIi48mKcaIw+oI4soCR6NVk70+me1Xr+TAZ9ZzzU2r2ZQcBSNj1Bxu4sDVa4Iu+Dys2ZhObUXHjH9Pz4pj48ZMWk+2T/pOSpJEweZUop1unjx8kN//8Q8hWd9SCO+qVKqg7ylUqVTExMSQl5fHli1b2Lt3LytXrkSj0dDU1MQ777zDiRMnqKurY2hoCIvFgtVqBQITfQ899BA5OTlERESwY8cOTp48OeN9H3vsMW+ZK8/P1JI0iqJw3333kZqaisFgYP/+/UGttiC4sLhgRR+ExunzJSa7uro4evQoJpOJnTt3Bmz1e1y5YCVLTBzTF4ODgxw9ehRJkiguLsZsnj08tRDRd+rUSf7lL48g58VSWNvPF/7h4hnv+/jP36bZYmHdLbMLuvhIA0ZT8GtxybLMd77zPL88UstIURKqtiFybVokJLZZDFxqieaQ0Uap1hr0uWficMQom2wRfnfqmI0ktOxtciP1WIKwssnEnu3ntmvWkp7lu2B0IFx743pq3mwKwqqCR6Q5AsXi4rIDRWiidDz06HE+eL85JHOp1CqSUk0MDc78OUtIimbXnnza3+vE5froe6mP0pGzIg5Zlrn3x/dTU1sT9PV5kjjCmcixGH13NRoNCQkJrFixgu3bt7Nnzx5ycnJwu92cPHmSXbt2cf3116NWq3n33XdxOOa+UHnyySe55557+N73vsfp06fZsGEDBw4coLu7e8bHmEwmOjo6vD9NTZO/G//xH//Bz3/+cx5++GFOnDhBVFQUBw4cwG63L/g1EFx4XPCiL9iJHPBRONbtdlNVVUV5eTlr165lzZo18zoYTdwnGMw1Th1PURTOnTvHqVOnyMnJYdOmTX7VsJqv6BsdHeXKu27FtTUNdecI119RRFS03ud9H/7Bq1gTtKy8qmDWMYd7LeTmzFzzbb60NPbyqTsf54RBjSNtXATHtYySLn/0+hhRc+2IEZNaxwvGYUYJ/mdrIqO4cGohxRW8sPIuxUjRO91B/axFtgxx/fYcVm32392eDX2ElsKCZIa6R4MyXjCofKmOnZuzKFqfRm5mLLZME4fO9vCbR4/R0T4Y9PnWbs6kqqRt1vtEGSO4+NJCeku6sVs+EhyJ2TGkRmsZjZC45tMfD/rJfymUawnH/DqdjuTkZFatWsWePXt45ZVX2L9/PyqVittuu43Y2FiuuOIKfvSjH9Hb2+tzjJ/85Cfcdddd3HHHHRQVFfHwww8TGRnJo48+OuO8kiR5k1FSUlJITv6opZ+iKDz44IN897vf5frrr2f9+vX84Q9/oL29nT//+c/BfgnmjSeRY7F/BNO54EVfsJ0+z7iecO7Q0BDFxcWkpMy/z+lC6+rNNObEE7vT6aSkpIRz586xbds2cnJy/L5Sn9g6LRA2X7wD20Xj+wR3WmSumSF548fffpHIjQnk7J271ETJ0zVcfPmqgNYxF3987DhfeeAVOouSYEJGcYJVQefjK1Jo13H9iInTRgdHIkInTF6PtrJzJLiJIxISV44ZSTo6c/gwENS9Fi7LiGPHZSuDMp6H/VespuVU6ELR/iLLMmUv1HLxRR8VmN6yPRt9vxXiDAxnmPjfQ7U8/vh72IMYklarVSQmGxkdnl2waXUa9u4vxFI/xEjvR85g3uY04uwOunVOLrn28qCtCz5y+sLFxBZo4UKWZQoKCrj22mtJSkqivb2dEydOcOWVV3LkyBGfrp/D4eD9999n//793ttUKhX79+/n2LFjM841OjpKdnY2mZmZXH/99VRWVnr/1tjYSGdn56QxzWYzO3bsmHVMwfLlghV9odrTB+NXV+Xl5cTFxbFjxw4iIxeWRRoqp8/z3IeGhjh69CiyLFNcXDypG4g/eEI5gazvpptvpGNdNJJWTWJVD5/7yu5pJwpZlvmXrz5L+pW5pG703ZB+KgnRBiJncAsDxeFw8dWvPc3vK9uwrEycXIcPiJsl8VuLiv0j0ax2R/KCcYQOgrsHrUxjpcClD6gmn7/EoWV3q4K0QCdNtjrYLWk4cOvG4CxsAiq1im3bc2ir9e2YLAYup5uK5+u48sp1JKV8lE2blhlDtmH8MyhJEnKKkfb4CH771GkOvlgetO/x2i2ZlL/fMuf91GoVxftWoOp30N8yPH6bRkXu2mQiLA6qhtr4/JfvDMqaYGk4fYsR3p0NTyKfpxuHSqVi7dq1fO1rX+OFF14gLS1t2mN6e3txu92TnDqA5ORkOjt9X+AUFhby6KOP8vzzz/PHP/7RewxvbW0F8D4ukDHDgXD6lg4XrOiD4PfedblclJeX43A4yMnJYdWqVUE5+E3sRxssPIK3ubmZkydPkpmZyebNm73ZZ4ESSNmWXz30c16z16PERyI7XFycGU/hhsnJGw6Hi+/97TMU3b6G+Hz/9oENdIxQWOifOJyLytI2PnXX/1CWGIkr2XcNRbMfUbE0p4aPj5hoj1Z4OXIEOQiJHi5kGvVOVtjn9175w3aiWfNOz7wFiuyS2dxt55Yv7QqZ67NtZw6j50ZCMvZcOKwOag6e5fqbNmKOne625mTEIk/YSyepVTjSTFSj8Js/nOTUiXMLXoNGoyY+KRrr6NwfREmS2LIrlxhJQ3ddPwDmpCjSE6NQFIUXT73FQ795aMFrgqUh+sLt9HncRpvNtuCL/tnYtWsXt99+Oxs3buTiiy/m2WefJTExkd/85jchm1NwYXNBi75gOn0jIyMcP34cq9WKyWQKel2mUGTwtrW1UV9fz5YtW8jLy1vQydlf0VdZWcE//c8vkFeOh8JWVw9w5zf3TbrPyJCd7//dM2y7ezPGZP9fx7Lnatl7WWFA6/bFQz9/i289/Da9a5ORInyXQZGtDuJt/r1eKiR2jRq4yBbFyyYrVWrbgtb3SpSF3ZbQloCQkLjSYSTlSHvAj5VlmcL6AT731T2o1aE7hEiSxMf2r+LsidaQzeGL0X4rDYeaufHWLRh89LwF2LorB3Ofj0SLCA2WdBNvtw7wX78/Tsu5vgWtZd3WLErf8//5F21IJzPeREf5eGJA1vokEl0Kzgg1P3j4J5SUfrCg9UD4RddSCO96nD6LxeJ35m5CQgJqtZqurq5Jt3d1dfm9PUir1bJp0ybOnj0L4H3cQsYULC8uWNE3Mby7kKxYRVFoaWnh+PHjJCcns23bNrRabUjq/wVToPb19eFyuSguLvb2pVwI/og+h8PBpZ++DseO8Q396q5Rrru8kCjjR+HY7o5hHrj3RfZ8cyeGAEt7xBoiZjwJ+4N11MFdX36C5zoGsebHzyqC9Q0D5NoCS6CIUTTcMGxCo9PwonEE+zxcvzbGiEeDkdCHr2LRUtwBqs7A3LScM/187ovFRBhC50R6KChMQmNVgn5BNBP97cN0n+ri+ls2zVprMCpaT07CzCd7xaRnINXIM8caefx/TmHxw63zhVarJjY+ElsA+wVzVySyqiCZttOdSJLEyu2pRA2NYY1Sc+Odn/TWlpsv4RZ9S2F+RVEmhXf9QafTsWXLFg4d+qhwtizLHDp0iF27dvk1htvtpry8nNTU8chJbm4uKSkpk8YcHh7mxIkTfo+5GIjw7tLhghV9MLmQ8nxwuVyUlpZSV1fH5s2bWbFiBSqVKmT1/4IxZmtrK8ePHycyMpLU1FT0+uDsf/NH9G3eu42R3WleMVU87Obqz272/v1sZTu/+PfXueibO9HO1u/UB73Ng6xbP32fjL+8+/ZZPn33k9Rlm3HHzx2Oie+ykzjPYshrbXquGTFyzGjnuD6w8iinjGNstATnPfOHbUSz5miv36Iq8Uw/t928ifiUmdsKBptrrl9H9RvnQj5PZ10v9rphrv74Br8czBX5iciWmcWYJEm4EiJpjzPwyLOlvPh82aSQsL+s35ZF6anAStikZsSweXMWrafa0UZqyVsRhzTqoE/vZt+1++ceYBZm6nu7WIR7T9/EjiAWiyWg8O4999zDf/7nf/L73/+e6upqvvKVr2CxWLjjjjsAuP3227n33nu997///vt59dVXaWho4PTp03zmM5+hqamJL3zhC8D4Z+zv//7v+Zd/+RdeeOEFysvLuf3220lLS+OGG24I3pMWXDBc0B05PO3E3G53wL0oh4aGKC0txWAwsHv37kniKVi9aCey0PCuy+WiqqqK3t5eNm3aRE/P/Pdr+WKu5/ypz36S5gIdUsS4OxZf3ctn7t7rFYCn3q7n5Zcr2XvP9nmFmcteOMt937tqXmt/4F9f4XDXIGNrk/2udhc/Nh62nS96VBwYiaZZ5+QF4wi7RyKIn6Ojx1sRo2wc1QelJp+/SEhc5TDS9XYb3fsyZ72v8dwAN+4rILcoOPsq/SU+yUiSOQqH3YVuhnD8Qmkp6SDKqWLP1f730F23OZN332uma44e0pJahSPVSI3DRcsfT7IxP5Hivf53HNHpNJhiIrHbHURE+O+uxsZHsWtPAcePnCV5YxKZPRaa3XDG2sOtn/8UTz72P36PNZFwO23hDu96Ls5VKlVATh/ArbfeSk9PD/fddx+dnZ1s3LiRl19+2ZuI0dzcPOm5DQwMcNddd9HZ2UlsbCxbtmzh6NGjFBUVee/zrW99C4vFwhe/+EUGBwfZs2cPL7/88rQizuFEdORYOlzQr8p8EiQ8texOnjxJRkYGW7duneaWLTWnb3R0lOPHj2Oz2SguLiYhISHowtTTis0Xj/3uEV7qrUBOGd+fJztcXJoWy6rNGQC89mwZb75Tx86vbJn3vsKE6Aj0AbqD/b2j3P43j/P62BhjARYNjgtSabMsh5YbR0ycjXbzeuTojIkeo7gYcblJVUIfMp2KGS17OlWoO2YO82o7R7iiMIVNe/MWcWUfcc0N66kNkdtXf7SFBG0Eey4JrOyMRqMie0JW71xIOg3WdBPHe4d55PcnaKjr8fuxG7ZnU3pi7kzeqURF67no0lX0lvWSuiqBeLsDdBpeLT/Ofzz4o4DHg/CXbFkKolOSJFQqVcBOH8Ddd99NU1MTY2NjnDhxgh07dnj/9tZbb/HYY495f//pT3/qvW9nZycHDx5k06ZNk8aTJIn777+fzs5O7HY7r7/+OitXBreEkuDC4YIVfR7BF4hAczgcfPDBB5w7d46tW7fOmPwQqp6+8xFp7e3tHDt2jMTERLZt2+a9uguF6PM1XmNjI//wm3/DVZTgva2oup/PfWsfAM/81wmq2/rY9Nl18567s76PdesDK/x78M9lfP5bf6Z5ZTxygN07ZFnGaAtedxQ1EntHI9lhj+SvJgtnVdMV5Z81Q1ziCl/T9i1EsXaGMK8yZOPiqEg+dsP838OFEmHQsSIvkeEgdxOpO9xEflIsW3bkzOvx6zako/GV0DELcrSe/tRoXjjdxB8fP8Xw0NyJP3q9hmiTHocj8ILgWp2aiy4rZKx5lKQ0I4YRO+5ILT969Fe89Ne/BnwsC7foCnd4d2Lf9UCdvuWKCiksP4LpXLCiz4O/Am1gYICjR48CUFxcTGzszM7QUnD63G43lZWVVFdXs2HDBgoLCycdiBdD9LlcLvbceBn2XR8JMnX3KNftLyTaFMHvfvQmPWoXq29Y2FVn5Uv1fhdklmWZe+99gZ+/Pd5KTZpPdmmfjQx78E8q8fJ4oocjQsXB6BEcH7p+70kWViuGkNTk8xcJiSudJlLfntwFQna42D4ic+Od28O0so/Yf2URLUHsHVzzaj0bClMp2jj/TiLZefFk6AIPOUuShCsuko6ESB79cyl/+tPpSe3UfLFhezYfzLMUjEqlYtfFBZg1OmJUEoy5GDNp+ZtvfIWXXnqJ06dPc+7cOYaHh+dMfAu36At3eHei6Ax1yRaBINgse9GnKAoNDQ2899573tZkc9WyC7fTZ7FYOH78OMPDwxQXF5OUlDTtPsFKDJk43tT17di3i6GdyZOKGhcPurjqc1v4yff/CrnR5O/PWfDcicYov5rbtzX1jbdS06u8rdTmg7FxiGxHaMKsEhIbrRFcMRrNS5ph3mWYOo2Dte7gdt6YDyY07O1UoW4bL/AryzKrm0f4zN27UanCf9WsVqvYsjWLzrqFlUGRZZnKg3UU78gjpyBxQWNJkkROegyye34XWJJKwpVmoilKwy8fO84bh2pnvG+EQUtkpB6nc37t/yRJYvOOHFatTCF20A6KgiVGx9fv+xYJCQmMjIxQUlLCkSNHKC8vp62tDat1uosZbtEX7vmF0yc4n7lgEzk8YdnZBNrY2BhlZWXYbDa2b9+O2eyfUAi2oApkzM7OTioqKkhPT5/m7k0k2HX/poq+O//m89Sny5PalsVX9/Dpr+zlX7/1Arn7s0kqWtgJFaCtuoeNH+4NnI0//uEETxw5y2hR0rTOGoESP+jASGhDrQbUXO4y8YjUTZys5WXdMLIEMgoyoHz4o3Ir6Fzyh78r3h2BOiT0qIhARSQqolB/+DN+m2ae13ObiOLs8X5O3xhNTt0gd9y9B12AeylDyfbiXGoefhdWzK//suySqT54lv1XFBEbH5yT9dYd2Zz64yksAdScnIqk0+DKjuH9YSvV/3WUj+3KZvWa6Q7khu1ZHH/rLNsDSASZyur1abicLk6ebGIsI4ZurZNPf+F2jrz6FrIsMzIywsDAAF1dXZw5cwa9Xk9cXBxxcXHExsaGXXSFe/6JTqPVag16zdYLkXCUUBElW3yzdI7mIUKtVuNyTb8y7uvro6ysjNjYWDZt2hRQdm8oCinPNaYsy9TW1tLW1sbatWvnLLwZyvDu44//kedbTuFa95HDKDtcXJwcw5OPnaDo00XEZs7faZtIzaFzfOr/XjPj3x0OF9/81p+p0kq4ChODsosj3hH6g8Xb0jC9GjdfciZxWBpln8P/EigyCk4UHCg4kBlDZgyFAVx0fPhvz33cEqgUxSsi3Xz0b+XDf8sT/g0Q4YT4V+q54su7MMctrdCVJEnsvXQl77zfSPaWwEr4OOwuzr7SwFXXrSPKGLzMRnNsJNmxkVQFYSwpWo8tWs9fytt552QLH79mDfGJH302IqP0aLQaXC4ZjSYw4eNwuDhxtJH2PgujEiiROjKRsbtlKuvP8OW/+woP/+LXmM1mzGYzOTk5uFwuhoaG6O/vp7GxkYqKCnQ6HTqdjv7+fsxm86Lvr1tKe/rmk8ghEISTC1r0SZI0rRWbLMvU19dz7tw5Vq1aRUZGRsCZaIu9p89ms1FSUoKiKBQXF/t1kAm26PP03m1paeHrP/s+Y3snl/dYWdFLR7SWnf9nK1HxwQtVJpoi0cxQJLeqrI37fnyIvhXxEBFYIeXZiA1S5q4vXMj8j7af9XIku53jJ/MRtQIBROxUSOiRGM8pn+PkF2A+iozC05HDWGI0uMdcvPK/H2C3OHA4XGgiNBRty2LFmuSwOi15K5M4dbQxIMfHOmyn5XAr131iU0icy/zceCrOdqMyBOdzKMVHMSgrPPZSJWl6LTd9fAO6D/cObtqZzfG36ti1b4VfY9VWdVBZ282wW8YWrUOKGRe8GlkBh0Lu+mRSRx28+tZBGhsbyc3N9T5Wo9EQHx9PfPy4szo2NkZ1dTV2u52qqipcLhdms9nrBEZHR4c8s3cp7ekTTp9/SJK06CVUwplhvpS5oEUfTBZodrud0tJSHA4HO3fuxGicX4HZxdzT193dTXl5OSkpKaxatcrvK9xQ7OlzOp1cctMVWC5On+SoSR3D6LWw5xs70UcGT3w1lXWydVu2z7/96heH+UtVO9a1yUH9cssuGfPCuqjNSB12jmktXOeMmdRxw6EsTrcJfzgYMULZ1lhc0VoGhuxc+emPimvbrQ7OnenhjWfKsY2MMTbmQpYgtyiJ9dtz0Ieohp4v9l9dxHPPl7Jin+/Px0SGukfpO93DdbdsClnbuE3bsjla0kpfkEQfjO/3U9JMtLpkHvrvkxSlx3DZ5aswmiJQ6TSzit6BPgtHjzXQO+pkLEqD26gbr2gw4T7OaB1jfVZG+qwY4yPJ2ZTC7Xd9hiOvvzvjmvR6PQaDAaPRSF5eHlarlf7+fvr7+zl37hwqlYrY2FivCAxFrbilEN6dKPoMhvDvxxUI/GXZiD6PeEpKSmLLli0BF2v2NWYwUalUOBwfVfeXZZm6ujqam5tZs2YNaWmBhbJCsafvk3d8mr71MWgb+skYdZNhjiQtPooX32ulI8HEU/96hF03rCR/29x78Pzh7NstfO4H1066zTrq4O+/+SwNMXrc+fFBT8pXtQ6RYwv+1+LP6n6iJQ2fcsZOK75scIMNGUOY86pe1o9waosZV8Z47blTp9s4MKFMS0SkjlUb01k1IdvV5ZJpP9fPiVdrGRm0MWZz4nC5ScqMYdPu3KDtm5tKfKKRJGPknAWbexv7GTtn4aqPbwhpMopWpyYn2USfHNzjAoCkUeHOiqHM6uDMo8fZuzmTbbtyOPFOA7sm7O3zhG/b+ixYJHAY9UgfilBfz1zSqkGvwdYxLvpUahX9lh7sdvusYs1Tp0+SJKKiooiKiiIzMxNZlhkeHqa/v5+Ojg5qa2sxGAxeERgbG7ug4+7E+cMd3vXULRVOn+B844IWfZ4Cmt3d3TQ0NMxLPPki1E6fx5F0Op3s2rVrXgeVYId3H/vD7yhcY+Cq/EQ2F2eTuyoJjUbNK0+X8lJpM93bUumWFc4eOofu2RpiNBKbtqSx/ZpC1AHuPfKQGBs1yZk5euQsP3rkGAOFCeMnrBAQ1zxCujt47sQQLp7VDvIxl5GMGQov73BHUaeys14O396gN3WjHN0UjSP7o72YfYqMy+FCM0tJEo1GRVZBAlkFH9VpVBSFvq4R6j5oo79rFLvVgcPhxmDWs6E4l6y8+SVhTOXy69by3787zsrLc33+vb2yG/2ozP5r1ixKqGfNmhQ+ePsscmxonB8pUsdYto7X6rowlbSSFKlDlmWqqzoprerE4pZxxRq84Vt/nvGoU2bNymSamgdJyIohPsfIl+6+i9//13/P+JiZnDaVSkVMTAwxMTHAeEmngYEBBgYGqK+vx2azYTQavQLQbDbPy7ELd3h3otNns9lE9q4fiESOpcMFLfqsVivd3d3evXDB+nKGck9fb28vpaWlJCUlUVRUNO8r2mCLvupzJ3jg19dOO3m++vYZXJ6QrkqCDDOODDPdisIrzcO8/s9vYFJJFOSYufST64mI9q8UytlTreycUDD3gR++wuGOwFqpzYd4q4IuSI7bO6oRutQuPuWMQzPLqtPRc0ptY32Yorxva0d5a0MkjrzJtSmtWWYOPlPG9Z/cPMMjfSNJEgkpJhKmdKsYHbZTX9nJq6dasI+O7xNEo2LV5nRWbUgPODEhwqCjIDeBkV4LxoTJ3+3m99pJ0EWw9VLfgjAUFKxKJv1IPYH3zQgMKS6S4ViFkbo+mn/2No78WIgzTAvf+oNdoyIiQoNscSHLMroILSdLjs0aQvU3vKrRaEhMTCQxcTyL326309/fz8DAAG1tbciyTExMjFcERkVF+SXOwx3enbqnT4i+C4eHHnqIH/3oR3R2drJhwwZ+8YtfsH277xql+/bt4/Dhw9Nuv+qqqzh48CBOp5Pvfve7vPTSSzQ0NGA2m9m/fz//9m//FhTzab5c0KKvrKyMiIgIoqOjg/rFDFXJlpGRET744ANWr15NRsbCQqTBFH0Wi4W8VTHTDsi//dURsi/O4O3nfWyCkySIi8QdF8kAcMrioPSBdzDKCsmxei77zHpi02ZuYdV0rIO7friNwX4rX/vWc7SkGlGyA2ulNh/ixhY+hguZ/9X2s0aO5Aanfy6tTRW8DiCBcFJj4Y11EYytiJv+R5Oe0sourg/SXNGmCDbsymHDrhzvbY4xF811vbz9QiXWYTt2m5MxFWQVxLNlRw6R0fqZBwQuunwVjz38DsYDH4m7s+80k5ccy9pNwdlm4C+SJJGVYqbJagu5KJF6LOT2yVgdKnosLuSo2V+nmVDMesorO1m/LpWy6g7SViUQl23k33/0Q+799nd9Pma+oisiIoK0tDTS0tJQFAWLxUJ/fz99fX3U19ej0Wi8AjAuLm5a+8uJ84c7vKvVar3hXSH65uZ8cPqefPJJ7rnnHh5++GF27NjBgw8+yIEDB6itrfVZC/fZZ5+dtCWrr6+PDRs2cPPNNwPjFwSnT5/mn//5n9mwYQMDAwN87Wtf47rrruO9995b2JNbABe06Nu6dStNTU0MDQ0FdVxPKFZRlKCEjcbGxmhubsZut7Nr1655J5hMJJjC9Dvf/Ro3fnFyv0eXy0VVay8RIzpI8uOgF6XDsTqRPqDP6abpD2XEuBRi9Sq2XZFP9rrJJWiyEo289OcyfvVMCdb1yfPrrDEPYhaYuXsWO0e1o9OSNeZClmVklEVtHfSB2spf1+iwr0qY8T49Khizu0KWpKHTayhYm0LB2o/ef9kt09E2xImjDYwO2HA73TgcbmLioti0M5vECQ6iWq1i0+YsGhoGSMyLpfb1RtatSqVgVXJI1jsXW3dk88FTp7EmhXCfV+sQa885WOc0cFItE9U2xtkoDap5CD9JrWLA7sBkNhCpVuNyyRhMep596amgi75J80oS0dHRREdHk5WVhSzL3tIwra2tVFdXExUV5RWAMTEx3v2ASyG8GxERgdVqRVEUsafvAuEnP/kJd911F3fccQcADz/8MAcPHuTRRx/lO9/5zrT7x8VNvlB+4okniIyM9Io+s9nMa6+9Nuk+v/zlL9m+fTvNzc1kZWWF6JnMzgUt+rRabcj23ymKEhTR56kXaDAYUKvVQRF8njUGy+nrGa4nMXlyK7V/++GrFN9cxJM/OwE5ATpwWjWWDDMWoE1WqHu1kdg/n8GklSjalEpktJb3Pmjj6cYe3JtSF00GyVYH8bb5z/a8eoBIlZpPOeOmJWvMRY5TSzcuUghe9udsVKqsvLBKg23N7AW0x7LMPPc/p7ltEduwqdQq0rNiSc/66HOlKApDAzbOVnfywfFz447gmAudTsPazelYSlvoreljx45cMrJ9uJaLREKykWxTJNUhGFtRFFQNA+xqUchWxvft6ZEocOmxnB2lY60W1TwujuyKgizLrN2QzvET58hYl4QUrfDkU//LrTd/0vc6giy6PFm/sbGx5Ofn43Q6GRgYoL+/n7q6Oux2OyaTibi4ONxud1jLcXj29Hm6lYg6fXOjklSLXrIlkPkcDgfvv/8+995770ePV6nYv38/x44d82uMRx55hNtuu21W53doaAhJkrz7XsPBBS36IHRJF7CwK05P+7eGhgYKCwvR6/WcPXs2aGv0ZJctVJhWVlWyYXvqpNuGBqwMq2RMCVFY7a7xUO68FyoxlhxNJ9CpKDSc6SetvAtjuhmnMVi76/xDd26Q3Hlk7g7j4hntIJe4osl0zy/MtoVoDmtGSHGFXvSdkWw8U6jCtmF6yGIqUpSOmoqekK9pznVIEjFxkWzdnTfpdpvVQWNdD60tg+hUKuprukhKNXlr2oWD3OxYKlv6UAVxDYqsoKntZX+nhrgJFwYxspph3GxxGHi3pp+hNTO7tjMhG7S0tw2RkRlLfEwkdqsDU1IkDz/6C5+ibzH21Gm1WpKSkrxhNZvN5i0NoygK77///qTSMAaDYdGEoEf0WSwWJEkSJVuWOMPDw5N+1+v107YO9Pb24na7SU6eHCFITk6mpqZmzjlOnjxJRUUFjzzyyIz3sdvtfPvb3+aTn/wkJtPMW5tCzbLvvTvfMYF5j+u5qmhtbWX79u1kZWUFfZ2eg/JC3D5FUbj/gX/gwPVrJ93+wL+9yp5bx2+TNUHcWyNJJPVZKViTzMO/uY17dxSwqcOC9txA8OaYhYQOG4kBOm1HVSO8qh3hU844MpX5CT6ACFQMq0O/r+8cdp5YAdZNs3d0mUi/GqyjIaxYvQAMkTqOvFXH5htWYUqKYvPOXE4daeCvz5RScuJc0Dvn+MOm7dkkDgZhc+iHyA4XERXdXNepI27KdXqKoqUVB1okNlsjiDg7j++KUc+Z+l4AVq9Joe/DMUbcQ5w+PX3vUTgSKQwGA+np6RQVFQGwbt06TCYTPT09nDhxgqNHj1JdXU1XV9ekfVahwPP8Pfv5RBHgpU1mZqa3y4zZbOaBBx4I+hyPPPII69atmzHpw+l0csstt6AoCr/+9a+DPn8gXNBOnyRJM7ZhW+i4890zNzAwQGlpKWazmeLiYrTacZERirp6MLm8QCC4XC4qKyuJMDvQTnAsGuq60KdHoYvQ4LC7cOmCJ/pMLUPsO5CPtX4IjUbFNZ/YwDWf2EDJe808++dyPmjpp39FPKp5loCZi/gx/N5T50LmCe0Aq+UIbnTGBGX+UBdpbmfs/7N33vFt1ef+f5+jLUuWvPeK7ey9ncEMScpoGaXQRYEuei9ddN7f7YbbveiiLaUtlE2hFCiFQCAQyB5OYiexnXjFe8i2rD3O+f3hyPGQbUk+stPE777yKraOvudrWzr6nGd8Hv5WHMS5Ijuq5LOnKIlnHzvERz+9Lm57i5UHf/MWOWuzMaclgF5FglnHxqvmAtDUYOOtV07icfmYvyyXguLoo2CxoDdoKEw3083k/56yy0diVQ/v6dWHnaesQySgAoKQiIqFfUHKW/sJZEVeJiIIAv3+gWukKIrk5iTR1+HAkm3if7/7Nf79z+3Djg/59E0HoWtkKNVbWFhIMBikt7eXnp4eGhoaqKysxGQyDTaFWK1WRRs/hqZ3jUbjjOiLgOls5Dhz5sywyFq4BqHU1FRUKhXt7e3Dvt/e3j7hyFOn08mTTz7J9773vbCPhwRfQ0MDb7zxxrRG+eACF33AqDFsShFtZE6WZerr6zl16hSlpaUUFBQMu1jEY4IGxBbpczgclJeX8867b7D1hgXDHvvV73ay+fMDdzNV7zbiNEdmwTIRQo+TVfkW5m4s4Ej9sWGPLV2Zz9KV+XR19PPoI/vZd7yVhowERIuybv+Rjl+rxcPOs80aiVE0a0yEPggeJPRxCMB34uPPRX4cq3Oi/pAS9GpqTk1/inckf/rd22StzCIxbaCGpmBFFjvfqObyzfMAyC1IJrcgeWBu9bFWtj1fQTAYZN0VpViS4luHNWdOBgf310Fi7K9Rsd9LalUfV/aPv1fVEAmfI2npb/Vw0uhGsESedvQKwuA838JZKex6t5bEdBOdjjZaWlqGWUxMp2VK6Ho2VMSpVKpho+J8Pt9gPeDJkyfx+/1YLJbBdLDZbJ6UUBsp+mY4v0lMTJxQaGm1WlasWMH27du5/vrrgYHX2vbt27n77rvHfe4zzzyD1+vlIx/5yKjHQoKvpqaGN998c/A1Op1c8KIvHuldiE6k+f1+jh07ht1uZ9WqVWGLOOMR6QvNy42GtrY2jh07Rn5+PoeP7+CaT24dfOydHdXkLM8cLBY/daiVoFWBehZ/gKWeIJfcthhgzFFZqelmvvDlK/D7gvzj74fZsauO41KQYL510luQZRmLe+L06gvqHvSCig/H0KwxEWuCCVTHwaS5hwB/zPfSvzb6OdODa2gE7L0uEq3nx4fcQ7/bSeayTBKHdI6bko3U9zWPOlYUReYtyWHekhx83gDl+xroaLWjN2jYcNXsuNT/zVmURe6eWppifL7a5qbwtJNVjonfX7oRr8M5QR39dS6aFuoijopLJi2nazqYMy8TQRAoKUmjvq6HlHwLX/jq3Tz96HPnjp1G0Rdq4hjvdazVasnIyCAjIwNZlofVAzY0NCAIwjBrmGhr8obW9M1E+iJDRJhSZ4LQOaPhnnvu4WMf+xgrV65k9erV/PKXv8TpdA528952223k5OSMSg8/9NBDXH/99aMEnd/v5/3vfz+HDh3ipZdeIhgM0tbWBgx0/mq1ygRMomVG9E1i3UgEVV9fH+Xl5ZhMJtatWzfmHzokIpWygQmtGanokySJ6upqmpqaWLx4MQkJCWQXDu9CeubFo2z9/JrBr51eCRSwUilttHP1/2wY/Lk1E9QJarQqPvChlXzgQyvZt6uOf75UweHmXvrmpMTeWGNzke4Y+/fuIMAzmh4uC5jJn0Tt3njkouOA2s1iBUuSHAR4INeFfV3epF5X3qIknn7kIJ/43EblNhcjf35gJ+nL0knMGN0lZ0gxYO9zkzhGlEurU7P67Ogye6+LAzvr6Ot1kZaVyPK1BYqJGVEUKMiy0OjyRL2mts3BvDoP8z2Rvc6skoo+AljOXs4FBJb7DbhP9NC9ICmi8wsGDfWtfcyZN5DKyshMpL6uGwSobakeNpptuiN90ZxbEASMRiNGo5Hc3FwkSaK/vx+bzUZ7ezvV1dXodLrBhpCkpKTBkpvx9hCK9M149F043HLLLXR2dvKtb32LtrY2li5dyiuvvDLY3NHY2DjqtVdVVcU777zDtm3bRq3X3NzMCy+8AMDSpUuHPfbmm29y2WWXxeXnmIgLWvSFavqU9NQLMZGYlGWZxsZGqqurKS4upqioaNzzh9IV0yH6Ro59S0hI4Dv/91Wu//A5b74n/raPeZuG/wyu4OQjkzl1NrbeuRSd8dyFVh2FkFy9rojV64pobe7lsUcPcOBkG2dyzIgTmPqOxFDTQ7EU/jl7hH7OaPx80JeCJs53q25BuWYOFwF+leOib30uwiTnzgpaFfUd/QrtLHb+8sBO0pakY8kI742WvyyTt14/yXU3LQv7+FASrUY2XDUHgJYzPby9rQpnv5f5S7MpKp24s3kilq7I4+DzR/GkRSYMZFlGf8bOyoYA+YHIX7+ZsoZjuAZFHwykfFd6dOyp7qN/7sSWSoIg4Bzxfp6/IIujlS2kFln54lc/xwO/+uPgPqdT9E2mPk8UxcGC/qKiIgKBwGA9YF1dHRUVFYOj4pKTk8OOigu5NoQifTNcONx9991jpnN37Ngx6ntz5sxBlsNfswsLC8d8bDq5KLp3IfZO2/HWHWvNQCDAkSNHqK2tZcWKFcyaNWtCIadEt224NSf6uW02G7t27cJgMAwKPoC6pkMkp5oG97TnWBOFC8+1s0uSNOpDIloSW+xsvLyItKLhH0rRiL4QWTlWvvy1TTz8wK18piST+Y19CE32iZ8Y2kuXj8QR90ABJP6R0ItepeJGX1LcBR9AUJKQmfyFwoPE/Vku+jbkKmZs3atX0d3pUGStWPjL73eSuiQNS+bYZrganRpfDMI5Oy+JK65ewDU3LyPol9n+UiWvPHeEnm5nzPvNzLGSH6FhsizJJJzu4bLTEvmB6NI+OkR8Yf7ERlQs7ldhqI/sfRAQRTyec2Fmc6Ieo0aNoBY5WLF38No03eldJc+tVqtJTU2ltLSUNWvWsH79enJzc/F6vVRWVvL2229TXl5OY2Mj/f39g9mYWGv6fvvb31JYWIher2fNmjXs27dvzGMffPBBNm7cOOhfuGnTplHH33777YPp7tC/rVu3jrHi9CEiDDZzTNm/KU4n/6dw0Yg+pTt4xxJ9drudXbt24ff7Wbdu3SjX7on2qaQ4HS8FLcsydXV1HDx4kJKSEhYtWjS4h6PHjrJo5bmOpft//garb5gz7PmtVd04DbEHioU+F6uzzcy/rHDUY9HOYB2KTq/mI7ev4fe//QD33biUdT1eEk52TiimkzzDhUIDHp7R9nCZ08SiwNT5cBX6NbQzudeqD4lfZPTTuzFH0UkmviIrT/9tesYH/eHXb5G8MA1L5sRdqZb8ROpPx9Z4IooCsxdmcdV7F7HpvYtoONXFtn8e442XK/F4ov+7FOZZkQLjv/bkgIS5qpstZ1SjLFkiRT3GTWUqGmZ3BlF1uyZcQ7bqqaxoG/a9hYtz6DzZjTZZxQ9+fN+g9+d/Sno3WnQ6HVlZWcyfP5/169ezcuVKUlJS6Onp4dChQ+zatYt9+/bxhz/8gaampqjSu6ExX9/+9rc5dOgQS5YsYcuWLXR0dIQ9fseOHXzwgx/kzTffZPfu3eTl5bF582aam4fXrW7dupXW1tbBf0888cSkfgczXNhc8OndUENDvCN9sizT3NzMiRMnKCoqori4OKo0behYpTt4w4kdv99PRUUFfX19YRtL/vzoT/nYPQNdux6Xjya7k3m5lmHHHNtRjzfWJg5/kKWeIBs+uyTsw2oFvP8EQeCSK2ZzyRWzaazv5vHHDnLgRDutBRZE4+hIStIQW7VX9XZ0osjNriTFmzUmYuUkTZoDSPwizU7vJXkISnooAoJaxRnbxOJBaf7w27dJX5pOUnZkNiRZc9M4+FI1hcXjTxuZCK1WzfKygZm+/X1uDu2qo7vLSXqWmVXriyISHyvWFLLvr3vpHWtUoSdAck0Pm7q0YS1ZIt7rOK/TQvT017k4ZdaOaxgtaFS0dwyPbGq0KlKTEggK8PL2F/j6V/534NhptGyZKsE5dFRcXl4ekiTR1dXFtm3beP755zlx4gRms5nPfvazbNq0icsvv3zcLtFox3w99thjw77+05/+xLPPPsv27du57bbbBr+v0+kmtBWZbs73iRwXExfFbyUeti1DBVUgEODYsWNUV1ezfPlySkpKorfFGFJ/GI89hujv72f37t0EAgHWrVs3SvBJkoRX6kCtGRAM//d/r7Lh1uHmzAC2Hg/oYrtnmNNs5+q7VyOOUWcWS3p3PPILU/j6/27mbw/cwidyU5lT2wtt5+rTpIBEqlvAQYAnEmzMDerZ6EqYcsEHkzNpDiLxy5Q+bJfkIGjiM5C+L0FDa3NvXNYOx4O/20naolRSciL3thJFAQxqRd9LZouBDZvm8L5bl1NUksabr5zkn08c4vTJ8FGaEEaTjsKU8Olo0eEl60Qvmycp+CA0mWPsSOQC2UB2Rc+EvxN3mMdL52Vgr+9DMvh46uknB/Y+jeldJT33okEURUwmE1deeSV79uzhjjvuYN26dciyzNe+9jWSk5MH566OJGTIv2nTpmHrRTPmy+Vy4ff7R2WPduzYQXp6OnPmzOEzn/kM3d3dsf+QM1zwXBSiL15TOYLBIA6Hgz179uB2u1m3bt2kfHji4dU3dL2Wlhb27NlDVlYWK1euDNtJ/Njjf+aKawbMbTva7AQtagzm0XVJ7glSVmOR29DLpo8uRpcQvm5pwCssPhd1g1HLHZ9ax4N/uIVvb13Imi4PhuouaOrBKwV5w+TiBqeFXP/UzL8dC38MJs0SEr9O6qNrYy6CLn779xdY+Pujh+K2/lAefGAnKQtSSB0RZY6ErAVpHNhdr/ymGKjVu+rahbzvgyuQZZnXX6zk5b+XYxuj3rG4OAXJMbwlW93jpvBkP5f16hAVuAxnnZ3MMRYiAkuDBlKOjz+xI6hVY+91D3+uKJCTk0QwKPOHh3979nsXZnp3IobWFEqSxMKFC/nNb37DyZMnqa2t5XOf+1zY54035itk4zERX/va18jOzh4mHLdu3cojjzzC9u3b+dGPfsRbb73Fe97znrg4VkyGKa/nmwYz6P8ULuj0boh4ib6+vj7q6uooKCigpKRk0hcjpSN9ofUkSeLkyZO0traydOlS0tLGTnvtP7aNT169EoAf/eR1Lv/vFWGPcwWjj0aZW+1suKSAjOKx6xydNheJkzC0jQRBENi0dR6bts7jdFUHX/30UxxIDbLFplbQajl2tFGaNEtIPGDto+2SHDDGV7AKKpFmu3viAyfJgw/sJHleCql50Qs+gKTsRCoOVrOaWRMfHCOiKDB7QRazF2Th9wc5dqCR/e/UodaIrL9yNnrDwN9i0Yo8dh1opNU0cKOjbnUwv97DgggtWSJhsJljnMuHDhWL3RoOnOrFWWINe4xs0XGsopX1G4b/3nILk2jfW48rUaa6pprLL79csb1Hw3SLvqHdwy6XC5PpXBQ3Pz+f/Pz8uJz3hz/8IU8++SQ7duwYtM4BuPXWWwf/e9GiRSxevJji4mJ27NjBlVdeGZe9zPCfzQUt+kIpVqVHsQWDQXp6enA6nSxbtmxcERUN8Yj0eb1e9u7diyzLlJWVjdtt1tvbiylp4Pd09OAZkuckDaZ5h2LvdOKM0gJE6HWzNjuR+ZcXjnuco9tNrnXqvK+2vVDBZVvn8nSHnadkmRdaHVj6PGS1+3lPt440pt5Ac03QSI3oYVGEJs0PWuw0bciGMaKnSmNP1FFX3UHR7MnbmoTjT3/YSdK8ZNLyYxN8IbRWHR6PH70+/pFbjUY1WP/ndHg5vKeBnm4HKWkmVm2cRUGmhRa/D/0ZO8vr/RQGlfd61MkTiyErGub1eDnS5sAfpgtaUIn0uUZHDAVBoKg4jdrmbh5/5mHu+vRdiuw5WiZr2TJZhqaXXS5XxMbOkxnz9dOf/pQf/vCHvP766yxevHjcY2fNmkVqaiqnTp2aEX0zhGUmvRslTqeTPXv24PP5SEtLU0zwgfKRPr/fT21tLWazmTVr1kxoL/DzX3+Pq28euKj86dE9LN9aEva4yh31OK1RROMCEit8QdZ/dPwLFoDDNraxrtL8/mdvsHrjLG65fQ3qfg+kGHEvTKdtfQ6Hrs3jR1fo+L+VAX5b6OJtnYOAArNUIyEPPS2qyG5S/pzYS8P6DOTE+BhGhyOQb+H5vx+Ny9oP/eEdrLOTSVdgykre0kzeeu3E5DcVJQkmHeuvnM21H1jOrDkZvP1qFY5eN7rDLVxyOhgXwQegjzD4noOOWU0+JKc37OO+MayYUtJMaPzQH+ylpaUl1m1OCqUtW2I5/1DRF2n37tAxXyFCY77KysrGfN6Pf/xj7r33Xl555RVWrlw54Xmampro7u4mKysron1NFYIgTsu/GUZzwf9WBEFQrJGjra2N3bt3k5KSMmp2rhIoFemTZZnTp0/T19dHamoqCxcujOju2OFvwJJk5F//PErx+rEnOJypsYEp8qjSnJY+Nv/XqjEbN4bi6fNgNsc3vQvwx1+8yYqyIpaszCc51YR+RI2ioFURLE6ma1kGNZtyef696Xx3A/x0kZeH0x20EP4DUync4sSf4A+bejlVlo6kxCi8KBBEgbYxBMNk+PMf38VSaiW9wKrIegazjn6vslZN0ZKRbeGKaxZgTjKgQqRB68cTp5uHRET6I7T7mSPryT/ZjxRG4PkTtLQ1ha/9K52XScDt5/Nf+e9J7TVWpju9O1R0RjuR45577uHBBx/k4Ycf5sSJE3zmM58ZNebrf/7nfwaP/9GPfsQ3v/lN/vznP1NYWEhbWxttbW04HAO1ow6Hg6985Svs2bOH+vp6tm/fzvve9z5KSkrYsmWLgj/1DBcSF3R6N8RkI32hmriWlhYWLVpERkYGDQ0NcakTnGykz+fzcezYMZxOJ6mpqcNqTsbj4KEDFMwesMR4dWcNVw8ZtzYStyRDhII3p7GXTR9ajD5Ckeix+zBGaGgbKw/+cgdLVhWwbHXB4PeMKpGxbIcFQUC2GnBYDTiApkCQ460OzDYv1i4vc1slLnEb0Sp4DxU4a9I8Vgfx4wl9VJWlIaVMz0QAe7Ke40eamb8kR5H1/vLguySWWEgvnHh6RDQkZBjp6ugnNT0yu5d4sOetUxzodqBNNrKsTqBK6yUgSSwI6BVp4giRhpYTOJkTwWVdQGCJZMR1vAfbouHNZ1KijuqqTjJzR/8tEkw6LAk6ahqrho1mmyrOp/Su2+2OSvRFO+brgQcewOfz8f73v3/YOt/+9rf5zne+g0ql4ujRozz88MP09vaSnZ3N5s2buffee9Hppi7yHwkCoqKv9UjPOcNoZkTfBLhcLo4cOYIsy6xbt24wRap0Kja05mSEZGjOr9lspqysjJqamoj3+Len7udjX5rPgw+8w9Jrwqd1Q0TaxGFutXPJxnwySiIzqAbwOX0Yo4giRstDv3qLhctzWbG2cNj3TWoV45tvnENQq/DlWejOg27gtN3DjlYHlj4fqe1eLm3TMIvJfRgW+DV04CcjTE3hM8Y+KlenIEU43iseBLMTefmFSkVE31//9C6mWcoLPoC8JRnsfKWaGz4QviEp3lQfb2VHZQv+VCNSIEgvXub79DgJckznJdEvUjTG+L9o0SNGZeutRmCpR8u+KhuOOefeo4Io4PSNfR0qnZfJ/t21fPErn+OBX/9xEjuOHkmSUKun72MrJDplWY5p9m40Y77q6+vHXctgMPDqq69Gdf4ZZrjgRV/I/y4WMdXR0cGxY8fIyspizpw5w+4w49ERHOms3HA0NTVx4sSJYXN+I11PkiR0ZhcgU9nYydZrC8c81ucJ4JQiEH19HspyzMy7vCjyHwIIegKDXY9K8+ff7GTekhxWrRvd0WkZx7R2QhL1OBP1OIHmoMTxNgfmbg9JNh/FLUEudxoxRHnXuRITu9UOMkaM5Hre0MeRVUkEsyKL4MYLQRRo9/gnvc7Df9qFschCRpHygg9ApVYhaabHuqGzvZ9X3qyhP23gRjGQZOC42cnGfjUJqFjqNdChCnBQ56LIq415GsdQoh0VaEbNArtE+Rk73rxzXogeIWSfNPp1q9GoyMiw8O6+t6c83RoMBsNaTU3l+UM/r9PpjDiTMsMM5wsXRfwzWoEmSRJVVVUcOXKE+fPnM3/+/FEphXh6/0VDMBgcZgw9dM5vpKLvL4/8kbVXFPKj+7ax7gPzxz22Zs8ZHOYJLroBiRXeAOs+PHHjxkhUKjEubv9//e07zJ6fyer14S08cjPMyArUfwkqkUBOIj2L06m9LJfX3pvFfZeK/Gipnz9lO6gSIrM7MSDi0gwX1y8a+tm/MolAFEbF8cSRZuTwnvqYn//IQ7sxFJrJjJPgC5FSnMyJo80TH6ggXo+ffz5XTnvaufS7oBKxW4YLu/SgmhVeA30aiYNaF75J1vvFMh86Ey0lbQHoO/fa9Ft01J8aO/ZdVJqG5Pfxgx/fF9M+Y+V8Su/GMnv3YmWmkeP84aL4rURj2eLxeNi3bx+dnZ2UlZWN2QV1PkT6XC4Xe/bswel0hjWGjrQxpKL6TdIzzfSpJRJTx09X1BxsJWgZP3U5u7mPq+5agRjDZA11HKIGjzzwDrPmprH2kuIxj9m4fhZin0fxc2PS4pqdQtuqTCrek8+frrXw3bVB7p/j4fnEfpzjJOT8Qz6/Xzb0885KM8G880PwAQQzTby6rSqm5z7yl93o8k1kzoo89R8r6cVJVB5vjft5QkiSxHNPHuS0JYypeYJ6VBe4gMAsv5YlPgOntD4q1W6kGMWfCVXEzRxDKUZPwSknkn/gubJRw5nGvjGPF0WBwlkpPPHMozHtM1bOh0aOWLp3Z5jhfOGCF33RdO92dnby7rvvYjKZKCsrGzd0P92Rvo6ODnbt2kVycjKrV68OW1AdSd2hzWYjOUvgx/e9yoYPLJjwvA5PEMYRc9mNvVz1oUUYYzRYVik8gu1vf9hFfkka6y4tHfe4xSsL0Dri25EriAKBTDO9i9KpvySHHe/N4f+u0PDD5X7+kOvgqOga9mGvkWS8SLypd/LWchNCnjWu+4sWQRDo9AaiLkn421/2oMs1kTWOSbeSCIKAyqQhEOMUmWh59YUKjiIhhkmNelONVOrCT87QILDAp6cgqOWIzkujEP3rMQMtLeNM5hgLAYFFkpHMyl4kSUIQBJxjWLeEyM5LQiTIk089HvX5YuV8sWwJBAL4fL4Z0RchAxMyxCn+NzORIxwXvOiDicWULMvU1NRQXl7O3LlzI7I4ma5InyzLVFdXc+TIERYsWMC8efPGvAhGst4vfv09SuanIeYa0UZQS+cep4kjodXOpRvzySiNfRSdknN3H3twNzmFSWy4fHzBB6DTq9FP8axdwaDBXZxM+4pMTmzJ55H3JvGN5QF+PtvFM5Z+Cj0aXjDaeXNZAkJBfFOgseLMMrFnx6mIj3/0r3vQ5BinTPCFyFmczq4d1XE/z96dtezr6EM0hi+BEPRq2i3jv8bNsorlXgNaUeSg1kVfFJE7PSJ+YpvdrEJgqV9P8sleAHxqAa9n/HPPWZDJvd//bkzni4XpjvSFzu90OgFmavpm+I/johd9Xq+X/fv309bWxtq1a8nJiawbUenpGTCxkPR6vRw4cID29vZxU89D9ziR6PPIzTz6t32svX7ehPuTJAnHWNESu4ey7OgbN0ailOh78qHdZOYkcsmVcyJ+ToLCUcZoEESBYJoJ94oszlyax7vvzeXpJSKueWYWWvWk1XQj1tmQJvgQnmqkVCM73q6L6NjHHt6DOstAdknsNwWxYk5NoMM2limPMpyqaufNI2fwTeCb6DJH1rCRFdSw3GegUxvkkNYVsTm4ehK1TAZULHCqMdTb8Vv1nDw2vglzUkoCeoPMtm3bFJ16NBbnS02fy+UCZkRfpAiI0/JvhtFc8N27MLaY6u7u5siRI6SkpLB8+fKorABCbftK3nmOJyR7e3s5fPgwSUlJLFu2LKK9TiT69uzdjdvfT9qStIjq79qqu3EawlxwAxLL3X42/PeqCdeYiHDdgtHy1F/3kpKZyKWbJxayQzGFGTk3XSR1OvnoTUtpPNXFB+5cgyTJtDb1cuxIM63t/XT1uOnuc9Pt9dOfbIAkw7REQARBoCsQmPB98PjDexEzDGSXpk7h7oajSzHgsHswxWG2c3eng3+9fpL+9InTfW6LjlacZEUw4k9EoNSnw4fECa0X0SezgPGbB7SxBfoGSUXDnE4Px0xeOn0TLzZvcRZf+39f5Oc/+Q0Wi4Xk5GRSUlIwmUyKN2WdL+ldl8uFVqudVvuYGWaIhQv+FRuybBl6FyrLMrW1tdTW1jJ37lxyc3OjvjiF7jaVFH3havBkWaaxsZHq6mpKS0ujmgQyUTTyyed+R31XL5fcHJlYO7ajHm+YKEZpcx+bv7AmpsaNkUy2pu/pR/ZjTTFy+ZboBB+ARadGluW4dA9HQ0pjH3dcMYcNV87mr795G4/bj96gISc/iZz84WleR7+Hk5VtnKrppKvXRVevmy67lx6tQDArEXEyVjQR4spN5LWXj7Pl2oVhH3/ib3sR0vXkzJ4+wQeQvyyTHa+d5Nqbliq6rs8b4Llny2lLicyYR7LoOWntJ6s38nNoEVnsM2DDzx6xn1xJSy7h/f3MZ5s5zJO4vBegp7/exZmUiW+EjAk6EhIF0tPTsVqt2Gw2GhoaEEWR5OTkwX9KGAZPd3o3JPqcTidGo3HarxUzzBAtF7zog+GRPp/Px9GjR3G5XKxZs4bExNi6IUOiLxgMKna3N1KkBQIBKisrsdlsrFy5kqSk6Oq6xmvkkCSJihMVzL95dsQXLpvNA5nDJxtkNvay+YOLMCo0L1cziUjfc4/tx2zRceV7Jm5ICceC0gz2NXZFNWJOaTIa+vj4exaweuOAtczl75nPsYNnWLUhvNWMyaxn5dpCVg4xmw4GJM402Kg42kJbZz9dvW66e910+4O4UhMQk5Qd2yYnGdhZ3hxW9D3xt32QoidnzvQKPgCtXqP4CDRJknnuqYPUJmojFiOCKOC0qKE3+vMlo6FM0lAneNklOFgi6UkYcRlPR0sVrkmJPoD5sgGHzUFvtxMZ6Otx0d/jxucOIIsCiKDVqRFFAUmS+e/Pfpodb7xDTk4OkiTR399Pd3c3zc3NnDx5EqPROCgArVZrTGna6U7vhs4fEn0zREaouWKqzznDaC4K0Rfq3u3p6aG8vByr1UpZWRkaTewmwKI44CenZF3fUJHmcDgoLy9Hq9Wybt26mO6Sx0vv/uHBX6FJ05G3OCPi9UY2cehb+7l8Qz4Zs5Wr0VLHeEF//omD6IxarromfLQpEjZcWswjv21CmibRl13fy6duWMLSIePhCopTeXd7dA0IKrVIYXEqhcXDhVZfj4vKoy3U1dvo6nHR1eemu99Lj0GNnJUYtts0UmzB4Cgz3ycf24+coiV37vQLvhCWPDONdV3kFymzp23/quBoMIioj+41407Q4CGIPsa6oyJZR4GspVL04JG9LJUNqM+uZUDEF2Mzhw+JJrz0E0SFgF4SePu1apaszCPBrCc1IxGNVjXqRlGWZY4fsg1+LYoiFosFi8XCrFmz8Pv99PT0YLPZqKqqwuv1YrVaB0VgpKng8yG9K4rijEffDP+xXPCiLzSZIhAIcODAAWbPnk1+fr4iYXmlO3hDkb62tjaOHTtGfn4+paWlMV/kxhN9jz/3MBs/vySq9YZZOPR7WZ+ZwLwrJte4MZJYGjn++dQhVFoVW65bNKlzF5WmoXP7icw+WVny63q569YVzF86upHI5YregiMcliQj6y4tYd2l577n9wWpP91FZUULHd2uwRRxtyTjzTQhmiK72QjkJPLS80e5/v1LAXj6sQMErRry5qYpsnelyJ6Xxp4XahQRfQf21LG3uRchOfrIqS/FyDFDN6vcsdcXiggskgy4CHIMFwmIzD5b7xeJSXMAiTZ82AggIiAgYEAgGTV56BAQaMVHh14mK3/8LIMgCHg8rjEf12g0pKenk56ejizLuN1ubDYbNpuN+vr6iFPB50t6NyT6ZtK7kTEdjRUzjRzhueBFn8/n48SJEwAxpUjHIx6iz+12U1FRweLFiwcHcU9mvXCir7m5GWOejqQoJjvYO504xbMXOEligc3Nhs+snNT+whFtI8dLz5SDKPCe90U//WMkoihiEIQpF31FdT3898fWUDIvM+zjiYl6em0urMnKRxY0WhWl8zIonXfutSbLMj1dTiqONNN4ppfOXjddfS66HV56E3SQYRoVFRTMevYfb+N64JnHD+C3qMibd34JPgBRJSIbxEmLh7qaDrYfasQ3gZn5WAhaFd1WFUq82IyoWI6JLvzsp58CtGhHiD4JiU78dBBARkYURHSyQDIq5mJEHEMkOgni1arxeQNodeN/XPj9kd2cCIKA0WjEaDSSm5uLJEnY7XZsNhvNzc2cOHECk8k0KAAtFstg45wsy+dN9+6MR98M/4lc8KKvv79/8G5M6fZ6JW1bPB4P1dXVBAIBNmzYoMgFZSxR+tkvfhqzVcXux46y6paFEQmtyrfqcZ6dxDG7yc41n12NSoFO25FEE+l7+blyApKkaGG+Sa3CNvFhilFS28NnP7mOgpKxBdKWGxez87UqLn/P+CPylEIQBJLTTFyyabjdjdfj53R1J1XH2+jtddPZ48bW76ZdlnBnmHGqBf7+2H4CiRry5p9/gi9E9oJ0Du2rZ+Xa8HWSE9Fjc/LitpPY0yb3HnUlqJGQEBWKSKSiIQU19Xjpwk8PPjSoUCGgRsCCmtkYUCEQafY3IEAwxcDxI83Dyg7CIRObm4EoilitVqxW67BUcHd3NydOnMDv9w8+DkxrdO1Cq+mrr6+nqGh0tubSSy9lx44dU7+hGeLOBS/6UlJSMJvNvPrqqwQCgUnV8Y0kkokXkWCz2SgvLycxMVFRl/exIn0efx/3fvdqujsdvPziMRqaesjfmEvugrEjizVH26EgiZRT3Vz+wYWYYkhpTYTfE0AbYbfpq88fw+MJ8t4PLFN0D+Yp6HaFgQ+PufV9fOHuS8jOGz/6bLEa6elyTsm+xkOn1zB/cTbzF2cPfk+WZTra7Jw81sobTSd5Z1cdaXkWdAlqUgvPT0Pp1DwLRw6djEn0+X0Bnn36MK0psVbjncObrKdBZacoOPmu1hACAkXosRPASYB5TO5a4hVBUKvoso2dug2h0oiUl5ezfPnySZ1zZCrY5XJhs9no6uoCYN++fcNSwVrt1NTgSpI0GGm8UCJ9eXl5tLaeG1HY1tbGpk2buOSSSxQ9z0wjx/nDBS/6BEEYtG2ZzrFp4ZBlmfr6ek6dOsWcOXOwWq3s27dPsf2FRN9IGxJ7vx21RkVeUQqf/txlBIMSb71WxcEnjtPr87PilgVo9cNfGl6VgK69n8suySdnQbpiexxKf7eLVOvENU7bXqyg3+Hh+ltXKL6HlAQtclBCiKNRsyRJLKy388UvXk5aZmQpdo/Lf17YyYxEEAQysiwcOXSGglVZeI4I1CXqObOnGcNbDRhFgeQkPQs2FmCcYGbzVKJJ1OLzRX6TAQPv1388fZjTJrUidWWSSUutBYoUDi3bCSAjoGXyaVCPduD15pHlUY06I9HqVPzr3y9MWvQNRRAEEhISSEhIIC0tjV27djF//nx6eno4c+YMx48fD5sKjgeha32okeNCEH0qlYrMzIGyEo/Hw/XXX09ZWRnf+c53pndjM8SNC170hTjfRJ/f76eiooK+vj5Wr16NxWLB6XQqEjkMEfpgGikW/D4vas25i7dKJXLF1nlcsXUe3R39vPjcEWobuklamEJpWT4A/XYfq0uTWbK5RLH9jcRhczPLYh33mNdfPk5fj4sbPqR8PSHAquV5vLW/DiaYqhArUkBiSVM/93zlSpKiqAcrLE2lqaGHvMKpHV8WCbvfrqG2q4/S9fl0NdupD0Ig1Ug/0A+0+4KcfrEKY1DGqBLIKbJSuioH9RRFVcNRuCKbN149wdYomn9e//dxjvh8ETe3TIQgCDgT1ShdT1CFmwUY6CJAO14yxvDzmwgZGa8wcD3yW3VUHWtlwbKxJxap1SqOVh6J6VyREOqcDQm84uJifD7fYFfw0FRw6JiEhATFbpRC1+YLKdI3lDvvvJP+/n5ee+01xZtlBEFEmOLI21Sf7z+FGdE3DWv29/dz+PBhjEYj69atG0xPhNLFSkV0Qm/ckXU2okoY802dkm7m9rs2IMsy+3fV8e7TVTR395EmwhV3KncHHw5nj5vEnPDNDAA7Xj1BV0c/7//I5Cd/jMXajcVoXz+BPw6iTwoEWdHs5J6vb8Icpa/hpVvn8eKTh8870VdxuIn9Fc0s2FwMQPbsVA7ubIChglarwpdpxgf0yjItXW4qnqjAKIBRo6J0aQbZc1KntCvTmKin1+2J+PjD+xvY3dANKcrWcXnMGvrxTdpTL0QzXpJRISKShoZynDGLPj8yXv1A1EzQqelodzCeA6YoCvT198Z0rkgIVy+o1WrJyMggIyNjWCrYZrNRW1uLWq1WLBUcEp2CIFwwNX0h7rvvPl599VX27duH2Wye+Akz/MdywYu+kHg6X0RfS0sLlZWVFBYWUlJSMkzcDRVpSqQowhlInz59GoNp4rpGQRBYvX4Wq9fP4sf3vkKvup99jx1Fn2pg7iWFGMzK1SGFcPeMPSLrrW0naW3u5ebb1ih+3qGkppvRBST8Cq8r+QKs7nBzz/9uxpgQ/QePVqvGYY9cpEwFDac7ef2tKhZdO3vwexmzU8h4o5b2sZ4kCJCgxZ2gxQ10SzItFZ3o9zZjVIlYTRrmbyjAMskmiUgwpSdg63SQnDZ+g1dDXTev76vHG4c9+ZONVJhclDkmfymWkDmDj6Vn6/gEBIyoCCANevhFg4MgHotm8JmuCcZOCoKA0xO/+cYTNYkMTQXn5eUhSRK9vb3YbDYaGxs5fvw4ZrN5WCo4mhuNUOcugMvlIjn5/LoBi5Vnn32W733ve/z73/+muLh4urczQ5y54EVfiHiIvolm2w5FkiROnDhBW1sbS5cuJS1tdHfjUJGmhOgLCcqhe9y+4zVSorSZ2F/bxeZLSvj4XRuwdTp49KFd2FxeMKmZd0UhphRlPgw9fd6wgujdN6ppauzhltvjK/hCGFUiSn50SR4/G/r8fO5/N6PXx95I5PcHCQakuHRNR0t3p4Nnni1n6Q3DO3xFUSA1NWFs0TcSUSCYZMCZZMAJdAYk6l47jdEvYVQJpGeYmL8xH+0kfm9jUbA0izdfreKmW8auDbX3unnx5Qp64yRCBbVIr0WNEi+4k6KHWdLwm7F8tJzCM+jfFw39BCHh3PP8iTpqqzrGtBYSRQGPL36GR9FeF4emgmHAvisUBaysrCQYDA5LBU/kuzfUGNrtdl8Q6d2Kigpuu+02vva1r7FgwQLa2tqAgQiqkqJWPPu/qWSqz/efwkUh+sLN31WCSNd0u92Ul5cjyzJlZWVjpgWGRvqUIGRMPXS9iqr9mKIoqG8500ObAP1OLwDJaSY+9/XNADjsHh59aDcne52ozBqK1uVizYo9NSB7gxgThn9o7XmrhtM1HXzo4+tiXjdaEhQUVZLTx2Vuic9+fROaSdawrVxfRHVlK/OWjF1XNRU4+j089OC7LLtpbtgPyZQsEzT1gz6Gn1ctEkg3YQfsQJvHT/UzxzFKMka1SOHcVAqXZSqSClZrVQTUY3uXBPxB/v70IZojnKkbK64E1aStW7xI9MpBZo1I5RpQxTibA7yCPNyP0aihqdk+pugTBIGAFMBut8c83nI8JuutqNVqyczMJDMzE1mWcTqd2Gw2uru7OX36NBqNZlgqeKTTw8hI34Ug+g4cOIDL5eK+++7jvvvuG/z+jGXLhctFIfogfundiQRaV1cXR44cISMjg3nz5o17pxoSaUobPg/do6xyRezRBfDjn72JO99Kb7931GOmRD13ffFyADweH0/9dR8H/l2LYFJTsCaH1AJrdJsNSGh1534/B3bVUXG4hdvv3hjdOpMkUaEGA6nPw2ZBxWe+tkmR6NzilXk8/Ze90yr6fN4Av73/TZbeNA9xjA7nwqWZHDrciiPPOvkT6jV4sjR4AJss09zQy6GKDoyCgFmvYt7qnElZw6TOSqKqspU5C7KGfV+WZZ5/+hA1RlXcaw29KQaq1b3MDcTe3XxUdLNYCv/8ZNT04sdKdNFSX5gf2yVLY4ovQQCNUc0bb7zB9ddfH9W5IkHJaRyCIGAymTCZTOTn5xMMBunr68Nms9HQ0EBlZeWoVPDQshun03lBiL7bb7+d22+/Pe7nmWnkOH+4aH4rofm7SjKekJRlmVOnTnH48GHmzJnDwoULI0pNRJMyjmWPKl0AOQrRV21zIKhV9PaPX0+m12v52F0b+Pa91/H/vnQVpiYvBx46woEnK2g92YUcwUnVqnMzPQ/vbeDwvsYpF3wAOakmZN/kXitCj4trtFr+60tXKJaOFUURl1OZkWyxIEkS9//0dRa/bw5qzdivZb1ZR0Y87FkEATlRjysnka5sM3UWPdv2NPOPh8t59W9H2PvCCVx90dU9Zs1O5eDBxlHff3PbScrdPsSp6DA2amm0xP50G340EmPW7eWgpZnoXzfeMD+6P0FLU0NP2OMFQUCXoGHb6/+O+lyRoFTZSzhUKhXJycmUlJSwevVq1q9fT25uLh6Ph4qKCnbu3EldXR07duygoqICp9MZldn/b3/7WwoLC9Hr9axZs2ZCa65nnnmGuXPnotfrWbRoES+//PKwx2VZ5lvf+hZZWVkYDAY2bdpETU1NTD/7DBcXF0Wkb6p9+nw+H0ePHsXlcrFmzZqoUh3xGO02VERq9XLEou/fL1RgO+ub1x1FE4Fareamj6ziJgaEwmsvVbL3z0eRjSrS56WSuzgDURydFtScFUdHDzRycHc9d0yD4APYuH4WL79wFGKs41J3Obkmycztn1mvuK+eSiXidvkwGKfGkHYov/rJduZuLUZrmDhilJxq5LQnAPGMkqnE0dYwL5xEH5BIUAnkFSYxe23uuNYwgiBAgmqYB92RA428W9uJrHCn7njYjWroju25J0UPy6WxX6sCAnrEqFPIXtXo165k0lBf101+Ucqox0RRQAKa2s5EfI5omMq5uzqdjqysLLKyspBlGYfDQV1dHa+88go//OEPkWWZhx9+GJ1OxxVXXDHueM+nnnqKe+65h9///vesWbOGX/7yl2zZsoWqqirS00d7nu7atYsPfvCD/OAHP+Daa6/l8ccf5/rrr+fQoUMsXLgQgB//+Mf86le/4uGHH6aoqIhvfvObbNmyhePHj6PXnz9+mCFmzJnPHy6a30q8GjlGrtnX18fu3bsRRZGysrKoa1vimd71+XwYjKqIom4Aj//zKIGznY3dLj9Ox+gUbyTn3/LeRXzrvuv49v+7miVWK4f/cpQDj1dQu7eJYOCcIFWpRCrLmziwq56P/feGqM+lFEtXFaANk86OBE27gxuzkuIi+ACuvHY+R/ePjkzFmwd+8SYFG/MiNljOmZ+GunPiKQ6KolURyErEkWelPSuRAzY3Tz1yhGcePMArj5Rz5kR72Ch60fJs3nmzCoDGehv/3n0azxQKPgCvVUt3DD3jdYKXTGliEZ6Hlnoif01LyHjC1DsKgoArGD4TodGq8fsC9Dv7Ij5PNEyl6BuKIAiYzWasViu//OUvqaurIzk5GbPZzHe+8x3S0tIoKyvjpZdeCvv8n//853zyk5/kjjvuYP78+fz+97/HaDTy5z//Oezx999/P1u3buUrX/kK8+bN495772X58uX85je/AQaifL/85S/5xje+wfve9z4WL17MI488QktLC88//3y8fg0zXCBcFJE+GBB9Pp+yqbGhKWNZlmlqauLkyZMUFxdTVFQU04e+UqPdQgwVfXv37mVWSQqnqyfurXS7fDQFAoM/g02norWpl5K5Y49qi4R1l89m3eUDFh9H9jfy0iNHCegEEvPM9LY72P9OLR+Nk2CKFL1Rix456oSYobWf95dmcNOH42McDZBbkMJbr56M2/rh+MsD75C6NI3E9Mgjn2mFVtKQaZ340PggCGDSETTpcANuSabjaAeqnWcwCJBs0bHs8llY0hKwZpg48M4Z+u0e/vHCUfozp8GnLDWBcqODK12R191JyDQLPlbKE/9dzKjxRSH63Eh4EsJ/PHgNajpa+0jPGp6T1mpVBJxeXIH4jAxUysoqVkLp5ZCP3T333MO6detobm7mtddeIyNj9LXR5/Nx8OBB/ud//mfwe6IosmnTJnbv3h32PLt37+aee+4Z9r0tW7YMCrq6urrBcWkhLBYLa9asYffu3dx6662T/VFnuIC5qERfvCxbgsEgx48fp7Ozk+XLl5OSMjr1Ec2a8Yj0ybLMC/9+hus/kcG2V05M+Lxf/vRN+rMthKRXMMNE/amuSYu+oSxZlc+SVQMTP05WtPK9JyuxpiTwxCP72HrNApJTI6+ZUZoElYg9muNb7HxwUS7Xvn9pvLY0iNuptIvg2Dz1yF50hWaS86IrOhMEgbTUhOkTfSMRBUhJIJiSgANwBCQa/12DxhPAqBLQeAP87S+7actImJb0hyAK9CaqIIrgaIXoZv4YzRvhsKDCRQBjBJf9foIEE8PPF5YSdVRXdYwSfRqtmkBPkGAwtij5RAy1TJkOhorOod27OTk5YzZDdHV1EQwGRwnCjIwMTp4Mf/PW1tYW9viQnUro/8c75nxDQERQYCxgtOecYTQXheiLZ02f3+9nz549qFQq1q1bN+l6inhE+vx+P8eOHaOtux5rch5CmHq6keyr7UQoOSdeBbOOjvZoZFB0vPrcEYrnZTD31rn43H7uf/BtBI9ERoqZjRuLWbA0Z0qjf2a1OmLBYmnq48Ori9h83cK47imENdmIrcsRd1H80rPleM0qckpj8+tKyTXD6R6YhvrDCVGLkJ2IH+iTZdQV7WiDkG/z0hIIEkg3TrnA8Jo0+JDQRvBh5SKIiyBGIr/e5KHjGE7mRXDZdyKBLvyHtCAIOMM0Oml1KgK+IFqdSE1NDaWlpRHvLRKmK70bIiQ6Q5M/LoTu3RkuPi4aKRyP7t3+/n4cDgfJycmsXr1akQJapSN9MDCFw+12Y009O/prAvFUXdFKh3b4S0MQBByu+ESYDu2pY/bCLBYvzaW7yY7epGP9hxez7uNLKXpvEa9X1HPvN17kod+8xY5XTuBxxz/SlSCIEdU+ppzp484NpVMm+AA2X7+II/viW9f35qsnaPN6yFkUe2S3YEkmFlv8zHoVQZZRV3ex+QPzsWSYuP32NXxsyzyWyyIprQ6kvqnbv5SewFFNZA1TFSoPi6XoRvmpENAQ2Y2TT5DHFVhenYqe7uFpXLVahRyQ0Zo0vPxK+Pq2yXC+pHc9Hg+SJEXUvZuamopKpaK9fXhJTXt7O5mZ4f0OMzMzxz0+9P/RrDndCGcbOaby34xlS3gumt+KkpE+WZaprq6mtrYWjUbDvHnzFLsDVTLS19nZSW9vLwaDgVWrVqHRD6w70XvhF7/biTdndDrPHkMjx0RIksSbL5/gymsXcNmWuTQe7xz2uCiKzL+0kLWfXk7ee4tpMUn89Cfb+M1PX+fZv+2nrblX8T0BLJqfAROIy7TGXj6xaR6Xbpkblz2MRaLFMOoDV0kO7q6jqqWbotWT8wPUGjRkxGGGsWLIMqpT3VxxTSmJKQnIZ290cvKSuPZ9i/n0nWu5YX42c10BEpr6kHzKmruPRDRoaDFPLMo68GMIxjZxIBMtTUwsLMN59A0laNVzsnJ4LFytEQn6g2gNavbuD1+vNhmmO70bEn0u10AOPpJIn1arZcWKFWzfvn3we5IksX37dsrKysI+p6ysbNjxAK+99trg8UVFRWRmZg47xm63s3fv3jHXnGGGEDPp3Sjxer0cPXoUj8fD4sWLqaysVGCH51Ai0ifLMrW1tdTW1pKYmEh6ejqiKKLRnBWT43yuSJJEbb8HIXt0MXtPHGa//umXb3HTx1YjCALW5AScPeNHVlLzLaTevgQAnyfAw0/vR+UKkp5iYunKfBYuzwtrBxMt6zcU88SfWvGPkZpMO2Xjk+9dzOqNsyZ9rlhwu3zIsqx4yvtkZQvvHq5nweYSRdZLSjWAyx9f65YYEWttXHpFIclnGzc0evWwFKKoElm0LI9Fy/LwuH3s39NAfVMPzR4/voyEuAgQl1kDtrEfl5GpET2sGMeiZTxS0HAmghalcB59QxFEgX7vcBGsUolIQQlBELD1xeg/Mw7Tnd4NRRqdzoEbLoMhshuae+65h4997GOsXLmS1atX88tf/hKn08kdd9wBwG233UZOTg4/+MEPAPj85z/PpZdeys9+9jOuueYannzySQ4cOMAf//hHYODz7Atf+AL33XcfpaWlg5Yt2dnZcTHFnuHC4qIQfaBMpK+np4fy8nKSkpJYtmwZHo9nWqZ8jEcgEODYsWPY7XbWrFlDfX09wWCQjo4OLNYBASOMo/qeeGQ/PWP403XblU11NdZ2kZioJyf/nMeV5In8Z9fq1Sy7ad7g17v2NfHSv46RZk2gsCiFdZfPJsGsG2eFsSmZn4HOFQhropFZ28Ndtyxn6cr8mNZWgpJ5GTTWdlNQnKrYms0NNl5+9TiLr5ut2Jr5izM49M8q/JMYzxcPhLoe1q3NJb3g3GsvrcDC6apOSueNTmnrDVo2Xl7KRqCj3c7BfY2cabPTrlMhJCkXzQwm62lqcJJL+NftadFLnjS5GskExAlrBycSfQAetYjL4cVoGtirIAgDDTOA090/qT2G43xI74qiSH9/P0Zj5DWft9xyC52dnXzrW98anL3+yiuvDDZiNDY2Dltr3bp1PP7443zjG9/g//2//0dpaSnPP//8oEcfwFe/+lWcTief+tSn6O3tZcOGDbzyyivnpUcfhBo5pngix8WTyIyKi0r0xTp7V5ZlGhsbqa6uprS0lIKCgsHoYagzVqmIy2TEqcPh4PDhw+j1esrKytBqtYN7fOPN15m/JBtg3EaOf+08hVwUvnC/2+nD7w+iGWcaQzQ89ee9fPYbm4d9TyXFOikUZq3OZdbqXAB62vr5xf3bSdRqyUgzs+6yEvLCGMqOhSiK6CQZx4jv557u4b8+uor5i7Jj3qcSXLJ5Hv947IBioq+328ljT+xn+Y3zFI0eWrPNZKgFmhRbcfIIDT2sWpJO7pzhv7uUPAvHX60LK/qGkp6RyHuuW4gsyVSdaOP4iTaaup30phgRY5k3PJQkA5UmO7kjX3hAEJl2/Kxgcg0EBeg4jot5Y6zjQ8KjnfgDM5ik5+ixFtaWFQ1+L/TacXuVr4Wc7khfKL3rdDoxGo1RvU/uvvtu7r777rCPhZtxe/PNN3PzzTePuZ4gCHzve9/je9/7XsR7mGEGuIhEX6yNHIFAgMrKSmw2GytXrhzmvB6661TyDjTWMWzt7e0cPXqUgoICSktLBy9IofUOHN3Jhy8biEyNda3q7XHRPIbxKkCXINPRYidnSHQkVv7+yF623LAI1Yj5rckJenxuf0RTH8bDmmlm9W2LAQj4Ajz57yNg85GeamLBomyWrikcnMAwFvoRv6j8qm4+f9d6imePdtGfatRqEadC6XaPy8cfHtjJ8vfPi6izOxoEQSA1LeH8EX1NfSydk8KsxaML3lVqES+Rv/cEUWDugizmLsjC5w1wcH8DtfU2mp1ePFmmmASKIAi4EjWMutsAjoluFkTZvBEOLSKioBpzBreTIB6LZsI4iaASsbmHizvx7HvGL/vxeDyKRp7Op5o+o3Fqzbv/05mZyHH+cFGIvqE1fdFE5RwOB+Xl5Wi1WtatW4dONzzlEhJ6Ss6EVKlUeL2RN0zIskxNTQ0NDQ0sWrRoVPdWqEbQK/Wj1Q38ucf6+X/6o9dx5lnHTP46LHrO1HVPWvTZe930dLmZt3h0o8Cll5VyoKaLwjAfyrGi1qpZcu25lOWRo228ct8JUi1G8vKsbNw0l8QwDQcpJi3NDIj6eQ12/vvuS8ifFbsHo9IEAhKBQBC1OvbXXsAX4Fc/f4OlN8xBVGhG8EjS8i1Q0QGJ05t6Elv7mZ9rZs7KsRtUxAgiXOHQ6tSUbSimbEMxPd1ODuxtoLGtj1YRSI0uMue3aPG0BBnqkucggBeJ8M550ZMmq+jCRyqjU8V2gmCKTNR4hYHaWu3ZCGdI9Kn1Knbt2sUVV1yhyH5h+tO7ofOH7Fqm00B+hhli5aKRwkOjcpHQ1tbG7t27SUtLY+XKlaMEHzB41xnPWbnj4fP5OHDgAO3t7ZSVlYVt1x9cT31OSI51sTra2oegG+c+IC2BM43jVJlHyB9//ia3fmJN2MdWlBXSUqN8EfhQ8hZnsvrOJcy6qRRvSQK/+t2b/PKH23jiod3UVnUMWrVYDVqkYJAFjXbu+dz5JfgA1lxazIkjLTE/X5Ik7v/JdhZcW4J6vL/7JMlblEFyjGPtlELV5WROioGFGwrGPc5g0eFyTC6CmpSSwFVXz+fOO9byofXFLPbJpLb2I7kim/HiTzNyzDD893VC5WVRFEbME5GJhvYxxr55BTnyGwCrnmMVzee+Phsp1pk0vPTvFya7zWGcL+ndmUhf9AhnLVSm+t+FQG1traLrXRSRPog8KidJElVVVTQ3N7N48eKwo3VCxMP0OdL17HY7hw8fxmw2U1ZWhlod/k8ZivRJwXNW/+E03753a+k0jp9SFUWRfsfkRtm99epxVm+Yhd4QvhhdrVbhc8bXGmMopmQjqz8ykAaWAhL/2F6J70kX6SkmdLLM/FO9fPnrV5GSPn3TQcZi0fI8nvzTbhatyIvp+b/56XZKNhehN8XW7BIpaq2K9GTDeE2pcUVlczErQcOSK4omPDa7NIVDBxrZcNnkm1kEQWBWaTqzStMJBIJUHG7mdF0Xjb1u+tMTxhRWgkZFl0UFZzOnHSo/ZkmIyaJlzL0hYEBEQhq17kR2LcPWUavo7Dl3bQl1zqs1Kuoalf2wOh/Su6Io4nQ6Z4yZZ5gySkpKuPTSS/n4xz/O+9///kmXTFwYUngCBEEYvFiM18zh8XjYv38/NpuNsrKycQVfCKVFXySRvpaWFvbu3Utubi7Lli0bU/CF9hcIBNAbzv2pw4m+3z+8D3924oT7m4xXXyAQ4Mi+M5RdPr5Tv+BXbiJJNIhqkUVbSllxxxLy3ltM+elOZJ+ffz5ziBeeOkRrU++07Gs8nM7YRPgff7WDnHU5mBTsPB2PpLQECEz931XsdZOvElhxVXFExxuteto6wxTUTRK1WsXSVfnc9IHlfPLWFVxmNlDQ7UHb4Qz7fneZ1EhIyMjUiz4KZeVT4wXoOB3Gsy8a0QfgQSZw9m8rDrm49Dt6JrW/kUxneleW5WHp3UjtWmaYYbIcOnSIxYsXc88995CZmcmnP/1p9u3bF/N6F02kb6KonM1mo7y8nNTUVBYsWBDxxUXpCRrj7VGSJE6ePElraytLly4lLS0tov1VV1cza0jzwci75UAgQKPbF1GNSt8kUl+///Gb3PKJtRMep5aIiwddNLz6p0N05VnJVQsUva8EvzfA3185hq/DTWpqAiWl6awsK0Snn1zDyWTRaERcTh/GhMhtPB558F0s81OwZk6djUrB0kwOP1WBJ4zpd7wQ7B5yAhJrro/cPFsQBGR1fF93pkQ9l1w5B4CWRhsVR1tobO+nxahCNA+IO1+SnnpVPwiQ64/Pa8yIinBXGq8qug56KVHHicpWFi3JGSb67C5lbVumM70ryzKyLA92785E+qJDPPu/qT7nhcDSpUu5//77+dnPfsYLL7zAX//6VzZs2MDs2bO58847+ehHPxqRFghxYfxWIiRcB68sy9TV1XHw4EFKS0tZtGhRVHeT8Yj0hVvP6/Wyf/9+enp6KCsri/iPLIoih47uZf7icxYjI8XUH3/7DvYIfdRs9tgifSeONJM/KyWiebGlRan0d0UxeV5hjr1RS0WXC79FT0uHAykoodGpWbi1mOW3LST/6iKa1F7u/9Ub/O7+N/n7o/s5U98d0dg2pbnquoUcfLcu4uOfffwAYpaR1EJr/DYVhsS0BDIm2ZEdFU4vmS4f66MQfCFUemXnX49Hdn4ym69dyJ23r+Gm+Tks9khYWuwE9WpOJ8p0CQGS43hvnoQa+5DaPgkZjyY60Svq1LTaBgyLh3Z/O10O9uzZQ3V1NV1dXZO+Tk5neje0d1EUZ+buzjAtqNVqbrzxRp555hl+9KMfcerUKb785S+Tl5fHbbfdRmtrZNPiL5pIH4wWaH6/n4qKCvr6+li9ejUWS/RRCCXHpo21XsgUOjk5mYULF0YlSkVRpL27gbTMc+N5RgbQdhxpQo6wSaHL7o4pCvevvx/hc9/cPPGBwKat83js9WMsumziGiyl6Wro4Y0dDbhmDXgVthg0tJ7oImfhcJuW9KJk0s/6GQZ8Af75ZiWeDg8pViOzZqWyZkMx+ikQOVl5Sbz07NGIjn3lhaP0a2Xy5ipn6BwNKalGGqZCS7l9pPW4ufTWRTE9PTnbTFNDN/lFkd89TxZRJbJgSQ4LluTgdvko39/IUVMfbncAuz9AYpwu1bloKcfJAgZeqx4kPAnRn8stSwORuCHXBVErYjQaB8dWer1erFYrKSkpJCcnR9UBG0qvTrfoU6lUuN3uGdEXJdPRWHGhNHKEOHDgAH/+85958sknSUhI4Mtf/jIf//jHaWpq4rvf/S7ve9/7Ikr7XhSiL3RhGSr6+vv7OXz4MEajkXXr1qHVxuZyH89InyzLnDlzhqqqqmGm0NHuzxe0D3ve0DFlrc29RHZ/MIBNlrB1OUlJi7yx4eHfvM0NH14R8d7zClPoaVW+rmoifJ4AzzxwEPsQ0145M5HmqtGibyhqrZoFV50bW9bZZOf+X7+BSashLdnEqrIiCktS45audronruvb+UYVZ+xOZq3NjcseIiFzVhLsb4F41hF6AyS3O7j8Q7EJPoD0oiSOvNEwpaJvKAajlkSzjqRkIyfTjLQ5fWjcQQzuIGZHkNlutWIiUERAP6Sho58ggURd1CmgoEnHqepOVEOuLYZELQcOHuDOO+5ElmXcbjc2m43u7m5qa2tRq9WDAjA5ORmNZuybpFAUfbpq+kJRRkEQcDqdw/xaZ5ghnvz85z/nL3/5C1VVVVx99dU88sgjXH311YM3QEVFRfz1r3+lsLAwovUuCtEXIiTQWlpaqKyspKioiOLi4kl9GMeje1eSJILBIMePH6ezs5MVK1aQnBx+SsZEiKII4vDmlaE/7f/d9xru/LG9+UbSrVPT0tgTsehrb+lDVInkRzk5IuhVdrxdJDzx/bfpKk4eFQrt7Iwu1ZySm0jKWdEhBST+vbMK598PkZJkpLAghbUbiwdHVylBZlYine39pGWET9GX72/kUFUrCyNsZogX2fPSSH27ga54iT5/EEtzH5s+snhSESG1VoXHP3Ud5CNpOdNDe6udskuKOf3KcYIpCQSTwAPYAhLN/R607iB6d5DE/iCzPWrMk7iU56DlDD4K0ONAghimiogGDQ1tfeSlnXsN6oxaduzczp133IkgCBiNRoxGI7m5uUiSRG9vLzabjfr6eo4fP47ZbCY5OZmUlBQSExOHXZeHpleng6FNJG63m9zc6bt5muHi4oEHHuDOO+/k9ttvJysrK+wx6enpPPTQQxGtd9GIvlAHb2NjIw6HI+JGiImIR6QvEAiwd+9eBEFg3bp1k2rRFkURi3W4wBCGXDhPdDoQciKP2skZZupOdUVsE/LI797h7v93VcTrhxADU1sf98Kv99KcZoYwI+aanT4c3S5MKdF7c4lqkXmXzxr8urfdwW8eeAujWkVqkomVawoonpsxqRuP625awkv/OMa1Ny4e9VhtdQfbd9Ww9Brl5unGiqgWSU8x0hWPxQMS5oZerpqk4BtENz3iwunwcmh3PVdcPR9ZkkkWVXQOeVxQiwSTjLiTBhxdbAGJM/0edK4Aek8QS7/EbI8aUxSXdgtq6hio1fUJcsy/P7ckIYjCYBpWEAVO150Ke6woioMRvpKSErxeL93d3dhsNpqaBua3hB5PSUkZ9rzpYGg9YWgM2wyRMzORI3Zee+018vPzR732Q5nA/Px8tFotH/vYxyJa76IRfW63G7vdjlqtpqysTLE3rdKir7+/n0AggMViYd68eZO+yLlcrlERoNCS/3rhKH3pxoijfACiXk1vb2RzNV966jBXXDMfdQyzek0aNUF/EJVCc37HY+8/T1LtCRJMCy+u+3Mt1B1sYdHmkrCPR4M1w8SqDw4MTpckie276nju+SOkWI3k5yVRdmkJJnN0Ij/BrKerc3SnZHtLL888X86KG6JvZogXKRkm6HCAVsFLT1DCVGdjy4cXTThaL1L0Zh0ejw+9Prayj1iQghJv/KuSy7fMAwaaIpITdcNE30gEtYg0QgQ2hkSgO4jFEZkINAlqPLIUtV3LUIJGLfZeN2aTCu1Zi6ievshsW3Q6HdnZ2WRnZyPLMna7HZvNRktLC1VVVYM3vr29vVit1ikXf0P9XWcaOWaYSoqLi2ltbSU9fXiJkc1mo6ioKGr9cVGIPkmS2LdvH1qtlqysLEXv0mKdlTsSWZapr6+npqYGgPnz5ytSA7Zr9y4WLhs+dipUbP3Q0+UwJ/qifodr4g5et8vHmQYbW8JEnyJhzaoCztT3klUa3ykYZyrb2V3ejrvAOvZBWjXdbU7Fzy2KIrM3FMCGga/7u1z87sGdGBBJSUpg2cp85izIGlaDORY+T2BYg42918Wf/7qble9fcF6Ni8pfloHxb+24chWybpFkjLU2Nt+yALWCQjKzOJljh5pZtW7qmonefOUEqzfMGmbabDHrIYL3W4iwIrDPg84dQO0IYHUGWeDXYhxx6S+UtZQLLtzaSbxWjBo6m+0Y0g2Ds7NlMfqIvSAIWCwWLBYLRUVF+P1+WltbOX36NCdOnMDv95OUlDQYBTQYDHF/jY8UfTORvugQEBGm2Cxkqs8XL8ZyhXA4HDFlAS8K0SeKImvXrqWmpkZxW42Q+fFkCAQCVFRU0Nvby7Jlyzh48KBiPnXv7t/OR7+QP+x7gijgdvlo8QdjOkdvBCO1fv/j7dzxuUuiXjvExitm86M/vhVX0eeye3jh0WP0z55Y+LZ2uggGJFRxmk8LYE41suoDC4CBG5V39zfx4ktHSU40kpNjZd1lJVis4T9sFi/Lpbamk+LZ6Xg8Pn7z6x2sfP/8iATjVJJgNZBh0hK5ycw4yDKG0zY237wArVHZiFximpGKPc2sYmpE36E99WRlJ2K2DK93TM8wI1X2I8b48wlqESnFGBrugT0QpLHHjdrpR+8OkOKUmR/QYUSFShBwTyKwLggCfrWIf0g9rqCSCQQC4xrIT4RGo8FqtaJWq1m3bh1OpxObzUZXVxenTp1Cp9MNNoQkJSVN6lxjMVT0OZ1OTKbzb0LPDBcW99xzDzDwvvrWt7417EYjGAyyd+9eli5dGvW6F4XoA9Dr9YqnYmFA9Pn94WdYRoLT6eTw4cNotVrKysqGzfNVIoXR1FqLMWH4BAxREPjRD1/HPysppnuhnv7xDZp37ahh0co8EqJMUw7FaNLhjtETMBIkSeLxH76LrSQl/IiSEbSYtTRVdFCwdPR843ggiiLFa3IpXjNQMO7ocfPbB3ei8kNacgIrVhawcFkOKtXAX/DSzXN59KHdFMxK5Rc/fp1lN86dktR4LCSnGqmbbM2mLKOvtXH5e0vRm5RPwQqCgBRnk+YQ9TWdOPs9zF04WmDmF6WQuL8Bh0KiVlCrIM1EMA2cgMMfpKF3QASqnRD0+zF0DYlqyyDLA81foX+yLCPIIAkD/0LHIQABiZbT3bgdXgwmHbIKXn/9dbZu3TqpfQ/WCQoCJpMJk8lEfn4+wWCQ3t5euru7OX36NG63G4vFMhgFNJlMitw8j2zkmIn0RYcoCNNQ03d+3fBGy+HDh4GB99uxY8eGOYxotVqWLFnCl7/85ajXvWhEHwwINK9XWSGhUqnweGKbUtHR0cHRo0fJzc1l9uzZw1LFSnn/qbSjRa4oCrxb3YG4cOIxc+HoHkeMSZLEnh2n+Oz/RubJNx6yL36mbs/9bDdteYmgivBClGai7ZRtykTfSExJBso+eLYjWJI4cLiVF14+hsWkJy8nics2zaav18VP/u9VFl1XinaaJ4WMR1ZpCrzdAGkx1kXJMrr6Hi7dUkxiSvxqq0Rd/EVzb4+TisPNXHH1vLCP6w0akgxa4mVgJGjOiUC5xU5BgpkVZbFFN2VZ5nRVJ4dOttLmCYLTCW4/x44dm7ToG2tmukqlIiUlZbDZY6gtTENDw2DDSCgSGKs1V+gmXJZlXC7XTKRvhrjz5ptvAnDHHXdw//33k5g48ZjUSLhoRF9oDNtkU7EjiSV6KMsyp06dor6+noULFw5rww7dlSoVkTQljv7wb2/qoUevjqqBYyg2rw+nw0tCGNuR337/dW65c+JRa5GgluLTwfvWY0epFUVkQ3QfAB0dytf1xYIoisxakcOsFQO1mu5+L394ZDd1h5pIzE2ks6GPnHnauKaiJ0Pm7BTStp8et0FhPLSNvWy4tICkOI+Rs2Qk0N7aR0ZWfEbHBfxBdrxykk3XzB/3uKREPWcUzlCMRPb4KUwxIvtiP48gCPT1OAeadDQq0IAqIEXcVTgekRozGwwGcnJyyMnJQZIk+vr6sNlsnDlzJqwtTKTZlJmavhmmi7/85S+KrnfRiD5QvtM2ljX9fj9Hjx7F6XSydu1azObhH1whcapUpC9xhF2LJEm8/nYtXBm7Z1uHWqC1qZeSucMjhbVVHaSkm0nPUuaOJCMpAXe/F4NZOU+76r1nOFTXizeGRoImdwB7u4PEjPPrLt9g1oEkccOtK/AHJNLSEtj58ik8SIgGNdnz0kjOMZ83DR2iKJCSYoxJ9GnP9LJmdQ5p+ValtzWKzJIUDu88w9brlBd9sizz2ksVbLxy9oTCw5KoR+ruj2vHqrbLRdl7F7J7Z23Ma0iSRL/DC0PqSEVZGNV1GOva0f78oiiSlJREUlISxcXF+Hy+wSjgsWPHkCRp0BYmOTkZg2Fs/8iRom8m0hcdM40c0XHjjTfy17/+lcTERG688cZxj33uueeiWvuiEn3hZu9OlmhEX2gKSEJCAmVlZWM60I81fzdaKioqyB0yY1WWZbra+3GYtQiRpjXD4E8z0XCqa5Toe+7R/Xz2G5NP64bYvGUe2443ULpaGSNUe6eTV1+oxlEa2xgyV76VuoOtLLm6dOKDp5Bj206xYl4uGy4r5U+/eZt1l5ZQOn8gehwISOzeUU3F/iokjYDeqid/SaaiQjoW0rLNnGx2RGUErG3uY8WidHLi3NE9eD69mn6Fy0FC7H7rFKVzMzFEUKuXX5CM6nQncnJ8oktyn5uls9MRRXFSljdtzX1ozFoYUv6hijmfMJyhNXWxotVqyczMJDMzE1mWcTgcdHd3097eTnV1NQaDYTAKaLVah50vdP5gMIjH45mJ9M0QVywWy+BNeizjYcfjohJ98Yj0RWrZ0traSkVFBYWFhZSUlIwbdVEq0vePfzzHa+WV/POVEzg9ARxuP/agH0t1HwFvA44iC1K+JfoIkElLfZ1t2Lf++tt32HKDQsa4Z5m7OJtHXz6iiOiTAhJP/Hw3vTEKPgDUIt3nSYo3RMORNlJFPRsuGxCiPk8AKSghnhX1arXIxk1z2bhpwKvP3uti28uV1PQ4Qa/CkmMmZ15aTF6Kk6FoeTaHDh3EWRDZOCtNq53FJckUxFiHGjNxSJFXVbQiCpCdZ43o+LSsRJJksE18aNTIskyC08/c+QO1qpMRfd1dTvQJGnCcGwuoFZX5iFGqsS2EIAiYzWbMZjOFhYUEAgF6enqw2WxUVVXh8/mwWCyDtYCBQAC9Xo/TOfD+n0ykz2az8dnPfpYXX3wRURS56aabuP/++8dc02az8e1vf5tt27bR2NhIWloa119/Pffee+8wQRDuOv7EE09w6623xrxXpZgxZ46OoSndmfRujITSplMd6ZMkierqapqamliyZElEqQ6lIn0f+9jt/OzgswRmWQe/J8syq/f38V9HjJQf7+OfWV00Zerwz09FsEQ2HksURbqc55pXerqd9Dm9zF2UPek9jzyP36PM3+vJH+ykoyBpWOopFlq7XAR8QdTa6e+M7W3rx3Gil4//18bB762/tISKo80sXhZ+Ykqi1cj7P7Rq8OvTVe28/UoNHjmIoFeTNTeFlLwYbgSiRG/Skplk4HQEx6rbHSzIM1OyQtnXVyRoEjQEfAHFPAA72uzUnerkkk1zIn6OKAqkJOrjIvqELieXri0c/FqjUceUSh1ocPAiJmjOub8DmQqkdiG29G40qNVq0tLSSEtLG2zWsNls2Gw2amtr6e7u5umnn2b9+vUAkzJn/vCHP0xrayuvvfYafr+fO+64g0996lM8/vjjYY9vaWmhpaWFn/70p8yfP5+GhgbuuusuWlpa+Pvf/z7s2L/85S/DmmasVmvM+5zhwuSiEX2gjKdeuDXHEmg+n4/y8nJ8Ph9lZWURXyiUivTl5+ej9QQZ+hMLgkAPQTxILPUbWdoIgUaJZyqa2Zcv0puTgDwndaCrbxz6hnj1/eKHr/PVb22Z9H7DISjQwfvqnw7RkKiPaaboSNqSDTSWtzFrdc7EB8cRn8vHyRdP89kvXzns+0tW5fPnB94ZU/SNpHhOBsVzBqJngYDE3p2nOPaPKiStgM6iJ39xBkZL7NY745GcauS0JzBMJIxE1elkdoqeuWvzxzwmnmTOSqLyWCtLIhw7OB5ej5/dO2q46tqFUT/XkqgHt2/iA6NADkqkIJCafq6u2Jyoo7/PgyUpuvRlT7cLMUGDFJQZLKWSZbIzw88KjRYl0ruRIggCCQkJJCQkkJeXRzAY5NVXXyUxMZEHHngAgE2bNrF161a2bNnCihUrIt7biRMneOWVV9i/fz8rV64E4Ne//jVXX301P/3pT8nOHn1js3DhQp599tnBr4uLi/m///s/PvKRj4zyQLRarWRmTo/DwAzKsWzZsohvvA8dOhTV2hed6JuqSF9fXx+HDx/GarWyfPnyqAxDlYr0AegDIq4R38vXGjgmeljlHriwqxH5oMvCB09Cz8kADx05TW2uDleRBcaI+vSe9ep78dlyLrtqDro4WYToEJAlGSHGCN3R7bVUdLkIKNXpmWSkvb53WkWfJEns/usxPnfPFYM+fUNxObwxmXur1SLrL5/N+ssH5vQ67B62/auCUz1O0IpYss3kzE9TLMqZuyCNw6+eIpAe/m+j7nFTYtaw+LKpm4oxEmuWmarDpyct+mRJZtuLFVy6ObaReKkpCUinXIgK3LiEENsdXLV5uFVMckoCTQ22qEVfW3MvlkwTtjP2c76XQZlF86IXuOFQOr0bDSqViqysLL73ve/R1dXFli1buOOOO9i2bRs///nPUalUHDp0iPz8iW9Mdu/ejdVqHRR8MCAgRVFk79693HDDDRHtqa+vj8TExFGfK//93//NJz7xCWbNmsVdd93FHXfccV40cAmCiDDF6dapPp+SXH/99XFb+6IRfVOZ3m1qauLEiROUlJRQWFgY9ZtOyX0myOpRaSGrRkOrWoIwI3STUPPlriTogkNHe3k2p5P2HD2BOakI1nPp3x6HF58vwNEjLXz1m/GJ8gEsnJdFT2s/yTnRdwR3NfSw460GXLOSFd1Te/v01vW981A5d3xi3ZhNAPMXZlFf201R8STqFwFTop4bP3juw6mxtps3tp3AFQwiGlRkzk4hNd8asyBPLbCSLkNLmMfUfR4KNSJLN8XeZa4EoiggKXCVfPv1kyxblY82xjRxQXEqxvIzePTKdI1KHj9FFgPaESLSZNbTF+Fs7aE4XT6SxISBiUeh650/yFVXbFJiu3FP705EqHvX6XRiNpv5+Mc/zic+8QkCgQD79+8nNzeyuuO2trZRJT5qtZrk5GTa2toiWqOrq4t7772XT33qU8O+/73vfY8rrrgCo9HItm3b+K//+i8cDgef+9znIvshZzhv+Pa3vx23tS8a0QcDby5JkhQbcQbnonKyLCPLMidOnKCtrY3ly5cPGoZGi5KWLXNzi2gMdg/r1g2KAu7AxFNElksJLD8DgTMSfz/azN5Q+nd2Kna3nx9++9985guXKbLPsdj0nnk8+NS+qEWfzxPg6QcO0hfDbOGJaA4E6Wm2kxSDEJ0se5+q4L3XLCY9c+xzX7ZlLo/+ac+kRd9I8melcPunBgYFS5LE/ndrOfzPKiS1gM6iI3dRBqakyOpCYeBGLDXVOEr0qfq95AYlVl4Ted1bPBEmadJ89FAjZoue5NTYBVuCSUeyThNWIMeCtsvFhveOjsKp1CLBKP0xnQ4vwcGU7pC1AvKwiNZkkCQpLuPVIiUUaRzp0adWqykrK+PrX/86P/rRj8Zd48SJE5Peh91u55prrmH+/Pl85zvfGfbYN7/5zcH/XrZsGU6nk5/85CfnhegT5IF/U33OGUZzUYm+UN1FMBhU7AIydDTPkSNHkGWZdevWjev5NBFKpndvfs9NvPbq/ZB6rp5QEiHNJdAu+MiQJ7aMUCNyq8vCrUPTvzo/hjkZWONkIxEiJd2MvzX6yNrj33+b7uLkiEasRYsn10r9obYpF30ha5a5C8evkxJFEYcjtikxkSKKIms2lrBmYwkAToeH1/99nNMt9agS1JgzTeQsSEOtG/99lppngRobJAy8DkWnj2y3n7U3hp9QMR0kJBvo6XaSFMP0j6YGG51t/ZRdUjLpfSQnGmiRFbgZtHtYXJw6ZuRMjNLOqbmxh+S8gS7SoZ+zOq1WMT+7YDAY8zQNpc4fivQZDIZRQYMvfelL3H777eOuMWvWLDIzM+no6Bj2/UAggM1mm7AWr7+/n61bt2I2m/nHP/4xpuVXiDVr1nDvvffi9XrR6abXommG2AkGg/ziF7/g6aefprGxEZ9veG2vzRZdi9eM6FNozd27d5Oens78+fMnXXCsZKTv6q1XI/7t+0hDRF9QhI0+E2+b3VzVH92FNJT+/YO2gxd2nqb+i8/xnqvmsPk98+NWOyJH2cH7wq/20pJmHpgKEA/UIt2dU5viHWnNMhHpGYl0tveTlhHfqRUhEkx63nfz8sGvmxtsZ1PBAQS9mvTSJFILkkalgguWZGLd10RvghbB7Se91836W5SpA1OKjOJkyg80cPmW8SdnjMTZ7+HQnno2XbNAkX1YzDqkXuek0pyyLGNy+Fhwxdid0NHatjgcXhJTzzb7DIkSmgzKNQBNd3o31EjicrnCNuSFOn8noqysjN7eXg4ePMiKFSsAeOONN5AkiTVr1oz5PLvdzpYtW9DpdLzwwgvo9RP/bsvLy0lKSjo/BJ8sDfyb6nNeAHz3u9/lT3/6E1/60pf4xje+wf/+7/9SX1/P888/z7e+9a2o17toRJ8gCIMDu5WKosmyTFNTEwCFhYXMmjVLEeGjVKRPlmW6u7tROXwMfflLImgRsWtif1MYRTVaQcWBjAQObjvO31+oYMuaIt734eVoFLK3CCEEI4/Tv/1MJRX9PoJxjsK1dLvwewJoFCysH4tw1iwTce1Ni/nnU+Vcd9OSOO5sbHIKkvnoJwfsLSRJ4tCeOsr/WUNQLaAyqcldnIE5xYhGrybdaqDXGyC108kltyojkJREb9LS54zOpDkYlHj9X5VcuTU6oTgeuflJiI02sMaeRdD0eFi/avyGg3DNQWPh9wXw+AOE3m0yQ0WfclMrprJ7NxxjpXejZd68eWzdupVPfvKT/P73v8fv93P33Xdz6623DnbuNjc3c+WVV/LII4+wevVq7HY7mzdvxuVy8eijj2K327Hb7cCA2FSpVLz44ou0t7ezdu1a9Ho9r732Gt///vf58pe/rMjPP8P08dhjj/Hggw9yzTXX8J3vfIcPfvCDFBcXs3jxYvbs2RN1+v6iEX0hlLJtCQaDVFRUYLPZEASBzMxMxSJdSkT6AoEAFRUV9Pb2YpRV9A197Ow2fb4gAWSincJbj4dZAS2NHX5qghJkJnICqKxu4bU7qlm/LI+b7lobdjZvLJjM+ogEVt3RNnYebkOarXwd30g600zUH2qldN3krTzGYyxrlonQ67XYbOeHkbQoiqxcV8zKdQNNGS6Xj+3/qqSi/QzoRPx2Lxanl8s/tnRaoznjIWui29cb/z5O2SUliAqaO2fmWEmSZHpifL4sSSTJ8oSzhDVRRMibGnqw5pyLJstD7s+sJuVuvKaze1eW5cH07liRvmh47LHHuPvuu7nyyisHzZl/9atfDT7u9/upqqrC5RrwXTh06BB79+4FoKRkeJlAXV0dhYWFaDQafvvb3/LFL34RWZYpKSnh5z//OZ/85CcntdcZpp+2tjYWLVoEDJiC9/UNfJpfe+21w+o4I+WiE31KjGJzuVwcPnwYtVrNunXreOeddxTtChZFcVLCNLQ/jUbDunXryE1OGSb6pLMab6VDR4XazdJAdHeu27UOPuJLJrHDw89a7HB2soBoMVC5yMAxh4PXP/k0ZbMzeP9da0mb5CzeNZcXU1HdTc7isacxuOwenv5rOdKiKfKosujpaOyLq+ibyJplIowGDc5+LwnTPHJtJEajlutuXgYMGHv/6qdvkKxWc/qNBtCKmDNNpM1KQhWHaRixotarkAJSRCLuwK46cnKtmBKV9TdUqUWsRm3Mok/X5eKyCMoDEkxaHP0eTOaJ99/X68JUcE5EDoo+WSY1Sbmu+elM74ZuwJUSfcnJyWMaMcNA1kgeop4vu+yyYV+HY+vWrcNMmc87ZtK7MZObm0trayv5+fkUFxezbds2li9fzv79+2NK3Z8/V9U4E4rCTdYOpbOzk927d5OUlMSqVavQ6XSKW8FMJtLX3d09uL+VK1ei1WrJT85BDpzbX6jTrgQDddqJu3hHohZF1AjMx4A2TJOFqFdTuySdv2mC3PXl5/nBV1+ktjIyO4JwrNxYTOeJrjEflySJv37jTXwLMuLSuDEW7R3OCS/Gk+Gdh46Ma80yEe+7ZTm7345k5sX00NFq57e/3UldoQVtop5bP7SaW9+/kgWZyZx56ww1r9dRs7ORroZepCg7SpUmOd/Cqar2CY+rq+nA7fRSWDJxfVcsWBJiE5KyL0iOSYc+gtdSckoC3R2OCY+TJAmXe/jN6eD7ISCxevmqMM+KjelM7yot+maYIRpuuOEGtm/fDsBnP/tZvvnNb1JaWsptt93GnXfeGfV6F12kL1aBJssytbW11NbWMn/+fHJyzpnzKtltG+t6sizT0NBATU0N8+bNG+YbddnKjfx7z8Nwtqg/OEQYOYnuPB34yA2e6xpL6vLSMcaxolqkfVEGL0oS7/x4O2sSjVx94yJWXh5dJ6NWqyZoH1uc/v3bb9FdmgoxRMMmQ7Mk093QR2qhVfG1B6xZFo1rzTIR1iQjrW19Ex84DZypt/Gnv+yhIduEKIr0+s/d5BSWpFNYMuBlJkkSJ4+1ULm9noAKRJ2a1FlWLJmmKTWdTc5JpGpbHbMXjN053WtzcvxIM5crWMc3kpRUI9IZG2KUdbMJNhfrro5sX+ZEA9WVbRRMYJHY1tyHMX1EfaEsAwJCQObKy6MrSRiP6Yz0ha7FoijidDonVdN30TIT6YuZH/7wh4P/fcstt5Cfn8/u3bspLS3luuuui3q9i0r0xWrQHAgEOHr0KP39/axZs4bExOEfxEp228ayXjAYpLKyku7ublatWjVq3uLaNWWoXnyA4FnRFxhy7Uz0CfQQICnCl8K/tXZu9iUNfr2kTebVfg/iOKkgURTpm5fKNuCtpw6w+onDXHnVbK64aVHEF/KxxrHt+NNh6gwaME+9nYMvz0LjkXbFRV+k1iwRIYPPF4jZFDge1FZ38PBThziTmziYanBKUtgPdlEUmb8kl/lLBm5iAgGJ8r11nHqtHtQCqgQ16aXJmOJsHaRSi0jjvFT9viA7Xj3JpmviJ/gACotT0Ve24kuNYsKP08ecvKSI32sarQp/cOLrT3enA1Pu8O5wSR4Q4hoZlixRroloOmv6QucWBAGXyzUz5myGaaWsrIyysrKYn3/+fBJMEdE2cjgcDg4fPoxer6esrCysV5TS6d1oIn0ej4dDhw4hCAJlZWVhW/kTEhIwo6L37NeBIa6VVwRMHE70sdEe2UtBFkV0Q6oC3uc283pdD/LiyASKtzCJncA7u2p44aXjXFJWyHvvWIV2Aj83JHmUqXbV2w0cOt2Db05sJtiTRlTeuiVaa5aJuOaGRRzcXU/ZpZP3iVOCk8da+Ns/jtKaNbyz02PRc+JYCwuWjD/ZQK0WWbm+mJXrB8JQHo+P/e/WUnOgDbQiWrOWjNkp6ONQxyiOYdIsyzKvvVjBJZtmx12YJFoNJGtURFosIcsypn4vCy+N7vU00c8hyzIut4+RfcSSJIEootdoFTVTns70bqiJAwbqpZXyHpxhhkh45JFHxn38tttui2q9i1L0RSqo2tvbOXr0KAUFBZSWlo6ZTpqumr6enh4OHz486A84ptmqKJJhShwUfdKQHyMBNXZdZHV9fQTIHDGTSo+IudOFPaIVziFnmDmUAQfOdPLqnU9Stiibmz9ThtkS3o4itzAZZ497MKJj73Ty6t9P4FyuzED3WGnq9eB1+tAlTD7SGIs1y0TkFqTwyguV54XoO3KgkSf+fZyOrNEfmpJFz76DZyYUfSPR67VsvPLcPFuH3cOut2o4Y3eDVsSQpCd9dsqocWOxoEvU4bB7RjVo7H37FHMWZKI3xD/aLAgCSYn6iEWfutfD6qXRz4lWqcZPnffaXIjG0ebAUlAGEYz62G1lwjHd6d2hJvwz6d0YkOVpSO9eGCM5Pv/5zw/72u/343K50Gq1GI3GGdE3HpGmd2VZpqamhoaGBhYtWjRhOH86In2NjY1UVVUxZ84c8vLyxq1vUqlUWFQJwIC4C4w41OXzIyEjTmDd8i91H9f6Rts95HT46QtKw0a9RYpo1nFiURqVPjfb73qGtcXp3PyptWTmW4cdd9m1C/jHW8eZc1khUkDise+8Td+K6RV8ALYMM/UHW5lzScGk1vG5fJx48TSfi9KaJaK1vQGkoBT1pAUl2fduLU+/UYUtM7xZtCAK9Honb6VkStSz+bpFg193dTjY804NDrcftCLGVCMZs5NRx2DcnV6SxJGDjay/fPbg96orWxEFgaxc66T3HikWkw6p3z1xNE6SSQpIZOUmjXtcOCYqB2hr7sUSTryf/Vw3G5VtdpjO9O7QKKPT6Zxp5JhhSunpGd2vX1NTw2c+8xm+8pWvRL3eRSX6YGLLFp/Px5EjR/B4PJSVlUUUyp/KSJ8kSRw/fpyOjg5WrFhBcvLEtgiiKJJlTkP2NSJo1fhHaLu5djWndD5me8dPiXnVkBAY/WF5vU1PTV0vgZLYLRpErZqGJRnUSRJv/M8LrM1M4vqPLGfOsoEoRVFpGn1/G4gnPv7/3qBrYRqIU1fIPyYmLZ3NdiYzJXay1iwTsf7SEiqPtLBoeXRRNKXY+XoVz+2tp28MwRfCoWBdbIjUdBPX3rhs8OvGum52v3kaVzCIqFORWmAhvdAakSA2WvQ0DPE+7Gy103C6i/VXzB7nWcqTnWOBg3aYIIWt63JyaZRp3RDaCUSx0+nDKo4tflSIlJeXk5KSQkpKStjRZZESmms+3TV9wEz3bqxI0rk7gqk85wVKaWkpP/zhD/nIRz7CyZMno3ruRSf6xhNodrudw4cPYzabKSsri7gmZaoifV6vl8OHDyNJEmVlZRHP9xVFkY0rN/DizoeQsswER0yiXiAbeD3BPa7o8yCRLIX/ICjGgOWMg+5JiL6he+1clMGLwFu/3sFqvYEt71vA2s2zEZ0BXvnFXs6kGcEw/tzJqaS+oY/1I+oNo2Gy1iwTsWRVPn95YOe0iL7XXqrkhaNncKZPfPPkNmqprelgVml63PaTX5RCftFADagkSVSfaOPgtnp8SKgMajJLkknONo8aFzeIduDD3+vxs+etU1x57dRPEMkuSMa6qw77OKJP9gfJMmoxxlh2oDdo8Lh8YS1eXE7vqGzB4HllGWSZ4vxCUlJS6O7u5vTp02i12kEBmJSUFFV93lDLlOlgZE3fjOib4XxArVbT0tIS/fPisJfzGpVKNWpgMUBLSwuVlZXMmjUr6nFqSlu2hIv09fX1cejQIZKTk1m4cGFUF0BRFFmyeAnGl304soZbtgAICLjE8esfXlL3cplv7EhNUreP7oh3FBn22am8Drz1QjnLny6nsbGLziQjgdnT1LgxBp1GDS3V3eTMiX4SiBLWLJHgdPhGNcLEmxefKefl0x140yIrfA8mG9i9uy6uom8ooigyd0E2cxcMjL8KBCSOHGig+rU6ZJWA2qgmfXYyphTjOZ9PnQopKPH6i5Vcunky8d3Y0WrVJBu149bRGrpdrJuEdYw1xUh3p4OcgtE3cs0NPVjzw0/1kGQZ/BKXXXIZeXl55OXlEQwG6enpobu7m+rqanw+HxaLZVAEGo3GcV+XQy1TpoOQ6JNleUb0xcqMZUvMvPDCC8O+lmWZ1tZWfvOb37B+/fqo17uoRF+opm9o964kSZw8eZLW1laWLl0a0dDskcQjvTt0vebmZo4fP05JSQmFhYVRf3CLoogoiqTojTgY3r07eE5XkH6CmAkvJnvVMkmBsV8uC20Cp3rdk5oLOhb+PCu7JYmiRhuZ/iCeI+3Y1SKuQgso0EAxWaScRE4dao1a9ClqzTIB8xdm0VDbTWFx/EfUybLMs48eYFtrD4GUyIveBZVIl2v0DdlUoVaLrFhbxIq1RcBALeT+d+uoOVCHrBXQmrRoTVr++cRBVm2YhXoabXCsiQYYw4VAcPmYnW1BPYmJJuZEPQ2nOsOKvn6Hl8TU8BZNMjJicED0hVCpVKSmppKamoosy7jdbrq7u+nu7qa2tnbCKGDoBnimpm+Gi5Hrr79+2NeCIJCWlsYVV1zBz372s6jXu6hEHwwXVF6vl/LycgKBAGVlZTF3ZY0VPYyVUORQkiSqqqpoaWlh2bJlpKbG9oEdihwmaRJoQAqbmtngMlJh8lHmGPycmTkAAQAASURBVC3aAkgkyeNHFjf7zbxW3YNztfKiDyD/aCff/93NPPjAW6y4Ywkel499Tx+n6VgHfZKMMyOBYEbClE7kGEQU6elyR/UUpa1ZJuKyLXN5/E974i76JEnmiT/v4Y0eJ3JS9O+n/gj84aYKrU7N+itKCd1LuxxeHn1wF302J5VHmkm0GCgqSSXROvXdnFaLHqndPmosnCzLmOxellwyudeVVqfGH8Yb0+8P4vWN3XAjy6ARRUpLw59fEASMRiNGo3EwCtjb20t3dzc1NTV4PB6sVuuwKGCoc3cqo9RDGVnTN9O9O8NUoqQHMFyEoi/UyNHT00N5eXlM6dKRxCPSJ8syBw4cwOfzTUqQwoCIlCSJZF0i0EtAGLgjF4Z061pR02PwQ5jpS9vEPtZ4x7+71SJi7fSirGvdAJLLx+ULs0nPsaDyygQDEnqjlktuXzrwuCRR824TR9+op88TpM+sJZCfCDF0aMZKt9uP2+7FkDixP1xvWz+eqj5uuWvDFOxsAFEUsfd74nqOYFDi4T+8yzseL1hjGxfm1qlpb+kjIzt8+nC6kGWZXW/WsHbjLPYfPEPK8gx8bj/vHqgHT5AEvZbERD2FJalYksZPVypBwaxUNNXtBFOGvy/Vdi8rF2ZPev2BrMjon6G5wUZi7thlHrIkY9DpIo7KqVSqQYEHA6Kqu7sbm802GAU0m8+aygcCinr/RcpIy5YZn74YmEnvxsw999wT8bE///nPJzzmohJ9giAgiiJut5sDBw5QWlpKQUHBpC/QSos+p9M5uO7atWsnfaELib55ebPZ3vUufgGCjP7jO/2BUWIQoF0VJEuauHEis9tPU0BCmERaKRwLa/q49XebAPjgp9fx/KvHmLP13IwoURSZszGfORvzAehp6WfH0xW09nlxigJSVuKEnY6TpTc3kdr9zSy4cta4x/lcPmr/Xcenv3B5XPcTjvTMRLo6+klNH7+LNhb8/iAP/XYnewRp3OksExFIMfL2W6e4+YMrFNzd5JAkmVeeO0LxvAxyC5I5XN4EgNagoWDFOYHl9wTYe6SRoDNAgl6L2aSjsCSVpJQExUVgcloCSYgMnUgtSzIWX5C8wsk3VAGjoogA9j4PxrxxRB8yCfrYb1DDRQFbW1uRJImdO3ditVpJTk4mJSWFhATlf6/hCKV3fT4fgUBgRvTNMKUcPnyYQ4cOEQgEmDNnoI64uroalUrF8uXLB4+L9L1wUYm+YDDImTNn8Hg8rF69OiK7k0hQUvS1trZSUVEBwMKFCxW5sw2li2+6+kb++KvtBEQBPxLqEfV7Bf0ijWofBYFzAklCIkmlDln8jcs1/UaO1vXgL1Wu0ULV1s+1m+cMTuwoKEmj/4Hx58kmZZu54QsDY2p8ngC7/3mCmppO7AEZf7IB0kzK270YtHS19I97iCRJHHqskk9/9rK4WLNMxLU3LebFp8q55iblxmPBQCfrH3+zk4MGETHMxJpoEDQq2trjES+OjWBA4sWnD7N8bQEpZ8XyWH87jV5N3tJz9ZkBX4CDx5vx93lJMGgxJejIn5VKavrk5wYLgoDVohsm+jRdLi7dOP5NRzSo1CNr62Scbh9jSTpZlpEkMCtU8xaKAoqiiN1uZ9myZYO1gHV1dWg0mmG1gPGKAgaDQTQazeDN+ExNXwzMRPpi5rrrrsNsNvPwww+TlDTgudnT08Mdd9zBxo0b+dKXvhTVeheV6Kuvr8fj8aDT6RQTfKCM6AsZQjc2NrJ48eJBaxal9idJEitXrsTslvDpVPiRR41QWhE08GaSl4IhXpB7NC6W+iKr08tHT2KTk24FRd/qvgCbPjBcpMydn0V3fS8pEcy81erVXHrLIi49+3XN/ib2bq/H5g3g1qkhxwJaZdLAbZ2ucU2Q9/3tGB++fW3crFkmQq/X0m1TVlA5+j388Tc7OWrVIqqV+T2eL3V9Pm+AF546xIZNczAPmcKhjjB1qdaqyVmUMfh1MCBxpLoV7z4PCXoNCUYdeYUpZGQljm0RMw5Wsx7cA7XEciBAul6FaRJR1lH7H/E67mjtQ58y9rVAlkEGksxWxfYA5yJtBoOB3NxccnNzCQaD9PX1DVrCuN3uYR3BSkYBQzV9M6JvhungZz/7Gdu2bRsUfABJSUncd999bN68eUb0jUdRUREWi4WDBw8qum4ofRorfr+fI0eO4HK5WLt2LSaTadJrhtufKIpYNHpatS78jO7gFRFxqYafs8UssdoWuSdecpdy1i2JVd3c/NHVoy7eN96xmu9/40VSPr406jVLV+VSumrAr87e4eDNvx+npcuNU5YJZidCYuwfms16FW1V3WTPH90Bfvi5E1y9dSFpGfG1ZpkIg0GD0+ElwTT5dHevzcUfH3iH46l6RTsrXRqRXpsLa/L0Fcy7nF5eerqcK6+bj14/XKTH2hWrUotkzz9nRyNJEpU1HRw4WE+CXkuCUUtuQTKZOVbECERgRoYZ6XgrolGLrsvNpZOwaAmHTq/G5w0MRtm7OhyYc8ZObcpBCUmG/Ow8RfcRbhqHSqUiOTmZ5ORkSktLBzuCbTbbYBQwlAZOTk6eVBQwVNPndDoxGAzT1kU8w8WJ3W6ns7Nz1Pc7Ozvp7x8/uxSOi0r0qVQqNBrNMMsWpdaNNdLncDg4dOgQCQkJlJWVodEMCCwlvf+GCsgkTQKNuh78hBeUQU8ANxIGBi5sCahG1fiNx9JuONXtQo7CqiMckiSxzmxk0drR481EUUQbFAj4gqgnEaVLTDfxvv9aDQyk4va9XMOJyk76AhL+RD1kmqNKA8tZFs4c7xwl+k68UcfyuTnMnjf+OL+p4H23LGfna9VcefW8Sa3T2W7nTw/upipN+Q9Bf4qRt3fU8N4blU1DR0pvj4tXnjvCe25aGlbgKZWaF0WRrDlphMa5SJLEyVobBw+dQadWYTJryctLJjs/Kew5C2alYtrfgAsozjBNyqIlHBarAVunk8xcC7Is43R50TO26JMkGTkYZNNlVyi6j0jm7g6NAkqSNNgRXFtbS2VlJRaLZVAEmkzRpddHir7p6iL+j2ZmIkfM3HDDDdxxxx387Gc/Y/Xqgc+rvXv38pWvfIUbb7wx6vUuKtEHA927A7Unyg3wjlX0dXR0cPToUfLz8yktLR12MRlvFFu0hESfLMuk6MwEdCr8hBe+ZQ4DlQleVjoNHFY5KXZEJ6quDCby75peHJMUfbnHOvnId68e8/HbPnsJj//9APOvU8byRK1Vs+76eay7fkAM1R9tY9crpwe6cjUq5FwL6CZ+u3R1Dk+fNh5tI12lY82G4jGeMbVYk4y0tfZOao3mxh7+/PBeTqcb4xL1EHRqmprGsx6OHx2tdl57uZL33rx0zJ9tZNpTKURRJLMkBUrOTQypbezj8NEm9Fo1CQYtOXlWcguSUatV6A0arAYNcp+HlZO0aAmH2WqgudFGZq6FXpsLwTh+xF+WZJBgwwZlu9KH+uRFgiiKo6KANpuN7u5uGhoahnUMJyUlDd5oT3R+p9M5Y9cyw5Tz+9//ni9/+ct86EMfwu8fKK5Xq9V8/OMf5yc/+UnU6110oi908VBygHe0ok+WZU6fPk1dXR2LFi0iM3N0BEjpSF/ovMtnL+HVjiq8wtkCnBFkoOWwwQ1OOJUY5Iae6Hz31IgkdXnCOb9EjOTxc/ncTDJyx7btyMy14mqMPrQdKYWLMylcPPB3cdhc7Ph7JW11Pfi0KpzJBiSLPqwnYLPDh9PmIiHZSG9bP94aOx/4ZPSu6fFElsHnC6CNwVy4/lQnf338II1ZJuKZ5LJPw116Y72N3W+d4vpblo97nNIRtbEQRZG0wiTSCgdqeSRJorHZzpGXW9CrVZiMOkRvkKWz4zPBRG/Q4PUM3By2NfdizRq/a1UKyqgQyMnJUXQfk71WGwwGcnJyyMnJGYwChtLAlZWVJCYmDorAcFHA0PndbveUdQxfcMw0csSM0Wjkd7/7HT/5yU84ffo0AMXFxTHXll5Uoi80kQPOdWQpQTSiLxAIcOzYMex2O2vXrh30oAq3ppKNHDDwM9907fv52euP4xXlAd+WMDiDA9YtCWJ0qd0QWd0BGv1BhBh98uZV2bj1N++f8LhFy/PorLGRVqpcU044TMlGrv3UKgCkgMSR109TfayT/qBEv16DLz0BzkZ/+vOt1B5oZc6GPOperudTX7wsrnuLhatvWMTBXfWUXVYS1fOqKlt59NkjNE/w4a8ETlHA5fBiVKD2MBJqTrZz9NAZro2gs3k6Oq9hQASm5llJzbMCYO900n2sBbGtj/b2fvQ6NUajluxcK4nWyachBUFAPOvV53T6sIrjf8hIQQm1WvmZ2EpmZYZGAUtKSvB4PIMdwaEo4NBaQI1GM5jenTFmnmE6SUhIYPHixZNe56KrSA159SlZ1yeK4mDKeDycTid79uwZnAAyluALral0pE+SJObPn0+CJA6IvjFIdwq8KzrId8Ym2q5zmNCd7pn4wDAIHQ6uuWIOesPEHx7XfWg5DW81xnSeWBHVIsu2lnLLV9bxia9v4Jb3zGJul5PMuh6MDb0QlOlssXP0iRPc/l8bpk0gjEduQQotjdH9fY4dPMOfnyufEsEH4Es28u7bp6bkXMcON3HiWAtb37soouM1WhVSYHqjCM5eD8d2NRJI0JC3LJOspekkzUtGlaXneG0Hb++oZs+7pzlysJHG2i5840zRGA8BEZfTiz/M6MaRSJKM0aD8RJ5o07vRoNfrycnJYfHixWzcuJEFCxag1Wqpr6/nnXfe4eDBg9TX13PgwAHsdvukOndtNhsf/vCHSUxMxGq18vGPfxyHY/ycyGWXXYYgCMP+3XXXXcOOaWxs5JprrsFoNJKens5XvvIVxevWJ00o0jfV/2YYxUUV6QuhtJlyqDNsvDvSrq4ujhw5QnZ2NnPmzJnwzlXJSF/ojj+0nsWQgF/0jnl8mc/I/boOPu/JGPOY8chCS2Kzk6650Y/8WtXtY8sHl0V0rCiKGAQVfk8AjX56XsrZc9J435yBxg2X3cPe56uoOdzG0qU5vP3aSWbPzySvKAW1QnYmSuH3B8a1lxnKnrdP89QbVfTlTF3nsWDUcPpML1fF+Tz7d9fR0+XgyvdE3vlqMutp6/diSorPyMGJ8Di8HHm7jr4kA7pu17DH1Fo1GSMi373dLur21KJCQK9VY9Brycy1kByBabRKK3KmwUZS7sR/eykoYYqDnYmSpTjjIYoiSUlJJCUlDUYBbTYbzz77LA899BAAVquVJ598ks2bN0dt+/XhD3+Y1tZWXnvtNfx+P3fccQef+tSnePzxx8d93ic/+Um+973vDX49NNoYDAa55ppryMzMZNeuXbS2tnLbbbeh0Wj4/ve/H9X+Zrg4mBF9ChC6IAWDwVHWALIsU19fz6lTp5g/f37E9S5KRvpC0c3QeikmC36NDcLoPg8SLyc6EL0CrdogOb7YXiIpXT46ZTmqFJPxVDc3fXhFRHYVIT72+Uv56992s/CGObFsU1GMiXrSU41c8ZkN/O5fFew4I6LeX0+qL0im1UhakpGUJAOlpRmUzMuYNr8+gJXrizlxtIUFy3LHPe6NbSd5bnctrikUfCHsCr5Hw7HzjWokSWL95bOjep45UU/9mf5pEX0+t5/yN+rotRpAFCGC8gtTihHTkMaqQECiqqEL95EmjFoter2KpCQjWblWdPrhEXa1WqTP7sGaOvHPKgVlkq3KeXQOrqtgejca9Ho9WVlZbNq0ia9+9av8z//8D3v37uUHP/gBH/nIR1i9ejXvf//7IxqTdeLECV555RX279/PypUrAfj1r3/N1VdfzU9/+lOys8cenWc0GsPWfQNs27aN48eP8/rrr5ORkcHSpUu59957+drXvsZ3vvMdtJM0S5/hwuOiEn0hARKav6sUoWHgI9cMBoNUVFTQ09PD6tWrsVginycaj3m+oUhfWkISAbF+2OMugvw70UmCSs0VPUZeN8kcxEmrXs9Ke/R1Vct7VFR1uyE1shoYSZJYr9OzfEN0EwVSM8x4Ws6PCQ4txzvINZkou7yU5189QbVaRMqz0gF0ACAj9Tjg5Q5SnjpIWoKWjLNCMDcniQWLc7CmxH9uK8DilXk8/sdd44q+f/3zGC8eOYMve3q8BZ3E3nAyEa+/XEmixcCCJdE3HSSYdXj7x46Ux4uAP8iR7aexWfVnBR8I4bqxJkCtFsksToYhDeWOPg97D9QjBGX0Og1GvYbMbAsajQqPL4JxPAzUuy5YODkroLDrStK0iZfQNTM0Gg7g0Ucfpbm5mVdffZWurq7xnj7I7t27sVqtg4IPYNOmTYiiyN69e7nhhhvGfO5jjz3Go48+SmZmJtdddx3f/OY3B6N9u3fvZtGiRWRknMvKbNmyhc985jNUVlaybFlkWZO4M9PIcd5wUYm+EEoLqnBrut1uDh8+jEqloqysDJ0uOuGkpDnzyPUWz1pACwMG1U4CvGxxYRHVXNWTMOjPt9ahp9koo/VI/DOpn/f0JKCNogT00qCJF2t6cEQo+tIrO/noN7ZE+VMNsGp9Ea3HO8kMY4o8VXgcPvrKu7jp7ksA+PAHlvP9Zw/jyxheAyeKIqSb6EmHHqAawOVFOlSPaVsl6WoN6UkG0pKMpKWaWLAoe0yftsnidvmQx4jGPvvUIV491U4ga/rMpL1JBva/W8f6y5WzI5FlmX/94ygFhUnMmh1b+YLBqCXgntqaqWBA4shrp+k0nRN8EEmcLzKMFj3GxeeMyaWAxOkmGx01PYhqgfZT3QiigKgS0Zu06Exa1FrVsNeOFJTYuim29/B4TFV6d6xzA4OWLaGavpycHO68886I12lrayM9fXiXtVqtJjk5mba2tjGf96EPfYiCggKys7M5evQoX/va16iqquK5554bXHeo4AMGvx5v3RkuXi460Rfq4I2n6LPZbBw+fJjMzEzmzZsX0wUrHinoYDDIiRMnmF04m6pgkMcNPZglka19JvQjBF0GWo4Y3VzlMpDfE+BZi53LHQlkBiPrzhuwbvFGZN0i+QJcWpJOVkFsXbhbblrKfV97flpF37EnjnPXFy4f/BBcvDyX9CcO0hTh80WzHpdZTz1QD+D3IzV0ot1TR5okk5FkIM1qJNlqZO78TGaVpo1KxUVLybwMGmu7KSg+V3spyzJPPLKfN1p7kNLHbjSaCmSTlkMn2hQTfZIk8fxTh1m0LIfs3KSJnzAGOr2GoDe+qeehSJLMse21tBvUMFV2MWoRvUUPAqzbeO73HwhI9HY76Wzvp9flBxFElYgkQL/Nxbp16xTfy3Sld+Gc6AtZtoxsvvv617/Oj370o3HXOHHiRMzn/9SnPjX434sWLSIrK4srr7yS06dPU1x8fnh/RoIsS8jy1L1nQuecYTQXneiD+EX6AoEADQ0NVFdXM3fu3MF0QKzrKRnpEwSBkydPIssy119/Pb+86/Pc5UtDN070rtvhQUaPCTU391l4McFOoahnWX9kUcucrgCNviDCBFMz5h638bFfR+8sPhSTVoPX5Uc3gYFsPDj4WAU3f3gluhHNJJcsz+PJ0+1IMY52E7VqAgVWWoFWACQkmx3h2VZSXT4yzPqBOkGrgYKCFOYuysJijdxSYuNVc3jmL/sGRZ8kyTz84C529jkhZfrniwqCQK9fmYhaIBDk2ccOsP7SEpJSJ9eBLIoCqhhm5caCLMtU7qijRS2CZvTlOl67kCSZzmobqWnDf1dqtUhqhpnUjNE3BBUHW0lJiU9NX7y6dyM9tyAIuFyuUVG1L33pS9x+++3jrjFr1iwyMzPp6OgY9v1AIIDNZhuzXi8ca9asAeDUqVMUFxeTmZnJvn37hh3T3t4OENW6M1w8XLSiT+mWdkEQqKuro7+/n5UrVw4bjhwLSjZyOByOwbvUNWvWoFarMS6eRWt5D4WBsWtlZvu1NKr9FJw95jpnIuVaNy9ZHWztTeD/s3fe4XGVZ9r/zZmi0cxoNOq92bKaiyTLVrENBmwwNbQQCIQWAoFANoRNssmmfZsNyW6STQgJWZaEBEggEFggdDA2zd2WrN6s3qVR1/RyzveHmLFktZE0kryx7uvSBZ455z3vtPfc7/M89/0o5rjlXG3RcfLUIPb1s0TgjCYuPW8tgdrF1ezc8fULeeL3H7Pps/6vKZoNpz5soSgvidiEqZ/3dTfm8N43/k7/Ivr5nglBECAmiAE43ePYbEM81ID+9Qoi1QoiQzSEatXExQWTlR1HVGzwtOIYQRCwWMZr00S3yBO/+4QjDgdCyNnjRWaXxqNLizFEdthdvPiXE1x8RSZanX8+i6XqyjERkiRR80kr7S4RZhD9LFX9Z2dVH5s3J1Bd1uXT8b1dI+RsLFySuax0etdzbYvFMsWyJSIigoiIuTMMRUVFDA8PU1xcTF5eHgD79+9HFEUvkfMFpaWlAMTExHjHffjhh+nr6/Omj/fu3Yterycry7+9mFfxj4FzjvTJZDK/CzlsNhs2mw1Jkti2bRtq9eJvLP4ipkajkbKyMlQqFcnJyV518e+e+BNf3LmLB8ZCZzRgznUHsj/ERtLQ6RtOjiOQEYeLPwcMcrlDT5Q0c2QtAhX6bjPG9TPPb6vRzhX/tmXmA3yEIVSDo8cyY43aUmCgbRi9VcaW7dOLTwRBIDNGz8d2FzIfWrgtBoIhEJMhEBPQBCC5EBt6CDzYSBQyb3o4LFRDemY0SanhKFUKwsJ19HaN8MJfiykWJOT6lbEhmQmu0EAqTrSRW5i8oPNNYzZefb6Ey6/NnhKJXQwUyxB5OnWknRarE7SzRNal+Qs55sJIr4mQQDUKhRy5fO7fkiRJtDUP8sZLT/h9LrDy6V1PlNFisaDTLSxKnJmZyaWXXsrdd9/N448/jtPp5IEHHuCmm27yKnc7OzvZtWsXzzzzDPn5+TQ2NvLcc89x+eWXExYWRnl5OV//+tc5//zzvSa9l1xyCVlZWdx666387Gc/o6enh+9973vcf//9864jX1Ks9t49a3DOkT7wb3p3eHjYK9hISUnxC+GDxUf6JlrFrF+/no6ODqQJN4isrCzMm6I5cHKE8yzTR3YEBCzTmDgHo+AWu4HnVcOkS2oKnDOnAkP7HfTNQMQ0TYNcd2PuvCxaZsN5F6fTUNZLXM7SpzVcDhcd+9r58kMXznrcl+/bQekP32IsybDkczoTglqJPclAG9AGILoQe4YRytqJsruJDtYQolXx8X++T2ukFiFi5VO6Z0IKCaT4RMeCSN/ggJk3Xy7j6htykfu5Fs4XMrQYNBV30jhsh6DlvXG7nW6GW0fZtmMtXe1DRMUa5jynu32YYEP0kilsVzK9eybpC1yE+fSzzz7LAw88wK5duxAEgeuvv55HH33U+7zT6aSurg6LZdx7UaVS8f777/PII49gNptJSEjg+uuv53vf+573HLlczhtvvMF9991HUVERWq2W22+/fZKv3ypWMRHnLOnzNC5eDDo6OqipqWHdunX09/dPIlWLxWJq+txuN1VVVQwMDHitYrq6uqaMd+tnPs9T7b8lt82NjukXVaXVzRhugs54XkDgZkcoB4QxXlQNcb3DgDBNxLBwSE59nxnpDBWrKIpsk6vYcuH8WoHNhp2Xr+fDb72yLKSv+JlK7v7KeXMSVo0ugES1kkpRQrZMdWCzQVAIEBdML9AjSQSV9ZLW7iC90U2FYZiRYAX2IBVitA5hkSl3f0AmkzFsm/9vtbtrhA/eqeGaG3OXJEq0lOnd1vIeGnrMSMFzbyD9PYuOyj625icBMDxkJWnN7DV6kiTR0jTA6y+/6+eZnMZKRvomEs7FRPoAQkNDZzViTk5OnnQPSUhI4KOPPppz3KSkJN56660Fz2t5sBIdMlYjfdPh7OsRtcTwh3pXFEWqq6upq6tj8+bN3rTpUqht5wu73c6xY8cwm80UFRV5vQGnG+8bX/0GjvRwXtPP7HN3nkVDZZBjxud3iEFsd2j4g6qfQabenLeLOnQNw1Mej67q5+av+F/pZ9AGYjPNPF9/oPR/a7j6mmx0Qb5Fde+6s4DAHl90zMsLbeMQ19aKhLkUJIsB3D4YxD81B/LVchkFH/QReqADZXkvUtswkmN5lXcTYWLuFocT0dY4wIG9tVz9uaUhfMCSRZ566vs51TqCywfCB/hVyTHQPkJchB7lp76ITodrzvevo3UIlSZoSevHzpaaPrPZvNp7dxX/53HOkT5YXHrX4XBw/PhxhoaGKCoq8qrVltJM2VeMjIxw+PBhNBoN+fn5k1LN0/n+CYJAdnQqJzdoOKWwTTumDgXDAbNHMCNRcYcjlL8rR6hgclsoAYHQgckkTHS42JkUTsLa+bdpmwt3ff0C6t5cup6tzcc72JgSxZr0yLkP/hTJqRFEuf1fe7UYqLrH2F5hIdkdwFZXIPWq02bDagQucAZxlzGIBxvVfLnYzfr9XQQf7kJR1YfUNYrkXr5dtC1UTUNNr0/HNlR0U364mcuvz1nSOS1FzLaveZCa+n4c8+j04a/yVYfVibXPQtKa079Jp2v29UwUJdpaB7nn9rv9M4kZr7PyNX2SJGG1WhcV6VvFKs4GnLOkbyEiiZGREQ4dOkRAQAAFBQWTdn1L5avnK7q7uzl27BiJiYls2rRpSiRiJhL5X9/9GVKIhjcNNsQZ3P1tDheuOZz/BQRudYbRIzh5k6FJYyX0u5Hsp9/vtOoBbnnwPJ9f23yg06txGm1+TbV7MNpvRtZh5byL59/y7fIL16EYtPp9TguBMGIjq2yEQss4uZAjYFNISDN8xsEouMKq554eLV+vD+C2o3bW7O9Ed6wLocaI1G9GEpeO1ErhGg4daJ7zuKpjbTTW9nLhNRuXbC4eKP0szBnsGKG2qg/rPCx3/AVJkuisNLK1INn7mMvlnjM71tY0gFOm5Gtf/dqSzu9ssGyB6dW7q/ARno4cy/23iik4Z0nffAlaV1eXl1RlZ2dP6bHrT4sVzxx9ifRJksSpU6eoqqoiOzubNWvWTCuamKnDR3JyMimKYGouiuZD/fSkZNOoklNq31KmF4p6NqDhzxgZY5zoXWXVoa4fHJ/vkIU929ag1S1dgfquq9bTfqLbr2OKosipVxu48Y6F2VJcfHkWYSvQumsKbC7iS4xcNTA5mpRoldMl8612LhoVnzXpua9Ty9drFVzzyRhxH3SgKe6G+n6kEf+SbpkgMGia/b0r/qiRvt5Rdly2PJY9SoX/OuaM9JioKunGtCDCt/hQX2/jEOvWhE+Kpg32mwmPnDmq5XaLtHcPszEtk87OTq/4wN+QJGnF07urpG8V/0g450jffC1bJEmitraW6upqcnJyZiRV/jZT9oVEulwuSktL6erqoqCgYEqbH1/Hu23PTcgR+DBKZJSpx6QSSIfGd0Ibh4obCeM1BjmFhTCUBPeME8q8TitX3bnV57EWgqKL0ugt9i0d6CuKn6ngC3cVLkoFmpsSBtbFC4gWCsktElrSwxe6ptaLZUkamlXzn5uAQBqB3DKq5/42DV+vknPRR4NEftxJQGkPNA0iWhZfYzk2C4k8+E4tNoeLfD+2a5sLGp0Kh2Xxn6Wp30Ll8Q7GQhcW4Vss5bOO2pGZXUTFTO4LPtBvJiJ65hZ8LQ39WNwy/uNHP2VgYICjR49y+PBh6uvrGRgY8Nta6Nk8rHRNnyiKq6RvMViN9J01OGfVu76QPofDQVlZGTabzSuHX+yY85njbAunxWLh5MmTKJVKioqK5rRLEARhxpT2vV/8Mr9+40laL0jgteE2vmCc6rZvnqcSSoHAjUTwAcO04yCsX2S0ZYjrrt+0JH1kz0S4QYN5yIp2HvVRM6HyzVPs3pW56E4Od9yzjSPffp3hZMOi5zRfSJJEUHkftzcrkc+w13PJRESkaVXYvkKBwBa3li2DwCDYEDlc3UeTAcb0SpzBAUgxQXN2aTkT9iAVHS0DxCefVpNKksQHr1YSHKElIyduwXNeCIL0gXQbB1EvImJtGbFRcbiNkcWYYS/iviaJEj01RrZtn9rOy2mfWcThcrnp7B1lbWyi1y/O5XIxNDTEwMAAtbW1OJ1OQkNDCQsLIywsbMFWVp41cKUtWzyRzFXSt4r/61glfTNgbGyMkydPotPpKCoqmpLOXciY88FskTlPb9+YmBgyMjJ82gXPlN71IDc6nTaxmRMbgthy2E6GbfLNLMwk0Ss4iRLn1+bsQgy0YuX40BBbXTIK9sy/Hm4huP3BC3j0l3vJuXnDosbpqu4lUR/Eej+QCpVKQUqQmhK3iGwZiO9EaBuHuLZOQsfMn98GWwANgp000X8dRNQIXOgM4kIjYIRhXBwN6KJHJ8OsV2IND8Qdo5vz/XBH6fho/ylu+eI46ZMkiXeeLyUpM4Kk1OXvuazTq7E0OVho3x2b2UHFxy0M+arSXQJ01RrZuDF22vXD6Zx5LWs+ZWQUeOyfv+N9TKFQeLtTSJKE2WxmYGCAnp4e6uvr0Wg0XgIYHBzsc+TOs2atZKRPpVKtkr7FYiUib6uRvmlxzpE+j2XLbEKO3t5eysvLSU5OJjU11acOD8sV6Wtvb6e2tpb09HQSExMXPZ4Hv/zBz/nw3ksZTQ/jnYYW1rWrkE+I+GxzaDkQbCdqZP69bZMIJEFppatnlKcefp8Lrt9IckbU3CcuAhqtCtegfVEdOmwmB6Olg1z/gP9EJ/fet52v/3I/lvjguQ/2E04rdWePesYTQI1qjLTphdx+gQEFe+x6sAMD0NVs41jgMEN6OaYgJbYoLVKEZspnJlMIGIfHJ+Z2i7z5l2I2FCQSFW9YusnOgkCNEpd5Yeldh81JxQfNDASrYZFkZibxzVwY67eglSkINkwlMaIoIs6gNnc6XHQaTUTpDFx5xZXTHiOTydDpdOh0OpKSknA6nQwODjIwMEBlZSWSJE2KAs6WpfCsqcvVZedMeIQcZrMZQRD8Zr6/ilWsFM450genCdqZhECSJBoaGmhpaWHTpk1Tmmv7Mqa/4In0eeYoiiK1tbV0d3eTl5dHaGjovMebjfRFR0eTGhhGCS6qdkSx7y0jl4ycviEoEDApFrZzsiNyaF0AIYFKLr9zKwferuHdP5eQmZ/I9iszlyzde/kNORw60klqUfy8z5UkiZN/ruSBb+zy6w0nIlpPjEygYZnaxY0rdYcpnKHrypmQkHAiolymct9YArjGGgBWEHtFGhpGKdMNMhIkx6xXYo8LAn0AMpmMMbeI0+nmtadPUHRpGsEroHT1IFCjwm2dvwOA2+mmYn8zRn3AogkfLKymT3SL9DcMseP86Y3RhwetGGYoi2io62NEJXDdebt8vp5SqSQqKoqoqCgkSWJsbIyBgQE6Ozupra1Fp9MRFhZGeHg4QUFBk34XHtK1UqTPU9NntVrRarUrNo9VrMJfOCdJnydVO1GO73K5KCsrw2w2U1hYSFDQ1Lq22eBvIYdnXpIk4XQ6KSsrw263U1RUtCCD0LlIH8B9132Je1/5BUTqOJggsHXURYh0+isi2t3YEFHPkxA8GjGKdWsiFrnAa386zh3fGm9dVl/eyePfe5vI2GAuvS2PoGD/9n3dvG0Nf3uzYkGkr+S5Sm65o8Cv/Vo9+NzVG/nF21U4l7rtmVep6/v3Jd+moUZhZ5Nr+XvwjotCNKSZABO4ukXKTg1So3Nj1iswuV389XcHueymXDQr3C1ELhfm3dpTdItU7GumV6PyC+FDkpAtYJjWsl62bJ05S9BvHCMmfmri2mZ10D1oQa9U8fOf/mz+F2Y8YqfX69Hr9aSkpOBwOBgYGGBgYIDS0lJkMpk3AhgaGrqiHn1wuqbPY8y8SvoWiNXeu2cNzknS5yFUE3/QJSUlqNVqioqKUCrnn8JcCssWgNHRUcrLy9HpdBQWFs5ZW7iY+X3+hs/z4+ceoRXo2hbLa71t3D5B1FFkUlOldZBn9j3F0Y2DxnQdsgAFMuBATS83WhwEalSkbYojbVMcZpONFx49gBwZ267KJN2PRfnxYTrGBiwEhflOfOr2t7Btyxqilyh1uHVbCpEvl9G5JKOPQ3KLhM+g1J0NBhQMyq0w/yCW36FAIE/UkjcKbaM2jmOjSYC3XiojOTmUjYVJBPjZL28+mA/hkkSJqg9a6FIJ4Mc+wMI8Wd9A5yhRBi3qwJlJs83sRDHNHBvqjIxpFBTEpPqtz65KpSImJoaYmBhEUWR0dJSBgQFaWlqorq5Gq9UiiiImk2lFIm0ThRyr3ThW8Y+Ac9KyxbNzdLvdGI1GDh8+TGRkJFu2bFkQ4YOlSe8CHD9+nOjoaHJzcxdM+MD3SGRR8iakT5V7J3OCqQw8XeAVgYr+wPntnn6baEXKPF1o374ulFeeOj7pGK1OzR3fvohbv30hjTW9/Pp7b7H3hTJcsxST+4p7vrKT8n1NPh9vbBnC4BTI25a86GvPhsINMciWyLdPkiT05b3cNotSdzaoJTBPY92zEhCROCQbows7m9FjidJRE67mzf4Rfv+HI/z92WIqjrXhci3/rt7XsgRJkqj5uIV2AJUfSaooIch9J0Euh5uR9jHWzVFP656m24rFbKdn2EKAXeTXP/vVvKfqCwRBwGAwsHbtWgoKCigqKsJgMABQXFzMoUOHqK2txWg0LshcfyGYWNO3GulbBFYtW84anHOkD04Tv5aWFkpLS8nKyiI9PX1RP2h/kj5JkmhtbQVg3bp1pKWlLXqx8SW9C/CLH/4cbcsIANa1IbwX6ZzUjcPidM/YueNMHFKa6d8Qikw4PXdBreDjqq4Z1YGXfDab+3+4hzWbovnvH7zDc7/8iEHjwvvWqtQKxFGnTx0jXA4XXR92cPVNmxd8PV/x+du2EjKwNIa22sYhrqkbb6G3EBQ6tFQrV95IegQX7zFEsqQim6Dx792nXyVBrWQoOZhyg4qXG3v5wxOHeOuFkzRUdiMuYXeQiVD4kHaUJIn6Q220ONzg71IBCeQK39eF1tIeiubYzEiShHsaAn2qphezTkmcIXxJ++xOhFqtJjQ0lMDAQM477zwyMzORy+U0NDTwySefcPLkSdrb25fMGBpO1/StRvpW8Y+CczK969kldnd3U1BQgF4/swmpr/AX6XO73VRVVTEwMIAgCN7evouFr6TPYDCw3hDLMcmGTCaj5vxY3nu9h8uHx+vP1pgE2pROkp1zp3deWiMiS5iqUm2O1fL3v53ks7dsmfHcpNRw7vvRpThsLl743UHcNhf5l6SxqSh5zuueic9/Lo+9h1vI3D672rnkmUruvv98BGEZBBaCQHp4EIecbmRK/3mQqbrH2FE5t1J3NqgRMMlFWDkfaWqw0IWD89AjfLo3Hady03Sb0asx6tUYgZKSVmI+aSIhMoj1efHEJoUsWXRGrpj7c6s/0knTqAOClqADjST5HG3sbRoiJSF0zmyBadSG9oy5msZs9JjsCGo5t9/whQVPdyHwkC5BEAgNDSU0NJR169ZhsVi8tYCNjY0EBAR4awENBoPffP0mlgCt2rWs4h8B51ykz+FwcPToUQCysrL8QvjgdPp0Me2nbDYbx44dw2w2e70B/SUOmU/N4Tfv+BryrrHx87QqDifLMcrHifImdyCNurlTK8/qRzHnTN8hRNCr+ehEm08RGZVawa0P7eSOf93FgNHEY//6Fm/9+QQOh+/pnQ25CfTWDc56TOlL1Vx9XfaStoc7E/fefx66T99nf0AYsZFVOkyBefEijFCnjP4VKOxzIvIhw4hIbJtA+OBT0jfHiiWFaelK1HNYJfHM+3X8+fdH2P9aJQN9/nufPZiu7m0iGoq7aB40Iy0F4QOfSZ/N7MAxaCMhaW7Ff3/vVBFHQ10fNp2SEJl6yfvsnomZhBwajYaEhARycnI477zzWLdunbd70ieffEJ5eTmdnZ3YbIvzH/KQPqvVuhrpWwz+j6R3H3vsMZKTk1Gr1RQUFHDs2LEZj73ggguQyWRT/q644orTL1uS+MEPfkBMTAyBgYHs3r2bU6dOLegt9BfOOdKnVCqJj49Ho9H4VRU2sU5wIRgZGeHw4cNotVry8/NRq9V+FYf4GukDuHzPFUSbT0dHevJjeD18vI2agIBZmH0cOyKH1yqRGWYmH6eCFLz3drVP8/HgvMsy+fK/7WHj9hSe+H/v8tQvPqSnc9inc9dEGxjpM0/7XNPRDjatjSZl3cxt7JYCQcFqElQKn1LPc8Kj1B30z41pi1tD3TKneLtxsI9hctCxhqnfnZkifdNBEARcMTpa43R8InPzx5fL+OuTR/nk3VpMI/4xIlTMQrhayntp7B5F9LMifRIkkCtnX8MkSaK9oo/8wmSfhrRanZMU6yNDFrpNdpCgYGPusitpJzoszAS5XE54eDjp6els27aNLVu2EBwcTG9vL4cPH+bo0aM0NDQwNDQ0r020JEne66+2YPvHxwsvvMBDDz3ED3/4Q0pKSsjOzmbPnj309fVNe/zLL79Md3e396+yshK5XM4NN9zgPeZnP/sZjz76KI8//jhHjx5Fq9WyZ8+eRW9GFoNzjvQJgkBycvK8+u/6gok2MPNFd3c3x44dIzk5mY0bN3oXOX/awMx3rIsy85E+7ZkqCAIlucGc1I5/UQPMIiOzRIEejRjFmT17sbgsQsf7H51aUGQ0JsHAvf92KTfdv503Xy7jVz99j0OfNMw61h1f3k7FNIKOUaMZWaeVHbuXp1PImbjjC1tQdo0uagzJLRK2AKXubJAjYJeJCzb/nQ8kJE4wRjNWdmIgYIZlSYIFGdMJgoAtIZiGaA37bTZ+/+wJXnz6OMc/bMBuW3gOe6ZIX0edkfrmIdxL7SMoSrMST4DO2n42ZEb7TNacjslrYlNjP059AIE2kd/+8rcLnupC4Unv+gqPMXRSUhKbN29mx44dXmuYyspKDhw4QGVlJd3d3djts29qJraAW03vLhKStAKRvvmtXb/85S+5++67ufPOO8nKyuLxxx9Ho9Hwxz/+cdrjQ0NDiY6O9v7t3bsXjUbjJX2SJPHII4/wve99j6uvvppNmzbxzDPP0NXVxauvvrrYd3TBOOdInwf+Vtt66obmM6YkSdTX11NVVUVOTg4pKSmT6o9WKtLX1dXFFRdcQUDDkPcxZ3II70c4cSJyvk1DVdD0N8suHDRmjFu0zIVqmcjhA74ra8+EQiFw+707+Oo3diE5Rf7z397m+WeOYbNOnZtKpUBmcSNOUCaKbpGyF2u56c7CBc9hsUhbH0OoZeFp1MUqdWfDGqeSdhx+HfNMmHDxHsNEoiSX2b0xx4UcixQ0KeSYkoKpDVfz1sAYT/zhCK8+W0z50dZ5K4BV09T0dTcOUlvbj2seFkELhgTKWXoYm4asKJ0S4RG+e466XKfXm0GjiR6LA0mSiDVEEB4evqjpLgSL9elTKpVERkaSlZXFjh07yMnJQavV0tnZycGDBzl+/DhNTU2MjIxM2TR61t5VIcf/bYyOjk76m47sOxwOiouL2b17t/cxQRDYvXs3hw8f9uk6Tz75JDfddJN3c9Dc3ExPT8+kMYODgykoKPB5zKXAOU36/Cn797R385WkuVwuTp48SU9PD4WFhURETO0f6s9Iny+kz0NCq6urKSoqYmN4/KSFsH5nLG+HWNGgoF+Y/r17LMmKlOFbL1Qp3sBb79b4/iJmQcF5a/nGd/dw0cXpPPaL/Tz2y/20Ng9MOubWW/KpPtDq/ffHT57kS/ftQO5H37SF4LILU5ENLUyBqG0Y5NpFKHVnQ4YUSKtq6dQcDVg5zBg7CCKCuYVBC430zQRBrWA4xUCFQcUrzX384YlDvPH8SU5V+KYADtQocUzYYBjbR6iu6MURtkwRIVFEmEEEJIkS3bX9bN6S5PNwVosDleq0ZVVzcz9OnQq5zcWXbrlz0dNdCHxJ7/oKjzF0SkoKW7ZsYceOHcTHx2OxWCgrK+PAgQNUV1fT29uL0+mcQvoWE+kbHBzklltuQa/XYzAYuOuuuzCZZnYlaGlpmbZeTCaT8eKLL056TWf+Pf/88wue55LBY8683H9AQkICwcHB3r+f/vSnU6bX39+P2+2e0oUrKiqKnp6eOV/esWPHqKys5Etf+pL3Mc95Cx1zqXBOqnfnS9B8ha9jWiwWSkpKCAgIoLCwcEajU39H+jw1KtPtnF0uFxUVFYyOjlJYWIhOp+PHX/shV/ziAcQkw/gYgSqOrFGytcyJxeLAiYRywl34kNJM//rJFi1zocJio7K8kw2b/GPIHBqu42vf3o0oirzwzDH6+sxszk9k56500tbH0P/sMdgJxa/Wctkl6wkL1/nluovB1dfn8PePGxgOmV8kQd4+wvZyC0nupYtAuGQSIhKCH9mWC4nDjKJHzg5870E8TvqWRokrBKkxBo0rgEtPthJzoImYqCA25sYRnxw6rQJYHxzI0MgYqkAlQ71jVJ7owr7UXVYmQpSYKbvbWtnH1rzZ1epnwtgzRvSnPaGNPaP02J2gCCBCpWPn+TsXO9sFYb7p3flgJmPo1tZWrzF0RUUFGo0Gk8lEcnLygq91yy230N3dzd69e3E6ndx5553cc889PPfcc9Men5CQQHd396THnnjiCX7+859z2WWXTXr8T3/6E5deeqn33x5vw1WMo729fZJgMyDA/8KqJ598ko0bN5Kfn+/3sf2Nc5L0gf/Tu76OOTg4yMmTJ4mJiSEjI2PWBc3fNX0wfbrEZrNRUlKCXC6nqKjIS0LP234ewd9xMjQhWNC/JZrXO1u4uEdLtcJKtmuccIiI/H2NNK1Fy2xwpITyyqsVfiN9HgiCwOfvGE/blh5v42f/9jZxCSGkRAVTtb+ZeL2O3LwEv15zMchODOVDqxNZoG/m4PJhKxsrRym0LW3KKduupl6wkSH6R5BgxEExJraiQzPP5UeEJSN9EyGFaekKgw5RpOSDeqKB+Eg9W/ITCY88nSrVBwdi6exHUMkpP9SONWKZNxAS00b6hntNhKiVaHXzq/E0m+xEROuRJImWlkHc2gAkl5sdW4tWrBWaPyN9s8FjDO0xh7bZbHR2dnLs2DEefvhhRFGkra2N7Oxsdu3aNa82nTU1NbzzzjscP36cLVvGbap+85vfcPnll/OLX/yC2NjYKefI5XKio6MnPfbKK6/wuc99Dp1u8vfMYDBMOXYVp+Fp+zcbwsPDkcvl9Pb2Tnq8t7d3zvfWbDbz/PPP86Mf/WjS457zent7iYmJmTRmTk7OPF6Bf3FOp3eXm/S1t7dTXFxMWloaWVlZcy6k/o70wVShiUc1HBQUxNatW6dEHT9/4ZVIptM1EDKZjLKtofRroVV1OsX7aoSV0dyFqV9LjaO0tgzMfeACkbM1kW98bw9XXL2B0SELte814XaJ1FX3TKphWknce/95aLt9tBWxuYg/2e83pe5siEVFr2Lx75GERBkmarCwE8O8CZ9nDH+md+eCIAhIUTq6o3QclVz8/tUynnrqKPvfq2Vs1IpGp2Ks38LJj1owLzfhg087ckxeQ9wukYGmYbI2zH8T5fpUxNHTOUKve/y3rbGKfPPBb/zDk74z4TGGvv/++2ltbSUjIwOdTse3v/1twsLCuPjii3nzzTd9Guvw4cMYDAYv4QPYvXs3giB47cPmQnFxMaWlpdx1111Tnrv//vsJDw8nPz+fP/7xj4uyDVsynOWWLSqViry8PPbt2+d9TBRF9u3bR1FR0aznvvjii9jtdr7whckelikpKURHR08ac3R0lKNHj8455lLinI30KRSKOdVb88VMJE0URWpra+nu7iYvL4/Q0Ln9ssD/NX2euXjQ09NDRUUFqampJCcnT5vC+vF3f8zvd2/Aufn0TsUVF8y+6GES+9xISNiROJGmRgpemHrUlBrKC8+X8K1vX7yg832F3qBh0GwjIT+WuPgQejtGeP+tahAEtIFKoqN1rM+OJy45dFkMmiciQK0kUauixi0im0WROd5Tt5db/KjUnROShAMR1QL3iFbcHGCUNahJY+FE1d81ffOBIAi44oJpB1qtdk48V0xMgJLejkFMEdpxpeAyt+iSSUypR20t66GwIGVB4zmcbiRJoq1tCDFQhSRJbFybiVKp9Ns6NF8sZXrXl2vL5XICAwPRaDTcdttt3H777TQ0NPD222/73H+4p6eHyMjJG2KFQkFoaKjPtV1PPvkkmZmZbNu2bdLjP/rRj7jooovQaDS89957fOUrX8FkMvFP//RPvr3IVXjx0EMPcfvtt7Nlyxby8/N55JFHMJvN3HnneD3rbbfdRlxc3JSawCeffJJrrrlmSiMFmUzGgw8+yI9//GPWrVtHSkoK3//+94mNjeWaa65Zrpc1Beck6VvKmr4zF0eHw0FpaSkOh4OioqJ5KcD8GenzFPm63eMLe1NTE01NTWRnZ09ZkCZCpVKRro+iQpQm1eo1nh+H/IV6umVOXoq2MZCWsOD7sSAInGzvZ8BoImwJIyavvFhCVE4Ua7Kj2ffHUr72tQvZduE67/MWk51jnzSy97UKVGolgYEqQsK1ZOXEEhUbvOR9N79673k8+OgHOBMM0z4vSRL6il5ua1b4Xak7GwqdGqoEK7ni/OvVWrBRh4Vt6FH4Y85nQe9TmVyGXQ4uSSQ2LQyVLoCulmGsDjcOEdxKGQSpYRZlrV/mgYQwgfT1t44QF65HtYB2bw67C7lcRmfbEL2SCMiRjzn49dO/QhTFFes5u1j17mKv7YkyThRypKam8tWvfpVvf/vbXHLJJbOOUVOzeKGa1Wrlueee4/vf//6U5yY+lpubi9ls5uc///nZR/pWohfuPK934403YjQa+cEPfkBPTw85OTm88847XiFGW1vblO9iXV0dBw4c4L333pt2zG9961uYzWbuuecehoeH2bFjB++88w5q9TJu2s/AOUn6wP/qXc+YE0mayWSipKQEnU7H5s2b52yBNNd4i4UgCLhcLsrLyxkaGvK5Bd3//OS3nP/dL+BeezpCKQQoMGaF8EHlGA3rDMgWeYMbTA3lxb+c4N6vX7CocWbC6LCF49Wd7LhpIwD5n1/PM388wpcfON97jEYXwAWXTe4rOjxo4fCHp+jrGUWtVqLRqoiICWJ9TjwhflZpxiQYiBKhXZKmvclqGwa5tnZplLqzIRgF/fPsySYicYQxVMD5GPwyD39Ytix6DnYXAe0jXH1RGkgSTUOjhEQHEZt6epdvMzloq+ljoN+CXRRxShKSWjneis2fEWRJ8noFOmxOLH0WsrevWdBQ/X0mIqODqa3rhU/rSvVCAFlZWdTW1qJU+lZr6m+sVHoXTkf6JEmaVr37z//8z9xxxx2zjrFmzRqio6OnGPy6XC4GBwd9qsV76aWXsFgs3HbbbXMeW1BQwL//+79jt9uXRLDwj44HHniABx54YNrnPvzwwymPpaenz5pOl8lk/OhHP5pS77eSOKdJ31LW9PX19VFeXk5SUhKpqakL2il7SJq/IAgCFRUVXsGGr4tC9qZs9EMuhs54fGRLDMVtgzgS5yfemHZuCoHy5kEsZjsarf8Xq5/+9F2KvrDJ+29VoBJFnIaDHzew/fzUGc8zhGq47LrsSY/1do6w740qxoatqDVKAjUBxCWFkLkpFp1+cTu4G67cwK/31yGeoQJVdY+xo8pK0iJ66i4GalHAhMsnwjmIiyMyE5slDcF+XGJWMr0LIBlNxLnhlruKEBQCRw80ERQ9NXKv1qlI2xrv/bcoigx1jdF+agC7XcQlA4cMnBolBCgWTGRlIiCMR4A7K40LTuvC+KZIAvqET99iu4uv3f1P3vmvZIr1bLi22WyeIqCIiIiY1mrrTBQVFTE8PExxcTF5eXkA7N+/H1EUKSgomPP8J598ks985jM+Xau0tJSQkJBVwreKGXHOkj5/d+SA09HDpqYmGhsb2bBhwyTVzkLG81fd4djYGE6nE71ez+bNm+e9e771kmt5tHkfTKjb03SO8IW7C/n7G1UMxelxzFO5eyYaY3S88b9lfO42/8re//L0EZK3xaM4IxqZvi2BA0+VsTEnDr3edzIVFRfMNTdvmfRYS4OR154/icPuQh04HhFMSg0nfUMMah8VuQDnXbiOP/+9nP4JpE8+bGV92TAF5pUzhz2fIA7JzRS5Z0+/V2GmDyc7Jd2kvrn+gFsmWxHSJ7lEFG3DXLQ5ntwJNihWm5Mg5dzRXkEQCIsPJiz+9O/D5XDRVTfAQJ8Zu1vCKUrY5QJikAp89o2UEASBvqYhUlPC5+wFPBucdje9g2ZkmvHvaqANHvza14GVT7GudE0fjKd3AwMXtuHKzMzk0ksv5e677+bxxx/H6XTywAMPcNNNN3mVu52dnezatYtnnnlmku1HQ0MDH3/8MW+99daUcV9//XV6e3spLCxErVazd+9efvKTn/CNb3xjQfNcUkzwzVvWa65iCs5J0rdUNX2CINDT04PL5SI/P5/g4MWRIH8JOfr6+igrK0OpVJKSkrKgdMmPv/djfn/RK1hzxkmfKIpsM2i5+sY8BvpMRMYZ+Mvb1YxmRSw41SuoFRyp6OIahwuVyj9fTWPvKHWdgxQVZk37fMEt63n6D4f56kMXLeo6yakRJKee3omLokhdRRd/ffIwblEiIFBJUFAA6etjSM2IQjmDqS5AQUYUbw6ZQavyKnWvHFjZbgABCAzLZv69OBA5wCgxqChk7pKBhUAmSf5Nj/oAachK6JidW2/dglo9uXDf7nDN0UNkZihUChI3RjHRSW9swEJ7rZGxURsOUcIpgUujAI1qxmigzWRHHHUSnbG4tWaw30y/SjYuSHG4SY6KmyT+WiV9limRvvng2Wef5YEHHmDXrl0IgsD111/Po48+6n3e6XRSV1eHxTLZpP2Pf/wj8fHx09YOKpVKHnvsMb7+9a8jSRKpqaneVmKrWMVMOCdJH/g/vWuz2bx1G9u3b/dLeH2xQo5xv60WGhoa2LBhA42NjQsmkYIgkBwYSvWn6tL41hFu/eZ4e5nb7juPJ3/zEX965Dr+9V/foE6rQBa3sBt/VUgAe1+r5IrP5izo/DPx8//ax3m3Z8/4vEKpIGR9GHvfqebiS6cnhguBIAhkZseTmX06zedyiZQea+Xp3x1AJkCgRoU+OJCsTbEkrQ1H/qlq9/YvbeOjf36ZseQQQo51cUvXyqR0z0S0a7y2L5zJkcsObFRipYigBSt8fYEbieUK9UmihLxtmK1rw9n52dxpj3E4/LtpDArTkLX9tCmm6BLpbRmku3UUu2tcJOKUyxB1AaCSIwO6qvvZvm32Or5xU3YJt0vE5RJxu9w4nW4cDjdOhxu7w8XwmAWlTE6AXQSXxEtv/m3S+WcD8VpueOoJnU4nTqdzUR05QkNDZzRiBkhOTp62NuwnP/kJP/nJT6Y959JLL51kynxWQ5TG/5b7mquYglXS5weMjIxQUlKCSqUiODjYb/UUi4n0iaJIdXU1RqPRG3VsaWlZVOTwmV/+gW3f+hz2KC27NsV5jWoVCoHc/ERKjrXyy19dx4t/LebZj07h3BA5q/3IdBCCAjh4oo1Lr93kJUELxRP//TEZFyXP2WYtOSeaQ38pJ2dzAhGRC43dzA2FQmDLthS2bDtde2WzOTj+SRPvv1GFQiknUKsiJExDjEKO+2Q3d7YHLKtSdzYUoOE9hYkLXOOkT0LiOGOIwM55dNZYKCQZy+IsKhuzozdauPmGHPSGmQm3c4k9HgWFQExqODGpp3vejotEjIwMWTCN2sEg59ix1nFSJ4IojnfdcYsSoiThdklISLhECZdMhlsAUQaSXAC5AIKArHOEXJOAFiW9Mhd3/Nu3Jyn6z/VIn9lsBlhUpG8VqzhbcE6SPn+md7u6uqiqqiI1NRW32z0lPL8YLDTS53A4OHnyJG63m6KiIq883Jf+u7MhMzOTkDEZkSo71389b9Jz+dvX8usfv0vOlkRu+HweF+/J4Ic/fpe28ECcIfOLVJWpZXy8t44LL81c8FybG4x0W6xsTfGtFVXhzRv4y1NHefCbu5bVnkKtVnHexRmcd3GG97GxURslR1rpbxzh4wA1MgmUSgWCDARkCIAMGYJs3KtN8PyJ4/8NFAXUIqjdMgIQCECGCgHFp+ctFAICVkQkJMZwc5hRNqAllOVRdi6156wkSahaR8gM13Hp3XObpy416ZsOap2KNTnRNB3tRKGT6NbPf4Mp+/RPkiSE1mEiTBJaVNgQCd2QRsH27Rw8eBC9Xk9YWBhO59L1X54LK036VCqVd01fJX2LgLQCNX3LbRHzfwTnJOmD05E+aQZ7jLkgSRKnTp2ira2NnJwcIiIiaGlp8WvKeCGRPo9NTFBQEBs3bpxkE7NY0gdwae55uBSnpq1Ju/uhC3nqfw5y39cuwBCq5de/vI4//eEQe+t6GEkJ8fl9FsO0fHKoiQv2ZCzosxFFkT/94RAFt2+a++BPIQgC8dtieP2Vcj5z3czp4OWAUilnwOlm+Px4dMdG2W4KBIdv5zoQMSNixs0gLiyChE0uYZeNq0YFQYbwqWejIGP8/xknkzIAl+TtzCAHAiQBDQJaUYYGOfEuOfuFUZwyOM+t97tYY3YsYZrR6kTfNsrVV2USmzC3ebrN6kSmWP60o2XERkdpDzk5ibx9sGHB40iShNAxSsiwi7UEICHRp1NQ/MH7XuP6oaEh+vv7MZlMNDQ0MDo6SlhYGCEhIcuWcj0bLFssFgsBAQErNo9VrMKfOKdJH4z/sOfrn+fxujOZTBQWFnp3gEvhqzcfktbf309paSmJiYmsW7duCmHyh9nz7371GIU7cyi6wMiadZMtBDQaFYlJoRQfbyVv63ht0p1f2sZFzf389Fcf0pWgR9T55mJ/3OXixKFmti7Ad+zJxz4m87I1k8ykfUHMunCOnqyio22I+MSQeV/XX/jbs8dpDA9EUCk4vMGFrtRKts03KxgVAioEQjw/bfHTvwVARMSGhBk3JkQ6cTCIi07RQaI8EPHTqOP/dSg6R0lWyLnmXt97zI4MWdAYltcWY6B9BHOXiV0XZ1JyrA17sHpB778kSQhdY6zpF5EhR0CgU+7iL2+/hUwmw+VyIZfLiYiIICoqiuPHjxMVFYXT6aS+vh6Hw0FISAjh4eGEhYUtmdHseC3iypszm81mNBrNihlUr2IV/sQ/wpo9b8hkMi/Rmy8JslgsHDlyxJs6nRjy9zfpm894bW1tnDx5kszMTNLS0qZdoPwR6QM48lEpj/5oH329o1Oeu/K6bPa/W4PTeXreSSnh/O6R67hQJkfbNuJTb0hXTBD7Pzg177nVVHRiVskIjl5YbV7B59bz12eP43avTGqgvWWAQw1GhE/Vy44kAx+vU9Io92/LQF8gIKBBTgQqUlCzCS2SQuBzhLLJHcAH8lHKZJZx0+RlgL+vIjndaOoGuCIvgetuzpsXuejtHSM4yr/m3LOho6oPhcnFeTvTxm1aBk0LJkOyXjMb+iTGBDdRqBjFTeFnLmdoaIiamhqMRqPXH9ThcHhFDGvWrKGgoICtW7diMBjo7e3l8OHDHDt2jMbGRkZGfPtt+wrPWrXSPn1ms3nBdi2r+BQey5bl/lvFFJyTpA8mtyXzFQMDAxw+fJiwsDDy8vKmuNSvRKTPI9hoaGhgy5YtxMXN3Gjdn718n/79i/zs229iNk0lI3fdu4Pnnp7cSFwQBL7+jV1894bNRNf2g3XuOqEToxZqK7t8npMoivztbyWs2+lbHd9MSNuTwv/+tXhRYywULz5fwuAZyuexrHDeT4Re2crVVgG4kLBIIgICOhRc6g4mRVLxESPUYkFaYvLnz9HlfWbiuszc+6UC0tfP30tzdNiK2seo9WIgukVOHWknOSKYTbnj3+uB/jGM9gWathvNZPSMp/1jRSVuJALTk3niz0+Rn5+PwWCgp6eHo0ePcvLkSa9ATa/XI0kSbrcbpVJJXFwc2dnZbNu2jcTERGw2G2VlZRw4cIDq6mp6e3sXbSzvWavOhvTuYpS7q1jF2YRzmvTNN5JWUlJCWloamZmZ0+4+/RVJ82Cu+TmdToqLixkcHKSwsJCQkNlTkv6cn0ql4tc/f4qHv/kaDsfkxT0sMgilXOBUXd+U8zZtTuB/fnk9W0edaHpMs17DlBDMu29V+zyn3/3XB2RevnbRaZiwOD3dFgsNtb2LGme+OPRxA8XW6SN6A/nRvBlhZ4zlFw94UCK3sNU92S8wBAW7MRCOnI8ZoQHrkpO/xUByi6hPDXB+Qihf+GI+igX6QbpdS592tJsdnDrQxrYtKcQlnq4zbKg34liAgINBC2u7HURKSsYkF1rk9GsVvPLh+8hkMoKCgkhJSSE/P59t27Z5a57tdjsnTpygoaGBoaEhJEnyEkCZTEZYWBgZGRls27aNjRs3EhAQQEtLC5988gklJSW0tbVhNpvnHQU8GyJ9crkcq9W6mt5dLDyWLcv9t4opOGdJH/jWf3diJC0vL4+EhIRZx/N3pG+m8TxpZkEQKCwsRKOZ27zXn6RPEASCg4P5n1//jZ/965tT0qG33FXEqy+eRJzmh6dQCPzw/13OvdtTCavtR3LO/J4d6x2lo3VgzvmcONwMkQHoQv1jYpx3dQavvFQ6KU29lHA6XLz1Xi3O8JkjCl0743gt2IxzoUV6i0S3zDljW7UoArgIA4HI+IQR2rAt8+zmhmzYRljLCF/6wha27lh4yzJgydP/w70mOk/2svviTDS60wRPkiSMg+Z5EyFp2EpCp4MkdwCNgo0UScWgzM13fvXzKf23nU4nlZWVaDQaduzYwc6dO9m4cSMqlYrm5mYOHTpEVVUVvb29OBzjCiO3240oimg0GpKSkti6dSuFhYVERkYyNDTE8ePHOXLkCKdOnWJwcNCndchDKleKbE20bFmN9K3iHwXnJOnzLCJzkTSHw8GJEycYGhqiqKiI0NDZVX1LUdPn2VVPxODgIIcPHyY8PJzNmzf7LETxh5Bj4liiKLJhwwY+f90/8ejDe6fM87Ofz+Xlv5XMOMZFl2Twu4evZH2niYD+6a1u+hP1vPFqxaxzcThcvP1uFWsK42c9br7YeH0aL//lhF/HnAmv/O0ktfrZrU8EQaB5VxxvBS9fHZ0HzTI7ca65v2eJqLkQA25EPmGELl9lxz5AWuC9X5IkVE1DbNEE8KV7iiaRqIXCsYSbge76fhw9Fi7cnTGF3PX1jmF0zY9wSmM2YjptrHOpGMONXJThAtZduJ3P3fL5Scc6nU5KSkpQKpVkZ2cjl8sRBIHQ0FDS0tLYvn07RUVFhIeHMzAwwPHjx73RPJPJhEwmQ5IkrxgkKiqKDRs2sH37dtatW4fb7aa6uppPPvmEiooKurq6vMTxTKykcnfi9VdJ3yr+kXDOqndh9v67Y2NjlJSUeHvV+kKsliLSB5MVxh0dHdTU1JCRkTFr1HGm+S22zmbi3NxuN6dOnSIxPpHs9D089dgn3PnAed5j1qyL4t03quntGSUqevoOHVqdmp/959W89NcTvHq8laE1IZMMnQVB4FjTADcYxwiLmF6c8ZtfvM/6K9b55XVNhC5UQ4vgoqaii8yNsX4f3wNj7ygfV3QiTOjNOhMEpYKKbRHoDgywa2z5WrPVym2c7/LdpywVDalANRYOYCWdQCJY+hq4KTA5MHSN8dnrNhEW5T/jbYfTP7+jiZAkiebiLhIjDazdFDntMU0NRlxBvvc9kcwOwjusZDnGiW6H4CBFVDEUEcSf//6/k451OByUlJSgVqvZtGnTjNFErVaLVqslKSkJl8vFwMAA/f39VFVVIUkSYWFhhIWFYTAYJq2Jer0eg8HAunXrsFgs9Pf309XVRV1dHUFBQYSFhREeHo5Op0Mmk62ochdOCzksFotPmZRVzILV3rtnDc7JSB/MXtPX19fH0aNHiY2NJScnx+dI2kTvP3/As8sVRRFJkqitraWuro7NmzfPm/CB/2sOh4aG6OrqoqCggO9/5/soXWt4+bnJAogvf20nzz11dIYRTuOzn9/Cr799CWsah1GMTE4NdiYG8/pLZdOe9+F7NejWGFAvpMbJB2y4NJX3363Gbls6EcXzfzlOT6zvhETQqzmxOZhj2uVJoZpxLbg+JgsNOwmmBwcHGWGI5RGjSJKEsn2ELKfE3V8u8ivhE0XJ78bMTruL+k9ayVkfy9q06QmfJEn0Dfie2pVsTgztJrJt47+NHpkTgyjQr4Q/vvHKpHEcDgfFxcUEBgbOSvjOhEKhICoqivXr17Nz5042b96MRqOhvb2dw4cPU15eTnd3Nzbb+HdVFEXcbjcBAQEkJCSwefNmioqKiIuL83qMHjx4kJqaGgYGBlYsteuxi/EIOVZJ3yr+UXDOkj6YGpmTJImmpibKysrYsGHDtF53c40H+LVuDk532Ojr66OwsJCwsLAFj+ePuTkcDtrb23G73RQUFBAYGIgoijzy819TcXiUfW/XTLrmeRes4z0fBBlhkUH85lfXcYVeS1DLkJc8CwqBY6f6MI9NJjkWi4MDx5pJyI1e9GuaDZnXpvP803MT14Wg9HgbxxdQo+WO1nEwS01NoP/SpzPhuMJCobi49FYOOnYQRBM2DjOKiflHynylnZLdRVD9INftWMuVn832e7TINGpDofFfFxLToIWWo51cdFEGISEzR1O72oaZu7p1HKLdha51jDzruIeeiMQQTlQIXH73bWzYsMF7rEeoodVq2bhx48KtYGQygoODSU1NpbCwkB07dhAbG+ttU3nixAlaWloYHR23evKkgQVBIDw8nKysLLZv305WVhYKhYKuri7sdjulpaV0dHRgtVoXNK+FwHNfWFXv+gmitAKWLatCjumwSvo+/XG73W7Ky8tpa2sjPz+f6Oj5E4mJhs/+gKeI+eTJk7hcLoqKiha1+Pijps9kMnH48GGUSiV6vR6FQoEkSVgsFo4fP86vfvYb9r/WyonDLd5ztm5Lobq8E9Oob5Gpu79yHg/ftY242gEE8zipaYzT8cbLk6N9v/rpe2y40v9p3TOh1qlwhig5dqDJr+O6XSKvvlGBbYGegtY1IXyQItCmWrromYjEsOTG94TizBAQyCeIbeiowsJRxrDMQ43syxIu7zaRbLRx7z1FJE3oWetPDA2Y0Yb5J/LT1zLESOMIuy/JQjFHh4+29kEkHyLaotONpm2UrZbT6fR2mYNoSYkqLYl///nPvI/bbDZOnDhBUFAQGzZs8CtBVqvVxMfHk5ubywUXXEBGxnirwfr6eg4dOjTFE9AjBtHpdKSkpJCamopWqyU0NBSj0ciRI0c4evQoDQ0NDA8P+zVrcSYm2sWs1vSt4h8J52xN38T0rs1m4+TJk8hkMoqKiggIWFiq0LNg+msxGh4eRpIkdDod2dmLj1gsNtI3MDDAyZMnSUxMJDAwkPr6elpaWlAqleO1fYmJrFmzho/eO0T+jk0EGdSkZ46T5/sfuognHvuY+79+oU/XWpMWxeOPXMcvfraP4o5RzPF6jlZ0ca3dhSpAwduvlhG+KQJV4PL0fc3Ymcz+P5ayPicOrR+EAABvvFJGZYB8UXRqeGME71u7ubpNRpjb/z/nCsHKJrd/Oy4ICGxDjwuRQ4wRgMAmtIsilpJLRNM0xAX5iWzMm3/pw3wwYDQRFL44s15Jkmgr6yFcpyHrvNQ5jxfFcdUuQbN/9yS3iLp1hEKTytsiz4aIXXJj0qrZ/8Fe77E2m43i4mIMBgNZWVlLmkr1dPiIiIhAkiRMJhP9/f309PRQX1+PTqcjLCyM0NBQtFotkiRhtVqRy+XExMQQFxeH2+1meHiY/v5+KioqJtUPhoWFTfFNXQw8m2OZTIbVaiU8fGk2EOcMVsJCZTXSNy3OWdIHp3dxHiXs+vXrF0WsZDKZ3xSyXV1dVFVVIZfLSU5O9ssOfDHmzB4BSWZmJtHR0bhcLtxuNx0dHZhMJgICAhBFkdHRUfR6PUc+LmXrjvV8+z8uJyYuGJVaQWpaBEcPNVOwzTe7DEEQ+Na3L+b4oSb++/liqqO0vPtaJedfnEZZfTebrs5Y0GtZKAq/sIGnfn/IZ+I6G4aHLHxQ3IZwhhHzQtCTH8Nb1g6u65Ghxb9qxzbBwUWi/+rhJkKBwPkEY0PkCKNoZAqyJS0K5kc+hH4LEaN2brxzK2r10otF7DYnKtXCSZ/bJdJ4uINNG2KJiplbvAPQ0TqIcY63RRIllK0jFI6dJnwAHdgJkil48Bc/wWAwAGC1WikuLiY0NJTMzMxlrZ3zeAJ6fAEdDgf9/f309/dTXl6OIAjodDqGhoZIS0sDTpOwkJAQb3mLyWRiYGCAtrY2ampq0Ov13tZwWq12Ua/JY9cik8lW07ur+IfCOU36bDYb/f39pKenk5SU5JeFb7EKXkmSaGhooLW1lZycHGpqavxaIzjfsSRJor6+no6ODjZv3ozBYJhkWmq328nNzcXtdtPX10dJSYl3V//qC+9x3c2X8P8euYZgQyCXXrWRn/3oHXLzElAF+P7V27ptDdlbEvn3H73DRx/UU17ZwcbPZs735S8aCpUCfbqBD/bWcuHFiyOcL/zlOB3ROr/VV7SeF8tb+zq5dnD+pGkm9OJA7156MqBG4AIMmCQXhxghBCVZaJCf8TrO3LdLooS6aYitaZFsu3HuaJm/4HC4F6xDto7Z6TzZw3nnr0Ot9j0y1dE+BLNEmCVJQtE2QuGIEsWEb9UILmTAmvOLuPm224Bxj8/i4mLCw8PJyMhYcdNhlUpFbGwssbGxiKJIa2srjY2NqFQq6uvrMRqNhIWFERISQkBAgHd9DQwMJDExkeTkZJxOJ/39/QwMDNDc3IxKpfKqgT0q4vlgol3MKulbxT8SzlnSV19fz8DAAKGhoSQnJ/tt3MWQPrfbTUVFBSMjIxQUFBAUFERdXd2KkT7PfEZHRykoKECtVnvVyZWVlZhMJrZu3epdEKOiohBFkaGhIYxGI83NzXzrn37ET771//jRo9cRoFby5a+ez7NPH+XOe7bPa+4qlYJ///GV/OS7r9PWOojqoxaSt8ShDVmaZu8zISUvloNPl5GdG09ouO8WJhNRU9HF0e5hhJjFR/k8EASBup0xvLO/mytGtMj8QPxKFVa2uZZPtahDwYUYGMbJAUaIREUGgdO+FtmIjdA+M5+7aTN6w/L2RV2oR99w1yhjbWPT+u/NBrdbpHfIDPrpv+uSJKFoH6NgSDEpRS4h0Y0dfXg4z73xKjBOYE6cOEFkZCTp6ekrTvjOxNDQEM3NzWzYsIHo6GjMZrM3CtjQ0IBGo/GmgYOCgrxiEJlMRmRkJNHR0d6MQ39/P3V1dTgcDkJDQ70k0JfyHc/GFlit6fMHVi1bzhqcs6RPr9eTlJTkd0XYQkmfp65QEASKiopQqVSLGm86zCf1bLfbKSkpQRAECgoKvKlhp9NJWVkZgiCwdetW7zwnXsNTY5Oens7Y2BiCIPDT7/yY7//8aoJDNGgCldRWd5ORNf+ep3KdkjUp8Rwo6+VoWS/xhgCCQwJJK4wnxA+pUl9QdMtGnvnjEb72zV3zvmlKksTzz5dg8iPh80BQKSjbFo7uwCAXLNLDz4GI/dM+u8sNA0ouwkAfdj5ihDgCSEWNxPj7F9A6QmZEEHvund/GwV+wLaDvbXdtP4Ei7Lggbd7ntjYN0K+Y/pOQJAlll4ncgfGI6UT04EAQFPzh1RcRBAGz2UxxcTHR0dHzdiZYDgwMDFBWVuYtIYGFewIGBQV5lcRWq5WBgQFv/aBWq/WmgfV6/bTvg8ejD1Yjfav4x8I5S/piYmKw2WyYTLP3f50vFkLSRkdHKS4uJiwsbIqCzp/eer7W9I2NjVFcXExISAjr168H8Cp0S0tLCQkJISsra85ohUwmQ6/Xc/3112NzWXnk3x/jof93KTfdXsDPfvQ269KjkMt9JxVHP24gPCOU2PWRmIfslBotVAWpweGm9IVK4tRKoqK0xK2PJCYtDJmwNDc1QSEQXRDN269XcPlnNs3r3Lf+XkF1gD/icNNDpg/keK6eoGITeeaFR0FPyC0UulfWmyySAHYRQBs2PmaEUUT09YNc85ksYuJn7zO9lHDP4/coukVai7tZmxhGQvLCrJa6uoYRNNMnlAP6LWT2SQSdsZS7kRjAxY1f+hLZubmYTCaKi4uJjY0lNTX1rCZ8MTHTbwY9noBRUVFIksTo6ChGo5H29vZJNX0hISGo1WrvWqdSqYiLiyM+Ph6Xy8XQ0JD3ep7eweHh4YSGhno9WSdG+lZ9+vyAVSHHWYNz3rLFXx0qPJivkKO3t5ejR4+SlJQ0rUeWvyN9c5G+/v5+jh49SlxcHOvXr/e2gRscHOTEiRPExsYuSPByy41fYGPGxfzh1x8DcNOt+bz01+I5zpqMt9+rISYrAoD8q9NZFyCgNDlAELDEBXMqTMMBl8T/7m3kld8c4fDzlTQf78S1BC2z4jMiqGrqo7tz2OdzLGY77x5oRBaytDcQZ0wQH6cFUCFfWBRbQqJP5kS7wntCCYlO7LQJTkY1coyBsDZCR0NZD21N/X4zQZ8P7HYXko9ffbvVSeOhDrZuTlww4XM53fQOTv85qgatrOtyETbN59SGnZjkJH7yq18wNjbGiRMniIuL+z9L+M7EQjwBPb18w8LCyMjIYNu2bZN6Cn/yySecPHmStrY2r3LYs9nV6RZWyvHwww+zbds2NBqNV0QzFyRJ4gc/+AExMTEEBgaye/duTp06NemYwcFBbrnlFm+Xk7vuusvvAYxV/GPinI30zdaRYzHwNZrmMYJuampi06ZNREVFTXvcUvTLnQnt7e3U1taSlZXl3U0D3lZJWVlZPi/K0+FH3/sRt99zKy88c4wbb8vnndcq6ewYIs6HqE1NeScRmaGTblgX3pqN5b+P0yQXEANPf5VdkTpagVaAkm5iPm4lNkpHZLye5K2xqLX+UXgW3LieZ586xkP/cjGCD1HFP//pKF2x/hNvzAZrWij7xrrRNdlJEednMdMg2FnjWoGWaYAdkQZs9Cjd9GnAmKzDHROKTIR1QzYuuykXGK+LfPvvFagDlaSkRpC8JmxZyMzokAVV8Nzv55jRzED9IBftSl+U8r65wcigeqqtj3LYRkqnnShx6udkwc2QQuK9fe96o/YeO6WzDQshfNPB4wkYHx+P2+1mcHCQ/v5+6uvrvTV9HlGHUqn0rqkajYbk5GTWrFmD3W73po8HBgb413/9V3JzcxkaGppSxuIrHA4HN9xwA0VFRTz55JM+nfOzn/2MRx99lKeffpqUlBS+//3vs2fPHqqrq1Grx6P3t9xyC93d3ezduxen08mdd97JPffcw3PPPbegea7i3IFMWont8lkAt9tNd3c3tbW1nHfeeXOf4CNKSkoICwsjKSlpxmNEUaSyspLBwUE2b96MXj9zfVdZWRlBQUF+WbDNZjMHDhxgz549kx6XJIm6ujo6OzvJzc0lODjYuytuaGigq6uL7OxsQkL8k1K79JqL2XpBCBdfkcUvf7KXh75z8Zw37If//S1yb8ickrIVRZFXHjlKR3QQqOZQ6FmdBPeMEalXE5OoZ11BPPqIxdXqGNuGERvNXH/T5lmPazpl5N+f+ARz4vKmJQ0ft3NjdwBh+K4UfVMxwgXz6LO7GEhI9OOkQWanP0Ciz6BgNCNkajqzY5j7r96E3jA1SlpX1UN9bS8BAQpS1oaTsjZ8yVL7tRVdGCUnmuCZU+e9DYPITC62FvpmTTQbPv6gnlNn6JYVY3aS2m0k2af/TGuwcvPX7mP7hRcAEBYWRlpa2qJtTPyNwcFBSktLF034ZsNET0Cj0cjo6OgUT0DPcXDadquxsZG3336bEydO8Nprr6HRaLjsssu44ooruPzyy4mMnL5V3kx46qmnePDBBxkeHp5zvrGxsfzzP/8z3/jGNwAYGRkhKiqKp556iptuuomamhqysrI4fvw4W7ZsAeCdd97h8ssvp6Ojg9jYpesTPl+Mjo4SHBzM8P6H0PvJ39Tna5vsGC76JSMjI7PeY881nLORPhivEVmKSN9sY3qamkuSRGFhoXfnNhP8HenzpGs9i7+nE8nY2Ni0Ct2xsbFJCl1/4J1X97Ltwq3oDRp2X5rB229UcflVG2Y8vr15AG2sdtobuSAIXP3AVl585Ch9SQaYrUYwUMlISigjwKkRB8f/VEqsTklElJa1m2OISA6Z900xItHAiRPdNDUYWZMaMe0xkiTx3HMnlp3wAQzuiOOV99u4ZUhHoA8efiO4UC5xLYwTiUZsdCtc9AWCMT4QZ1K0NyI23SeocUrTEj6A9PXRpK8fL/w/VdPD269VEBCoJDkljDWpEX4lgGOjNtSx06uFJUmivayXGIOO1MLFG0Q7HC56hy0wQZ0sNzmI7ZiZ8A3gJH5DOl//l29564RFUeTo0aMEBAQQHh5OREQEISEhfm9PNx94CF9GRsaSET7wzRPQQwANBgMymcy7/u3evZuvfOUrhIWF8eyzz1JWVsbvfvc77rrrLg4ePEhhYaHf59vc3ExPTw+7d+/2PhYcHExBQQGHDx/mpptu4vDhwxgMBi/hA9i9ezeCIHD06FGuvfZav89rFf84OGdJ31Kmd2cac2xsjJKSEoKDg9m4caNP3lGLMVSebiw47UFls9m8vnozKXTz8/MXnNqYDQf2HWXrjo3c863zaKjtZWTHGoJnqHV79tljbLw+fcaxFCoFV9+bx/OPHmcsPQx8IW4KAWuSgUag0SFy4tVaYgQZUdE6EtMjSNgYieCjyGTLdZm89IcS/vlfLkaumHrO/r21VIj+rR31FYIg0LMrkdfebeezY0FTvO/OxEm5lQK3/5WKQ7ioUdrpV0oMamUMZRgQgk5veGZ7pyW7ixQfI7LrMqNZ92kXmMa6Xt5+rQKVWklScihr0yJ9SsPPBofDjXoasuRyumk51kVOdhxh4f4xs26q62NYo/S+N4LFSVSnlVTb9IRPQqJfI+fQ229SUlJCamoqiYmJAN6Up9FopKqqCpfLRVhYGBEREYSHhy/Jb3wmTCR8yx2VOtMT0NPho7m5GavVSkhICG63m/r6enbt2kV5eTkAa9as4eqrr+YHP/gBPT09hIaGLsn8enp6AKaU+0RFRXmf6+npmRJpVCgUhIaGeo856yCtgGWLtGrZMh3OWdIHSyPkmIn0GY1GysrKSEpKmlcxtb8jfTBO+jwGraGhoWRlZXkjgB6FrsFgWHSHkrnmcvjDkxScv5F//rdLeOaPR/jqP1805bjBfhOKUNWcBEyjV3P17Zt4+S8VWNbNs2heEHDFBtMOtAMnDrYRva+R6Cgt0UkhpG6NQ6me/aey8Zp1PP/nY9xy5+Tdv93u4q3365ESVi69IMgFTl0Ux7v7u7lsbGYPPzcSdpWEwrr4z9yNRKvgoC3AjVENxnAl9pRIBMXM0byZIOsZ45Kb8+Y9h7XpUaxNH795NjcYeff1SpQBChITQ0jNiFoQAXQ6XZwZm7cMW+muNLLz/HUoVP5bUnv6xhA+HU9mcxHWaSbDMj05G8VFp+DiF3/4I6Wlpaxbt46EhNPRxjPboI2NjWE0Gmlra6O6uprg4GBvFHAp08ArSfjOhCAIhIaGEhoaSlpaGmazmba2Nl5//XUefvhhIiMjGRoa4sILLyQ19bT59yOPPMJ//ud/zjp2TU2Nt9fwKlZxNuGcJ32SJCGKot/IjSAIk4ikJEm0trZy6tQpNmzYMO9Uhj+Jqec1Go1GqqurSU5OJjk52VvPMjg4SEVFhbfoe6nrf1QqFR+8c5TdVxRw0VVZHPq4gW3nT+6s8Kc/HCT9yrU+jReWEMzuS9fywSdtjMUugmSFa+kBegDqBgg90k5MmIbIuCDSChOmrecKCtfSiJOqii7Wbzx9M/vrn4/RGqFZcZm8oFZQWhSG7tAQ55umj6jWqOxkWhce8THhpinQhVEj0auGvgQtstDT11roe6CXWHR7tZTUCFI+Tb+3NvXzwVvVqAIUxCQYWLMuwueorsMxeQM22DGCvcfKRbv92yHGZnXSM2KFkEBwuAjpNLHRNPk9kJAw4mRYJjImc/OXv7+MCKSlpREfHz/j2B4rJb1ez9q1a72diYxGI01NTUuWBvYQvvT09BUnfNPBbrfT3d3NrbfeysUXX8yVV15JUlISlZWVxMbGemv6HnroIe64445Zx1poDbbHn7C3t3fSvaK3t5ecnBzvMX19fZPOc7lcDA4Oes8/2+AJKiz3NVcxFec06ZvoyeSvhU0ul2O324HxiFp1dTV9fX1s3brVZ8n+RPgz0uchcZWVlWzYsIHIyMgpCt3MzMxlXZANBgPP/el17rj3GsJi9eTlJxHwaXsqs8mGUy3MK3qSkhuDadjKgYp+HLF+SLMFBTAYFMAgUNVn4cQTJ4jRBxARrWPdlrhJhtA5l6fxxh9Osi4tElWAgq6OIQ7U9CAkr5yn3CSEaDiW7SLopJlcy1Ti2qN0kuLw3U5GQqJb7qJN46Y/ELr1ckzJhtPRKT9MWbQ4yPBzLWTSmnCS1oQD0NEyyIdv16AMUBAdF8ya9MhZvSPtn9r/SJJEV7URg0pF7g7fNiXzQUNdL2NBAcicbgwdJjaNTlCnI9GNAwsiESgIDg/l7++9SUdHx4IiaNMpXz1pYLfb7fWxW0waeCLhi4uLW9AYS4nh4WHv/FwuF7fccgs33XQTjz32GADHjx/njTfe4LXXXuOWW26Zt5DDV6SkpBAdHc2+ffu8JG90dJSjR49y3333AVBUVMTw8DDFxcXk5Y1HwPfv348oihQUFCzJvFbxj4NzlvR5avpgnPQplb6rG2eDpy7O4XBQWlqK0+mkqKiIwMCFtYryV02fJEnU1tYCsH79eqKioqYodDdv3uw3he58kJaWxg//9REe/vlDPPPkYe6+/3wAnvyfA2TsmlkFPRM2XriG4X4r5YMWXKF+9MRTKRhLDGEMqLe4OP7XCuLUCiKitCRviCI2PZy8G7P4y5+O8MV7d/Dnp48znBi84lG+iXDE6zlgdqKrcbDOfvoG3iN3Emybm6bZEGlSO+kL/DSaFxuIK0IzqwhjMVD0mdl5+8win8UiPjmU+OTx+qzOtkE+fKcGlUpOVKyBtRmTCaAoSrhcbkS3SMvxLjLTIomOXZrfS2+fCZkA2tZRckeVCAhYEemSO3G53axFjQsJMlN4+o1XqK6u9osKdinSwENDQ2c14RsZGeHkyZOsW7cOQRC47LLL2LVrF7/97W+93+uCgoIFEaq2tjYGBwdpa2vD7XZTWloKQGpqqtf7LyMjg5/+9Kdce+21yGQyHnzwQX784x+zbt06r2VLbGws11xzDQCZmZlceuml3H333Tz++OM4nU4eeOABbrrpprMygrqKswvnLOmD0/J8f4o5PJG+I0eOoNPp2Lx5szeiuBD4Y34ul4vy8nLMZjMKhQKNRrPkCt35Ys/uS2houo8n/vBLqnasZV1mFCbJTcAMnQjmwnk3rMf0RDGnRqxIwUvQm1UQcCQYaAaaRTixt5GIv9cRFqVF4XDz5GMfU2axIej9U9TvT4ylh7Hf3Iuu2UmMa3yzUxdgZ4tl6vskIdEvuGnWuBhQQ7dOYCQlGCHw9CZpKUltsEyGYhpxzFIgLjGUuMRxAtjVMeQlgJExelIzorFYHLhl0HSog+3b16Je4HdzLphNNnrHbOhMTvJGlYzIJQYFOwqnRKpbhUAAw7iJv3g7//X7xykvL2f9+vV+T+35Iw08NDTEyZMnz1rC5xHXrV27loCAAC677DIKCgp44oknfBLazYUf/OAHPP30095/5+aO+0x+8MEHXHDBBQDU1dUxMjLiPeZb3/oWZrOZe+65h+HhYXbs2ME777wzyenh2Wef5YEHHmDXrl0IgsD111/Po48+uuj5LhlWe++eNThnffokScLhcLBv3z62bt3qNx+furo6WlpaSE5OJi0tbdF1cZ2dnXR2dpKfn7+g8z0KXYVCQU5ODocOHfIu1r29vSgUCrKzs5dVvTcbvv6dhygu2UvcmlAitsegC1kcYXv10aO0GgJB459Irk/oN6OtMaIN0xAQpMYlSbhFafy/ErglCTcgfvonAZIMJIUw7jWolI//VyEHpQAKYUnqK2MPdnJtp4oASeBAgIki+zjpdyLSrHLSq5HoVUv0RqpxxOqW3eJDGrFxcZyBrQXJy3rdM9HTNUz5sTZMYw66e4bJyIxGEOQoFAJKlQKlSo4qQIEqQIFSIUehFFAq5T7XCZ6J8uI2yit7SB6RsCnAYJMROcFnsU9wc9E9t/HAv3yDiooKNmzYMKO5+1JhYhq4v79/2jSwh/DNVWO4UjCZTJw4cYLk5GSCgoK44oorSE9P57nnnvNb5udch8enb+i9r6LXLrNPn9lOyCW/WfXpOwPnbKTPcxP1p21Le3s7ra2tqNVq0tNnthiZDxYT6fP09A0PDyczMxNJksjLy6Ojo4OmpiYkSUKv19PZ2UlkZORZ0VT8Vz/9JVfdcBWVlbXs2b14r7PPPLCV//3lEbri9ONkahkgH7Bw7Te3UX+gnQ1roijcPndRt8slYhq1MTpsZWzYyuCQmf4hC8MjVkyDduwuN263BIIMUcanBFLyEkgvkZQY/++nJFJSCohyOZJKDgrB+yeTyegoiuHNDztJGpWxxq6kRGujPxB6NDCQrEeYYKa6EilqxaCFvGvm19vY33DYXbQ1DmBxujA7HNx427g6e7yEw4XN4sJmdWK3ORkZtmCzOnHY3TidLkS3hCCTIcjH1xpBJgPZ+Noz/sfk/wrj/9/a2E/YiIswlxKt6/QSLSHRrYL7fvYwl37mSioqKti4ceOS1ZfNhrnSwFqtFrPZTEpKylkZ4TObzRQXF5OQkIDBYODKK68kJSWFZ599dpXwLQVWI31nDc5Z0ueBP9Sxnnq5rq4uUlNT6erq8tPsFl7T19fXR1lZGWvWrCEpKckr2LBYLHR2dpKSkkJ8fDxGoxGj0UhjYyMajYbIyEgiIyMJCgpaEff+sbExvvnVb/LVb3yF1x/+hNRtCazflbJgKwxBELj2n/J54ZdH6E8Jmd282Q8QRmysTw5Go1eTc/k66g62M/R6JZfNYj4NoFAIGEI1GPxUgzhOIq2MDFkZG7ExNGhmaNjK6JgN86gNp3s88uhYF0x5aTdHEgKxZkYsyFJlKSBJEqEK+YoZCA8PWig93sbgqIXY7EiioyKRl/d7nxcEAbVatWhV8UR0tQ9x7GAzCR0uQpkc4RaR6NTKefTl50lJXUtlZSWbNm0iImJ6Q/DlxJlp4L6+PsrLy9FqtbS0tNDd3X3WmELD+Bro6UUcHh7ONddcQ1RUFH/729/OmozHKlaxVDinSZ8/DJpdLhelpaVYrVaKioqwWq10dHT4bY4LifS1tLR4LWI8O3GYXqHrUe25XC76+/vp6+vjxIkTKJVKIiIiiIyMxGAwLMtCPTAwQHl5OUlJSZQerWDj5jSGawY53m0iKFFPxs5kFAuI1ilUCq69bwsvPV7M0JoQ38ybFwJRwmA0U/iVrd6H0rcn0Flj5K/PHOPGW7YsOOU3X4yTSC2G0Nmjt/vfrGbd9Tk01Pex70gzQ8EBiMvcLmk6yIesnF8wfxHPYtHeNEBNVTcW0UV8bjR6YbzGr+lYJ9sLFt9WbTo4nW6KDzdT3zVMbJ+L0DNa5jkQ6Y/Q8fqRT5AkierqarKzswkPD1+S+SwGw8PDVFZWkpGRMUUNXFlZiSiKflEDLxRWq5Xi4mJiYmKIjo7muuuuQ6vV8vLLLxMQsPLf+1WsYqlxTpM+WFx612KxUFJSglqtprCwEKVSicPh8LswxNdInyiK1NbW0tPTw5YtW9Dr9V6FbmNjIx0dHeTm5k7rJq9QKIiOjiY6OhpRFBkcHKSvr4+KigokSfKmcsLCwvxS4Hwmurq6qKmpmURIS4/XkFeUzto4PWtCQ6h4oRZtvJa1OxKn7XwxGzTBai67aT1vvFTDaJLB7/MHCOwYYde1U9P6cZkRjISq+eP/HOTWu4oICDg7fnYWs4O+7hHyd6xha1EKW4tSeO/tKo7X9DASpkEKXLk0V5DVRVrm8niOiaJEdWkHLS2DyA1KonInp0tFt4hodaH0o/GyBx0tg5SUddClkhM+4mLtGd02LIi41sXx8bFDGI1G6urqyM7OJixsngbky4Dh4WGvCtZTw3e2mELDeH1zcXExERERxMfHc8MNNyAIAq+99tqC3RVW4SNEafxvua+5iik4O+4+K4iF9t8dGhqipKSEmJgYMjIyvJEwf7d28zXS53K5KCsrw2q1UlhYiEqlmqLQzc/P96luTxAE705ckiSGh4fp6+ujvr4eh8NBWFgYkZGRhIeHL7r+RZIkmpubaW1tJScnZ9LNTKFQsPfNw1x/8y5CQ02kpUawKS+BV/73JIExWtZuT5hX5CwiycCFFyWz/5N2xvzh4TcBMouDpJAAQmKmLxgOjgoi66q1/OHxT7j5tnxCQla+fvKDN6vYfdX6SY9dctl6du/J5JWXTlLVMcJolBbZMtVCeiCJEqFLQLDOhN3mpORoK729oxhSDcTmT2930l0/QHaOf4UIToeLY4eaOTVswR4UgKZ1hNyRye/zCC4id+bz17dep6Ojg/r6enJycpasBdhi4CF8qampkzqBTIQvamBPWzh/p4Htdru3A1FSUhI333wzNpuNd99912udsopVnAs450nfQkhaZ2cn1dXVpKene3tbLma8ueY3V6TParVSUlKCSqVi69atfu2hK5PJCAkJISQkhLS0NEwmE319fbS0tFBVVUVISIi3DnC+6RFRFKmpqWFgYIAtW7YQFDSViEVGRvLBOye5/ubLkcXZ2ftaJbd/aTvGnlHe/FsF2sQg1hTF+XyDSM6NYcuwjaO1A1h87Oc6JySJ4K5Rdty7ZdbDVBoVW29ez3N/Oc6VV20kKXnlojUDfWM47K5pa9IEQeD6z+VxlcPF88+eoNE4hjlKi2yZUtPKQQs7dyyso4EvGOw3U3ailSGTndicKBLXzq7ssxgthG3yX6q5ramfk2VddGuVCHo1ih4Tm/pBmFBJ2S+4Kbztc/zssd/Q3t7OqVOnyM3NXREfzbngC+GbDjOZQvs7DexwOCguLiY4OJi1a9dy22230d/fz/vvv7+q6lwurAo5zhqc06TPU9Pnq5BDkiTq6+tpb28nNzd32poaf7d280T6JEmaNvUxMjJCSUkJERERZGRkTNtDNysryy8pWZlMRlBQEEFBQaxduxaLxYLRaKSnp4e6ujr0ej2RkZHeVM1s8HgH2u128vPzJ3lQnQmFQsHf//Yev/7vX3LoxKv88dcfc/1tW7nngZ20NRl5+2/V6FP0pGyNQ+ZDP9VNF6ZgHrJSNmjDbpj5ur4ioGeM8y5Z69PnLQgCBTdv4J1XaijcnET25sUrlBeC99+o5rJrN856jEql4LY7CzGN2fjLX07Q6XJijdD59B4vBkF2NzHx/iU3kiTR0mCkvqYXm0wkLjuKYB8+r6HOURLj/DMXu93FsYNNNIxZcQarxynemJ34XjvBjG+YJCS6FSI3/etDfO1b36StrY3GxkY2b968oI4+Sw2PsfF8Cd+ZWKo0sIfwBQUFkZaWxhe/+EVaW1vZv3//WUmgV7GKpcY5TfrA98icy+WioqKCsbExCgsLZ0wJTOzy4Q/S5xlvOtLX29tLeXk5a9euJTExcdl76Go0GpKSkkhKSsJut2M0Gunr66OhoWFWJbDNZqO0tBSlUsnWrVt9Nq/+2n0PsavqYr7z8P28/OwJtu1MZWNeAl++fydNdb3s/Vs1hrUhJG2JmfM1F12XhfmpUupNdpyLES7YXMQIEJM6v6hd3rUZnNzXxPCQhZ27/GPv4ytaGoyEhGl8/n7qgtTce98OeruHeeGlMnrlYA/TLMn3SnKJRPrR9NjtFqk82UF76yDKiEAiNs/Pz66/dZhdOzMWPY/mU32UVvbQG6RECBrfaEhOF0GdJtKc498/EYlOtYyv/MePSVmXygcffIAoiqxdu/asTEF6NpyLJXxnwl9pYKfTSUlJCRqNhvT0dO677z5qa2v54IMPzkoRzD80RGkFIn2rNX3T4Zw1Z4bxRaGmpgaXy8X69etnPM5TAKxUKsnJyZk11SCKIu+99x4XXHDBrNErX+FyuXj//ffZtWuXt35OkiRaWlpoaGhg48aN3to7WLkeumfO2aME7u/vR6lUeiOASqWS0tJSQkNDyczMXBAxdrlc3H7fTYyY2olPDJ0Usaqr7OKDD+sJywglISd6TmLy2m+P0WJQI6kXVpuorTHy+fu3eq1O5ovmE10oRlxcc0PuslnkPPfkYT7z2dwFn3+qtpe/v1PNgEaJyw+R0olQ9Yxx9xXr0RsWZ11jtTgoOdJCX7+JsPRQdGHzH886Zme4boiCooWnmq0WB8cPNdNgtuMKOr25kCQJRfMQFwwqEBBwIdEbGsgLn+wjOTmZpqYmWlpaiIyMZHR0FIvFQmhoqDca5o+1ZTHwED7PhnO5MDENbDQaZ0wDu1wuiouLUalUbNiwga997WscOnSIDz/8cLVV2TLCa8782pfRa5dXqT1qdhDymf9ZNWc+A+d0pE8mk6FQKLDb7TMeMzF9mpWVNSdJEYRx41t/9Mv1jAen+wN76uD6+vrYunUrQUFBPit0lwtnKoEHBgYwGo2UlZXhcrnQ6XSTrGQWMv6zv3+J/3zkp3x0+FX+9N8H+MJdRShVctI3xJK+IZaqk+188kI1EevDid84c3Tnyq9s4aX/OkJ3/PzNm9X9ZgrPS1ww4QNI2RJLX/MQf/3jET53e8GStxwrK25j7brFebuty4jiGxlRHD/czLufNDIWFogY5B+7C70oLYrw9fWMUny0FYvDRUJeFElphgWP1V3Tz46CtQs+v7Gul7LqHvqCVAhnvD+yXhN5g4K3p641KYoPThxCo9HQ2NhIe3u79/cN42bCE0spPL+hiIiIZffUXCnCB76lgUNDQ6mtrSUqKoqNGzfyjW98g48//niV8K1iFZzjpA9mT+92d3dTWVlJamoqycnJPi+s/hRzTCSRHk9Am81GQUHBohS6ywVBEIiIiMDlctHV1UVycjKiKFJXV4fT6VyUEvhfHvwOF+/cw3cf/iqP/+oDPn9nAeGR4zfJ9bkJrM9N4OTxFo6+UE3UpghiM6eSHUEQuOar+bz4yBH614SCr/VqTjdRdhdrNy+uwT1AZEoIutBAnvn9QW66rQDNEu2IRVGivLida2/M88t4p21eqjlW081ImAYWYfMiOVzEL0DVLEkS9dU91NT0IqplJOZGLbq0wu0SkWzuBZFwi9nOsUPNNFrtuD21exPnO2YnpddJMCpGcGPI38ib+95FJpPR0NBAR0cHeXl5k4RNWq0WrVZLcnIyDofDu5FqbW1FoVB4iVBoaOiSemquJOE7E9OlgT3lJV/+8pcJCAggJCSE/v5+Pv744xWf7zmNVcuWswbndHrX5XLR0tJCb28vW7acVl5KkkRjYyPNzc1kZ2fPu83RBx98QG5urt8Kr/fu3UtOTg51dXWo1Wo2bdqEIAhehW55eTkymeys6qHrwURLlk2bNnktWSRJ8iqB+/r6MJvNhIaGetPA81ECOxwObrv3Bnp6W9j9mQ1szJ7a9unYgUZKyjuIyYkiOn1q/Z152Mr/PlHCUIpv5s2GliGuuS0bldp/+yaXw0X5y3Vc+9lcIqL8n444sL+eyEgdsQn+jwKLosjLL52kqmOYsSjdgmxe1F2j3HdDjs9dLtwukYqSdjo6hlFFBRLuR//F9oo+NqVGE6T3PY0qSRKnanqpqOvFGKSalnyJThfBDSMUmgPok7nI+9xn+PUff48kSTQ0NNDV1UVeXp7PNXyiKDI0NORNd3o2Up6aN3+uB2cT4ZsObrebsrIy3G43a9eu5Z577uHDDz8kKCgIm83Gnj17uOqqq7jyyitXRRzLBG9699V7Via9e80Tq+ndM7Aa6TtDvet2u6msrGRoaIjCwsJpbUR8GdOfti0ymYzy8nKio6NJT09fUoWuP+Exi+7v759iyTKdErivr4/u7m5qa2u9SuDIyEg0mtnTfSqViuf/+Hd+/PN/4+2XX6KzY5hLr5hco5m/Yy35O9Zy8INTnHyxmrjN0USuPU1+tIZALrvRN/Nm1bCN9enhfiV8MN45JOdzmfz91XIu3JnG2jT/9VR1Olw0NxjJyVuam7UgCHz2c3l8xuHir8+eoLFvFEu0bl42L8HIfCJ8ZpON0mNt9A+aCcsMm9Ffb6GQJAnboHVehM88ZuPo4Raa7A7EaaJ7nnGV7aPkm5W0C05u+e43ePDb3/K6Ang2n/OJ1AuCQFhYGGFhYaSnp2MymTAajbS3t3vTnZ4ooEazcPHN6OgoJSUlrFmz5qwkfKIoUl5ejsvlIjc3l5///OcUFxdz4sQJMjMzKSkp4fXXX+fXv/41kZGR7NmzZ6WnfG5h1bLlrME5Helzu910dnbS0NDA9u3bsdvtlJSUIJPJyM3NXXBbnoMHD7Ju3Tq/NELv6emhtLSUxMRE0tLSpih0ExISWLt27Yr0yZ0NEy1ZcnNz51V4PlEJPDg4iFar9baEm6t+6eCRg3zzu18hKlHHF+4qRKGYngh/+F4NdU1G4rfGEJ5s8D7eVNLFBwc7MMXMQPbdIrEdo1x592afX89CUPVOIxtTo9hckOyX8d79ewWbNifMi8gsBuM2L8fpcLqxRWrntnmxOtkWqJpVydzbOUJpcTtjDgeJm6MX3I95LvS3DhMmqEhaM7fCU5Ik6qq6qag3MqCfPrrnRfcYBZ1u+hQS//HnJ7n8M1eNn19Xh9FoJC8vb84NznwwUfU6ODiIWq32EsDg4GCf08Cjo6MUFxd7+3ifbRBFkYqKCqxWK5s3b+Y3v/kNjzzyCPv37yc7O3ulp3dOwxvpe/lLKxPpu+4Pq5G+M3DOk77e3l6qqqrIycmhpKSEkJAQNmzYsKio2eHDh0lOTiYmZuERCE9atLGxEYVCQVZWllec4YmGraRCdzZMtGTZtGnTorp2OJ1OBgYGplUCh4SETEsALRYLN9xxNWZLH7fft53QsJlTZXvfrKSpY5DEwlhC44MBKNvXxLFTQ1jCp96A9W3DXPXZTLSGpW/b1HConSilmgsvzVzUOGOjVt54qZSrrl+4Yneh6O0e5vmXSumVy3DMYvMS2DnCAzdvnVJDJ0kSdZU9NJzqQwwUiNsQueQbnFMH2th14dw2LWOjVo4eaqbJ6QLt7BtEadRGSpMZtyDnlSMfeyP2EyPhS9kKzO12e+sAjUYjgNf3LiwsbEbbpLOd8EmSREVFBWazmby8PJ544gl++tOf8t5777F169a5B1jFkmKV9J19WB6L/bMYcrkch8PB0aNHSUhIYNOmTYtOky42vSuKIlVVVbS2tpKfn09AQAAdHR0MDQ3R0NBAfX09ubm5ZyXhM5lMHD9+HJ1OR25u7qLbtCmVSqKjo9m0aRM7d+4kIyPDG0X86KOPqKqqwmg0Tnq/NRoNb/5tL9vzL+O/f/YB1ZVdM45/8RUb+PKXz4dmMydfqmGoa4zsXWvYEBlIwLBt0rGKMTupMUHLQvgAUrclMKqFV/5SjLiIouT336xiz1WzGzEvFaJiDHztqxdwx4UZRHebUAxbpz1OJ8omET6n082Jw838/X9LaTeNEZsfQ/zGqCUnfOZhKwbt7NFQSZKoKu3k7X31NChkcxI+0eEiqMMMWg1HWk95Cd/EbjRL3ftVLpcTGRnJ+vXr2blzJzk5OQQEBNDY2MiHH35ISUkJbW1tWK2nPx8P4UtJSTlrCV9VVRUmk4nNmzfz9NNP8/DDD/Pmm2/6nfB9/PHHXHXVVcTGxiKTyXj11VfnPOfDDz9k8+bNBAQEkJqaylNPPTXlmMcee4zk5GTUajUFBQUcO3bMr/M+a+BJ7y733yqm4Jyv6evu7sblcpGTk0N0tH8avPvSOm0mOJ1OSktLcTgcFBYWolQqSU9Pp7Ozk9LSUkRRJDIyErfb7beuH/7C4OAgZWVlS2YKfaZdg6cncG1tLU6n0xu58CiBH/7Bf7Dr/Ev452/fx/ZL1nHx5Vkzjn3ZNdmIosibL5dx7MNW1u9KxvRWA/UmBy6dCiSJ0H4zW748e6s1fyMuK4Lh0DFe+NMRrv/CVlQB8/vJ9nSNICBDtQy9bGdDWmYU38iM4uihJt472MRYiBrp01SzbNROTuZ4KcTYiJWS4630D1mI2RhJYsJUUc5SoqdugJ3bUmd8fnjIzNGDLbQiwgy1exMhSRLKthGSwqM5VFWOIAhIkkR1dTXDw8Ns2bJl2T33ZDIZBoMBg8HAunXrvJ11PP21tVotwcHB9PT0kJKSQnJy8rLOzxd4SPPIyAh5eXk8//zzfP/73+f1119n27Ztfr+e2WwmOzubL37xi1x33XVzHt/c3MwVV1zBvffey7PPPsu+ffv40pe+RExMjLee8IUXXuChhx7i8ccfp6CggEceeYQ9e/ZQV1fnl9KgVaxiOpzT6d2Ojg4qKipwOBzs2bPHbySltLSU4OBgUlJS5nWexWKhuLgYjUbDxo0bvQpdl8tFWVkZkiSRkpLC0NAQfX19OJ1Ob63bbCma5UB3dzfV1dVkZGQQF7e8N2qPX1dfXx9Go3GKEtjpdHLJZy4gOjGAL9xdhHwOcYEoirz07AkGrTYaGgfojtWjHbRy6SVrCI1dmTSBzeKg4Y1Grvt83rx87F548giXXbfprNocALz7dhVHqrsxhWsJ7Ldww0VpVFV0Yna6SMiJXpT34ULhcrjpONbF+RdOrSuUJInyk+1UNw0yYgjw+f2UdY2yJXIt+w8eAE5H8cfGxti8efOKmyyfCafTSUdHB42NjV4f04l2MGeDWMxTB9nf309eXh6vvvoqX/va1/j73//Orl27lvz6MpmMV155hWuuuWbGY/7lX/6FN998k8rKSu9jN910E8PDw7zzzjsAFBQUsHXrVn77298C49+NhIQEvvrVr/Ltb397SV/DcsGb3n3xTvR+7LTj07UtDkJu+NNqevcMnNORvpiYGNRqNQcPHpyxt+1CsJD07vDwMCUlJV6FriiKSJKE1WqltLQUvV7P+vXrvWmatLQ0L9FpaGigsrLS63nn6XyxHPB0B/HY26xEe6OJfl2pqaleJXBXVxe1tbUEBQXx0x/+F//95G/59Y/3ctfXzid4lhStIAh87tZ8XC6R//3rcfZ+2EBwaCBqrcqv35P5QK1RkXVdOv/7txIuvXy9T71pG2t7iY7zvWB/uWA22VmbEk6AUuDIoRbMVifvvF1FUm4M8ZGaFSF8AB2VfWwtmLpRGxwwcfRIK22SiCw0cO7ons2JfNSB3CGyfeNWXn/1NWD8pl5ZWYnJZCIvL2/BQrGlhM1mo7W1ldTUVBITE712MLW1tTgcjkl2MCsxf4/S2Wg0smXLFt5++23+6Z/+iRdffHFZCJ+vOHz4MLt375702J49e3jwwQeB0z2Bv/Od73ifFwSB3bt3c/jw4eWc6irOMZzTpE8QBG8tjcvl8pun1XxJn8cEet26dSQkJHhTw0NDQ5SXl0+r0D2T6Hg87zzO9CEhIV7Lk6VanCdaskzsHrDS0Gg0JCcnk5yczNDQEKWlpcjlcr5025cpqyzjNw//gRvuyic9Y/Y+rAqFwFXX5dLY2I9xxMaRp8qJTgxGUMmRKQVkChlCgBx9TBCGaB0qzdISbUEhsPH6DPa+XkvhlmTSNswsFJIkiRMHm7niszlLOqeZYLM66e0eoaNtCJPJjs3uxGZzYnO4kKnkGBKCCFsTjL5ZS58owyxAd1UfmhIXWrUCbaCSALWCoLBAQqKDUPrZHudMSJKEZdhG4IRohChKlBW3UdM+hMkQyExUX3KLyEftqEWQO12oUXDr52/jhz/4sZdwexSmFouFLVu2nHV+mgBjY2MUFxeTlJTkTelOtIPxdAXp7OykpqYGvV7vjQJqtdol3wx5vAw91jb79u3jy1/+Ms8++yyXX375kl57vujp6SEqavL6EhUVxejoKFarlaGhIdxu97TH1NbWLudUV3GO4ZwmfYA3XeFPXz1fSZ8kSTQ1NdHU1ER2djahoaFewjdfha5Op0On07FmzRqsVit9fX3elk0ez7uoqCi/FYy7XC4qKiqw2Wzk5+efdWkqGI+elpWVeUmzp8dywZYCHvz2vWy/ZA0XXTKzStPlcvPkY59QFapBiNTRZ3OiGLOzPS+JvG3jHVocNhd1Nd3UftjGiMmBW844GVTJCQwKIDIpGEOUDoXKf2mxrKvWUfxBMyPDFrbumL5NWOnRVtI3+qdGdSY4HC6MPWN0tA0wOmrDandis7mw2V2IcgiK1hGZbEAfoGO65Ep7VR8tY3YI/jRdHaLBAlgAI4BbhOYRAiqN6FQCapWCgAAFWkMAEQl6ArQqvxGN7lMDbFx/+ndm7Bvj6OEWOpQyhDOiwpIkIZgdqOxudAo5YfoAItZGIJc0XP+Z2/niF7806XiPh5zNZiMvL++sJ3zTlaXIZDLvGpOSkoLdbvfawTQ1NREQEOAlgAaDYUmiy01NTXR1dbFlyxY++eQT7rzzTv70pz/NmmZdxVmCVZ++swbnPOmTyWR+N1MWBAGHwzHrMZ7anoGBAfLz89HpdH7roRsYGEhSUhJJSUmTPO8aGhrQ6XTeCOBCd+d2u52TJ0+iVCrZsmXLsqWS5wOj0UhFRYU3egrjSuCYmBhiYmI4+lEZn7/9Bv7Sepibv1iAIJ9qFfKH3x3giFxE+LRWUlArOaVW0ljWxuGjrey+JJ3MDTFszE1gY27ClDmYRm1UV3RRV9yE1TlOhGQKAUWAHF1oIJGJwQSFa6Zc2xesuzCFtpJuhl+vYPeVGyZ9jm63SG1FF1d9bvFegm6XyIBxjM72IQb7LZgtDhwuJ1aHC5cooY3UEJESgi5Ri289JMZhGbFRW9GLK2wWI2JBgKAA7EEBTOqOPWBFfmqQQBkEBioIDFSi0akIj9cTFBq4oO/0cJeZwvWJiKLIsaOt1HUOYw/VeFO5ks2FyuJEK5cRpFKQnhVNfGIIrQ0DuO2BPHj/d7l49yVTxnW73ZSXl+NwOMjLyzsrfytzEb7pEBAQQFxcHHFxcbjdbgYHB72/OVEUJ9nB+OM1Nzc3097ezpYtWzh+/Di33nor//M//8MNN9yw6LGXAtHR0fT29k56rLe3F71eT2BgIHK5HLlcPu0x/hIUrmIV0+GcJ33g/w4ac43ndDo5efIkLpeLgoIClEqlt4duVVUVo6OjfuuhGxAQQHx8PPHx8TidTi8BbG5uRq1WewmgXq/36WZpMpk4efIkISEhZGVlnXX1YjAu0Kmvr2f9+vVT0iceyOVy/vaXl3nm2af57X/8mju/up0g/emIzgvPFXNozIoQMjUyKoZoqAOa3q0m62AT11yziYioqaltnV5N/vY15G9fM+U5Y/coVZVdVBzowCGKSAoZMqWAUqUgJFpHeIIejUE962eSuDmG/uZBXv7Lca65eYtXoHJofz2F58+sQJ3yekSR4QELHa1DDPSbcDrd2OxOrHYnDpcbVYia8GQDmg0h+MM6WBIlyvc3MTzNe+sT1ErcsUpMgMnzmNmJ7EgHapeIRq0gUKMgMFBFeFwQ+ggt8lnqBEeMZqLDtPR0j3D0SAvdAQpkwWpkgxY0EugDFMRG6lh/YRwqlQKX001jXT9ttW6+dPt30euDkclkVFVVERkZ6RU8eNqCuVwuNm/e/A9D+M7Emar60dFRjEYjzc3NVFZWEhIS4n1+IZmG1tZWWlpa2LJlC6Wlpdx44438+te/5pZbbjnrTOk9KCoq4q233pr02N69eykqKgLGuwjl5eWxb98+b6RSFEX27dvHAw88sNzTXXqsRvrOGpzTpM+zYJzZim2xmM2yxaPQ1Wq15OTkTFHoAuTn5y9JCkipVBIbG0tsbCxut5v+/n76+vooKSnxqvQiIyNnND32WLKcrV1APOnytrY2cnNzfeqvedstt7P7wou58c6ruPYLm1i7LoK979Sw91QvUuTssStnrJ6TokjTHw+TkxTK1ddmow707cYeEaPngpipSU9RFOlsHaKyopNTvWPIBBmqQAWoBOQqOfoYHYaYINS68e9HeEoogSGBPPfkYW64dSsymYzO1iFy85OnvDejw1Z6ukYw9oxis7vGiZ3NicXqRBEcQHhyMLoMPWpBYCmrM08d7aBdJoxH8vwFlQIpKggr4HWaE0VOlfWgtrlRq+Vo1EoCNQpCInWExOhQfmp/0107gF6pYu8H9biVckIliVAhgM0XrCM45DTNtVrs1FQPEBWWwtOPP+211RBFkeHhYYxGI3V1ddjtdkJDQ7FarcjlcvLy8lZUWT8TPIQvMTFxwYTvTMhkMoKDgwkODiY1NRWr1eo1hPbYwXgIoC8bzfb2dpqamti8eTPV1dXccMMN/Md//Adf/OIXl3X9MZlMNDQ0eP/d3NxMaWkpoaGhJCYm8p3vfIfOzk6eeeYZAO69915++9vf8q1vfYsvfvGL7N+/n7/97W+8+eab3jEeeughbr/9drZs2UJ+fj6PPPIIZrOZO++8c9le1yrOPZzTli0wnqo8cOAAaWlpfvNG6ujooLu7e4pB6NDQECUlJcTGxpKWluYlhp4euhMVussJURQZHBykr6+Pvr4+AG8EMDQ0FEEQvJYs6enpxMfHL+v8fMFEUcnmzZt9blg/Edff/BlQDXKsdYCRhPlJ/EWHi+huE0XZ8ey6JH1BKdu54HC4aD5lpL6mlzGTDUku8wpKZCqBkcYRwkO1JKWGMzxoGa+vszmxOZxYbS4EjZzgeD2GGN2KRWgHO0c5/EkrltnSuksJUYQxBwEmOxq5gFohYB+2odIq2ZAVQ9La8CnvzeiwhY5mE+lrcvj5fz46a/2qJEmMjIxQUVGB0+lEFMVJ/W/9Eb33B0wmEydOnPB6ai4HPN11jEYj/f39CIIwKQ185rrnidhv3ryZpqYmrrrqKn7wgx/w4IMPLvuG88MPP+TCCy+c8vjtt9/OU089xR133EFLSwsffvjhpHO+/vWvU11dTXx8PN///ve54447Jp3/29/+lp///Of09PSQk5PDo48+SkFBwRK/muWD17Ll2S+sjGXLLX9ZtWw5A+c86XM4HBw6dGjRbdMmoru7m9bWVgoLC72PdXV1UVVVRVpaGvHx8T4pdFcCkiR5fQD7+vpwuVwEBgZisVjYsGHDjOnSlYTb7fYqIxfrffarX/4XT/7lKfpdJhyhATjjg5DNgyBJI1bWjDi56KJ15G5dvsb0FpOdd14pp66qC4U2gKS8aMKT5450LifcTjcHXqmhL8R//WXnBUlCNuZAaXYQKJeB2UFSgoGCbdOLYfp6RhnsdrC94GK++6//5hNRdrlcnDx5EkEQyMnJwel0eiPqg4ODaDSaSf1vV+L3vhKE70xMjI4ajUZvdNTz3gwMDFBbW0tubi4dHR1cfvnlfPOb3+Rf/uVfVnyNXIXvWCV9Zx9WSZ/DwbFjx4iJifFbBKuvr49Tp06xfft2JEmisbGRlpYWsrOzCQkJwfOWexS6K2Fo7AvcbjeVlZX09/ejUqm8Pl3L7QU4GxwOB6WlpchkMnJycvw2J5vNxrfv/yf+vv8dLAES7vBA7InByHz0kFN1jZIlV3LZtRuJS1p68tVY20tNeRc794z36S0rbqW2theFXkXs+ggU8+zksRQo29tAvUOE5ewO4nQjH7ahFkUCFQIJa0MwROloLelmQ0YMUTHBkw6XJInO1iGso3Ku+8yt3PXFe3y/1Ke1ugqFguzs7CmRK5fLNan/rSfSNbEOcKnhIXyeTebZAEmSvHYwRqORkZER/vu//5uUlBQKCgr45je/yf33388Pf/jDVcL3fwyrpO/sw8rfCc4CLJWQw2PGOjg46BVmeBS6TU1NtLe3L1ihu9TwWLJYrVa2bduGWq3GbDZP8gKc2PViJYxarVYrJSUl6HQ6NmzY4Nebplqt5pEnn+ARoLamhn/90lc4/kE1olaJM0yNNTkY2SxEyhGrpxRo/stxciL0XHZTDjr90tjatDcPUFHczq4rN3gfy85LIjsvCdOojX3vVGFDIiTFQEjsyngpdtb20zxsh6XuWyxJYHKgMjkIVMgI1qlYsz0B9afN3gc7R+ko7mHn+WmTev2Kokhz/QC4tHztK/+P3dMocWeD0+mkpKQElUo1Y/9uhUJBVFQUUVFR09YBejZU4eHhS1LTazKZKC4uPqsIH0y2g9FqtZSXl7N9+3Zef/11Hn/8cfR6PQMDA+zbt4/zzz//rLS8WcUcWBVynDU45yN9nt15UFCQ31IdHkNgjUaDKIrk5uaiUCi8XTaqq6sZHR0lNzf3rKnxmQiPJYsnYjFd9MzT9aKvr8+7m/PUAS5183gYL0IvKSkhKiqK9PT0ZYkAiKLIn//nD/zvo49TaeyAIBXmUBXW5GDQznwjEl0i8c3DbM2I5sJrN6BQ+o+c9nQOc2BvHXuuzZ7z2GOfNNLU2o8qRE3s+gjkfpzHbLCO2Tn4Rj1D4Uv0XXeJyIesBIgigXKBuORgoteGTkrHSqJEa1kPIYEBbNh4OqruUeJqlOH86Ae/YP369fO+vMPhoKSkBLVazaZN8295J0kSJpPJG+kaGxvzex2gh/DFx8efVYRvIoxGI+Xl5WzcuBGz2cyll17KNddcw549e3jjjTd4/fXXMZlMPP7443z+859f6emuwgd4I31/vnllIn23Prca6TsDq6TP6aS8vJyAgADWrVvnlzF7e3s5efIkUVFRbNgw7qF2pkI3JyfnrNyxeixZDAYD69ev9+kGZrfbvQRwaGhokhfgQgQVc8GjIvZ03ViJlM/w8DD/9tWHaPzwMG2jA9gMSkYNKsxJeiTD9BE90eIgvdvCeTvWkLtzzaLnPWAcY++rlVzxudz5zX3Qwv73anDIRCLSQtHPoVJeDCRJ4thrtbSplf5T60oSmJ0ox+wEymXoNQrWZEejmSGSah2z01bSTd7mBEJCx1+r1WKnpX6YyNBkfvGfv11wraqnndbEftmLhc1m8xJAf9QB/l8gfAMDA5SVlbF+/XpvL/TLLruMxx57zPueSpJESUkJYWFh3o4hqzi74SF9g099fkVIX+gdf10lfWdglfQ5nVRVVQGQmZm56PEGBwcpKSnB5XJx8cUXnzUKXV/giVAuRlQy0QtwYGCAwMBALwEMCgpaNNHp6emhqqrK504ly4GDH33MY9/5Iea6FkxOG916gRGDElO8DjFCM+U1K/rMrLdL7L4yi5SshZGN0WErL/75BJ/9Qt6CiYYoihz9uIHWzmHUoWqisyJm9bNbCE4d7qC0dwy0i0z/u0WEISsBbpFAQUZMvJ64jKlK2zNhbB7C0mNm2461CILwqRJ3jPQ1uXMqceeC3W6nuLjYW16wFIro6eoAPQTQlzpAD+GLi4s7K4Ri02FwcJDS0lLv+rtnzx527tzJE088cVauk6vwHauk7+zDKulzOr3NxDds2DD3CbOgs7OT6upq1q5dS319PRdccAFyufysU+hOBw+Z8qcli+eG1dfXh9FoRKlUegmgwWCY9/vQ2tpKY2MjmzZtIjw83C9z9CecTiff//o3qHxjL9oBE0huqvQSgyFKLNEa3DFByITTr1nXOkx2kIbLbszGEO57tM1qcfDsk0e4/uYtk+rSFoP+3jE+2l+HUw5RGWHowhavsB3tNXH4oxZGF6rWtThQjtpRCzJ0ajlrN0Wj89HQWXSJNJd0ERemZ11GFMaeUQZ6nGzbupvvfdc3Je5s8BC+oKAgnyPii8V0itfZ6gDNZjMnTpw4qwnf8PAwJSUlZGRkoFAouOyyy8jLy+Ppp59eJXz/AFglfWcfznnS53K5/n97Zx4XVb3//+ewL4LsIIoKbuDCruRSWZq4JdhqWWp5rexq2XJTu6mtZlldMy21m0u3zAKXbCNNxRZNZRNRQBHcWYZ932bO7w9/53wZQASEYdDP8/GYR3E4c87njMOc17yX15vTp09TWlqKn9/166IaQx4Efv78efz9/bG1teXIkSNUVlbSpUsXiouLGTBggDIOzJCQJInz58+Tnp7OkCFDcHZ2bpfzaLVaHQGoUqkUM2jZC7CpNZ4+fZrMzEwCAgLo2rXrNfftKLRaLadOnaKwsJDAwEByc3N5+58voI5NwrmoCgmJwzY1FNiZUOlsSXVPW1TGV425Xc8WEuTpxLiH/DC7TpdtdVUt3679i4mPB2HWDl2wWq2WP/adJjOnGEtnK9y8HVvlOaip1XJ0dwqXbFoQSdNqMSqoxKxGg6WxChe3LvQa6IJRC4VtaX4FlxOzGTGyD3lZJVSUmHDflMf4x+ynW3gVjVNZWUlsbCxdu3Zl0KBBHSKmrlcHCBi84CsqKiIuLo5+/fphaWnJxIkT8fHxYevWre1iZr127VrFE8/Pz49PPvmEYcOGNbrv6NGjOXjwYIPtEydOVAyWZ82axZYtW3R+HxoaSlRUVJuvvbOiiL6N0zpG9D25TYi+egjRV1tLeno6eXl5BAa2fFapbGsi3+wtLS2VlG5KSgqZmZmYmZlRU1Oj2DM4OzsbhEO/VqslNTWVnJwcAgIC9PaHIUcs5DpAjUajCMD6Jq3yjOKioiICAwOxsuogj7cmkOerVlZWEhgY2KCTeee279j2/ipqMq7Qp9qIaiT+tKok386EUkdzKnvbISHhdb6E4cEeDB/vjZFRw5u0plbLd2v/YuxDfljo4QM082IB0ftT0Zoa0X2IC9YOzW/QSY7OIKms5vr2LBW1mBRVYmkkYW1mjOdAZ7o2MtKuuVxJUUNRDfb21hhrbXju2UXcc09oq4/XYLkVFcTGxipjCA1FTNWvA5Qkia5du9K/f/8O8wNsiuLiYmJjY+nTpw+2trZMnjwZDw8PIiIi2qXW+dtvv2XGjBmsW7eOkJAQVq1aRUREBKmpqY2a8ufn5+vMT8/Ly8PPz4///ve/isHyrFmzyM7OZtOmTcp+5ubmzZoEdKsgRJ/hIURfbS3nz59vdILG9ZC79iRJumaHrr+/P9bW1pSVlZGdnU1OTg5lZWU4Ojri6uraYX53slCpqKggICBALx23jSHP6szJySE7O5uqqipFHNvZ2XHq1ClqamoICAjoEFuY6yF3fzfHJ7C8vJy3X1pIyq/RmOcU0k+yoAINh8wryLYzptjBnCoHMwZWwV33DMA76P/S7FqNlu/WHeaOewdh07V9rF+uRW2tlt+iTnJZXYpd9y54+DjrpKnrcyk1l2PxmdQ2NnVDK2FUVIlZZS2WRiocHa3o7eeCyQ1GLWurNaQdvohpDfTs4cm7b3/cqk7cpqioqCAmJgYnJye8vb0NTkjB1ZTusWPHsLOzw9jYWJl80ZI6wPZGHv/Wu3dvHBwcCAsLw8HBgV27drXb33hISAhDhw5lzZo1wNUvkx4eHsyfP59FixZd9/mrVq1i6dKlZGZmKt3Us2bNorCwkF27drXLmm8GFNH3+cMdI/rmfCtEXz06PtzUwahUqlbN3pULpOumeJqaoSv7UPXp06eB3529vb0iAPUhbKqqqkhISMDY2JihQ4d2qMly/VmdsjjOyMigrKwMU1NTvLxuvNO1PaisrCQuLk7p3LzezdTKyorln30CwIkTJ3hv3otcSTiJf5U5LtlmVGdr+du0iHNdVXyx5SgDfj/LvQ/64dK9Kzs3HiXknv56F3wAJiZGjJ88BIDz6XlE/3YaycIIT/+GHbNVZdUkxVym1qVOtK6yFtOiKqz+fzSvh7cjDu5t9yFckFlC+t+X8fLozYL5C7G2tqampobLly/j7OzcJpEjeWa2s7Oz3iyCWkrdGr6+ffsqn0lyHaBcuyyPPmsvP8CmkD83e/bsiZOTE/fddx9dunRhx44d7fbZJ3dYL168WNlmZGTE2LFjOXz4cLOO8cUXXzBt2rQG9jnR0dHKvPK7776bt99+G0dHxzZdv0DQltzykT6NRsOVK1c4ffo0o0aNatZz8vLydLpcb6RDt6KiQolyyd+KXF1dcXFxuaHOwmtRVlZGXFxciyxZ9I28RhsbG7p27YpardZ5bZydnTssMll/jQ4ODvj4+NxQB+2qd1aw67Mv0JSWg1aDiaTCFIkLRrVUOZjS3cMOUzNjHJ1sMDFWYWRkhMpIhbGpEWZmJpiaGWNqboypmQmmFiaYmptgYmqMiYkRxiZGmJgYX/2vqRHGxkZtIlhqa2uJ+vEk2UVlOPSwpXt/J1DBoV0pXLE0RVVajXl5LdamKuztLOjt69roVBCtVkJTo0FTraG2Rnv1v9W1aKqv/r8kSSABkoSmRkt1tYbaKg1ajYRWo8VIZYKdlSN7f96HtbW1znSHnJwcpdZNLqtoTXlAWVkZsbGxuLq60r9/f4MVfLGxsXTr1k0RfPVpqg7QxcWl3Usn6opSd3d3HnjgAbRaLT///HO7WDvJXLlyhe7du3Po0CGGDx+ubH/llVc4ePAgR44cafL5R48eJSQkhCNHjujUAG7btg0rKys8PT05e/Ysr776Kl26dOHw4cMdHk01FOTP7bwND2FrqedIX0U1jk99JyJ99RCiT6MhOzubpKQk7rzzzuvuf+nSJZKTk/Hx8aFbt25tOkNXrsvJzs6msLAQW1tbXFxccHV1bRORU1BQwPHjx3UiAYZGYWEhCQkJDdYovzayF6CNjY3SCaxvg+uioiLi4+Pb5XXUarWcOHGCPd/v5uThY5Rn51JdUExZcQmZNeWUmUmoLEypsTCm0kxFtY0pmi5moAJqJdBoQaPFWCNhopUw1oKJBMbS1V0AMAaViQojlRHGRiqMjFQYqVQYG9f5fyMjjIxVGBuprkbDjVT/t6/RVeEp/5yfU0JubglmlmZkZpVgAjg7WWPnYn1VsAEqLcD/CTjV//9RpTLCwsIYS0szTE2Nqa3RUF1Vi5GRCRbmFpiYWGBiZIG5mTV9eg/g9lF3M3To0GYLlPq1btbW1orIaY6FkCxU3N3dDfZvRhZ8bm5u9OvXr9lrbGs/wKaoqKjg2LFjuLm54eHhwaOPPkpxcTG//vpru9+Qb1T0Pf300xw+fJjExMQm90tPT6dPnz789ttvjBkzpk3W3tkRos/wEOldlQoTE5PrjmGTJIkzZ84oo9Ps7OyUkWpZWVkkJyff8AxdCwsLPDw88PDwoLq6Wml0SEtLUwyPXV1dWyVy2sOSpa1Rq9WcOHGCvn370rNnT53f1X9tcnNzyc7OJj09vc29AJtCNpHt06cPvXr1avPjGxkZ4efn12gneXl5OQejo/lt526yTqdToc4j51wel2pzqTZVobIwQWtuQrWVCTWOFlRbmzVZe9dypKvGyBpAo0GqrME0twIbVHR37crI273o0kS3rlajpbiokoK8MkoKq9DUShipzDA3tcbM1Aonh27cNux2Ro26nW7durXJiuu+b2pqapQO8piYGExNTRUBaGdn1yBa2xk87uS0c0sFH+i+NnXtleLj49u0DlCuhXR1daVXr17MmDGD3NxcfvvtN73cjJ2cnDA2NiY7O1tne3Z2Nm5ubk0+t6ysjG3btvHmm29e9zxeXl44OTmRlpYmRJ/AYLnlRR9cf/auRqPhxIkTFBUVERISgoWFBVqtVmeGrr+/f5vWcpiZmdGjRw969OihY3ickZGhiBxXV1e6dOnS5Ad9XUsWX1/fdrNkuVEuXbrE6dOnGTRo0HWnI5iZmeHu7o67uzu1tbXk5ubq3Mjl16atoxVyRLijjKGtrKyYMHEiEyZObPC7ixcvsvennzn44y9knc0g62QBuVIeNaYqMDdBa26MpqsZtfYWqG6gaUIqrcIsvxI7EyN6udow/IEBmFlcPZ4kSZSXVlGQV05BXjmaWhVGmGBiZI6pqRVWFl3xGzIa/9BAKioq6Nu3b7sI52thamqKm5sbbm5uaLVa8vPzlS8aWq1WETmOjo5Kl66hzamtS3l5OTExMa0SfPW51lzgG60DlO1tnJyc8PT05Mknn+TChQvs27dPb12uZmZmBAUFsW/fPsLDw4GrEfV9+/Yxb968Jp8bERFBVVUVjz322HXPc+nSJfLy8trsC8tNhQbQ6Dmp2HQc55bllk/varVaiouLOXjwIKGhoQ0+OKuqqoiLi0OlUhEQEICxsbFOh25RUREBAQHtWpNSl7oiR61WY25urtQA2tra6qxfkiRSU1PJzs7G39/fIP3tJEkiPT2dCxcu4O/vf0M3Ao1GQ35+vo4XoBwBtLe3v6H6xYsXL3LmzJl29TK8UWRROnDgQOXGU1tbS0JCAr9E7uTwgYOkZ12iRFtFrakRWjMjNBbGaBws0NqYoWrk9ZEkCYoqsSiuxs7UmL497PDs40BhfgWV5RpUmGBsZIaJsSUWpl3o3asvd4waQ3BwcKN/E/L0hX79+hmMb2XdDnK1Wk15eTkAzs7O+Pj4GOS4RFnwtXed4Y3UAcoG1rJ1zNNPP01iYiIHDhxo9di71vLtt98yc+ZM1q9fz7Bhw1i1ahXfffcdKSkpuLq6MmPGDLp37867776r87zbb7+d7t27s23bNp3tpaWlvPHGG9x///24ublx9uxZXnnlFUpKSjhx4oRBOg10BEp697OHsLXUb8NgcUUNjnNFerc+ItIHSupCo9Ho+OfJ6R07OzvFk6t+h25ISIhebwomJiZKtEKj0ZCXl0d2djZxcXGYmJjopDmTkpIoLy9n2LBhHd740BharZaUlBRyc3MZOnToDQtnY2NjJVpT1wvw5MmTTXoBNkVdURoYGIidnd0NrbG9uHz5MqmpqQ2iuSYmJgQHBxMcHKxsk0VOWloav/7yC3/s+Y0Lp7OoUtVSIlVTaQJac2OMK2sxLqvBw6kr3gMHYG7WBUd7N24Lup2RI0e1uJRBjqp5e3sbzAg90O0gd3FxUf7mq6qq+P333/Xa7NAc5JSuPhpLVCoVNjY22NjY4OXlpVMHmJaWds06QNnOysbGhgEDBvDcc88RFxdHdHS03gUfwMMPP4xarWbp0qVkZWXh7+9PVFSUspYLFy40+FKYmprKn3/+yZ49exocz9jYmMTERLZs2UJhYSHu7u6MGzeOt956Swi+xvj/tcZ6P6egAbd8pE+SJCoqKti7dy933XWX8gebm5tLQkICvXr1wsvLy+Bn6NadeCEbHpuamuLj44OT0/VnlOobOWVeXl5OYGBgu3Qqy0iSRFFRkfLa1PUCbMooW46U5uTkEBgYqLdobks5d+4cGRkZrY6UyhZCdbtdCwsLGTFiRJs1ychRyMGDB3fITb85FBYWEh8fj5eXl5J2rqqqUkor5GYH+X1TP7KuD2TB5+Li0uGdxHXrAOv6ATo4OHD69Gnly/LLL7/Mb7/9RnR0dINaXcHNjRLpW/NAx0T65kWKSF89hOiTJKqqqvj111+54447sLKy4uLFi6SkpDBw4EAloqZSqZQO3R49ehh0J19cXBwWFhZYW1ujVquRJAlnZ2dcXV2vO/JMH1RXV5OQkNAsQ+O2Rk5XySJHNsqWb+Ry1Far1ZKUlERJSYkyacXQkCSJs2fPcunSJQIDA9vkg61+l7TcQCR3SbfmPZ+ZmUlycrJBp8YLCgpISEigb9++10w71xc5cmS5LcoHmoPcEGEIgq8+cmQ9KyuLEydO8OyzzxISEqKMqPzjjz/w8vLq6GUK9IwQfYaHEH2SRHV1Nb/99hvDhg0jMzOTS5cuKTVwcsNGW3XotieN2Z1IkqQz8qy2trZVac62oqKigri4OLp06cLgwYM7PFJa19OtuLgYOzs7nJycyMnJQavVEhgYaJA1XfqIQtZtIMrLy8Pc3FwRgM1tkpEbdPz8/AzWtFauM+zfv3+zO9u1Wi0FBQVKHaBGo9FpdmjrMYuGLPhkamtriYuLw8jIiOrqahYuXEhiYiKSJDFy5EjCwsKYMmUKffv27eilCvSELPpyV9/fIaLP6bntQvTV45YXfXA1hbN//366dOmizE+1sLBAfmnkDl1fX1+DvXFlZ2dz8uTJJgvk6488k7vyXFxc2uVGVZ+SkhLi4uJwcXExyDFWlZWVZGZmkpGRgUajwcbGRmmS0bcXYFNotVpOnTpFYWEhQUFBeolCyvWjssiRU3kuLi7XjB7LXeM32qDTnsgWPAMGDGj1lzn570oWyOXl5Tg4OCjR4xut8ZIFnyFPA9FoNMo4Qj8/P95//30+//xzDhw4gK2tLT/88APff/89+/fv5+DBgzp+eYKbFyH6DA8h+kDp3rW2tiY4OBhjY2MkSUKr1ZKcnExhYaFeO3RbgiRJXLhwgbNnz7YofSanOeV5wBUVFTppzrZOuebn53P8+HF69+5N7969DfLGVTcKOWDAAEXk5OXlYW1trUS5rmeT057ItZAVFRUEBgZ2SNG4HOWSRY4c5ZKjxyYmJkrzS0BAgEF2jcPVut3ExMQ2byyRo8dqtVq54cgCuaVfHjqL4EtISECr1RIQEMDHH3/MqlWr2L9/fwO/yeLiYqysrNr9C6bAMFBE33/u6xjR98IOIfrqccuLvpqaGvbv309tbS0DBw7ExcVF6dCVUxN+fn4G2ZHVlpYsdevcSktLlUiFi4vLDac3ZWPojvK3aw6lpaXExcXh7OzcIApZ1yYnNzcXMzOzFqc52wK5a1yj0RAQENChM5Nl6kaPc3JyqKysxMLCgqqqKvz9/XFwcOjoJTaK3EksT9ZpL6qqqpT3Tn5+PpaWlooAvF4jSGcQfFqtluPHj1NTU0NAQADr1q3jvffe49dff2Xo0KEdvTxBByNEn+Fxy4s+QJm96+TkRK9evaioqDDIDt26yBGfsrKyNm80KC8vV27icp2bPPO2pV2258+f5+zZs/j6+uLk5NRma2xL5FpIDw8PvLy8mry5NpbmbCsvwKaoqalRbHn8/PwMMlIiSRInT54kJycHS0tLysrKsLOzU6LHhtIMk5OTw4kTJ/TeSSw3gshRwKZS5J1F8CUmJlJVVUVgYCCbNm1i2bJlREVFtVv6du3ataxcuZKsrCz8/Pz45JNPdObh1mXz5s088cQTOtvMzc2prKxUfpYkiWXLlvH5559TWFjIyJEj+eyzz+jXr1+7rP9WQxF9H07tGNH30k4h+upheHcOPVNeXo6RkRFubm6kp6fz448/YmtrS2BgoMEKvrrdr8OGDWvziI+VlZWShq2srCQnJ4esrCxSU1MVLzMXF5cmb+Ly2LorV64QFBRk8Cm+xka/NYaxsbFy/XWL+ZOSkpQuafkm3lbvncrKSuLi4rC2tmbIkCEd3n3dGJIkkZycTEFBAcOHD8fS0lJ576jVak6fPt0mncA3imwdM2TIEFxcXPR67samXuTk5JCcnExNTY2SIre2tub48eM4OTkZtOBLSkpSaqC3bt3K0qVL+eGHH9pN8H377be8+OKLrFu3jpCQEFatWkVoaCipqanX/Le0tbUlNTVV+bn+a/n++++zevVqtmzZgqenJ0uWLCE0NJRTp061q42UQNBR3PKRvh07dvDoo48yZswYbG1t2blzJwsXLuS2225DkiRlpJc+LBmaQ1lZGfHx8R0ShayqqlIigAUFBdjY2OjcxGW0Wi0nT56kqKiIwMBAgzC0bYzMzExOnTrFoEGDrjuD83rU9wJsqyaZ8vJy4uLisLe3x8fHxyDeg/WR/72Li4sJCgpq9GYpz0uWayQtLCyUCKC+UuRymYGhjSOUJImSkhKlwaq8vBxzc3M8PT1bFV1vb+SIrvzvvWPHDp5//nm+//77dp05GxISwtChQ1mzZg1w9X3n4eHB/PnzWbRoUYP9N2/ezIIFCygsLLzmdbi7u/PSSy/x8ssvA1BUVISrqyubN29m2rRp7XYttwoi0md43PKRvvvuu49jx44xb948oqKiMDIy4ujRo7i7uzNq1CgqKyt1ojgd6XUnpyHd3d1veNZmazA3N1cGtFdXVyuF/GfPnlUaHZycnDhz5gy1tbUMHTrUIGsh4aoDf1paWpvNTFapVNjZ2WFnZ0e/fv2UJpn09HSSkpIa9QK8HvJEGDc3N4O16dBqtYrJdnBw8DX/vevOS66bIo+Pj9dLilz2CvTz8zO4MgOVSoWtrS1mZmZkZWXh5uaGjY2NEl2Xv1w5Ozt3WIRUpu74yeDgYH766Seef/55vvvuu3YVfNXV1cTGxrJ48WJlm5GREWPHjuXw4cPXfF5paSm9evVS7JeWL1/OoEGDAMjIyCArK4uxY8cq+3ft2pWQkBAOHz4sRF8bImkkJD3P3tX3+ToLt7zoq6ysZMWKFVy4cIHExESMjIyIjIxk3bp1zJ8/n9GjRxMeHs4dd9xBdXU1p06dUkZ6ubq64ujoqBcB2BxLFn1iZmZG9+7d6d69OzU1NeTm5pKVlUV6ejpGRkZ4eHhQVVWFmZmZQYmVuobG7ZV2rju6qm/fvsrEi0uXLpGcnKzUubm4uFwzilNUVER8fHyz6gw7Co1GoxTxBwUFNVvMXitFLo/LqxshbYtI9pUrV0hJSTFor8DKykpiYmJwcHDAx8cHlUpF7969lS9XarWa9PR0LCwslBICfTYRwdW/nZSUFAoKCggODmbv3r08/fTTfP3110ycOLFdz52bm4tGo2lQg+nq6kpKSkqjzxkwYAAbN27E19eXoqIiPvjgA0aMGMHJkyfp0aMHWVlZyjHqH1P+nUBws3HLi763336bs2fP8vfffyt//EuWLOG1117jzJkzREZGsnHjRp5//nnuuOMOwsPDueuuu6ipqSElJUUvZsdyM8TgwYP1XofUHExNTbG1tSUtLU1p+FCr1cTExGBqaqp43en7JlUfue4sNzeX4OBgvVnwWFtb4+npiaenJxUVFUqE9PTp09ja2ioCSE6Dy2bBza0z7Ahqa2tJSEhAkiQCAwNbXVdqZGSEo6Mjjo6OeHt7K53AaWlpOhFSJyenVnWRyzOJDbmTuDHBJ1P3y1XdCKlc0yvPvW3LGtLGkCSJ06dPK387Bw8e5IknnmDTpk2Eh4e323lvhOHDh+vUF44YMQIfHx/Wr1/PW2+91YEruwWRtKDV8yxcSczebYxbvqavtLQUY2Pj6zYlpKenExkZyY4dO4iLi2PUqFGEhYVx9913o9VqlTouWQC2RZRC/qCVB4QbajOEHJWqOwkErkaC8vPzyc7ORq1W60R47O3t9SoANRoNSUlJSrezIdRJ1U2Ry16A8ug8Q578UlNTQ3x8PMbGxvj7+7eL2JAkSYmQqtVqSkpKWtwJfPHiRc6cOUNAQIDBmkM3JfiaQm4Ekd8/NTU1OgK5LZu75FFqmZmZBAcHc/ToUR566CHWrVvH9OnT9fJ3XF1djZWVFZGRkToic+bMmRQWFvL999836zgPPvggJiYmfPPNN6Snp9OnTx/i4+Px9/dX9rnzzjvx9/fn448/buOruPWQa/rU703B1kLPNX2VNTgv3C1q+upxy4u+liJJEufOnWP79u3s2LGDY8eOMXz4cMLCwhgzZgwqlUpn2oWrq2urBKAsUkpLSwkICDDYZgjZ7+x6USk5jSebQQN6a5KRo1JarRZ/f3+DHKtWU1NDWloaly5dQqVSKY0OhhAhrUt1dTVxcXGYm5vj6+urt0YiuRM4JyeHwsLC63YCy4blAQEB2NnZ6WWNLaW1gq8+dedJq9VqSktLsbe3VwTyjX7BkcshgoODiY+P5/7772fVqlU8+eSTen1fhoSEMGzYMD755BPg6mdKz549mTdvXqONHPXRaDQMGjSIiRMn8tFHHymNHC+//DIvvfQScFWkuLi4iEaONkKIPsNDiL4bQJIkLl68qAjAv//+m5CQEEUAmpiYkJ2dTWVlpY4AvF4nZ11LFj8/P4MUKXA1dZaSktJivzNJkpQ6LnmiQ90mmbYUElVVVcTHx2NmZoavr69B+tvB/0Wl/Pz8sLOz0/ECrBshtbOz67AO3qqqKmJjY5W5yR21jut1Al+4cIH09HQCAwMNNjreVoKvMeqWEDRHIDdFRkYG58+fJzg4mJMnTxIeHs7y5ct59tln9f5F5Ntvv2XmzJmsX7+eYcOGsWrVKr777jtSUlJwdXVlxowZdO/enXfffReAN998k9tuu42+fftSWFjIypUr2bVrF7GxsQwcOBCA9957jxUrVuhYtiQmJgrLljZCEX3L7+0Y0ffqD0L01UOIvjZCkiQuX77Mjh072L59O4cOHSI4OJiwsDDuueceTE1NdcadyQKwfhpGtugwZGNoOd194cIF/Pz8bqhWqq7VSXZ2tuJX1toIaV0qKiqIjY2la9euDBo0yCDtTuTI8blz5xqNStVtdMjJyWk3L8DrIb+WdnZ2DBw40GBeS41GQ25urtLsII9P7N+/Pz169DCYddalsrJS57VsT/EkC2S1Wk1ubi7m5uaKQLazs2vy3PL7MigoiDNnznDvvfeydOlSFixY0GGR5zVr1ijmzP7+/qxevZqQkBAARo8eTe/evdm8eTMAL7zwAjt27CArKwt7e3uCgoJ4++23CQgIUI4nmzNv2LCBwsJCRo0axaeffkr//v074vJuOoToMzyE6GsHJEkiMzOTnTt3sn37dv744w8CAgIIDw/nnnvuwcLCgpycHMrKyhQB6OzsTFlZWYdasjQHrVZLSkoKubm5BAQEYGNj02bHru9XJkdI5ZtUS6J0JSUlxMXF4erqarAGt7KBdWZmJoGBgdd9LWWBLKfI6xr63ogX4PUoLy8nNjYWJyenBiPqDImzZ89y/vx5nJycKCgoQKvVKo0ObdUJfKPoU/DVR24EkQUycM0vEHJ6PCgoiPPnzzNx4kT+9a9/sXDhQoP99xcYHrLoy3l7coeIPpfXfhSirx5C9LUzkiSRnZ3Nrl27iIyM5ODBg/j6+hIeHk5oaChWVlbk5OSwd+9ebGxsGDNmDAMGDDDIlK48+q28vLzdmyHkQn5Z4MgCuTledwUFBSQkJNCrVy88PT0N8iYldxLn5eURGBioY27d3OfLAlmOIDs4OCgR0rZ6/3QGr0A58nzx4kWCgoKwsbFRBLKc5qysrLzhTuAbpSMFX30kSVImgqjVaqqqqnBycsLZ2Znq6moyMjIIDAzkypUrTJgwgWeffZZly5YZ5L+/wHARos/wEKJPj0iSRG5uLt9//z0REREcOHCAgQMHYm9vz+HDh3n77bcJCgqipKQEe3t7xerEEARg3TpDf3//Nh/9dj3kTs6cnBzl9ZHrlOoaAsuNJXJ6zxCRR1iVlpa2mXi+1utzI4X8JSUlxMbG0qNHD/r06WOQN3y5s1Qe99eYDU/dTuCcnBxKS0ub5ZXYllRVVRETE2MQgq8+dV+fy5cv8+6771JUVMRtt93G9u3bmT17NsuXLzeoNQs6B4roe2NSx4i+ZT8J0VcPIfo6CFkAPvrooxw8eBBJkvDx8SEsLIwJEyZgZ2dHTk4OxcXF1xQ4+qKiooL4+Hisra0ZPHhwh6fJKioqlBt4UVERXbt2xdXVVREALW0s0SeyoXF1dTWBgYHtIujlQv7s7GzlA6++F+D1KCoqIi4ujt69e+Pp6dnma2wL6qbHg4ODmx0trd/oUHfiRXt4N8qCT64tNVTxJE8tsbOzY9u2bXz++efU1tYqmYnw8HB8fX0Ndv0Cw0OIPsNDiL4OoqKigscff5zExER+/vlnHB0d+f7779m+fTt79+6lT58+hIWFMXHiRBwdHRWBo+8IhVwb5+LiYpD1XJWVlajVas6fP09FRQXW1ta4u7u3SODoi5qaGhISEgD0Fi2tqqpSBE5+fr4yLs/V1fWanZxyerxPnz4Gaw4te1hmZ2cTFBTU4vS4TF2vxPz8fB2rHFtb2xt+v8sdz3JjlqH9/cjIE398fX2pqKggNDSUCRMm8NZbbxEVFcWuXbuIiopi8uTJbNu2raOXK+gkCNFneAjR10F89NFHbN++ne+//77BLNCioiJ2797N9u3b+fXXX+nVqxdhYWFMmjRJmXZRWFioRLjaSwDm5+dz/Phxg6+NO3PmDFeuXGHIkCFKFDA/P1/HqkJf0zeuRUf529VFHpeXk5NDbm5uowInNzeXxMREBgwYYLDm0JIkkZqailqtJigoqM3EfW1trWKVk5ubi7GxsdLo0Bovyc4i+NRqNYmJifj6+lJbW0toaCh33nknGzZs0HmfVlZWkpWVRe/evTtusYJOhSL6lk7sGNH35s9C9NVDiL4OQqPRUF1dfd3JAsXFxfz4449s376dqKgo3N3dCQsLY/Lkybi5uaFWqykoKMDW1lYRgM2ZVnA9srKyOHnypEFPhtBqtSQnJ5Ofn9+gGaKmpkZn2oWlpaUS4erSpYteb8ByAb+NjU2H+tvVpe5IL9kL0MbGhvz8fHx8fHB3d+/oJTaK3ACTn59PUFBQm7zXG6O+VY7cCdzccYudRfDl5uZy/PhxBg8eDMCECRMYOnQomzdv7vAyDkHnR4g+w0OIvk5EaWkpP/30E9u3b+fnn3/GxcWFsLAw7r33Xtzd3RUBaGNjowjA1kRB5Fm/Q4YMwdnZuR2u5MaRO4krKioICAhoMtJZW1urE+EyMzNTXp+2SOE1RVlZGXFxcTg6Ora5CW9bodVqFbsTY2NjZaarLHAMQaTCVcF36tQpCgoKCA4O1pt5bl0vyZycHKqqqnQ6yeun6TuL4JNnPA8cOBBTU1MmTpyIj48PW7dubTf7n7Vr1yo+e35+fnzyyScMGzas0X0///xzvvzyS5KSkgAICgpi+fLlOvvPmjWLLVu26DwvNDSUqKiodlm/oGXIoi/7tQkdIvpc3/5FiL56CNHXSSkrK+OXX35h+/bt/PTTTzg4ODBlyhSmTJmCh4cHarVaSXG6urri6up6XQFYN1UaEBBgsNMMbqQ2rn6Ey8TERGfaRVveoOV6SHd3d52ZxIbG5cuXSU1NxdfXF0dHR8XKQ/YCrCsAO2qiiSRJnDx5kqKiIoKCgjpsWkJjncD29vbKa6RSqXSiuob6b15QUEB8fDze3t5YWVkxefJkPDw8iIiIaDe3gG+//ZYZM2awbt06QkJCWLVqFREREaSmpuLi4tJg/+nTpzNy5EhGjBiBhYUF7733Hjt37uTkyZNK9mHWrFlkZ2ezadMm5Xnm5uYGO2v5VkOIPsNDiL6bgPLycn799Ve2b9/Ojz/+iK2tLVOmTOHee++ld+/e5ObmkpeXh7W1tSIA6xe+a7Va5aYaEBDQ6sL49qaqqoq4uDgsLCxuuDZOq9WSn59PdnY2arUalUqlCMAbnQdcWFhIfHy8QXe/wv+Nf/P3928wWaUxs+ymIlztRV2Lm6CgoA7pYL8WdTuBCwoKMDIywsrKisGDB7epcXlbIr83+/Xrp3xWODo6smvXrnZ9bUNCQhg6dChr1qwBrv67enh4MH/+/GbPzrW3t2fNmjXMmDEDuCr6CgsL2bVrV7utW9B6hOgzPAxzEKmgRVhZWTF16lSmTp1KZWUle/bsYfv27TzyyCNYWlrqRABzc3PJyMjAyspKqXGzsLDg+PHj1NTUMHToUIO6qdZFHlHXVqPAjIyMcHJywsnJSaeGKykpSWfcWUtTnHIzRL9+/fDw8LihNbYn586dU0x4649/A1CpVNja2mJra0vfvn0pLS0lJyeHCxcucOrUKb1YCWm1WsUQPDg42CA8K+tiaWlJz549cXNz49ixY5iYmGBmZsbRo0extLRU3kPtXUbQXIqLi4mPj6dv377Y2dkxdepUbGxs2LFjR7v+3VdXVxMbG8vixYuVbUZGRowdO5bDhw836xjl5eXU1NQ0+HISHR2tfFG7++67efvtt3F0dGzT9QtuEI326kPf5xQ0QIi+mwwLCwtF5FVXV7N37162b9/OY489hpmZGffeey9hYWF4eHiQl5dHfHw8+/fvZ9q0afj6+hrcTVVGvll169atXUbUGRkZ4ejoiKOjI97e3kqKMyUlhdraWmUe8PWK+LOzs0lKSmLgwIF069atTdfYVtSfYNHcb8FdunShS5cueHl5KV3SWVlZpKam0rVrV0UAtlVzhSz4KioqCAoKMtj3pixo6jbq1O0EjouLw9jYWImQ3mgUubXI5QZeXl44OjrywAMPYGxszPfff99uDTEyubm5aDSaBv6Zrq6upKSkNOsYCxcuxN3dnbFjxyrbxo8fz3333Yenpydnz57l1VdfZcKECRw+fFg0oggEjSBE302MmZkZkyZNYtKkSVRXV3PgwAEiIyOZNWsWRkZGjBw5kujoaMXYNjY2FgsLC6XJwcbGxiCiE7J1jKenp17sIlQqFfb29tjb29O/f3+Ki4vJycnh9OnTVFVVKdGb+vNu69bGGWoDTH1D49Za2VhaWtKrVy969eql4wV45swZHauca3kBXg+tVsvx48epqqoiKChI7xNgmoss+GTjclnMmZiYKKUUchmBHEVuaSdwWyCP0+vVqxeurq488sgjVFVV8euvv3a4nVFzWLFiBdu2bSM6OlqnnnPatGnK/w8ZMgRfX1/69OlDdHQ0Y8aM6YilChpBkiQkrX4ryUTlWuMI0XeLYGZmRmhoKKGhoXz66aesW7eOV155BZVKRVxcHBs3biQsLIxevXpRUFBATEyMXrtcr4V8o+wo3ziVSkXXrl3p2rWrkuLMzs4mPT2dkydPKjVulZWVnD9/vtHaOENBkiRSUlLIzc1l6NChbeZvZ25uTo8ePejRo4eOVU5GRkarzI7lqSU1NTWdUvDVp24ZQd1OYPlLhDzztr3qJMvKyoiNjcXDw4Pu3bvz2GOPkZeXx969e/VW6+Tk5ISxsTHZ2dk627Ozs3Fzc2vyuR988AErVqzgt99+w9fXt8l9vby8cHJyIi0tTYg+gaARhOi7BdmzZw+vvvoqK1eu5JlnnuGPP/4gIiKCZ599lqqqKiZPnsyUKVPo378/hYWFxMXFKZELFxcXunbtqhcBeOnSJU6fPs3gwYMb7e7TNyqVChsbG2xsbOjbty9lZWVkZ2dz5swZqqur6dq1K+Xl5XTp0sXgUpFarZZTp05RWFhIcHBwu6XzTE1NcXd3x93dHY1Go1jlyO+h63VKazQaEhIS0Gg0BAYGdnrBVx+VSoWdnR12dnb069fvmnWSNzIzuS7l5eXExsbi7u6Oh4cHTzzxBBcvXmT//v167XA1MzMjKCiIffv2ER4eDlx9T+7bt4958+Zd83nvv/8+77zzDr/++ivBwcHXPc+lS5fIy8sz2NKKWxaNdPWh73MKGiC6d28xcnNz8fb2Zt26dTzwwAM6v9NoNPz5559ERkayc+dOysrKmDRpElOmTMHPz4+ioiIdmxNXV9d2EYCSJHHu3DnOnTuHv7+/wdovyJMhcnJyGDhwoHIDLy4uxs7ODldX1za7ed8IhtD9WjfFmZOTA6AIQAcHB4yMjNBoNMTHxyNJEgEBAR1mD3M9ZMFnZWXFkCFD2qw+r/5MaXkmsJwmb83xYmJicHFxwcvLi6effprExEQOHDjQIbOpv/32W2bOnMn69esZNmwYq1at4rvvviMlJQVXV1dmzJhB9+7deffddwF47733WLp0KVu3bmXkyJHKceTa0tLSUt544w3uv/9+3NzcOHv2LK+88golJSWcOHHCYBvSbiXk7t2sf92Drbmeu3eranBbuVd079ZDiL5bkMLCwka7Neui0Wg4fPiwIgCLioqYMGECU6ZMITAwkOLiYtRqNUZGRooAbAufO3mmalZWFoGBgQZre1E3clZ/MkRlZaVicyJ/4LTltJSWoNFoSExMpKqqisDAQIOIQEqSpDPtQqPR4OjoSElJCWZmZgQGBhpsEX57Cb7GzlN3oozcbe/s7NysNHllZSUxMTE4OjrSr18/nnvuOQ4dOkR0dHSHTltZs2aNYs7s7+/P6tWrCQkJAWD06NH07t2bzZs3A9C7d2/Onz/f4BjLli3j9ddfp6KigvDwcOLj4yksLMTd3Z1x48bx1ltvdYioFTREiD7DQ4g+wXXRarUcOXKEyMhIduzYQV5eHuPHj2fKlCkMGzZMaXSQfe5kAdjSG2Jdr8DAwMA2qzlra+pOAwkMDGwyoiA3OWRnZ1NQUKCYZbc2etPSdcqp0oCAAINMlUqSRH5+PidPnqSmpga4Wv8lN8oY0prl+cmWlpbtKvjqU3+iTP00ef11VFVVERMTg52dHd7e3rz44ovs27eP6OhoevbsqZc1CwRQR/S9NLZjRN+HvwnRV4+bRvS98847/PTTTyQkJGBmZkZhYeF1nyNJEsuWLePzzz+nsLCQkSNH8tlnn9GvXz9ln/z8fObPn88PP/yAkZER999/Px9//HGn6HhrD7RaLTExMYoAzMrKIjQ0lLCwMG677TbFzFeSJEUANseiQi7er66uJiAgwGBTM7W1tRw/frxVQkpucsjOzlbMsuXXqLVdrk2tMz4+HpVKhb+/v8GmSmtqaoiLi8PU1BRfX18lSipPu3BwcFAiXB35nqipqSE2Nlbvgq8+ddPkarUaSZIUkezo6IhGoyEmJgZbW1t8fHxYvHgxu3fvJjo6Gi8vrw5Zs+DWRYg+w+OmEX3Lli3Dzs6OS5cu8cUXXzRL9L333nu8++67bNmyBU9PT5YsWcKJEyc4deqUUoc1YcIEMjMzWb9+PTU1NTzxxBMMHTqUrVu3tvMVGT5arZb4+HgiIyPZvn07ly9f5p577iEsLIwRI0YojQ6y0bGrq6tSv1WXmpoa4uPjMTIyws/Pz6CiO3WR12lsbIyfn98NCana2lolfZebm6t0ubq6ut6wVU5dIeXn52ewqVJZSJmbm+Pn59fgfVFeXq4IQPnm0dZegC1ZZ0cLvvo0NhM4JiaGmpoa/vGPf7B27Vq++eYboqOj6d+/f0cvV3ALIv/dZi4Yi625fr94FlfV0m2VEH31uWlEn8zmzZtZsGDBdUWfJEm4u7vz0ksv8fLLLwNQVFSEq6srmzdvZtq0aSQnJzNw4ECOHTumdI5FRUUxceJELl261KG1MYaGVqslMTFREYDnzp1j7NixhIeHM3LkSOUGrtFolBu3o6OjkjKTa6QMVaDI49/ao5arbperWq3G1NS01Y0y+qo5u1Faus6qqipF3NRNkzs7O7dr1F0WfPLYP0N+PWNiYhQz9oyMDIyNjVm0aBHPPPOM+KwSdAhC9BkehvkJpgcyMjLIysrScXfv2rUrISEhyligw4cPY2dnp2MVMHbsWIyMjDhy5Ije12zIGBkZ4e/vz9tvv82pU6c4evQoAQEB/Oc//8Hf358lS5Zw4cIFvLy8MDExISUlha+++ooNGzZgbm7OoEGDDFbwVVRUcOzYMWxsbNpFSBkbG+Pq6sqQIUO488478fb2VtKzf/zxBykpKeTn51/XbLSyspJjx47RpUuXTiH4rK2tm71Oc3NzPDw8CAoK4s4776Rnz54UFRVx5MgRDh06RFpaGsXFxW1qyNpZBF9tbS0JCQlYWlry2muvMXPmTGxtbXnuueeUOr7hw4ezatWqjl6qQCDoYAyz0EcPZGVlATQ6Fkj+XVZWVgN/OBMTExwcHJR9BA1RqVQMGTKEIUOG8MYbb5CcnExERARr165l/vz53HXXXfj4+PDFF1/wwAMPEBgYyB9//KGkgPU1paA5lJaWEhcXh4uLCwMGDGh3f0JjY2PFqNfHx4eCggKys7M5ceKEUidZ1+ZEpqKigtjYWBwcHPDx8TGISSqNUVVVpYwsGzRoUKuEVF0vwLrjzmJiYpQoaVNegM2hswg+2ebG2NiYIUOG8Omnn/Kf//yHvXv3Kl9Wc3Jy+OGHH7h06VIHr1Zwy6KVrj70fU5BAwxa9C1atIj33nuvyX2Sk5Px9vbW04oELUWlUjFw4ECWLVvG0qVLOX36NCtWrGD16tUAXLx4kdOnT3PXXXdRW1vL6dOnqa6uVmbdyk7+HUFRURHx8fF4eHjg5eWldyFVdx5wXZuTU6dOodFolFFelpaWxMfH602YtpbKykpiY2Pp2rUrgwYNapN11h93JgvA48ePo1KplNeosVrSayHXRHYGwZeQkIBKpcLPz4+NGzeyfPlyoqKidLITLi4uzJ49uwNXKhAIDAXD/DT7/7z00kskJyc3+WhtR5o8+qepsUBubm6KkaxMbW0t+fn51x0dJGiISqXi+PHjfPfdd2zevJnU1FTuvvtutmzZgr+/Py+88AIpKSn07t0bKysr0tLSiI6O5vjx42RlZVFbW6u3tebn5xMXF4enpyd9+vTpcCGlUqlwcHDA29ub22+/nYCAAMzMzEhJSeHvv//G2NgYOzs7tFpth67zWsi+cXZ2dm0m+OpjZGSEs7MzgwYN4o477lBSx6dOneLgwYMkJSUpdaXXQhZ8ZmZmBi345NnEWq0WPz8/vv76a5YuXcru3bsZPnx4u5xz7dq19O7dGwsLC0JCQjh69GiT+0dERODt7Y2FhQVDhgzh559/1vm9JEksXbqUbt26YWlpydixYzlz5ky7rF3QwWi0HfMQNMAwP9H+P87Oznh7ezf5aK3ZrKenJ25ubuzbt0/ZVlxczJEjR5QPzeHDh1NYWEhsbKyyz/79+9FqtYqhqKD5/P7778yePZuIiAgef/xx+vbty+LFizl69CipqamMHz+erVu3EhAQwPz580lKSqJ3795YW1uTnp7OwYMHSUhIIDMzU/F0aw/UajUJCQn079+fXr16tdt5Wos8ysvV1RWNRkOPHj1wdXXl7Nmzikhu79eoJciTIRwcHBg4cKBeBLSRkZGOSJb9FE+fPn3N16iu4Gusm9hQkJumampq8Pf3JzIykldeeYWdO3dy5513tss5v/32W1588UWWLVtGXFwcfn5+hIaGNvhSLHPo0CEeeeQRZs+eTXx8POHh4YSHh5OUlKTs8/7777N69WrWrVvHkSNHsLa2JjQ0lMrKyna5BoHgerT0i01hYSH//Oc/6datG+bm5vTv31/ny41Go2HJkiV4enpiaWlJnz59eOutt9q09ril3DTduxcuXCA/P5/du3ezcuVK/vjjDwD69u2rdPd5e3vz7rvvMnXqVOCqZcuKFSt0LFsSExMbWLZkZ2ezbt06xbIlODhYWLa0Aq1WS2pqKj4+PtfcR5Ikzp8/z/bt29mxYwdHjx7ltttuIzw8nHvuuQeVSkVOTg5lZWU4OjoqHZxtZfOSmZnJqVOnGDx4sEG7+hcWFhIfH4+Xl5ciTCVJUmxy6r5Gss9dR0zjkGe/Ojs7G0TqubHXyMHBAUdHR65cuYKFhYXBCz7ZGDwoKIjdu3czd+5cIiIimDBhQrudNyQkhKFDh7JmzRplHR4eHsyfP59FixY12P/hhx+mrKyMH3/8Udl222234e/vz7p165rlniDo/Mjdu1fmju6Q7l33z6Kb3b377bffMmPGDNatW0dISAirVq0iIiKC1NTURme/V1dXM3LkSFxcXHj11Vfp3r0758+fx87ODj8/PwCWL1/ORx99xJYtWxg0aBAxMTE88cQTvPPOOzz33HNtfs3N4aYRfbNmzWLLli0Nth84cIDRo0cDVyMkmzZtYtasWcD/mTNv2LCBwsJCRo0axaeffqrjaZWfn8+8efN0zJlXr159y5oz6xNJkrh06ZIiAA8dOsSwYcMIDw9n3LhxmJiY6Jj4ypMuWisAL168yJkzZ/Dz88PR0bGNr6btyMvL4/jx4/Tv358ePXpcc7+ysjLF5qSkpAR7e3ulyUEfRsdlZWXExsbi6upK//79O1zwNUZ5eTmZmZmcP38ejUajMzNZ3yPzrockSTozlPfs2cMTTzzB119/TXh4eLudt7q6GisrKyIjI3XOM3PmTAoLC/n+++8bPKdnz568+OKLLFiwQNm2bNkydu3axfHjx0lPT6dPnz7Ex8fj7++v7HPnnXfi7+/Pxx9/3G7XI9AfnUn0tfSLzbp161i5ciUpKSnXvOdMnjwZV1dXvvjiC2Xb/fffj6WlJV999VUrr+zGMMyvs61g8+bNSJLU4CELPrj6oSkLPrgqAt98802ysrKorKzkt99+a2Bi6uDgwNatWykpKaGoqIiNGzfqCL78/HymT5+Ora0tdnZ2zJ49m9LS0muu89y5c6hUqkYfEREROmur/9i2bduNv1CdCJVKhYeHBwsWLODgwYOcP3+eRx55hJ9//pmhQ4cye/Zsjhw5Qo8ePbC3t+fSpUscPHiQuLg4Ll26RHV1dbPOI0kSGRkZpKWlERgYaNCCT61Wc/z4cby9vZsUfADW1tZ4enoSEhLCyJEjcXJyIisriz/++INjx45x4cKFdkullZWVERMTg5ubm8EKPrjaCZyXl4e9vT0jR47Ezc0NtVrNX3/9xZEjR8jIyKCsrKyjl4kkSZw6dYqSkhKCgoI4cOAATzzxBJs2bWpXwQeQm5uLRqNp0umgPllZWdd1RpC3NfeYAkFrKC4u1nlUVVU12Ee2kapr4WZkZMTYsWMVC7f6yPWz//znP3F1dWXw4MEsX75cp2Z4xIgR7Nu3j9OnTwNw/Phx/vzzz3aNyl8Pg+7e7QxMnz6dzMxM9u7dq6R/n3rqqWumfz08PMjMzNTZtmHDBlauXNngjbBp0ybGjx+v/GxnZ9fm6+8sqFQqunfvzvz585k3bx5ZWVns3LmT7du3s3TpUvz8/Jg6dSqhoaFYWVlx5coVUlJSrhvdkiSJM2fOkJmZSXBwMDY2Nh1wdc0jOzubpKSkVqWeLS0t6dWrF7169dIxOj59+jQ2NjZKlLQt5h2XlpYSGxtL9+7dDaIJ5lrIXogmJib4+vpibGyMlZUVHh4eVFdXk5ubS3Z2Nunp6VhaWirvoxudmNJSJEkiOTmZgoICgoOD+euvv3j88cdZv349Dz74oN7WIRC0Gq0Emo6xbPHw8NDZvGzZMl5//XWdbU19sUlJSWn08Onp6ezfv5/p06fz888/k5aWxrPPPktNTQ3Lli0DrjqQFBcX4+3tjbGxMRqNhnfeeYfp06e30UW2HCH6boDk5GSioqJ0JnZ88sknTJw4kQ8++KBRF3xjY+MGnb87d+7koYceapAytrOzE13CjaBSqejWrRvPPvssc+fORa1Ws3PnTiIjI3n99dcZPHgwU6dOZcKECXTp0oWsrCxSU1OV1J0sAOWbaV5eHsHBwVhbW3f0pV0TWcT6+vri7Ox8Q8eSjY5lcSPPA05LS8Pa2lp5jVpTwlBSUkJsbGyH2dw0l9raWuLi4jAxMWl0VJ2ZmZmOF6A8MaWuF2BrJqa0FEmSSE1NJS8vj6FDhxITE8O0adP4+OOPmT59ul5eX9k2qSmng/q4ubld1xlB3tatWzedfeqmewWCG+XixYs66d22Km3RarW4uLiwYcMGjI2NCQoK4vLly6xcuVIRfd999x1ff/01W7duZdCgQSQkJLBgwQLc3d2ZOXNmm6yjpdw06d2OoC0mdsTGxpKQkNCoj9Y///lPnJycGDZsGBs3buzQjh9DRaVS4eLiwtNPP82ePXvIzMxk3rx5HDp0iJEjR/Lwww+zf/9+pU5LTm8eOnSIXbt2kZ+fz9ChQw1a8F26dImUlBT8/PxuWPDVx8zMjO7duxMYGMidd95Jr169lC52edJFSUlJs957suDr2bOnwUf4mhJ89TExMcHNzQ1fX1+diSkJCQn8/vvvyheHtrbLkaPQarWa4OBgjh8/zoMPPsiKFSt48skn9fb6mpmZERQUpON0oNVq2bdv3zXtYYYPH66zP8DevXuV/ZvjniC4eZC0Uoc8AGxtbXUejYm+1nyx6datG/3799f5/PDx8SErK0spLfrXv/7FokWLmDZtGkOGDOHxxx/nhRde4N13322rl7bFiEjfDdAWEzu++OILfHx8GDFihM72N998k7vvvhsrKyv27NnDs88+S2lpaYd1/HQGVCoVTk5OzJ49myeffJKCggK+//57IiMjWbFiBf369SM8PJzRo0fz6quvAvDaa6+RmJioRLcMrXj//PnzpKenExgY2O7p/fqTLuTo1rFjxzAzM1OiW7a2tg0ER3FxMbGxsXh6etK7d+92XeeN0FLBV5+6E1O0Wi2FhYXk5ORw8uRJHcPstpgqc/bsWTIzMxk6dCjJycncd999vP766zz77LN6F9QvvvgiM2fOJDg4mGHDhrFq1SrKysp44oknAJgxYwbdu3dXbmbPP/88d955Jx9++CGTJk1i27ZtxMTEsGHDBuDq3+qCBQt4++236devn+Ke4O7u3u41igJBfep+sZHff/IXm3nz5jX6nJEjR7J161a0Wq3S7X/69Gm6deumOCWUl5c3cAIwNjbuUD9VIfoaobmTQG6UiooKtm7dypIlSxr8ru62gIAAysrKWLlypRB9zUQ2M37iiSeYNWsWRUVF7N69m2+++Ybly5djZmbGM888o0y8UKvVnDlzRqlvc3V17VABKDeXXLhwgcDAQLp27arX88vRLTc3NzQajTLpIi4uDmNjY0UA2tnZUVxcTFxcnI59jCFyo4KvPrIXoIODAwMGDKCoqEipk6yqqsLJyUmxyzExadlHbXp6OpcvXyY4OJizZ88SFhbGwoULWbBgQYdEUB9++GHUajVLly4lKysLf39/oqKilBqoCxcu6NzcRowYwdatW3nttdd49dVX6devH7t27WLw4MHKPq+88gplZWU89dRTintCVFSUYpclEOiTln6xmTt3LmvWrOH5559n/vz5nDlzhuXLl+vco++9917eeecdevbsyaBBg4iPj+ejjz7iySef7JBrhJvIsqUtUavV5OXlNbmPl5cXX331FS+99BIFBQXK9traWiwsLIiIiFD8AK/F//73P2bPns3ly5evm7b76aefmDx5MpWVlXqx27gZUavVhIaG4uzszMMPP8wPP/zAr7/+ioeHB2FhYUyZMgVnZ2fUajX5+fl06dJFEYBt0eDQXCRJIi0tjStXrhAYGGhQzSVarZb8/Hyys7NRq9VIkoRGo6F79+4MGDDAYP3t5KYNIyMj/P3923W0nyRJlJaWKs0yLfVLPHfuHOfOnSMoKIhLly4xYcIEnn32WZYtW2awKXOBoDFky5ZLT96OrZmeLVuqa+mx8Y9mW7YArFmzhpUrVypfbFavXq0MYhg9ejS9e/dm8+bNyv6HDx/mhRdeICEhge7duzN79mwWLlyofL6UlJSwZMkSdu7cSU5ODu7u7jzyyCMsXbq0Q3xTQYi+GyI5OZmBAwcSExNDUFAQAHv27GH8+PFcunSp0UaOuowePRonJyciIyOve6533nmHDz/8kPz8/DZZ+61GZmYmd911F/7+/nz55ZfKH1xJSQk//fQTkZGR/PLLL3Tr1k0RgN26dVO+AMgNDq6uru1a/ycX7ufk5BAUFGTQtYb5+fnEx8dja2tLeXk5kiTppDcNRQDqU/A1RllZGWq1mpycHIqLi7Gzs1M6getHtS5cuMDZs2cJCgoiOzub8ePHM2vWLJYvXy4En6DT0dlE362AEH03yPUmdly+fJkxY8bw5ZdfMmzYMOV5aWlpysiWurYsAD/88APZ2dncdtttWFhYsHfvXl5++WVefvll3njjDb1e381CZWUl69evZ968ede86ZeWlvLLL78QGRnJzz//jJOTkyIAPTw8FAFoZWWlpDfb0qRb7ibOz88nKCjI4OoL65Kfn09CQgIDBgyge/fuSJJEUVGRMumitrYWJycnXF1d26S+rbV0tOCrT2VlpRIBLCwsxMbGRhGABQUFnDlzhsDAQPLz8xk/fjwPPPAAH374ocEIaIGgJcii7+KsUR0i+jw2/ylEXz2E6LtBrjex49y5c3h6eupMBgF49dVX+eqrrzh37lyDD/SoqCgWL15MWloakiTRt29f5s6dy5w5c8SHv54oLy8nKiqKyMhIfvrpJ+zs7JgyZQphYWH07t0btVpNbm6u4t8mC8DWRmO0Wi0nT56kuLiYoKAgg65rkieCeHt7NxrNliSJ4uJicnJyyM7OVurbXF1dcXJyanF9W2sxNMFXH9kuJycnh7y8PD7++GO8vLy4++67WbRoERMnTmTt2rXib17QaRGiz/AQoq+Tkp+fz/z583XE5scff9xk5Gn06NEcPHhQZ9vTTz/NunXrlJ8vXLjA3LlzOXDgAF26dGHmzJm8++67ertRGyIVFRXs2bOHyMhIfvzxR7p06cKUKVOYMmUKffr0ITc3F7VajYWFhdIF3BIDX3meanl5OYGBgQZds5mbm0tiYiI+Pj46/mrXom59W3Z2NhUVFcrIvLacmVwfQxd8dZHnPScnJ7N7924OHTpEly5dmDNnDg888AAhISFC+Ak6JUL0GR5C9HVSJkyYQGZmJuvXr1fSykOHDr3mJBC4Kvr69+/Pm2++qWyzsrJS/iA0Gg3+/v64ubmxcuVKMjMzmTFjBnPmzGH58uXtfk2dAXlcX2RkJLt378bCwkKJAPbt25e8vDxyc3MxMzNTBGBjFicyGo2G48ePU1NTQ2BgYLuJoLZArVaTmJjIoEGDWm0aLs8Dzs7OVmYmy+nNtips1mg0xMXFdQrBl52dzcmTJ/Hz86O2tpYJEybg7+/PtGnT2LVrl/IeW7RokejcF3Q6ZNF3/vGRHSL6ev3vLyH66iFEXydEbiCpOwkkKiqKiRMnNtlAMnr0aPz9/Vm1alWjv//ll1+YPHkyV65cUawY1q1bx8KFC1Gr1R3WbWSoVFdX89tvv7F9+3a+//57TExMuPfeewkLC8Pb25u8vDzUajWmpqZKE0hdASgb/EqSREBAgEFHU3Nycjhx4kSrRsBdi/LycqW+7XoNDs1Fo9EQHx8PXLU6MmTBJ7+mvr6+GBkZMXHiRHx8fNi6davyXqipqeH3339HpVJx9913d/CKBYKWIUSf4SFEXydk48aNrbKKGT16NCdPnkSSJNzc3Lj33ntZsmSJYkeydOlSdu/eTUJCgvKcjIwMvLy8iIuLIyAgoF2vqzNTU1PDgQMHiIyMZNeuXQBMnjyZ8PBwBg4cSH5+Pmq1GhMTE1xcXHBwcCA9PR0TE5NOEY1KSkpiyJAhDczI24r6DQ62trZKrWRzG1o6k+DLzc3l+PHjDBkyBDMzMyZPnoyHhwcRERHiy5XgpkEWfeemj+gQ0df760NC9NVDFIp0Qlo7CeTRRx/lq6++4sCBAyxevJj//e9/PPbYYzrHbWzgtPw7wbUxNTVl3LhxbNiwgStXrvDNN99gZmbGU089RUhICGvXrqW6upo+ffqQk5PDpEmTOHXqFFZWVhQXFxvsiL3MzExOnjyJr69vuwk+AAsLC3r27ElwcDC333477u7u5OXl8ddff/H333+TkZFBWVnZNZ/fmQRfXl6ekia3sLAgPDwcV1dXvvvuO70Jvvz8fKZPn46trS12dnbMnj2b0tLSJvefP38+AwYMwNLSkp49e/Lcc89RVFSks59KpWrw2LZtW3tfjkAgaCaGm0+6BWnvSSBPPfWU8v9DhgyhW7dujBkzhrNnz9KnT59WH1egi4mJCWPGjGHMmDGsWbOGP//8k4iICObNm0dpaSlarRYvLy9Gjx5NRUUFx48fV2YIy1MuDKFw/8qVK8rMX0dHR72d19zcnB49etCjRw9qampQq9VkZ2dz9uxZrK2tlRSw3C3dmQRfQUEBx48fx8fHhy5dujB16lRsbGzYsWOHXht4pk+fTmZmJnv37lVqgp966qlr1gRfuXKFK1eu8MEHHzBw4EDOnz/PM888w5UrVxr4jG7atEnHhqo14wO//PJLXnjhBa5cuaLzuoSHh2NjY8P//ve/Fh9T0HFIWi2SnkeP6ft8nQWR3jUg9DUJRKasrIwuXboQFRVFaGioSO+2M+np6dxxxx106dKF0tJSSktLmTRpElOmTCEoKEgZ4yVJkiIA7e3tO0QAXr58mdTUVL0Lvqaora1VLE5yc3OxsLDA2dmZgoICVCoVQUFBBi34CgsLiYuLY8CAAdjb2/PAAw+g1Wr5+eef29Tv8Xq0tia4PhERETz22GOUlZUpNYgqlYqdO3fe8PzciooKunXrxueff86DDz4IXK2B7N69O3v27OGuu+66oeML9IOc3s145LYOSe96fvO3SO/Wo+PDCQIFZ2dnvL29m3yYmZkxfPhwCgsLiY2NVZ67f/9+tFqtMjKmOcjiTrbeGD58OCdOnCAnJ0fZZ+/evdja2jJw4MC2uchblLS0NEaPHs2UKVM4deoUFy5c4KeffsLFxYVXXnmFoKAgVq5cSWFhIf3798fIyIikpCR+//13Tp06RW5urt6GdF+6dInU1FT8/f0NRvDB1Qhqt27d8PPzY/To0Xh5eZGZmUlxcTFVVVWkpaVRWFhokKnyoqIi4uPj6devH46OjkyfPp2qqirFAkifHD58GDs7O0XwAYwdOxYjIyOOHDnS7OPIN9P6DUj//Oc/cXJyYtiwYWzcuLFV/x6WlpY8+uijbNq0Sdn21Vdf0bNnTx2/U4FA0DJEercT4uPjw/jx45kzZ44yCWTevHlMmzZN+ZZefxLI2bNn2bp1KxMnTsTR0ZHExEReeOEF7rjjDnx9fQEYN24cAwcO5PHHH+f9998nKyuL1157jX/+858G7R3XGVi7di0PPfQQK1euVLp3R44cyciRI/nwww85evQokZGR/Pvf/0atVjN+/HjCwsK47bbbKCkp4dSpU2g0GiW12V5jzi5evEhaWhqBgYGtSsvpkytXrmBlZcXw4cOVKGl8fDzGxsbK62QIqfKSkhLi4uLw8vLC1dWVxx57jLy8POULlb5pbU1wXXJzc3nrrbd0SkYA3nzzTe6++26srKzYs2cPzz77LKWlpa2ym5kzZw5Dhw7l8uXLdO/enc2bNzNr1iwxjq4zopGQNHr+Mqbv83USRHq3k9LSSSAXL17kscceIykpibKyMjw8PJg6dSqvvfaazo3n/PnzzJ07l+joaKytrZk5cyYrVqwwaDuRzoBGo8HIyOi6NyytVktsbCyRkZHs2LGDzMxMxo0bR1hYGCNGjFCMjmtra3Xm3LZFWvP8+fOkp6cTEBBg0IJPo9GQkJCAVqttYHWj1WopKCggOzsbtVqtpMrljml9C8DS0lJiYmLo1asXPXr0YNasWaSnp7N///42j6I2tyZ4x44dbNmyhdTUVJ3fubi48MYbbzB37twmj1FcXMw999yDg4MDu3fvbtJbcunSpWzatImLFy82/0LqEBQUxAMPPMC4ceMYNmwY586dw8PDo1XHEugfJb37UAg2ek7vllTX4vndEZHerYcQfQKBgaLVaklISCAyMpLt27dz8eJF7rnnHsLCwhg1apTic1ddXY2zs/MNzbk9d+4cGRkZBAYG0rVr13a4mrahKcFXH0mSKCwsVOYBazSaNhfKTVFWVkZMTAw9evSgV69ePPXUUyQmJnLgwIE28zqsiz5qgktKSggNDcXKyooff/zxun6KP/30E5MnT6aysrJV2YLPPvuMVatWcc8993DmzBl+/fXXFh9D0HHIoi/9wWHYmOpZ9NXU4hVxVIi+egjRJ2gxLR0Bl5+fz7Jly9izZw8XLlzA2dmZ8PBw3nrrLR2B0VgU7JtvvmHatGntdi2dBa1WS1JSEt999x07duwgIyODsWPHEhYWxh133EFFRQXZ2dlUV1frzLltjrDJyMjg/PnzBAYGGvSHozy9pLa2lsDAwBZFnyVJUlLAslCWXydHR8c2j2SXl5cTExODu7s7vXv35rnnnuPQoUNER0c3u1GivZAbOWJiYggKCgJgz549jB8/vslGjuLiYkJDQzE3N+fnn39W/D2b4p133uHDDz8kPz+/VWstKirC3d2d2tpavvzySx5++OFWHUfQMQjRZ3gI0SdoMS0dAZeUlMSyZcuYNWuWjt2Dr6+vjt2DSqVq1O6htdMZblYkSeLkyZNERESwY8cOTp8+zZgxYwgLC2P06NGK0XFlZaWOAKwvbCRJIj09nYsXLxIUFISNjU0HXdH1uRHBVx9JkigpKVEEYEVFBY6OjsrrdKOj8CoqKoiJicHFxYW+ffvy4osvsm/fPqKjo+nZs+cNHbutmDBhAtnZ2UpN8BNPPEFwcLDyN1y/Jri4uJhx48ZRXl7Ozp07sba2Vo7l7OyMsbExP/zwA9nZ2dx2221YWFiwd+9eXn75ZV5++WXeeOONVq91xowZ/PTTTw3sWwSGjxB9hocQfYIW0RnsHm4lJEkiJSVFEYCnTp3irrvuIiwsjLvvvpvq6uoGwka+SZ89e5bLly8TFBSk9w7SltCWgq8xSktLlRRwWVkZDg4OyuvUUrPkyspKYmJicHJyol+/fixevJjdu3cTHR2Nl5dXm677RmhpTXB0dPQ1bVIyMjLo3bs3UVFRLF68mLS0NCRJom/fvsydO5c5c+bcUC3lmDFjGDRoEKtXr271MQQdgyz6zt43tENEX58dx4Toq4cQfYIW0doRcPX573//y+LFi1Gr1co2lUqFu7s7VVVVeHl58cwzz/DEE0+Ibr1mIkkSZ86cUWoAT5w4wR133EF4eDh33303Go2GnJwcSktLOXHiBH5+fgQHBxt8DV97Cr76lJeXKwKwpKQEe3t7pRHkelGmqqoqYmJisLe3Z8CAAbz++ut88803REdH079//3Zd981IQUEB0dHRPPDAA5w6dYoBAwZ09JIELUSIPsNDtGQKWkRnsXu4FVGpVPTv359XX32VxYsXk56eTkREhDLdYNSoUUyZMoU//viD33//nXXr1nHs2DEcHR0VYXOjqc22RKvVKoLvek0bbYWVlRWenp54enpSUVFBTk4OWVlZpKam0rVrV+V1qj8PuLq6mtjYWLp27Yq3tzcrVqxQRh4Kwdc6AgICKCgo4L333hOCr5MjaSUkrX7jS/o+X2dBiD4B0P4j4GSKi4uZNGkSAwcO5PXXX9f53ZIlS5T/DwgIoKysjJUrVwrR1wpUKhV9+vRh0aJFLFy4kHPnzhEREaH4LwYGBnLhwgXGjRuHSqXi0qVLJCcn4+DgoAgbfc2BbYz6gq8jxKilpSW9evWiV69eVFVVKTWAZ86cwcbGRpmaYmJiQmxsLF26dGHgwIH85z//Yd26dezbt0+Ymt8A586d6+glCAQ3HUL0CQB46aWXmDVrVpP7eHl54ebmpjOxA66md/Pz83Fzc2vy+SUlJYwfPx4bGxt27tx53Rt5SEgIb731FlVVVaKA+wZQqVT06tWLjIwMLCws+PPPPzly5Ag7duxg4cKFhISEEB4eTmhoKMbGxsrMXXt7e1xdXfUuAGXBV11dTWBgoEFEH83NzfHw8MDDw4Pq6mqdecAJCQmkp6fzxBNPsHbtWv7zn/+wZ88e/Pz8OnrZAoFBoNVKaPUcedP3+ToLQvQJgKsdeM7Oztfdr+4IONnuoTkj4OraPezevbtZHbkJCQnY29sLwdcGzJ8/n71793Lw4EF69uzJyJEjeeGFF7h8+TLbt29nx44dLF68mODgYMLDwxk/fjxmZmZkZmaSkpKCnZ2dIgDb89/DEAVffczMzOjevTuurq7ExsZiY2NDeno6Y8aMQZIkHn/8cYyNjZEkSdSjCgQCg0LM3hW0iLoj4I4ePcpff/3V6Ag4b29vjh49CqDYPZSVlfHFF19QXFxMVlYWWVlZaDQaAH744Qf++9//kpSURFpaGp999hnLly9n/vz5HXatNxP33nuvIvhkVCoVPXr04Pnnnyc6Oprz588zffp0oqKiCA4OZubMmRw6dAgPDw+cnZ3Jysrijz/+4NixY1y4cIHKyso2XWNnEHwytbW1xMfHY2pqyj/+8Q8eeeQRLC0tWbJkCRUVFdx+++307duXf/3rX5SUlHT0cgUCgQAQ3buCVtCZ7B4ELUeSJLKzs9m5cyfbt2/n4MGD+Pr6MnXqVCZMmIC1tTU5OTkUFhZia2urRADrNze0hM4k+DQaDfHx8QD4+/sTERHBggUL2LVrF2PGjAGuevXt2bOHqKgo1qxZ0+7TPwQCQ0Tu3k2dFISNqX7/BkpqNAz4KVZ079ZDiD6BQbN27VpWrlxJVlYWfn5+fPLJJwwbNuya+0dERLBkyRLOnTtHv379eO+995g4caLye0mSWLZsGZ9//jmFhYWMHDmSzz77jH79+unjcjodkiSRm5urCMADBw4wcOBApk6dyqRJk7CxsSEnJ4eCggJsbW2V5oaWCECtVktiYiKVlZUEBQUZvOA7fvw4Go2GwMBAdu3axdy5c4mIiGDChAkdvTyBwKAQos/wECEUgcHy7bff8uKLL7Js2TLi4uLw8/MjNDS0QSOJzKFDh3jkkUeYPXs28fHxhIeHEx4eTlJSkrLP+++/z+rVq1m3bh1HjhzB2tqa0NDQNk9V3iyoVCqcnZ156qmniIqKIjMzk/nz53PkyBFGjhzJgw8+yN69e3F1dcXd3Z38/Hz++usv/v77bzIyMigvL2/y+J1J8MlrlTuKf/nlF5555hm++uorvQq+/Px8pk+fjq2tLXZ2dsyePZvS0tImnzN69GhUKpXO45lnntHZ58KFC0yaNAkrKytcXFz417/+RW1tbXteiuAWQbZs0fdD0BAR6RMYLCEhIQwdOpQ1a9YAV2+6Hh4ezJ8/n0WLFjXY/+GHH6asrIwff/xR2Xbbbbfh7+/PunXrkCQJd3d3XnrpJV5++WXg6mxPV1dXNm/eLGb8tgBJkigsLOT7779n+/bt7N27lz59+hAeHs7kyZNxcnIiJyeHvLw8unTpokQA647v6myC78SJE1RUVBAUFMT+/ft57LHH2LRpEw899JBe19LSMYhwVfT179+fN998U9lmZWWlREA0Gg3+/v64ubmxcuVKMjMzmTFjBnPmzGH58uXtfk2CmxM50pcyIbBDIn3ev8SJSF89RKRPYJDIZrdjx45VthkZGTF27FgOHz7c6HMOHz6ssz9AaGiosn9GRgZZWVk6+3Tt2pWQkJBrHlPQOCqVCnt7e2bNmsUPP/xAVlYWixYt4uTJk9x9993ce++9/PDDDzg6OuLh4UFxcTF///03hw8f5uzZsxQXF3PixIlOIfgkSSIpKYny8nICAwP5888/efzxx1m/fj0PPvigXteSnJxMVFQU//3vfwkJCWHUqFF88sknbNu2jStXrjT5XCsrK9zc3JRH3Rvhnj17OHXqFF999RX+/v5MmDCBt956i7Vr11JdXd3elyUQCPSEEH0CgyQ3NxeNRoOrq6vOdldX12tO/sjKympyf/m/LTmmoHnY2dnx+OOPs2vXLrKzs1m6dClnzpxh3LhxTJo0iZ07d2JnZ0evXr0oKCjg0Ucf5e+//8bBwYHKykoMNeEgSRInT56ktLSUoKAgjh49yrRp01i9ejXTp0/XuyXL4cOHsbOzU+ZeA4wdOxYjIyOOHDnS5HO//vprnJycGDx4MIsXL9ZJvR8+fJghQ4bo/G2EhoZSXFzMyZMn2/5CBLcUIr1rOAifPoFA0KbY2try6KOP8uijj1JSUsLPP//M9u3bmTBhAi4uLmg0GrRaLSNGjKCiooKjR49iYWGBq6srrq6udOnSxSD87SRJIjk5maKiIoKDg4mPj+fBBx9kxYoVHTYTurVjEB999FF69eqFu7s7iYmJLFy4kNTUVHbs2KEct7EvQ/LvBALBzYEQfQKDxMnJCWNjY7Kzs3W2Z2dnX3Pyh5ubW5P7y//Nzs6mW7duOvv4+/u34eoFMjY2Njz88MM8/PDDFBYWMn78eFJTU6mpqWHatGlMmTKFsLAwevXqhVqt5tixY5iZmSkC0MbGpkPElSRJpKamkp+fT3BwMCdPnuS+++7j9ddf59lnn23zNbX3GMS6c66HDBlCt27dGDNmDGfPnqVPnz6tPq5A0BwkjYRkpOfZuxoR6WsMkd4VGCRmZmYEBQWxb98+ZZtWq2Xfvn0MHz680ecMHz5cZ3+AvXv3Kvt7enri5uams09xcTFHjhy55jEFbUNNTQ1z5syhqqqKtLQ0cnJy+Oijj8jNzWXq1KncddddfP3115ibm9OnTx8qKyuJiYnhzz//5PTp0xQVFektBSxJEqdPn0atVhMUFMSZM2cICwtj4cKFLFiwoF1E6EsvvURycnKTjxsdg1gXeXpOWloacO0vTPLvBALBzYGI9AkMlhdffJGZM2cSHBzMsGHDWLVqFWVlZTzxxBMAzJgxg+7du/Puu+8C8Pzzz3PnnXfy4YcfMmnSJLZt20ZMTAwbNmwArjYfLFiwgLfffpt+/frh6enJkiVLcHd3Jzw8vKMu85Zg/fr1nDlzhn379uHo6AjA1KlTmTp1KhUVFezdu5fIyEgeeughrK2tmTJlClOmTKFfv37k5uYSFxeHiYmJ0gXctWvXdhFfkiSRlpZGdnY2wcHBZGRkMHnyZJ577jkWLlzYblHH9h6DWJ+EhAQAJeI9fPhw3nnnHXJycpT08d69e7G1tWXgwIEtvBqBQBdJ0iJp9RuxlyStXs/XWRCWLQKDZs2aNYo5s7+/P6tXr1ZubqNHj6Z3795s3rxZ2T8iIoLXXntNMWd+//33GzVn3rBhA4WFhYwaNYpPP/2U/v376/vSbilqa2spLS3Fzs6uyf0qKyvZt28fkZGRfP/995ibmyspYG9vb/Ly8sjJycHY2FgRgHZ2dm0mxs6ePculS5cIDg7mypUrjB8/nlmzZrF8+XKDqDOEq5Yt2dnZrFu3TrFsCQ4OVixbLl++zJgxY/jyyy8ZNmwYZ8+eZevWrUycOBFHR0cSExN54YUX6NGjBwcPHgT+z7LF3d2d999/n6ysLB5//HH+8Y9/CMsWQauRLVtOjvHFxkTPli21GgbtSxSWLfUQok8gEBgk1dXV7N+/n8jISHbt2oWxsTH33nsvYWFhDBo0iPz8fHJyclCpVMooOHt7+1aLs4yMDM6fP09wcDBqtZrx48fzwAMP8OGHHxrUKMCWjkG8ePEijz32GElJSZSVleHh4cHUqVN57bXXdG6G58+fZ+7cuURHR2Ntbc3MmTNZsWIFJiYiISRoHUL0GR5C9AkETdCSMXCff/45X375pTIBJCgoiOXLl+vsP2vWLLZs2aLzvNDQUKKiotrvIm4CampqiI6OVgSgVqtl8uTJhIWF4efnpwhAuJoqdXV1xd7evtli7fz586SnpxMcHExBQQHjx49n4sSJrFmzxqAEn0DQmZBFX9LoIR0i+gZHnxCirx7i00wguAYtHQMXHR3NI488woEDBzh8+DAeHh6MGzeOy5cv6+w3fvx4MjMzlcc333yjj8vp1JiamnLPPfewfv16Ll++zLfffouFhQVz584lODiY1atXU1FRwYABAzAyMiIpKYnff/+dU6dOkZubi1Z77fqeixcvkp6eTmBgIKWlpUyePJmxY8cKwScQCG46RKRPILgGLR0DVx+NRoO9vT1r1qxhxowZwNVIX2FhIbt27WrPpd8yaDQa/vjjDyIjI9m5cyfl5eVMmjSJ8PBwgoKCKCgoICcnB41Gg4uLCy4uLjg6Oipi7vLly6SmphIYGEhVVRUTJkxg6NChbN68GWNj/UYmBIKbDTnSd+KOwR0S6Rvye5KI9NVDfI0VCBqhNWPg6lNeXk5NTQ0ODg4626Ojo3FxcWHAgAHMnTuXvLy8Nl37rYSxsTGjR49mzZo1XLhwgd27d+Po6MiLL75IQEAAK1eupKioCG9vb0xMTEhJSeHgwYMkJSVx6NAhEhMTCQgIQKPRMGXKFHx9fdmOAHqRAAASMUlEQVS0aZMQfAKB4KZEVOgKBI3Q1Bi4lJSUZh1j4cKFuLu76wjH8ePHc9999+Hp6cnZs2d59dVXmTBhAocPHxZC4wYxNjbm9ttv5/bbb+c///kPf//9N5GRkSxcuJD8/HzGjx9PeHg4ISEhfP3113z44YfU1NQwYsQI0tLSGDx4MF999ZVoXBAIBDct4tNNIGgHVqxYwbZt24iOjsbCwkLZPm3aNOX/hwwZgq+vL3369CE6OpoxY8Z0xFJvSoyMjBgxYgQjRozggw8+4NixY0RGRrJkyRIuX75MTU0NTz/9NLfffjvPP/88paWlREdHM2PGDB544AEmTpyIlZVVR1+GQHBToNVKaPU8C1ff5+ssiPSuQNAIrRkDJ/PBBx+wYsUK9uzZg6+vb5P7enl54eTkpExGELQ9RkZGhISEsHLlSlatWoVKpSIsLIzffvuNxx57jG7dupGbm8uff/5J3759+fe//42zszNXrlzp6KULBAJBmyJEn0DQCK0ZAwfw/vvv89ZbbxEVFUVwcPB1z3Pp0iXy8vJ0ZgEL2oc9e/bwyCOP8L///Y8dO3aQkpLCV199xa5du7CyssLf35+3336blJQUYmNjcXd37+glCwQ3BZJG6pCHoCFC9AkE1+DFF1/k888/Z8uWLSQnJzN37twGY+AWL16s7P/ee++xZMkSNm7cSO/evcnKyiIrK4vS0lIASktL+de//sXff//NuXPn2LdvH2FhYfTt25fQ0NAOucZbiU8//ZQNGzbwwAMPAFcjgI888gienp46+6lUKry9vdtlDfn5+UyfPh1bW1vs7OyYPXu28v5ojHPnzqFSqRp9RERE6Ky5/mPbtm3tcg0CgaDzImr6BIJr8PDDD6NWq1m6dKkyBi4qKkpp7rhw4YKOj9tnn31GdXW1Iipkli1bxuuvv46xsTGJiYls2bKFwsJC3N3dGTduHG+99Rbm5uZ6vbZbkZ07d3b4KLXp06eTmZnJ3r17lRFqTz31lDJCrT4eHh5kZmbqbNuwYQMrV65kwoQJOts3bdrE+PHjlZ+vN/JOINAXklZC0nONnb7P11kQPn0CgYHSkmkgmzdvViKQMubm5lRWVio/y3OHP//8cwoLCxk5ciSfffYZ/fr1a9frEFwlOTmZgQMHcuzYMSX1HxUVxcSJE7l06VKz08kBAQEEBgbyxRdfKNtUKhU7d+4kPDy8PZYuELQK2acvPsSnQ3z6Ao4kC5++eoj0rkBggLR0GgiAra2tzqSP8+fP6/z+/fffZ/Xq1axbt44jR45gbW1NaGiojjAUtB+HDx/Gzs5Op9Zz7NixGBkZceTIkWYdIzY2loSEBGbPnt3gd//85z9xcnJi2LBhbNy4EfF9XiAQ1EekdwUCA+Sjjz5izpw5SvRu3bp1/PTTT2zcuPGa00BUKtU1O4slSWLVqlW89tprhIWFAfDll1/i6urKrl27dKxkBO1DVlYWLi4uOttMTExwcHAgKyurWcf44osv8PHxYcSIETrb33zzTe6++26srKzYs2cPzz77LKWlpTz33HNttn6BoLVIGglJpef0rmjkaBQR6RMYJGq1Gjc3N5YvX65sO3ToEGZmZjodtTcjrZ0GUlpaSq9evfDw8CAsLIyTJ08qv8vIyCArK0vnmF27diUkJKTZE0YEjbNo0aJrNlvIj+YaejdFRUUFW7dubTTKt2TJEkaOHElAQAALFy7klVdeYeXKlTd8ToFAcHMhIn0Cg8TZ2ZmNGzcSHh7OuHHjGDBgAI8//jjz5s276U2MWzMNZMCAAWzcuBFfX1+Kior44IMPGDFiBCdPnqRHjx5KJKmxYzY3yiRonJdeeolZs2Y1uY+Xlxdubm4N0vO1tbXk5+df1/sRIDIykvLycmWOc1OEhITw1ltvUVVVJZqEBB2PpP9GDkR5Q6MI0ScwWCZOnMicOXOYPn06wcHBWFtb8+6773b0sgyS4cOH6/gHjhgxAh8fH9avX89bb73VgSu7+XF2dsbZ2fm6+w0fPpzCwkJiY2MJCgoCYP/+/Wi1WkJCQq77/C+++IIpU6Y061wJCQnY29sLwScQCHQQ6V2BQfPBBx9QW1tLREQEX3/99S1xE7uRaSAypqamBAQEKJM+5OfdyDEFN4aPjw/jx49nzpw5HD16lL/++ot58+Yxbdo0pXP38uXLeHt7c/ToUZ3npqWl8fvvv/OPf/yjwXF/+OEH/vvf/5KUlERaWhqfffYZy5cvZ/78+Xq5LoFA0HkQok9g0Jw9e5YrV66g1Wo5d+5cRy9HL7R2GkhdNBoNJ06cUCZ9eHp64ubmpnPM4uJijhw50uxjCm6cr7/+Gm9vb8aMGcPEiRMZNWoUGzZsUH5fU1NDamoq5eXlOs/buHEjPXr0YNy4cQ2OaWpqytq1axk+fDj+/v6sX7+ejz76iGXLlrX79QgEzUH26dP3Q9AQ4dMnMFiqq6sZNmwY/v7+DBgwgFWrVnHixIkGHZA3I99++y0zZ85k/fr1DBs2jFWrVvHdd9+RkpKCq6srM2bMoHv37kq6+8033+S2226jb9++FBYWsnLlSnbt2kVsbCwDBw4Erk4MWbFiBVu2bMHT05MlS5aQmJjIqVOnsLCw6MjLFQgENyGyT19sQH+6GOvXp69UoyEo/rTw6auHqOkTGCz//ve/KSoqYvXq1XTp0oWff/6ZJ598kh9//LGjl9butHQaSEFBAXPmzCErKwt7e3uCgoI4dOiQIvgAXnnlFcrKynjqqacoLCxk1KhRREVFCcEnEAjaFUkjISEsWwwBEekTGCTR0dHcc889HDhwgFGjRgFX55D6+fmxYsUK5s6d28ErFAgEAkFTyJG+GN9+HRLpC048IyJ99RA1fQKDZPTo0dTU1CiCD6B3794UFRUJwadH1q5dS+/evbGwsCAkJKRBg0FdRo8e3ahH3aRJk5R9Zs2a1eD3defFCgSCmw+tVuqQh6AhIr0rEAgaRR4Ft27dOkJCQli1ahWhoaGkpqY2Wle5Y8cOqqurlZ/z8vLw8/PjwQcf1Nlv/PjxbNq0Sfn5VujIFggEAkNARPoEAkGj1B0FN3DgQNatW4eVlRUbN25sdH8HBwfc3NyUx969e7Gysmog+szNzXX2s7e318flCAQCwS2PEH0CgaABrR0FV5cvvviCadOmYW1trbM9OjoaFxcXBgwYwNy5c8nLy2vTtQsEAsNCq+2Yh6AhQvQJBIIGNDUKrjlj244ePUpSUlIDM+Hx48fz5Zdfsm/fPt577z0OHjzIhAkT0Gg0bbp+gUAgEDRE1PQJBII254svvmDIkCEMGzZMZ/u0adOU/x8yZAi+vr706dOH6Ojom36mskBwq6LVglal/3MKGiIifQKBoAE3MgqurKyMbdu2MXv27Ouex8vLCycnJ2VcnKHyzjvvMGLECKysrLCzs2vWcyRJYunSpXTr1g1LS0vGjh3LmTNndPbJz89n+vTp2NraYmdnx+zZsyktLW2HKxAIBAIh+gQCQSPcyCi4iIgIqqqqeOyxx657nkuXLpGXl6eMizNUqqurefDBB1tkF/T++++zevVq1q1bx5EjR7C2tiY0NJTKykpln+nTp3Py5En27t3Ljz/+yO+//85TTz3VHpcgEAgEwpxZIBA0TktHwcncfvvtdO/enW3btulsLy0t5Y033uD+++/Hzc2Ns2fP8sorr1BSUsKJEyc6hXXL5s2bWbBgAYWFhU3uJ0kS7u7uvPTSS7z88ssAFBUV4erqyubNm5k2bRrJyckMHDiQY8eOERwcDEBUVBQTJ07k0qVLuLu7t/flCATtimzO/Gf/vh1izjzqdJowZ66HiPQJBIJGefjhh/nggw9YunQp/v7+JCQkNBgFl5mZqfOc1NRU/vzzz0ZTu8bGxiQmJjJlyhT69+/P7NmzCQoK4o8//ugUgq8lZGRkkJWVpdP93LVrV0JCQpTu58OHD2NnZ6cIPoCxY8diZGTEkSNH9L5mgUBw8yMaOQQCwTWZN28e8+bNa/R30dHRDbYNGDCAayUPLC0t+fXXX9tyeQaL3OHcVPdzVlZWA5NrExMTHBwcmtUhLRB0FrTS1Ye+zyloiIj0CQQCg+T333/n3nvvxd3dHZVKxa5du677nOjoaAIDAzE3N6dv375s3ry5wT7yaDkTE5NGx8bVfaSkpLT9hQkEAkEHIUSfQCAwSMrKyvDz82Pt2rXN2j8jI4NJkyZx1113kZCQwIIFC/jHP/6hE12UR8stW7aM6OhoHnzwQWxsbPjzzz9JTk5u8PDy8mrV2uUO56a6n93c3MjJydH5fW1tLfn5+dftkBYIOhPCnNlwEOldgUBgkEyYMIEJEyY0e/9169bh6enJhx9+CICPjw9//vkn//nPfwgNDQV0R8sBjBgxAg8PD/744w8WLVrUZmv39PTEzc2Nffv24e/vD1wtaj9y5IjSATx8+HAKCwuJjY0lKCgIgP3796PVagkJCWmztQgEAoGMiPQJBIKbgsOHD+s0TgCEhoYqjRM3MlruwoULJCQkcOHCBTQaDQkJCSQkJOh46nl7e7Nz504AVCoVCxYs4O2332b37t2cOHGCGTNm4O7uTnh4OHBVlI4fP545c+Zw9OhR/vrrL+bNm8e0adNE565AIGgXRKRPIBDcFGRlZTXaOFFcXExFRQUFBQXXHC13vdq9pUuXsmXLFuXngIAAAA4cOMDo0aOBq53LRUVFyj6vvPIKZWVlPPXUUxQWFjJq1CiioqKwsLBQ9vn666+ZN28eY8aMwcjIiPvvv5/Vq1e36voFAkNFK+k/3SoaORpHiD6BQCC4Dps3b260KaQu9buWVSoVb775Jm+++eY1n+Pg4MDWrVvbYokCgUBwXYToEwgENwVubm6NNk7Y2tpiaWmJsbFxq0fLCQSC1iNpQd99FZJo5GgUUdMnEAhuCoYPH64zNg5g7969yti4GxktJxAIBDcDQvQJBAKDpLS0VGmYgKuWLHIzBcDixYuZMWOGsv8zzzxDeno6r7zyCikpKXz66ad89913vPDCC8o+L774Ip9//jlbtmwhOTmZuXPnUlZWpnTzCgQCwc2MSO8KBAKDJCYmhrvuukv5+cUXXwRg5syZbN68mczMTEUAwlWblJ9++okXXniBjz/+mB49evDf//5XsWuBq6Pl1Go1S5cuJSsrC39/f53RcgKBoO3RdkB6V/j0NY5KutbMJIFAIBAIBIJWUlxcTNeuXdnbsy/WRsZ6PXeZVsM9F9IoKirC1tZWr+c2ZESkTyAQCAQCQbshIn2Gg6jpEwgEAoFAILgFEKJPIBAIBAKB4BZApHcFAoFAIBC0GyK9aziISJ9AIBAIBALBLYCI9AkEAoFAIGg3RKTPcBCRPoFAIBAIBIJbABHpEwgEAoFA0G6ISJ/hICJ9AoFAIBAIBLcAQvQJBAKBQCAQ3AKI9K5AIBAIBIJ2Q5Ik9D3xVUyYbRwR6RMIBAKBQCC4BRCRPoFAIBAIBO2GaOQwHESkTyAQCAQCgeAWQIg+gUAgEAgEglsAkd4VCAQCgUDQboj0ruEgIn0CgUAgEAgEtwAi0icQCAQCgaDd0Er6j7xphWNLo4hIn0AgEAgEAsEtgIj0CQQCgUAgaDckLWhVej6niPQ1ioj0CQQCgUAgENwCCNEnEAgEAoFAcAsg0rsCgUAgEAjaDW0HpHdFI0fjiEifQCAQCAQCwS2AiPQJBAKBQCBoN0Skz3AQkT6BQCAQCASCWwAh+gQCgUAgEAhuAUR6VyAQCAQCQbsh0ruGg4j0CQQCgUAgENwCiEifQCAQCASCdkMrgZ5H74pI3zUQkT6BQCAQCASCWwAR6RMIBAKBQNBuiJo+w0FE+gQCgUAgEAhuAYToEwgEAoFAILgFEOldgUAgEAgE7YZI7xoOItInEAgEAoFAcAsgIn0CgUAgEAjaDRHpMxxEpE8gEAgEAoHgFkCIPoFAIBAIBIJbAJHeFQgEAoFA0G5oJf2nW/U9AaSzIESfQCAQCASCdqOiAyRYR5yzMyBEn0AgEAgEgjbHzMwMNzc3nsvK6JDzu7m5YWZm1iHnNlRUkiSJHheBQCAQCARtTmVlJdXV1R1ybjMzMywsLDrk3IaKEH0CgUAgEAgEtwCie1cgEAgEAoHgFkCIPoFAIBAIBIJbACH6BAKBQCAQCG4BhOgTCAQCgUAguAUQok8gEAgEAoHgFkCIPoFAIBAIBIJbACH6BAKBQCAQCG4B/h+WUS0KpLo5JgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import math\n", + "\n", + "# Visualize quality score\n", + "mesh.cell_data[\"quality\"] = metrics[\"quality_score\"]\n", + "\n", + "print(\n", + " f\"Quality score range: [{metrics['quality_score'].min():.3f}, {metrics['quality_score'].max():.3f}]\"\n", + ")\n", + "print(f\"Ideal equilateral triangle: 1.0\")\n", + "\n", + "mesh.draw(cell_scalars=\"quality\", cmap=\"RdYlGn\", show_edges=True, backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cells with quality < 0.5: 0 / 320 (0.0%)\n" + ] + } + ], + "source": [ + "# Identify poor quality cells\n", + "quality_threshold = 0.5\n", + "poor_quality_mask = metrics[\"quality_score\"] < quality_threshold\n", + "n_poor = poor_quality_mask.sum().item()\n", + "\n", + "print(\n", + " f\"Cells with quality < {quality_threshold}: {n_poor} / {mesh.n_cells} ({100 * n_poor / mesh.n_cells:.1f}%)\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparing Mesh Quality\n", + "\n", + "Let's compare quality between different mesh types." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regular sphere mean quality: 0.7238\n", + "Lumpy sphere mean quality: 0.6667\n" + ] + } + ], + "source": [ + "# Regular mesh (high quality)\n", + "regular = sphere_icosahedral.load(subdivisions=3)\n", + "regular_quality = regular.quality_metrics[\"quality_score\"].mean()\n", + "\n", + "# Perturbed mesh (lower quality)\n", + "lumpy = lumpy_sphere.load(noise_amplitude=0.3, subdivisions=3, seed=42)\n", + "lumpy_quality = lumpy.quality_metrics[\"quality_score\"].mean()\n", + "\n", + "print(f\"Regular sphere mean quality: {regular_quality:.4f}\")\n", + "print(f\"Lumpy sphere mean quality: {lumpy_quality:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regular sphere (high quality):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Visualize quality on both meshes\n", + "regular.cell_data[\"quality\"] = regular.quality_metrics[\"quality_score\"]\n", + "lumpy.cell_data[\"quality\"] = lumpy.quality_metrics[\"quality_score\"]\n", + "\n", + "print(\"Regular sphere (high quality):\")\n", + "regular.draw(\n", + " cell_scalars=\"quality\",\n", + " cmap=\"RdYlGn\",\n", + " vmin=0.5,\n", + " vmax=0.8,\n", + " show_edges=True,\n", + " backend=\"matplotlib\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lumpy sphere (lower quality - note red/yellow cells where geometry is distorted):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\n", + " \"Lumpy sphere (lower quality - note red/yellow cells where geometry is distorted):\"\n", + ")\n", + "lumpy.draw(\n", + " cell_scalars=\"quality\",\n", + " cmap=\"RdYlGn\",\n", + " vmin=0.5,\n", + " vmax=0.8,\n", + " show_edges=True,\n", + " backend=\"matplotlib\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 2: Mesh Statistics\n", + "\n", + "Get a comprehensive summary of mesh properties." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh Statistics:\n", + "========================================\n", + " n_points: 1594\n", + " n_cells: 3184\n", + " n_manifold_dims: 2\n", + " n_spatial_dims: 3\n", + " n_degenerate_cells: 0\n", + " n_isolated_vertices: 0\n" + ] + } + ], + "source": [ + "mesh = torch.load(\"assets/bunny.pt\", weights_only=False).subdivide(1, \"loop\")\n", + "\n", + "stats = mesh.statistics\n", + "\n", + "print(\"Mesh Statistics:\")\n", + "print(\"=\" * 40)\n", + "for key, value in stats.items():\n", + " if isinstance(value, (int, float)):\n", + " if isinstance(value, float):\n", + " print(f\" {key}: {value:.4f}\")\n", + " else:\n", + " print(f\" {key}: {value}\")\n", + " elif isinstance(value, dict):\n", + " print(f\" {key}:\")\n", + " for k, v in value.items():\n", + " if isinstance(v, float):\n", + " print(f\" {k}: {v:.4f}\")\n", + " else:\n", + " print(f\" {k}: {v}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 3: Mesh Validation\n", + "\n", + "The `validate()` method checks for common mesh errors." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation Report (good mesh):\n", + " Valid: True\n" + ] + } + ], + "source": [ + "# Validate a good mesh\n", + "mesh = sphere_icosahedral.load(subdivisions=2)\n", + "report = mesh.validate()\n", + "\n", + "print(\"Validation Report (good mesh):\")\n", + "print(f\" Valid: {report['valid']}\")\n", + "if report.get(\"errors\"):\n", + " print(f\" Errors: {report['errors']}\")\n", + "if report.get(\"warnings\"):\n", + " print(f\" Warnings: {report['warnings']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation Report (bad mesh):\n", + " Valid: False\n", + " n_out_of_bounds_cells: 0\n", + " n_duplicate_vertices: 1\n", + " duplicate_vertex_pairs: tensor([[0, 4]])\n", + " n_degenerate_cells: 1\n", + " degenerate_cell_indices: tensor([1])\n", + " degenerate_cell_areas: tensor([0.])\n" + ] + } + ], + "source": [ + "# Create a mesh with some problems\n", + "points = torch.tensor(\n", + " [\n", + " [0.0, 0.0],\n", + " [1.0, 0.0],\n", + " [0.5, 1.0],\n", + " [0.5, 0.5], # Interior point (will be unused)\n", + " [0.0, 0.0], # Duplicate of point 0\n", + " ]\n", + ")\n", + "\n", + "cells = torch.tensor(\n", + " [\n", + " [0, 1, 2], # Valid triangle\n", + " [0, 0, 1], # Degenerate (repeated vertex)\n", + " ]\n", + ")\n", + "\n", + "bad_mesh = Mesh(points=points, cells=cells)\n", + "\n", + "# Validate\n", + "report = bad_mesh.validate(\n", + " check_degenerate_cells=True,\n", + " check_duplicate_vertices=True,\n", + ")\n", + "\n", + "print(\"Validation Report (bad mesh):\")\n", + "print(f\" Valid: {report['valid']}\")\n", + "for key, value in report.items():\n", + " if key != \"valid\":\n", + " print(f\" {key}: {value}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 4: Repair Operations\n", + "\n", + "PhysicsNeMo-Mesh provides several repair operations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### All-in-One: mesh.clean()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Before cleaning: 5 points, 2 cells\n", + "After cleaning: 3 points, 1 cells\n" + ] + } + ], + "source": [ + "# Create a mesh with duplicate points\n", + "points = torch.tensor(\n", + " [\n", + " [0.0, 0.0],\n", + " [1.0, 0.0],\n", + " [0.5, 1.0],\n", + " [0.0, 0.0], # Duplicate of point 0\n", + " [1.0, 0.0], # Duplicate of point 1\n", + " ]\n", + ")\n", + "\n", + "cells = torch.tensor(\n", + " [\n", + " [0, 1, 2], # Triangle using original points\n", + " [3, 4, 2], # Triangle using duplicate points\n", + " ]\n", + ")\n", + "\n", + "mesh_with_duplicates = Mesh(points=points, cells=cells)\n", + "print(\n", + " f\"Before cleaning: {mesh_with_duplicates.n_points} points, {mesh_with_duplicates.n_cells} cells\"\n", + ")\n", + "\n", + "# Clean the mesh\n", + "cleaned = mesh_with_duplicates.clean()\n", + "print(f\"After cleaning: {cleaned.n_points} points, {cleaned.n_cells} cells\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The examples above use small 2D meshes to illustrate the API. See the **Practical Workflow**\n", + "section below for a visual before/after demonstration of repair on a 3D mesh." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Detailed Repair Pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original: 5 points, 2 cells\n", + "\n", + "Repaired: 3 points, 1 cells\n", + "\n", + "Repair statistics:\n", + " degenerates: {'n_zero_area_cells': 1, 'n_duplicate_vertex_cells': 1, 'n_cells_original': 2, 'n_cells_final': 1}\n", + " merge_points: {'n_points_original': 5, 'n_points_final': 4, 'n_duplicates_merged': 1}\n", + " clean: {'n_points_before_merge': 5, 'n_points_after_merge': 4}\n", + " isolated: {'n_isolated_removed': 1, 'n_points_original': 4, 'n_points_final': 3}\n" + ] + } + ], + "source": [ + "from physicsnemo.mesh.repair import repair_mesh\n", + "\n", + "# Create a mesh with multiple issues\n", + "points = torch.tensor(\n", + " [\n", + " [0.0, 0.0],\n", + " [1.0, 0.0],\n", + " [0.5, 1.0],\n", + " [2.0, 2.0], # Isolated point\n", + " [0.0, 0.0], # Duplicate\n", + " ]\n", + ")\n", + "\n", + "cells = torch.tensor(\n", + " [\n", + " [0, 1, 2], # Valid\n", + " [0, 0, 1], # Degenerate\n", + " ]\n", + ")\n", + "\n", + "mesh = Mesh(points=points, cells=cells)\n", + "print(f\"Original: {mesh.n_points} points, {mesh.n_cells} cells\")\n", + "\n", + "# Repair with detailed stats\n", + "repaired, stats = repair_mesh(\n", + " mesh,\n", + ")\n", + "\n", + "print(f\"\\nRepaired: {repaired.n_points} points, {repaired.n_cells} cells\")\n", + "print(f\"\\nRepair statistics:\")\n", + "for operation, operation_stats in stats.items():\n", + " print(f\" {operation}: {operation_stats}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 5: Topology Checks\n", + "\n", + "Check if meshes are watertight (closed) or manifold." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sphere:\n", + " Watertight: True\n", + " Manifold: True\n" + ] + } + ], + "source": [ + "# Closed sphere\n", + "sphere = sphere_icosahedral.load(subdivisions=2)\n", + "print(f\"Sphere:\")\n", + "print(f\" Watertight: {sphere.is_watertight()}\")\n", + "print(f\" Manifold: {sphere.is_manifold()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Closed sphere (watertight, no boundary):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Closed sphere (watertight, no boundary):\")\n", + "sphere.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hemisphere:\n", + " Watertight: False\n", + " Manifold: True\n" + ] + } + ], + "source": [ + "# Hemisphere (open)\n", + "hemisphere = sphere.slice_cells(sphere.cell_centroids[:, 2] > 0)\n", + "print(f\"Hemisphere:\")\n", + "print(f\" Watertight: {hemisphere.is_watertight()}\")\n", + "print(f\" Manifold: {hemisphere.is_manifold()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hemisphere (open boundary visible at the equator):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Hemisphere (open boundary visible at the equator):\")\n", + "hemisphere.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bunny:\n", + " Watertight: True\n", + " Manifold: True\n" + ] + } + ], + "source": [ + "# The bunny (should be watertight if cleaned properly)\n", + "bunny = torch.load(\"assets/bunny.pt\", weights_only=False)\n", + "print(f\"Bunny:\")\n", + "print(f\" Watertight: {bunny.is_watertight()}\")\n", + "print(f\" Manifold: {bunny.is_manifold()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 6: Practical Workflow\n", + "\n", + "Here's a complete validate-repair-verify workflow on a mesh with real defects.\n", + "We'll take the bunny mesh, inject some common problems (duplicate vertices and a\n", + "degenerate cell), then walk through detection and repair with before/after visualizations." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Corrupted mesh: 410 points, 797 cells\n", + " (original bunny had 400 points, 796 cells)\n", + "\n", + "Validation: FAIL\n", + " Duplicate vertices: 10\n", + " Degenerate cells: 1\n" + ] + } + ], + "source": [ + "# Step 1: Create a mesh with real defects\n", + "bunny = torch.load(\"assets/bunny.pt\", weights_only=False)\n", + "\n", + "# Inject 10 duplicate vertices and 1 degenerate cell (zero-area triangle)\n", + "bad_points = torch.cat([bunny.points, bunny.points[:10]], dim=0)\n", + "bad_cells = torch.cat([bunny.cells, torch.tensor([[0, 0, 1]])], dim=0)\n", + "bad_mesh = Mesh(points=bad_points, cells=bad_cells)\n", + "\n", + "print(f\"Corrupted mesh: {bad_mesh.n_points} points, {bad_mesh.n_cells} cells\")\n", + "print(f\" (original bunny had {bunny.n_points} points, {bunny.n_cells} cells)\")\n", + "\n", + "# Step 2: Validate - should detect problems\n", + "report = bad_mesh.validate(\n", + " check_degenerate_cells=True,\n", + " check_duplicate_vertices=True,\n", + ")\n", + "print(f\"\\nValidation: {'PASS' if report['valid'] else 'FAIL'}\")\n", + "print(f\" Duplicate vertices: {report.get('n_duplicate_vertices', 0)}\")\n", + "print(f\" Degenerate cells: {report.get('n_degenerate_cells', 0)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Before repair:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Before repair:\")\n", + "bad_mesh.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Repair results:\n", + " Points: 410 -> 400\n", + " Cells: 797 -> 796\n", + "\n", + "Repair statistics:\n", + " degenerates: {'n_zero_area_cells': 1, 'n_duplicate_vertex_cells': 1, 'n_cells_original': 797, 'n_cells_final': 796}\n", + " merge_points: {'n_points_original': 410, 'n_points_final': 400, 'n_duplicates_merged': 10}\n", + " clean: {'n_points_before_merge': 410, 'n_points_after_merge': 400}\n", + " isolated: {'n_isolated_removed': 0, 'n_points_original': 400, 'n_points_final': 400}\n" + ] + } + ], + "source": [ + "# Step 3: Repair\n", + "from physicsnemo.mesh.repair import repair_mesh\n", + "\n", + "repaired, stats = repair_mesh(\n", + " bad_mesh,\n", + " merge_points=True,\n", + " remove_degenerates=True,\n", + " remove_isolated=True,\n", + ")\n", + "\n", + "print(f\"Repair results:\")\n", + "print(f\" Points: {bad_mesh.n_points} -> {repaired.n_points}\")\n", + "print(f\" Cells: {bad_mesh.n_cells} -> {repaired.n_cells}\")\n", + "print(f\"\\nRepair statistics:\")\n", + "for operation, op_stats in stats.items():\n", + " print(f\" {operation}: {op_stats}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation after repair: PASS\n", + "Watertight: True\n", + "Manifold: True\n", + "\n", + "After repair:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Step 4: Verify the repaired mesh\n", + "report_clean = repaired.validate(\n", + " check_degenerate_cells=True,\n", + " check_duplicate_vertices=True,\n", + ")\n", + "print(f\"Validation after repair: {'PASS' if report_clean['valid'] else 'FAIL'}\")\n", + "print(f\"Watertight: {repaired.is_watertight()}\")\n", + "print(f\"Manifold: {repaired.is_manifold()}\")\n", + "\n", + "print(\"\\nAfter repair:\")\n", + "repaired.draw(backend=\"matplotlib\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "In this tutorial, you learned about mesh quality and repair:\n", + "\n", + "1. **Quality Metrics**: `mesh.quality_metrics` for per-cell analysis\n", + "2. **Statistics**: `mesh.statistics` for mesh summary\n", + "3. **Validation**: `mesh.validate()` to detect errors\n", + "4. **Repair**:\n", + " - `mesh.clean()` for all-in-one cleaning\n", + " - `repair_mesh()` for detailed control\n", + "5. **Topology**: `is_watertight()` and `is_manifold()`" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/minimal/mesh/tutorial_6_ml_integration.ipynb b/examples/minimal/mesh/tutorial_6_ml_integration.ipynb new file mode 100644 index 0000000000..1d9d62b192 --- /dev/null +++ b/examples/minimal/mesh/tutorial_6_ml_integration.ipynb @@ -0,0 +1,2106 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mesh Tutorial 6: Integration with ML Workflows\n", + "\n", + "This tutorial covers advanced topics for using PhysicsNeMo-Mesh in ML pipelines:\n", + "\n", + "1. **Performance Benchmarks**: PhysicsNeMo-Mesh (GPU) vs PyVista/VTK (CPU)\n", + "2. **GPU Acceleration Benefits**: When and how much speedup to expect\n", + "3. **Batching Meshes**: Padding for torch.compile compatibility\n", + "4. **Feature Extraction**: Preparing mesh data for ML models\n", + "5. **Boundary Condition Handling**: Storing BC metadata in TensorDict\n", + "6. **End-to-End Workflow**: Complete CAE preprocessing example\n", + "\n", + "---\n", + "\n", + "## Why Replace PyVista/VTK in ML Pipelines?\n", + "\n", + "Traditional mesh libraries like PyVista and VTK are excellent tools for visualization and\n", + "interactive exploration, but they are fundamentally CPU-bound:\n", + "\n", + "- **CPU-GPU transfers**: Data must be copied to GPU for each training step\n", + "- **GIL bottleneck**: Python's Global Interpreter Lock limits parallelism\n", + "- **Per-element APIs**: Many operations (e.g., neighbor queries) only expose single-element functions\n", + "- **No autograd**: Cannot backpropagate through mesh operations\n", + "\n", + "In large physics-AI training pipelines, mesh preprocessing and ETL can easily become the\n", + "bottleneck. When training on millions of mesh samples, even small per-sample overheads compound.\n", + "\n", + "PhysicsNeMo-Mesh addresses these limitations:\n", + "- **GPU-native**: All operations are vectorized PyTorch, running natively on CUDA\n", + "- **Differentiable**: Seamless integration with PyTorch autograd\n", + "- **Batch operations**: Compute neighbors, samples, and features for all elements at once\n", + "- **TensorDict-based**: Efficient batching and device management\n", + "\n", + "By moving mesh operations to GPU, we also enable **post-load feature engineering** that would\n", + "previously be prohibitively slow - opening opportunities for physics-aware model architectures\n", + "that compute geometric features on-the-fly during training." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import platform\n", + "\n", + "import pyvista as pv\n", + "import torch\n", + "from tensordict import TensorDict\n", + "\n", + "### Benchmark infrastructure and operations (compiled + uncompiled) ###\n", + "from benchmarks import (\n", + " benchmark,\n", + " collect_system_metadata,\n", + " compiled_ops,\n", + " plot_speedup_chart,\n", + " raw_ops,\n", + " save_benchmark_results,\n", + ")\n", + "from physicsnemo.mesh import Mesh\n", + "from physicsnemo.mesh.io import from_pyvista, to_pyvista" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "SYSTEM INFORMATION\n", + "============================================================\n", + "Python: 3.13.8\n", + "PyTorch: 2.10.0+cu130\n", + "PyVista: 0.46.5\n", + "CPU: x86_64\n", + "PyTorch CPU threads: 16\n", + "GPU: NVIDIA GeForce RTX 4090 Laptop GPU\n", + "CUDA: 13.0\n", + "GPU Memory: 17.2 GB\n", + "============================================================\n" + ] + } + ], + "source": [ + "### System Information\n", + "\n", + "print(\"=\" * 60)\n", + "print(\"SYSTEM INFORMATION\")\n", + "print(\"=\" * 60)\n", + "print(f\"Python: {platform.python_version()}\")\n", + "print(f\"PyTorch: {torch.__version__}\")\n", + "print(f\"PyVista: {pv.__version__}\")\n", + "print(f\"CPU: {platform.processor() or platform.machine()}\")\n", + "print(f\"PyTorch CPU threads: {torch.get_num_threads()}\")\n", + "\n", + "if torch.cuda.is_available():\n", + " print(f\"GPU: {torch.cuda.get_device_name(0)}\")\n", + " print(f\"CUDA: {torch.version.cuda}\")\n", + " gpu_mem = torch.cuda.get_device_properties(0).total_memory / 1e9\n", + " print(f\"GPU Memory: {gpu_mem:.1f} GB\")\n", + " torch.set_float32_matmul_precision(\"high\")\n", + "else:\n", + " print(\"GPU: Not available (benchmarks will run on CPU only)\")\n", + "print(\"=\" * 60)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 1: Performance Benchmarks\n", + "\n", + "We compare PhysicsNeMo-Mesh (GPU) to PyVista/VTK (CPU) across several common mesh operations.\n", + "All benchmarks use the Stanford Bunny mesh at various subdivision levels. We always use\n", + "`to_pyvista(pnm_mesh)` to ensure both libraries operate on identical geometry.\n", + "\n", + "**Operations benchmarked:**\n", + "- Normal computation\n", + "- Curvature computation\n", + "- Subdivision (Loop scheme)\n", + "- Neighbor computation (point-to-point, cell-to-cell)\n", + "- Random point sampling\n", + "- Laplacian smoothing\n", + "- Geometric transformations" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "### Benchmark Configuration ###\n", + "# Toggle which variants to include in benchmarks and charts.\n", + "# Disable variants to speed up notebook execution.\n", + "BENCHMARK_VARIANTS = {\n", + " \"pyvista\": True, # PyVista / VTK (CPU baseline)\n", + " \"pnm_cpu_raw\": True, # PhysicsNeMo CPU (no torch.compile)\n", + " \"pnm_cpu_compiled\": True, # PhysicsNeMo CPU (torch.compile)\n", + " \"pnm_gpu_raw\": True, # PhysicsNeMo GPU (no torch.compile)\n", + " \"pnm_gpu_compiled\": True, # PhysicsNeMo GPU (torch.compile)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# benchmark() and compiled_ops are imported from the benchmarks/ module.\n", + "# Store benchmark results for final visualization.\n", + "benchmark_results = {}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the Bunny Mesh\n", + "\n", + "We use the Stanford Bunny at increasing subdivision levels to demonstrate scaling behavior.\n", + "Higher subdivision levels amortize CUDA kernel launch overhead, showing the true GPU advantage." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh sizes at each subdivision level:\n", + "--------------------------------------------------\n", + " Level 0: 400 points, 796 cells\n", + " Level 1: 1,594 points, 3,184 cells\n", + " Level 2: 6,370 points, 12,736 cells\n", + " Level 3: 25,474 points, 50,944 cells\n", + " Level 4: 101,890 points, 203,776 cells\n", + " Level 5: 407,554 points, 815,104 cells\n", + " Level 6: 1,630,210 points, 3,260,416 cells\n", + " Level 7: 6,520,834 points, 13,041,664 cells\n" + ] + } + ], + "source": [ + "# Load the base bunny mesh and create subdivision variants\n", + "bunny_base = torch.load(\"assets/bunny.pt\", weights_only=False)\n", + "\n", + "# Create meshes at increasing subdivision levels\n", + "# Level 0 = base mesh, Level 3 = highly refined (100k+ cells)\n", + "subdivision_levels = [0, 1, 2, 3, 4, 5, 6, 7]\n", + "meshes = {}\n", + "\n", + "print(\"Mesh sizes at each subdivision level:\")\n", + "print(\"-\" * 50)\n", + "for level in subdivision_levels:\n", + " if level == 0:\n", + " meshes[level] = bunny_base.clone()\n", + " else:\n", + " meshes[level] = bunny_base.subdivide(levels=level, filter=\"loop\")\n", + " m = meshes[level]\n", + " print(f\" Level {level}: {m.n_points:,} points, {m.n_cells:,} cells\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Normal Computation\n", + "\n", + "Computing surface normals is a fundamental operation for rendering, physics simulation, and\n", + "ML feature extraction. PyVista calls VTK's CPU-based normal computation; PhysicsNeMo-Mesh\n", + "uses vectorized PyTorch operations." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Normal Computation Benchmark\n", + "============================================================\n", + "\n", + "Level 0: 400 points, 796 cells\n", + " PyVista (CPU): 0.751 ms (50 runs)\n", + " PNM CPU: 0.573 ms (50 runs)\n", + " PNM CPU (compiled): 0.482 ms (50 runs)\n", + " PNM GPU: 1.463 ms (50 runs)\n", + " PNM GPU (compiled): 1.506 ms (50 runs)\n", + "\n", + "Level 1: 1,594 points, 3,184 cells\n", + " PyVista (CPU): 1.207 ms (50 runs)\n", + " PNM CPU: 0.706 ms (50 runs)\n", + " PNM CPU (compiled): 0.768 ms (50 runs)\n", + " PNM GPU: 1.493 ms (50 runs)\n", + " PNM GPU (compiled): 1.514 ms (50 runs)\n", + "\n", + "Level 2: 6,370 points, 12,736 cells\n", + " PyVista (CPU): 3.105 ms (50 runs)\n", + " PNM CPU: 1.641 ms (50 runs)\n", + " PNM CPU (compiled): 1.484 ms (50 runs)\n", + " PNM GPU: 1.627 ms (50 runs)\n", + " PNM GPU (compiled): 1.764 ms (50 runs)\n", + "\n", + "Level 3: 25,474 points, 50,944 cells\n", + " PyVista (CPU): 10.706 ms (50 runs)\n", + " PNM CPU: 3.770 ms (50 runs)\n", + " PNM CPU (compiled): 6.065 ms (50 runs)\n", + " PNM GPU: 2.314 ms (50 runs)\n", + " PNM GPU (compiled): 1.842 ms (50 runs)\n", + "\n", + "Level 4: 101,890 points, 203,776 cells\n", + " PyVista (CPU): 40.297 ms (50 runs)\n", + " PNM CPU: 9.925 ms (50 runs)\n", + " PNM CPU (compiled): 16.412 ms (50 runs)\n", + " PNM GPU: 1.534 ms (50 runs)\n", + " PNM GPU (compiled): 1.571 ms (50 runs)\n", + "\n", + "Level 5: 407,554 points, 815,104 cells\n", + " PyVista (CPU): 169.304 ms (17 runs)\n", + " PNM CPU: 42.107 ms (42 runs)\n", + " PNM CPU (compiled): 64.212 ms (40 runs)\n", + " PNM GPU: 1.677 ms (50 runs)\n", + " PNM GPU (compiled): 1.648 ms (50 runs)\n", + "\n", + "Level 6: 1,630,210 points, 3,260,416 cells\n", + " PyVista (CPU): 829.092 ms (4 runs)\n", + " PNM CPU: 339.250 ms (9 runs)\n", + " PNM CPU (compiled): 367.864 ms (8 runs)\n", + " PNM GPU: 8.431 ms (50 runs)\n", + " PNM GPU (compiled): 6.942 ms (50 runs)\n", + "\n", + "Level 7: 6,520,834 points, 13,041,664 cells\n", + " PyVista (CPU): 4122.355 ms (1 runs)\n", + " PNM CPU: 1650.074 ms (2 runs)\n", + " PNM CPU (compiled): 1710.736 ms (2 runs)\n", + " PNM GPU: 30.118 ms (50 runs)\n", + " PNM GPU (compiled): 29.975 ms (50 runs)\n" + ] + } + ], + "source": [ + "print(\"Normal Computation Benchmark\")\n", + "print(\"=\" * 60)\n", + "\n", + "benchmark_results[\"normals\"] = {\n", + " \"pyvista\": [],\n", + " \"pnm_cpu_raw\": [],\n", + " \"pnm_cpu_compiled\": [],\n", + " \"pnm_gpu_raw\": [],\n", + " \"pnm_gpu_compiled\": [],\n", + " \"sizes\": [],\n", + "}\n", + "\n", + "for level in subdivision_levels:\n", + " pnm_mesh = meshes[level]\n", + " pv_mesh = to_pyvista(pnm_mesh)\n", + " pts, cls = pnm_mesh.points, pnm_mesh.cells\n", + "\n", + " print(f\"\\nLevel {level}: {pnm_mesh.n_points:,} points, {pnm_mesh.n_cells:,} cells\")\n", + " benchmark_results[\"normals\"][\"sizes\"].append(pnm_mesh.n_cells)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pyvista\"]:\n", + " pv_time, _ = benchmark(\n", + " \" PyVista (CPU)\",\n", + " lambda: pv_mesh.compute_normals(cell_normals=True, point_normals=False),\n", + " )\n", + " benchmark_results[\"normals\"][\"pyvista\"].append(pv_time)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_raw\"]:\n", + " t, _ = benchmark(\" PNM CPU\", lambda: raw_ops.cell_normals(pts, cls))\n", + " benchmark_results[\"normals\"][\"pnm_cpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU (compiled)\", lambda: compiled_ops.cell_normals(pts, cls)\n", + " )\n", + " benchmark_results[\"normals\"][\"pnm_cpu_compiled\"].append(t)\n", + "\n", + " if torch.cuda.is_available():\n", + " gpu = pnm_mesh.to(\"cuda\")\n", + " gpts, gcls = gpu.points, gpu.cells\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_raw\"]:\n", + " t, _ = benchmark(\" PNM GPU\", lambda: raw_ops.cell_normals(gpts, gcls))\n", + " benchmark_results[\"normals\"][\"pnm_gpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU (compiled)\", lambda: compiled_ops.cell_normals(gpts, gcls)\n", + " )\n", + " benchmark_results[\"normals\"][\"pnm_gpu_compiled\"].append(t)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Curvature Computation\n", + "\n", + "Gaussian curvature measures local surface bending. This is computed from vertex angles and areas.\n", + "PyVista/VTK does not have a direct Gaussian curvature function, so we compare CPU vs GPU within\n", + "PhysicsNeMo-Mesh only." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Curvature Computation Benchmark\n", + "============================================================\n", + "\n", + "Level 1: 1,594 points\n", + " PyVista (CPU): 0.502 ms (50 runs)\n", + " PNM CPU: 2.533 ms (50 runs)\n", + " PNM CPU (compiled): 1.130 ms (50 runs)\n", + " PNM GPU: 3.490 ms (50 runs)\n", + " PNM GPU (compiled): 1.448 ms (50 runs)\n", + "\n", + "Level 2: 6,370 points\n", + " PyVista (CPU): 1.448 ms (50 runs)\n", + " PNM CPU: 5.414 ms (50 runs)\n", + " PNM CPU (compiled): 2.233 ms (50 runs)\n", + " PNM GPU: 3.461 ms (50 runs)\n", + " PNM GPU (compiled): 1.635 ms (50 runs)\n", + "\n", + "Level 3: 25,474 points\n", + " PyVista (CPU): 5.243 ms (50 runs)\n", + " PNM CPU: 11.571 ms (50 runs)\n", + " PNM CPU (compiled): 8.950 ms (50 runs)\n", + " PNM GPU: 4.260 ms (50 runs)\n", + " PNM GPU (compiled): 1.963 ms (50 runs)\n", + "\n", + "Level 4: 101,890 points\n", + " PyVista (CPU): 20.708 ms (50 runs)\n", + " PNM CPU: 52.688 ms (33 runs)\n", + " PNM CPU (compiled): 40.498 ms (50 runs)\n", + " PNM GPU: 6.409 ms (50 runs)\n", + " PNM GPU (compiled): 4.331 ms (50 runs)\n", + "\n", + "Level 5: 407,554 points\n", + " PyVista (CPU): 85.403 ms (35 runs)\n", + " PNM CPU: 424.069 ms (7 runs)\n", + " PNM CPU (compiled): 213.721 ms (14 runs)\n", + " PNM GPU: 21.215 ms (50 runs)\n", + " PNM GPU (compiled): 16.195 ms (50 runs)\n", + "\n", + "Level 6: 1,630,210 points\n", + " PyVista (CPU): 343.229 ms (9 runs)\n", + " PNM CPU: 2403.396 ms (2 runs)\n", + " PNM CPU (compiled): 936.999 ms (4 runs)\n", + " PNM GPU: 91.024 ms (31 runs)\n", + " PNM GPU (compiled): 67.639 ms (43 runs)\n", + "\n", + "Level 7: 6,520,834 points\n", + " PyVista (CPU): 1483.546 ms (3 runs)\n", + " PNM CPU: 9876.560 ms (1 runs)\n", + " PNM CPU (compiled): 3657.682 ms (1 runs)\n", + " PNM GPU: 875.964 ms (2 runs)\n", + " PNM GPU (compiled): 281.793 ms (7 runs)\n" + ] + } + ], + "source": [ + "print(\"Curvature Computation Benchmark\")\n", + "print(\"=\" * 60)\n", + "\n", + "benchmark_results[\"curvature\"] = {\n", + " \"pyvista\": [],\n", + " \"pnm_cpu_raw\": [],\n", + " \"pnm_cpu_compiled\": [],\n", + " \"pnm_gpu_raw\": [],\n", + " \"pnm_gpu_compiled\": [],\n", + " \"sizes\": [],\n", + "}\n", + "\n", + "for level in subdivision_levels[1:]: # Skip level 0 (too small)\n", + " pnm_mesh = meshes[level]\n", + " pv_mesh = to_pyvista(pnm_mesh)\n", + " pts, cls = pnm_mesh.points, pnm_mesh.cells\n", + "\n", + " print(f\"\\nLevel {level}: {pnm_mesh.n_points:,} points\")\n", + " benchmark_results[\"curvature\"][\"sizes\"].append(pnm_mesh.n_points)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pyvista\"]:\n", + " pv_time, _ = benchmark(\n", + " \" PyVista (CPU)\", lambda: pv_mesh.curvature(curv_type=\"gaussian\")\n", + " )\n", + " benchmark_results[\"curvature\"][\"pyvista\"].append(pv_time)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_raw\"]:\n", + " t, _ = benchmark(\" PNM CPU\", lambda: raw_ops.gaussian_curvature(pts, cls))\n", + " benchmark_results[\"curvature\"][\"pnm_cpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU (compiled)\", lambda: compiled_ops.gaussian_curvature(pts, cls)\n", + " )\n", + " benchmark_results[\"curvature\"][\"pnm_cpu_compiled\"].append(t)\n", + "\n", + " if torch.cuda.is_available():\n", + " gpu = pnm_mesh.to(\"cuda\")\n", + " gpts, gcls = gpu.points, gpu.cells\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_raw\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU\", lambda: raw_ops.gaussian_curvature(gpts, gcls)\n", + " )\n", + " benchmark_results[\"curvature\"][\"pnm_gpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU (compiled)\",\n", + " lambda: compiled_ops.gaussian_curvature(gpts, gcls),\n", + " )\n", + " benchmark_results[\"curvature\"][\"pnm_gpu_compiled\"].append(t)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gradient Computation\n", + "\n", + "Computing gradients of scalar fields is fundamental for physics simulations and feature extraction.\n", + "PyVista provides `compute_derivative()` which wraps VTK's gradient filter. PhysicsNeMo-Mesh offers\n", + "both least-squares (LSQ) and discrete exterior calculus (DEC) gradient methods." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gradient Computation Benchmark\n", + "============================================================\n", + "\n", + "Level 1: 1,594 points\n", + " PyVista (CPU): 2.111 ms (50 runs)\n", + " PNM CPU: 24.839 ms (50 runs)\n", + " PNM CPU (compiled): 23.473 ms (50 runs)\n", + " PNM GPU: 7.729 ms (50 runs)\n", + " PNM GPU (compiled): 7.550 ms (50 runs)\n", + "\n", + "Level 2: 6,370 points\n", + " PyVista (CPU): 7.020 ms (50 runs)\n", + " PNM CPU: 99.287 ms (28 runs)\n", + " PNM CPU (compiled): 104.106 ms (22 runs)\n", + " PNM GPU: 7.535 ms (50 runs)\n", + " PNM GPU (compiled): 7.589 ms (50 runs)\n", + "\n", + "Level 3: 25,474 points\n", + " PyVista (CPU): 26.679 ms (50 runs)\n", + " PNM CPU: 342.779 ms (9 runs)\n", + " PNM CPU (compiled): 343.407 ms (9 runs)\n", + " PNM GPU: 8.224 ms (50 runs)\n", + " PNM GPU (compiled): 8.031 ms (50 runs)\n", + "\n", + "Level 4: 101,890 points\n", + " PyVista (CPU): 112.606 ms (26 runs)\n", + " PNM CPU: 1352.175 ms (3 runs)\n", + " PNM CPU (compiled): 1356.871 ms (3 runs)\n", + " PNM GPU: 9.101 ms (50 runs)\n", + " PNM GPU (compiled): 8.371 ms (50 runs)\n", + "\n", + "Level 5: 407,554 points\n", + " PyVista (CPU): 483.255 ms (6 runs)\n", + " PNM CPU: 6128.439 ms (1 runs)\n", + " PNM CPU (compiled): 5591.905 ms (1 runs)\n", + " PNM GPU: 19.163 ms (50 runs)\n", + " PNM GPU (compiled): 15.425 ms (50 runs)\n", + "\n", + "Level 6: 1,630,210 points\n", + " PyVista (CPU): 2027.252 ms (2 runs)\n", + " PNM CPU: 24006.322 ms (1 runs)\n", + " PNM CPU (compiled): 23184.054 ms (1 runs)\n", + " PNM GPU: 69.885 ms (39 runs)\n", + " PNM GPU (compiled): 56.705 ms (50 runs)\n", + "\n", + "Level 7: 6,520,834 points\n", + " PyVista (CPU): 8420.445 ms (1 runs)\n", + " PNM CPU: 86460.014 ms (1 runs)\n", + " PNM CPU (compiled): 94146.896 ms (1 runs)\n", + " PNM GPU: 264.232 ms (12 runs)\n", + " PNM GPU (compiled): 209.222 ms (14 runs)\n" + ] + } + ], + "source": [ + "print(\"Gradient Computation Benchmark\")\n", + "print(\"=\" * 60)\n", + "\n", + "benchmark_results[\"gradient\"] = {\n", + " \"pyvista\": [],\n", + " \"pnm_cpu_raw\": [],\n", + " \"pnm_cpu_compiled\": [],\n", + " \"pnm_gpu_raw\": [],\n", + " \"pnm_gpu_compiled\": [],\n", + " \"sizes\": [],\n", + "}\n", + "\n", + "for level in subdivision_levels[\n", + " 1:\n", + "]: # Skip level 0 (too small for meaningful gradients)\n", + " pnm_mesh = meshes[level]\n", + " pv_mesh = to_pyvista(pnm_mesh)\n", + " pts, cls = pnm_mesh.points, pnm_mesh.cells\n", + "\n", + " # Scalar field: z-coordinate\n", + " scalar_field = pts[:, 2].clone()\n", + " pv_mesh.point_data[\"scalar_field\"] = scalar_field.numpy()\n", + "\n", + " print(f\"\\nLevel {level}: {pnm_mesh.n_points:,} points\")\n", + " benchmark_results[\"gradient\"][\"sizes\"].append(pnm_mesh.n_points)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pyvista\"]:\n", + " pv_time, _ = benchmark(\n", + " \" PyVista (CPU)\",\n", + " lambda: pv_mesh.compute_derivative(scalars=\"scalar_field\", gradient=True),\n", + " )\n", + " benchmark_results[\"gradient\"][\"pyvista\"].append(pv_time)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_raw\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU\",\n", + " lambda: raw_ops.gradient(pts, cls, scalar_field),\n", + " )\n", + " benchmark_results[\"gradient\"][\"pnm_cpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU (compiled)\",\n", + " lambda: compiled_ops.gradient(pts, cls, scalar_field),\n", + " )\n", + " benchmark_results[\"gradient\"][\"pnm_cpu_compiled\"].append(t)\n", + "\n", + " if torch.cuda.is_available():\n", + " gpu = pnm_mesh.to(\"cuda\")\n", + " gpts, gcls = gpu.points, gpu.cells\n", + " g_scalar = scalar_field.to(\"cuda\")\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_raw\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU\",\n", + " lambda: raw_ops.gradient(gpts, gcls, g_scalar),\n", + " )\n", + " benchmark_results[\"gradient\"][\"pnm_gpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU (compiled)\",\n", + " lambda: compiled_ops.gradient(gpts, gcls, g_scalar),\n", + " )\n", + " benchmark_results[\"gradient\"][\"pnm_gpu_compiled\"].append(t)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Subdivision\n", + "\n", + "Mesh subdivision increases resolution by splitting each triangle into 4 smaller triangles.\n", + "The Loop scheme also smooths the surface. This operation scales with mesh size and is a\n", + "common preprocessing step for ML models that require consistent resolution." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Subdivision Benchmark (Loop scheme)\n", + "============================================================\n", + "\n", + "Subdividing level 0 -> 1\n", + " Input: 400 points, 796 cells\n", + " PyVista (CPU): 1.429 ms (50 runs)\n", + " Output: 1,594 points, 3,184 cells\n", + " PNM CPU: 10.121 ms (50 runs)\n", + " PNM CPU (compiled): 9.942 ms (50 runs)\n", + " PNM GPU: 6.145 ms (50 runs)\n", + " PNM GPU (compiled): 3.844 ms (50 runs)\n", + " Output: 1,594 points, 3,184 cells\n", + "\n", + "Subdividing level 1 -> 2\n", + " Input: 1,594 points, 3,184 cells\n", + " PyVista (CPU): 3.853 ms (50 runs)\n", + " Output: 6,370 points, 12,736 cells\n", + " PNM CPU: 39.854 ms (50 runs)\n", + " PNM CPU (compiled): 53.937 ms (40 runs)\n", + " PNM GPU: 5.179 ms (50 runs)\n", + " PNM GPU (compiled): 4.292 ms (50 runs)\n", + " Output: 6,370 points, 12,736 cells\n", + "\n", + "Subdividing level 2 -> 3\n", + " Input: 6,370 points, 12,736 cells\n", + " PyVista (CPU): 13.158 ms (50 runs)\n", + " Output: 25,474 points, 50,944 cells\n", + " PNM CPU: 181.641 ms (13 runs)\n", + " PNM CPU (compiled): 181.896 ms (14 runs)\n", + " PNM GPU: 5.737 ms (50 runs)\n", + " PNM GPU (compiled): 5.495 ms (50 runs)\n", + " Output: 25,474 points, 50,944 cells\n", + "\n", + "Subdividing level 3 -> 4\n", + " Input: 25,474 points, 50,944 cells\n", + " PyVista (CPU): 51.069 ms (50 runs)\n", + " Output: 101,890 points, 203,776 cells\n", + " PNM CPU: 650.585 ms (4 runs)\n", + " PNM CPU (compiled): 970.020 ms (3 runs)\n", + " PNM GPU: 13.102 ms (50 runs)\n", + " PNM GPU (compiled): 10.483 ms (50 runs)\n", + " Output: 101,890 points, 203,776 cells\n", + "\n", + "Subdividing level 4 -> 5\n", + " Input: 101,890 points, 203,776 cells\n", + " PyVista (CPU): 312.487 ms (8 runs)\n", + " Output: 407,554 points, 815,104 cells\n", + " PNM CPU: 2472.374 ms (2 runs)\n", + " PNM CPU (compiled): 2708.669 ms (2 runs)\n", + " PNM GPU: 8.273 ms (50 runs)\n", + " PNM GPU (compiled): 5.806 ms (50 runs)\n", + " Output: 407,554 points, 815,104 cells\n", + "\n", + "Subdividing level 5 -> 6\n", + " Input: 407,554 points, 815,104 cells\n", + " PyVista (CPU): 943.419 ms (4 runs)\n", + " Output: 1,630,210 points, 3,260,416 cells\n", + " PNM CPU: 9814.359 ms (1 runs)\n", + " PNM CPU (compiled): 9916.702 ms (1 runs)\n", + " PNM GPU: 23.499 ms (50 runs)\n", + " PNM GPU (compiled): 16.429 ms (50 runs)\n", + " Output: 1,630,210 points, 3,260,416 cells\n", + "\n", + "Subdividing level 6 -> 7\n", + " Input: 1,630,210 points, 3,260,416 cells\n", + " PyVista (CPU): 3859.456 ms (1 runs)\n", + " Output: 6,520,834 points, 13,041,664 cells\n", + " PNM CPU: 39454.267 ms (1 runs)\n", + " PNM CPU (compiled): 41797.043 ms (1 runs)\n", + " PNM GPU: 372.398 ms (4 runs)\n", + " PNM GPU (compiled): 192.371 ms (13 runs)\n", + " Output: 6,520,834 points, 13,041,664 cells\n" + ] + } + ], + "source": [ + "print(\"Subdivision Benchmark (Loop scheme)\")\n", + "print(\"=\" * 60)\n", + "\n", + "benchmark_results[\"subdivision\"] = {\n", + " \"pyvista\": [],\n", + " \"pnm_cpu_raw\": [],\n", + " \"pnm_cpu_compiled\": [],\n", + " \"pnm_gpu_raw\": [],\n", + " \"pnm_gpu_compiled\": [],\n", + " \"sizes\": [],\n", + "}\n", + "\n", + "for level in subdivision_levels[:-1]: # Subdivide levels 0..N-2 -> 1..N-1\n", + " pnm_mesh = meshes[level]\n", + " pv_mesh = to_pyvista(pnm_mesh)\n", + " pts, cls = pnm_mesh.points, pnm_mesh.cells\n", + "\n", + " print(f\"\\nSubdividing level {level} -> {level + 1}\")\n", + " print(f\" Input: {pnm_mesh.n_points:,} points, {pnm_mesh.n_cells:,} cells\")\n", + " benchmark_results[\"subdivision\"][\"sizes\"].append(pnm_mesh.n_cells)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pyvista\"]:\n", + " pv_time, pv_result = benchmark(\n", + " \" PyVista (CPU)\", lambda: pv_mesh.subdivide(nsub=1, subfilter=\"loop\")\n", + " )\n", + " benchmark_results[\"subdivision\"][\"pyvista\"].append(pv_time)\n", + " print(f\" Output: {pv_result.n_points:,} points, {pv_result.n_cells:,} cells\")\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_raw\"]:\n", + " t, _ = benchmark(\" PNM CPU\", lambda: raw_ops.subdivide(pts, cls))\n", + " benchmark_results[\"subdivision\"][\"pnm_cpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU (compiled)\", lambda: compiled_ops.subdivide(pts, cls)\n", + " )\n", + " benchmark_results[\"subdivision\"][\"pnm_cpu_compiled\"].append(t)\n", + "\n", + " if torch.cuda.is_available():\n", + " gpu = pnm_mesh.to(\"cuda\")\n", + " gpts, gcls = gpu.points, gpu.cells\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_raw\"]:\n", + " t, result = benchmark(\" PNM GPU\", lambda: raw_ops.subdivide(gpts, gcls))\n", + " benchmark_results[\"subdivision\"][\"pnm_gpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_compiled\"]:\n", + " t, result = benchmark(\n", + " \" PNM GPU (compiled)\", lambda: compiled_ops.subdivide(gpts, gcls)\n", + " )\n", + " benchmark_results[\"subdivision\"][\"pnm_gpu_compiled\"].append(t)\n", + " new_pts, new_cls = result\n", + " print(\n", + " f\" Output: {new_pts.shape[0]:,} points, {new_cls.shape[0]:,} cells\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Neighbor Computation\n", + "\n", + "Finding mesh neighbors (point-to-point, cell-to-cell) is essential for graph neural networks\n", + "and message-passing architectures. PyVista/VTK only exposes **per-element** query functions\n", + "(`point_neighbors(i)`, `cell_neighbors(i)`), requiring a Python loop over all elements.\n", + "PhysicsNeMo-Mesh computes **all neighbors at once** in a single vectorized operation.\n", + "\n", + "This is where the architectural difference is most stark: O(n) Python calls with VTK overhead\n", + "vs. a single GPU kernel launch." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Neighbor Computation Benchmark\n", + "============================================================\n", + "\n", + "Level 0: 400 points, 796 cells\n", + " Point-to-Point Neighbors:\n", + " PyVista (CPU loop): 70.358 ms (33 runs)\n", + " PNM CPU: 6.767 ms (50 runs)\n", + " PNM CPU (compiled): 8.482 ms (50 runs)\n", + " PNM GPU: 2.241 ms (50 runs)\n", + " PNM GPU (compiled): 1.932 ms (50 runs)\n", + " Cell-to-Cell Neighbors:\n", + " PyVista (CPU loop): 78.453 ms (29 runs)\n", + " PNM CPU: 19.418 ms (50 runs)\n", + " PNM CPU (compiled): 23.178 ms (50 runs)\n", + " PNM GPU: 9.850 ms (50 runs)\n", + " PNM GPU (compiled): 7.708 ms (50 runs)\n", + "\n", + "Level 1: 1,594 points, 3,184 cells\n", + " Point-to-Point Neighbors:\n", + " PyVista (CPU loop): 176.799 ms (16 runs)\n", + " PNM CPU: 20.970 ms (50 runs)\n", + " PNM CPU (compiled): 22.760 ms (50 runs)\n", + " PNM GPU: 1.834 ms (50 runs)\n", + " PNM GPU (compiled): 1.857 ms (50 runs)\n", + " Cell-to-Cell Neighbors:\n", + " PyVista (CPU loop): 240.236 ms (12 runs)\n", + " PNM CPU: 46.727 ms (50 runs)\n", + " PNM CPU (compiled): 38.124 ms (50 runs)\n", + " PNM GPU: 6.097 ms (50 runs)\n", + " PNM GPU (compiled): 8.616 ms (50 runs)\n", + "\n", + "Level 2: 6,370 points, 12,736 cells\n", + " Point-to-Point Neighbors:\n", + " PyVista (CPU loop): 680.641 ms (5 runs)\n", + " PNM CPU: 73.783 ms (37 runs)\n", + " PNM CPU (compiled): 77.365 ms (35 runs)\n", + " PNM GPU: 1.661 ms (50 runs)\n", + " PNM GPU (compiled): 1.516 ms (50 runs)\n", + " Cell-to-Cell Neighbors:\n", + " PyVista (CPU loop): 921.179 ms (3 runs)\n", + " PNM CPU: 151.605 ms (18 runs)\n", + " PNM CPU (compiled): 159.694 ms (17 runs)\n", + " PNM GPU: 5.969 ms (50 runs)\n", + " PNM GPU (compiled): 7.039 ms (50 runs)\n", + "\n", + "Level 3: 25,474 points, 50,944 cells\n", + " Point-to-Point Neighbors:\n", + " PyVista (CPU loop): 2739.777 ms (2 runs)\n", + " PNM CPU: 274.381 ms (11 runs)\n", + " PNM CPU (compiled): 277.523 ms (10 runs)\n", + " PNM GPU: 1.864 ms (50 runs)\n", + " PNM GPU (compiled): 1.560 ms (50 runs)\n", + " Cell-to-Cell Neighbors:\n", + " PyVista (CPU loop): 3708.040 ms (1 runs)\n", + " PNM CPU: 588.400 ms (5 runs)\n", + " PNM CPU (compiled): 584.924 ms (6 runs)\n", + " PNM GPU: 5.785 ms (50 runs)\n", + " PNM GPU (compiled): 7.826 ms (50 runs)\n" + ] + } + ], + "source": [ + "print(\"Neighbor Computation Benchmark\")\n", + "print(\"=\" * 60)\n", + "\n", + "benchmark_results[\"neighbors_p2p\"] = {\n", + " \"pyvista\": [],\n", + " \"pnm_cpu_raw\": [],\n", + " \"pnm_cpu_compiled\": [],\n", + " \"pnm_gpu_raw\": [],\n", + " \"pnm_gpu_compiled\": [],\n", + " \"sizes\": [],\n", + "}\n", + "benchmark_results[\"neighbors_c2c\"] = {\n", + " \"pyvista\": [],\n", + " \"pnm_cpu_raw\": [],\n", + " \"pnm_cpu_compiled\": [],\n", + " \"pnm_gpu_raw\": [],\n", + " \"pnm_gpu_compiled\": [],\n", + " \"sizes\": [],\n", + "}\n", + "\n", + "neighbor_levels = [\n", + " 0,\n", + " 1,\n", + " 2,\n", + " 3,\n", + "] # PyVista's per-element loop is too slow for larger meshes\n", + "\n", + "for level in neighbor_levels:\n", + " pnm_mesh = meshes[level]\n", + " pv_mesh = to_pyvista(pnm_mesh)\n", + " pts, cls = pnm_mesh.points, pnm_mesh.cells\n", + "\n", + " print(f\"\\nLevel {level}: {pnm_mesh.n_points:,} points, {pnm_mesh.n_cells:,} cells\")\n", + " benchmark_results[\"neighbors_p2p\"][\"sizes\"].append(pnm_mesh.n_points)\n", + " benchmark_results[\"neighbors_c2c\"][\"sizes\"].append(pnm_mesh.n_cells)\n", + "\n", + " ### Point-to-Point Neighbors ###\n", + " print(\" Point-to-Point Neighbors:\")\n", + "\n", + " if BENCHMARK_VARIANTS[\"pyvista\"]:\n", + " pv_time, _ = benchmark(\n", + " \" PyVista (CPU loop)\",\n", + " lambda: [pv_mesh.point_neighbors(i) for i in range(pv_mesh.n_points)],\n", + " )\n", + " benchmark_results[\"neighbors_p2p\"][\"pyvista\"].append(pv_time)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_raw\"]:\n", + " t, _ = benchmark(\" PNM CPU\", lambda: raw_ops.p2p_neighbors(pts, cls))\n", + " benchmark_results[\"neighbors_p2p\"][\"pnm_cpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU (compiled)\", lambda: compiled_ops.p2p_neighbors(pts, cls)\n", + " )\n", + " benchmark_results[\"neighbors_p2p\"][\"pnm_cpu_compiled\"].append(t)\n", + "\n", + " if torch.cuda.is_available():\n", + " gpu = pnm_mesh.to(\"cuda\")\n", + " gpts, gcls = gpu.points, gpu.cells\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_raw\"]:\n", + " t, _ = benchmark(\" PNM GPU\", lambda: raw_ops.p2p_neighbors(gpts, gcls))\n", + " benchmark_results[\"neighbors_p2p\"][\"pnm_gpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU (compiled)\", lambda: compiled_ops.p2p_neighbors(gpts, gcls)\n", + " )\n", + " benchmark_results[\"neighbors_p2p\"][\"pnm_gpu_compiled\"].append(t)\n", + "\n", + " ### Cell-to-Cell Neighbors ###\n", + " print(\" Cell-to-Cell Neighbors:\")\n", + "\n", + " if BENCHMARK_VARIANTS[\"pyvista\"]:\n", + " pv_time, _ = benchmark(\n", + " \" PyVista (CPU loop)\",\n", + " lambda: [\n", + " pv_mesh.cell_neighbors(i, \"edges\") for i in range(pv_mesh.n_cells)\n", + " ],\n", + " )\n", + " benchmark_results[\"neighbors_c2c\"][\"pyvista\"].append(pv_time)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_raw\"]:\n", + " t, _ = benchmark(\" PNM CPU\", lambda: raw_ops.c2c_neighbors(pts, cls))\n", + " benchmark_results[\"neighbors_c2c\"][\"pnm_cpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU (compiled)\", lambda: compiled_ops.c2c_neighbors(pts, cls)\n", + " )\n", + " benchmark_results[\"neighbors_c2c\"][\"pnm_cpu_compiled\"].append(t)\n", + "\n", + " if torch.cuda.is_available():\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_raw\"]:\n", + " t, _ = benchmark(\" PNM GPU\", lambda: raw_ops.c2c_neighbors(gpts, gcls))\n", + " benchmark_results[\"neighbors_c2c\"][\"pnm_gpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU (compiled)\", lambda: compiled_ops.c2c_neighbors(gpts, gcls)\n", + " )\n", + " benchmark_results[\"neighbors_c2c\"][\"pnm_gpu_compiled\"].append(t)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Random Point Sampling\n", + "\n", + "Sampling random points on mesh surfaces is common for data augmentation, point cloud generation,\n", + "and collocation point selection in physics-informed methods. PyVista does not provide a native\n", + "surface sampling function - you must manually select cells, compute areas, and generate\n", + "barycentric coordinates. PhysicsNeMo-Mesh provides a single vectorized function." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Random Point Sampling Benchmark (area-weighted)\n", + "============================================================\n", + "\n", + "Level 0: 796 cells, sampling 10,000 points\n", + " PyVista (CPU manual): 361.626 ms (9 runs)\n", + " PNM CPU: 3.149 ms (50 runs)\n", + " PNM CPU (compiled): 1.389 ms (50 runs)\n", + " PNM GPU: 1.531 ms (50 runs)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/psharpe/gh/physicsnemo/.venv/lib/python3.13/site-packages/torch/_inductor/compile_fx.py:321: UserWarning: TensorFloat32 tensor cores for float32 matrix multiplication available but not enabled. Consider setting `torch.set_float32_matmul_precision('high')` for better performance.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " PNM GPU (compiled): 0.585 ms (50 runs)\n", + "\n", + "Level 1: 3,184 cells, sampling 10,000 points\n", + " PyVista (CPU manual): 349.315 ms (9 runs)\n", + " PNM CPU: 4.100 ms (50 runs)\n", + " PNM CPU (compiled): 1.788 ms (50 runs)\n", + " PNM GPU: 1.854 ms (50 runs)\n", + " PNM GPU (compiled): 0.553 ms (50 runs)\n", + "\n", + "Level 2: 12,736 cells, sampling 10,000 points\n", + " PyVista (CPU manual): 359.735 ms (9 runs)\n", + " PNM CPU: 4.480 ms (50 runs)\n", + " PNM CPU (compiled): 2.717 ms (50 runs)\n", + " PNM GPU: 2.091 ms (50 runs)\n", + " PNM GPU (compiled): 0.939 ms (50 runs)\n", + "\n", + "Level 3: 50,944 cells, sampling 10,000 points\n", + " PyVista (CPU manual): 359.745 ms (9 runs)\n", + " PNM CPU: 5.266 ms (50 runs)\n", + " PNM CPU (compiled): 3.569 ms (50 runs)\n", + " PNM GPU: 1.143 ms (50 runs)\n", + " PNM GPU (compiled): 0.556 ms (50 runs)\n", + "\n", + "Level 4: 203,776 cells, sampling 10,000 points\n", + " PyVista (CPU manual): 372.055 ms (8 runs)\n", + " PNM CPU: 9.240 ms (50 runs)\n", + " PNM CPU (compiled): 7.787 ms (50 runs)\n", + " PNM GPU: 1.216 ms (50 runs)\n", + " PNM GPU (compiled): 0.629 ms (50 runs)\n", + "\n", + "Level 5: 815,104 cells, sampling 10,000 points\n", + " PyVista (CPU manual): 409.170 ms (7 runs)\n", + " PNM CPU: 34.296 ms (50 runs)\n", + " PNM CPU (compiled): 21.405 ms (50 runs)\n", + " PNM GPU: 2.074 ms (50 runs)\n", + " PNM GPU (compiled): 1.345 ms (50 runs)\n", + "\n", + "Level 6: 3,260,416 cells, sampling 10,000 points\n", + " PyVista (CPU manual): 551.218 ms (6 runs)\n", + " PNM CPU: 94.924 ms (23 runs)\n", + " PNM CPU (compiled): 77.155 ms (32 runs)\n", + " PNM GPU: 7.991 ms (50 runs)\n", + " PNM GPU (compiled): 6.301 ms (50 runs)\n", + "\n", + "Level 7: 13,041,664 cells, sampling 10,000 points\n", + " PyVista (CPU manual): 1161.610 ms (3 runs)\n", + " PNM CPU: 482.949 ms (6 runs)\n", + " PNM CPU (compiled): 308.597 ms (10 runs)\n", + " PNM GPU: 34.259 ms (50 runs)\n", + " PNM GPU (compiled): 27.759 ms (50 runs)\n" + ] + } + ], + "source": [ + "import numpy as np # needed for PyVista manual sampling below\n", + "\n", + "print(\"Random Point Sampling Benchmark (area-weighted)\")\n", + "print(\"=\" * 60)\n", + "\n", + "benchmark_results[\"sampling\"] = {\n", + " \"pyvista\": [],\n", + " \"pnm_cpu_raw\": [],\n", + " \"pnm_cpu_compiled\": [],\n", + " \"pnm_gpu_raw\": [],\n", + " \"pnm_gpu_compiled\": [],\n", + " \"sizes\": [],\n", + "}\n", + "\n", + "n_samples = 10000 # Sample this many points\n", + "\n", + "for level in subdivision_levels:\n", + " pnm_mesh = meshes[level]\n", + " pv_mesh = to_pyvista(pnm_mesh)\n", + " pts, cls = pnm_mesh.points, pnm_mesh.cells\n", + "\n", + " print(f\"\\nLevel {level}: {pnm_mesh.n_cells:,} cells, sampling {n_samples:,} points\")\n", + " benchmark_results[\"sampling\"][\"sizes\"].append(pnm_mesh.n_cells)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pyvista\"]:\n", + " # PyVista (CPU) - area-weighted sampling (manual, no native API)\n", + " def pyvista_sample():\n", + " sized = pv_mesh.compute_cell_sizes(length=False, area=True, volume=False)\n", + " areas = sized.cell_data[\"Area\"]\n", + " probs = areas / areas.sum()\n", + " cell_indices = np.random.choice(pv_mesh.n_cells, size=n_samples, p=probs)\n", + " r = np.random.exponential(scale=1.0, size=(n_samples, 3))\n", + " bary = r / r.sum(axis=1, keepdims=True)\n", + " points = []\n", + " for i, cell_idx in enumerate(cell_indices):\n", + " cell = pv_mesh.get_cell(cell_idx)\n", + " verts = np.array([cell.points[j] for j in range(3)])\n", + " points.append(\n", + " bary[i, 0] * verts[0]\n", + " + bary[i, 1] * verts[1]\n", + " + bary[i, 2] * verts[2]\n", + " )\n", + " return np.array(points)\n", + "\n", + " pv_time, _ = benchmark(\" PyVista (CPU manual)\", pyvista_sample)\n", + " benchmark_results[\"sampling\"][\"pyvista\"].append(pv_time)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_raw\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU\",\n", + " lambda: raw_ops.sample_points_area_weighted(pts, cls, n_samples),\n", + " )\n", + " benchmark_results[\"sampling\"][\"pnm_cpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU (compiled)\",\n", + " lambda: compiled_ops.sample_points_area_weighted(pts, cls, n_samples),\n", + " )\n", + " benchmark_results[\"sampling\"][\"pnm_cpu_compiled\"].append(t)\n", + "\n", + " if torch.cuda.is_available():\n", + " gpu = pnm_mesh.to(\"cuda\")\n", + " gpts, gcls = gpu.points, gpu.cells\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_raw\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU\",\n", + " lambda: raw_ops.sample_points_area_weighted(gpts, gcls, n_samples),\n", + " )\n", + " benchmark_results[\"sampling\"][\"pnm_gpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU (compiled)\",\n", + " lambda: compiled_ops.sample_points_area_weighted(gpts, gcls, n_samples),\n", + " )\n", + " benchmark_results[\"sampling\"][\"pnm_gpu_compiled\"].append(t)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Laplacian Smoothing\n", + "\n", + "Laplacian smoothing is an iterative mesh smoothing technique that moves each vertex toward\n", + "the centroid of its neighbors. Both PyVista and PhysicsNeMo-Mesh provide this operation,\n", + "making it a fair direct comparison." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Laplacian Smoothing Benchmark\n", + "============================================================\n", + "\n", + "Level 0: 400 points (50 iterations)\n", + " PyVista (CPU): 1.227 ms (50 runs)\n", + " PNM CPU: 21.734 ms (48 runs)\n", + " PNM CPU (compiled): 15.841 ms (50 runs)\n", + " PNM GPU: 32.564 ms (50 runs)\n", + " PNM GPU (compiled): 32.232 ms (50 runs)\n", + "\n", + "Level 1: 1,594 points (50 iterations)\n", + " PyVista (CPU): 2.150 ms (50 runs)\n", + " PNM CPU: 60.009 ms (43 runs)\n", + " PNM CPU (compiled): 62.137 ms (39 runs)\n", + " PNM GPU: 29.785 ms (50 runs)\n", + " PNM GPU (compiled): 33.037 ms (50 runs)\n", + "\n", + "Level 2: 6,370 points (50 iterations)\n", + " PyVista (CPU): 7.538 ms (50 runs)\n", + " PNM CPU: 185.686 ms (14 runs)\n", + " PNM CPU (compiled): 216.789 ms (12 runs)\n", + " PNM GPU: 30.274 ms (50 runs)\n", + " PNM GPU (compiled): 35.483 ms (50 runs)\n", + "\n", + "Level 3: 25,474 points (50 iterations)\n", + " PyVista (CPU): 39.984 ms (50 runs)\n", + " PNM CPU: 691.782 ms (5 runs)\n", + " PNM CPU (compiled): 702.139 ms (5 runs)\n", + " PNM GPU: 33.772 ms (50 runs)\n", + " PNM GPU (compiled): 38.099 ms (50 runs)\n", + "\n", + "Level 4: 101,890 points (50 iterations)\n", + " PyVista (CPU): 248.790 ms (12 runs)\n", + " PNM CPU: 2669.751 ms (2 runs)\n", + " PNM CPU (compiled): 2654.521 ms (2 runs)\n", + " PNM GPU: 35.748 ms (50 runs)\n", + " PNM GPU (compiled): 37.531 ms (50 runs)\n", + "\n", + "Level 5: 407,554 points (50 iterations)\n", + " PyVista (CPU): 1585.251 ms (2 runs)\n", + " PNM CPU: 10321.686 ms (1 runs)\n", + " PNM CPU (compiled): 10665.535 ms (1 runs)\n", + " PNM GPU: 48.063 ms (50 runs)\n", + " PNM GPU (compiled): 43.060 ms (50 runs)\n", + "\n", + "Level 6: 1,630,210 points (50 iterations)\n", + " PyVista (CPU): 7255.088 ms (1 runs)\n", + " PNM CPU: 41383.577 ms (1 runs)\n", + " PNM CPU (compiled): 40846.728 ms (1 runs)\n", + " PNM GPU: 261.203 ms (11 runs)\n", + " PNM GPU (compiled): 226.707 ms (13 runs)\n", + "\n", + "Level 7: 6,520,834 points (50 iterations)\n", + " PyVista (CPU): 30835.376 ms (1 runs)\n", + " PNM CPU: 168819.252 ms (1 runs)\n", + " PNM CPU (compiled): 165383.021 ms (1 runs)\n", + " PNM GPU: 1060.351 ms (3 runs)\n", + " PNM GPU (compiled): 964.554 ms (4 runs)\n" + ] + } + ], + "source": [ + "print(\"Laplacian Smoothing Benchmark\")\n", + "print(\"=\" * 60)\n", + "\n", + "benchmark_results[\"smoothing\"] = {\n", + " \"pyvista\": [],\n", + " \"pnm_cpu_raw\": [],\n", + " \"pnm_cpu_compiled\": [],\n", + " \"pnm_gpu_raw\": [],\n", + " \"pnm_gpu_compiled\": [],\n", + " \"sizes\": [],\n", + "}\n", + "\n", + "n_smooth_iter = 50\n", + "\n", + "for level in subdivision_levels:\n", + " pnm_mesh = meshes[level]\n", + " pv_mesh = to_pyvista(pnm_mesh)\n", + " pts, cls = pnm_mesh.points, pnm_mesh.cells\n", + "\n", + " print(f\"\\nLevel {level}: {pnm_mesh.n_points:,} points ({n_smooth_iter} iterations)\")\n", + " benchmark_results[\"smoothing\"][\"sizes\"].append(pnm_mesh.n_points)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pyvista\"]:\n", + " pv_time, _ = benchmark(\n", + " \" PyVista (CPU)\",\n", + " lambda: pv_mesh.smooth(n_iter=n_smooth_iter, relaxation_factor=0.1),\n", + " )\n", + " benchmark_results[\"smoothing\"][\"pyvista\"].append(pv_time)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_raw\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU\",\n", + " lambda: raw_ops.smooth(pts, cls, n_smooth_iter, 0.1),\n", + " )\n", + " benchmark_results[\"smoothing\"][\"pnm_cpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU (compiled)\",\n", + " lambda: compiled_ops.smooth(pts, cls, n_smooth_iter, 0.1),\n", + " )\n", + " benchmark_results[\"smoothing\"][\"pnm_cpu_compiled\"].append(t)\n", + "\n", + " if torch.cuda.is_available():\n", + " gpu = pnm_mesh.to(\"cuda\")\n", + " gpts, gcls = gpu.points, gpu.cells\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_raw\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU\",\n", + " lambda: raw_ops.smooth(gpts, gcls, n_smooth_iter, 0.1),\n", + " )\n", + " benchmark_results[\"smoothing\"][\"pnm_gpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU (compiled)\",\n", + " lambda: compiled_ops.smooth(gpts, gcls, n_smooth_iter, 0.1),\n", + " )\n", + " benchmark_results[\"smoothing\"][\"pnm_gpu_compiled\"].append(t)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Geometric Transformations\n", + "\n", + "Geometric transformations (translate, rotate, scale) are fundamental operations for data\n", + "augmentation and coordinate system manipulation. We benchmark a chain of transformations." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Geometric Transformations Benchmark\n", + "============================================================\n", + "\n", + "Level 0: 400 points\n", + " PyVista (CPU): 3.754 ms (50 runs)\n", + " PNM CPU: 0.629 ms (50 runs)\n", + " PNM CPU (compiled): 0.562 ms (50 runs)\n", + " PNM GPU: 2.791 ms (50 runs)\n", + " PNM GPU (compiled): 1.869 ms (50 runs)\n", + "\n", + "Level 1: 1,594 points\n", + " PyVista (CPU): 3.423 ms (50 runs)\n", + " PNM CPU: 0.574 ms (50 runs)\n", + " PNM CPU (compiled): 0.711 ms (50 runs)\n", + " PNM GPU: 2.919 ms (50 runs)\n", + " PNM GPU (compiled): 3.960 ms (50 runs)\n", + "\n", + "Level 2: 6,370 points\n", + " PyVista (CPU): 3.611 ms (50 runs)\n", + " PNM CPU: 0.624 ms (50 runs)\n", + " PNM CPU (compiled): 0.838 ms (50 runs)\n", + " PNM GPU: 2.891 ms (50 runs)\n", + " PNM GPU (compiled): 1.828 ms (50 runs)\n", + "\n", + "Level 3: 25,474 points\n", + " PyVista (CPU): 4.352 ms (50 runs)\n", + " PNM CPU: 0.751 ms (50 runs)\n", + " PNM CPU (compiled): 1.220 ms (50 runs)\n", + " PNM GPU: 2.861 ms (50 runs)\n", + " PNM GPU (compiled): 1.896 ms (50 runs)\n", + "\n", + "Level 4: 101,890 points\n", + " PyVista (CPU): 7.568 ms (50 runs)\n", + " PNM CPU: 0.876 ms (50 runs)\n", + " PNM CPU (compiled): 2.338 ms (50 runs)\n", + " PNM GPU: 2.861 ms (50 runs)\n", + " PNM GPU (compiled): 1.960 ms (50 runs)\n", + "\n", + "Level 5: 407,554 points\n", + " PyVista (CPU): 22.314 ms (50 runs)\n", + " PNM CPU: 1.526 ms (50 runs)\n", + " PNM CPU (compiled): 7.783 ms (50 runs)\n", + " PNM GPU: 3.768 ms (50 runs)\n", + " PNM GPU (compiled): 2.979 ms (50 runs)\n", + "\n", + "Level 6: 1,630,210 points\n", + " PyVista (CPU): 61.215 ms (47 runs)\n", + " PNM CPU: 3.870 ms (50 runs)\n", + " PNM CPU (compiled): 28.767 ms (50 runs)\n", + " PNM GPU: 2.846 ms (50 runs)\n", + " PNM GPU (compiled): 1.901 ms (50 runs)\n", + "\n", + "Level 7: 6,520,834 points\n", + " PyVista (CPU): 205.929 ms (15 runs)\n", + " PNM CPU: 21.987 ms (50 runs)\n", + " PNM CPU (compiled): 107.834 ms (27 runs)\n", + " PNM GPU: 5.248 ms (50 runs)\n", + " PNM GPU (compiled): 4.414 ms (50 runs)\n" + ] + } + ], + "source": [ + "print(\"Geometric Transformations Benchmark\")\n", + "print(\"=\" * 60)\n", + "\n", + "benchmark_results[\"transforms\"] = {\n", + " \"pyvista\": [],\n", + " \"pnm_cpu_raw\": [],\n", + " \"pnm_cpu_compiled\": [],\n", + " \"pnm_gpu_raw\": [],\n", + " \"pnm_gpu_compiled\": [],\n", + " \"sizes\": [],\n", + "}\n", + "\n", + "# Pre-compute transform parameters (shared across all levels)\n", + "offset_cpu = torch.tensor([1.0, 2.0, 3.0])\n", + "angle_x = torch.tensor(torch.pi / 4) # 45 degrees\n", + "angle_y = torch.tensor(torch.pi / 6) # 30 degrees\n", + "\n", + "for level in subdivision_levels:\n", + " pnm_mesh = meshes[level]\n", + " pv_mesh = to_pyvista(pnm_mesh)\n", + " pts, cls = pnm_mesh.points, pnm_mesh.cells\n", + "\n", + " print(f\"\\nLevel {level}: {pnm_mesh.n_points:,} points\")\n", + " benchmark_results[\"transforms\"][\"sizes\"].append(pnm_mesh.n_points)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pyvista\"]:\n", + "\n", + " def pyvista_transform():\n", + " result = pv_mesh.translate((1.0, 2.0, 3.0), inplace=False)\n", + " result = result.rotate_x(45, inplace=False)\n", + " result = result.rotate_y(30, inplace=False)\n", + " result = result.scale((2.0, 2.0, 2.0), inplace=False)\n", + " return result\n", + "\n", + " pv_time, _ = benchmark(\" PyVista (CPU)\", pyvista_transform)\n", + " benchmark_results[\"transforms\"][\"pyvista\"].append(pv_time)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_raw\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU\",\n", + " lambda: raw_ops.transforms(pts, cls, offset_cpu, angle_x, angle_y, 2.0),\n", + " )\n", + " benchmark_results[\"transforms\"][\"pnm_cpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_cpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM CPU (compiled)\",\n", + " lambda: compiled_ops.transforms(\n", + " pts, cls, offset_cpu, angle_x, angle_y, 2.0\n", + " ),\n", + " )\n", + " benchmark_results[\"transforms\"][\"pnm_cpu_compiled\"].append(t)\n", + "\n", + " if torch.cuda.is_available():\n", + " gpu = pnm_mesh.to(\"cuda\")\n", + " gpts, gcls = gpu.points, gpu.cells\n", + " offset_gpu = offset_cpu.to(\"cuda\")\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_raw\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU\",\n", + " lambda: raw_ops.transforms(\n", + " gpts, gcls, offset_gpu, angle_x, angle_y, 2.0\n", + " ),\n", + " )\n", + " benchmark_results[\"transforms\"][\"pnm_gpu_raw\"].append(t)\n", + "\n", + " if BENCHMARK_VARIANTS[\"pnm_gpu_compiled\"]:\n", + " t, _ = benchmark(\n", + " \" PNM GPU (compiled)\",\n", + " lambda: compiled_ops.transforms(\n", + " gpts, gcls, offset_gpu, angle_x, angle_y, 2.0\n", + " ),\n", + " )\n", + " benchmark_results[\"transforms\"][\"pnm_gpu_compiled\"].append(t)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Saving Benchmark Results\n", + "\n", + "The `benchmarks/` module provides `save_benchmark_results()` and `load_benchmark_results()`\n", + "for persisting results to JSON. Each file captures system metadata, benchmark configuration,\n", + "and all timing data - enabling comparisons across hardware (CPU, 4090, H100, B200) and\n", + "mesh sizes (small vs. large)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Benchmark results saved to benchmark_laptop_small.json\n" + ] + } + ], + "source": [ + "### Save benchmark results to disk ###\n", + "metadata = collect_system_metadata()\n", + "\n", + "# Derive a short GPU identifier for the filename\n", + "gpu_short = metadata[\"gpu\"].split()[-2].lower() if metadata[\"gpu\"] else \"cpu_only\"\n", + "results_path = save_benchmark_results(\n", + " results=benchmark_results,\n", + " metadata=metadata,\n", + " config={\"mesh_bucket\": \"small\", \"mesh_source\": \"Stanford Bunny\"},\n", + " path=f\"benchmark_{gpu_short}_small.json\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# (Results saved in the cell above.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Benchmark Summary\n", + "\n", + "We show the speedup of each PhysicsNeMo-Mesh variant over PyVista (CPU) for the largest\n", + "mesh size tested in each category. Comparing raw vs. compiled bars reveals the effect of\n", + "`torch.compile`, while comparing CPU vs. GPU bars reveals the hardware acceleration benefit." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Benchmark visualization saved to benchmark_results.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Plot speedup chart from live benchmark results ###\n", + "gpu_name = metadata.get(\"gpu\", \"\") if metadata else \"\"\n", + "plot_speedup_chart(\n", + " results=benchmark_results,\n", + " title_suffix=gpu_name,\n", + " save_path=\"benchmark_results.png\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Key Takeaways\n", + "\n", + "The benchmarks demonstrate several important points:\n", + "\n", + "1. **Neighbor computation shows the largest speedups** - This is because PyVista/VTK only\n", + " exposes per-element query functions, requiring O(n) Python calls with VTK overhead.\n", + " PhysicsNeMo-Mesh computes all neighbors in a single vectorized GPU operation.\n", + "\n", + "2. **Speedups increase with mesh size** - Larger meshes better amortize CUDA kernel launch\n", + " overhead, showing the true GPU advantage for production workloads.\n", + "\n", + "3. **Batch operations are key** - Operations like random sampling, where PyVista requires\n", + " manual Python loops, show dramatic speedups when vectorized on GPU.\n", + "\n", + "4. **Even simple operations benefit** - Normal computation and transformations, while fast\n", + " on CPU, still see meaningful speedups on GPU - and these add up in training loops.\n", + "\n", + "**For physics-AI pipelines**: When training on millions of mesh samples, even 10x speedups\n", + "in preprocessing translate to significant time and cost savings. More importantly, having\n", + "mesh operations on GPU enables:\n", + "\n", + "- **On-the-fly feature engineering**: Compute geometric features during training, not just preprocessing\n", + "- **Differentiable mesh operations**: Backpropagate through mesh computations for end-to-end learning\n", + "- **Dynamic augmentation**: Apply random transformations without CPU-GPU transfer overhead" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 2: Batching Meshes for Training\n", + "\n", + "When training with meshes of varying sizes, you need to handle dynamic shapes.\n", + "PhysicsNeMo-Mesh provides padding utilities for this." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original mesh sizes:\n", + " Mesh 0: 400 points, 796 cells\n", + " Mesh 1: 1,594 points, 3,184 cells\n", + " Mesh 2: 6,370 points, 12,736 cells\n" + ] + } + ], + "source": [ + "# Use the bunny meshes at different subdivision levels (already created above)\n", + "batching_meshes = [meshes[0], meshes[1], meshes[2]]\n", + "\n", + "print(\"Original mesh sizes:\")\n", + "for i, m in enumerate(batching_meshes):\n", + " print(f\" Mesh {i}: {m.n_points:,} points, {m.n_cells:,} cells\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fixed-Size Padding" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Padded to 6,370 points, 12,736 cells:\n", + " Mesh 0: 6,370 points, 12,736 cells\n", + " Mesh 1: 6,370 points, 12,736 cells\n", + " Mesh 2: 6,370 points, 12,736 cells\n" + ] + } + ], + "source": [ + "# Pad all meshes to fixed sizes\n", + "max_points = max(m.n_points for m in batching_meshes)\n", + "max_cells = max(m.n_cells for m in batching_meshes)\n", + "\n", + "padded_meshes = [\n", + " m.pad(target_n_points=max_points, target_n_cells=max_cells) for m in batching_meshes\n", + "]\n", + "\n", + "print(f\"\\nPadded to {max_points:,} points, {max_cells:,} cells:\")\n", + "for i, m in enumerate(padded_meshes):\n", + " print(f\" Mesh {i}: {m.n_points:,} points, {m.n_cells:,} cells\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Power-Based Padding (for torch.compile)\n", + "\n", + "For `torch.compile` with `dynamic=False`, pad to the next power of a base.\n", + "This limits the number of compiled kernel variants." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Power-padded sizes:\n", + " Mesh 0: 400 -> 437 points, 796 -> 985 cells\n", + " Mesh 1: 1,594 -> 2,216 points, 3,184 -> 3,325 cells\n", + " Mesh 2: 6,370 -> 7,481 points, 12,736 -> 16,834 cells\n" + ] + } + ], + "source": [ + "# Pad to next power of 1.5 (balances memory vs. compile cache hits)\n", + "power_padded = [m.pad_to_next_power(power=1.5) for m in batching_meshes]\n", + "\n", + "print(\"Power-padded sizes:\")\n", + "for i, (orig, padded) in enumerate(zip(batching_meshes, power_padded)):\n", + " print(\n", + " f\" Mesh {i}: {orig.n_points:,} -> {padded.n_points:,} points, \"\n", + " f\"{orig.n_cells:,} -> {padded.n_cells:,} cells\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 3: Feature Extraction for ML\n", + "\n", + "Prepare geometric and physical features for model input." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def extract_features(mesh):\n", + " \"\"\"Extract features for an ML model.\"\"\"\n", + " features = TensorDict({}, batch_size=[mesh.n_points])\n", + "\n", + " # Geometric features\n", + " features[\"position\"] = mesh.points\n", + "\n", + " if mesh.codimension == 1: # Surface mesh\n", + " features[\"normal\"] = mesh.point_normals\n", + " features[\"gaussian_curvature\"] = mesh.gaussian_curvature_vertices.unsqueeze(-1)\n", + " features[\"mean_curvature\"] = mesh.mean_curvature_vertices.unsqueeze(-1)\n", + "\n", + " return features" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracted features:\n", + " position: torch.Size([6370, 3])\n", + " normal: torch.Size([6370, 3])\n", + " gaussian_curvature: torch.Size([6370, 1])\n", + " mean_curvature: torch.Size([6370, 1])\n" + ] + } + ], + "source": [ + "# Example: extract features from bunny mesh\n", + "bunny = torch.load(\"assets/bunny.pt\", weights_only=False).subdivide(2, \"loop\")\n", + "\n", + "features = extract_features(bunny)\n", + "\n", + "print(\"Extracted features:\")\n", + "for key in features.keys():\n", + " print(f\" {key}: {features[key].shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature matrix: torch.Size([6370, 8])\n", + " (n_points, n_features)\n" + ] + } + ], + "source": [ + "# Concatenate into feature matrix\n", + "feature_matrix = torch.cat(\n", + " [\n", + " features[\"position\"],\n", + " features[\"normal\"],\n", + " features[\"gaussian_curvature\"],\n", + " features[\"mean_curvature\"],\n", + " ],\n", + " dim=-1,\n", + ")\n", + "\n", + "print(f\"Feature matrix: {feature_matrix.shape}\")\n", + "print(f\" (n_points, n_features)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 4: Boundary Condition Handling\n", + "\n", + "A key advantage of PhysicsNeMo-Mesh is the ability to store rich metadata,\n", + "including boundary condition information." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Boundary condition counts:\n", + " Interior: 2651\n", + " Inlet: 138\n", + " Outlet: 1102\n", + " Wall: 2479\n" + ] + } + ], + "source": [ + "# Example: CFD mesh with boundary conditions (using bunny mesh)\n", + "bc_mesh = meshes[2].clone() # Use level 2 bunny\n", + "\n", + "# Define BC types\n", + "BC_INTERIOR = 0\n", + "BC_INLET = 1\n", + "BC_OUTLET = 2\n", + "BC_WALL = 3\n", + "\n", + "# Assign BC types based on position (example)\n", + "# Bunny is roughly centered, so we use quantiles to define boundaries\n", + "x = bc_mesh.points[:, 0]\n", + "x_min, x_max = x.min(), x.max()\n", + "x_range = x_max - x_min\n", + "\n", + "bc_type = torch.full((bc_mesh.n_points,), BC_INTERIOR, dtype=torch.long)\n", + "bc_type[x < x_min + 0.15 * x_range] = BC_INLET\n", + "bc_type[x > x_max - 0.15 * x_range] = BC_OUTLET\n", + "bc_type[\n", + " (x >= x_min + 0.15 * x_range)\n", + " & (x <= x_max - 0.15 * x_range)\n", + " & (bc_mesh.points[:, 2] < bc_mesh.points[:, 2].median())\n", + "] = BC_WALL\n", + "\n", + "bc_mesh.point_data[\"bc_type\"] = bc_type\n", + "\n", + "print(\"Boundary condition counts:\")\n", + "for name, val in [(\"Interior\", 0), (\"Inlet\", 1), (\"Outlet\", 2), (\"Wall\", 3)]:\n", + " count = (bc_type == val).sum().item()\n", + " print(f\" {name}: {count}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Visualize BC types\n", + "bc_mesh.draw(point_scalars=\"bc_type\", cmap=\"Set1\", backend=\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh with BCs: Mesh(manifold_dim=2, spatial_dim=3, n_points=6370, n_cells=12736)\n", + " point_data : {\n", + " bc_type : (),\n", + " bc_values: {pressure: (), velocity: (3,)}}\n", + " cell_data : {}\n", + " global_data: {}\n" + ] + } + ], + "source": [ + "# Store BC values in nested TensorDict\n", + "bc_mesh.point_data[\"bc_values\"] = TensorDict(\n", + " {\n", + " \"velocity\": torch.zeros(bc_mesh.n_points, 3),\n", + " \"pressure\": torch.full((bc_mesh.n_points,), float(\"nan\")),\n", + " },\n", + " batch_size=[bc_mesh.n_points],\n", + ")\n", + "\n", + "# Set inlet velocity (1 m/s in x-direction)\n", + "inlet_mask = bc_mesh.point_data[\"bc_type\"] == BC_INLET\n", + "bc_mesh.point_data[\"bc_values\", \"velocity\"][inlet_mask] = torch.tensor([1.0, 0.0, 0.0])\n", + "\n", + "# Set outlet pressure (0 Pa gauge)\n", + "outlet_mask = bc_mesh.point_data[\"bc_type\"] == BC_OUTLET\n", + "bc_mesh.point_data[\"bc_values\", \"pressure\"][outlet_mask] = 0.0\n", + "\n", + "print(f\"Mesh with BCs: {bc_mesh}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 5: End-to-End CAE Workflow\n", + "\n", + "Complete example: load mesh, extract features, prepare for GNN training." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def prepare_mesh_for_training(mesh, device=\"cpu\"):\n", + " \"\"\"\n", + " Prepare a mesh for GNN training.\n", + "\n", + " Returns:\n", + " node_features: (n_nodes, n_features)\n", + " edge_index: (2, n_edges)\n", + " edge_features: (n_edges, n_edge_features)\n", + " \"\"\"\n", + " mesh = mesh.to(device)\n", + "\n", + " ### Node features: position + geometric features\n", + " node_features = [mesh.points]\n", + "\n", + " if mesh.codimension == 1:\n", + " node_features.append(mesh.point_normals)\n", + " node_features.append(mesh.gaussian_curvature_vertices.unsqueeze(-1))\n", + " node_features.append(mesh.mean_curvature_vertices.unsqueeze(-1))\n", + "\n", + " node_features = torch.cat(node_features, dim=-1)\n", + "\n", + " ### Edge index from mesh adjacency\n", + " adj = mesh.get_point_to_points_adjacency()\n", + " neighbor_counts = adj.offsets[1:] - adj.offsets[:-1]\n", + " source = torch.repeat_interleave(\n", + " torch.arange(mesh.n_points, device=device), neighbor_counts\n", + " )\n", + " target = adj.indices\n", + " edge_index = torch.stack([source, target], dim=0)\n", + "\n", + " ### Edge features: relative position, distance\n", + " edge_vectors = mesh.points[target] - mesh.points[source]\n", + " edge_lengths = edge_vectors.norm(dim=-1, keepdim=True)\n", + " edge_features = torch.cat([edge_vectors, edge_lengths], dim=-1)\n", + "\n", + " return {\n", + " \"node_features\": node_features,\n", + " \"edge_index\": edge_index,\n", + " \"edge_features\": edge_features,\n", + " \"n_nodes\": mesh.n_points,\n", + " \"n_edges\": edge_index.shape[1],\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GNN-ready data:\n", + " node_features: torch.Size([6370, 8]) on cuda:0\n", + " edge_index: torch.Size([2, 38208]) on cuda:0\n", + " edge_features: torch.Size([38208, 4]) on cuda:0\n", + " n_nodes: 6370\n", + " n_edges: 38208\n" + ] + } + ], + "source": [ + "# Example usage\n", + "bunny = torch.load(\"assets/bunny.pt\", weights_only=False).subdivide(2, \"loop\")\n", + "\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "graph_data = prepare_mesh_for_training(bunny, device=device)\n", + "\n", + "print(\"GNN-ready data:\")\n", + "for key, value in graph_data.items():\n", + " if isinstance(value, torch.Tensor):\n", + " print(f\" {key}: {value.shape} on {value.device}\")\n", + " else:\n", + " print(f\" {key}: {value}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 6: torch.compile Compatibility\n", + "\n", + "Most PhysicsNeMo-Mesh operations are compatible with `torch.compile`." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Testing torch.compile...\n", + " Normals: torch.Size([12736, 3])\n", + " Areas: torch.Size([12736])\n", + " Success!\n" + ] + } + ], + "source": [ + "if torch.cuda.is_available():\n", + "\n", + " @torch.compile\n", + " def compute_features_compiled(points, cells):\n", + " \"\"\"Compiled feature computation.\"\"\"\n", + " m = Mesh(points=points, cells=cells)\n", + " normals = m.cell_normals\n", + " areas = m.cell_areas\n", + " return normals, areas\n", + "\n", + " # Use the bunny mesh on GPU\n", + " compile_mesh = meshes[2].to(\"cuda\") # Level 2 bunny\n", + "\n", + " print(\"Testing torch.compile...\")\n", + " normals, areas = compute_features_compiled(compile_mesh.points, compile_mesh.cells)\n", + " print(f\" Normals: {normals.shape}\")\n", + " print(f\" Areas: {areas.shape}\")\n", + " print(\" Success!\")\n", + "else:\n", + " print(\"CUDA not available - skipping torch.compile demo\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "In this tutorial, you learned about ML integration:\n", + "\n", + "1. **Performance Benchmarks**: Comprehensive comparison of PhysicsNeMo-Mesh (GPU) vs PyVista/VTK (CPU)\n", + " - Normal computation, curvature, subdivision, neighbor queries\n", + " - Random sampling, Laplacian smoothing, geometric transformations\n", + " - Neighbor computation shows the largest speedups due to vectorized vs per-element APIs\n", + "2. **Batching**: `pad()` and `pad_to_next_power()` for dynamic shapes with torch.compile\n", + "3. **Feature Extraction**: Geometric features (normals, curvature) for model input\n", + "4. **Boundary Conditions**: Nested TensorDict for rich metadata storage\n", + "5. **End-to-End**: Complete workflow from mesh to GNN-ready data\n", + "6. **torch.compile**: Most operations are compilation-compatible\n", + "\n", + "---\n", + "\n", + "### Key Takeaway\n", + "\n", + "PyVista and VTK are excellent tools for visualization and interactive exploration. However,\n", + "for large-scale physics-AI training pipelines, their CPU-bound nature and per-element APIs\n", + "create bottlenecks. PhysicsNeMo-Mesh addresses this by providing:\n", + "\n", + "- **Vectorized GPU operations**: Compute all neighbors, samples, or features in one kernel\n", + "- **Differentiable mesh processing**: Enable end-to-end learning through mesh operations\n", + "- **On-the-fly feature engineering**: Compute geometric features during training, not just preprocessing\n", + "\n", + "This enables new physics-aware model architectures that were previously impractical.\n", + "\n", + "---\n", + "\n", + "### Conclusion\n", + "\n", + "You've completed the PhysicsNeMo-Mesh tutorial series! You now know how to:\n", + "\n", + "- Create, load, and manipulate meshes\n", + "- Perform geometric transformations and subdivision\n", + "- Compute gradients, divergence, curl, and curvature\n", + "- Query neighbors and perform spatial searches\n", + "- Validate and repair meshes\n", + "- Integrate meshes into high-performance ML training pipelines\n", + "\n", + "For more details, see the [physicsnemo.mesh README](../../../physicsnemo/mesh/README.md)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "project", + "language": "python", + "name": "project" + }, + "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.13.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/physicsnemo/mesh/README.md b/physicsnemo/mesh/README.md index e2bdee4604..28c7dcd589 100644 --- a/physicsnemo/mesh/README.md +++ b/physicsnemo/mesh/README.md @@ -455,6 +455,54 @@ keys starting with `_`. --- +## torch.compile Compatibility + +PhysicsNeMo-Mesh operations are generally compatible with `torch.compile`, but some +operations may cause graph breaks due to dynamic shapes or data-dependent control flow. + +### Generally Compilable + +- Point and cell arithmetic operations +- Tensor operations on mesh data (e.g., computing centroids, areas) +- Barycentric coordinate computation +- Basic transformations (translate, rotate, scale) + +### May Cause Graph Breaks + +The following patterns may cause graph breaks under `torch.compile`: + +- **`scatter_add_` operations**: Used extensively for edge counting, facet extraction, + and adjacency computations +- **`torch.where` with variable-length output**: Returns tensors whose size depends + on data values +- **Dynamic shape operations**: Operations like `torch.unique` that return + variable-sized outputs + +### Recommendations + +1. **Separate preprocessing from inner loops**: Wrap mesh topology computations + (boundaries, neighbors, facets) in a separate function and compile only the + numerical computation inner loops + + ```python + # Preprocessing (may have graph breaks) + neighbors = mesh.get_point_to_points_adjacency() + + # Compilable inner loop + @torch.compile + def compute_laplacian(points, neighbor_indices, neighbor_offsets): + # Pure tensor arithmetic here + ... + ``` + +2. **Use `mode="reduce-overhead"`**: For mixed workloads with some graph breaks + +3. **Pre-compute cached properties**: Access properties like `mesh.cell_areas`, + `mesh.cell_normals` etc. before entering compiled code to avoid graph breaks + from lazy computation + +--- + ## Philosophy & Design PhysicsNeMo-Mesh is built on three principles: diff --git a/physicsnemo/mesh/boundaries/__init__.py b/physicsnemo/mesh/boundaries/__init__.py new file mode 100644 index 0000000000..c96e3abfab --- /dev/null +++ b/physicsnemo/mesh/boundaries/__init__.py @@ -0,0 +1,40 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Boundary detection and facet extraction for simplicial meshes. + +This module provides: +1. Boundary detection: identify vertices, edges, and cells on mesh boundaries +2. Facet extraction: extract lower-dimensional simplices from cells +3. Topology checking: validate watertight and manifold properties +""" + +from physicsnemo.mesh.boundaries._detection import ( + get_boundary_cells, + get_boundary_edges, + get_boundary_vertices, +) +from physicsnemo.mesh.boundaries._facet_extraction import ( + categorize_facets_by_count, + compute_aggregation_weights, + deduplicate_and_aggregate_facets, + extract_candidate_facets, + extract_facet_mesh_data, +) +from physicsnemo.mesh.boundaries._topology import ( + is_manifold, + is_watertight, +) diff --git a/physicsnemo/mesh/boundaries/_detection.py b/physicsnemo/mesh/boundaries/_detection.py new file mode 100644 index 0000000000..204ed42d76 --- /dev/null +++ b/physicsnemo/mesh/boundaries/_detection.py @@ -0,0 +1,266 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Boundary detection for simplicial meshes. + +Provides functions to identify boundary vertices, edges, and cells in meshes. +A facet is on the boundary if it appears in only one cell (non-watertight / +manifold-with-boundary). +""" + +from typing import TYPE_CHECKING + +import torch + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def _extract_boundary_facets( + mesh: "Mesh", + manifold_codimension: int = 1, +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """Extract boundary facets at a given codimension. + + Shared helper that avoids duplicating the extract-then-categorize pattern + across the public detection functions. + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh (must have n_cells > 0). + manifold_codimension : int + Codimension of facets to extract and filter to boundary. + + Returns + ------- + boundary_facets : torch.Tensor + Unique facets appearing in exactly one cell, + shape (n_boundary_facets, n_verts_per_facet). + parent_cell_indices : torch.Tensor + Parent cell index for every *candidate* facet (before deduplication), + shape (n_candidates,). + boundary_candidate_mask : torch.Tensor + Boolean mask over candidates: True where the candidate maps to a + kept boundary facet, shape (n_candidates,). + """ + from physicsnemo.mesh.boundaries._facet_extraction import ( + categorize_facets_by_count, + extract_candidate_facets, + ) + + candidate_facets, parent_cell_indices = extract_candidate_facets( + mesh.cells, + manifold_codimension=manifold_codimension, + ) + boundary_facets, inverse_indices, _ = categorize_facets_by_count( + candidate_facets, + target_counts="boundary", + ) + boundary_candidate_mask = inverse_indices >= 0 + return boundary_facets, parent_cell_indices, boundary_candidate_mask + + +def get_boundary_vertices(mesh: "Mesh") -> torch.Tensor: + """Identify vertices that lie on the mesh boundary. + + A vertex is on the boundary if it belongs to at least one boundary facet + (a codimension-1 sub-simplex appearing in exactly one cell). + + For 1D manifolds the boundary facets are vertices (0-simplices), for 2D + they are edges, and for 3D they are faces. + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh + + Returns + ------- + torch.Tensor + Boolean tensor of shape (n_points,) where True indicates boundary vertices + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import cylinder_open + >>> # Cylinder with open ends + >>> mesh = cylinder_open.load(n_circ=32, n_height=16) + >>> is_boundary = get_boundary_vertices(mesh) + >>> # Top and bottom circles are boundary vertices + >>> assert is_boundary.sum() == 2 * 32 # 64 boundary vertices + + Notes + ----- + For closed manifolds (watertight meshes), returns all False. + """ + device = mesh.cells.device + n_points = mesh.n_points + + ### Handle empty mesh + if mesh.n_cells == 0: + return torch.zeros(n_points, dtype=torch.bool, device=device) + + ### Extract codimension-1 boundary facets and mark their vertices + boundary_facets, _, _ = _extract_boundary_facets(mesh, manifold_codimension=1) + + is_boundary_vertex = torch.zeros(n_points, dtype=torch.bool, device=device) + if len(boundary_facets) > 0: + is_boundary_vertex.scatter_(0, boundary_facets.flatten(), True) + + return is_boundary_vertex + + +def get_boundary_cells( + mesh: "Mesh", + boundary_codimension: int = 1, +) -> torch.Tensor: + """Identify cells that have at least one facet on the mesh boundary. + + A cell is on the boundary if it contains at least one k-codimension facet + that appears in no other cell. + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh + boundary_codimension : int, optional + Codimension of facets defining boundary membership. + + - 1 (default): cells with at least one codim-1 boundary facet + - 2: cells with at least one codim-2 boundary facet (more permissive) + - k: cells with at least one codim-k boundary facet + + Returns + ------- + torch.Tensor + Boolean tensor of shape (n_cells,) where True indicates boundary cells + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh import Mesh + >>> # Two triangles sharing an edge, with 4 boundary edges total + >>> points = torch.tensor([[0., 0.], [1., 0.], [0., 1.], [1., 1.]]) + >>> cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + >>> mesh = Mesh(points=points, cells=cells) + >>> is_boundary = get_boundary_cells(mesh, boundary_codimension=1) + >>> assert is_boundary.all() # Both triangles touch boundary edges + + Notes + ----- + For closed manifolds (watertight meshes), returns all False. + """ + device = mesh.cells.device + n_cells = mesh.n_cells + + ### Handle empty mesh + if n_cells == 0: + return torch.zeros(0, dtype=torch.bool, device=device) + + ### Validate boundary_codimension + if boundary_codimension < 1 or boundary_codimension > mesh.n_manifold_dims: + raise ValueError( + f"Invalid {boundary_codimension=}. " + f"Must be in range [1, {mesh.n_manifold_dims}] for {mesh.n_manifold_dims=}" + ) + + ### Extract boundary facets and determine which parent cells they belong to + _, parent_cell_indices, boundary_candidate_mask = _extract_boundary_facets( + mesh, + manifold_codimension=boundary_codimension, + ) + + ### Mark cells that contain at least one boundary facet + is_boundary_cell = torch.zeros(n_cells, dtype=torch.bool, device=device) + boundary_parent_cells = parent_cell_indices[boundary_candidate_mask] + + if len(boundary_parent_cells) > 0: + is_boundary_cell.scatter_(0, boundary_parent_cells, True) + + return is_boundary_cell + + +def get_boundary_edges(mesh: "Mesh") -> torch.Tensor: + """Get edges that lie on the mesh boundary. + + For 2D manifolds, boundary edges are codimension-1 facets appearing in only + one cell. For 1D manifolds (edge meshes), the boundary consists of vertices + rather than edges, so an empty tensor is returned. For 3D+ manifolds, boundary + edges are those belonging to at least one boundary face (codimension-1 facet + appearing in only one cell). + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh + + Returns + ------- + torch.Tensor + Tensor of shape (n_boundary_edges, 2) containing boundary edge connectivity. + Returns empty tensor of shape (0, 2) for watertight meshes or 1D manifolds. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import cylinder_open + >>> # Cylinder with open ends + >>> mesh = cylinder_open.load(n_circ=32, n_height=16) + >>> boundary_edges = get_boundary_edges(mesh) + >>> # Top and bottom circles each have 32 edges = 64 total + >>> assert len(boundary_edges) == 64 + + Notes + ----- + For closed manifolds (watertight meshes), returns empty tensor. + """ + device = mesh.cells.device + + ### Handle empty mesh or 1D manifolds (whose boundary consists of vertices, not edges) + if mesh.n_cells == 0 or mesh.n_manifold_dims < 2: + return torch.zeros((0, 2), dtype=torch.int64, device=device) + + ### For 2D manifolds, boundary edges are codim-1 facets appearing in exactly 1 cell. + ### For 3D+ manifolds, extract edges of boundary faces. + if mesh.n_manifold_dims == 2: + # Edges are codim-1 facets; boundary = appear in exactly 1 cell + boundary_edges, _, _ = _extract_boundary_facets(mesh, manifold_codimension=1) + return boundary_edges + + # For 3D+ manifolds: find boundary faces (codim-1), then extract their edges + boundary_faces, _, _ = _extract_boundary_facets(mesh, manifold_codimension=1) + + if len(boundary_faces) == 0: + return torch.zeros((0, 2), dtype=torch.int64, device=device) + + # Extract unique edges from boundary faces + n_verts_per_face = boundary_faces.shape[1] + from itertools import combinations + + combo_indices = list(combinations(range(n_verts_per_face), 2)) + combo_tensor = torch.tensor( + combo_indices, dtype=torch.long, device=device + ) # (n_combos, 2) + + # Gather edges from boundary faces: (n_boundary_faces, n_combos, 2) + all_edges = boundary_faces[:, combo_tensor] + # Reshape to (n_boundary_faces * n_combos, 2) + all_edges = all_edges.reshape(-1, 2) + # Sort each edge for canonical ordering + all_edges = torch.sort(all_edges, dim=-1).values + # Deduplicate + boundary_edges = torch.unique(all_edges, dim=0) + + return boundary_edges diff --git a/physicsnemo/mesh/boundaries/_facet_extraction.py b/physicsnemo/mesh/boundaries/_facet_extraction.py new file mode 100644 index 0000000000..7dcd099a2e --- /dev/null +++ b/physicsnemo/mesh/boundaries/_facet_extraction.py @@ -0,0 +1,622 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""High-performance facet extraction for simplicial meshes. + +This module extracts k-codimension simplices from n-simplicial meshes. For example: +- Triangle meshes (2-simplices) → edge meshes (1-simplices) [codimension 1] +- Tetrahedral meshes (3-simplices) → triangular facets (2-simplices) [codimension 1] +- Tetrahedral meshes (3-simplices) → edge meshes (1-simplices) [codimension 2] +- Triangle meshes (2-simplices) → point meshes (0-simplices) [codimension 2] + +Note: Originally designed to use Triton kernels, but Triton requires all array sizes +to be powers of 2, which doesn't work for triangles (3 vertices) or tets (4 vertices). +The pure PyTorch implementation here is highly optimized and performs excellently. +""" + +from typing import TYPE_CHECKING, Literal + +import torch +from tensordict import TensorDict + +from physicsnemo.mesh.utilities._cache import CACHE_KEY +from physicsnemo.mesh.utilities._tolerances import safe_eps + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def _generate_combination_indices(n: int, k: int) -> torch.Tensor: + """Generate all combinations of k elements from n elements. + + This is a vectorized implementation similar to itertools.combinations(range(n), k). + + Parameters + ---------- + n : int + Total number of elements + k : int + Number of elements to choose + + Returns + ------- + torch.Tensor + Tensor of shape (n_choose_k, k) containing all combinations + + Examples + -------- + >>> _generate_combination_indices(4, 2) + tensor([[0, 1], + [0, 2], + [0, 3], + [1, 2], + [1, 3], + [2, 3]]) + """ + from itertools import combinations + + ### Use standard library for correctness + # For small values of n and k (which is always the case for simplicial meshes), + # this is fast enough and avoids reinventing the wheel + combos = list(combinations(range(n), k)) + return torch.tensor(combos, dtype=torch.int64) + + +def categorize_facets_by_count( + candidate_facets: torch.Tensor, # shape: (n_candidate_facets, n_vertices_per_facet) + target_counts: list[int] | Literal["boundary", "shared", "interior", "all"] = "all", +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """Deduplicate facets and optionally filter by occurrence count. + + This utility consolidates the common pattern of deduplicating facets using + torch.unique and filtering based on how many times each facet appears. + + Parameters + ---------- + candidate_facets : torch.Tensor + All candidate facets (may contain duplicates), already sorted + target_counts : list[int] | {"boundary", "shared", "interior", "all"}, optional + How to filter the results: + - "all": Return all unique facets with their counts (no filtering) + - "boundary": Return facets appearing exactly once (counts == 1) + - "interior": Return facets appearing exactly twice (counts == 2) + - "shared": Return facets appearing 2+ times (counts >= 2) + - list[int]: Return facets with counts in the specified list + + Returns + ------- + tuple[torch.Tensor, torch.Tensor, torch.Tensor] + Tuple of (unique_facets, inverse_indices, counts): + - unique_facets: Deduplicated facets, possibly filtered by count + - inverse_indices: Mapping from candidate facets to unique facet indices + - counts: How many times each unique facet appears + + If filtering is applied, only the matching facets and their data are returned. + + Examples + -------- + >>> import torch + >>> # Create candidate facets from a simple mesh (edges from 2 triangles) + >>> candidate_facets = torch.tensor([[0, 1], [1, 2], [0, 2], [1, 2], [1, 3], [2, 3]]) + >>> # Find boundary facets (appear exactly once) + >>> boundary_facets, _, counts = categorize_facets_by_count( + ... candidate_facets, target_counts="boundary" + ... ) + >>> assert boundary_facets.shape[0] == 4 # 4 boundary edges + """ + ### Deduplicate and count occurrences + unique_facets, inverse_indices, counts = torch.unique( + candidate_facets, + dim=0, + return_inverse=True, + return_counts=True, + ) + + ### Apply filtering based on target_counts + if target_counts == "all": + # Return everything, no filtering + return unique_facets, inverse_indices, counts + + elif target_counts == "boundary": + # Facets appearing exactly once (on boundary) + mask = counts == 1 + + elif target_counts == "interior": + # Facets appearing exactly twice (interior of watertight mesh) + mask = counts == 2 + + elif target_counts == "shared": + # Facets appearing 2+ times (shared by multiple cells) + mask = counts >= 2 + + elif isinstance(target_counts, list): + # Custom list of target counts + mask = torch.zeros_like(counts, dtype=torch.bool) + for target_count in target_counts: + mask |= counts == target_count + + else: + raise ValueError( + f"Invalid {target_counts=}. " + f"Must be 'all', 'boundary', 'interior', 'shared', or a list of integers." + ) + + ### Filter facets and update inverse indices + filtered_facets = unique_facets[mask] + filtered_counts = counts[mask] + + # Update inverse indices to point to filtered facets + # Create mapping from old unique indices to new filtered indices + # For facets that don't pass the filter, map to -1 + old_to_new = torch.full( + (len(unique_facets),), -1, dtype=torch.int64, device=unique_facets.device + ) + old_to_new[mask] = torch.arange( + mask.sum(), dtype=torch.int64, device=unique_facets.device + ) + + # Remap inverse indices + filtered_inverse = old_to_new[inverse_indices] + + return filtered_facets, filtered_inverse, filtered_counts + + +def extract_candidate_facets( + cells: torch.Tensor, # shape: (n_cells, n_vertices_per_cell) + manifold_codimension: int = 1, +) -> tuple[torch.Tensor, torch.Tensor]: + """Extract all candidate k-codimension simplices from n-simplicial mesh. + + Each n-simplex generates C(n+1, n+1-k) candidate sub-simplices, where k is the + manifold codimension. Sub-simplices are sorted to canonical form but may contain + duplicates (sub-simplices shared by multiple parent cells). + + This uses vectorized PyTorch operations for high performance. + + Parameters + ---------- + cells : torch.Tensor + Parent mesh connectivity, shape (n_cells, n_vertices_per_cell) + manifold_codimension : int, optional + Codimension of the extracted mesh relative to parent. + - 1: Extract (n-1)-facets (default, e.g., triangular faces from tets) + - 2: Extract (n-2)-facets (e.g., edges from tets, vertices from triangles) + - k: Extract (n-k)-facets + + Returns + ------- + candidate_facets : torch.Tensor + All sub-simplices with duplicates, + shape (n_cells * n_combinations, n_vertices_per_subsimplex) + parent_cell_indices : torch.Tensor + Parent cell index for each sub-simplex, + shape (n_cells * n_combinations,) + + Raises + ------ + ValueError + If manifold_codimension is invalid for the given cells + + Examples + -------- + >>> import torch + >>> # Extract edges (codim 1) from triangles + >>> cells = torch.tensor([[0, 1, 2]]) + >>> facets, parents = extract_candidate_facets(cells, manifold_codimension=1) + >>> assert facets.shape == (3, 2) # three edges with 2 vertices each + + >>> # Extract vertices (codim 2) from triangles + >>> facets, parents = extract_candidate_facets(cells, manifold_codimension=2) + >>> assert facets.shape == (3, 1) # three vertices + """ + n_cells, n_vertices_per_cell = cells.shape + n_vertices_per_subsimplex = n_vertices_per_cell - manifold_codimension + + ### Validate codimension + if manifold_codimension < 1: + raise ValueError( + f"{manifold_codimension=} must be >= 1. " + "Use codimension=1 to extract immediate boundary facets." + ) + if n_vertices_per_subsimplex < 1: + raise ValueError( + f"{manifold_codimension=} is too large for {n_vertices_per_cell=}. " + f"Would result in {n_vertices_per_subsimplex=} < 1. " + f"Maximum allowed codimension is {n_vertices_per_cell - 1}." + ) + + ### Generate combination indices for selecting vertices + # Shape: (n_combinations, n_vertices_per_subsimplex) + combination_indices = _generate_combination_indices( + n_vertices_per_cell, + n_vertices_per_subsimplex, + ).to(cells.device) + n_combinations = len(combination_indices) + + ### Extract sub-simplices using combination indices + # Use advanced indexing to gather the correct vertex IDs + # Shape: (n_cells, n_combinations, n_vertices_per_subsimplex) + candidate_facets = torch.gather( + cells.unsqueeze(1).expand(-1, n_combinations, -1), + dim=2, + index=combination_indices.unsqueeze(0).expand(n_cells, -1, -1), + ) + + ### Sort vertices within each sub-simplex to canonical form for deduplication + # Shape remains (n_cells, n_combinations, n_vertices_per_subsimplex) + candidate_facets = torch.sort(candidate_facets, dim=-1)[0] + + ### Reshape to (n_cells * n_combinations, n_vertices_per_subsimplex) + candidate_facets = candidate_facets.reshape(-1, n_vertices_per_subsimplex) + + ### Create parent cell indices + # Each cell contributes n_combinations sub-simplices + # Shape: (n_cells * n_combinations,) + parent_cell_indices = torch.arange( + n_cells, + device=cells.device, + dtype=torch.int64, + ).repeat_interleave(n_combinations) + + return candidate_facets, parent_cell_indices + + +def _aggregate_tensor_data( + parent_data: torch.Tensor, # shape: (n_parent_cells, *data_shape) + parent_cell_indices: torch.Tensor, # shape: (n_candidate_facets,) + inverse_indices: torch.Tensor, # shape: (n_candidate_facets,) + n_unique_facets: int, + aggregation_weights: torch.Tensor | None, +) -> torch.Tensor: + """Aggregate tensor data from parent cells to unique facets. + + Parameters + ---------- + parent_data : torch.Tensor + Data from parent cells + parent_cell_indices : torch.Tensor + Which parent cell each candidate facet came from + inverse_indices : torch.Tensor + Mapping from candidate facets to unique facets + n_unique_facets : int + Number of unique facets + aggregation_weights : torch.Tensor | None + Optional weights for aggregation + + Returns + ------- + torch.Tensor + Aggregated data for unique facets + """ + from physicsnemo.mesh.utilities._scatter_ops import scatter_aggregate + + ### Gather parent cell data for each candidate facet + # Shape: (n_candidate_facets, *data_shape) + candidate_data = parent_data[parent_cell_indices] + + ### Use unified scatter aggregation utility + return scatter_aggregate( + src_data=candidate_data, + src_to_dst_mapping=inverse_indices, + n_dst=n_unique_facets, + weights=aggregation_weights, + aggregation="mean", + ) + + +def deduplicate_and_aggregate_facets( + candidate_facets: torch.Tensor, # shape: (n_candidate_facets, n_vertices_per_facet) + parent_cell_indices: torch.Tensor, # shape: (n_candidate_facets,) + parent_cell_data: TensorDict, # shape: (n_parent_cells, *data_shape) + aggregation_weights: torch.Tensor | None = None, # shape: (n_candidate_facets,) +) -> tuple[torch.Tensor, TensorDict, torch.Tensor]: + """Deduplicate facets and aggregate data from parent cells. + + Finds unique facets (topologically, based on vertex indices) and aggregates + associated data from all parent cells that share each facet. + + Parameters + ---------- + candidate_facets : torch.Tensor + All candidate facets including duplicates + parent_cell_indices : torch.Tensor + Which parent cell each candidate facet came from + parent_cell_data : TensorDict + TensorDict with data to aggregate from parent cells + aggregation_weights : torch.Tensor | None, optional + Weights for aggregating data (optional, defaults to uniform) + + Returns + ------- + unique_facets : torch.Tensor + Deduplicated facets, shape (n_unique_facets, n_vertices_per_facet) + aggregated_data : TensorDict + Aggregated TensorDict for each unique facet + facet_to_parents : torch.Tensor + Inverse mapping from candidate facets to unique facets, shape (n_candidate_facets,) + """ + ### Find unique facets and inverse mapping + unique_facets, inverse_indices = torch.unique( + candidate_facets, + dim=0, + return_inverse=True, + ) + + ### Aggregate data using TensorDict.apply() (handles nested TensorDicts automatically) + n_unique_facets = len(unique_facets) + aggregated_data = parent_cell_data.apply( + lambda tensor: _aggregate_tensor_data( + tensor, + parent_cell_indices, + inverse_indices, + n_unique_facets, + aggregation_weights, + ), + batch_size=torch.Size([n_unique_facets]), + ) + + return unique_facets, aggregated_data, inverse_indices + + +def compute_aggregation_weights( + aggregation_strategy: Literal["mean", "area_weighted", "inverse_distance"], + parent_cell_areas: torch.Tensor | None, # shape: (n_parent_cells,) + parent_cell_centroids: torch.Tensor + | None, # shape: (n_parent_cells, n_spatial_dims) + facet_centroids: torch.Tensor | None, # shape: (n_candidate_facets, n_spatial_dims) + parent_cell_indices: torch.Tensor, # shape: (n_candidate_facets,) +) -> torch.Tensor: + """Compute weights for aggregating parent cell data to facets. + + Parameters + ---------- + aggregation_strategy : {"mean", "area_weighted", "inverse_distance"} + How to weight parent contributions + parent_cell_areas : torch.Tensor | None + Areas of parent cells (required for area_weighted) + parent_cell_centroids : torch.Tensor | None + Centroids of parent cells (required for inverse_distance) + facet_centroids : torch.Tensor | None + Centroids of candidate facets (required for inverse_distance) + parent_cell_indices : torch.Tensor + Which parent cell each candidate facet came from + + Returns + ------- + torch.Tensor + Aggregation weights, shape (n_candidate_facets,) + """ + n_candidate_facets = len(parent_cell_indices) + device = parent_cell_indices.device + + if aggregation_strategy == "mean": + return torch.ones(n_candidate_facets, device=device) + + elif aggregation_strategy == "area_weighted": + if parent_cell_areas is None: + raise ValueError("parent_cell_areas required for area_weighted aggregation") + # Weight by parent cell area + return parent_cell_areas[parent_cell_indices] + + elif aggregation_strategy == "inverse_distance": + if parent_cell_centroids is None or facet_centroids is None: + raise ValueError( + "parent_cell_centroids and facet_centroids required for inverse_distance aggregation" + ) + # Weight by inverse distance from facet centroid to parent cell centroid + parent_centroids_for_facets = parent_cell_centroids[parent_cell_indices] + distances = torch.norm(facet_centroids - parent_centroids_for_facets, dim=-1) + # Avoid division by zero (facets exactly at parent centroid get high weight) + distances = distances.clamp(min=safe_eps(distances.dtype)) + return 1.0 / distances + + else: + raise ValueError( + f"Invalid {aggregation_strategy=}. " + f"Must be one of: 'mean', 'area_weighted', 'inverse_distance'" + ) + + +def extract_facet_mesh_data( + parent_mesh: "Mesh", + manifold_codimension: int = 1, + data_source: Literal["points", "cells"] = "cells", + data_aggregation: Literal["mean", "area_weighted", "inverse_distance"] = "mean", + target_counts: list[int] | Literal["boundary", "shared", "interior", "all"] = "all", +) -> tuple[torch.Tensor, TensorDict]: + """Extract facet mesh data from parent mesh. + + Main entry point that orchestrates facet extraction, deduplication, and data + aggregation. Optionally filters facets by occurrence count before aggregation. + + Parameters + ---------- + parent_mesh : Mesh + The parent mesh to extract facets from + manifold_codimension : int, optional + Codimension of extracted mesh relative to parent (default 1) + data_source : {"points", "cells"}, optional + Whether to inherit data from "cells" or "points" + data_aggregation : {"mean", "area_weighted", "inverse_distance"}, optional + How to aggregate data from multiple sources + target_counts : list[int] | {"boundary", "shared", "interior", "all"}, optional + Which facets to keep based on how many parent cells share them: + + - ``"all"`` (default): keep every unique facet + - ``"boundary"``: keep facets appearing in exactly 1 cell + - ``"interior"``: keep facets appearing in exactly 2 cells + - ``"shared"``: keep facets appearing in 2+ cells + - ``list[int]``: keep facets whose count is in the list + + Returns + ------- + facet_cells : torch.Tensor + Connectivity for facet mesh, shape (n_unique_facets, n_vertices_per_facet) + facet_cell_data : TensorDict + Aggregated TensorDict for facet mesh cells + + Examples + -------- + >>> from physicsnemo.mesh.primitives.procedural import lumpy_ball + >>> vol_mesh = lumpy_ball.load(n_shells=2, subdivisions=1) + >>> # Extract ALL codim-1 facets (interior + boundary) + >>> all_facets, all_data = extract_facet_mesh_data(vol_mesh) + >>> # Extract only the boundary surface + >>> bnd_facets, bnd_data = extract_facet_mesh_data( + ... vol_mesh, target_counts="boundary" + ... ) + >>> assert bnd_facets.shape[0] <= all_facets.shape[0] + """ + ### Extract candidate facets from parent cells + candidate_facets, parent_cell_indices = extract_candidate_facets( + parent_mesh.cells, + manifold_codimension=manifold_codimension, + ) + + ### Deduplicate, optionally filtering by occurrence count + if target_counts == "all": + unique_facets, inverse_indices = torch.unique( + candidate_facets, + dim=0, + return_inverse=True, + ) + else: + unique_facets, inverse_indices, _ = categorize_facets_by_count( + candidate_facets, + target_counts=target_counts, + ) + # Discard candidates that were filtered out (inverse == -1) + keep_mask = inverse_indices >= 0 + candidate_facets = candidate_facets[keep_mask] + parent_cell_indices = parent_cell_indices[keep_mask] + inverse_indices = inverse_indices[keep_mask] + + n_unique_facets = len(unique_facets) + + ### Initialize empty output TensorDict + facet_cell_data = TensorDict( + {}, + batch_size=torch.Size([n_unique_facets]), + device=parent_mesh.points.device, + ) + + if data_source == "cells": + ### Aggregate data from parent cells + filtered_cell_data = parent_mesh.cell_data.exclude(CACHE_KEY) + + if len(filtered_cell_data.keys()) > 0: + ### Compute facet centroids if needed for inverse_distance + facet_centroids = None + if data_aggregation == "inverse_distance": + facet_points = parent_mesh.points[candidate_facets] + facet_centroids = facet_points.mean(dim=1) + + ### Prepare parent cell areas and centroids if needed + parent_cell_areas = None + parent_cell_centroids = None + + if data_aggregation == "area_weighted": + parent_cell_areas = parent_mesh.cell_areas + if data_aggregation == "inverse_distance": + parent_cell_centroids = parent_mesh.cell_centroids + + ### Compute aggregation weights + weights = compute_aggregation_weights( + aggregation_strategy=data_aggregation, + parent_cell_areas=parent_cell_areas, + parent_cell_centroids=parent_cell_centroids, + facet_centroids=facet_centroids, + parent_cell_indices=parent_cell_indices, + ) + + ### Aggregate data from parent cells to unique facets + facet_cell_data = filtered_cell_data.apply( + lambda tensor: _aggregate_tensor_data( + tensor, + parent_cell_indices, + inverse_indices, + n_unique_facets, + weights, + ), + batch_size=torch.Size([n_unique_facets]), + ) + + elif data_source == "points": + ### Aggregate data from facet vertices + if len(parent_mesh.point_data.exclude(CACHE_KEY).keys()) > 0: + facet_cell_data = _aggregate_point_data_to_facets( + point_data=parent_mesh.point_data, + candidate_facets=candidate_facets, + inverse_indices=inverse_indices, + n_unique_facets=n_unique_facets, + ) + + else: + raise ValueError(f"Invalid {data_source=}. Must be one of: 'points', 'cells'") + + return unique_facets, facet_cell_data + + +def _aggregate_point_data_to_facets( + point_data: TensorDict, + candidate_facets: torch.Tensor, + inverse_indices: torch.Tensor, + n_unique_facets: int, +) -> TensorDict: + """Aggregate point data to facets by averaging over facet vertices. + + Parameters + ---------- + point_data : TensorDict + Data at points + candidate_facets : torch.Tensor + Candidate facet connectivity + inverse_indices : torch.Tensor + Mapping from candidate to unique facets + n_unique_facets : int + Number of unique facets + + Returns + ------- + TensorDict + Facet cell data (averaged from points) + """ + + def _aggregate_point_tensor(tensor: torch.Tensor) -> torch.Tensor: + """Aggregate a single tensor from points to facets.""" + from physicsnemo.mesh.utilities._scatter_ops import scatter_aggregate + + ### Gather point data for vertices of each candidate facet + # Shape: (n_candidate_facets, n_vertices_per_facet, *data_shape) + facet_point_data = tensor[candidate_facets] + + ### Average over vertices to get candidate facet data + # Shape: (n_candidate_facets, *data_shape) + candidate_facet_data = facet_point_data.mean(dim=1) + + ### Aggregate to unique facets using scatter_aggregate + return scatter_aggregate( + src_data=candidate_facet_data, + src_to_dst_mapping=inverse_indices, + n_dst=n_unique_facets, + aggregation="mean", + ) + + ### Use TensorDict.apply() to handle nested structure automatically + return point_data.apply( + _aggregate_point_tensor, + batch_size=torch.Size([n_unique_facets]), + ) diff --git a/physicsnemo/mesh/boundaries/_topology.py b/physicsnemo/mesh/boundaries/_topology.py new file mode 100644 index 0000000000..3cc1a170f7 --- /dev/null +++ b/physicsnemo/mesh/boundaries/_topology.py @@ -0,0 +1,574 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Topology validation for simplicial meshes. + +This module provides functions to check topological properties of meshes: +- Watertight checking: mesh has no boundary (all facets shared by exactly 2 cells) +- Manifold checking: mesh is a valid topological manifold +""" + +from typing import TYPE_CHECKING, Literal + +import torch + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def is_watertight(mesh: "Mesh") -> bool: + """Check if mesh is watertight (has no boundary). + + A mesh is watertight if every codimension-1 facet is shared by exactly 2 cells. + This means the mesh forms a closed surface/volume with no holes or gaps. + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh to check + + Returns + ------- + bool + True if mesh is watertight (no boundary facets), False otherwise + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral, cylinder_open + >>> # Closed sphere is watertight + >>> sphere = sphere_icosahedral.load(subdivisions=3) + >>> assert is_watertight(sphere) == True + >>> + >>> # Open cylinder with holes at ends + >>> cylinder = cylinder_open.load() + >>> assert is_watertight(cylinder) == False + """ + from physicsnemo.mesh.boundaries._facet_extraction import ( + categorize_facets_by_count, + extract_candidate_facets, + ) + + ### Empty mesh is considered watertight + if mesh.n_cells == 0: + return True + + ### Extract all codimension-1 facets + candidate_facets, _ = extract_candidate_facets( + mesh.cells, + manifold_codimension=1, + ) + + ### Deduplicate and get counts + _, _, counts = categorize_facets_by_count(candidate_facets, target_counts="all") + + ### Watertight iff all facets appear exactly twice + # Each facet should be shared by exactly 2 cells + return bool(torch.all(counts == 2)) + + +def is_manifold( + mesh: "Mesh", + check_level: Literal["facets", "edges", "full"] = "full", +) -> bool: + """Check if mesh is a valid topological manifold. + + A mesh is a manifold if it locally looks like Euclidean space at every point. + This function checks various topological constraints depending on the check level. + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh to check + check_level : {"facets", "edges", "full"}, optional + Level of checking to perform: + - "facets": Only check codimension-1 facets (each appears 1-2 times) + - "edges": Check facets + edge neighborhoods (for 2D/3D meshes) + - "full": Complete manifold validation (default) + + Returns + ------- + bool + True if mesh passes the specified manifold checks, False otherwise + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral, cylinder_open + >>> # Valid manifold (sphere) + >>> sphere = sphere_icosahedral.load(subdivisions=3) + >>> assert is_manifold(sphere) == True + >>> + >>> # Manifold with boundary (open cylinder) + >>> cylinder = cylinder_open.load() + >>> assert is_manifold(cylinder) == True # manifold with boundary is OK + + Notes + ----- + This function checks topological constraints but does not check for + geometric self-intersections (which would require expensive spatial queries). + """ + ### Empty mesh is considered a valid manifold + if mesh.n_cells == 0: + return True + + ### Check facets (codimension-1) + if not _check_facets_manifold(mesh): + return False + + if check_level == "facets": + return True + + ### Check edges (for 2D and 3D meshes) + if mesh.n_manifold_dims >= 2: + if not _check_edges_manifold(mesh): + return False + + if check_level == "edges": + return True + + ### Full check includes vertices (for 2D and 3D meshes) + if mesh.n_manifold_dims >= 2: + if not _check_vertices_manifold(mesh): + return False + + return True + + +def _check_facets_manifold(mesh: "Mesh") -> bool: + """Check if facets satisfy manifold constraints. + + For a manifold (possibly with boundary), each codimension-1 facet must appear + in at most 2 cells. Facets appearing once are on the boundary; facets appearing + twice are interior. + + Parameters + ---------- + mesh : Mesh + Input mesh + + Returns + ------- + bool + True if facets satisfy manifold constraints + """ + from physicsnemo.mesh.boundaries._facet_extraction import ( + categorize_facets_by_count, + extract_candidate_facets, + ) + + ### Extract all codimension-1 facets + candidate_facets, _ = extract_candidate_facets( + mesh.cells, + manifold_codimension=1, + ) + + ### Deduplicate and get counts + _, _, counts = categorize_facets_by_count(candidate_facets, target_counts="all") + + ### For manifold: each facet appears at most twice (1 = boundary, 2 = interior) + # If any facet appears 3+ times, it's a non-manifold edge + return bool(torch.all(counts <= 2)) + + +def _check_edges_manifold(mesh: "Mesh") -> bool: + """Check if edges satisfy manifold constraints. + + For 2D manifolds (triangles): Each edge should be shared by at most 2 triangles. + For 3D manifolds (tetrahedra): Each edge should have a valid "link" - the + codimension-1 faces (triangles) incident to the edge must form a single + connected chain (boundary edge) or cycle (interior edge). Two faces + containing the same edge are adjacent when their parent tets share a + codimension-1 facet that also contains the edge - equivalently, when the + two faces share a vertex besides the edge's two endpoints. + + Parameters + ---------- + mesh : Mesh + Input mesh (must have n_manifold_dims >= 2) + + Returns + ------- + bool + True if edges satisfy manifold constraints + """ + ### For 2D meshes, edges are codimension-1, already checked in _check_facets_manifold + if mesh.n_manifold_dims == 2: + return True + + ### For 3D meshes, verify edge-link connectivity + if mesh.n_manifold_dims == 3: + return _check_3d_edge_link_connectivity(mesh) + + ### For higher dimensions, we don't have specific checks yet + return True + + +def _check_3d_edge_link_connectivity(mesh: "Mesh") -> bool: + """Check that the face-link around every edge is connected (3D meshes). + + For each edge in a 3D tetrahedral mesh, collect every codimension-1 + face (triangle) that contains the edge. Two such faces are "link- + adjacent" when they share a third vertex (the non-edge vertex of each + face) via their parent tets sharing a triangular face that contains + the edge. All the faces around an edge must form a single connected + component; a disconnected link indicates a non-manifold edge. + + The implementation is fully vectorized via union-find, following the + same pattern used in ``_check_3d_vertex_manifold``. + + Parameters + ---------- + mesh : Mesh + Input 3D tetrahedral mesh. + + Returns + ------- + bool + True if every edge has a connected face-link. + """ + from physicsnemo.mesh.boundaries._facet_extraction import extract_candidate_facets + + device = mesh.cells.device + + ### Step 1: Extract candidate edges and their parent tets + candidate_edges, parent_cell_indices = extract_candidate_facets( + mesh.cells, + manifold_codimension=2, + ) + # candidate_edges: (n_candidate_edges, 2), parent_cell_indices: (n_candidate_edges,) + + ### Step 2: Map each candidate edge to a unique edge index + unique_edges, edge_inverse = torch.unique( + candidate_edges, + dim=0, + return_inverse=True, + ) + n_unique_edges = len(unique_edges) + n_candidates = len(candidate_edges) + + if n_unique_edges == 0: + return True + + ### Step 3: For each candidate edge, find the "third vertex" of the parent + # tet that is NOT one of the edge's two endpoints. In a tet (4 vertices) + # with an edge occupying 2, there are 2 remaining vertices. Each such + # (edge, third_vertex) triple identifies one face of the tet that contains + # the edge. Two candidate edges that map to the same unique edge and + # share a third vertex came from tets that share a face containing the + # edge - making their link-faces adjacent. + + tet_verts = mesh.cells[parent_cell_indices] # (n_candidates, 4) + edge_v0 = candidate_edges[:, 0].unsqueeze(1) # (n_candidates, 1) + edge_v1 = candidate_edges[:, 1].unsqueeze(1) # (n_candidates, 1) + + # Mask: which columns of each tet are NOT part of the edge + not_edge = (tet_verts != edge_v0) & (tet_verts != edge_v1) # (n_candidates, 4) + + # Extract the two non-edge vertices per candidate. + # not_edge has exactly 2 True values per row (for non-degenerate tets). + # Collect them into a (n_candidates, 2) tensor. + # Use a scatter trick: for each row, the True columns give the third vertices. + third_verts = tet_verts[not_edge].reshape(n_candidates, -1) # (n_candidates, 2) + + # If a tet is degenerate (edge vertex appears >2 times), third_verts may + # have fewer than 2 columns. Skip the check for such edges. + if third_verts.shape[1] < 2: + return True + + ### Step 4: Build adjacency between candidates that share both the same + # unique edge AND at least one third vertex. Two candidates (c_a, c_b) + # are adjacent when edge_inverse[c_a] == edge_inverse[c_b] and they share + # a third vertex. + # + # Strategy: for each (unique_edge_id, third_vertex) pair, group the + # candidates that have that pair and union consecutive members. + + # Expand: each candidate contributes two (edge_id, third_vert) keys. + # Use repeat_interleave so that entries i*2 and i*2+1 both correspond + # to candidate i (matching the interleaved layout of flatten()). + edge_ids_2x = edge_inverse.repeat_interleave(2) # (2 * n_candidates,) + third_verts_flat = third_verts.flatten() # (2 * n_candidates,) + cand_indices_2x = torch.arange(n_candidates, device=device).repeat_interleave(2) + + # Use lexicographic sort via two stable argsorts to avoid integer overflow + order = torch.argsort(third_verts_flat.long(), stable=True) + order = order[torch.argsort(edge_ids_2x[order].long(), stable=True)] + + sorted_cand = cand_indices_2x[order] + sorted_edge_ids = edge_ids_2x[order] + sorted_third_verts = third_verts_flat[order] + + # Consecutive entries with the same (edge_id, third_vertex) pair + # are candidates sharing a link-adjacent face. + same_key = (sorted_edge_ids[:-1] == sorted_edge_ids[1:]) & ( + sorted_third_verts[:-1] == sorted_third_verts[1:] + ) + pair_a = sorted_cand[:-1][same_key] + pair_b = sorted_cand[1:][same_key] + + ### Step 5: Union-find over candidates to find connected components per edge + from physicsnemo.mesh.utilities._duplicate_detection import ( + vectorized_connected_components, + ) + + pairs = torch.stack([pair_a, pair_b], dim=1) + labels = vectorized_connected_components(pairs, n_candidates) + + ### Step 6: Check single connected component per unique edge. + # For each unique edge, all candidate entries must share the same root. + min_labels = torch.full( + (n_unique_edges,), + n_candidates, + dtype=torch.long, + device=device, + ) + max_labels = torch.zeros(n_unique_edges, dtype=torch.long, device=device) + min_labels.scatter_reduce_(0, edge_inverse, labels, reduce="amin") + max_labels.scatter_reduce_(0, edge_inverse, labels, reduce="amax") + + # Count candidates per edge to identify edges with 2+ tets (others are + # trivially connected since they have a single candidate). + edge_counts = torch.zeros(n_unique_edges, dtype=torch.long, device=device) + edge_counts.scatter_add_(0, edge_inverse, torch.ones_like(edge_inverse)) + multi = edge_counts >= 2 + + return bool(torch.all(min_labels[multi] == max_labels[multi])) + + +def _check_vertices_manifold(mesh: "Mesh") -> bool: + """Check if vertices satisfy manifold constraints. + + For a manifold, the link of each vertex (the set of cells incident to the vertex) + must form a valid topological structure: + - For 2D: The edges around each vertex form a single cycle or fan + - For 3D: The faces around each vertex form a single connected surface + + Parameters + ---------- + mesh : Mesh + Input mesh (must have n_manifold_dims >= 2) + + Returns + ------- + bool + True if vertices satisfy manifold constraints + """ + ### For 2D meshes, check that edges around each vertex form a valid fan/cycle + if mesh.n_manifold_dims == 2: + return _check_2d_vertex_manifold(mesh) + + ### For 3D meshes, check that faces around each vertex form a connected surface + if mesh.n_manifold_dims == 3: + return _check_3d_vertex_manifold(mesh) + + ### For other dimensions, no specific check + return True + + +def _check_2d_vertex_manifold(mesh: "Mesh") -> bool: + """Check vertex manifold constraints for 2D meshes. + + For a 2D triangular mesh to be manifold at a vertex, the triangles around the + vertex must form a single fan (for boundary vertices) or a complete cycle + (for interior vertices). + + Parameters + ---------- + mesh : Mesh + 2D triangular mesh + + Returns + ------- + bool + True if all vertices satisfy 2D manifold constraints + """ + from physicsnemo.mesh.boundaries._facet_extraction import extract_candidate_facets + + ### Extract edges (codimension-1 for 2D) + candidate_edges, parent_cell_indices = extract_candidate_facets( + mesh.cells, + manifold_codimension=1, + ) + + ### Find unique edges + unique_edges, inverse_indices, edge_counts = torch.unique( + candidate_edges, + dim=0, + return_inverse=True, + return_counts=True, + ) + + ### For each vertex, count how many boundary edges are incident + # In a manifold with boundary, each boundary vertex should have exactly 2 boundary edges + # In a closed manifold, no vertex should have boundary edges + + boundary_edge_mask = edge_counts == 1 + boundary_edges = unique_edges[boundary_edge_mask] + + if len(boundary_edges) > 0: + ### Count boundary edges per vertex + vertex_boundary_count = torch.zeros( + mesh.n_points, dtype=torch.int64, device=mesh.cells.device + ) + vertex_boundary_count.scatter_add_( + dim=0, + index=boundary_edges.flatten(), + src=torch.ones( + boundary_edges.numel(), dtype=torch.int64, device=mesh.cells.device + ), + ) + + ### Each boundary vertex should have exactly 2 boundary edges (forms a chain) + # Non-boundary vertices should have 0 + valid_counts = (vertex_boundary_count == 0) | (vertex_boundary_count == 2) + if not torch.all(valid_counts): + return False + + return True + + +def _check_3d_vertex_manifold(mesh: "Mesh") -> bool: + """Check vertex manifold constraints for 3D tetrahedral meshes. + + For a 3D mesh to be manifold at vertex v, the **link** of v must be + connected. The link at v consists of one triangular face per incident + tetrahedron (the face opposite to v, formed by the tet's other 3 + vertices). Two link faces are adjacent if their parent tets share a + triangular face that contains v - equivalently, if their non-v vertex + sets share exactly 2 vertices (an edge). + + A disconnected link indicates a **pinch point**: two groups of + tetrahedra meeting at a single vertex without sharing any face that + contains it. This is the primary non-manifold vertex configuration not + caught by the facet and edge checks. + + This implementation is fully vectorized (no Python loops over vertices), + following the union-find pattern from + :func:`~physicsnemo.mesh.utilities._duplicate_detection.compute_canonical_indices`. + + Parameters + ---------- + mesh : Mesh + Input 3D tetrahedral mesh. + + Returns + ------- + bool + True if all vertices have connected links (manifold at all vertices). + """ + from physicsnemo.mesh.neighbors import get_point_to_cells_adjacency + + device = mesh.cells.device + + p2c = get_point_to_cells_adjacency(mesh) + + ### Step 1: Expand p2c to all (vertex_id, tet_id) pairs + vertex_ids, tet_ids = p2c.expand_to_pairs() # both shape (total_pairs,) + total = len(vertex_ids) + if total == 0: + return True + + ### Step 2: Extract link faces (3 non-v vertices per incident tet) + tet_verts = mesh.cells[tet_ids] # (total, 4) + + # Find which column of each tet holds the vertex v + # (total, 4) == (total, 1) -> bool mask, argmax gives first True column + v_col = (tet_verts == vertex_ids.unsqueeze(1)).byte().argmax(dim=1) # (total,) + + # Detect degenerate tets (vertex appears more than once) + v_occurrence_count = (tet_verts == vertex_ids.unsqueeze(1)).sum(dim=1) + is_degenerate = v_occurrence_count > 1 + + # Precomputed lookup: given v is at column c, take columns COL_MAP[c] + _COL_MAP = torch.tensor( + [[1, 2, 3], [0, 2, 3], [0, 1, 3], [0, 1, 2]], + dtype=torch.long, + device=device, + ) + gather_cols = _COL_MAP[v_col] # (total, 3) + link_faces = torch.gather(tet_verts, 1, gather_cols) # (total, 3) + + # Sort each link face for canonical ordering + link_faces, _ = torch.sort(link_faces, dim=1) + + ### Step 3: Generate all edges of all link faces + # Each sorted face (a, b, c) gives edges: (a,b), (a,c), (b,c) + edge_ab = link_faces[:, :2] # (total, 2) -> columns 0,1 + edge_ac = link_faces[:, [0, 2]] # (total, 2) -> columns 0,2 + edge_bc = link_faces[:, 1:] # (total, 2) -> columns 1,2 + + all_edges = torch.cat([edge_ab, edge_ac, edge_bc], dim=0) # (3*total, 2) + + # Matching vertex_ids and face indices, repeated 3x + face_indices = torch.arange(total, device=device) + vertex_ids_3x = vertex_ids.repeat(3) # (3*total,) + face_indices_3x = face_indices.repeat(3) # (3*total,) + + ### Step 4: Find pairs of link faces sharing an edge at the same vertex + # Sort by composite key (vertex_id, edge_v0, edge_v1) to group identical + # (vertex, edge) tuples together. Consecutive entries sharing a key are + # face pairs connected via that edge. + # Use lexicographic sort via three stable argsorts to avoid integer overflow + order = torch.argsort(all_edges[:, 1], stable=True) + order = order[torch.argsort(all_edges[order, 0], stable=True)] + order = order[torch.argsort(vertex_ids_3x[order], stable=True)] + + sorted_face_idx = face_indices_3x[order] + sorted_vertex_ids = vertex_ids_3x[order] + sorted_edges = all_edges[order] + + # Adjacent entries with the same (vertex_id, edge_v0, edge_v1) are face pairs + same_key = ( + (sorted_vertex_ids[:-1] == sorted_vertex_ids[1:]) + & (sorted_edges[:-1, 0] == sorted_edges[1:, 0]) + & (sorted_edges[:-1, 1] == sorted_edges[1:, 1]) + ) + pair_f1 = sorted_face_idx[:-1][same_key] + pair_f2 = sorted_face_idx[1:][same_key] + + if len(pair_f1) == 0: + # No shared edges at all - each link face is isolated. + # Vertices with 0 or 1 incident tet are trivially manifold. + # Vertices with 2+ incident tets but no shared edges are non-manifold. + incident_counts = p2c.counts # (n_points,) + return bool(torch.all(incident_counts <= 1)) + + ### Step 5: Vectorized union-find (using shared utility) + from physicsnemo.mesh.utilities._duplicate_detection import ( + vectorized_connected_components, + ) + + pairs = torch.stack([pair_f1, pair_f2], dim=1) + labels = vectorized_connected_components(pairs, total) + + ### Step 6: Check single connected component per vertex + # For each vertex, all its link faces must share the same root label. + # Use scatter to find min and max label per vertex. + min_labels = torch.full((mesh.n_points,), total, dtype=torch.long, device=device) + max_labels = torch.zeros(mesh.n_points, dtype=torch.long, device=device) + + min_labels.scatter_reduce_(0, vertex_ids, labels, reduce="amin") + max_labels.scatter_reduce_(0, vertex_ids, labels, reduce="amax") + + # Only check vertices with 2+ incident tets (others are trivially manifold) + incident_counts = p2c.counts # (n_points,) + multi_incident = incident_counts >= 2 + + # Also exclude degenerate vertices from the check + degenerate_per_vertex = torch.zeros(mesh.n_points, dtype=torch.bool, device=device) + degenerate_per_vertex.scatter_(0, vertex_ids[is_degenerate], True) + + check_mask = multi_incident & ~degenerate_per_vertex + return bool(torch.all(min_labels[check_mask] == max_labels[check_mask])) diff --git a/physicsnemo/mesh/calculus/README.md b/physicsnemo/mesh/calculus/README.md new file mode 100644 index 0000000000..29d3d7ca4f --- /dev/null +++ b/physicsnemo/mesh/calculus/README.md @@ -0,0 +1,530 @@ +# Discrete Calculus on Simplicial Meshes + +## Overview + +This module implements differential operators (gradient, divergence, curl, +Laplacian) for simplicial meshes using two complementary approaches: + +1. **Discrete Exterior Calculus (DEC)** - Rigorous differential geometry + framework based on Desbrun et al. (2005) and Hirani (2003) +2. **Weighted Least-Squares (LSQ)** - Practical CFD/FEM approach for general + use cases + +--- + +## Discrete Exterior Calculus (DEC) + +DEC provides a mathematically rigorous framework where discrete operators +satisfy exact discrete versions of continuous theorems (Stokes, Gauss-Bonnet, +etc.). + +### Core DEC Operators + +#### Laplace-Beltrami Operator + +```python +from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + +# Intrinsic Laplacian: Δf(v) = -(1/|⋆v|) Σ (|⋆e|/|e|)(f_neighbor - f_v) +laplacian = compute_laplacian_points_dec(mesh, scalar_field) +``` + +**Properties**: + +- Uses cotangent weights derived from the FEM stiffness matrix (see below) +- In 2D: equivalent to `(1/2)(cot α + cot β)` (Meyer Eq. 5) +- In 1D: gives `1/|edge|` (standard finite-difference second derivative) +- In 3D+: gives exact dihedral-angle-based weights via Gram matrix inverse +- Normalized by circumcentric dual volumes (Voronoi cells) +- Exact for linear functions at interior vertices +- Works on manifolds of any dimension embedded in any ambient space + +**Cotangent weights via FEM stiffness matrix** (n-dimensional): + +For an n-simplex with vertices v₀, ..., vₙ, the cotangent weight for +edge (i, j) is: + +```text +w_ij = -|σ| × (∇λ_i · ∇λ_j) +``` + +where λ_i are barycentric coordinate functions and |σ| is the cell volume. +The gradient dot products are computed from the inverse Gram matrix: + +```text +E = [v₁-v₀, ..., vₙ-v₀] (edge matrix, n × d) +G = E @ E^T (Gram matrix, n × n) +∇λ_k · ∇λ_l = (G⁻¹)_{k-1,l-1} for k, l ≥ 1 +``` + +This generalizes the classical 2D cotangent formula to arbitrary dimensions. + +**Reference**: Hirani (2003) Eq. 6.4.2, Meyer et al. (2003) Eq. 8 + +#### Exterior Derivative + +```python +from physicsnemo.mesh.calculus._exterior_derivative import ( + exterior_derivative_0, + exterior_derivative_1, +) + +# d: Ω⁰ → Ω¹ (0-forms to 1-forms) +# df([vi,vj]) = f(vj) - f(vi) +edge_1form, edges = exterior_derivative_0(mesh, vertex_values) + +# d: Ω¹ → Ω² (1-forms to 2-forms) +# Circulation around faces +face_2form, faces = exterior_derivative_1(mesh, edge_1form, edges) +``` + +**Properties**: + +- `d ∘ d = 0` (exact by construction) +- Discrete Stokes theorem: `⟨dα, c⟩ = ⟨α, ∂c⟩` (true by definition) + +**Reference**: Desbrun et al. (2005) Section 3, Hirani (2003) Chapter 3 + +#### Hodge Star + +```python +from physicsnemo.mesh.calculus._hodge_star import hodge_star_0, hodge_star_1 + +# ⋆: Ω⁰ → Ωⁿ (vertex values to dual n-cells) +star_f = hodge_star_0(mesh, f) # ⋆f(⋆v) = f(v) × |⋆v| +``` + +**Properties**: + +- Preserves averages: `⟨α, σ⟩/|σ| = ⟨⋆α, ⋆σ⟩/|⋆σ|` +- `⋆⋆α = (-1)^(k(n-k)) α` +- Uses circumcentric (Voronoi) dual cells, NOT barycentric + +**Reference**: Hirani (2003) Def. 4.1.1, Desbrun et al. (2005) Section 4 + +#### Sharp and Flat Operators + +```python +from physicsnemo.mesh.calculus._sharp_flat import sharp, flat + +# ♯: Ω¹ → 𝔛 (1-forms to vector fields) +grad_vector = sharp(mesh, df, edges) + +# ♭: 𝔛 → Ω¹ (vector fields to 1-forms) +one_form = flat(mesh, vector_field, edges) +``` + +**Implementation**: + +- **Sharp (♯)**: Hirani Eq. 5.8.1 with support volume intersections and + barycentric gradients +- **Flat (♭)**: PDP-flat (Hirani Section 5.6) using averaged endpoint vectors + +**Note**: Sharp and flat are NOT exact inverses in discrete DEC (Hirani +Prop. 5.5.3). This is a fundamental property of the discrete theory, not a bug. + +**Reference**: Hirani (2003) Chapter 5 + +### Gradient via DEC + +```python +from physicsnemo.mesh.calculus.gradient import compute_gradient_points_dec + +# Computes: grad(f) = ♯(df) +grad_f = compute_gradient_points_dec(mesh, scalar_field) +``` + +Combines exterior derivative and sharp operator to produce gradient vector +field. + +--- + +## Weighted Least-Squares (LSQ) Methods + +LSQ methods provide general-purpose operators that work robustly on arbitrary +meshes. + +### Gradient + +```python +from physicsnemo.mesh.calculus.gradient import ( + compute_gradient_points_lsq, + compute_gradient_cells_lsq, +) + +# At vertices +grad = compute_gradient_points_lsq( + mesh, + scalar_field, + weight_power=2.0, # Inverse distance weighting + intrinsic=False # Set True for tangent-space gradients on manifolds +) + +# At cell centers +grad_cells = compute_gradient_cells_lsq(mesh, cell_values) +``` + +**Properties**: + +- Exact for constant and linear fields +- First-order accurate O(h) for smooth fields +- Supports intrinsic (tangent-space) computation for embedded manifolds +- Works for both scalar and tensor fields + +### Divergence + +```python +from physicsnemo.mesh.calculus.divergence import compute_divergence_points_lsq + +div_v = compute_divergence_points_lsq(mesh, vector_field) +``` + +Computes `div(v) = ∂vₓ/∂x + ∂vᵧ/∂y + ∂vᵧ/∂z` via component gradients. + +### Curl (3D Only) + +```python +from physicsnemo.mesh.calculus.curl import compute_curl_points_lsq + +curl_v = compute_curl_points_lsq(mesh, vector_field) # Requires n_spatial_dims = 3 +``` + +Computes curl from antisymmetric part of Jacobian matrix. + +--- + +## Circumcentric Dual Volumes (Voronoi Cells) + +### Implementation + +```python +from physicsnemo.mesh.geometry.dual_meshes import compute_dual_volumes_0 + +dual_vols = compute_dual_volumes_0(mesh) # |⋆v| for each vertex +``` + +**Algorithm** (dimension-specific): + +**1D manifolds (edges)**: + +- Each vertex gets half the length of each incident edge +- Exact for piecewise linear 1-manifolds + +**2D manifolds (triangles)**: + +- **Acute triangles**: Circumcentric Voronoi formula (Meyer Eq. 7) + +```text +|⋆v| = (1/8) Σ (||e||² cot(opposite_angle)) +``` + +- **Obtuse triangles**: Mixed area subdivision (Meyer Fig. 4) + +```text +If obtuse at vertex: |⋆v| = area(T)/2 +Otherwise: |⋆v| = area(T)/4 +``` + +**3D+ manifolds (tetrahedra, etc.)**: + +- Barycentric approximation: `|⋆v| = Σ |cell|/(n+1)` +- Note: Rigorous circumcentric dual requires "well-centered" meshes + (Desbrun 2005) + +**Property**: Perfect tiling: `Σ_vertices |⋆v| = |mesh|` (conservation holds +exactly) + +**References**: + +- Meyer et al. (2003) Sections 3.2-3.4 +- Desbrun et al. (2005) lines 286-395 +- Hirani (2003) Def. 2.4.5 + +--- + +### Known Behavior (Not Bugs) + +**div(grad(f)) ≈ Δf but not exactly**: + +- In discrete DEC, sharp (♯) and flat (♭) are NOT exact inverses (Hirani + Prop. 5.5.3) +- Therefore `div(grad(f))` and `Δf` may differ by ~2-3x on coarse meshes +- Both are O(h) accurate, difference → 0 as mesh refines +- This is a fundamental property of discrete exterior calculus + +**3D dual volumes use barycentric approximation**: + +- Rigorous circumcentric requires "well-centered" meshes (Desbrun 2005) +- Mixed volume formula for obtuse tetrahedra doesn't exist in literature +- Current barycentric approximation is standard practice and works well + +--- + +## API Reference + +### High-Level Interface + +```python +# Unified interface for derivatives +mesh_with_grad = mesh.compute_point_derivatives( + keys=['pressure', 'temperature'], + method='lsq', # or 'dec' for Laplacian only + gradient_type='extrinsic', # or 'intrinsic' for manifolds + weight_power=2.0, +) + +# Access results +grad_p = mesh_with_grad.point_data['pressure_gradient'] # (n_points, n_spatial_dims) +``` + +### Direct Operator Calls + +```python +from physicsnemo.mesh.calculus import ( + compute_gradient_points_lsq, + compute_divergence_points_lsq, + compute_curl_points_lsq, + compute_laplacian_points_dec, +) + +# Gradient (LSQ or DEC) +grad = compute_gradient_points_lsq(mesh, f, weight_power=2.0, intrinsic=False) +grad = compute_gradient_points_dec(mesh, f) # DEC method + +# Divergence +div = compute_divergence_points_lsq(mesh, vector_field) + +# Curl (3D only) +curl = compute_curl_points_lsq(mesh, vector_field) + +# Laplacian (DEC method) +laplacian = compute_laplacian_points_dec(mesh, scalar_field) +``` + +--- + +## Performance + +All operations are **fully vectorized** (no Python loops over mesh elements): + +- **Gradient/Divergence/Curl**: O(n_points × avg_degree) +- **Laplacian**: O(n_edges), very efficient +- **Dual volumes**: O(n_cells), one-time computation with caching + +**Memory**: Minimal overhead, intermediate results cached in `TensorDict` + +**Scaling**: Designed for massive meshes (100M+ points on GB200-class GPUs) + +--- + +## Module Structure + +```text +src/physicsnemo.mesh/calculus/ +├── __init__.py # Public API +├── derivatives.py # High-level interface (compute_point_derivatives) +├── gradient.py # Gradient (LSQ + DEC) +├── divergence.py # Divergence (LSQ + DEC) +├── curl.py # Curl (LSQ, 3D only) +├── laplacian.py # Laplace-Beltrami (DEC) +│ +├── _exterior_derivative.py # DEC: exterior derivative d +├── _hodge_star.py # DEC: Hodge star ⋆ +├── _sharp_flat.py # DEC: sharp ♯ and flat ♭ +│ +├── _lsq_reconstruction.py # LSQ: gradient reconstruction (ambient space) +└── _lsq_intrinsic.py # LSQ: intrinsic gradients (tangent space) +``` + +```text +src/physicsnemo.mesh/geometry/ +├── dual_meshes.py # Unified dual 0-cell volumes (Voronoi cells) +├── support_volumes.py # Support volume intersections for DEC +└── interpolation.py # Barycentric function gradients +``` + +--- + +## Usage Examples + +### Example 1: Laplace-Beltrami on Curved Surface + +```python +import torch +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + +# Create surface mesh (e.g., sphere, imported mesh, etc.) +mesh = ... # 2D surface in 3D + +# Add scalar field (e.g., temperature distribution) +temperature = mesh.point_data['temperature'] + +# Compute intrinsic Laplacian +laplacian = compute_laplacian_points_dec(mesh, temperature) + +# Use for diffusion: ∂T/∂t = κ Δ T +mesh.point_data['laplacian_T'] = laplacian +``` + +### Example 2: Gradient on Manifold (Intrinsic) + +```python +from physicsnemo.mesh.calculus.gradient import compute_gradient_points_lsq + +# Compute gradient in tangent space (for surface in 3D) +grad_intrinsic = compute_gradient_points_lsq( + mesh, + scalar_field, + intrinsic=True, # Solves in tangent space +) + +# Result is guaranteed perpendicular to surface normal +assert torch.allclose( + (grad_intrinsic * mesh.point_normals).sum(dim=-1), + torch.zeros(mesh.n_points), + atol=1e-6 +) +``` + +### Example 3: Vector Calculus Identities + +```python +from physicsnemo.mesh.calculus import ( + compute_gradient_points_lsq, + compute_divergence_points_lsq, + compute_curl_points_lsq, +) + +# Verify curl(grad(f)) = 0 +grad_f = compute_gradient_points_lsq(mesh, scalar_field) +curl_grad_f = compute_curl_points_lsq(mesh, grad_f) +assert torch.allclose(curl_grad_f, torch.zeros_like(curl_grad_f), atol=1e-5) + +# Verify div(curl(v)) = 0 +curl_v = compute_curl_points_lsq(mesh, vector_field) +div_curl_v = compute_divergence_points_lsq(mesh, curl_v) +assert torch.allclose(div_curl_v, torch.zeros_like(div_curl_v), atol=1e-5) +``` + +--- + +## Dimension Support + +| Operator | 1D | 2D | 3D | nD | +|----------|----|----|----|----| +| Gradient (LSQ) | ✓ | ✓ | ✓ | ✓ | +| Gradient (DEC) | ✓ | ✓ | ✓ | ✓ | +| Divergence | ✓ | ✓ | ✓ | ✓ | +| Curl (LSQ) | - | - | ✓ | - | +| Laplacian (DEC) | ✓ | ✓ | ✓† | - | +| Hodge star | ✓ | ✓ | ✓* | ✓* | + +*Uses barycentric approximation for n ≥ 3 + +†3D Laplacian uses an inverse-edge-length approximation rather than true +dihedral-angle cotangent weights. Accuracy degrades on poorly-shaped tetrahedra. +Not implemented for n > 3. + +--- + +## Choosing Between DEC and LSQ + +**Use DEC when**: + +- Need mathematically rigorous operators +- Working with differential geometry (curvatures, etc.) +- Require exact discrete theorems (Stokes, Gauss-Bonnet) +- Computing Laplacian on manifolds + +**Use LSQ when**: + +- Need general-purpose gradient/divergence/curl +- Working with irregular/poor-quality meshes +- Need robust performance on all mesh types +- Computing derivatives of tensor fields + +**Both methods**: + +- Are first-order accurate O(h) +- Work on irregular meshes +- Are fully vectorized +- Support GPU acceleration + +--- + +## Limitations and Future Work + +### Current Limitations + +1. **3D+ Dual Volumes**: Uses barycentric approximation (standard practice) + - Rigorous circumcentric requires "well-centered" meshes + - Mixed volume for obtuse tets is an open research problem + - The Laplacian cotangent *weights* are exact for all dimensions (via FEM + stiffness matrix); only the dual volume *normalization* uses approximation + +2. **Sharp/Flat Not Exact Inverses**: `♯ ∘ ♭ ≠ identity` in discrete DEC + - This is fundamental to discrete theory (Hirani Prop. 5.5.3) + - Causes `div(grad) ≈ Δ` (not exact) + +3. **Boundary Effects**: Cotangent Laplacian assumes complete 1-ring + neighborhoods + - Boundary vertices may show artifacts + - Set `include_boundary=False` in curvature computations + +### Future Enhancements + +1. **Well-centered mesh detection** for rigorous 3D dual volumes +2. **Additional DEC operators**: wedge product, interior product, Lie + derivative +3. **Higher-order LSQ** with extended stencils +4. **Convergence analysis**: Verify O(h²) error as mesh refines +5. **Alternative sharp/flat combinations** (DPP-flat, etc.) + +--- + +## Mathematical Foundations + +### Discrete Exterior Calculus + +- Exterior forms as cochains (Hirani Chapter 3) +- Circumcentric dual complexes (Desbrun Section 2, Hirani Section 2.4) +- Hodge star via volume ratios (Hirani Def. 4.1.1) +- Sharp/flat with support volumes (Hirani Chapter 5) + +### Discrete Differential Geometry + +- Meyer mixed Voronoi areas for curvature (Meyer Sections 3.2-3.4) +- Cotangent Laplacian for mean curvature (Meyer Eq. 8) +- Angle defect for Gaussian curvature (Meyer Eq. 9) + +### Key Theorems Preserved + +- Discrete Stokes theorem (exact) +- Gauss-Bonnet theorem (< 0.001% error numerically) +- Conservation of dual volumes (exact) +- Vector calculus identities: `curl ∘ grad = 0`, `div ∘ curl = 0` (exact) + +--- + +## References + +1. **Meyer, M., Desbrun, M., Schröder, P., & Barr, A. H.** (2003). "Discrete + Differential-Geometry Operators for Triangulated 2-Manifolds". *VisMath*. + - Sections 3.2-3.4: Mixed Voronoi areas + - Eq. 5: Cotangent weights + - Eq. 7: Circumcentric Voronoi formula + - Eq. 8-9: Mean and Gaussian curvature + +2. **Desbrun, M., Hirani, A. N., Leok, M., & Marsden, J. E.** (2005). + "Discrete Exterior Calculus". *arXiv:math/0508341v2*. + - Section 2: Circumcentric dual complexes + - Section 3-4: Exterior derivative and Hodge star + - Lines 268-275: Cotangent weight derivation + +3. **Hirani, A. N.** (2003). "Discrete Exterior Calculus". PhD thesis, + California Institute of Technology. + - Chapter 5: Sharp and flat operators + - Eq. 5.8.1: PP-sharp formula + - Eq. 6.4.2: Laplace-Beltrami + - Prop. 5.5.1: Support volume intersections diff --git a/physicsnemo/mesh/calculus/__init__.py b/physicsnemo/mesh/calculus/__init__.py new file mode 100644 index 0000000000..a80522d827 --- /dev/null +++ b/physicsnemo/mesh/calculus/__init__.py @@ -0,0 +1,52 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Discrete calculus operators for simplicial meshes. + +This module implements discrete differential operators using both: +1. Discrete Exterior Calculus (DEC) - rigorous differential geometry framework +2. Weighted Least-Squares (LSQ) reconstruction - standard CFD approach + +The DEC implementation follows Desbrun, Hirani, Leok, and Marsden's seminal work +on discrete exterior calculus (arXiv:math/0508341v2). + +Key operators: +- Gradient: ∇φ (scalar → vector) +- Divergence: div(v) (vector → scalar) +- Curl: curl(v) (vector → vector, 3D only) +- Laplacian: Δφ (scalar → scalar, Laplace-Beltrami operator) + +Both intrinsic (manifold tangent space) and extrinsic (ambient space) derivatives +are supported for manifolds embedded in higher-dimensional spaces. +""" + +from physicsnemo.mesh.calculus.curl import compute_curl_points_lsq +from physicsnemo.mesh.calculus.derivatives import ( + compute_cell_derivatives, + compute_point_derivatives, +) +from physicsnemo.mesh.calculus.divergence import ( + compute_divergence_points_dec, + compute_divergence_points_lsq, +) +from physicsnemo.mesh.calculus.gradient import ( + compute_gradient_cells_lsq, + compute_gradient_points_dec, + compute_gradient_points_lsq, +) +from physicsnemo.mesh.calculus.laplacian import ( + compute_laplacian_points_dec, +) diff --git a/physicsnemo/mesh/calculus/_exterior_derivative.py b/physicsnemo/mesh/calculus/_exterior_derivative.py new file mode 100644 index 0000000000..2f03f899bb --- /dev/null +++ b/physicsnemo/mesh/calculus/_exterior_derivative.py @@ -0,0 +1,229 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Discrete exterior derivative operators for DEC. + +The exterior derivative d maps k-forms to (k+1)-forms. In the discrete setting, +d is the coboundary operator, dual to the boundary operator ∂. + +Fundamental property: d² = 0 (applying d twice always gives zero) + +This implements the discrete Stokes theorem exactly: + ⟨dα, c⟩ = ⟨α, ∂c⟩ (true by definition) + +Reference: Desbrun et al., "Discrete Exterior Calculus", Section 3 +""" + +from typing import TYPE_CHECKING + +import torch + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def exterior_derivative_0( + mesh: "Mesh", + vertex_0form: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor]: + """Compute exterior derivative of 0-form (function on vertices). + + Maps Ω⁰(K) → Ω¹(K): takes vertex values to edge values. + + For an oriented edge [v_i, v_j]: + df([v_i, v_j]) = f(v_j) - f(v_i) + + This is the discrete gradient, represented as a 1-form on edges. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + vertex_0form : torch.Tensor + Values at vertices, shape (n_points,) or (n_points, ...) + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + Tuple of (edge_values, edge_connectivity): + - edge_values: 1-form values on edges, shape (n_edges,) or (n_edges, ...) + - edge_connectivity: Edge vertex indices, shape (n_edges, 2) + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> f = torch.randn(mesh.n_points) # scalar field at vertices + >>> edge_df, edges = exterior_derivative_0(mesh, f) + >>> # edge_df[i] = f[edges[i,1]] - f[edges[i,0]] + """ + ### Extract edges from mesh + # Get 1-skeleton (edge mesh) from the full mesh + # For triangle mesh: edges are 1-simplices (codimension 1 of 2-simplex) + # For tet mesh: edges are also needed + + # Use get_facet_mesh to extract edges (codimension = n_manifold_dims - 1) + # This gives us (n-1)-dimensional facets, but we want 1-simplices (edges) + # So we need codimension to get to dimension 1 + + if mesh.n_manifold_dims >= 1: + # Extract 1-simplices (edges) + codim_to_edges = mesh.n_manifold_dims - 1 + edge_mesh = mesh.get_facet_mesh( + manifold_codimension=codim_to_edges, + data_source="cells", + ) + edges = edge_mesh.cells # (n_edges, 2) + else: + # 0-manifold (point cloud): no edges + edges = torch.empty((0, 2), dtype=torch.long, device=mesh.cells.device) + + ### Compute oriented difference along each edge + # df(edge) = f(v₁) - f(v₀) + # Edge ordering: we use canonical ordering (sorted vertices) + + # Ensure edges are canonically ordered (smaller index first) + # This is important for consistent orientation + sorted_edges, sort_indices = torch.sort(edges, dim=-1) + + # Compute differences (indexing works for any ndim) + edge_values = vertex_0form[sorted_edges[:, 1]] - vertex_0form[sorted_edges[:, 0]] + + return edge_values, sorted_edges + + +def exterior_derivative_1( + mesh: "Mesh", + edge_1form: torch.Tensor, + edges: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor]: + """Compute exterior derivative of 1-form (values on edges). + + Maps Ω¹(K) → Ω²(K): takes edge values to face values (2-cells or higher). + + For a 2-simplex (triangle) with boundary edges [v₀,v₁], [v₁,v₂], [v₂,v₀]: + dα(triangle) = α([v₁,v₂]) - α([v₀,v₂]) + α([v₀,v₁]) + + This implements the discrete curl in 2D, or the circulation around faces. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + edge_1form : torch.Tensor + Values on edges, shape (n_edges,) or (n_edges, ...) + edges : torch.Tensor + Edge connectivity, shape (n_edges, 2) + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + Tuple of (face_values, face_connectivity): + - face_values: 2-form values on 2-simplices, shape (n_faces,) or (n_faces, ...) + - face_connectivity: Face vertex indices + + Notes + ----- + For n_manifold_dims = 2 (triangle mesh), faces are the triangles themselves. + For n_manifold_dims = 3 (tet mesh), faces are the triangular facets. + """ + if mesh.n_manifold_dims < 2: + # Cannot compute d₁ for manifolds of dimension < 2 + raise ValueError( + f"exterior_derivative_1 requires n_manifold_dims >= 2, got {mesh.n_manifold_dims=}" + ) + + ### Get 2-skeleton (faces) + if mesh.n_manifold_dims == 2: + # For triangle mesh, the 2-cells are the triangles themselves + faces = mesh.cells # (n_cells, 3) + n_faces = mesh.n_cells + else: + # For higher-dimensional meshes, extract 2-simplices + codim_to_faces = mesh.n_manifold_dims - 2 + face_mesh = mesh.get_facet_mesh( + manifold_codimension=codim_to_faces, + data_source="cells", + ) + faces = face_mesh.cells # (n_faces, 3) + n_faces = face_mesh.n_cells + + ### Extract all boundary edges from all faces (vectorized) + # For each triangular face [v₀, v₁, v₂], extract edges [v₀,v₁], [v₁,v₂], [v₂,v₀] + # Shape: (n_faces, 3, 2) where 3 is the number of edges per triangle + boundary_edges = torch.stack( + [ + faces[:, [0, 1]], # edge from v₀ to v₁ + faces[:, [1, 2]], # edge from v₁ to v₂ + faces[:, [2, 0]], # edge from v₂ to v₀ + ], + dim=1, + ) # (n_faces, 3, 2) + + # Flatten to (n_faces*3, 2) for easier processing + boundary_edges_flat = boundary_edges.reshape(-1, 2) # (n_faces*3, 2) + + ### Find each boundary edge in the reference edge list + from physicsnemo.mesh.utilities._edge_lookup import find_edges_in_reference + + edge_indices, matches = find_edges_in_reference( + edges, boundary_edges_flat + ) # edge_indices: (n_faces*3,), matches: (n_faces*3,) + + ### Determine orientation of each boundary edge + # If edge is [v_i, v_j] with v_i < v_j, orientation is +1 + # If edge is [v_i, v_j] with v_i > v_j, orientation is -1 (reversed) + orientations = torch.where( + boundary_edges_flat[:, 0] < boundary_edges_flat[:, 1], + torch.ones( + boundary_edges_flat.shape[0], + dtype=edge_1form.dtype, + device=edge_1form.device, + ), + -torch.ones( + boundary_edges_flat.shape[0], + dtype=edge_1form.dtype, + device=edge_1form.device, + ), + ) # (n_faces*3,) + + ### Compute contributions from each edge, respecting orientation + # Get the edge values for all boundary edges + edge_values = edge_1form[edge_indices] # (n_faces*3,) or (n_faces*3, ...) + + # Broadcast orientations and matches to match the shape of edge_values + # Add singleton dimensions to the right to match any trailing dimensions + orientations_broadcast = orientations.reshape( + -1, *([1] * (edge_values.ndim - 1)) + ) # (n_faces*3, 1, 1, ...) + matches_broadcast = matches.reshape( + -1, *([1] * (edge_values.ndim - 1)) + ) # (n_faces*3, 1, 1, ...) + + # Apply orientation and mask out non-matches (set to 0 contribution) + edge_contributions = torch.where( + matches_broadcast, + orientations_broadcast * edge_values, + torch.zeros_like(edge_values), + ) # (n_faces*3,) or (n_faces*3, ...) + + ### Sum contributions from the 3 edges of each face to get circulation + # Reshape to (n_faces, 3, ...) and sum over the 3 edges + edge_contributions = edge_contributions.reshape(n_faces, 3, *edge_1form.shape[1:]) + face_values = edge_contributions.sum(dim=1) # (n_faces,) or (n_faces, ...) + + return face_values, faces diff --git a/physicsnemo/mesh/calculus/_hodge_star.py b/physicsnemo/mesh/calculus/_hodge_star.py new file mode 100644 index 0000000000..2ac77afd21 --- /dev/null +++ b/physicsnemo/mesh/calculus/_hodge_star.py @@ -0,0 +1,143 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Hodge star operator for Discrete Exterior Calculus. + +The Hodge star ⋆ maps k-forms to (n-k)-forms, where n is the manifold dimension. +It's used for defining inner products on forms and building higher-level DEC operators. + +Key property: ⋆⋆ = (-1)^(k(n-k)) on k-forms + +The discrete Hodge star preserves averages between primal and dual cells: + ⟨α, σ⟩/|σ| = ⟨⋆α, ⋆σ⟩/|⋆σ| + +Reference: Desbrun et al., "Discrete Exterior Calculus", Section 4 +""" + +from typing import TYPE_CHECKING + +import torch + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def hodge_star_0( + mesh: "Mesh", + primal_0form: torch.Tensor, +) -> torch.Tensor: + """Apply Hodge star to 0-form (vertex values). + + Maps ⋆₀: Ω⁰(K) → Ωⁿ(⋆K) + + Takes values at vertices (0-simplices) to values at dual n-cells. + In the dual mesh, each vertex corresponds to a dual n-cell (Voronoi region). + + Formula: ⟨⋆f, ⋆v⟩/|⋆v| = ⟨f, v⟩/|v| = f(v) (since |v|=1 for 0-simplex) + Therefore: ⋆f(⋆v) = f(v) × |⋆v| + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + primal_0form : torch.Tensor + Values at vertices, shape (n_points,) or (n_points, ...) + + Returns + ------- + torch.Tensor + Dual n-form values (one per cell in dual mesh = one per vertex in primal), + shape (n_points,) or (n_points, ...) + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> f = torch.randn(mesh.n_points) # function at vertices + >>> star_f = hodge_star_0(mesh, f) + >>> # star_f[i] = f[i] * dual_volume[i] + """ + from physicsnemo.mesh.geometry.dual_meshes import ( + get_or_compute_dual_volumes_0, + ) + + dual_volumes = get_or_compute_dual_volumes_0(mesh) # (n_points,) + + ### Apply Hodge star: multiply by dual volume + # This preserves the average: f(v)/|v| = ⋆f(⋆v)/|⋆v| + # Since |v| = 1 for a vertex (0-dimensional), we get: ⋆f(⋆v) = f(v) × |⋆v| + + if primal_0form.ndim == 1: + return primal_0form * dual_volumes + else: + # Tensor case: broadcast dual volumes + return primal_0form * dual_volumes.view(-1, *([1] * (primal_0form.ndim - 1))) + + +def hodge_star_1( + mesh: "Mesh", + primal_1form: torch.Tensor, + edges: torch.Tensor, +) -> torch.Tensor: + """Apply Hodge star to 1-form (edge values). + + Maps ⋆₁: Ω¹(K) → Ω^(n-1)(⋆K) + + Takes values at edges (1-simplices) to values at dual (n-1)-cells. + + Formula: ⟨⋆α, ⋆e⟩/|⋆e| = ⟨α, e⟩/|e| + Therefore: ⋆α(⋆e) = α(e) × |⋆e|/|e| = α(e) × w_ij + + where w_ij is the FEM cotangent weight for the edge. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh of any manifold dimension. + primal_1form : torch.Tensor + Values on edges, shape (n_edges,) or (n_edges, ...) + edges : torch.Tensor + Edge connectivity, shape (n_edges, 2) + + Returns + ------- + torch.Tensor + Dual (n-1)-form values, shape (n_edges,) or (n_edges, ...) + """ + from physicsnemo.mesh.geometry.dual_meshes import compute_cotan_weights_fem + from physicsnemo.mesh.utilities._edge_lookup import find_edges_in_reference + + ### Get FEM cotangent weights w_ij = |⋆e|/|e| in canonical edge order + canonical_weights, canonical_edges = compute_cotan_weights_fem(mesh) + + ### Map the caller's edges to the canonical ordering + indices, matched = find_edges_in_reference(canonical_edges, edges) + + if not matched.all(): + n_unmatched = (~matched).sum().item() + raise ValueError( + f"hodge_star_1: {n_unmatched} of {len(edges)} input edges were not found " + "in the mesh's canonical edge set. Ensure edges are valid mesh edges." + ) + + cotan_weights = canonical_weights[indices] # (n_edges,) + + ### Apply Hodge star: ⋆α(⋆e) = α(e) × w_ij + if primal_1form.ndim == 1: + return primal_1form * cotan_weights + else: + return primal_1form * cotan_weights.view(-1, *([1] * (primal_1form.ndim - 1))) diff --git a/physicsnemo/mesh/calculus/_lsq_intrinsic.py b/physicsnemo/mesh/calculus/_lsq_intrinsic.py new file mode 100644 index 0000000000..4b69fddc3e --- /dev/null +++ b/physicsnemo/mesh/calculus/_lsq_intrinsic.py @@ -0,0 +1,240 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Intrinsic LSQ gradient reconstruction on manifolds. + +For manifolds embedded in higher dimensions, solves LSQ in the local tangent space +rather than solving in ambient space and projecting. This avoids ill-conditioning. +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.utilities._tolerances import safe_eps + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def compute_point_gradient_lsq_intrinsic( + mesh: "Mesh", + point_values: torch.Tensor, + weight_power: float = 2.0, +) -> torch.Tensor: + """Compute intrinsic gradient on manifold using tangent-space LSQ. + + For surfaces in 3D, solves LSQ in the local 2D tangent plane at each vertex. + This avoids the ill-conditioning that occurs when solving in full ambient space. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh (assumed to be a manifold) + point_values : torch.Tensor + Values at vertices, shape (n_points,) or (n_points, ...) + weight_power : float + Exponent for inverse distance weighting (default: 2.0) + + Returns + ------- + torch.Tensor + Intrinsic gradients (living in tangent space, represented in ambient coordinates). + Shape: (n_points, n_spatial_dims) for scalars, or (n_points, n_spatial_dims, ...) for tensor fields + + Notes + ----- + Algorithm: + For each point: + 1. Estimate tangent space using point normals + 2. Project neighbor positions onto tangent space + 3. Solve LSQ in tangent space (reduced dimension) + 4. Express result as vector in ambient space + + Implementation: + Fully vectorized using batched operations. Groups points by neighbor count + and processes each group in parallel. + """ + n_points = mesh.n_points + n_spatial_dims = mesh.n_spatial_dims + n_manifold_dims = mesh.n_manifold_dims + device = mesh.points.device + dtype = point_values.dtype + + if mesh.codimension == 0: + # No manifold structure: use standard LSQ + from physicsnemo.mesh.calculus._lsq_reconstruction import ( + compute_point_gradient_lsq, + ) + + return compute_point_gradient_lsq(mesh, point_values, weight_power) + + ### Get adjacency + adjacency = mesh.get_point_to_points_adjacency() + + ### Determine output shape + is_scalar = point_values.ndim == 1 + if is_scalar: + gradient_shape = (n_points, n_spatial_dims) + else: + gradient_shape = (n_points, n_spatial_dims) + point_values.shape[1:] + + gradients = torch.zeros(gradient_shape, dtype=dtype, device=device) + + ### Build tangent space basis for all points (vectorized) + # For codim-1: use point normals and construct orthogonal basis + if mesh.codimension == 1: + # Get point normals (already vectorized and cached) + point_normals = mesh.point_normals # (n_points, n_spatial_dims) + + # Build tangent basis for all points at once + tangent_bases = _build_tangent_bases_vectorized( + point_normals, n_manifold_dims + ) # (n_points, n_spatial_dims, n_manifold_dims) + + ### Process each neighbor-count group in parallel + from physicsnemo.mesh.calculus._neighborhoods import iter_neighborhood_batches + + for batch in iter_neighborhood_batches(mesh.points, adjacency, min_neighbors=2): + point_indices = batch.entity_indices + neighbors_flat = batch.neighbor_indices + A_ambient = ( + batch.relative_positions + ) # (n_group, n_neighbors, n_spatial_dims) + n_group = len(point_indices) + n_neighbors = batch.n_neighbors + + ### Project into tangent space + tangent_basis = tangent_bases[ + point_indices + ] # (n_group, n_spatial_dims, n_manifold_dims) + A_tangent = torch.einsum("gns,gsm->gnm", A_ambient, tangent_basis) + + ### Function differences + b = point_values[neighbors_flat] - point_values[point_indices].unsqueeze(1) + + ### Compute inverse-distance weights (using ambient distances) + distances = torch.linalg.vector_norm(A_ambient, dim=-1) + weights = 1.0 / distances.pow(weight_power).clamp( + min=safe_eps(distances.dtype) + ) + + ### Apply sqrt-weights to tangent-space system + sqrt_w = weights.sqrt().unsqueeze(-1) # (n_group, n_neighbors, 1) + A_tangent_weighted = sqrt_w * A_tangent + + ### Solve batched least-squares in tangent space + if is_scalar: + b_weighted = sqrt_w.squeeze(-1) * b + grad_tangent = torch.linalg.lstsq( + A_tangent_weighted, b_weighted.unsqueeze(-1), rcond=None + ).solution.squeeze(-1) # (n_group, n_manifold_dims) + + # Map back to ambient coordinates + grad_ambient = torch.einsum("gsm,gm->gs", tangent_basis, grad_tangent) + gradients[point_indices] = grad_ambient + else: + # Tensor field: flatten extra dims, solve, map back + b_weighted = sqrt_w * b + orig_shape = b.shape[2:] + b_flat = b_weighted.reshape(n_group, n_neighbors, -1) + + grad_tangent = torch.linalg.lstsq( + A_tangent_weighted, b_flat, rcond=None + ).solution # (n_group, n_manifold_dims, n_components) + + grad_ambient = torch.bmm(tangent_basis, grad_tangent) + grad_ambient_reshaped = grad_ambient.reshape( + n_group, n_spatial_dims, *orig_shape + ) + perm = [0] + list(range(2, grad_ambient_reshaped.ndim)) + [1] + gradients[point_indices] = grad_ambient_reshaped.permute(*perm) + + return gradients + + +def _build_tangent_bases_vectorized( + normals: torch.Tensor, + n_manifold_dims: int, +) -> torch.Tensor: + """Build orthonormal tangent space bases from normal vectors (vectorized). + + Parameters + ---------- + normals : torch.Tensor + Unit normal vectors, shape (n_points, n_spatial_dims) + n_manifold_dims : int + Dimension of the manifold + + Returns + ------- + torch.Tensor + Tangent bases, shape (n_points, n_spatial_dims, n_manifold_dims) + where tangent_bases[i, :, :] contains n_manifold_dims orthonormal tangent vectors + as columns + + Notes + ----- + Algorithm: + Uses Gram-Schmidt to construct orthonormal basis from arbitrary starting vectors. + """ + n_points, n_spatial_dims = normals.shape + device = normals.device + dtype = normals.dtype + + ### Start with arbitrary vectors not parallel to normals + # Use standard basis vector least aligned with normal + # For each point, choose e_i where |normal · e_i| is smallest + standard_basis = torch.eye( + n_spatial_dims, device=device, dtype=dtype + ) # (n_spatial_dims, n_spatial_dims) + + # Compute |normal · e_i| for all i: (n_points, n_spatial_dims) + alignment = torch.abs(normals @ standard_basis) # (n_points, n_spatial_dims) + + # Choose least-aligned basis vector for each point + least_aligned_idx = torch.argmin(alignment, dim=-1) # (n_points,) + v1 = standard_basis[least_aligned_idx] # (n_points, n_spatial_dims) + + ### Project v1 onto tangent plane: v1 = v1 - (v1·n)n + v1_dot_n = (v1 * normals).sum(dim=-1, keepdim=True) # (n_points, 1) + v1 = v1 - v1_dot_n * normals # (n_points, n_spatial_dims) + v1 = v1 / torch.linalg.vector_norm(v1, dim=-1, keepdim=True).clamp( + min=safe_eps(v1.dtype) + ) + + if n_manifold_dims == 1: + # 1D manifold (curves): single tangent vector + return v1.unsqueeze(-1) # (n_points, n_spatial_dims, 1) + + elif n_manifold_dims == 2: + # 2D manifold (surfaces): two tangent vectors + # Second tangent vector: v2 = n × v1 + if n_spatial_dims == 3: + v2 = torch.linalg.cross(normals, v1) # (n_points, 3) + v2 = v2 / torch.linalg.vector_norm(v2, dim=-1, keepdim=True).clamp( + min=safe_eps(v2.dtype) + ) + return torch.stack([v1, v2], dim=-1) # (n_points, 3, 2) + else: + raise ValueError( + f"2D manifolds require 3D ambient space, got {n_spatial_dims=}" + ) + + else: + raise NotImplementedError( + f"Tangent basis construction for {n_manifold_dims=} not implemented" + ) diff --git a/physicsnemo/mesh/calculus/_lsq_reconstruction.py b/physicsnemo/mesh/calculus/_lsq_reconstruction.py new file mode 100644 index 0000000000..f94c5200f7 --- /dev/null +++ b/physicsnemo/mesh/calculus/_lsq_reconstruction.py @@ -0,0 +1,240 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Weighted least-squares gradient reconstruction for unstructured meshes. + +This implements the standard CFD approach for computing gradients on irregular +meshes using weighted least-squares fitting. + +The method solves for the gradient that best fits the function differences +to neighboring points/cells, weighted by inverse distance. + +Reference: Standard in CFD literature (Barth & Jespersen, AIAA 1989) +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.utilities._tolerances import safe_eps + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def _solve_batched_lsq_gradients( + positions: torch.Tensor, # shape: (n_entities, n_spatial_dims) + values: torch.Tensor, # shape: (n_entities, ...) + adjacency, # Adjacency object + weight_power: float, + min_neighbors: int = 0, +) -> torch.Tensor: + """Core batched LSQ gradient solver (shared by point and cell versions). + + For each entity (point or cell), solves a weighted least-squares problem: + min_{∇φ} Σ_neighbors w_i ||∇φ·(x_i - x_0) - (φ_i - φ_0)||² + + Parameters + ---------- + positions : torch.Tensor + Entity positions (points or cell centroids) + values : torch.Tensor + Values at entities (scalars or tensor fields) + adjacency + Adjacency structure (entity-to-entity neighbors) + weight_power : float + Exponent for inverse distance weighting + min_neighbors : int + Minimum neighbors required for gradient computation + + Returns + ------- + torch.Tensor + Gradients at entities, shape (n_entities, n_spatial_dims) for scalars, + or (n_entities, n_spatial_dims, ...) for tensor fields. + Entities with insufficient neighbors have zero gradients. + """ + n_entities = len(positions) + n_spatial_dims = positions.shape[1] + device = positions.device + dtype = values.dtype + + ### Determine output shape + is_scalar = values.ndim == 1 + if is_scalar: + gradient_shape = (n_entities, n_spatial_dims) + else: + gradient_shape = (n_entities, n_spatial_dims) + values.shape[1:] + + gradients = torch.zeros(gradient_shape, dtype=dtype, device=device) + + ### Process each neighbor-count group in parallel + from physicsnemo.mesh.calculus._neighborhoods import iter_neighborhood_batches + + for batch in iter_neighborhood_batches( + positions, adjacency, min_neighbors=min_neighbors + ): + entity_indices = batch.entity_indices + neighbors_flat = batch.neighbor_indices + A = batch.relative_positions # (n_group, n_neighbors, n_spatial_dims) + n_group = len(entity_indices) + n_neighbors = batch.n_neighbors + + ### Entities with no neighbors retain their zero-initialized gradient + if n_neighbors == 0: + continue + + ### Function differences (b vector) + b = values[neighbors_flat] - values[entity_indices].unsqueeze(1) + + ### Compute inverse-distance weights + distances = torch.linalg.vector_norm(A, dim=-1) # (n_group, n_neighbors) + weights = 1.0 / distances.pow(weight_power).clamp(min=safe_eps(distances.dtype)) + + ### Apply sqrt-weights to system + sqrt_w = weights.sqrt().unsqueeze(-1) # (n_group, n_neighbors, 1) + A_weighted = sqrt_w * A # (n_group, n_neighbors, n_spatial_dims) + + ### Solve batched least-squares + if is_scalar: + b_weighted = sqrt_w.squeeze(-1) * b # (n_group, n_neighbors) + solution = torch.linalg.lstsq( + A_weighted, b_weighted.unsqueeze(-1), rcond=None + ).solution.squeeze(-1) # (n_group, n_spatial_dims) + + gradients[entity_indices] = solution + else: + # Tensor field: flatten extra dims, solve, reshape back + b_weighted = sqrt_w * b # (n_group, n_neighbors, ...) + orig_shape = b.shape[2:] + b_flat = b_weighted.reshape(n_group, n_neighbors, -1) + + solution = torch.linalg.lstsq( + A_weighted, b_flat, rcond=None + ).solution # (n_group, n_spatial_dims, n_components) + + solution_reshaped = solution.reshape(n_group, n_spatial_dims, *orig_shape) + # Permute spatial_dims to second position + perm = [0] + list(range(2, solution_reshaped.ndim)) + [1] + gradients[entity_indices] = solution_reshaped.permute(*perm) + + return gradients + + +def compute_point_gradient_lsq( + mesh: "Mesh", + point_values: torch.Tensor, + weight_power: float = 2.0, + min_neighbors: int = 0, +) -> torch.Tensor: + """Compute gradient at vertices using weighted least-squares reconstruction. + + For each vertex, solves: + min_{∇φ} Σ_neighbors w_i ||∇φ·(x_i - x_0) - (φ_i - φ_0)||² + + Where weights w_i = 1/||x_i - x_0||^α (typically α=2). + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + point_values : torch.Tensor + Values at vertices, shape (n_points,) or (n_points, ...) + weight_power : float + Exponent for inverse distance weighting (default: 2.0) + min_neighbors : int + Minimum neighbors required for gradient computation. Points with + fewer neighbors get zero gradients. The default of 0 means all + points are processed: ``lstsq`` naturally returns the minimum-norm + solution for under-determined systems (fewer neighbors than spatial + dims) and zero for isolated points with no neighbors. + + Returns + ------- + torch.Tensor + Gradients at vertices, shape (n_points, n_spatial_dims) for scalars, + or (n_points, n_spatial_dims, ...) for tensor fields + + Notes + ----- + Algorithm: + Solve weighted least-squares: (A^T W A) ∇φ = A^T W b + where: + A = [x₁-x₀, x₂-x₀, ...]^T (n_neighbors × n_spatial_dims) + b = [φ₁-φ₀, φ₂-φ₀, ...]^T (n_neighbors,) + W = diag([w₁, w₂, ...]) (n_neighbors × n_neighbors) + + Implementation: + Fully vectorized using batched operations. Groups points by neighbor count + and processes each group in parallel to handle ragged neighbor structure. + """ + ### Get point-to-point adjacency + adjacency = mesh.get_point_to_points_adjacency() + + ### Use shared batched LSQ solver + return _solve_batched_lsq_gradients( + positions=mesh.points, + values=point_values, + adjacency=adjacency, + weight_power=weight_power, + min_neighbors=min_neighbors, + ) + + +def compute_cell_gradient_lsq( + mesh: "Mesh", + cell_values: torch.Tensor, + weight_power: float = 2.0, +) -> torch.Tensor: + """Compute gradient at cells using weighted least-squares reconstruction. + + Uses cell-to-cell adjacency to build LSQ system around each cell centroid. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + cell_values : torch.Tensor + Values at cells, shape (n_cells,) or (n_cells, ...) + weight_power : float + Exponent for inverse distance weighting (default: 2.0) + + Returns + ------- + torch.Tensor + Gradients at cells, shape (n_cells, n_spatial_dims) for scalars, + or (n_cells, n_spatial_dims, ...) for tensor fields + + Notes + ----- + Implementation: + Fully vectorized using batched operations. Groups cells by neighbor count + and processes each group in parallel. + """ + ### Get cell-to-cell adjacency + adjacency = mesh.get_cell_to_cells_adjacency(adjacency_codimension=1) + + ### Get cell centroids + cell_centroids = mesh.cell_centroids # (n_cells, n_spatial_dims) + + ### Use shared batched LSQ solver + return _solve_batched_lsq_gradients( + positions=cell_centroids, + values=cell_values, + adjacency=adjacency, + weight_power=weight_power, + min_neighbors=0, # Cells may have fewer neighbors than points + ) diff --git a/physicsnemo/mesh/calculus/_neighborhoods.py b/physicsnemo/mesh/calculus/_neighborhoods.py new file mode 100644 index 0000000000..1b97507d0e --- /dev/null +++ b/physicsnemo/mesh/calculus/_neighborhoods.py @@ -0,0 +1,145 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Batched neighborhood iteration for ragged adjacency structures. + +Provides a generator that groups mesh entities by neighbor count and yields +dense batches of neighborhood data, enabling efficient vectorized processing +without Python-level loops over individual entities. + +Used by the LSQ gradient solvers (standard and intrinsic) and PCA tangent +space estimation to avoid duplicating the grouping + extraction boilerplate. +""" + +from collections.abc import Iterator +from typing import TYPE_CHECKING, NamedTuple + +import torch + +if TYPE_CHECKING: + from physicsnemo.mesh.neighbors._adjacency import Adjacency + + +class NeighborhoodBatch(NamedTuple): + """A batch of entities that share the same neighbor count. + + All tensors in a batch have a leading dimension of ``n_group`` (the number + of entities in this batch) and a second dimension of ``n_neighbors``. + + Parameters + ---------- + entity_indices : torch.Tensor + Global indices of the entities in this batch, shape ``(n_group,)``. + neighbor_indices : torch.Tensor + Global indices of each entity's neighbors, shape ``(n_group, n_neighbors)``. + relative_positions : torch.Tensor + Vectors from each entity to its neighbors, + shape ``(n_group, n_neighbors, n_spatial_dims)``. + n_neighbors : int + Number of neighbors per entity in this batch (same for all entities). + """ + + entity_indices: torch.Tensor + neighbor_indices: torch.Tensor + relative_positions: torch.Tensor + n_neighbors: int + + +def iter_neighborhood_batches( + positions: torch.Tensor, + adjacency: "Adjacency", + *, + min_neighbors: int = 0, + max_neighbors: int | None = None, +) -> Iterator[NeighborhoodBatch]: + """Iterate over neighborhoods grouped by neighbor count. + + Groups entities by their (possibly clamped) neighbor count and yields + dense batches containing entity indices, neighbor indices, and relative + position vectors. This converts a ragged adjacency structure into a + sequence of regular batches suitable for ``torch.linalg`` operations. + + Parameters + ---------- + positions : torch.Tensor + Entity positions, shape ``(n_entities, n_spatial_dims)``. + adjacency : Adjacency + Adjacency structure mapping entities to their neighbors. Must have + ``offsets`` and ``indices`` attributes (CSR format). + min_neighbors : int + Skip entities with fewer than this many (effective) neighbors. + max_neighbors : int | None + Clamp each entity's neighbor count to at most this value. + Useful for PCA where only the k nearest neighbors are needed. + If ``None``, use all neighbors. + + Yields + ------ + NeighborhoodBatch + One batch per unique (effective) neighbor count that meets the + ``min_neighbors`` threshold. Batches are yielded in order of + ascending neighbor count. + """ + device = positions.device + + ### Compute per-entity neighbor counts from CSR offsets + neighbor_counts = adjacency.offsets[1:] - adjacency.offsets[:-1] + + ### Optionally clamp to max_neighbors + if max_neighbors is not None: + effective_counts = torch.minimum( + neighbor_counts, + torch.tensor(max_neighbors, dtype=neighbor_counts.dtype, device=device), + ) + else: + effective_counts = neighbor_counts + + ### Group by effective neighbor count + unique_counts, inverse_indices = torch.unique(effective_counts, return_inverse=True) + + ### Yield one batch per unique count + for count_idx, count_tensor in enumerate(unique_counts): + n_neighbors = int(count_tensor) + + # Skip groups below the minimum threshold + if n_neighbors < min_neighbors: + continue + + # Find all entities in this group + entity_indices = torch.where(inverse_indices == count_idx)[0] + if len(entity_indices) == 0: + continue + + ### Extract neighbor indices for the entire group at once + # Build a (n_group, n_neighbors) index matrix into adjacency.indices + offsets_group = adjacency.offsets[entity_indices] # (n_group,) + col_range = torch.arange(n_neighbors, device=device) # (n_neighbors,) + flat_indices = offsets_group.unsqueeze(1) + col_range.unsqueeze(0) + neighbor_indices = adjacency.indices[flat_indices] # (n_group, n_neighbors) + + ### Gather positions and compute relative vectors + center = positions[entity_indices] # (n_group, n_spatial_dims) + neighbor_pos = positions[ + neighbor_indices + ] # (n_group, n_neighbors, n_spatial_dims) + relative = neighbor_pos - center.unsqueeze(1) + + yield NeighborhoodBatch( + entity_indices=entity_indices, + neighbor_indices=neighbor_indices, + relative_positions=relative, + n_neighbors=n_neighbors, + ) diff --git a/physicsnemo/mesh/calculus/_pca_tangent.py b/physicsnemo/mesh/calculus/_pca_tangent.py new file mode 100644 index 0000000000..c73f8ff6ac --- /dev/null +++ b/physicsnemo/mesh/calculus/_pca_tangent.py @@ -0,0 +1,222 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""PCA-based tangent space estimation for manifolds. + +For higher codimension manifolds (e.g., curves in 3D, surfaces in 4D+), normal +vectors are not uniquely defined. PCA on local neighborhoods provides a robust +method to estimate the tangent space. +""" + +from typing import TYPE_CHECKING + +import torch + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def estimate_tangent_space_pca( + mesh: "Mesh", + k_neighbors: int | None = None, +) -> tuple[torch.Tensor, torch.Tensor]: + """Estimate tangent space at each point using PCA on local neighborhoods. + + For each point, gathers k-nearest neighbors and performs PCA on their + relative positions. The eigenvectors corresponding to the largest eigenvalues + span the tangent space, while those with smallest eigenvalues span the normal space. + + Parameters + ---------- + mesh : Mesh + Input mesh + k_neighbors : int | None + Number of neighbors to use for PCA. If None, uses + min(2 * n_manifold_dims + 1, available_neighbors) + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + Tuple of (tangent_basis, normal_basis) where: + - tangent_basis: (n_points, n_manifold_dims, n_spatial_dims) + Orthonormal basis vectors spanning tangent space at each point + - normal_basis: (n_points, codimension, n_spatial_dims) + Orthonormal basis vectors spanning normal space at each point + + Notes + ----- + Algorithm: + 1. For each point, gather k nearest neighbors + 2. Center the neighborhood (subtract mean) + 3. Compute covariance matrix C = (1/k) Σ (x_i - mean)(x_i - mean)^T + 4. Eigen-decompose: C = V Λ V^T + 5. Sort eigenvectors by eigenvalue (descending) + 6. First n_manifold_dims eigenvectors span tangent space + 7. Remaining eigenvectors span normal space + + Examples + -------- + >>> from physicsnemo.mesh.primitives.curves import helix_3d + >>> curve_mesh = helix_3d.load() + >>> tangent_basis, normal_basis = estimate_tangent_space_pca(curve_mesh) + >>> # tangent_basis: (n_points, 1, 3) - tangent direction + >>> # normal_basis: (n_points, 2, 3) - normal plane basis + """ + n_points = mesh.n_points + n_spatial_dims = mesh.n_spatial_dims + n_manifold_dims = mesh.n_manifold_dims + codimension = mesh.codimension + device = mesh.points.device + dtype = mesh.points.dtype + + ### Determine k_neighbors if not specified + if k_neighbors is None: + k_neighbors = min(2 * n_manifold_dims + 1, n_points - 1) + + k_neighbors = max(k_neighbors, n_manifold_dims + 1) # Need at least n+1 neighbors + + ### Get point-to-point adjacency + adjacency = mesh.get_point_to_points_adjacency() + + ### Initialize output tensors + tangent_basis = torch.zeros( + (n_points, n_manifold_dims, n_spatial_dims), + dtype=dtype, + device=device, + ) + normal_basis = torch.zeros( + (n_points, codimension, n_spatial_dims), + dtype=dtype, + device=device, + ) + + ### Identity fallback for points with insufficient neighbors + min_required = n_manifold_dims + 1 + neighbor_counts = adjacency.offsets[1:] - adjacency.offsets[:-1] + effective_counts = torch.minimum( + neighbor_counts, + torch.tensor(k_neighbors, dtype=neighbor_counts.dtype, device=device), + ) + insufficient_mask = effective_counts < min_required + if insufficient_mask.any(): + insufficient_indices = torch.where(insufficient_mask)[0] + for i in range(min(n_manifold_dims, n_spatial_dims)): + tangent_basis[insufficient_indices, i, i] = 1.0 + for i in range(min(codimension, n_spatial_dims - n_manifold_dims)): + normal_basis[insufficient_indices, i, n_manifold_dims + i] = 1.0 + + ### Process each neighbor-count group via shared iterator + from physicsnemo.mesh.calculus._neighborhoods import iter_neighborhood_batches + + for batch in iter_neighborhood_batches( + mesh.points, adjacency, min_neighbors=min_required, max_neighbors=k_neighbors + ): + point_indices = batch.entity_indices + centered = batch.relative_positions # (n_group, n_neighbors, n_spatial_dims) + n_neighbors = batch.n_neighbors + + ### Covariance matrix: C = (1/k) X^T X + cov_matrices = ( + torch.bmm( + centered.transpose(1, 2), # (n_group, n_spatial_dims, n_neighbors) + centered, # (n_group, n_neighbors, n_spatial_dims) + ) + / n_neighbors + ) + + ### Batch eigen-decomposition + eigenvalues, eigenvectors = torch.linalg.eigh(cov_matrices) + + ### Sort eigenvectors by eigenvalue (descending) + sorted_indices = torch.argsort(eigenvalues, dim=1, descending=True) + sorted_idx_expanded = sorted_indices.unsqueeze(1).expand_as(eigenvectors) + eigenvectors_sorted = torch.gather( + eigenvectors, dim=2, index=sorted_idx_expanded + ) + + ### Extract tangent and normal bases + tangent_vecs = eigenvectors_sorted[:, :, :n_manifold_dims] + tangent_basis[point_indices] = tangent_vecs.transpose(1, 2) + + normal_vecs = eigenvectors_sorted[:, :, n_manifold_dims:] + normal_basis[point_indices] = normal_vecs.transpose(1, 2) + + return tangent_basis, normal_basis + + +def project_gradient_to_tangent_space_pca( + mesh: "Mesh", + gradients: torch.Tensor, + k_neighbors: int | None = None, +) -> torch.Tensor: + """Project gradients onto PCA-estimated tangent space. + + For higher codimension manifolds, uses PCA to estimate tangent space + and projects gradients accordingly. + + Parameters + ---------- + mesh : Mesh + Input mesh + gradients : torch.Tensor + Extrinsic gradients, shape (n_points, n_spatial_dims) or + (n_points, n_spatial_dims, ...) + k_neighbors : int | None + Number of neighbors for PCA estimation + + Returns + ------- + torch.Tensor + Intrinsic gradients projected onto tangent space, same shape as input + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh.primitives.curves import helix_3d + >>> mesh = helix_3d.load() + >>> gradients = torch.randn(mesh.n_points, mesh.n_spatial_dims) + >>> grad_intrinsic = project_gradient_to_tangent_space_pca(mesh, gradients) + """ + ### Estimate tangent space using PCA + tangent_basis, _ = estimate_tangent_space_pca(mesh, k_neighbors) + # tangent_basis: (n_points, n_manifold_dims, n_spatial_dims) + + ### Project gradient onto tangent space + # For each point: grad_intrinsic = Σ_i (grad · t_i) t_i + # where t_i are the tangent basis vectors + + if gradients.ndim == 2: + ### Scalar gradient case: (n_points, n_spatial_dims) + # Compute projection onto each tangent vector + # grad · t_i for all i: (n_points, n_manifold_dims) + projections = torch.einsum("ij,ikj->ik", gradients, tangent_basis) + + # Reconstruct in tangent space: Σ_i (grad · t_i) t_i + grad_intrinsic = torch.einsum("ik,ikj->ij", projections, tangent_basis) + + return grad_intrinsic + else: + ### Tensor gradient case: (n_points, n_spatial_dims, ...) + # More complex - need to handle extra dimensions + + # Compute projections: grad · t_i + # Shape: (n_points, n_manifold_dims, ...) + projections = torch.einsum("ij...,ikj->ik...", gradients, tangent_basis) + + # Reconstruct + grad_intrinsic = torch.einsum("ik...,ikj->ij...", projections, tangent_basis) + + return grad_intrinsic diff --git a/physicsnemo/mesh/calculus/_sharp_flat.py b/physicsnemo/mesh/calculus/_sharp_flat.py new file mode 100644 index 0000000000..4a1ba8b037 --- /dev/null +++ b/physicsnemo/mesh/calculus/_sharp_flat.py @@ -0,0 +1,316 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Sharp and flat operators for converting between forms and vector fields. + +These operators relate 1-forms (edge-based) to vector fields (vertex-based): +- Flat (♭): Converts vector fields to 1-forms +- Sharp (♯): Converts 1-forms to vector fields + +These are metric-dependent operators crucial for DEC gradient and divergence. + +Reference: Desbrun et al., "Discrete Exterior Calculus", Section 5 +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.utilities._edge_lookup import find_edges_in_reference + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def sharp( + mesh: "Mesh", + edge_1form: torch.Tensor, + edges: torch.Tensor, +) -> torch.Tensor: + r"""Apply sharp operator to convert 1-form to primal vector field (rigorous DEC). + + Maps :math:`\sharp: \Omega^1(K) \to \mathfrak{X}(K)` + + Converts edge-based 1-form values to vectors at vertices: + + .. math:: + + \alpha^\sharp(v) = \sum_{\text{edges } [v,\sigma^0]} + \langle \alpha, [v,\sigma^0] \rangle + \sum_{\sigma^n \supset \text{edge}} + \frac{|{\star}v \cap \sigma^n|}{|{\star}v|} + \,\nabla\varphi_{\sigma^0, \sigma^n} + + Where: + + - :math:`\langle \alpha, [v,\sigma^0] \rangle` is the 1-form value on the + oriented edge from *v* to :math:`\sigma^0` + - :math:`|{\star}v \cap \sigma^n|` is the portion of vertex *v*'s Voronoi + cell within cell :math:`\sigma^n` + - :math:`|{\star}v|` is the total dual 0-cell volume of vertex *v* + - :math:`\nabla\varphi_{\sigma^0, \sigma^n}` is the gradient of the + barycentric interpolation function for :math:`\sigma^0` in cell + :math:`\sigma^n` + + The weights :math:`|{\star}v \cap \sigma^n| / |{\star}v|` sum to 1.0 for + each vertex, guaranteeing exact reproduction of constant gradients. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh (2D or 3D). + edge_1form : torch.Tensor + 1-form values on edges, shape ``(n_edges,)`` or ``(n_edges, ...)``. + edges : torch.Tensor + Edge connectivity, shape ``(n_edges, 2)``. + + Returns + ------- + torch.Tensor + Vector field at vertices, shape ``(n_points, n_spatial_dims)`` or + ``(n_points, n_spatial_dims, ...)`` for tensor-valued 1-forms. + + References + ---------- + Hirani (2003) Definition 5.8.1, Corollary 6.1.8. + """ + n_points = mesh.n_points + n_spatial_dims = mesh.n_spatial_dims + + ### Initialize output + if edge_1form.ndim == 1: + vector_field = torch.zeros( + (n_points, n_spatial_dims), + dtype=edge_1form.dtype, + device=mesh.points.device, + ) + else: + vector_field = torch.zeros( + (n_points, n_spatial_dims) + edge_1form.shape[1:], + dtype=edge_1form.dtype, + device=mesh.points.device, + ) + + ### Get barycentric gradients for all cells + from physicsnemo.mesh.geometry.interpolation import compute_barycentric_gradients + + bary_grads = compute_barycentric_gradients( + mesh + ) # (n_cells, n_verts_per_cell, n_spatial_dims) + + ### Get support volume fractions |⋆v ∩ cell| / |⋆v| (sum to 1.0 per vertex) + from physicsnemo.mesh.geometry.support_volumes import ( + compute_vertex_support_volume_cell_fractions, + ) + + fractions, cell_vertex_pairs = compute_vertex_support_volume_cell_fractions(mesh) + # fractions: (n_pairs,) + # cell_vertex_pairs: (n_pairs, 2) - [cell_idx, local_vertex_idx] + + ### Build mapping from edges to cells containing them + from physicsnemo.mesh.boundaries import extract_candidate_facets + + candidate_edges, parent_cells = extract_candidate_facets( + mesh.cells, + manifold_codimension=1, + ) + + ### Match candidates to input edges to get 1-form values + # Implements Hirani Eq. 5.8.1 (FULLY VECTORIZED) + # Challenge: This is complex to vectorize due to variable vertex valence + # Strategy: Process all (edge, cell) pairs, then scatter to vertices + + edge_indices_for_candidates, matches = find_edges_in_reference( + edges, candidate_edges + ) + + ### Filter to only matched candidates + matched_mask = matches + matched_edge_indices = edge_indices_for_candidates[matched_mask] # Which input edge + matched_cell_indices = parent_cells[matched_mask] # Which cell + matched_candidate_edges = candidate_edges[matched_mask] # (n_matched, 2) + + ### For each matched triple, process both vertices of the edge + # We'll create contributions for v0 and v1 separately + for vertex_position in [0, 1]: # Process v0, then v1 + ### Get global vertex indices + vertex_indices = matched_candidate_edges[:, vertex_position] # (n_matched,) + + ### Get the OTHER vertex (for ∇φ) + other_vertex_position = 1 - vertex_position + other_vertex_indices = matched_candidate_edges[:, other_vertex_position] + + ### Find local indices in cells + # For each matched triple, find where vertex appears in cell + cells_expanded = mesh.cells[ + matched_cell_indices + ] # (n_matched, n_verts_per_cell) + + # Find local index of current vertex + local_v_mask = cells_expanded == vertex_indices.unsqueeze(1) + local_v_idx = torch.argmax(local_v_mask.int(), dim=1) # (n_matched,) + + # Find local index of other vertex + local_other_mask = cells_expanded == other_vertex_indices.unsqueeze(1) + local_other_idx = torch.argmax(local_other_mask.int(), dim=1) # (n_matched,) + + ### Get weights: |⋆v ∩ cell| / |⋆v| + pair_indices = matched_cell_indices * (mesh.n_manifold_dims + 1) + local_v_idx + weights = fractions[pair_indices] # (n_matched,) + + ### Get barycentric gradients ∇φ_{other,cell} + grad_phi = bary_grads[ + matched_cell_indices, local_other_idx, : + ] # (n_matched, n_spatial_dims) + + ### Get 1-form values (with orientation) + # Orientation: +1 if vertex is first in canonical edge order, -1 if second + # Canonical order has smaller index first + canonical_v0 = torch.minimum( + matched_candidate_edges[:, 0], matched_candidate_edges[:, 1] + ) + is_first_in_canonical = vertex_indices == canonical_v0 + orientations = torch.where(is_first_in_canonical, 1.0, -1.0) # (n_matched,) + + alpha_values = edge_1form[ + matched_edge_indices + ] # (n_matched,) or (n_matched, ...) + + ### Compute contributions + if edge_1form.ndim == 1: + # Scalar case: (n_matched,) * (n_matched,) * (n_matched, n_spatial_dims) + contributions = ( + orientations.unsqueeze(-1) + * alpha_values.unsqueeze(-1) + * weights.unsqueeze(-1) + * grad_phi + ) # (n_matched, n_spatial_dims) + + ### Scatter-add to vector_field + vector_field.scatter_add_( + 0, + vertex_indices.unsqueeze(-1).expand(-1, n_spatial_dims), + contributions, + ) + else: + # Tensor case: more complex broadcasting + # alpha_values: (n_matched, features...) + # Need: (n_matched, n_spatial_dims, features...) + contrib_spatial = ( + orientations.unsqueeze(-1) * weights.unsqueeze(-1) * grad_phi + ) # (n_matched, n_spatial_dims) + contrib_spatial_expanded = contrib_spatial.unsqueeze( + -1 + ) # (n_matched, n_spatial_dims, 1) + alpha_expanded = alpha_values.unsqueeze(1) # (n_matched, 1, features...) + + contributions = ( + contrib_spatial_expanded * alpha_expanded + ) # (n_matched, n_spatial_dims, features...) + + # Flatten and scatter + contributions_flat = contributions.reshape(len(matched_edge_indices), -1) + vector_field_flat = vector_field.reshape(n_points, -1) + + vertex_indices_expanded = vertex_indices.unsqueeze(-1).expand( + -1, contributions_flat.shape[1] + ) + vector_field_flat.scatter_add_( + 0, vertex_indices_expanded, contributions_flat + ) + + vector_field = vector_field_flat.reshape(vector_field.shape) + + return vector_field + + +def flat( + mesh: "Mesh", + vector_field: torch.Tensor, + edges: torch.Tensor, +) -> torch.Tensor: + """Apply PDP-flat operator to convert primal vector field to primal 1-form (rigorous DEC). + + Maps ♭: 𝔛(K) → Ω¹(K) + + Converts vectors at vertices (primal vector field) to edge-based 1-form values. + Uses the PDP-flat formula from Hirani Section 5.6 (line 2456): + + ⟨X♭, edge⟩ = X(v0) · edge⃗/2 + X(v1) · edge⃗/2 = (X(v0) + X(v1))/2 · edge⃗ + + This is the simplest flat operator for primal fields and is exact for + linearly interpolated vector fields along edges. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + vector_field : torch.Tensor + Vectors at vertices, shape (n_points, n_spatial_dims) or + (n_points, n_spatial_dims, ...) for tensor fields + edges : torch.Tensor + Edge connectivity, shape (n_edges, 2) + + Returns + ------- + torch.Tensor + 1-form values on edges, shape (n_edges,) or (n_edges, ...) + + References + ---------- + Hirani (2003) Section 5.6, PDP-flat (lines 2456-2465) + + Notes + ----- + Note on flat operator variants: + Hirani defines 8 different flat operators depending on: + - Source: primal vs dual vector field + - Interpolation: constant in cells vs barycentric + - Destination: primal vs dual 1-form + + This implements PDP-flat (Primal-Dual-Primal): primal vectors, constant + in Voronoi regions, to primal 1-form. This is compatible with PP-sharp. + + Algorithm: + For edge [v0, v1]: + 1. Average vectors: (X(v0) + X(v1))/2 + 2. Project onto edge direction + 3. Multiply by edge length for proper units + """ + ### Get edge vectors + edge_vectors = ( + mesh.points[edges[:, 1]] - mesh.points[edges[:, 0]] + ) # (n_edges, n_spatial_dims) + + ### Get vectors at edge endpoints + v0_vectors = vector_field[edges[:, 0]] # (n_edges, n_spatial_dims, ...) + v1_vectors = vector_field[edges[:, 1]] # (n_edges, n_spatial_dims, ...) + + ### Average vectors (PDP-flat: constant in Voronoi regions, average at boundary) + avg_vectors = (v0_vectors + v1_vectors) / 2 # (n_edges, n_spatial_dims, ...) + + ### Project onto edge direction: X̄ · edge⃗ + # Dot product along spatial dimension + if vector_field.ndim == 2: + # Scalar field case + projection = (avg_vectors * edge_vectors).sum(dim=-1) # (n_edges,) + else: + # Tensor field case + projection = (avg_vectors * edge_vectors.unsqueeze(-1)).sum( + dim=1 + ) # (n_edges, ...) + + return projection diff --git a/physicsnemo/mesh/calculus/curl.py b/physicsnemo/mesh/calculus/curl.py new file mode 100644 index 0000000000..61fe85f728 --- /dev/null +++ b/physicsnemo/mesh/calculus/curl.py @@ -0,0 +1,90 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Curl operator for vector fields (3D only). + +Implements curl using both DEC and LSQ methods. + +DEC formula: curl = ⋆d♭ + 1. Apply flat ♭ to convert vector field to 1-form + 2. Apply exterior derivative d to get 2-form + 3. Apply Hodge star ⋆ to get dual 1-form + 4. Convert back to vector field + +For 3D: curl maps vectors to vectors. +""" + +from typing import TYPE_CHECKING + +import torch + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def compute_curl_points_lsq( + mesh: "Mesh", + vector_field: torch.Tensor, +) -> torch.Tensor: + """Compute curl at vertices using LSQ gradient method. + + For 3D vector field v = [vₓ, vᵧ, v_z]: + curl(v) = [∂vᵧ/∂y - ∂vᵧ/∂z, ∂vₓ/∂z - ∂vᵧ/∂x, ∂vᵧ/∂x - ∂vₓ/∂y] + + Computes Jacobian of vector field, then takes antisymmetric part. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + vector_field : torch.Tensor + Vectors at vertices, shape (n_points, 3) + + Returns + ------- + torch.Tensor + Curl at vertices, shape (n_points, 3) + + Raises + ------ + ValueError + If n_spatial_dims != 3 + """ + if mesh.n_spatial_dims != 3: + raise ValueError( + f"Curl is only defined for 3D vector fields, got {mesh.n_spatial_dims=}" + ) + + from physicsnemo.mesh.calculus._lsq_reconstruction import compute_point_gradient_lsq + + n_points = mesh.n_points + + ### Compute full Jacobian in one batched LSQ solve + # vector_field: (n_points, 3) -> jacobian: (n_points, 3, 3) + # jacobian[i, j, k] = ∂v_j/∂x_k + jacobian = compute_point_gradient_lsq(mesh, vector_field) + + ### Compute curl from Jacobian + # curl = [∂vz/∂y - ∂vy/∂z, ∂vx/∂z - ∂vz/∂x, ∂vy/∂x - ∂vx/∂y] + curl = torch.zeros( + (n_points, 3), dtype=vector_field.dtype, device=mesh.points.device + ) + + curl[:, 0] = jacobian[:, 2, 1] - jacobian[:, 1, 2] # ∂vz/∂y - ∂vy/∂z + curl[:, 1] = jacobian[:, 0, 2] - jacobian[:, 2, 0] # ∂vx/∂z - ∂vz/∂x + curl[:, 2] = jacobian[:, 1, 0] - jacobian[:, 0, 1] # ∂vy/∂x - ∂vx/∂y + + return curl diff --git a/physicsnemo/mesh/calculus/derivatives.py b/physicsnemo/mesh/calculus/derivatives.py new file mode 100644 index 0000000000..6da8269695 --- /dev/null +++ b/physicsnemo/mesh/calculus/derivatives.py @@ -0,0 +1,295 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Unified API for computing discrete derivatives on meshes. + +Provides high-level interface for gradient, divergence, curl, and Laplacian +computations using both DEC and LSQ methods. +""" + +from typing import TYPE_CHECKING, Literal, Sequence + +from physicsnemo.mesh.utilities._cache import CACHE_KEY + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def _make_output_key( + key: str | tuple[str, ...], + suffix: str, +) -> str | tuple[str, ...]: + """Build the output key name for a gradient field. + + Parameters + ---------- + key : str or tuple[str, ...] + Original field key (possibly a nested TensorDict path). + suffix : str + Suffix to append (e.g., ``"_gradient"``). + + Returns + ------- + str or tuple[str, ...] + Key with suffix appended to the leaf name. + """ + if isinstance(key, str): + return f"{key}{suffix}" + return key[:-1] + (key[-1] + suffix,) + + +def compute_point_derivatives( + mesh: "Mesh", + keys: str | tuple[str, ...] | Sequence[str | tuple[str, ...]] | None = None, + method: Literal["lsq", "dec"] = "lsq", + gradient_type: Literal["intrinsic", "extrinsic", "both"] = "intrinsic", +) -> "Mesh": + """Compute gradients of point_data fields. + + Computes discrete gradients using either DEC or LSQ methods, with support + for both intrinsic (tangent space) and extrinsic (ambient space) derivatives. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh with point_data fields to differentiate. + keys : str or tuple[str, ...] or Sequence or None + Fields to compute gradients of. Options: + + - ``None``: All non-cached fields (excludes ``"_cache"`` subdictionary). + - ``str``: Single field name (e.g., ``"pressure"``). + - ``tuple``: Nested path (e.g., ``("flow", "temperature")``). + - ``Sequence``: List of the above. + method : {"lsq", "dec"} + Discretization method: + + - ``"lsq"``: Weighted least-squares reconstruction (CFD standard). + - ``"dec"``: Discrete Exterior Calculus (differential geometry). + gradient_type : {"intrinsic", "extrinsic", "both"} + Type of gradient to compute: + + - ``"intrinsic"``: Project onto manifold tangent space. + - ``"extrinsic"``: Full ambient space gradient. + - ``"both"``: Compute and store both. + + Returns + ------- + Mesh + A new Mesh with gradient fields added to ``point_data``. The original + mesh is **not** modified. Field naming convention: + + - ``gradient_type="intrinsic"`` or ``"extrinsic"``: + ``"{field}_gradient"`` + - ``gradient_type="both"``: + ``"{field}_gradient_intrinsic"`` and ``"{field}_gradient_extrinsic"`` + + Example + ------- + >>> import torch + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> mesh.point_data["pressure"] = torch.randn(mesh.n_points) + >>> mesh_with_grad = compute_point_derivatives(mesh, keys="pressure") + >>> grad_p = mesh_with_grad.point_data["pressure_gradient"] + """ + from physicsnemo.mesh.calculus.gradient import ( + compute_gradient_points_dec, + compute_gradient_points_lsq, + project_to_tangent_space, + ) + + ### Parse keys: normalize to list of key paths + if keys is None: + key_list = list( + mesh.point_data.exclude(CACHE_KEY).keys( + include_nested=True, leaves_only=True + ) + ) + elif isinstance(keys, (str, tuple)): + key_list = [keys] + elif isinstance(keys, Sequence): + key_list = list(keys) + else: + raise TypeError(f"Invalid keys type: {type(keys)}") + + ### Clone point_data so we don't mutate the original mesh + new_point_data = mesh.point_data.clone() + + ### Compute gradients for each key + for key in key_list: + field_values = mesh.point_data[key] + + ### Compute gradient based on method and gradient_type + if method == "lsq": + if gradient_type == "intrinsic": + grad_intrinsic = compute_gradient_points_lsq( + mesh, field_values, intrinsic=True + ) + grad_extrinsic = None + elif gradient_type == "extrinsic": + grad_extrinsic = compute_gradient_points_lsq( + mesh, field_values, intrinsic=False + ) + grad_intrinsic = None + else: # "both" + grad_extrinsic = compute_gradient_points_lsq( + mesh, field_values, intrinsic=False + ) + grad_intrinsic = project_to_tangent_space( + mesh, grad_extrinsic, location="points" + ) + elif method == "dec": + # DEC always computes in ambient space initially + grad_extrinsic = compute_gradient_points_dec(mesh, field_values) + + if gradient_type == "intrinsic": + grad_intrinsic = project_to_tangent_space( + mesh, grad_extrinsic, "points" + ) + grad_extrinsic = None + elif gradient_type == "both": + grad_intrinsic = project_to_tangent_space( + mesh, grad_extrinsic, "points" + ) + else: # extrinsic + grad_intrinsic = None + else: + raise ValueError(f"Invalid {method=}. Must be 'lsq' or 'dec'.") + + ### Store gradients in the cloned point_data + if gradient_type in ("extrinsic", "intrinsic"): + out_key = _make_output_key(key, "_gradient") + value = grad_extrinsic if gradient_type == "extrinsic" else grad_intrinsic + new_point_data[out_key] = value + elif gradient_type == "both": + new_point_data[_make_output_key(key, "_gradient_extrinsic")] = ( + grad_extrinsic + ) + new_point_data[_make_output_key(key, "_gradient_intrinsic")] = ( + grad_intrinsic + ) + else: + raise ValueError(f"Invalid {gradient_type=}") + + ### Return a new Mesh with the augmented point_data + from physicsnemo.mesh.mesh import Mesh + + return Mesh( + points=mesh.points, + cells=mesh.cells, + point_data=new_point_data, + cell_data=mesh.cell_data, + global_data=mesh.global_data, + ) + + +def compute_cell_derivatives( + mesh: "Mesh", + keys: str | tuple[str, ...] | Sequence[str | tuple[str, ...]] | None = None, + method: Literal["lsq", "dec"] = "lsq", + gradient_type: Literal["intrinsic", "extrinsic", "both"] = "intrinsic", +) -> "Mesh": + """Compute gradients of cell_data fields. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh with cell_data fields to differentiate. + keys : str or tuple[str, ...] or Sequence or None + Fields to compute gradients of (same format as + :func:`compute_point_derivatives`). + method : {"lsq"} + Discretization method for cell-centered data. Currently only + ``"lsq"`` (weighted least-squares) is implemented. DEC gradients + for cell-centered data are not available because the standard DEC + exterior derivative maps vertex 0-forms to edge 1-forms; there is + no analogous cell-to-cell operator in the primal DEC complex. + gradient_type : {"intrinsic", "extrinsic", "both"} + Type of gradient to compute. + + Returns + ------- + Mesh + A new Mesh with gradient fields added to ``cell_data``. The original + mesh is **not** modified. + + Raises + ------ + NotImplementedError + If ``method="dec"`` is requested. + """ + from physicsnemo.mesh.calculus.gradient import ( + compute_gradient_cells_lsq, + project_to_tangent_space, + ) + + ### Parse keys: normalize to list of key paths + if keys is None: + key_list = list( + mesh.cell_data.exclude(CACHE_KEY).keys( + include_nested=True, leaves_only=True + ) + ) + elif isinstance(keys, (str, tuple)): + key_list = [keys] + elif isinstance(keys, Sequence): + key_list = list(keys) + else: + raise TypeError(f"Invalid keys type: {type(keys)}") + + ### Clone cell_data so we don't mutate the original mesh + new_cell_data = mesh.cell_data.clone() + + ### Compute gradients for each key + for key in key_list: + field_values = mesh.cell_data[key] + + ### Compute extrinsic gradient + if method == "lsq": + grad_extrinsic = compute_gradient_cells_lsq(mesh, field_values) + elif method == "dec": + raise NotImplementedError( + "DEC cell gradients not yet implemented. Use method='lsq'." + ) + else: + raise ValueError(f"Invalid {method=}") + + ### Store gradients in the cloned cell_data + if gradient_type == "extrinsic": + new_cell_data[_make_output_key(key, "_gradient")] = grad_extrinsic + + elif gradient_type == "intrinsic": + grad_intrinsic = project_to_tangent_space(mesh, grad_extrinsic, "cells") + new_cell_data[_make_output_key(key, "_gradient")] = grad_intrinsic + + elif gradient_type == "both": + grad_intrinsic = project_to_tangent_space(mesh, grad_extrinsic, "cells") + new_cell_data[_make_output_key(key, "_gradient_extrinsic")] = grad_extrinsic + new_cell_data[_make_output_key(key, "_gradient_intrinsic")] = grad_intrinsic + + else: + raise ValueError(f"Invalid {gradient_type=}") + + ### Return a new Mesh with the augmented cell_data + from physicsnemo.mesh.mesh import Mesh + + return Mesh( + points=mesh.points, + cells=mesh.cells, + point_data=mesh.point_data, + cell_data=new_cell_data, + global_data=mesh.global_data, + ) diff --git a/physicsnemo/mesh/calculus/divergence.py b/physicsnemo/mesh/calculus/divergence.py new file mode 100644 index 0000000000..cf26f56e71 --- /dev/null +++ b/physicsnemo/mesh/calculus/divergence.py @@ -0,0 +1,159 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Divergence operator for vector fields. + +Implements divergence using both DEC and LSQ methods. + +The DEC divergence is the composition ⋆₀⁻¹ d* ⋆₁ ♭(X), where ♭ is the +PDP-flat operator (Hirani 2003, Section 5.6) that converts a vertex vector +field to a primal 1-form via midpoint averaging along edges. The composition +reduces to a weighted sum over edges: + + div(X)(v) = (1/|⋆v|) Σ_{edges [v,w]} w_ij × (X(v) + X(w))/2 · (w - v) + +where w_ij are the FEM cotangent weights (= |⋆e|/|e|) and |⋆v| is the dual +0-cell (Voronoi) volume. This is exact for linear vector fields at interior +vertices and first-order convergent on smooth fields. + +Physical interpretation: net flux through the dual cell boundary per unit +volume, with the PDP-flat providing the edge flux estimate. +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.utilities._tolerances import safe_eps + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def compute_divergence_points_dec( + mesh: "Mesh", + vector_field: torch.Tensor, +) -> torch.Tensor: + r"""Compute divergence at vertices using DEC: div = ⋆₀⁻¹ d* ⋆₁ ♭(X). + + For a vertex vector field X, the DEC divergence at vertex v is: + + .. math:: + + \operatorname{div}(X)(v) = \frac{1}{|{\star}v|} + \sum_{\text{edges } [v,w]} w_{vw}\; + \frac{X(v) + X(w)}{2} \cdot (w - v) + + where :math:`w_{vw} = |{\star}e|/|e|` is the FEM cotangent weight and + :math:`|{\star}v|` is the dual 0-cell volume (Voronoi area). + + The edge-length factors from the Hodge star and the PDP-flat cancel + algebraically: :math:`|{\star}e| \times (X \cdot \hat{e}) + = w \times |e| \times (X \cdot \vec{e}/|e|) = w \times (X \cdot \vec{e})`, + so only cotangent weights and full edge vectors are needed. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh of any manifold dimension. + vector_field : torch.Tensor + Vectors at vertices, shape ``(n_points, n_spatial_dims)``. + + Returns + ------- + torch.Tensor + Divergence at vertices, shape ``(n_points,)``. + """ + from physicsnemo.mesh.geometry.dual_meshes import ( + compute_cotan_weights_fem, + get_or_compute_dual_volumes_0, + ) + + n_points = mesh.n_points + + ### Get FEM cotangent weights and canonical edges (one consistent source) + cotan_weights, edges = compute_cotan_weights_fem(mesh) # (n_edges,), (n_edges, 2) + + ### Get dual 0-cell volumes |⋆v| at vertices + dual_volumes_0 = get_or_compute_dual_volumes_0(mesh) # (n_points,) + + ### Edge vectors: (w - v) for each canonical edge [v, w] with v < w + edge_vectors = ( + mesh.points[edges[:, 1]] - mesh.points[edges[:, 0]] + ) # (n_edges, n_spatial_dims) + + v0_indices = edges[:, 0] # (n_edges,) + v1_indices = edges[:, 1] # (n_edges,) + + ### PDP-flat 1-form value: = (X(v) + X(w))/2 . (w - v) + v_edge = ( + vector_field[v0_indices] + vector_field[v1_indices] + ) / 2 # (n_edges, n_spatial_dims) + flat_1form = (v_edge * edge_vectors).sum(dim=-1) # (n_edges,) + + ### Weighted flux: w_ij × + weighted_flux = cotan_weights * flat_1form # (n_edges,) + + ### Scatter-add to vertices with orientation signs + # v0 (smaller index): edge points outward from v0's dual cell → positive + # v1 (larger index): edge points inward to v1's dual cell → negative + divergence = torch.zeros( + n_points, dtype=vector_field.dtype, device=mesh.points.device + ) + divergence.scatter_add_(0, v0_indices, weighted_flux) + divergence.scatter_add_(0, v1_indices, -weighted_flux) + + ### Normalize by dual 0-cell volumes + divergence = divergence / dual_volumes_0.clamp(min=safe_eps(dual_volumes_0.dtype)) + + return divergence + + +def compute_divergence_points_lsq( + mesh: "Mesh", + vector_field: torch.Tensor, +) -> torch.Tensor: + """Compute divergence at vertices using LSQ gradient of each component. + + For vector field v = [vₓ, vᵧ, v_z]: + div(v) = ∂vₓ/∂x + ∂vᵧ/∂y + ∂v_z/∂z + + Computes the full Jacobian via a single batched LSQ solve, then takes + the trace. This is more efficient than solving each component separately, + because the adjacency construction, neighbor grouping, A-matrix assembly, + and batched lstsq are all performed once instead of ``n_spatial_dims`` + times. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + vector_field : torch.Tensor + Vectors at vertices, shape (n_points, n_spatial_dims) + + Returns + ------- + torch.Tensor + Divergence at vertices, shape (n_points,) + """ + from physicsnemo.mesh.calculus._lsq_reconstruction import compute_point_gradient_lsq + + ### Single call computes full Jacobian: J[i, j, k] = ∂v_j/∂x_k + # Shape: (n_points, n_spatial_dims, n_spatial_dims) + jacobian = compute_point_gradient_lsq(mesh, vector_field) + + ### Divergence = trace of Jacobian = Σ_k ∂v_k/∂x_k + return torch.einsum("...ii", jacobian) diff --git a/physicsnemo/mesh/calculus/gradient.py b/physicsnemo/mesh/calculus/gradient.py new file mode 100644 index 0000000000..b8eb3e5281 --- /dev/null +++ b/physicsnemo/mesh/calculus/gradient.py @@ -0,0 +1,223 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Gradient operators using both DEC and LSQ methods. + +Provides gradient computation via: +1. DEC (Discrete Exterior Calculus): grad(f) = ♯(df) - rigorous differential geometry +2. LSQ (Least-Squares): weighted reconstruction - standard CFD approach + +Both methods support intrinsic (tangent space) and extrinsic (ambient space) gradients +for manifolds embedded in higher-dimensional spaces. +""" + +from typing import TYPE_CHECKING, Literal + +import torch + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def compute_gradient_points_dec( + mesh: "Mesh", + point_values: torch.Tensor, +) -> torch.Tensor: + """Compute gradient at vertices using DEC: grad(f) = ♯(df). + + Steps: + 1. Apply exterior derivative d₀ to get 1-form on edges + 2. Apply sharp operator ♯ to convert 1-form to vector field + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + point_values : torch.Tensor + Values at vertices, shape (n_points,) or (n_points, ...) + + Returns + ------- + torch.Tensor + Gradient vectors at vertices, shape (n_points, n_spatial_dims) or + (n_points, n_spatial_dims, ...) for tensor fields + """ + from physicsnemo.mesh.calculus._exterior_derivative import exterior_derivative_0 + from physicsnemo.mesh.calculus._sharp_flat import sharp + + ### Step 1: Compute df (exterior derivative) + edge_1form, edges = exterior_derivative_0(mesh, point_values) + + ### Step 2: Apply sharp to convert 1-form to vector field + gradient_vectors = sharp(mesh, edge_1form, edges) + + return gradient_vectors + + +def compute_gradient_points_lsq( + mesh: "Mesh", + point_values: torch.Tensor, + weight_power: float = 2.0, + intrinsic: bool = False, +) -> torch.Tensor: + """Compute gradient at vertices using weighted least-squares. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + point_values : torch.Tensor + Values at vertices, shape (n_points,) or (n_points, ...) + weight_power : float + Exponent for inverse distance weighting + intrinsic : bool + If True and mesh is a manifold, solve LSQ in tangent space + + Returns + ------- + torch.Tensor + Gradient vectors at vertices, shape (n_points, n_spatial_dims) or + (n_points, n_spatial_dims, ...) for tensor fields + """ + if intrinsic and mesh.codimension > 0: + # Use intrinsic LSQ (solves in tangent space) + from physicsnemo.mesh.calculus._lsq_intrinsic import ( + compute_point_gradient_lsq_intrinsic, + ) + + return compute_point_gradient_lsq_intrinsic(mesh, point_values, weight_power) + else: + # Use standard ambient-space LSQ + from physicsnemo.mesh.calculus._lsq_reconstruction import ( + compute_point_gradient_lsq, + ) + + return compute_point_gradient_lsq(mesh, point_values, weight_power) + + +def compute_gradient_cells_lsq( + mesh: "Mesh", + cell_values: torch.Tensor, + weight_power: float = 2.0, +) -> torch.Tensor: + """Compute gradient at cells using weighted least-squares. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + cell_values : torch.Tensor + Values at cells, shape (n_cells,) or (n_cells, ...) + weight_power : float + Exponent for inverse distance weighting + + Returns + ------- + torch.Tensor + Gradient vectors at cells, shape (n_cells, n_spatial_dims) or + (n_cells, n_spatial_dims, ...) for tensor fields + """ + from physicsnemo.mesh.calculus._lsq_reconstruction import compute_cell_gradient_lsq + + return compute_cell_gradient_lsq(mesh, cell_values, weight_power) + + +def project_to_tangent_space( + mesh: "Mesh", + gradients: torch.Tensor, + location: Literal["points", "cells"], +) -> torch.Tensor: + """Project gradients onto manifold tangent space for intrinsic derivatives. + + For manifolds where n_manifold_dims < n_spatial_dims (e.g., surfaces in 3D), + the intrinsic gradient lies in the tangent space of the manifold. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + gradients : torch.Tensor + Extrinsic gradients, shape (n, n_spatial_dims, ...) + location : Literal["points", "cells"] + Whether gradients are at "points" or "cells" + + Returns + ------- + torch.Tensor + Intrinsic gradients (projected onto tangent space), + same shape as input + + Notes + ----- + Algorithm: + For codimension-1 manifolds: + 1. Get normal vector at each point/cell + 2. Project gradient: grad_intrinsic = grad - (grad·n)n + + For higher codimension: + Use PCA on local neighborhood to estimate tangent space + """ + if mesh.codimension == 0: + # Manifold fills the space: intrinsic = extrinsic + return gradients + + elif mesh.codimension == 1: + ### Codimension-1: use normals for projection + if location == "cells": + # Use cell normals + normals = mesh.cell_normals # (n_cells, n_spatial_dims) + else: + # For points, use area-weighted averaged normals from adjacent cells + # This is already computed and cached by mesh.point_normals + normals = mesh.point_normals # (n_points, n_spatial_dims) + + ### Project: grad_intrinsic = grad - (grad·n)n + # grad·n contracts along the spatial dimension (dim=1 for gradients) + if gradients.ndim == 2: + # Scalar gradient: (n, n_spatial_dims) + grad_dot_n = (gradients * normals).sum(dim=-1, keepdim=True) # (n, 1) + grad_intrinsic = gradients - grad_dot_n * normals # (n, n_spatial_dims) + else: + # Tensor gradient: (n, n_spatial_dims, ...) + # Contract along spatial dimension (dim=1) + # normals is (n, n_spatial_dims), need to broadcast to match gradient shape + + # Expand normals to (n, n_spatial_dims, 1, 1, ...) + normals_expanded = normals.view( + normals.shape[0], # n + normals.shape[1], # n_spatial_dims + *([1] * (gradients.ndim - 2)), # broadcast dimensions + ) + + # Dot product: sum over spatial dimension + grad_dot_n = (gradients * normals_expanded).sum( + dim=1, keepdim=True + ) # (n, 1, ...) + + # Project out normal component + grad_intrinsic = ( + gradients - grad_dot_n * normals_expanded + ) # (n, n_spatial_dims, ...) + + return grad_intrinsic + + else: + ### Higher codimension: use PCA to estimate tangent space + from physicsnemo.mesh.calculus._pca_tangent import ( + project_gradient_to_tangent_space_pca, + ) + + return project_gradient_to_tangent_space_pca(mesh, gradients) diff --git a/physicsnemo/mesh/calculus/laplacian.py b/physicsnemo/mesh/calculus/laplacian.py new file mode 100644 index 0000000000..e57ea70ece --- /dev/null +++ b/physicsnemo/mesh/calculus/laplacian.py @@ -0,0 +1,178 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Laplace-Beltrami operator for scalar fields. + +The Laplace-Beltrami operator is the generalization of the Laplacian to +curved manifolds. + +This implementation uses the analyst's sign convention: + Δf(v₀) = (1/|⋆v₀|) Σ_{edges from v₀} (|⋆e|/|e|)(f(v) - f(v₀)) + +which is positive for locally convex functions (e.g., Δ(x²) = 2). + +For functions (0-forms), this gives the discrete Laplace-Beltrami operator +which reduces to the standard Laplacian on flat manifolds. + +This is the cotangent Laplacian, intrinsic to the manifold. +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.utilities._tolerances import safe_eps + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def _apply_cotan_laplacian_operator( + n_vertices: int, + edges: torch.Tensor, + cotan_weights: torch.Tensor, + data: torch.Tensor, +) -> torch.Tensor: + """Apply cotangent Laplacian operator to data via scatter-add. + + Computes: (L @ data)[i] = Σ_{j adjacent to i} w_ij * (data[j] - data[i]) + + This is the core scatter-add pattern shared by all cotangent Laplacian computations. + Used by both compute_laplacian_points_dec() for scalar fields and + compute_laplacian_at_points() in curvature module for point coordinates. + + Parameters + ---------- + n_vertices : int + Number of vertices + edges : torch.Tensor + Edge connectivity, shape (n_edges, 2) + cotan_weights : torch.Tensor + Cotangent weights for each edge, shape (n_edges,) + data : torch.Tensor + Data at vertices, shape (n_vertices, *data_shape) + + Returns + ------- + torch.Tensor + Laplacian applied to data, shape (n_vertices, *data_shape) + + Examples + -------- + >>> import torch + >>> # For scalar field + >>> n_points, edges = 4, torch.tensor([[0, 1], [1, 2], [0, 2]]) + >>> weights = torch.ones(3) + >>> scalar_field = torch.randn(4) + >>> laplacian = _apply_cotan_laplacian_operator(n_points, edges, weights, scalar_field) + """ + ### Initialize output with same shape as data + device = data.device + if data.ndim == 1: + laplacian = torch.zeros(n_vertices, dtype=data.dtype, device=device) + else: + laplacian = torch.zeros_like(data) + + ### Extract vertex indices + v0_indices = edges[:, 0] # (n_edges,) + v1_indices = edges[:, 1] # (n_edges,) + + ### Compute weighted differences + if data.ndim == 1: + # Scalar case + contrib_v0 = cotan_weights * (data[v1_indices] - data[v0_indices]) + contrib_v1 = cotan_weights * (data[v0_indices] - data[v1_indices]) + laplacian.scatter_add_(0, v0_indices, contrib_v0) + laplacian.scatter_add_(0, v1_indices, contrib_v1) + else: + # Multi-dimensional case (vectors, tensors) + # Broadcast weights to match data dimensions + weights_expanded = cotan_weights.view(-1, *([1] * (data.ndim - 1))) + contrib_v0 = weights_expanded * (data[v1_indices] - data[v0_indices]) + contrib_v1 = weights_expanded * (data[v0_indices] - data[v1_indices]) + + # Flatten for scatter_add + laplacian_flat = laplacian.reshape(n_vertices, -1) + contrib_v0_flat = contrib_v0.reshape(len(edges), -1) + contrib_v1_flat = contrib_v1.reshape(len(edges), -1) + + v0_expanded = v0_indices.unsqueeze(-1).expand(-1, contrib_v0_flat.shape[1]) + v1_expanded = v1_indices.unsqueeze(-1).expand(-1, contrib_v1_flat.shape[1]) + + laplacian_flat.scatter_add_(0, v0_expanded, contrib_v0_flat) + laplacian_flat.scatter_add_(0, v1_expanded, contrib_v1_flat) + + laplacian = laplacian_flat.reshape(laplacian.shape) + + return laplacian + + +def compute_laplacian_points_dec( + mesh: "Mesh", + point_values: torch.Tensor, +) -> torch.Tensor: + """Compute Laplace-Beltrami at vertices using DEC cotangent formula. + + This is the INTRINSIC Laplacian - it automatically respects the manifold structure. + + Formula: Δf(v₀) = (1/|⋆v₀|) Σ_{edges from v₀} (|⋆e|/|e|)(f(v) - f(v₀)) + + Where: + - |⋆v₀| is the dual 0-cell volume (Voronoi cell around vertex) + - |⋆e| is the dual 1-cell volume (dual to edge) + - |e| is the edge length + - The ratio |⋆e|/|e| are the cotangent weights + + Parameters + ---------- + mesh : Mesh + Simplicial mesh + point_values : torch.Tensor + Values at vertices, shape (n_points,) or (n_points, ...) + + Returns + ------- + torch.Tensor + Laplacian at vertices, same shape as input + """ + from physicsnemo.mesh.geometry.dual_meshes import ( + compute_cotan_weights_fem, + get_or_compute_dual_volumes_0, + ) + + ### Get cotangent weights and edges via FEM stiffness matrix (works for any dimension) + cotan_weights, sorted_edges = compute_cotan_weights_fem(mesh) + + ### Apply cotangent Laplacian operator using shared utility + laplacian = _apply_cotan_laplacian_operator( + n_vertices=mesh.n_points, + edges=sorted_edges, + cotan_weights=cotan_weights, + data=point_values, + ) + + ### Normalize by Voronoi areas + # Standard cotangent Laplacian: Δf_i = (1/A_voronoi_i) × accumulated_sum + dual_volumes_0 = get_or_compute_dual_volumes_0(mesh) + + if point_values.ndim == 1: + laplacian = laplacian / dual_volumes_0.clamp(min=safe_eps(dual_volumes_0.dtype)) + else: + laplacian = laplacian / dual_volumes_0.view( + -1, *([1] * (point_values.ndim - 1)) + ).clamp(min=safe_eps(dual_volumes_0.dtype)) + + return laplacian diff --git a/physicsnemo/mesh/curvature/__init__.py b/physicsnemo/mesh/curvature/__init__.py new file mode 100644 index 0000000000..8c43cd2d3f --- /dev/null +++ b/physicsnemo/mesh/curvature/__init__.py @@ -0,0 +1,52 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Curvature computation for simplicial meshes. + +This module provides discrete differential geometry tools for computing +intrinsic and extrinsic curvatures on n-dimensional simplicial manifolds. + +Gaussian Curvature (Intrinsic): +- Angle defect method: K = (full_angle - Σ angles) / voronoi_area +- Works for any codimension (intrinsic property) +- Measures intrinsic geometry (Theorema Egregium) + +Mean Curvature (Extrinsic): +- Cotangent Laplacian method: H = ||L @ points|| / (2 * voronoi_area) +- Requires codimension-1 (needs normal vectors) +- Measures extrinsic bending + +Example: + >>> from physicsnemo.mesh.curvature import gaussian_curvature_vertices, mean_curvature_vertices + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> mesh = sphere_icosahedral.load(subdivisions=2) + >>> + >>> # Compute Gaussian curvature + >>> K = gaussian_curvature_vertices(mesh) + >>> + >>> # Compute mean curvature (codimension-1 only) + >>> H = mean_curvature_vertices(mesh) + >>> + >>> # Or use Mesh properties: + >>> K = mesh.gaussian_curvature_vertices + >>> H = mesh.mean_curvature_vertices +""" + +from physicsnemo.mesh.curvature.gaussian import ( + gaussian_curvature_cells, + gaussian_curvature_vertices, +) +from physicsnemo.mesh.curvature.mean import mean_curvature_vertices diff --git a/physicsnemo/mesh/curvature/_angles.py b/physicsnemo/mesh/curvature/_angles.py new file mode 100644 index 0000000000..faeba3cfc7 --- /dev/null +++ b/physicsnemo/mesh/curvature/_angles.py @@ -0,0 +1,190 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Angle computation for curvature calculations. + +Computes angles and solid angles at vertices in n-dimensional simplicial meshes. +For manifold dimension >= 2, delegates to the unified formula in +:mod:`physicsnemo.mesh.geometry._angles`. The 1D case (edge meshes) requires +special handling because the relevant quantity is the *inter-cell* turning +angle between adjacent edges, not an intra-cell interior angle. +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.curvature._utils import stable_angle_between_vectors +from physicsnemo.mesh.geometry._angles import compute_vertex_angle_sums + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def compute_angles_at_vertices(mesh: "Mesh") -> torch.Tensor: + """Compute sum of angles at each vertex over all incident cells. + + For manifold dimension >= 2, uses the unified correlation-matrix formula + from :func:`~physicsnemo.mesh.geometry._angles.compute_vertex_angle_sums`. + For 1D manifolds (edge meshes), computes the inter-cell turning angle + between adjacent edges at each vertex. + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh. + + Returns + ------- + torch.Tensor + Tensor of shape ``(n_points,)`` containing sum of angles at each vertex. + For isolated vertices, angle is 0. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> triangle_mesh = two_triangles_2d.load() + >>> angles = compute_angles_at_vertices(triangle_mesh) + >>> # Angles are computed at each vertex + """ + ### For 2D+ manifolds, delegate to the unified geometry primitive + if mesh.n_manifold_dims >= 2: + return compute_vertex_angle_sums(mesh) + + ### 1D manifolds (edges): inter-cell turning angle at each vertex + # This is conceptually different from intra-cell angles: we need the + # angle between adjacent edges sharing a vertex, which requires + # examining the cell connectivity. + + device = mesh.points.device + n_points = mesh.n_points + + angle_sums = torch.zeros(n_points, dtype=mesh.points.dtype, device=device) + + if mesh.n_cells == 0: + return angle_sums + + from physicsnemo.mesh.neighbors import get_point_to_cells_adjacency + + adjacency = get_point_to_cells_adjacency(mesh) + + ### Group points by number of incident edges + neighbor_counts = adjacency.offsets[1:] - adjacency.offsets[:-1] # (n_points,) + + ### Handle most common case: exactly 2 incident edges (vectorized) + two_edge_mask = neighbor_counts == 2 + two_edge_indices = torch.where(two_edge_mask)[0] # (n_two_edge,) + + if len(two_edge_indices) > 0: + # Extract the two incident edges for each vertex + offsets_two_edge = adjacency.offsets[two_edge_indices] # (n_two_edge,) + edge0_cells = adjacency.indices[offsets_two_edge] # (n_two_edge,) + edge1_cells = adjacency.indices[offsets_two_edge + 1] # (n_two_edge,) + + # Get edge vertices: (n_two_edge, 2) + edge0_verts = mesh.cells[edge0_cells] + edge1_verts = mesh.cells[edge1_cells] + + # Determine incoming/outgoing edges + # Incoming: point_idx is at position 1 (edge = [prev, point_idx]) + # Outgoing: point_idx is at position 0 (edge = [point_idx, next]) + edge0_is_incoming = edge0_verts[:, 1] == two_edge_indices # (n_two_edge,) + + # Select prev/next vertices based on edge configuration + prev_vertex = torch.where( + edge0_is_incoming, + edge0_verts[:, 0], + edge1_verts[:, 0], + ) # (n_two_edge,) + next_vertex = torch.where( + edge0_is_incoming, + edge1_verts[:, 1], + edge0_verts[:, 1], + ) # (n_two_edge,) + + # Compute vectors + v_from_prev = ( + mesh.points[two_edge_indices] - mesh.points[prev_vertex] + ) # (n_two_edge, n_spatial_dims) + v_to_next = ( + mesh.points[next_vertex] - mesh.points[two_edge_indices] + ) # (n_two_edge, n_spatial_dims) + + # Compute interior angles + if mesh.n_spatial_dims == 2: + # 2D: Use signed angle with cross product + cross_z = ( + v_from_prev[:, 0] * v_to_next[:, 1] + - v_from_prev[:, 1] * v_to_next[:, 0] + ) # (n_two_edge,) + dot = (v_from_prev * v_to_next).sum(dim=-1) # (n_two_edge,) + + # Signed angle in range [-pi, pi] + signed_angle = torch.atan2(cross_z, dot) + + # Interior angle: pi - signed_angle + interior_angles = torch.pi - signed_angle + else: + # Higher dimensions: Use unsigned angle + interior_angles = stable_angle_between_vectors(v_from_prev, v_to_next) + + # Assign angles to vertices + angle_sums[two_edge_indices] = interior_angles + + ### Handle vertices with >2 edges (junctions) - rare, so small loop is acceptable + multi_edge_mask = neighbor_counts > 2 + multi_edge_indices = torch.where(multi_edge_mask)[0] + + for point_idx_tensor in multi_edge_indices: + point_idx = int(point_idx_tensor) + offset_start = int(adjacency.offsets[point_idx]) + offset_end = int(adjacency.offsets[point_idx + 1]) + incident_cells = adjacency.indices[offset_start:offset_end] + n_incident = len(incident_cells) + + # Get all incident edge vertices + edge_verts = mesh.cells[incident_cells] # (n_incident, 2) + + # Find the "other" vertex in each edge (not point_idx) + is_point = edge_verts == point_idx + other_indices = torch.where( + ~is_point, edge_verts, edge_verts.new_full(edge_verts.shape, -1) + ) + other_vertices = other_indices.max(dim=1).values # (n_incident,) + + # Compute vectors from point to all neighbors + vectors = ( + mesh.points[other_vertices] - mesh.points[point_idx] + ) # (n_incident, n_spatial_dims) + + # Compute all pairwise angles using broadcasting + v_i = vectors.unsqueeze(1) # (n_incident, 1, n_spatial_dims) + v_j = vectors.unsqueeze(0) # (1, n_incident, n_spatial_dims) + + pairwise_angles = stable_angle_between_vectors( + v_i.expand(-1, n_incident, -1).reshape(-1, mesh.n_spatial_dims), + v_j.expand(n_incident, -1, -1).reshape(-1, mesh.n_spatial_dims), + ).reshape(n_incident, n_incident) + + # Sum only upper triangle (i < j) to avoid double-counting + triu_indices = torch.triu_indices( + n_incident, n_incident, offset=1, device=device + ) + angle_sum = pairwise_angles[triu_indices[0], triu_indices[1]].sum() + + angle_sums[point_idx] = angle_sum + + return angle_sums diff --git a/physicsnemo/mesh/curvature/_laplacian.py b/physicsnemo/mesh/curvature/_laplacian.py new file mode 100644 index 0000000000..815e0da85f --- /dev/null +++ b/physicsnemo/mesh/curvature/_laplacian.py @@ -0,0 +1,99 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Direct cotangent Laplacian computation for mean curvature. + +Computes the cotangent Laplacian applied to point positions without building +the full matrix, for memory efficiency and performance. + +L @ points gives the mean curvature normal (times area). +""" + +from typing import TYPE_CHECKING + +import torch + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def compute_laplacian_at_points(mesh: "Mesh") -> torch.Tensor: + """Compute cotangent Laplacian applied to point positions directly. + + Computes L @ points where L is the cotangent Laplacian matrix, but + without explicitly building L (more efficient). + + For each vertex i: + (L @ points)_i = Σ_neighbors_j w_ij * (p_j - p_i) + + where w_ij are cotangent weights that depend on manifold dimension. + + Parameters + ---------- + mesh : Mesh + Input mesh (must be codimension-1 for mean curvature). + + Returns + ------- + torch.Tensor + Tensor of shape (n_points, n_spatial_dims) representing Laplacian + applied to point coordinates. + + Raises + ------ + ValueError + If codimension != 1 (mean curvature requires normals). + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> mesh = sphere_icosahedral.load(subdivisions=2) + >>> laplacian_coords = compute_laplacian_at_points(mesh) + >>> # Use for mean curvature: H = ||laplacian_coords|| / (2 * voronoi_area) + """ + ### Validate codimension + if mesh.codimension != 1: + raise ValueError( + f"Cotangent Laplacian for mean curvature requires codimension-1 manifolds.\n" + f"Got {mesh.n_manifold_dims=} and {mesh.n_spatial_dims=}, {mesh.codimension=}.\n" + f"Mean curvature is only defined for hypersurfaces (codimension-1)." + ) + + device = mesh.points.device + n_points = mesh.n_points + + ### Handle empty mesh + if mesh.n_cells == 0: + return torch.zeros( + (n_points, mesh.n_spatial_dims), + dtype=mesh.points.dtype, + device=device, + ) + + ### Compute cotangent weights and edges via FEM stiffness matrix + from physicsnemo.mesh.geometry.dual_meshes import compute_cotan_weights_fem + + cotangent_weights, unique_edges = compute_cotan_weights_fem(mesh) + + ### Apply cotangent Laplacian operator to point coordinates using shared utility + from physicsnemo.mesh.calculus.laplacian import _apply_cotan_laplacian_operator + + return _apply_cotan_laplacian_operator( + n_vertices=n_points, + edges=unique_edges, + cotan_weights=cotangent_weights, + data=mesh.points, + ) diff --git a/physicsnemo/mesh/curvature/_utils.py b/physicsnemo/mesh/curvature/_utils.py new file mode 100644 index 0000000000..1a6144f4fd --- /dev/null +++ b/physicsnemo/mesh/curvature/_utils.py @@ -0,0 +1,153 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Utility functions for curvature computations. + +Provides helper functions for computing angles, full angles in n-dimensions, +and numerically stable geometric operations. +""" + +import math + +import torch + + +def compute_full_angle_n_sphere(n_manifold_dims: int) -> float: + """Compute the full angle around a point in an n-dimensional manifold. + + This is the total solid angle/turning angle available at a point. + + For discrete differential geometry: + - 1D curves: Full turning angle is π (can turn left or right from straight) + - 2D surfaces: Full angle is 2π (can look 360° around a point) + - 3D volumes: Full solid angle is 4π (full sphere around a point) + - nD: Surface area of unit (n-1)-sphere + + Parameters + ---------- + n_manifold_dims : int + Manifold dimension + + Returns + ------- + float + Full angle for n-dimensional manifold: + - 1D: π + - 2D: 2π + - 3D: 4π + - nD: 2π^(n/2) / Γ(n/2) for n ≥ 2 + + Examples + -------- + >>> import math + >>> assert abs(compute_full_angle_n_sphere(1) - math.pi) < 1e-10 # π + >>> assert abs(compute_full_angle_n_sphere(2) - 2*math.pi) < 1e-5 # 2π + """ + + ### Special case for 1D: turning angle is π + if n_manifold_dims == 1: + return math.pi + + ### General case (n ≥ 2): Surface area of (n-1)-sphere + # Formula: 2π^(n/2) / Γ(n/2) + n = n_manifold_dims + return 2 * math.pi ** (n / 2.0) / math.exp(math.lgamma(n / 2.0)) + + +def stable_angle_between_vectors(v1: torch.Tensor, v2: torch.Tensor) -> torch.Tensor: + """Compute angle between vectors using numerically stable atan2 formula. + + More stable than using acos(dot product) which suffers from numerical + issues when vectors are nearly parallel or anti-parallel. + + Parameters + ---------- + v1 : torch.Tensor + First vector(s), shape (..., n_dims) + v2 : torch.Tensor + Second vector(s), shape (..., n_dims) + + Returns + ------- + torch.Tensor + Angle(s) in radians, shape (...) + Range: [0, π] + + Formula: + angle = atan2(||v1 × v2||, v1 · v2) + + For higher dimensions (>3), uses generalized cross product magnitude. + """ + ### Compute dot product + dot_product = (v1 * v2).sum(dim=-1) + + ### Compute cross product magnitude (generalized) + # For 2D/3D: ||v1 × v2|| = ||v1|| * ||v2|| * sin(θ) + # More generally: ||v1|| * ||v2|| * sin(θ) = sqrt(||v1||² * ||v2||² - (v1·v2)²) + v1_norm = torch.linalg.vector_norm(v1, dim=-1) + v2_norm = torch.linalg.vector_norm(v2, dim=-1) + + cross_magnitude_sq = v1_norm**2 * v2_norm**2 - dot_product**2 + # Clamp to avoid numerical issues with negative values near zero + cross_magnitude_sq = torch.clamp(cross_magnitude_sq, min=0) + cross_magnitude = torch.sqrt(cross_magnitude_sq) + + ### Compute angle using atan2 (stable) + angle = torch.atan2(cross_magnitude, dot_product) + + return angle + + +def compute_triangle_angles( + p0: torch.Tensor, + p1: torch.Tensor, + p2: torch.Tensor, +) -> torch.Tensor: + """Compute the angle at p0 in triangle (p0, p1, p2) using stable formula. + + Uses atan2-based computation for numerical stability. + + Parameters + ---------- + p0 : torch.Tensor + Vertex at which to compute angle, shape (..., n_spatial_dims) + p1 : torch.Tensor + Second vertex, shape (..., n_spatial_dims) + p2 : torch.Tensor + Third vertex, shape (..., n_spatial_dims) + + Returns + ------- + torch.Tensor + Angle at p0 in radians, shape (...) + + Examples + -------- + >>> # Right angle at origin + >>> p0 = torch.tensor([0., 0.]) + >>> p1 = torch.tensor([1., 0.]) + >>> p2 = torch.tensor([0., 1.]) + >>> angle = compute_triangle_angles(p0, p1, p2) + >>> assert torch.allclose(angle, torch.tensor(torch.pi / 2)) + """ + ### Compute edge vectors from p0 + edge1 = p1 - p0 # (..., n_spatial_dims) + edge2 = p2 - p0 # (..., n_spatial_dims) + + ### Compute angle using stable formula + angle = stable_angle_between_vectors(edge1, edge2) + + return angle diff --git a/physicsnemo/mesh/curvature/gaussian.py b/physicsnemo/mesh/curvature/gaussian.py new file mode 100644 index 0000000000..6abc56dd20 --- /dev/null +++ b/physicsnemo/mesh/curvature/gaussian.py @@ -0,0 +1,189 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Gaussian curvature computation for simplicial meshes. + +Implements intrinsic Gaussian curvature using angle defect method. +Works for any codimension (intrinsic property). + +For 2D surfaces: K = k1 * k2 where k1, k2 are principal curvatures +For 1D curves: K represents discrete turning angle +For 3D volumes: K represents volumetric angle defect + +Reference: Meyer et al. (2003), Discrete Gauss-Bonnet theorem +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.curvature._angles import compute_angles_at_vertices +from physicsnemo.mesh.curvature._utils import compute_full_angle_n_sphere +from physicsnemo.mesh.geometry.dual_meshes import compute_dual_volumes_0 +from physicsnemo.mesh.utilities._tolerances import safe_eps + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def gaussian_curvature_vertices(mesh: "Mesh") -> torch.Tensor: + """Compute intrinsic Gaussian curvature at mesh vertices. + + Uses the angle defect formula from discrete differential geometry: + K_vertex = angle_defect / voronoi_area + where: + angle_defect = full_angle(n) - Σ(angles at vertex in incident cells) + + This is an intrinsic measure of curvature that works for any codimension, + as it depends only on distances measured within the manifold (Theorema Egregium). + + Signed curvature: + - Positive: Elliptic point (sphere-like) + - Zero: Flat/parabolic point (plane-like) + - Negative: Hyperbolic point (saddle-like) + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh (1D, 2D, or 3D manifold) + + Returns + ------- + torch.Tensor + Tensor of shape (n_points,) containing signed Gaussian curvature at each vertex. + For isolated vertices (no incident cells), curvature is NaN. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> # Sphere of radius r has K = 1/r² everywhere + >>> sphere_mesh = sphere_icosahedral.load(radius=2.0, subdivisions=3) + >>> K = gaussian_curvature_vertices(sphere_mesh) + >>> # K.mean() ≈ 0.25 (= 1/(2.0)²) + + Notes + ----- + Satisfies discrete Gauss-Bonnet theorem: + Σ_vertices (K_i * A_i) = 2π * χ(M) + where χ(M) is the Euler characteristic. + """ + n_manifold_dims = mesh.n_manifold_dims + + ### Compute angle sums at each vertex + angle_sums = compute_angles_at_vertices(mesh) # (n_points,) + + ### Compute full angle for this manifold dimension + full_angle = compute_full_angle_n_sphere(n_manifold_dims) + + ### Compute angle defect + # angle_defect = full_angle - sum_of_angles + # Positive defect = positive curvature + angle_defect = full_angle - angle_sums # (n_points,) + + ### Compute dual volumes (Voronoi areas) + dual_volumes = compute_dual_volumes_0(mesh) # (n_points,) + + ### Compute Gaussian curvature + # K = angle_defect / dual_volume + # For isolated vertices (dual_volume = 0), this gives inf/nan + # Clamp areas to avoid division by zero, use inf for zero areas + dual_volumes_safe = torch.clamp(dual_volumes, min=safe_eps(dual_volumes.dtype)) + + gaussian_curvature = angle_defect / dual_volumes_safe + + # Set isolated vertices (zero dual volume) to NaN + gaussian_curvature = torch.where( + dual_volumes > 0, + gaussian_curvature, + torch.full_like(gaussian_curvature, float("nan")), + ) + + return gaussian_curvature + + +def gaussian_curvature_cells(mesh: "Mesh") -> torch.Tensor: + """Compute Gaussian curvature at cell centers. + + Averages the intrinsic vertex-based Gaussian curvature (angle defect) + over each cell's vertices. This gives a cell-centered curvature field + that is consistent with the vertex-based curvature and inherits its + mathematical properties (intrinsic, satisfies discrete Gauss-Bonnet). + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh + + Returns + ------- + torch.Tensor + Tensor of shape (n_cells,) containing Gaussian curvature at each cell. + Cells whose vertices all have NaN curvature are set to NaN. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> sphere_mesh = sphere_icosahedral.load(subdivisions=2) + >>> K_cells = gaussian_curvature_cells(sphere_mesh) + >>> # Should be positive for sphere + """ + device = mesh.points.device + n_cells = mesh.n_cells + + ### Handle empty mesh + if n_cells == 0: + return torch.zeros(0, dtype=mesh.points.dtype, device=device) + + ### Compute vertex Gaussian curvature (intrinsic, angle-defect based) + K_vertices = gaussian_curvature_vertices(mesh) # (n_points,) + + ### Average vertex curvature to cell centers + # For each cell, take the mean of its vertices' curvatures, ignoring NaN. + cell_vertex_K = K_vertices[mesh.cells] # (n_cells, n_verts_per_cell) + + # Mask NaN vertices (isolated vertices with no incident cells) + valid = ~torch.isnan(cell_vertex_K) # (n_cells, n_verts_per_cell) + n_valid = valid.sum(dim=1) # (n_cells,) + + # Replace NaN with 0 for summation, then divide by count of valid vertices + cell_vertex_K_safe = torch.where( + valid, cell_vertex_K, torch.zeros_like(cell_vertex_K) + ) + K_sum = cell_vertex_K_safe.sum(dim=1) # (n_cells,) + K_cells = K_sum / n_valid.clamp(min=1).to(K_sum.dtype) + + # Set cells with no valid vertices to NaN + K_cells = torch.where( + n_valid > 0, + K_cells, + torch.full_like(K_cells, float("nan")), + ) + + ### Set boundary cells to NaN. + # Boundary vertices have incomplete angular neighborhoods, giving + # spuriously large curvature values. Cells that touch the boundary + # inherit those values and should be excluded. + from physicsnemo.mesh.boundaries._detection import get_boundary_vertices + + is_boundary_vertex = get_boundary_vertices(mesh) # (n_points,) + cell_touches_boundary = is_boundary_vertex[mesh.cells].any(dim=1) # (n_cells,) + K_cells = torch.where( + cell_touches_boundary, + torch.full_like(K_cells, float("nan")), + K_cells, + ) + + return K_cells diff --git a/physicsnemo/mesh/curvature/mean.py b/physicsnemo/mesh/curvature/mean.py new file mode 100644 index 0000000000..ccab524b18 --- /dev/null +++ b/physicsnemo/mesh/curvature/mean.py @@ -0,0 +1,162 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Mean curvature computation for simplicial meshes. + +Implements extrinsic mean curvature using the cotangent Laplace-Beltrami operator. +Only works for codimension-1 manifolds (surfaces with well-defined normals). + +For 2D surfaces: H = (k1 + k2) / 2 where k1, k2 are principal curvatures +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.curvature._laplacian import compute_laplacian_at_points +from physicsnemo.mesh.geometry.dual_meshes import compute_dual_volumes_0 +from physicsnemo.mesh.utilities._tolerances import safe_eps + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def mean_curvature_vertices( + mesh: "Mesh", + include_boundary: bool = False, +) -> torch.Tensor: + """Compute extrinsic mean curvature at mesh vertices. + + Uses the cotangent Laplace-Beltrami operator: + H_vertex = (1/2) * ||L @ points|| / voronoi_area + + where L is the cotangent Laplacian. The Laplacian of the embedding coordinates + gives the mean curvature normal vector, whose magnitude is the mean curvature. + + Mean curvature is an extrinsic measure (depends on embedding in ambient space) + and is only defined for codimension-1 manifolds where normals exist. + + Signed curvature: + - Sign determined by normal orientation + - Positive: Convex (outward bulging like sphere exterior) + - Negative: Concave (inward curving like sphere interior) + - Zero: Minimal surface (soap film) + + Parameters + ---------- + mesh : Mesh + Input mesh (must be codimension-1) + include_boundary : bool, optional + If False, boundary vertices are set to NaN (default). + If True, computes curvature at boundary vertices using available + neighbors (Neumann-like boundary condition). This may be less accurate + at boundaries but provides complete coverage. + + Returns + ------- + torch.Tensor + Tensor of shape (n_points,) containing signed mean curvature at each vertex. + For isolated vertices, mean curvature is NaN. + For boundary vertices, NaN if include_boundary=False, otherwise computed. + + Raises + ------ + ValueError + If mesh is not codimension-1 + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> # Sphere of radius r has H = 1/r everywhere + >>> sphere = sphere_icosahedral.load(radius=2.0, subdivisions=3) + >>> H = mean_curvature_vertices(sphere) + >>> # H.mean() ≈ 0.5 (= 1/2.0) + + Notes + ----- + For a sphere with outward normals, H > 0. + For minimal surfaces (soap films), H = 0. + """ + ### Validate codimension (done in compute_laplacian_at_points) + + ### Compute Laplacian applied to points + laplacian_coords = compute_laplacian_at_points(mesh) # (n_points, n_spatial_dims) + + ### Compute magnitude of mean curvature normal + # ||L @ points|| gives 2 * H * voronoi_area + laplacian_magnitude = torch.norm(laplacian_coords, dim=-1) # (n_points,) + + ### Compute dual volumes (Voronoi areas) + dual_volumes = compute_dual_volumes_0(mesh) # (n_points,) + + ### Compute mean curvature + # H = ||L @ points|| / (2 * dual_volume) + dual_volumes_safe = torch.clamp(dual_volumes, min=safe_eps(dual_volumes.dtype)) + mean_curvature = laplacian_magnitude / (2.0 * dual_volumes_safe) + + ### Determine sign using normal orientation + # The mean curvature normal is: H * n = (1/2) * L @ points + # For a sphere with outward normals, L @ points points INWARD (toward center) + # But we want H > 0 for convex surfaces, so: + # sign = -sign(L · n) to flip the convention + + point_normals = mesh.point_normals # (n_points, n_spatial_dims) + + # Normalize laplacian_coords first + laplacian_normalized = torch.nn.functional.normalize( + laplacian_coords, dim=-1, eps=1e-12 + ) + + # Sign from dot product (NEGATIVE of dot product for correct convention) + # Positive curvature when Laplacian opposes normal (convex like sphere) + sign = -torch.sign((laplacian_normalized * point_normals).sum(dim=-1)) + + # Handle zero magnitude case (flat regions) + sign = torch.where( + laplacian_magnitude > 1e-10, + sign, + torch.ones_like(sign), # Default to positive for zero curvature + ) + + # Apply sign + mean_curvature = mean_curvature * sign + + ### Set isolated vertices to NaN + mean_curvature = torch.where( + dual_volumes > 0, + mean_curvature, + torch.full_like(mean_curvature, float("nan")), + ) + + ### Handle boundary vertices + # The cotangent Laplacian formula assumes a complete neighborhood around each vertex. + # For boundary vertices, we can either: + # 1. Set to NaN (conservative, default) + # 2. Compute using available neighbors (Neumann-like boundary condition) + + if not include_boundary: + from physicsnemo.mesh.boundaries import get_boundary_vertices + + is_boundary_vertex = get_boundary_vertices(mesh) + + # Set boundary vertices to NaN + mean_curvature = torch.where( + is_boundary_vertex, + torch.full_like(mean_curvature, float("nan")), + mean_curvature, + ) + + return mean_curvature diff --git a/physicsnemo/mesh/geometry/__init__.py b/physicsnemo/mesh/geometry/__init__.py new file mode 100644 index 0000000000..6c422bbeb0 --- /dev/null +++ b/physicsnemo/mesh/geometry/__init__.py @@ -0,0 +1,42 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Geometric primitives and computations for simplicial meshes. + +This module contains fundamental geometric operations that are shared across +the codebase, including: +- Interior angle computation for n-simplices +- Dual mesh (Voronoi/circumcentric) computations +- Circumcenter calculations +- Support volume computations (for DEC) +- Geometric utility functions + +These are used by both DEC operators (calculus module) and differential +geometry computations (curvature module). +""" + +from physicsnemo.mesh.geometry._angles import ( + compute_vertex_angle_sums, + compute_vertex_angles, +) +from physicsnemo.mesh.geometry.dual_meshes import ( + compute_circumcenters, + compute_cotan_weights_fem, + compute_dual_volumes_0, + compute_dual_volumes_1, + get_or_compute_circumcenters, + get_or_compute_dual_volumes_0, +) diff --git a/physicsnemo/mesh/geometry/_angles.py b/physicsnemo/mesh/geometry/_angles.py new file mode 100644 index 0000000000..e4bdbf3b12 --- /dev/null +++ b/physicsnemo/mesh/geometry/_angles.py @@ -0,0 +1,195 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Interior angle computation for simplicial meshes. + +Computes generalized interior angles at vertices of n-simplices using a +dimension-agnostic formula based on correlation (normalized Gram) matrices. +The formula unifies planar angles (triangles), solid angles (tetrahedra), +and higher-dimensional generalizations into a single expression. + +This module provides two levels of abstraction: + +- :func:`compute_vertex_angles`: Per-cell-per-vertex angles, shape + ``(n_cells, n_vertices_per_cell)``. This is the fundamental geometric + primitive, used by normal weighting and quality metrics. + +- :func:`compute_vertex_angle_sums`: Per-vertex angle sums, shape + ``(n_points,)``. This aggregates angles across all incident cells, + used by Gaussian curvature (angle defect method). + +Reference: + Van Oosterom, A. & Strackee, J. (1983). "The Solid Angle of a Plane + Triangle." IEEE Trans. Biomed. Eng. BME-30(2):125-126. +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.utilities._tolerances import safe_eps + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def compute_vertex_angles(mesh: "Mesh") -> torch.Tensor: + """Compute generalized interior angles at each vertex of each cell. + + For an n-simplex, the "angle" at a vertex is computed using the unified + formula that generalizes to arbitrary dimensions: + + Omega = 2 * arctan(sqrt(det(C)) / (1 + sum_{i>> import torch + >>> from physicsnemo.mesh import Mesh + >>> # Equilateral triangle: all angles should be pi/3 + >>> pts = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 0.866025]]) + >>> cells = torch.tensor([[0, 1, 2]]) + >>> mesh = Mesh(points=pts, cells=cells) + >>> angles = compute_vertex_angles(mesh) + >>> angles.shape + torch.Size([1, 3]) + """ + n_edges = mesh.n_manifold_dims # edges emanating from each vertex + input_dtype = mesh.points.dtype + + ### Upcast to float64 for the correlation matrix and determinant + # The correlation matrix C_ij = cos(angle_ij) suffers catastrophic + # cancellation in float32 when angles are near 0 or pi, because + # cos(epsilon) = 1 - epsilon^2/2 is indistinguishable from 1.0. + # Computing in float64 avoids this with negligible overhead. + cell_vertices = mesh.points[mesh.cells].double() + + ### Build edge vectors for all vertices simultaneously + # For each vertex k, edges[k, i] = v_{(k+i+1) mod n_verts} - v_k + # Shape: (n_cells, n_verts, n_edges, n_spatial_dims) + edges = torch.stack( + [ + torch.roll(cell_vertices, shifts=-(i + 1), dims=1) - cell_vertices + for i in range(n_edges) + ], + dim=2, + ) + + ### Compute edge lengths: (n_cells, n_verts, n_edges) + edge_lengths = edges.norm(dim=-1) + + ### Compute normalized edges: (n_cells, n_verts, n_edges, n_spatial_dims) + edges_normalized = edges / edge_lengths.unsqueeze(-1).clamp( + min=safe_eps(torch.float64) + ) + + ### Compute correlation matrix C for each vertex of each cell + # C[i,j] = normalized_edge_i . normalized_edge_j + # Shape: (n_cells, n_verts, n_edges, n_edges) + corr_matrix = torch.einsum("cvid,cvjd->cvij", edges_normalized, edges_normalized) + + ### Compute det(C) for each vertex: (n_cells, n_verts) + det_C = torch.linalg.det(corr_matrix) + + ### Compute sum of upper-triangle off-diagonal elements: sum_{i torch.Tensor: + """Compute the sum of interior angles at each vertex over all incident cells. + + For each vertex, sums the generalized interior angle contributed by every + cell incident to that vertex. This is the quantity used in the angle defect + formula for discrete Gaussian curvature: + + K_v = (full_angle - angle_sum_v) / voronoi_area_v + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh. + + Returns + ------- + torch.Tensor + Tensor of shape ``(n_points,)`` containing the summed angle at each + vertex. Isolated vertices (no incident cells) have angle sum 0. + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh import Mesh + >>> # Two triangles sharing an edge: interior vertex has angle sum = 2*pi/3 + 2*pi/3 + >>> pts = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 0.866025], [0.5, -0.866025]]) + >>> cells = torch.tensor([[0, 1, 2], [0, 3, 1]]) + >>> mesh = Mesh(points=pts, cells=cells) + >>> sums = compute_vertex_angle_sums(mesh) + >>> sums.shape + torch.Size([4]) + """ + ### Compute per-cell-per-vertex angles + angles = compute_vertex_angles(mesh) # (n_cells, n_verts_per_cell) + + ### Scatter-add angles to their corresponding vertex indices + angle_sums = torch.zeros( + mesh.n_points, dtype=mesh.points.dtype, device=mesh.points.device + ) + angle_sums.scatter_add_(0, mesh.cells.reshape(-1), angles.reshape(-1)) + + return angle_sums diff --git a/physicsnemo/mesh/geometry/dual_meshes.py b/physicsnemo/mesh/geometry/dual_meshes.py new file mode 100644 index 0000000000..f80b037a47 --- /dev/null +++ b/physicsnemo/mesh/geometry/dual_meshes.py @@ -0,0 +1,691 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Dual mesh (circumcentric/Voronoi) volume computation and DEC dual operators. + +This module provides the unified implementation of dual cell volumes (Voronoi regions), +circumcenters, and cotangent weights for n-dimensional simplicial meshes. These are +fundamental to both: +- Discrete Exterior Calculus (DEC) operators (Hodge star, Laplacian, etc.) +- Discrete differential geometry (curvature computations) + +Dual 0-cell volumes follow Meyer et al. (2003) for 2D manifolds, using the mixed +Voronoi area approach that handles both acute and obtuse triangles correctly. +For higher dimensions, barycentric approximation is used as rigorous circumcentric +dual volumes require well-centered meshes (Desbrun et al. 2005, Hirani 2003). + +Circumcenters and cotangent weights are computed using the perpendicular bisector +method and FEM stiffness matrix approach, respectively, following Desbrun et al. +"Discrete Exterior Calculus", Section 2. + +References: + Meyer, M., Desbrun, M., Schröder, P., & Barr, A. H. (2003). + "Discrete Differential-Geometry Operators for Triangulated 2-Manifolds". VisMath. + + Desbrun, M., Hirani, A. N., Leok, M., & Marsden, J. E. (2005). + "Discrete Exterior Calculus". arXiv:math/0508341. + + Hirani, A. N. (2003). "Discrete Exterior Calculus". PhD thesis, Caltech. +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.utilities._cache import get_cached, set_cached +from physicsnemo.mesh.utilities._tolerances import safe_eps + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def _scatter_add_cell_contributions_to_vertices( + dual_volumes: torch.Tensor, # shape: (n_points,) + cells: torch.Tensor, # shape: (n_selected_cells, n_vertices_per_cell) + contributions: torch.Tensor, # shape: (n_selected_cells,) +) -> None: + """Scatter cell volume contributions to all cell vertices. + + This is a common pattern in dual volume computation where each cell + contributes a fraction of its volume to each of its vertices. + + Parameters + ---------- + dual_volumes : torch.Tensor + Accumulator for dual volumes (modified in place) + cells : torch.Tensor + Cell connectivity for selected cells + contributions : torch.Tensor + Volume contribution from each cell to its vertices + + Examples + -------- + >>> import torch + >>> # Add 1/3 of each triangle area to each vertex + >>> dual_volumes = torch.zeros(4) + >>> triangle_cells = torch.tensor([[0, 1, 2], [1, 2, 3]]) + >>> triangle_areas = torch.tensor([0.5, 0.5]) + >>> _scatter_add_cell_contributions_to_vertices( + ... dual_volumes, triangle_cells, triangle_areas / 3.0 + ... ) + """ + n_vertices_per_cell = cells.shape[1] + for vertex_idx in range(n_vertices_per_cell): + dual_volumes.scatter_add_( + 0, + cells[:, vertex_idx], + contributions, + ) + + +def _compute_meyer_mixed_voronoi_areas( + cell_vertices: torch.Tensor, # (n_cells, 3, n_spatial_dims) + cell_areas: torch.Tensor, # (n_cells,) +) -> torch.Tensor: + """Compute per-(cell, local_vertex) mixed Voronoi areas (Meyer et al. 2003). + + This implements the branchless mixed Voronoi area formula for triangular meshes, + handling both acute and obtuse triangles correctly. For acute triangles, uses the + circumcentric Voronoi formula (Meyer Eq. 7). For obtuse triangles, uses the + mixed area subdivision (Meyer Fig. 4). + + Parameters + ---------- + cell_vertices : torch.Tensor + Vertex positions for each triangle cell. + Shape: (n_cells, 3, n_spatial_dims) + cell_areas : torch.Tensor + Area of each triangle cell. + Shape: (n_cells,) + + Returns + ------- + torch.Tensor + Per-(cell, local_vertex) Voronoi areas, shape (n_cells * 3,). + Ordered as [cell0_v0, cell0_v1, cell0_v2, cell1_v0, ...], i.e. + the flattened (n_cells, 3) tensor where column j corresponds to + local vertex j. + + References + ---------- + Meyer, M., Desbrun, M., Schröder, P., & Barr, A. H. (2003). + "Discrete Differential-Geometry Operators for Triangulated 2-Manifolds". + Section 3.3 (Equation 7) and Section 3.4 (Figure 4). + """ + from physicsnemo.mesh.curvature._utils import compute_triangle_angles + + n_cells = cell_vertices.shape[0] + device = cell_vertices.device + dtype = cell_vertices.dtype + + ### Compute all 3 angles in a single vectorized call (E6 optimization) + # Stack the 3 vertex permutations so compute_triangle_angles is called once + # instead of three times. Each permutation computes the angle at a different + # vertex of the triangle. + # Permutation 0: angle at vertex 0 -> (v0, v1, v2) + # Permutation 1: angle at vertex 1 -> (v1, v2, v0) + # Permutation 2: angle at vertex 2 -> (v2, v0, v1) + stacked_p0 = torch.cat( + [ + cell_vertices[:, 0, :], + cell_vertices[:, 1, :], + cell_vertices[:, 2, :], + ], + dim=0, + ) # (3 * n_cells, n_spatial_dims) + stacked_p1 = torch.cat( + [ + cell_vertices[:, 1, :], + cell_vertices[:, 2, :], + cell_vertices[:, 0, :], + ], + dim=0, + ) # (3 * n_cells, n_spatial_dims) + stacked_p2 = torch.cat( + [ + cell_vertices[:, 2, :], + cell_vertices[:, 0, :], + cell_vertices[:, 1, :], + ], + dim=0, + ) # (3 * n_cells, n_spatial_dims) + + stacked_angles = compute_triangle_angles( + stacked_p0, stacked_p1, stacked_p2 + ) # (3 * n_cells,) + + # Unstack into (n_cells, 3) where column j = angle at local vertex j + all_angles = stacked_angles.reshape(3, n_cells).T # (n_cells, 3) + + # Check if triangle is obtuse (any angle > pi/2) + is_obtuse = torch.any(all_angles > torch.pi / 2, dim=1) # (n_cells,) + + ### Branchless computation of mixed Voronoi areas + # Computes both acute (Eq. 7) and obtuse (Fig. 4) formulas for all cells, + # then selects per-cell via torch.where. This avoids data-dependent branching + # that would break torch.compile. + eps = safe_eps(all_angles.dtype) + voronoi_per_vertex = torch.zeros(n_cells, 3, dtype=dtype, device=device) + + for local_v_idx in range(3): + next_idx = (local_v_idx + 1) % 3 + prev_idx = (local_v_idx + 2) % 3 + + ### Voronoi contribution (Eq. 7) - computed for ALL cells + edge_to_next = ( + cell_vertices[:, next_idx, :] - cell_vertices[:, local_v_idx, :] + ) # (n_cells, n_spatial_dims) + edge_to_prev = ( + cell_vertices[:, prev_idx, :] - cell_vertices[:, local_v_idx, :] + ) # (n_cells, n_spatial_dims) + + edge_to_next_sq = (edge_to_next**2).sum(dim=-1) # (n_cells,) + edge_to_prev_sq = (edge_to_prev**2).sum(dim=-1) # (n_cells,) + + cot_prev = torch.cos(all_angles[:, prev_idx]) / torch.sin( + all_angles[:, prev_idx] + ).clamp(min=eps) + cot_next = torch.cos(all_angles[:, next_idx]) / torch.sin( + all_angles[:, next_idx] + ).clamp(min=eps) + + voronoi_contribution = ( + edge_to_next_sq * cot_prev + edge_to_prev_sq * cot_next + ) / 8.0 # (n_cells,) + + ### Mixed-area contribution (Figure 4) - computed for ALL cells + is_obtuse_at_vertex = all_angles[:, local_v_idx] > torch.pi / 2 + mixed_contribution = torch.where( + is_obtuse_at_vertex, + cell_areas / 2.0, + cell_areas / 4.0, + ) # (n_cells,) + + ### Select per cell: Voronoi for acute, mixed for obtuse + voronoi_per_vertex[:, local_v_idx] = torch.where( + is_obtuse, mixed_contribution, voronoi_contribution + ) + + return voronoi_per_vertex.reshape(-1) # (n_cells * 3,) + + +def compute_dual_volumes_0(mesh: "Mesh") -> torch.Tensor: + """Compute circumcentric dual 0-cell volumes (Voronoi regions) at mesh vertices. + + This is the unified, mathematically rigorous implementation used by both DEC + operators and curvature computations. It replaces the previous buggy + `compute_dual_volumes_0()` in `calculus/_circumcentric_dual.py` which failed + on obtuse triangles (giving up to 513% conservation error). + + The dual 0-cell (also called Voronoi cell or circumcentric dual) of a vertex + is the region of points closer to that vertex than to any other. In DEC, these + volumes appear in the Hodge star operator and normalization of the Laplacian. + + **Note**: In the curvature/differential geometry literature, these are often + called "Voronoi areas" (for 2D) or "Voronoi volumes". In DEC literature, they + are called "dual 0-cell volumes" (denoted |⋆v|). These are identical concepts. + + Dimension-specific algorithms: + + **1D manifolds (edges)**: + Each vertex receives half the length of each incident edge. + Formula: V(v) = Σ_{edges ∋ v} |edge|/2 + + **2D manifolds (triangles)**: + Uses Meyer et al. (2003) mixed area approach: + - **Acute triangles** (all angles ≤ π/2): Circumcentric Voronoi formula (Eq. 7) + V(v) = (1/8) Σ (||e_i||² cot(α_i) + ||e_j||² cot(α_j)) + where e_i, e_j are edges from v, α_i, α_j are opposite angles + + - **Obtuse triangles**: Mixed area subdivision (Figure 4) + - If obtuse at vertex v: V(v) = area(T)/2 + - Otherwise: V(v) = area(T)/4 + + This ensures perfect tiling and optimal error bounds. + + **3D+ manifolds (tetrahedra, etc.)**: + Barycentric approximation (standard practice): + V(v) = Σ_{cells ∋ v} |cell| / (n_manifold_dims + 1) + + Note: Rigorous circumcentric dual volumes in 3D require "well-centered" + meshes where all circumcenters lie inside their simplices (Desbrun 2005). + Mixed volume formulas for obtuse tetrahedra do not exist in the literature. + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh + + Returns + ------- + torch.Tensor + Tensor of shape (n_points,) containing dual 0-cell volume for each vertex. + For isolated vertices, volume is 0. + + Property: Σ dual_volumes = total_mesh_volume (perfect tiling) + + Raises + ------ + NotImplementedError + If n_manifold_dims > 3 + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> dual_vols = compute_dual_volumes_0(mesh) + >>> # Use in Hodge star: ⋆f(⋆v) = f(v) × dual_vols[v] + >>> # Use in Laplacian: Δf(v) = (1/dual_vols[v]) × Σ w_ij(f_j - f_i) + + Mathematical Properties: + 1. Conservation: Σ_v |⋆v| = |mesh| (perfect tiling) + 2. Optimality: Minimizes spatial averaging error (Meyer Section 3.2) + 3. Gauss-Bonnet: Enables Σ K_i × |⋆v_i| = 2πχ(M) to hold exactly + + References: + - Meyer Eq. 7 (circumcentric Voronoi, acute triangles) + - Meyer Fig. 4 (mixed area, obtuse triangles) + - Desbrun Def. of circumcentric dual (lines 333-352 in umich_dec.tex) + - Hirani Def. 2.4.5 (dual cell definition, lines 884-896 in Hirani03.txt) + """ + device = mesh.points.device + n_points = mesh.n_points + n_manifold_dims = mesh.n_manifold_dims + + ### Initialize dual volumes + dual_volumes = torch.zeros(n_points, dtype=mesh.points.dtype, device=device) + + ### Handle empty mesh + if mesh.n_cells == 0: + return dual_volumes + + ### Get cell volumes (reuse existing computation) + cell_volumes = mesh.cell_areas # (n_cells,) - "areas" is volumes in nD + + ### Dimension-specific computation + if n_manifold_dims == 1: + ### 1D: Each vertex gets half the length of each incident edge + # This is exact for piecewise linear 1-manifolds + _scatter_add_cell_contributions_to_vertices( + dual_volumes, mesh.cells, cell_volumes / 2.0 + ) + + elif n_manifold_dims == 2: + ### 2D: Mixed Voronoi area for triangles using Meyer et al. 2003 algorithm + # Reference: Section 3.3 (Equation 7) and Section 3.4 (Figure 4) + # + # CRITICAL: This correctly handles BOTH acute and obtuse triangles. + # The previous buggy implementation in _circumcentric_dual.py assumed + # circumcenters were always inside triangles, which is only true for acute. + + cell_vertices = mesh.points[mesh.cells] # (n_cells, 3, n_spatial_dims) + voronoi_areas = _compute_meyer_mixed_voronoi_areas( + cell_vertices, cell_volumes + ) # (n_cells * 3,) + + ### Scatter to global dual volumes + voronoi_areas_2d = voronoi_areas.reshape(mesh.n_cells, 3) # (n_cells, 3) + for local_v_idx in range(3): + vertex_indices = mesh.cells[:, local_v_idx] + dual_volumes.scatter_add_( + 0, vertex_indices, voronoi_areas_2d[:, local_v_idx] + ) + + elif n_manifold_dims >= 3: + ### 3D and higher: Barycentric subdivision + # Each vertex gets equal share of each incident cell's volume + # + # NOTE: This is an APPROXIMATION, not rigorous like 2D. + # Rigorous circumcentric dual volumes in 3D+ require "well-centered" + # meshes where all circumcenters lie inside simplices (Desbrun 2005). + # Mixed volume formulas for obtuse tetrahedra do NOT exist in literature. + n_vertices_per_cell = n_manifold_dims + 1 + _scatter_add_cell_contributions_to_vertices( + dual_volumes, mesh.cells, cell_volumes / n_vertices_per_cell + ) + + else: + raise NotImplementedError( + f"Dual volume computation not implemented for {n_manifold_dims=}. " + f"Currently supported: 1D (edges), 2D (triangles), 3D+ (tetrahedra, etc.)." + ) + + return dual_volumes + + +def compute_circumcenters( + vertices: torch.Tensor, # (n_simplices, n_vertices_per_simplex, n_spatial_dims) +) -> torch.Tensor: + """Compute circumcenters of simplices using perpendicular bisector method. + + The circumcenter is the unique point equidistant from all vertices of the simplex. + It lies at the intersection of perpendicular bisector hyperplanes. + + Parameters + ---------- + vertices : torch.Tensor + Vertex positions for each simplex. + Shape: (n_simplices, n_vertices_per_simplex, n_spatial_dims) + + Returns + ------- + torch.Tensor + Circumcenters, shape (n_simplices, n_spatial_dims) + + Notes + ----- + Algorithm: + For simplex with vertices v₀, v₁, ..., vₙ, the circumcenter c satisfies: + ||c - v₀||² = ||c - v₁||² = ... = ||c - vₙ||² + + Substituting d = c - v₀ gives n linear equations: + 2(v_i - v₀)·d = ||v_i - v₀||² for i=1,...,n + + In matrix form: A·d = b where: + A = 2[(v₁-v₀)^T, (v₂-v₀)^T, ...]^T + b = [||v₁-v₀||², ||v₂-v₀||², ...]^T + + Then c = v₀ + d. For over-determined systems (embedded manifolds), + use least-squares. + """ + n_simplices, n_vertices, n_spatial_dims = vertices.shape + n_manifold_dims = n_vertices - 1 + + ### Handle special cases + if n_vertices == 1: + # 0-simplex: circumcenter is the vertex itself + return vertices.squeeze(1) + + if n_vertices == 2: + # 1-simplex (edge): circumcenter is the midpoint + # This avoids numerical issues with underdetermined lstsq for edges in higher dimensions + return vertices.mean(dim=1) + + ### Build linear system for circumcenter + # Reference vertex (first one) + v0 = vertices[:, 0, :] # (n_simplices, n_spatial_dims) + + # Relative vectors from v₀ to other vertices + # Shape: (n_simplices, n_manifold_dims, n_spatial_dims) + relative_vecs = vertices[:, 1:, :] - v0.unsqueeze(1) + + # Matrix A = 2 * relative_vecs (each row is an equation) + # Shape: (n_simplices, n_manifold_dims, n_spatial_dims) + A = 2 * relative_vecs + + # Right-hand side: ||v_i - v₀||² + # Shape: (n_simplices, n_manifold_dims) + b = (relative_vecs**2).sum(dim=-1) + + ### Solve for circumcenter + # Need to solve: A @ (c - v₀) = b for each simplex + # This is: 2*(v_i - v₀) @ (c - v₀) = ||v_i - v₀||² + + if n_manifold_dims == n_spatial_dims: + ### Square system: use direct solve + # A is (n_simplices, n_dims, n_dims) + # b is (n_simplices, n_dims) + try: + # Solve A @ x = b + c_minus_v0 = torch.linalg.solve( + A, # (n_simplices, n_dims, n_dims) + b.unsqueeze(-1), # (n_simplices, n_dims, 1) + ).squeeze(-1) # (n_simplices, n_dims) + except torch.linalg.LinAlgError: + # Singular matrix - fall back to least squares + c_minus_v0 = torch.linalg.lstsq( + A, + b.unsqueeze(-1), + ).solution.squeeze(-1) + else: + ### Over-determined system (manifold embedded in higher dimension) + # Use least-squares: (A^T A)^-1 A^T b + # A is (n_simplices, n_manifold_dims, n_spatial_dims) + # We need A^T @ A which is (n_simplices, n_spatial_dims, n_spatial_dims) + + # Use torch.linalg.lstsq which handles batched least-squares + c_minus_v0 = torch.linalg.lstsq( + A, # (n_simplices, n_manifold_dims, n_spatial_dims) + b.unsqueeze(-1), # (n_simplices, n_manifold_dims, 1) + ).solution.squeeze(-1) # (n_simplices, n_spatial_dims) + + ### Circumcenter = v₀ + solution + circumcenters = v0 + c_minus_v0 + + return circumcenters + + +def compute_cotan_weights_fem( + mesh: "Mesh", +) -> tuple[torch.Tensor, torch.Tensor]: + r"""Compute cotangent weights for all edges using the FEM stiffness matrix. + + This is the dimension-general approach that works for simplicial meshes of + any manifold dimension (1D edges, 2D triangles, 3D tetrahedra, etc.). It + derives the cotangent weights from the Finite Element Method (FEM) stiffness + matrix with piecewise-linear basis functions. + + For an n-simplex with vertices v_0, ..., v_n and barycentric coordinate + functions lambda_i, the stiffness matrix entry for edge (i, j) is: + + K_ij = |sigma| * (grad lambda_i . grad lambda_j) + + The cotangent weight is w_ij = -K_ij, accumulated over all cells sharing + the edge. This is mathematically equivalent to the classical cotangent + formula in 2D: w_ij = (1/2)(cot alpha + cot beta). + + The gradient dot products are computed efficiently via the Gram matrix: + + E = [v_1 - v_0, ..., v_n - v_0] (n x d edge matrix) + G = E @ E^T (n x n Gram matrix) + grad lambda_k . grad lambda_l = (G^{-1})_{k-1, l-1} for k, l >= 1 + + For pairs involving vertex 0, the constraint sum(grad lambda_i) = 0 is used. + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh of any manifold dimension. + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + Tuple of (cotan_weights, unique_edges): + - cotan_weights: Cotangent weight for each unique edge, shape (n_edges,) + - unique_edges: Sorted edge vertex indices, shape (n_edges, 2) + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> weights, edges = compute_cotan_weights_fem(mesh) + >>> # weights[i] is the cotangent weight for edges[i] + """ + from itertools import combinations + + from physicsnemo.mesh.utilities._topology import extract_unique_edges + + device = mesh.points.device + dtype = mesh.points.dtype + n_cells = mesh.n_cells + n_manifold_dims = mesh.n_manifold_dims + n_verts_per_cell = n_manifold_dims + 1 # n+1 vertices in an n-simplex + + ### Extract unique edges and the inverse mapping from candidate edges + unique_edges, inverse_indices = extract_unique_edges(mesh) + n_unique_edges = len(unique_edges) + + ### Handle empty mesh + if n_cells == 0: + return ( + torch.zeros(n_unique_edges, dtype=dtype, device=device), + unique_edges, + ) + + ### Compute edge vectors from reference vertex (vertex 0 of each cell) + # cell_vertices: (n_cells, n_verts_per_cell, n_spatial_dims) + cell_vertices = mesh.points[mesh.cells] + # E: (n_cells, n_manifold_dims, n_spatial_dims) - rows are e_k = v_k - v_0 + E = cell_vertices[:, 1:, :] - cell_vertices[:, [0], :] + + ### Compute Gram matrix G = E @ E^T + # G: (n_cells, n_manifold_dims, n_manifold_dims) + G = E @ E.transpose(-1, -2) + + ### Handle degenerate cells by regularizing singular Gram matrices + # Degenerate cells (collinear/coplanar vertices) have det(G) ~ 0. + # We regularize these so that torch.linalg.inv doesn't produce NaN, + # then zero out their contributions via the cell volume (which is also ~0). + det_G = torch.linalg.det(G) # (n_cells,) + # Scale-aware degeneracy threshold: compare det against typical edge length + # raised to the 2n power (since det(G) has units of length^{2n}) + edge_length_scale = E.norm(dim=-1).mean(dim=-1).clamp(min=1e-30) # (n_cells,) + det_threshold = (edge_length_scale ** (2 * n_manifold_dims)) * 1e-12 + is_degenerate = det_G.abs() < det_threshold # (n_cells,) + + # Add identity to degenerate Gram matrices to make them invertible. + # The contribution from these cells will be zeroed by cell_volumes ~ 0. + # Written branchlessly so torch.compile can trace through without graph breaks. + eye = torch.eye(n_manifold_dims, dtype=dtype, device=device) + G = G + is_degenerate.float().unsqueeze(-1).unsqueeze(-1) * eye + + ### Invert Gram matrix + # G_inv: (n_cells, n_manifold_dims, n_manifold_dims) + G_inv = torch.linalg.inv(G) + + ### Build the gradient dot product matrix C = H @ G_inv @ H^T + # H: (n_verts_per_cell, n_manifold_dims) = [[-1,...,-1]; I_n] + # This encodes the relationship: grad lambda_0 = -sum(grad lambda_k for k>=1) + H = torch.zeros(n_verts_per_cell, n_manifold_dims, dtype=dtype, device=device) + H[0, :] = -1.0 + H[1:, :] = torch.eye(n_manifold_dims, dtype=dtype, device=device) + + # C: (n_cells, n_verts_per_cell, n_verts_per_cell) + # C[c, i, j] = grad lambda_i . grad lambda_j in cell c + C = H.unsqueeze(0) @ G_inv @ H.T.unsqueeze(0) + + ### Extract gradient dot products for each local edge pair + # Local edge pairs in combinations order (matches extract_candidate_facets) + local_pairs = list(combinations(range(n_verts_per_cell), 2)) + pair_i = torch.as_tensor([p[0] for p in local_pairs], device=device) + pair_j = torch.as_tensor([p[1] for p in local_pairs], device=device) + + # grad_dots: (n_cells, n_pairs) - one value per cell per local edge + grad_dots = C[:, pair_i, pair_j] + + ### Compute cotangent weight contributions per cell per edge + # w = -|sigma| * (grad lambda_i . grad lambda_j) + cell_volumes = mesh.cell_areas # (n_cells,) + weights_per_cell = -cell_volumes[:, None] * grad_dots # (n_cells, n_pairs) + + ### Accumulate contributions to unique edges via scatter_add + cotan_weights = torch.zeros(n_unique_edges, dtype=dtype, device=device) + # inverse_indices maps each candidate edge to its unique edge index. + # For 1D: shape (n_cells,); for nD>1: shape (n_cells * n_pairs,) + # weights_per_cell.reshape(-1) aligns with inverse_indices in both cases. + cotan_weights.scatter_add_(0, inverse_indices, weights_per_cell.reshape(-1)) + + return cotan_weights, unique_edges + + +def compute_dual_volumes_1( + mesh: "Mesh", +) -> tuple[torch.Tensor, torch.Tensor]: + """Compute dual 1-cell volumes (dual to edges). + + The dual 1-cell of an edge is the portion of the circumcentric dual mesh + associated with that edge. For a 2D triangle mesh, it consists of segments + from the edge midpoint to the circumcenters of adjacent triangles: + + |⋆e| = |e| × w_ij + + where w_ij is the FEM cotangent weight for the edge. This relationship + holds for any manifold dimension; the FEM stiffness matrix approach + (see :func:`compute_cotan_weights_fem`) derives these weights from the + gradient dot products of barycentric basis functions. + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh of any manifold dimension. + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + Tuple of ``(dual_volumes, edges)``: + + - ``dual_volumes``: Dual 1-cell volume for each edge, shape ``(n_edges,)``. + May be negative for edges in non-Delaunay configurations (obtuse + angles exceeding pi/2 at both adjacent cells). + - ``edges``: Canonically sorted edge connectivity, shape ``(n_edges, 2)``, + with ``edges[:, 0] < edges[:, 1]``. + + Notes + ----- + Negative dual volumes are geometrically meaningful: they indicate that the + circumcentric dual edge crosses the primal edge. Clamping them to zero (as + some implementations do) silently degrades accuracy on non-Delaunay meshes. + """ + ### Derive cotangent weights from the FEM stiffness matrix (works for any dimension) + cotan_weights, edges = compute_cotan_weights_fem(mesh) + + ### |⋆e| = w_ij × |e| + edge_vectors = mesh.points[edges[:, 1]] - mesh.points[edges[:, 0]] + edge_lengths = torch.norm(edge_vectors, dim=-1) + dual_volumes_1 = cotan_weights * edge_lengths + + return dual_volumes_1, edges + + +def get_or_compute_dual_volumes_0(mesh: "Mesh") -> torch.Tensor: + """Get cached dual 0-cell volumes or compute if not present. + + Parameters + ---------- + mesh : Mesh + Input mesh + + Returns + ------- + torch.Tensor + Dual volumes for vertices, shape (n_points,) + """ + cached = get_cached(mesh.point_data, "dual_volumes_0") + if cached is None: + cached = compute_dual_volumes_0(mesh) + set_cached(mesh.point_data, "dual_volumes_0", cached) + return cached + + +def get_or_compute_circumcenters(mesh: "Mesh") -> torch.Tensor: + """Get cached circumcenters or compute if not present. + + Parameters + ---------- + mesh : Mesh + Input mesh + + Returns + ------- + torch.Tensor + Circumcenters for all cells, shape (n_cells, n_spatial_dims) + """ + cached = get_cached(mesh.cell_data, "circumcenters") + if cached is None: + parent_cell_vertices = mesh.points[mesh.cells] + cached = compute_circumcenters(parent_cell_vertices) + set_cached(mesh.cell_data, "circumcenters", cached) + return cached diff --git a/physicsnemo/mesh/geometry/interpolation.py b/physicsnemo/mesh/geometry/interpolation.py new file mode 100644 index 0000000000..7dd78f77ca --- /dev/null +++ b/physicsnemo/mesh/geometry/interpolation.py @@ -0,0 +1,254 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Barycentric interpolation functions and their gradients for DEC. + +Barycentric (or Whitney 0-form) interpolation functions φ_{v,cell} are the standard +linear shape functions used in finite elements. For a simplex with vertices v₀,...,vₙ, +the function φ_v is 1 at vertex v and 0 at all other vertices, linearly interpolated. + +The gradients of these functions are needed for the discrete sharp operator in DEC. + +Key properties (Hirani Rem. 2.7.2, lines 1260-1288): +- ∇φ_{v,cell} is constant in the cell interior +- ∇φ_{v,cell} is perpendicular to the face opposite to v +- ||∇φ_{v,cell}|| = 1/h where h is the height of v above opposite face +- Σ_{vertices v in cell} ∇φ_{v,cell} = 0 (gradients sum to zero) + +References: + Hirani (2003) Section 2.7, Remark 2.7.2 +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.utilities._tolerances import safe_eps + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def compute_barycentric_gradients( + mesh: "Mesh", +) -> torch.Tensor: + """Compute gradients of barycentric interpolation functions. + + For each cell and each of its vertices, computes ∇φ_{v,cell}, the gradient + of the barycentric interpolation function that is 1 at vertex v and 0 at + all other vertices of the cell. + + These gradients are needed for the PP-sharp operator (Hirani Eq. 5.8.1). + + Parameters + ---------- + mesh : Mesh + Simplicial mesh (2D or 3D) + + Returns + ------- + torch.Tensor + Gradients of shape (n_cells, n_vertices_per_cell, n_spatial_dims) + + gradients[cell_i, local_vertex_j, :] = ∇φ_{v_j, cell_i} + + where v_j is the j-th vertex of cell_i (in local indexing). + + Algorithm: + For n-simplex with vertices v₀, ..., vₙ: + 1. The gradient ∇φ_{v₀,cell} is perpendicular to face [v₁,...,vₙ] + 2. Points from face centroid toward v₀ + 3. Has magnitude 1/height + + Efficient computation: + - Use barycentric coordinate derivatives + - For vertex i: ∇φᵢ = ∇(volume ratio) = normal to opposite face / height + + Properties: + - Σᵢ ∇φᵢ = 0 (constraint: barycentric coords sum to 1) + - ∇φᵢ · (vⱼ - vᵢ) = -1 for j ≠ i (decrease along edge away from i) + - ∇φᵢ · (vᵢ - vⱼ) = +1 for j ≠ i (increase along edge toward i) + + Reference: + Hirani Remark 2.7.2 (lines 1260-1288) + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> grads = compute_barycentric_gradients(mesh) + >>> # grads[i, j, :] is ∇φ for j-th vertex of i-th cell + >>> # Use in sharp operator with α♯(v) = Σ α(edge) × weight × grad + """ + n_cells = mesh.n_cells + n_manifold_dims = mesh.n_manifold_dims + n_spatial_dims = mesh.n_spatial_dims + n_vertices_per_cell = n_manifold_dims + 1 + + device = mesh.points.device + dtype = mesh.points.dtype + + ### Initialize output + gradients = torch.zeros( + (n_cells, n_vertices_per_cell, n_spatial_dims), + dtype=dtype, + device=device, + ) + + ### Handle empty mesh + if n_cells == 0: + return gradients + + ### Get cell vertices + cell_vertices = mesh.points[ + mesh.cells + ] # (n_cells, n_vertices_per_cell, n_spatial_dims) + + if n_manifold_dims == 2: + ### 2D triangles: Efficient closed-form solution + # For triangle with vertices v₀, v₁, v₂: + # ∇φ₀ is perpendicular to edge [v₁, v₂] and points toward v₀ + # + # Standard formula from finite elements: + # For 2D triangle, ∇φᵢ = perpendicular to opposite edge / (2 × area) + # + # More precisely: ∇φ₀ = (v₂ - v₁)^⊥ / (2 × signed_area) + # where ^⊥ rotates 90° counterclockwise in 2D + + ### Extract vertices + v0 = cell_vertices[:, 0, :] # (n_cells, n_spatial_dims) + v1 = cell_vertices[:, 1, :] + v2 = cell_vertices[:, 2, :] + + ### Compute 2× signed area for each triangle + # Using cross product: 2A = (v1-v0) × (v2-v0) + edge1 = v1 - v0 + edge2 = v2 - v0 + + if n_spatial_dims == 2: + # 2D: cross product gives z-component (scalar) + twice_signed_area = edge1[:, 0] * edge2[:, 1] - edge1[:, 1] * edge2[:, 0] + twice_signed_area = twice_signed_area.unsqueeze(-1) # (n_cells, 1) + elif n_spatial_dims == 3: + # 3D: cross product encodes both normal direction and twice-area + cross = torch.linalg.cross(edge1, edge2) # (n_cells, 3) + else: + # Higher dimensions: use Gram determinant + raise NotImplementedError( + f"Barycentric gradients for n_spatial_dims={n_spatial_dims} not yet implemented" + ) + + ### Compute gradients of barycentric functions for each vertex + # In 2D: ∇φᵢ = perpendicular(opposite_edge) / (2 × signed_area) + # where perpendicular(x, y) = (-y, x) is a fixed 90° CCW rotation, + # and the signed area corrects the direction for CW-oriented cells. + # In 3D: ∇φᵢ = cross × opposite_edge / |cross|² + # where cross = (v₁-v₀) × (v₂-v₀). This formula is inherently + # orientation-independent (no signed area needed) because flipping + # two vertices negates both cross and the opposite edge, leaving + # the quotient unchanged. + + if n_spatial_dims == 2: + ### 2D case: direct perpendicular + edge_v2_v1 = v2 - v1 # (n_cells, 2) + edge_v0_v2 = v0 - v2 + edge_v1_v0 = v1 - v0 + + # Perpendicular: (x,y) → (-y, x) + perp_v2_v1 = torch.stack([-edge_v2_v1[:, 1], edge_v2_v1[:, 0]], dim=1) + perp_v0_v2 = torch.stack([-edge_v0_v2[:, 1], edge_v0_v2[:, 0]], dim=1) + perp_v1_v0 = torch.stack([-edge_v1_v0[:, 1], edge_v1_v0[:, 0]], dim=1) + + gradients[:, 0, :] = perp_v2_v1 / twice_signed_area + gradients[:, 1, :] = perp_v0_v2 / twice_signed_area + gradients[:, 2, :] = perp_v1_v0 / twice_signed_area + + elif n_spatial_dims == 3: + ### 3D case: ∇φᵢ = (cross × opposite_edge) / |cross|² + # Equivalent to the textbook n̂ × edge / (2A), since + # n̂ = cross/|cross| and 2A = |cross|, giving cross×edge / |cross|². + + # Opposite edges + edge_v2_v1 = v2 - v1 + edge_v0_v2 = v0 - v2 + edge_v1_v0 = v1 - v0 + + # |cross|² = (2A)²; clamp for degenerate triangles (zero area) + cross_norm_sq = ( + (cross * cross) + .sum(dim=-1, keepdim=True) + .clamp(min=safe_eps(cross.dtype)) + ) + + gradients[:, 0, :] = torch.linalg.cross(cross, edge_v2_v1) / cross_norm_sq + gradients[:, 1, :] = torch.linalg.cross(cross, edge_v0_v2) / cross_norm_sq + gradients[:, 2, :] = torch.linalg.cross(cross, edge_v1_v0) / cross_norm_sq + + elif n_manifold_dims == 3: + ### 3D tetrahedra: Use dual basis / perpendicular to opposite face + # ∇φᵢ is perpendicular to the triangular face opposite to vertex i + # and has magnitude 1/(height from i to opposite face) + + ### For each vertex, compute gradient + for local_v_idx in range(4): + ### Get opposite face (3 vertices excluding current one) + other_indices = [j for j in range(4) if j != local_v_idx] + opposite_face_vertices = cell_vertices[ + :, other_indices, : + ] # (n_cells, 3, n_spatial_dims) + + ### Compute normal to opposite face + # Face has 3 vertices: compute normal via cross product + face_v0 = opposite_face_vertices[:, 0, :] + face_v1 = opposite_face_vertices[:, 1, :] + face_v2 = opposite_face_vertices[:, 2, :] + + face_edge1 = face_v1 - face_v0 + face_edge2 = face_v2 - face_v0 + + face_normal = torch.linalg.cross(face_edge1, face_edge2) # (n_cells, 3) + face_area = ( + torch.norm(face_normal, dim=-1, keepdim=True) / 2.0 + ) # (n_cells, 1) + + ### Normalize face normal + face_normal_unit = face_normal / (2.0 * face_area).clamp( + min=safe_eps(face_area.dtype) + ) + + ### Height from vertex to opposite face + vertex_pos = cell_vertices[:, local_v_idx, :] + vec_to_face = face_v0 - vertex_pos + height = torch.abs( + (vec_to_face * face_normal_unit).sum(dim=-1, keepdim=True) + ) # (n_cells, 1) + + ### Gradient: normal direction with magnitude 1/height + # Direction: toward vertex (opposite of normal if on other side) + sign = torch.sign( + (vec_to_face * face_normal_unit).sum(dim=-1, keepdim=True) + ) + grad = -sign * face_normal_unit / height.clamp(min=safe_eps(height.dtype)) + + gradients[:, local_v_idx, :] = grad.squeeze(-1) + + else: + raise NotImplementedError( + f"Barycentric gradients not implemented for {n_manifold_dims=}D. " + f"Currently supported: 2D (triangles), 3D (tetrahedra)." + ) + + return gradients diff --git a/physicsnemo/mesh/geometry/support_volumes.py b/physicsnemo/mesh/geometry/support_volumes.py new file mode 100644 index 0000000000..7fe1e76400 --- /dev/null +++ b/physicsnemo/mesh/geometry/support_volumes.py @@ -0,0 +1,385 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Support volume computation for Discrete Exterior Calculus. + +Support volumes are geometric regions associated with primal simplices, formed by +the convex hull of the simplex and its circumcentric dual cell. These are fundamental +to DEC formulas for sharp and flat operators. + +Key concept (Hirani Def. 2.4.9, line 2034): + V_σᵏ = convex hull(σᵏ, ⋆σᵏ) + +The support volumes perfectly tile the mesh: their union is |K| and intersections +have measure zero. + +For implementing sharp/flat operators, we need the intersection of support volumes +with n-simplices (cells). Hirani Prop. 5.5.1 (lines 2345-2390) proves that these +can be computed efficiently using pyramid volumes. + +References: + Hirani (2003) Section 2.4, Proposition 5.5.1, Figure 5.4 +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.utilities._tolerances import safe_eps + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def compute_edge_support_volume_cell_fractions( + mesh: "Mesh", + edges: torch.Tensor, +) -> torch.Tensor: + """Compute |⋆edge ∩ cell| / |⋆edge| for all edge-cell pairs. + + For each edge and each cell containing it, computes the fraction of the edge's + dual 1-cell (and support volume) that lies within that cell. + + This is needed for the DPP-flat operator (Hirani Eq. 5.5.3, line 2398): + ⟨X♭, edge⟩ = Σ_{cells ⊃ edge} (|⋆edge ∩ cell|/|⋆edge|) × X(cell) · edge⃗ + + From Hirani Prop. 5.5.1 (line 2348), this equals: + |⋆edge ∩ cell| / |⋆edge| = |V_edge ∩ cell| / |V_edge| + + And from the pyramid volume analysis (lines 2361-2388), for dimension n: + |V_edge ∩ cell| = 2 × (1/(n+1)) × |edge|/2 × |⋆edge ∩ cell| + |V_edge| = Σ_{cells ⊃ edge} |V_edge ∩ cell| + + So: fraction = |⋆edge ∩ cell| / |⋆edge| = |⋆edge ∩ cell| / Σ|⋆edge ∩ cell| + + For 2D triangles, |⋆edge ∩ triangle| is the length of the dual edge segment + from edge midpoint to triangle circumcenter. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh (must be 2D for now) + edges : torch.Tensor + Edge connectivity, shape (n_edges, 2) + + Returns + ------- + torch.Tensor + Sparse representation of fractions, shape (n_edges, max_cells_per_edge) + where max_cells_per_edge = 2 for manifold meshes without boundary. + + For boundary edges (only 1 adjacent cell), the fraction is 1.0. + For interior edges (2 adjacent cells), fractions sum to 1.0. + + Algorithm (2D specific): + For each edge: + 1. Find all triangles containing it (typically 1 or 2) + 2. Compute circumcenter of each triangle + 3. Dual edge length in triangle = distance from edge midpoint to circumcenter + 4. Total dual edge length = sum over all triangles + 5. Fraction = (dual length in triangle) / (total dual length) + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> edges = torch.tensor([[0, 1], [1, 2], [0, 2], [1, 3], [2, 3]]) + >>> fractions = compute_edge_support_volume_cell_fractions(mesh, edges) + >>> # fractions[i, j] = fraction of edge i's support volume in its j-th cell + """ + if mesh.n_manifold_dims != 2: + raise NotImplementedError( + f"Support volume fractions only implemented for 2D manifolds. " + f"Got {mesh.n_manifold_dims=}" + ) + + from physicsnemo.mesh.geometry.dual_meshes import compute_circumcenters + + n_edges = len(edges) + device = mesh.points.device + dtype = mesh.points.dtype + + ### Find which cells contain each edge + # Use facet extraction to map edges → parent cells + from physicsnemo.mesh.boundaries import extract_candidate_facets + + candidate_edges, parent_cells = extract_candidate_facets( + mesh.cells, + manifold_codimension=1, # Extract 1-simplices (edges) from 2-simplices (triangles) + ) + + ### Build mapping from edges to their parent cells + # Each edge maps to a list of cell indices + # Most edges have 1 (boundary) or 2 (interior) adjacent cells + # Store as (n_edges, 2) with -1 for missing second cell + from physicsnemo.mesh.utilities._edge_lookup import find_edges_in_reference + + edge_indices, matches = find_edges_in_reference(edges, candidate_edges) + edge_to_cells = torch.full( + (n_edges, 2), -1, dtype=torch.long, device=device + ) # (n_edges, 2) + + ### Vectorized fill of edge_to_cells matrix + # Filter to only matched candidates + matched_edge_indices = edge_indices[matches] + matched_cell_indices = parent_cells[matches] + + if len(matched_edge_indices) > 0: + ### Sort by edge index to group edges together + sort_order = torch.argsort(matched_edge_indices, stable=True) + sorted_edges_idx = matched_edge_indices[sort_order] + sorted_cells_idx = matched_cell_indices[sort_order] + + ### Compute within-group position (0, 1, 2, ...) for each entry + # Find group boundaries where edge index changes + group_starts = torch.cat( + [ + sorted_edges_idx.new_zeros(1), + torch.where(sorted_edges_idx[1:] != sorted_edges_idx[:-1])[0] + 1, + ] + ) + + # Compute cumulative position within each group + # positions[i] = i - group_start for entry i + positions = torch.arange(len(sorted_edges_idx), device=device) + group_ids = torch.searchsorted(group_starts, positions, right=True) - 1 + within_group_positions = positions - group_starts[group_ids] + + ### Keep only first 2 entries per edge (slot 0 and slot 1) + valid_mask = within_group_positions < 2 + final_edge_indices = sorted_edges_idx[valid_mask] + final_cell_indices = sorted_cells_idx[valid_mask] + final_slots = within_group_positions[valid_mask] + + ### Fill matrix using advanced indexing + edge_to_cells[final_edge_indices, final_slots] = final_cell_indices + + ### Compute circumcenters of all cells + cell_vertices = mesh.points[mesh.cells] # (n_cells, 3, n_spatial_dims) + circumcenters = compute_circumcenters(cell_vertices) # (n_cells, n_spatial_dims) + + ### For each edge, compute dual edge length segments + # Dual edge goes from edge midpoint to circumcenters of adjacent cells + edge_midpoints = ( + mesh.points[edges[:, 0]] + mesh.points[edges[:, 1]] + ) / 2 # (n_edges, n_spatial_dims) + + ### Compute |⋆edge ∩ cell| for each edge-cell pair + dual_edge_segments = torch.zeros( + (n_edges, 2), dtype=dtype, device=device + ) # (n_edges, 2) + + for slot in range(2): + valid_mask = edge_to_cells[:, slot] >= 0 + # Clamp indices to 0 for invalid slots (distances will be zeroed by mask) + safe_cell_indices = edge_to_cells[:, slot].clamp(min=0) + + # Distance from edge midpoint to circumcenter + distances = torch.norm( + circumcenters[safe_cell_indices] - edge_midpoints, + dim=-1, + ) # (n_edges,) + + # Zero out distances for invalid slots (no adjacent cell) + dual_edge_segments[:, slot] = torch.where( + valid_mask, distances, distances.new_zeros(()) + ) + + ### Compute total dual edge length for each edge + total_dual_lengths = dual_edge_segments.sum(dim=1) # (n_edges,) + + ### Compute fractions: |⋆edge ∩ cell| / |⋆edge| + fractions = dual_edge_segments / total_dual_lengths.unsqueeze(-1).clamp( + min=safe_eps(total_dual_lengths.dtype) + ) + + return fractions # (n_edges, 2) - fractions for up to 2 adjacent cells + + +def compute_vertex_support_volume_cell_fractions( + mesh: "Mesh", +) -> tuple[torch.Tensor, torch.Tensor]: + r"""Compute |⋆vertex ∩ cell| / |⋆vertex| for all vertex-cell pairs. + + For each vertex v and each cell containing it, computes the fraction of v's + total dual 0-cell volume (Voronoi region) that lies within that cell. These + fractions sum to 1.0 for each vertex by construction, since + :math:`|⋆v| = \sum_{\text{cells } c \ni v} |⋆v \cap c|`. + + This normalization is required by the PP-sharp operator so that it exactly + reproduces constant gradients: + + .. math:: + + \alpha^\sharp(v) = \sum_{\text{edges } [v,\sigma^0]} + \langle \alpha, [v,\sigma^0] \rangle + \sum_{\text{cells } \sigma^n \supset \text{edge}} + \frac{|⋆v \cap \sigma^n|}{|⋆v|} + \nabla\varphi_{\sigma^0, \sigma^n} + + For 2D triangles, :math:`|⋆v \cap \text{cell}|` is the area of the Voronoi + region within the triangle, computed using the Meyer mixed area formula + (Eq. 7 for acute triangles, Fig. 4 for obtuse). + + Parameters + ---------- + mesh : Mesh + Simplicial mesh. + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + Tuple of ``(fractions, cell_vertex_pairs)``: + + - ``fractions``: shape ``(n_pairs,)`` - the weight + :math:`|⋆v \cap \text{cell}| / |⋆v|` + - ``cell_vertex_pairs``: shape ``(n_pairs, 2)`` - + ``[cell_idx, local_vertex_idx]`` + + Fractions are guaranteed to sum to 1.0 for each vertex. + + Notes + ----- + For non-2D manifolds, uses the barycentric approximation where each + vertex's Voronoi region in a cell is ``|cell| / n_vertices_per_cell``. + + Returns a flat array of all (cell, vertex) pairs to avoid a dense tensor. + """ + device = mesh.points.device + dtype = mesh.points.dtype + n_cells = mesh.n_cells + n_vertices_per_cell = mesh.n_manifold_dims + 1 + + ### Initialize storage for raw Voronoi areas |⋆v ∩ cell| + n_pairs = n_cells * n_vertices_per_cell + voronoi_areas = torch.zeros(n_pairs, dtype=dtype, device=device) + cell_indices_out = torch.arange(n_cells, device=device).repeat_interleave( + n_vertices_per_cell + ) + local_vertex_indices = torch.arange(n_vertices_per_cell, device=device).repeat( + n_cells + ) + + if mesh.n_manifold_dims != 2: + ### Non-2D: barycentric approximation |⋆v ∩ cell| ≈ |cell| / n_verts + cell_areas = mesh.cell_areas # (n_cells,) + approx_voronoi = cell_areas / n_vertices_per_cell # (n_cells,) + for local_v_idx in range(n_vertices_per_cell): + pair_indices = ( + torch.arange(n_cells, device=device) * n_vertices_per_cell + local_v_idx + ) + voronoi_areas[pair_indices] = approx_voronoi + else: + ### 2D manifolds: Meyer mixed area computation for |⋆v ∩ cell| + from physicsnemo.mesh.geometry.dual_meshes import ( + _compute_meyer_mixed_voronoi_areas, + ) + + cell_vertices = mesh.points[mesh.cells] # (n_cells, 3, n_spatial_dims) + cell_areas = mesh.cell_areas # (n_cells,) + + voronoi_areas[:] = _compute_meyer_mixed_voronoi_areas( + cell_vertices, cell_areas + ) # (n_cells * 3,) + + ### Normalize per vertex: fraction = |⋆v ∩ cell| / |⋆v| + # Map each (cell, local_vertex) pair to its global vertex index + global_vertex_indices = mesh.cells[cell_indices_out, local_vertex_indices] + + # Sum Voronoi areas per vertex to get total dual volume |⋆v| + dual_volumes = torch.zeros(mesh.n_points, dtype=dtype, device=device) + dual_volumes.scatter_add_(0, global_vertex_indices, voronoi_areas) + + # Divide each per-cell area by the vertex total (guaranteed to sum to 1.0) + fractions = voronoi_areas / dual_volumes[global_vertex_indices].clamp( + min=safe_eps(dtype) + ) + + cell_vertex_pairs = torch.stack([cell_indices_out, local_vertex_indices], dim=1) + return fractions, cell_vertex_pairs + + +def compute_dual_edge_volumes_in_cells( + mesh: "Mesh", + edges: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor]: + """Compute |⋆edge ∩ cell| for all edge-cell adjacencies. + + Returns the actual volume (not fraction) of dual 1-cell within each cell. + This is the |⋆edge ∩ cell| term from Hirani Eq. 5.5.3. + + Parameters + ---------- + mesh : Mesh + Simplicial mesh (2D for now) + edges : torch.Tensor + Edge connectivity, shape (n_edges, 2) + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + Tuple of (dual_volumes_in_cells, edge_cell_mapping): + - dual_volumes_in_cells: shape (n_edge_cell_pairs,) + - edge_cell_mapping: shape (n_edge_cell_pairs, 2) - [edge_idx, cell_idx] + + Algorithm (2D): + For each edge-cell pair: + |⋆edge ∩ cell| = distance from edge midpoint to cell circumcenter + """ + if mesh.n_manifold_dims != 2: + raise NotImplementedError( + f"Dual edge volumes only implemented for 2D. Got {mesh.n_manifold_dims=}" + ) + + from physicsnemo.mesh.boundaries import extract_candidate_facets + from physicsnemo.mesh.geometry.dual_meshes import compute_circumcenters + + ### Extract all edges with their parent cells + candidate_edges, parent_cells = extract_candidate_facets( + mesh.cells, + manifold_codimension=1, + ) + + ### Match candidates to input edges + from physicsnemo.mesh.utilities._edge_lookup import find_edges_in_reference + + edge_indices_for_candidates, matches = find_edges_in_reference( + edges, candidate_edges + ) + + ### Filter to only matched pairs + edge_indices = edge_indices_for_candidates[matches] + cell_indices = parent_cells[matches] + + ### Compute circumcenters + cell_vertices = mesh.points[mesh.cells] + circumcenters = compute_circumcenters(cell_vertices) + + ### Compute edge midpoints + edge_midpoints = (mesh.points[edges[:, 0]] + mesh.points[edges[:, 1]]) / 2 + + ### For each matched pair, compute dual edge segment length + # |⋆edge ∩ cell| = ||midpoint - circumcenter|| + dual_volumes = torch.norm( + circumcenters[cell_indices] - edge_midpoints[edge_indices], + dim=-1, + ) # (n_matched,) + + ### Package output + edge_cell_mapping = torch.stack([edge_indices, cell_indices], dim=1) + + return dual_volumes, edge_cell_mapping diff --git a/physicsnemo/mesh/io/__init__.py b/physicsnemo/mesh/io/__init__.py index af85283aa4..71e516e6d6 100644 --- a/physicsnemo/mesh/io/__init__.py +++ b/physicsnemo/mesh/io/__init__.py @@ -13,3 +13,11 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. + +"""I/O utilities for PhysicsNeMo Mesh. + +This module provides functions to convert between PhysicsNeMo Mesh and other +mesh formats, particularly PyVista. +""" + +from physicsnemo.mesh.io.io_pyvista import from_pyvista, to_pyvista diff --git a/physicsnemo/mesh/io/io_pyvista.py b/physicsnemo/mesh/io/io_pyvista.py index 16ba1e909f..4d171401ef 100644 --- a/physicsnemo/mesh/io/io_pyvista.py +++ b/physicsnemo/mesh/io/io_pyvista.py @@ -14,7 +14,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Literal +from typing import TYPE_CHECKING, Literal import numpy as np import torch @@ -22,10 +22,13 @@ from physicsnemo.core.version_check import require_version_spec from physicsnemo.mesh.mesh import Mesh +if TYPE_CHECKING: + import pyvista + @require_version_spec("pyvista") def from_pyvista( - pyvista_mesh: "pyvista.PolyData | pyvista.UnstructuredGrid | pyvista.PointSet", # noqa: F821 + pyvista_mesh: "pyvista.PolyData | pyvista.UnstructuredGrid | pyvista.PointSet", manifold_dim: int | Literal["auto"] = "auto", ) -> Mesh: """Convert a PyVista mesh to a physicsnemo.mesh Mesh. @@ -170,27 +173,59 @@ def is_all_tetra(pv_mesh) -> bool: if lines_raw is None or len(lines_raw) == 0: cells = torch.empty((0, 2), dtype=torch.long) else: - # Parse the lines array and convert to line segments - cells_list = [] - i = 0 - while i < len(lines_raw): - n_points = lines_raw[i] - point_ids = lines_raw[i + 1 : i + 1 + n_points] - - # Convert polyline to line segments (consecutive pairs) - cells_list.extend( - [ - [point_ids[j], point_ids[j + 1]] - for j in range(len(point_ids) - 1) - ] - ) + lines_array = np.asarray(lines_raw) + + # Fast path: check if all line segments have uniform vertex count + # (common case — all edges have 2 vertices, stride = 3) + first_count = int(lines_array[0]) + stride = first_count + 1 + is_uniform = len(lines_array) % stride == 0 and len(lines_array) >= stride + if is_uniform: + n_segments = len(lines_array) // stride + reshaped = lines_array.reshape(n_segments, stride) + is_uniform = bool((reshaped[:, 0] == first_count).all()) + + if is_uniform: + # Vectorized path: reshape and extract vertex columns + point_ids = reshaped[:, 1:] # (n_segments, first_count) + + # Convert polylines to consecutive line segments + if first_count == 2: + # Already line segments — use directly + cells = torch.from_numpy(point_ids.copy()).long() + else: + # Polylines with >2 vertices: create consecutive pairs + seg_starts = point_ids[:, :-1].reshape(-1) + seg_ends = point_ids[:, 1:].reshape(-1) + cells = torch.stack( + [ + torch.from_numpy(seg_starts.copy()), + torch.from_numpy(seg_ends.copy()), + ], + dim=1, + ).long() + else: + # Fallback: Python loop for non-uniform segment sizes + cells_list = [] + i = 0 + while i < len(lines_array): + n_pts = int(lines_array[i]) + point_ids = lines_array[i + 1 : i + 1 + n_pts] + + # Convert polyline to line segments (consecutive pairs) + cells_list.extend( + [ + [point_ids[j], point_ids[j + 1]] + for j in range(len(point_ids) - 1) + ] + ) - i += n_points + 1 + i += n_pts + 1 - if cells_list: - cells = torch.from_numpy(np.array(cells_list)).long() - else: - cells = torch.empty((0, 2), dtype=torch.long) + if cells_list: + cells = torch.from_numpy(np.array(cells_list)).long() + else: + cells = torch.empty((0, 2), dtype=torch.long) elif manifold_dim == 2: # Triangular cells - use regular_faces property @@ -213,16 +248,16 @@ def is_all_tetra(pv_mesh) -> bool: return Mesh( points=points, cells=cells, - point_data=pyvista_mesh.point_data, # type: ignore[arg-type] - cell_data=pyvista_mesh.cell_data, # type: ignore[arg-type] - global_data=pyvista_mesh.field_data, # type: ignore[arg-type] + point_data=pyvista_mesh.point_data, + cell_data=pyvista_mesh.cell_data, + global_data=pyvista_mesh.field_data, ) @require_version_spec("pyvista") def to_pyvista( mesh: Mesh, -) -> "pyvista.PolyData | pyvista.UnstructuredGrid | pyvista.PointSet": # noqa: F821 +) -> "pyvista.PolyData | pyvista.UnstructuredGrid | pyvista.PointSet": """Convert a physicsnemo.mesh Mesh to a PyVista mesh. Parameters @@ -266,21 +301,16 @@ def to_pyvista( elif mesh.n_manifold_dims == 1: # Line mesh - create PolyData with lines - # Convert line segments to PyVista format: [n_points, id0, id1, ...] cells_np = mesh.cells.cpu().numpy() if mesh.n_cells == 0: - # Empty lines pv_mesh = pv.PolyData(points_np) else: - # Each line segment has 2 points - # PyVista format: [2, i0, i1, 2, j0, j1, ...] - lines_list = [] - for cell in cells_np: - lines_list.append(2) # Number of points in this line - lines_list.extend(cell) - lines_array = np.array(lines_list, dtype=np.int64) - + # PyVista padded format: [n_pts, v0, v1, n_pts, v0, v1, ...] + # Vectorized: prepend vertex count to each cell row, then flatten + lines_array = np.column_stack( + [np.full(len(cells_np), cells_np.shape[1], dtype=np.int64), cells_np] + ).ravel() pv_mesh = pv.PolyData(points_np, lines=lines_array) elif mesh.n_manifold_dims == 2: @@ -288,52 +318,51 @@ def to_pyvista( cells_np = mesh.cells.cpu().numpy() if mesh.n_cells == 0: - # Empty cells pv_mesh = pv.PolyData(points_np) else: - # PyVista format for cells: [3, i0, i1, i2, 3, j0, j1, j2, ...] - cells_list = [] - for cell in cells_np: - cells_list.append(3) # Number of points in this triangle - cells_list.extend(cell) - cells_array = np.array(cells_list, dtype=np.int64) - - pv_mesh = pv.PolyData(points_np, faces=cells_array) + # PyVista padded format: [n_pts, v0, v1, v2, n_pts, v0, v1, v2, ...] + faces_array = np.column_stack( + [np.full(len(cells_np), cells_np.shape[1], dtype=np.int64), cells_np] + ).ravel() + pv_mesh = pv.PolyData(points_np, faces=faces_array) elif mesh.n_manifold_dims == 3: # Volume mesh - create UnstructuredGrid with tetrahedral cells cells_np = mesh.cells.cpu().numpy() if mesh.n_cells == 0: - # Empty cells - create UnstructuredGrid with no cells cells = np.array([], dtype=np.int64) celltypes = np.array([], dtype=np.uint8) pv_mesh = pv.UnstructuredGrid(cells, celltypes, points_np) else: - # PyVista format for cells: [4, i0, i1, i2, i3, 4, j0, j1, j2, j3, ...] - cells_list = [] - for cell in cells_np: - cells_list.append(4) # Number of points in this tetrahedron - cells_list.extend(cell) - cells_array = np.array(cells_list, dtype=np.int64) - - # All cells are tetrahedra + # PyVista padded format: [n_pts, v0..v3, n_pts, v0..v3, ...] + cells_array = np.column_stack( + [np.full(len(cells_np), cells_np.shape[1], dtype=np.int64), cells_np] + ).ravel() celltypes = np.full(mesh.n_cells, pv.CellType.TETRA, dtype=np.uint8) - pv_mesh = pv.UnstructuredGrid(cells_array, celltypes, points_np) else: raise ValueError(f"Unsupported {mesh.n_manifold_dims=}. Must be 0, 1, 2, or 3.") - ### Convert data dictionaries + ### Convert data dictionaries (flatten high-rank tensors for VTK compatibility) for k, v in mesh.point_data.items(include_nested=True, leaves_only=True): - pv_mesh.point_data[str(k)] = v.cpu().numpy() + arr = v.cpu().numpy() + pv_mesh.point_data[str(k)] = ( + arr.reshape(arr.shape[0], -1) if arr.ndim > 2 else arr + ) for k, v in mesh.cell_data.items(include_nested=True, leaves_only=True): - pv_mesh.cell_data[str(k)] = v.cpu().numpy() + arr = v.cpu().numpy() + pv_mesh.cell_data[str(k)] = ( + arr.reshape(arr.shape[0], -1) if arr.ndim > 2 else arr + ) for k, v in mesh.global_data.items(include_nested=True, leaves_only=True): - pv_mesh.field_data[str(k)] = v.cpu().numpy() + arr = v.cpu().numpy() + pv_mesh.field_data[str(k)] = ( + arr.reshape(arr.shape[0], -1) if arr.ndim > 2 else arr + ) return pv_mesh diff --git a/physicsnemo/mesh/mesh.py b/physicsnemo/mesh/mesh.py index e9f4811089..f061dd9807 100644 --- a/physicsnemo/mesh/mesh.py +++ b/physicsnemo/mesh/mesh.py @@ -14,6 +14,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +import math +import types from typing import TYPE_CHECKING, Any, Literal, Self, Sequence import torch @@ -26,7 +28,11 @@ transform, translate, ) -from physicsnemo.mesh.utilities._cache import get_cached, set_cached +from physicsnemo.mesh.utilities._cache import ( + CACHE_KEY, + get_cached, + set_cached, +) from physicsnemo.mesh.utilities._padding import _pad_by_tiling_last, _pad_with_value from physicsnemo.mesh.utilities._scatter_ops import scatter_aggregate from physicsnemo.mesh.utilities.mesh_repr import format_mesh_repr @@ -245,22 +251,28 @@ def __init__( self.global_data = global_data ### Validate shapes and dtypes - if self.points.ndim != 2: - raise ValueError( - f"`points` must have shape (n_points, n_spatial_dimensions), but got {self.points.shape=}." - ) - if self.cells.ndim != 2: - raise ValueError( - f"`cells` must have shape (n_cells, n_manifold_dimensions + 1), but got {self.cells.shape=}." - ) - if self.n_manifold_dims > self.n_spatial_dims: - raise ValueError( - f"`n_manifold_dims` must be <= `n_spatial_dims`, but got {self.n_manifold_dims=} > {self.n_spatial_dims=}." - ) - if torch.is_floating_point(self.cells): - raise TypeError( - f"`cells` must have an int-like dtype, but got {self.cells.dtype=}." - ) + if not torch.compiler.is_compiling(): + if self.points.ndim != 2: + raise ValueError( + f"`points` must have shape (n_points, n_spatial_dimensions), but got {self.points.shape=}." + ) + if self.cells.ndim != 2: + raise ValueError( + f"`cells` must have shape (n_cells, n_manifold_dimensions + 1), but got {self.cells.shape=}." + ) + if self.n_manifold_dims > self.n_spatial_dims: + raise ValueError( + f"`n_manifold_dims` must be <= `n_spatial_dims`, but got {self.n_manifold_dims=} > {self.n_spatial_dims=}." + ) + if torch.is_floating_point(self.cells): + raise TypeError( + f"`cells` must have an int-like dtype, but got {self.cells.dtype=}." + ) + if self.points.device != self.cells.device: + raise ValueError( + f"`points` and `cells` must be on the same device, " + f"but got {self.points.device=} and {self.cells.device=}." + ) if TYPE_CHECKING: # Type stub for the `to` method dynamically added by @tensorclass. @@ -305,6 +317,14 @@ def to(self, *args: Any, **kwargs: Any) -> Self: """ ... + def clone(self) -> Self: + """Return a shallow clone of this Mesh. + + All tensor storage is shared with the original; metadata and + TensorDict structure are independent copies. + """ + ... + @property def n_points(self) -> int: return self.points.shape[0] @@ -398,10 +418,7 @@ def cell_areas(self) -> torch.Tensor: ) # Result: (n_cells, n_manifold_dims, n_manifold_dims) ### Compute volume: sqrt(|det(G)|) / n! - # Compute factorial using torch for small integers - factorial = torch.arange( - 1, self.n_manifold_dims + 1, device=gram_matrix.device - ).prod() + factorial = math.factorial(self.n_manifold_dims) cached = gram_matrix.det().abs().sqrt() / factorial set_cached(self.cell_data, "areas", cached) @@ -551,7 +568,7 @@ def compute_point_normals( Four weighting schemes are available (following industry conventions from Autodesk Maya and 3ds Max): - - **"area"** (default): Area-weighted averaging, where larger faces have more + - **"area"**: Area-weighted averaging, where larger faces have more influence on the vertex normal. The normal at vertex v is computed as: ``point_normal_v = normalize(sum(cell_normal * cell_area))``. This reduces the influence of small sliver triangles. @@ -566,7 +583,7 @@ def compute_point_normals( have more influence. This often provides the most geometrically accurate normals for curved surfaces. - - **"angle_area"**: Combined angle and area weighting, where each face's + - **"angle_area"** (default): Combined angle and area weighting, where each face's contribution is weighted by both its area and the angle at the vertex. This is the default in Maya and balances both geometric factors. @@ -669,8 +686,10 @@ def compute_point_normals( elif weighting in ("angle", "angle_area"): # Compute interior angles at each vertex of each cell # For a simplex, angle at vertex k is between edges to other vertices - vertex_angles = ( - self._compute_vertex_angles() + from physicsnemo.mesh.geometry._angles import compute_vertex_angles + + vertex_angles = compute_vertex_angles( + self ) # (n_cells, n_vertices_per_cell) weights = vertex_angles.flatten() @@ -697,95 +716,126 @@ def compute_point_normals( ### Normalize to get unit normals return F.normalize(accumulated_normals, dim=-1) - def _compute_vertex_angles(self) -> torch.Tensor: - """Compute generalized interior angles at each vertex of each cell. + @property + def gaussian_curvature_vertices(self) -> torch.Tensor: + """Compute intrinsic Gaussian curvature at mesh vertices. - For an n-simplex, the "angle" at a vertex is computed using the unified - formula that generalizes to arbitrary dimensions: + Uses the angle defect method from discrete differential geometry: + K = (full_angle - Σ angles) / voronoi_area - Ω = 2 × arctan(√det(C) / (1 + Σᵢ<ⱼ Cᵢⱼ)) + This is an intrinsic measure of curvature (Theorema Egregium) that works + for any codimension, as it depends only on distances within the manifold. - where C is the correlation (normalized Gram) matrix of edge vectors: - Cᵢⱼ = (eᵢ · eⱼ) / (|eᵢ| |eⱼ|) + Signed curvature: + - Positive: Elliptic/convex (sphere-like) + - Zero: Flat/parabolic (plane-like) + - Negative: Hyperbolic/saddle (saddle-like) - This formula reduces to: - - For triangles (n=2): the planar interior angle θ - - For tetrahedra (n=3): the solid angle Ω (steradians) - - For higher n: the generalized solid angle + The result is cached in point_data["_cache"]["gaussian_curvature"] for efficiency. Returns ------- torch.Tensor - Tensor of shape (n_cells, n_vertices_per_cell) containing the - generalized angle at each vertex. + Tensor of shape (n_points,) containing signed Gaussian curvature. + Isolated vertices have NaN curvature. Notes ----- - This formula is derived by recognizing that both the planar angle formula - and the Van Oosterom & Strackee (1983) solid angle formula follow the - same pattern when expressed in terms of the correlation matrix. + Satisfies discrete Gauss-Bonnet theorem: + Σ_vertices (K_i * A_i) = 2π * χ(M) - The formula uses atan2 for numerical stability when the denominator - approaches zero (nearly degenerate simplices). + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> # Sphere of radius r has K = 1/r² + >>> sphere = sphere_icosahedral.load(radius=2.0, subdivisions=3) + >>> K = sphere.gaussian_curvature_vertices + >>> # K.mean() ≈ 0.25 (= 1/(2.0)²) """ - n_edges = self.n_manifold_dims # edges from each vertex - - # Get vertex positions: (n_cells, n_verts, n_spatial_dims) - cell_vertices = self.points[self.cells] - - # For each vertex k, compute the edge vectors to the other n_edges vertices - # Use roll to get shifted vertex positions: - # rolled[:, :, i, :] = cell_vertices[:, (k + i + 1) % n_verts, :] - - # Build edge vectors for all vertices simultaneously - # edges[k, i] = v_{(k+i+1) mod n_verts} - v_k - # Shape: (n_cells, n_verts, n_edges, n_spatial_dims) - edges = torch.stack( - [ - torch.roll(cell_vertices, shifts=-(i + 1), dims=1) - cell_vertices - for i in range(n_edges) - ], - dim=2, - ) + cached = get_cached(self.point_data, "gaussian_curvature") + if cached is None: + from physicsnemo.mesh.curvature import gaussian_curvature_vertices - # Compute edge lengths: (n_cells, n_verts, n_edges) - edge_lengths = edges.norm(dim=-1) + cached = gaussian_curvature_vertices(self) + set_cached(self.point_data, "gaussian_curvature", cached) - # Compute normalized edges: (n_cells, n_verts, n_edges, n_spatial_dims) - edges_normalized = edges / edge_lengths.unsqueeze(-1).clamp(min=1e-10) + return cached - # Compute correlation matrix C for each vertex of each cell - # C[i,j] = normalized_edge_i · normalized_edge_j - # Shape: (n_cells, n_verts, n_edges, n_edges) - # Using einsum: C_ij = sum_d (edges_normalized[:,:,i,d] * edges_normalized[:,:,j,d]) - corr_matrix = torch.einsum( - "cvid,cvjd->cvij", edges_normalized, edges_normalized - ) + @property + def gaussian_curvature_cells(self) -> torch.Tensor: + """Compute Gaussian curvature at cell centers using dual mesh concept. - # Compute det(C) for each vertex: (n_cells, n_verts) - det_C = torch.linalg.det(corr_matrix) + Treats cell centroids as vertices of a dual mesh and computes curvature + based on angles between connections to adjacent cell centroids. - # Compute sum of off-diagonal elements: Σᵢ<ⱼ Cᵢⱼ - # For an n×n matrix, sum of upper triangle (excluding diagonal) - # Create upper triangle mask - triu_mask = torch.triu( - torch.ones(n_edges, n_edges, device=self.points.device, dtype=torch.bool), - diagonal=1, - ) - # Sum off-diagonal: (n_cells, n_verts) - sum_off_diag = corr_matrix[:, :, triu_mask].sum(dim=-1) + The result is cached in cell_data["_cache"]["gaussian_curvature"] for efficiency. + + Returns + ------- + torch.Tensor + Tensor of shape (n_cells,) containing Gaussian curvature at cells. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> mesh = sphere_icosahedral.load(subdivisions=2) + >>> K_cells = mesh.gaussian_curvature_cells + """ + cached = get_cached(self.cell_data, "gaussian_curvature") + if cached is None: + from physicsnemo.mesh.curvature import gaussian_curvature_cells + + cached = gaussian_curvature_cells(self) + set_cached(self.cell_data, "gaussian_curvature", cached) + + return cached + + @property + def mean_curvature_vertices(self) -> torch.Tensor: + """Compute extrinsic mean curvature at mesh vertices. + + Uses the cotangent Laplace-Beltrami operator: + H = (1/2) * ||L @ points|| / voronoi_area + + Mean curvature is an extrinsic measure (depends on embedding) and is + only defined for codimension-1 manifolds where normal vectors exist. + + For 2D surfaces: H = (k1 + k2) / 2 where k1, k2 are principal curvatures - # Denominator: 1 + Σᵢ<ⱼ Cᵢⱼ - denominator = 1.0 + sum_off_diag + Signed curvature: + - Positive: Convex (sphere exterior with outward normals) + - Negative: Concave (sphere interior with outward normals) + - Zero: Minimal surface (soap film) - # Numerator: √det(C) (use abs for numerical stability with near-degenerate cells) - numerator = det_C.abs().sqrt() + The result is cached in point_data["_cache"]["mean_curvature"] for efficiency. - # Compute angle: Ω = 2 × arctan(numerator / denominator) - # Use atan2 for numerical stability - angles = 2.0 * torch.atan2(numerator, denominator) + Returns + ------- + torch.Tensor + Tensor of shape (n_points,) containing signed mean curvature. + Isolated vertices have NaN curvature. - return angles + Raises + ------ + ValueError + If mesh is not codimension-1. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> # Sphere of radius r has H = 1/r + >>> sphere = sphere_icosahedral.load(radius=2.0, subdivisions=3) + >>> H = sphere.mean_curvature_vertices + >>> # H.mean() ≈ 0.5 (= 1/2.0) + """ + cached = get_cached(self.point_data, "mean_curvature") + if cached is None: + from physicsnemo.mesh.curvature import mean_curvature_vertices + + cached = mean_curvature_vertices(self) + set_cached(self.point_data, "mean_curvature", cached) + + return cached @classmethod def merge( @@ -821,8 +871,8 @@ def merge( if not torch.compiler.is_compiling(): if len(meshes) == 0: raise ValueError("At least one Mesh must be provided to merge.") - elif len(meshes) == 1: # Short-circuit for speed in this case - return meshes[0] + elif len(meshes) == 1: # Return a shallow copy to avoid aliasing + return meshes[0].clone() if not all(isinstance(m, Mesh) for m in meshes): raise TypeError( f"All objects must be Mesh types. Got:\n" @@ -839,8 +889,20 @@ def merge( f"All meshes must have the same {name}. Got:\n{values=}" ) # Check that all cell_data dicts have the same keys across all meshes + # (ignoring internal cache keys stored under CACHE_KEY) + ref_keys = set( + meshes[0] + .cell_data.exclude(CACHE_KEY) + .keys(include_nested=True, leaves_only=True) + ) if not all( - m.cell_data.keys() == meshes[0].cell_data.keys() for m in meshes + set( + m.cell_data.exclude(CACHE_KEY).keys( + include_nested=True, leaves_only=True + ) + ) + == ref_keys + for m in meshes ): raise ValueError("All meshes must have the same cell_data keys.") @@ -867,8 +929,13 @@ def merge( [m.cells + offset for m, offset in zip(meshes, cell_index_offsets)], dim=0, ), - point_data=TensorDict.cat([m.point_data for m in meshes], dim=0), - cell_data=TensorDict.cat([m.cell_data for m in meshes], dim=0), + # Strip cached values before concatenating (caches are mesh-specific) + point_data=TensorDict.cat( + [m.point_data.exclude(CACHE_KEY) for m in meshes], dim=0 + ), + cell_data=TensorDict.cat( + [m.cell_data.exclude(CACHE_KEY) for m in meshes], dim=0 + ), global_data=global_data, ) @@ -876,7 +943,7 @@ def slice_points( self, indices: int | slice - | type(Ellipsis) # ty: ignore[invalid-type-form] + | types.EllipsisType | None | torch.Tensor | Sequence[int | bool], @@ -970,7 +1037,7 @@ def slice_cells( self, indices: int | slice - | type(Ellipsis) # ty: ignore[invalid-type-form] + | types.EllipsisType | None | torch.Tensor | Sequence[int | bool | slice], @@ -998,6 +1065,131 @@ def slice_cells( global_data=self.global_data, ) + def sample_random_points_on_cells( + self, + cell_indices: Sequence[int] | torch.Tensor | None = None, + alpha: float = 1.0, + ) -> torch.Tensor: + """Sample random points on specified cells of the mesh. + + Uses a Dirichlet distribution to generate barycentric coordinates, which are + then used to compute random points as weighted combinations of cell vertices. + The concentration parameter alpha controls the distribution of samples within + each cell (simplex). + + This is a convenience method that delegates to physicsnemo.mesh.sampling.sample_random_points_on_cells. + + Parameters + ---------- + cell_indices : Sequence[int] or torch.Tensor or None, optional + Indices of cells to sample from. Can be a Sequence or tensor. + Allows repeated indices to sample multiple points from the same cell. + If None, samples one point from each cell (equivalent to arange(n_cells)). + Shape: (n_samples,) where n_samples is the number of points to sample. + alpha : float, optional + Concentration parameter for the Dirichlet distribution. Controls how + samples are distributed within each cell: + - alpha = 1.0: Uniform distribution over the simplex (default) + - alpha > 1.0: Concentrates samples toward the center of each cell + - alpha < 1.0: Concentrates samples toward vertices and edges + + Returns + ------- + torch.Tensor + Random points on cells, shape (n_samples, n_spatial_dims). Each point lies + within its corresponding cell. If cell_indices is None, n_samples = n_cells. + + Raises + ------ + NotImplementedError + If alpha != 1.0 and torch.compile is being used. + This is due to a PyTorch limitation with Gamma distributions under torch.compile. + IndexError + If any cell_indices are out of bounds. + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> # Sample one point from each cell uniformly + >>> points = mesh.sample_random_points_on_cells() + >>> assert points.shape == (mesh.n_cells, mesh.n_spatial_dims) + """ + from physicsnemo.mesh.sampling import sample_random_points_on_cells + + return sample_random_points_on_cells( + mesh=self, + cell_indices=cell_indices, + alpha=alpha, + ) + + def sample_data_at_points( + self, + query_points: torch.Tensor, + data_source: Literal["cells", "points"] = "cells", + multiple_cells_strategy: Literal["mean", "nan"] = "mean", + project_onto_nearest_cell: bool = False, + tolerance: float = 1e-6, + bvh: Any = None, + ) -> "TensorDict": + """Extract or interpolate mesh data at specified query points. + + This method retrieves mesh data at arbitrary spatial locations. Note that + "sample" here means "extract/query at specific points" - NOT random sampling. + For random point sampling, see :meth:`sample_random_points_on_cells`. + + Containment queries are BVH-accelerated (O(n_queries * log(n_cells))). + + Parameters + ---------- + query_points : torch.Tensor + Query point locations, shape (n_queries, n_spatial_dims). + data_source : {"cells", "points"}, optional + How to retrieve data: + - "cells": Use cell data directly (no interpolation) + - "points": Interpolate point data using barycentric coordinates + multiple_cells_strategy : {"mean", "nan"}, optional + How to handle query points in multiple cells: + - "mean": Return arithmetic mean of values from all containing cells + - "nan": Return NaN for ambiguous points + project_onto_nearest_cell : bool, optional + If True, snaps each query point to the centroid of the nearest cell + before containment testing. Useful for codimension != 0 manifolds. + tolerance : float, optional + Tolerance for considering a point inside a cell. + bvh : BVH or None, optional + Pre-built Bounding Volume Hierarchy. If ``None`` (default), one is + built automatically. For repeated queries, pre-build with + ``BVH.from_mesh(mesh)`` and pass it here to avoid redundant work. + + Returns + ------- + TensorDict + Data for each query point. Values are NaN for query points outside + the mesh. + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> mesh.cell_data["pressure"] = torch.tensor([1.0, 2.0]) + >>> query_pts = torch.tensor([[0.3, 0.3], [0.8, 0.5]]) + >>> data = mesh.sample_data_at_points(query_pts, data_source="cells") + """ + from physicsnemo.mesh.sampling import sample_data_at_points + + return sample_data_at_points( + mesh=self, + query_points=query_points, + data_source=data_source, + multiple_cells_strategy=multiple_cells_strategy, + project_onto_nearest_cell=project_onto_nearest_cell, + tolerance=tolerance, + bvh=bvh, + ) + def cell_data_to_point_data(self, overwrite_keys: bool = False) -> "Mesh": """Convert cell data to point data by averaging. @@ -1029,14 +1221,20 @@ def cell_data_to_point_data(self, overwrite_keys: bool = False) -> "Mesh": """ ### Check for key conflicts if not overwrite_keys: - for key in self.cell_data.exclude("_cache").keys(): - if key in self.point_data.keys(): - raise ValueError( - f"Key {key!r} already exists in point_data. " - f"Set overwrite_keys=True to overwrite." - ) + src_keys = set( + self.cell_data.exclude(CACHE_KEY).keys( + include_nested=True, leaves_only=True + ) + ) + dst_keys = set(self.point_data.keys(include_nested=True, leaves_only=True)) + conflicts = src_keys & dst_keys + if conflicts: + raise ValueError( + f"Keys {conflicts} already exist in point_data. " + f"Set overwrite_keys=True to overwrite." + ) - ### Convert each cell data field to point data + ### Convert each cell data field to point data via scatter aggregation new_point_data = self.point_data.clone() # Get flat list of point indices and corresponding cell indices @@ -1053,21 +1251,17 @@ def cell_data_to_point_data(self, overwrite_keys: bool = False) -> "Mesh": self.n_cells, device=self.points.device ).repeat_interleave(n_vertices_per_cell) - for key, cell_values in self.cell_data.exclude("_cache").items(): - ### Use scatter aggregation utility to average cell values to points - # Expand cell values to one entry per vertex - src_data = cell_values[cell_indices] - - # Aggregate to points using mean - point_values = scatter_aggregate( - src_data=src_data, + converted = self.cell_data.exclude(CACHE_KEY).apply( + lambda cell_values: scatter_aggregate( + src_data=cell_values[cell_indices], src_to_dst_mapping=point_indices, n_dst=self.n_points, weights=None, aggregation="mean", - ) - - new_point_data[key] = point_values + ), + batch_size=torch.Size([self.n_points]), + ) + new_point_data.update(converted) ### Return new mesh with updated point data return Mesh( @@ -1109,25 +1303,27 @@ def point_data_to_cell_data(self, overwrite_keys: bool = False) -> "Mesh": """ ### Check for key conflicts if not overwrite_keys: - for key in self.point_data.exclude("_cache").keys(): - if key in self.cell_data.keys(): - raise ValueError( - f"Key {key!r} already exists in cell_data. " - f"Set overwrite_keys=True to overwrite." - ) + src_keys = set( + self.point_data.exclude(CACHE_KEY).keys( + include_nested=True, leaves_only=True + ) + ) + dst_keys = set(self.cell_data.keys(include_nested=True, leaves_only=True)) + conflicts = src_keys & dst_keys + if conflicts: + raise ValueError( + f"Keys {conflicts} already exist in cell_data. " + f"Set overwrite_keys=True to overwrite." + ) - ### Convert each point data field to cell data + ### Convert each point data field to cell data by averaging over cell vertices new_cell_data = self.cell_data.clone() - for key, point_values in self.point_data.exclude("_cache").items(): - # Get point values for each cell and average - # cell_point_values shape: (n_cells, n_vertices_per_cell, ...) - cell_point_values = point_values[self.cells] - - # Average over vertices dimension (dim=1) - cell_values = cell_point_values.mean(dim=1) - - new_cell_data[key] = cell_values + converted = self.point_data.exclude(CACHE_KEY).apply( + lambda point_values: point_values[self.cells].mean(dim=1), + batch_size=torch.Size([self.n_cells]), + ) + new_cell_data.update(converted) ### Return new mesh with updated cell data return Mesh( @@ -1138,6 +1334,344 @@ def point_data_to_cell_data(self, overwrite_keys: bool = False) -> "Mesh": global_data=self.global_data, ) + def get_facet_mesh( + self, + manifold_codimension: int = 1, + data_source: Literal["points", "cells"] = "cells", + data_aggregation: Literal["mean", "area_weighted", "inverse_distance"] = "mean", + target_counts: "list[int] | Literal['boundary', 'shared', 'interior', 'all']" = "all", + ) -> "Mesh": + """Extract k-codimension facet mesh from this n-dimensional mesh. + + Extracts all (n-k)-simplices from the current n-simplicial mesh. For example: + - Triangle mesh (2-simplices) → edge mesh (1-simplices) [codimension=1, default] + - Triangle mesh (2-simplices) → vertex mesh (0-simplices) [codimension=2] + - Tetrahedral mesh (3-simplices) → triangular facet mesh (2-simplices) [codimension=1, default] + - Tetrahedral mesh (3-simplices) → edge mesh (1-simplices) [codimension=2] + + The resulting mesh shares the same vertex positions but has connectivity + representing the lower-dimensional simplices. Data can be inherited from + either the parent cells or the boundary points. + + Parameters + ---------- + manifold_codimension : int, optional + Codimension of extracted mesh relative to parent. + - 1: Extract (n-1)-facets (default, immediate boundaries of all cells) + - 2: Extract (n-2)-facets (e.g., edges from tets, vertices from triangles) + - k: Extract (n-k)-facets + data_source : {"points", "cells"}, optional + Source of data inheritance: + - "cells": Facets inherit from parent cells they bound. When multiple + cells share a facet, data is aggregated according to data_aggregation. + - "points": Facets inherit from their boundary vertices. Data from + multiple boundary points is averaged. + data_aggregation : {"mean", "area_weighted", "inverse_distance"}, optional + Strategy for aggregating data from multiple sources + (only applies when data_source="cells"): + - "mean": Simple arithmetic mean + - "area_weighted": Weighted by parent cell areas + - "inverse_distance": Weighted by inverse distance from facet centroid + to parent cell centroids + target_counts : list[int] | {"boundary", "shared", "interior", "all"}, optional + Which facets to keep based on how many parent cells share them: + - "all": Keep all unique facets (default) + - "boundary": Keep only boundary facets (appearing in exactly 1 cell) + - "shared": Keep only shared facets (appearing in 2+ cells) + - "interior": Keep only interior facets (appearing in exactly 2 cells) + - list[int]: Keep facets with counts matching any value in the list + + Returns + ------- + Mesh + New Mesh with n_manifold_dims = self.n_manifold_dims - manifold_codimension, + embedded in the same spatial dimension. The mesh shares the same points array + but has new cells connectivity and aggregated cell_data. + + Raises + ------ + ValueError + If manifold_codimension is too large for this mesh + (would result in negative manifold dimension). + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> # Extract edges from a triangle mesh (codimension 1) + >>> triangle_mesh = two_triangles_2d.load() + >>> edge_mesh = triangle_mesh.get_facet_mesh(manifold_codimension=1) + >>> assert edge_mesh.n_manifold_dims == 1 # edges + >>> + >>> # Extract vertices from a triangle mesh (codimension 2) + >>> vertex_mesh = triangle_mesh.get_facet_mesh(manifold_codimension=2) + >>> assert vertex_mesh.n_manifold_dims == 0 # vertices + >>> facet_mesh = triangle_mesh.get_facet_mesh( + ... data_source="cells", + ... data_aggregation="area_weighted" + ... ) + """ + ### Validate that extraction is possible + new_manifold_dims = self.n_manifold_dims - manifold_codimension + if new_manifold_dims < 0: + raise ValueError( + f"Cannot extract facet mesh with {manifold_codimension=} from mesh with {self.n_manifold_dims=}.\n" + f"Would result in negative manifold dimension ({new_manifold_dims=}).\n" + f"Maximum allowed codimension is {self.n_manifold_dims}." + ) + + ### Call kernel to extract facet mesh data + from physicsnemo.mesh.boundaries import extract_facet_mesh_data + + facet_cells, facet_cell_data = extract_facet_mesh_data( + parent_mesh=self, + manifold_codimension=manifold_codimension, + data_source=data_source, + data_aggregation=data_aggregation, + target_counts=target_counts, + ) + + ### Create and return new Mesh + # Filter out cached properties from point_data + # Cached geometric properties depend on cell connectivity and would be invalid + filtered_point_data = self.point_data.exclude(CACHE_KEY) + + return Mesh( + points=self.points, # Share the same points + cells=facet_cells, # New connectivity for sub-simplices + point_data=filtered_point_data, # User data only, no cached properties + cell_data=facet_cell_data, # Aggregated cell data + global_data=self.global_data, # Share global data + ) + + def get_boundary_mesh( + self, + data_source: Literal["points", "cells"] = "cells", + data_aggregation: Literal["mean", "area_weighted", "inverse_distance"] = "mean", + ) -> "Mesh": + """Extract the boundary surface of this mesh. + + Convenience wrapper around :meth:`get_facet_mesh` that extracts only + boundary facets (those appearing in exactly one parent cell). + + See :meth:`get_facet_mesh` for full parameter documentation. + + Parameters + ---------- + data_source : {"points", "cells"}, optional + Source of data inheritance. Default: "cells". + data_aggregation : {"mean", "area_weighted", "inverse_distance"}, optional + Strategy for aggregating data. Default: "mean". + + Returns + ------- + Mesh + Boundary mesh containing only boundary facets. + + Notes + ----- + For meshes with internal cavities (like volume meshes with voids or + drivaerML-style automotive meshes), this returns BOTH the exterior + surface and any interior cavity surfaces. All facets that appear in + exactly one parent cell are included, regardless of whether they face + "outward" or "inward". + + Examples + -------- + >>> from physicsnemo.mesh.primitives.procedural import lumpy_ball + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> # Extract triangular surface of a volume mesh + >>> vol_mesh = lumpy_ball.load(n_shells=2, subdivisions=1) + >>> surface_mesh = vol_mesh.get_boundary_mesh() + >>> assert surface_mesh.n_manifold_dims == 2 # triangles + >>> + >>> # For a closed watertight sphere + >>> sphere = sphere_icosahedral.load(subdivisions=3) + >>> boundary = sphere.get_boundary_mesh() + >>> assert boundary.n_cells == 0 # no boundary + """ + return self.get_facet_mesh( + manifold_codimension=1, + data_source=data_source, + data_aggregation=data_aggregation, + target_counts="boundary", + ) + + def is_watertight(self) -> bool: + """Check if mesh is watertight (has no boundary). + + A mesh is watertight if every codimension-1 facet is shared by exactly 2 cells. + This means the mesh forms a closed surface/volume with no holes or gaps. + + Returns + ------- + bool + True if mesh is watertight (no boundary facets), False otherwise. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral, cylinder_open + >>> # Closed sphere is watertight + >>> sphere = sphere_icosahedral.load(subdivisions=3) + >>> assert sphere.is_watertight() == True + >>> + >>> # Open cylinder with holes at ends + >>> cylinder = cylinder_open.load() + >>> assert cylinder.is_watertight() == False + """ + from physicsnemo.mesh.boundaries import is_watertight + + return is_watertight(self) + + def is_manifold( + self, + check_level: Literal["facets", "edges", "full"] = "full", + ) -> bool: + """Check if mesh is a valid topological manifold. + + A mesh is a manifold if it locally looks like Euclidean space at every point. + This function checks various topological constraints depending on the check level. + + Parameters + ---------- + check_level : {"facets", "edges", "full"}, optional + Level of checking to perform: + - "facets": Only check codimension-1 facets (each appears 1-2 times) + - "edges": Check facets + edge neighborhoods (for 2D/3D meshes) + - "full": Complete manifold validation (default) + + Returns + ------- + bool + True if mesh passes the specified manifold checks, False otherwise. + + Notes + ----- + This function checks topological constraints but does not check for + geometric self-intersections (which would require expensive spatial queries). + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral, cylinder_open + >>> # Valid manifold (sphere) + >>> sphere = sphere_icosahedral.load(subdivisions=3) + >>> assert sphere.is_manifold() == True + >>> + >>> # Manifold with boundary (open cylinder) + >>> cylinder = cylinder_open.load() + >>> assert cylinder.is_manifold() == True # manifold with boundary is OK + """ + from physicsnemo.mesh.boundaries import is_manifold + + return is_manifold(self, check_level=check_level) + + def get_point_to_cells_adjacency(self): + """Compute the star of each vertex (all cells containing each point). + + For each point in the mesh, finds all cells that contain that point. This + is the graph-theoretic "star" operation on vertices. + + Returns + ------- + Adjacency + Adjacency where adjacency.to_list()[i] contains all cell indices that + contain point i. Isolated points (not in any cells) have empty lists. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> adj = mesh.get_point_to_cells_adjacency() + >>> # Get cells containing point 0 + >>> cells_of_point_0 = adj.to_list()[0] + """ + from physicsnemo.mesh.neighbors import get_point_to_cells_adjacency + + return get_point_to_cells_adjacency(self) + + def get_point_to_points_adjacency(self): + """Compute point-to-point adjacency (graph edges of the mesh). + + For each point, finds all other points that share a cell with it. In simplicial + meshes, this is equivalent to finding all points connected by an edge. + + Returns + ------- + Adjacency + Adjacency where adjacency.to_list()[i] contains all point indices that + share a cell (edge) with point i. Isolated points have empty lists. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> adj = mesh.get_point_to_points_adjacency() + >>> # Get neighbors of point 0 + >>> neighbors_of_point_0 = adj.to_list()[0] + """ + from physicsnemo.mesh.neighbors import get_point_to_points_adjacency + + return get_point_to_points_adjacency(self) + + def get_cell_to_cells_adjacency(self, adjacency_codimension: int = 1): + """Compute cell-to-cells adjacency based on shared facets. + + Two cells are considered adjacent if they share a k-codimension facet. + + Parameters + ---------- + adjacency_codimension : int, optional + Codimension of shared facets defining adjacency. + - 1 (default): Cells must share a codimension-1 facet (e.g., triangles + sharing an edge, tetrahedra sharing a triangular face) + - 2: Cells must share a codimension-2 facet (e.g., tetrahedra sharing + an edge) + - k: Cells must share a codimension-k facet + + Returns + ------- + Adjacency + Adjacency where adjacency.to_list()[i] contains all cell indices that + share a k-codimension facet with cell i. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> adj = mesh.get_cell_to_cells_adjacency(adjacency_codimension=1) + >>> # Get cells sharing an edge with cell 0 + >>> neighbors_of_cell_0 = adj.to_list()[0] + """ + from physicsnemo.mesh.neighbors import get_cell_to_cells_adjacency + + return get_cell_to_cells_adjacency( + self, adjacency_codimension=adjacency_codimension + ) + + def get_cell_to_points_adjacency(self): + """Get the vertices (points) that comprise each cell. + + This is a simple wrapper around the cells array that returns it in the + standard Adjacency format for consistency with other neighbor queries. + + Returns + ------- + Adjacency + Adjacency where adjacency.to_list()[i] contains all point indices that + are vertices of cell i. For simplicial meshes, all cells have the same + number of vertices (n_manifold_dims + 1). + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> adj = mesh.get_cell_to_points_adjacency() + >>> # Get vertices of cell 0 + >>> vertices_of_cell_0 = adj.to_list()[0] + """ + from physicsnemo.mesh.neighbors import get_cell_to_points_adjacency + + return get_cell_to_points_adjacency(self) + def pad( self, target_n_points: int | None = None, @@ -1201,11 +1735,11 @@ def pad( return self.__class__( points=_pad_by_tiling_last(self.points, target_n_points), cells=_pad_with_value(self.cells, target_n_cells, self.n_points - 1), - point_data=self.point_data.apply( # type: ignore + point_data=self.point_data.apply( lambda x: _pad_with_value(x, target_n_points, data_padding_value), batch_size=torch.Size([target_n_points]), ), - cell_data=self.cell_data.apply( # type: ignore + cell_data=self.cell_data.apply( lambda x: _pad_with_value(x, target_n_cells, data_padding_value), batch_size=torch.Size([target_n_cells]), ), @@ -1264,8 +1798,8 @@ def next_power_size(current_size: int, base: float) -> int: # Solve for n: floor(base^n) >= current_size # n >= log(current_size) / log(base) - n = (torch.tensor(safe_size).log() / torch.tensor(base).log()).ceil() - return int(torch.tensor(base) ** n) + n = math.ceil(math.log(safe_size) / math.log(base)) + return int(base**n) target_n_points = next_power_size(self.n_points, power) target_n_cells = next_power_size(self.n_cells, power) @@ -1290,7 +1824,7 @@ def draw( alpha_edges: float = 1.0, show_edges: bool = True, ax=None, - **kwargs, + backend_options: dict[str, Any] | None = None, ): """Draw the mesh using matplotlib or PyVista backend. @@ -1339,8 +1873,9 @@ def draw( ax : matplotlib.axes.Axes, optional (matplotlib only) Existing matplotlib axes to plot on. If None, creates new figure and axes. - **kwargs : dict - Additional backend-specific keyword arguments. + backend_options : dict[str, Any], optional + Additional keyword arguments forwarded to the underlying + visualization backend (e.g. PyVista's ``plotter.add_mesh()``). Returns ------- @@ -1390,7 +1925,7 @@ def draw( alpha_edges=alpha_edges, show_edges=show_edges, ax=ax, - **kwargs, + backend_options=backend_options, ) def translate( @@ -1416,7 +1951,7 @@ def translate( def rotate( self, angle: float, - axis: torch.Tensor | list | tuple | None = None, + axis: torch.Tensor | list | tuple | Literal["x", "y", "z"] | None = None, center: torch.Tensor | list | tuple | None = None, transform_point_data: bool = False, transform_cell_data: bool = False, @@ -1430,8 +1965,10 @@ def rotate( ---------- angle : float Rotation angle in radians. - axis : torch.Tensor or list or tuple, optional + axis : torch.Tensor or list or tuple or {"x", "y", "z"}, optional Rotation axis vector. None for 2D, shape (3,) for 3D. + String literals "x", "y", "z" are converted to unit vectors + (1,0,0), (0,1,0), (0,0,1) respectively. center : torch.Tensor or list or tuple, optional Center point for rotation. transform_point_data : bool @@ -1544,6 +2081,405 @@ def transform( assume_invertible, ) + def compute_point_derivatives( + self, + keys: str | tuple[str, ...] | list[str | tuple[str, ...]] | None = None, + method: Literal["lsq", "dec"] = "lsq", + gradient_type: Literal["intrinsic", "extrinsic", "both"] = "intrinsic", + ) -> "Mesh": + """Compute gradients of point_data fields. + + This is a convenience method that delegates to physicsnemo.mesh.calculus.compute_point_derivatives. + + Parameters + ---------- + keys : str or tuple[str, ...] or list[str | tuple[str, ...]] or None, optional + Fields to compute gradients of. Options: + - None: All non-cached fields (excludes "_cache" subdictionary) + - str: Single field name (e.g., "pressure") + - tuple: Nested path (e.g., ("flow", "temperature")) + - list: Multiple fields (e.g., ["pressure", "velocity"]) + method : {"lsq", "dec"}, optional + Discretization method: + - "lsq": Weighted least-squares reconstruction (default, CFD standard) + - "dec": Discrete Exterior Calculus (differential geometry) + gradient_type : {"intrinsic", "extrinsic", "both"}, optional + Type of gradient: + - "intrinsic": Project onto manifold tangent space (default) + - "extrinsic": Full ambient space gradient + - "both": Compute and store both + + Returns + ------- + Mesh + Self (mesh) with gradient fields added to point_data (modified in place). + Field naming: "{field}_gradient" or "{field}_gradient_intrinsic/extrinsic" + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> mesh.point_data["pressure"] = torch.randn(mesh.n_points) + >>> # Compute gradient of pressure + >>> mesh_grad = mesh.compute_point_derivatives(keys="pressure") + >>> grad_p = mesh_grad.point_data["pressure_gradient"] + """ + from physicsnemo.mesh.calculus import compute_point_derivatives + + return compute_point_derivatives( + mesh=self, + keys=keys, + method=method, + gradient_type=gradient_type, + ) + + def compute_cell_derivatives( + self, + keys: str | tuple[str, ...] | list[str | tuple[str, ...]] | None = None, + method: Literal["lsq", "dec"] = "lsq", + gradient_type: Literal["intrinsic", "extrinsic", "both"] = "intrinsic", + ) -> "Mesh": + """Compute gradients of cell_data fields. + + This is a convenience method that delegates to + :func:`physicsnemo.mesh.calculus.compute_cell_derivatives`. + + Parameters + ---------- + keys : str or tuple[str, ...] or list[str | tuple[str, ...]] or None, optional + Fields to compute gradients of (same format as compute_point_derivatives). + method : {"lsq"}, optional + Discretization method for cell-centered data. Currently only + ``"lsq"`` (weighted least-squares) is implemented. DEC + gradients for cell-centered data are not available because the + standard DEC exterior derivative maps vertex 0-forms to edge + 1-forms; there is no analogous cell-to-cell operator in the + primal DEC complex. + gradient_type : {"intrinsic", "extrinsic", "both"}, optional + Type of gradient to compute. + + Returns + ------- + Mesh + A new Mesh with gradient fields added to ``cell_data``. + + Raises + ------ + NotImplementedError + If ``method="dec"`` is requested. + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> mesh.cell_data["pressure"] = torch.randn(mesh.n_cells) + >>> # Compute gradient of cell-centered pressure + >>> mesh_grad = mesh.compute_cell_derivatives(keys="pressure") + """ + from physicsnemo.mesh.calculus import compute_cell_derivatives + + return compute_cell_derivatives( + mesh=self, + keys=keys, + method=method, + gradient_type=gradient_type, + ) + + def validate( + self, + check_degenerate_cells: bool = True, + check_duplicate_vertices: bool = True, + check_inverted_cells: bool = False, + check_out_of_bounds: bool = True, + check_manifoldness: bool = False, + tolerance: float = 1e-10, + raise_on_error: bool = False, + ): + """Validate mesh integrity and detect common errors. + + Convenience method that delegates to physicsnemo.mesh.validation.validate_mesh. + + Parameters + ---------- + check_degenerate_cells : bool, optional + Check for zero/negative area cells. + check_duplicate_vertices : bool, optional + Check for coincident vertices. + check_inverted_cells : bool, optional + Check for negative orientation. + check_out_of_bounds : bool, optional + Check cell indices are valid. + check_manifoldness : bool, optional + Check manifold topology (2D only). + tolerance : float, optional + Tolerance for geometric checks. + raise_on_error : bool, optional + Raise ValueError on first error vs return report. + + Returns + ------- + dict + Dictionary with validation results. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> report = mesh.validate() + >>> assert report["valid"] == True + """ + from physicsnemo.mesh.validation import validate_mesh + + return validate_mesh( + mesh=self, + check_degenerate_cells=check_degenerate_cells, + check_duplicate_vertices=check_duplicate_vertices, + check_inverted_cells=check_inverted_cells, + check_out_of_bounds=check_out_of_bounds, + check_manifoldness=check_manifoldness, + tolerance=tolerance, + raise_on_error=raise_on_error, + ) + + @property + def quality_metrics(self): + """Compute geometric quality metrics for all cells. + + Returns + ------- + TensorDict + Per-cell quality metrics: + - aspect_ratio: max_edge / characteristic_length + - edge_length_ratio: max_edge / min_edge + - min_angle, max_angle: Interior angles (triangles only) + - quality_score: Combined metric in [0,1] (1.0 is perfect) + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> metrics = mesh.quality_metrics + >>> assert "quality_score" in metrics.keys() + """ + from physicsnemo.mesh.validation import compute_quality_metrics + + return compute_quality_metrics(self) + + @property + def statistics(self): + """Compute summary statistics for mesh. + + Returns + ------- + dict + Mesh statistics including counts, edge length distributions, + area distributions, and quality metrics. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> stats = mesh.statistics + >>> assert "n_points" in stats and "n_cells" in stats + """ + from physicsnemo.mesh.validation import compute_mesh_statistics + + return compute_mesh_statistics(self) + + def subdivide( + self, + levels: int = 1, + filter: Literal["linear", "butterfly", "loop"] = "linear", + ) -> "Mesh": + """Subdivide the mesh using iterative application of subdivision schemes. + + Subdivision refines the mesh by splitting each n-simplex into 2^n child + simplices. Multiple subdivision schemes are supported, each with different + geometric and smoothness properties. + + This method applies the chosen subdivision scheme iteratively for the + specified number of levels. Each level independently subdivides the + current mesh. + + Parameters + ---------- + levels : int, optional + Number of subdivision iterations to perform. Each level + increases mesh resolution exponentially: + - 0: No subdivision (returns original mesh) + - 1: Each cell splits into 2^n children + - 2: Each cell splits into 4^n children + - k: Each cell splits into (2^k)^n children + filter : {"linear", "butterfly", "loop"}, optional + Subdivision scheme to use: + - "linear": Simple midpoint subdivision (interpolating). + New vertices at exact edge midpoints. Works for any dimension. + Preserves original vertices. + - "butterfly": Weighted stencil subdivision (interpolating). + New vertices use weighted neighbor stencils for smoother results. + Currently only supports 2D manifolds (triangular meshes). + Preserves original vertices. + - "loop": Valence-based subdivision (approximating). + Both old and new vertices are repositioned for C² smoothness. + Currently only supports 2D manifolds (triangular meshes). + Original vertices move to new positions. + + Returns + ------- + Mesh + Subdivided mesh with refined geometry and connectivity. + - Manifold and spatial dimensions are preserved + - Point data is interpolated to new vertices + - Cell data is propagated from parents to children + - Global data is preserved unchanged + + Raises + ------ + ValueError + If levels < 0 or if filter is not one of the supported schemes. + NotImplementedError + If butterfly/loop filter used with non-2D manifold. + + Notes + ----- + Multi-level subdivision is achieved by iterative application. + For levels=3, this is equivalent to calling subdivide(levels=1) + three times in sequence. This is the standard approach for all + subdivision schemes. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> # Linear subdivision of triangular mesh + >>> mesh = two_triangles_2d.load() + >>> refined = mesh.subdivide(levels=2, filter="linear") + >>> # Each triangle splits into 4, twice: 2 -> 8 -> 32 triangles + >>> assert refined.n_cells == mesh.n_cells * 16 + """ + from physicsnemo.mesh.subdivision import ( + subdivide_butterfly, + subdivide_linear, + subdivide_loop, + ) + + ### Validate inputs + if levels < 0: + raise ValueError(f"levels must be >= 0, got {levels=}") + + ### Apply subdivision iteratively + mesh = self + for _ in range(levels): + if filter == "linear": + mesh = subdivide_linear(mesh) + elif filter == "butterfly": + mesh = subdivide_butterfly(mesh) + elif filter == "loop": + mesh = subdivide_loop(mesh) + else: + raise ValueError( + f"Invalid {filter=}. Must be one of: 'linear', 'butterfly', 'loop'" + ) + + return mesh + + def clean( + self, + tolerance: float = 1e-12, + merge_points: bool = True, + remove_duplicate_cells: bool = True, + remove_unused_points: bool = True, + ) -> "Mesh": + """Clean and repair this mesh. + + Performs various cleaning operations to fix common mesh issues: + 1. Merge duplicate points within tolerance + 2. Remove duplicate cells + 3. Remove unused points + + This is useful after mesh operations that may introduce duplicate geometry + or after importing meshes from external sources that may have redundant data. + + Parameters + ---------- + tolerance : float, optional + Absolute L2 distance threshold for merging duplicate points. + merge_points : bool, optional + Whether to merge duplicate points (default True). + remove_duplicate_cells : bool, optional + Whether to remove duplicate cells (default True). + remove_unused_points : bool, optional + Whether to remove unused points (default True). + + Returns + ------- + Mesh + Cleaned mesh with same structure but repaired topology. + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh import Mesh + >>> # Mesh with duplicate points + >>> points = torch.tensor([[0., 0.], [1., 0.], [0., 0.], [1., 1.]]) + >>> cells = torch.tensor([[0, 1, 3], [2, 1, 3]]) + >>> mesh = Mesh(points=points, cells=cells) + >>> cleaned = mesh.clean() + >>> assert cleaned.n_points == 3 # points 0 and 2 merged + >>> + >>> # Adjust tolerance for coarser merging + >>> mesh_loose = mesh.clean(tolerance=1e-6) + >>> + >>> # Only merge points, keep duplicate cells + >>> mesh_partial = mesh.clean( + ... merge_points=True, + ... remove_duplicate_cells=False + ... ) + """ + from physicsnemo.mesh.repair import clean_mesh + + cleaned, _stats = clean_mesh( + mesh=self, + tolerance=tolerance, + merge_points=merge_points, + deduplicate_cells=remove_duplicate_cells, + drop_unused_points=remove_unused_points, + ) + return cleaned + + def strip_caches(self) -> "Mesh": + r"""Return a new mesh with all cached values removed. + + Cached values (stored under the ``_cache`` key in data TensorDicts) are + computed lazily for expensive operations like normals, areas, and curvature. + This method creates a new mesh without these cached values, which is useful + for: + + - Accurate benchmarking (prevents false performance benefits from caching) + - Reducing memory usage + - Forcing recomputation of cached values + + Returns + ------- + Mesh + A new mesh with the same geometry and data, but without cached values. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> mesh = sphere_icosahedral.load(subdivisions=2) + >>> _ = mesh.cell_normals # Triggers caching + >>> mesh_clean = mesh.strip_caches() # Remove cached normals + """ + return Mesh( + points=self.points, + cells=self.cells, + point_data=self.point_data.exclude(CACHE_KEY), + cell_data=self.cell_data.exclude(CACHE_KEY), + global_data=self.global_data.exclude(CACHE_KEY), + ) + ### Override the tensorclass __repr__ with custom formatting # Note: Must be done after class definition because @tensorclass overrides __repr__ diff --git a/physicsnemo/mesh/neighbors/__init__.py b/physicsnemo/mesh/neighbors/__init__.py new file mode 100644 index 0000000000..f3c20732e4 --- /dev/null +++ b/physicsnemo/mesh/neighbors/__init__.py @@ -0,0 +1,35 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Neighbor and adjacency computation for simplicial meshes. + +This module provides GPU-compatible functions for computing various adjacency +relationships in simplicial meshes, including point-to-cells, point-to-points, +and cell-to-cells adjacency. + +All adjacency relationships are returned as Adjacency tensorclass objects using +offset-indices encoding for efficient representation of ragged arrays. +""" + +from physicsnemo.mesh.neighbors._adjacency import Adjacency, build_adjacency_from_pairs +from physicsnemo.mesh.neighbors._cell_neighbors import ( + get_cell_to_cells_adjacency, + get_cell_to_points_adjacency, +) +from physicsnemo.mesh.neighbors._point_neighbors import ( + get_point_to_cells_adjacency, + get_point_to_points_adjacency, +) diff --git a/physicsnemo/mesh/neighbors/_adjacency.py b/physicsnemo/mesh/neighbors/_adjacency.py new file mode 100644 index 0000000000..dcbe7c9a9d --- /dev/null +++ b/physicsnemo/mesh/neighbors/_adjacency.py @@ -0,0 +1,343 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Core data structure for storing ragged adjacency relationships in meshes. + +This module provides the Adjacency tensorclass for representing ragged arrays +using offset-indices encoding, commonly used in graph and mesh processing. +""" + +import torch +from tensordict import tensorclass + + +@tensorclass +class Adjacency: + """Ragged adjacency list stored with offset-indices encoding. + + This structure efficiently represents variable-length neighbor lists using two + arrays: offsets and indices. This is a standard format for sparse graph data + structures and enables GPU-compatible operations on ragged data. + + Attributes: + offsets: Indices into the indices array marking the start of each neighbor list. + Shape (n_sources + 1,), dtype int64. The i-th source's neighbors are + indices[offsets[i]:offsets[i+1]]. + indices: Flattened array of all neighbor indices. + Shape (total_neighbors,), dtype int64. + + Examples + -------- + >>> # Represent [[0,1,2], [3,4], [5], [6,7,8]] + >>> adj = Adjacency( + ... offsets=torch.tensor([0, 3, 5, 6, 9]), + ... indices=torch.tensor([0, 1, 2, 3, 4, 5, 6, 7, 8]), + ... ) + >>> adj.to_list() + [[0, 1, 2], [3, 4], [5], [6, 7, 8]] + + >>> # Empty neighbor list for source 2 + >>> adj = Adjacency( + ... offsets=torch.tensor([0, 2, 2, 4]), + ... indices=torch.tensor([10, 11, 12, 13]), + ... ) + >>> adj.to_list() + [[10, 11], [], [12, 13]] + """ + + offsets: torch.Tensor # shape: (n_sources + 1,), dtype: int64 + indices: torch.Tensor # shape: (total_neighbors,), dtype: int64 + + def __post_init__(self): + if not torch.compiler.is_compiling(): + ### Validate offsets is non-empty + # Offsets must have length (n_sources + 1), so minimum length is 1 (for n_sources=0) + if len(self.offsets) < 1: + raise ValueError( + f"Offsets array must have length >= 1 (n_sources + 1), but got {len(self.offsets)=}. " + f"Even for 0 sources, offsets should be [0]." + ) + + ### Validate offsets starts at 0 + if self.offsets[0].item() != 0: + raise ValueError( + f"First offset must be 0, but got {self.offsets[0].item()=}. " + f"The offset-indices encoding requires offsets[0] == 0." + ) + + ### Validate last offset equals length of indices + last_offset = self.offsets[-1].item() + indices_length = len(self.indices) + if last_offset != indices_length: + raise ValueError( + f"Last offset must equal length of indices, but got " + f"{last_offset=} != {indices_length=}. " + f"The offset-indices encoding requires offsets[-1] == len(indices)." + ) + + def to_list(self) -> list[list[int]]: + """Convert adjacency to a ragged list-of-lists representation. + + This method is primarily for testing and comparison with other libraries. + The order of neighbors within each sublist is preserved (not sorted). + + This is, in general, much less efficient than directly using the sparse encoding + itself -- all internal library operations use Adjacency objects directly. + + Returns + ------- + list[list[int]] + Ragged list where result[i] contains all neighbors of source i. + Empty sublists represent sources with no neighbors. + + Examples + -------- + >>> adj = Adjacency( + ... offsets=torch.tensor([0, 3, 3, 5]), + ... indices=torch.tensor([1, 2, 0, 4, 3]), + ... ) + >>> adj.to_list() + [[1, 2, 0], [], [4, 3]] + """ + ### Convert to CPU numpy for Python list operations + offsets_np = self.offsets.cpu().numpy() + indices_np = self.indices.cpu().numpy() + + ### Build ragged list structure + n_sources = len(offsets_np) - 1 + result = [] + for i in range(n_sources): + start = offsets_np[i] + end = offsets_np[i + 1] + neighbors = indices_np[start:end].tolist() + result.append(neighbors) + + return result + + @property + def n_sources(self) -> int: + """Number of source elements (points or cells) in the adjacency.""" + return len(self.offsets) - 1 + + @property + def n_total_neighbors(self) -> int: + """Total number of neighbor relationships across all sources.""" + return len(self.indices) + + @property + def counts(self) -> torch.Tensor: + """Number of neighbors for each source element. + + Returns + ------- + torch.Tensor + Shape (n_sources,), dtype int64. counts[i] is the number of + neighbors for source i. + + Example + ------- + >>> adj = Adjacency( + ... offsets=torch.tensor([0, 3, 3, 5]), + ... indices=torch.tensor([1, 2, 0, 4, 3]), + ... ) + >>> adj.counts.tolist() + [3, 0, 2] + """ + return self.offsets[1:] - self.offsets[:-1] + + def expand_to_pairs(self) -> tuple[torch.Tensor, torch.Tensor]: + """Expand offset-indices encoding to (source_idx, target_idx) pairs. + + This is the inverse of build_adjacency_from_pairs. It produces a pair + of tensors where (source_indices[i], target_indices[i]) represents the + i-th edge in the adjacency. + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + Tuple of (source_indices, target_indices), both shape (n_total_neighbors,). + source_indices[i] is the source entity for the i-th pair. + target_indices[i] is the target entity for the i-th pair. + + Examples + -------- + >>> adj = Adjacency( + ... offsets=torch.tensor([0, 2, 4, 5]), + ... indices=torch.tensor([10, 11, 20, 21, 30]), + ... ) + >>> sources, targets = adj.expand_to_pairs() + >>> sources.tolist() + [0, 0, 1, 1, 2] + >>> targets.tolist() + [10, 11, 20, 21, 30] + """ + device = self.offsets.device + + ### Handle empty adjacency + if self.n_total_neighbors == 0: + return ( + torch.tensor([], dtype=torch.int64, device=device), + self.indices, + ) + + ### For each position in indices, find which source it belongs to + # offsets[i] <= position < offsets[i+1] means position belongs to source i + # searchsorted(offsets, position, right=True) - 1 gives source index + positions = torch.arange( + self.n_total_neighbors, dtype=torch.int64, device=device + ) + source_indices = torch.searchsorted(self.offsets, positions, right=True) - 1 + + return source_indices, self.indices + + def truncate_per_source(self, max_count: int | None = None) -> "Adjacency": + """Limit each source to at most max_count neighbors. + + This is useful for capping the number of candidates in spatial queries + (e.g., BVH candidate cells) to prevent memory explosion. + + Parameters + ---------- + max_count : int | None, optional + Maximum neighbors per source. If None (default), + returns self unchanged (no limit applied). + + Returns + ------- + Adjacency + New Adjacency with at most max_count neighbors per source. + If max_count is None, returns self. + + Examples + -------- + >>> adj = Adjacency( + ... offsets=torch.tensor([0, 5, 8, 10]), + ... indices=torch.tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), + ... ) + >>> adj.to_list() + [[0, 1, 2, 3, 4], [5, 6, 7], [8, 9]] + >>> adj.truncate_per_source(2).to_list() + [[0, 1], [5, 6], [8, 9]] + """ + if max_count is None: + return self + + device = self.offsets.device + + ### Compute counts per source + counts = self.offsets[1:] - self.offsets[:-1] + + ### Clamp counts to max_count + clamped_counts = torch.clamp(counts, max=max_count) + + ### Build new offsets from clamped counts + new_offsets = torch.zeros_like(self.offsets) + new_offsets[1:] = torch.cumsum(clamped_counts, dim=0) + + ### Build mask for which indices to keep + if self.n_total_neighbors == 0: + return Adjacency(offsets=new_offsets, indices=self.indices) + + ### Use expand_to_pairs to get source ID for each position + source_ids, _ = self.expand_to_pairs() + + # Compute position within source: position - offsets[source_id] + positions = torch.arange(self.n_total_neighbors, device=device) + within_source_pos = positions - self.offsets[source_ids] + + # Keep only positions where within_source_pos < max_count + keep_mask = within_source_pos < max_count + + return Adjacency( + offsets=new_offsets, + indices=self.indices[keep_mask], + ) + + +def build_adjacency_from_pairs( + source_indices: torch.Tensor, # shape: (n_pairs,) + target_indices: torch.Tensor, # shape: (n_pairs,) + n_sources: int, +) -> Adjacency: + """Build offset-index adjacency from (source, target) pairs. + + This utility consolidates the common pattern of constructing an Adjacency object + from a list of directed edges (source → target pairs). + + Algorithm: + 1. Sort pairs by source index (then by target for consistency) + 2. Use bincount to count neighbors per source + 3. Use cumsum to compute offsets + 4. Return Adjacency with sorted neighbor lists + + Parameters + ---------- + source_indices : torch.Tensor + Source entity indices, shape (n_pairs,) + target_indices : torch.Tensor + Target entity (neighbor) indices, shape (n_pairs,) + n_sources : int + Total number of source entities (may exceed max(source_indices)) + + Returns + ------- + Adjacency + Adjacency object where adjacency.to_list()[i] contains all targets + connected from source i. Sources with no outgoing edges have empty lists. + + Examples + -------- + >>> # Create adjacency: 0→[1,2], 1→[3], 2→[], 3→[0] + >>> sources = torch.tensor([0, 0, 1, 3]) + >>> targets = torch.tensor([1, 2, 3, 0]) + >>> adj = build_adjacency_from_pairs(sources, targets, n_sources=4) + >>> adj.to_list() + [[1, 2], [3], [], [0]] + """ + device = source_indices.device + + ### Handle empty pairs + if len(source_indices) == 0: + return Adjacency( + offsets=torch.zeros(n_sources + 1, dtype=torch.int64, device=device), + indices=torch.zeros(0, dtype=torch.int64, device=device), + ) + + ### Lexicographic sort by (source, target) using two stable argsorts. + # This avoids the int64 overflow that occurs with the composite-key + # approach (source * max_target + target) when indices exceed ~3 × 10^9. + sort_by_target = torch.argsort(target_indices, stable=True) + sort_indices = sort_by_target[ + torch.argsort(source_indices[sort_by_target], stable=True) + ] + + sorted_sources = source_indices[sort_indices] + sorted_targets = target_indices[sort_indices] + + ### Compute offsets for each source + # offsets[i] marks the start of source i's neighbor list + offsets = torch.zeros(n_sources + 1, dtype=torch.int64, device=device) + + # Count occurrences of each source index + source_counts = torch.bincount(sorted_sources, minlength=n_sources) + + # Cumulative sum to get offsets + offsets[1:] = torch.cumsum(source_counts, dim=0) + + return Adjacency( + offsets=offsets, + indices=sorted_targets, + ) diff --git a/physicsnemo/mesh/neighbors/_cell_neighbors.py b/physicsnemo/mesh/neighbors/_cell_neighbors.py new file mode 100644 index 0000000000..42a240edc9 --- /dev/null +++ b/physicsnemo/mesh/neighbors/_cell_neighbors.py @@ -0,0 +1,344 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Compute cell-based adjacency relationships in simplicial meshes. + +This module provides functions to compute: +- Cell-to-cells adjacency based on shared facets +- Cell-to-points adjacency (vertices of each cell) +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.neighbors._adjacency import Adjacency + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def get_cell_to_cells_adjacency( + mesh: "Mesh", + adjacency_codimension: int = 1, +) -> Adjacency: + """Compute cell-to-cells adjacency based on shared facets. + + Two cells are considered adjacent if they share a k-codimension facet. + For example: + - codimension=1: Share an (n-1)-facet (e.g., triangles sharing an edge in 2D, + tetrahedra sharing a triangular face in 3D) + - codimension=2: Share an (n-2)-facet (e.g., tetrahedra sharing an edge in 3D) + - codimension=k: Share any (n-k)-facet + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh. + adjacency_codimension : int, optional + Codimension of shared facets defining adjacency. + - 1 (default): Cells must share a codimension-1 facet (most restrictive) + - 2: Cells must share a codimension-2 facet (more permissive) + - k: Cells must share a codimension-k facet + + Returns + ------- + Adjacency + Adjacency where adjacency.to_list()[i] contains all cell indices that + share a k-codimension facet with cell i. Each neighbor appears exactly + once per source cell. + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh import Mesh + >>> # Two triangles sharing an edge + >>> points = torch.tensor([[0., 0.], [1., 0.], [0., 1.], [1., 1.]]) + >>> cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + >>> mesh = Mesh(points=points, cells=cells) + >>> adj = get_cell_to_cells_adjacency(mesh, adjacency_codimension=1) + >>> adj.to_list() + [[1], [0]] + """ + from physicsnemo.mesh.boundaries import ( + categorize_facets_by_count, + extract_candidate_facets, + ) + + ### Handle empty mesh + if mesh.n_cells == 0: + return Adjacency( + offsets=torch.zeros(1, dtype=torch.int64, device=mesh.cells.device), + indices=torch.zeros(0, dtype=torch.int64, device=mesh.cells.device), + ) + + ### Extract all candidate facets from cells + # candidate_facets: (n_cells * n_facets_per_cell, n_vertices_per_facet) + # parent_cell_indices: (n_cells * n_facets_per_cell,) + candidate_facets, parent_cell_indices = extract_candidate_facets( + mesh.cells, + manifold_codimension=adjacency_codimension, + ) + + ### Find shared facets (those appearing in 2+ cells) + _, inverse_indices, _ = categorize_facets_by_count( + candidate_facets, target_counts="shared" + ) + + ### Filter to only keep candidate facets that are shared + # inverse_indices maps candidates to unique shared facets (or -1 if not shared) + candidate_is_shared = inverse_indices >= 0 + + # Extract only the parent cells and inverse indices for shared facets + shared_parent_cells = parent_cell_indices[candidate_is_shared] + shared_inverse = inverse_indices[candidate_is_shared] + + ### Handle case where no cells share facets + if len(shared_parent_cells) == 0: + return Adjacency( + offsets=torch.zeros( + mesh.n_cells + 1, dtype=torch.int64, device=mesh.cells.device + ), + indices=torch.zeros(0, dtype=torch.int64, device=mesh.cells.device), + ) + + ### Build cell-to-cell pairs using vectorized operations + # Sort by unique facet index to group cells sharing the same facet + sort_by_facet = torch.argsort(shared_inverse) + sorted_cells = shared_parent_cells[sort_by_facet] + sorted_facet_ids = shared_inverse[sort_by_facet] + + # Find boundaries of each unique shared facet + # diff != 0 marks transitions between different facets + facet_changes = torch.cat( + [ + sorted_facet_ids.new_zeros(1), + torch.where(sorted_facet_ids[1:] != sorted_facet_ids[:-1])[0] + 1, + sorted_facet_ids.new_tensor([len(sorted_facet_ids)]), + ] + ) + + # Generate all pairs for cells sharing each facet + # Fully vectorized implementation - no Python loops over facets + + ### Compute the size (number of cells) for each unique shared facet + # Shape: (n_unique_shared_facets,) + facet_sizes = facet_changes[1:] - facet_changes[:-1] + + ### Filter to only facets shared by 2+ cells (can form pairs) + # Single-cell facets cannot form pairs + multi_cell_facet_mask = facet_sizes > 1 + + if not multi_cell_facet_mask.any(): + # No facets shared by multiple cells + return Adjacency( + offsets=torch.zeros( + mesh.n_cells + 1, dtype=torch.int64, device=mesh.cells.device + ), + indices=torch.zeros(0, dtype=torch.int64, device=mesh.cells.device), + ) + + ### Build arrays for vectorized pair generation + # For each facet, we'll generate all directed pairs (i, j) where i != j + # Fully vectorized - no Python loops whatsoever + + # Get sizes only for facets with multiple cells + valid_facet_sizes = facet_sizes[multi_cell_facet_mask] + n_valid_facets = len(valid_facet_sizes) + + # Filter facet_changes to only include valid facets + valid_facet_starts = facet_changes[:-1][multi_cell_facet_mask] + + ### Extract all cells belonging to valid facets (those with 2+ cells) + # Fully vectorized - no Python loops or .tolist() calls + total_cells_in_valid_facets = valid_facet_sizes.sum() + + # Generate indices into sorted_cells for all cells in valid facets + # For each facet: [start, start+1, ..., end-1] + # Vectorized: repeat each start by facet_size, then add [0,1,2,...,size-1] + + # Generate local indices [0, 1, 2, ..., size-1] for each facet + # For facet_sizes [2, 3, 2], we want [0, 1, 0, 1, 2, 0, 1] + # Fully vectorized approach: use cumulative indexing with group offsets + + # Create cumulative index for all positions + cumulative_idx = torch.arange( + total_cells_in_valid_facets, dtype=torch.int64, device=mesh.cells.device + ) + + # For each position, compute the start index of its facet group + # First, compute cumulative starts: [0, size[0], size[0]+size[1], ...] + facet_cumulative_starts = torch.cat( + [ + torch.tensor([0], dtype=torch.int64, device=mesh.cells.device), + torch.cumsum(valid_facet_sizes[:-1], dim=0), + ] + ) + + # Expand starts to match each cell position + start_indices_per_cell = torch.repeat_interleave( + facet_cumulative_starts, valid_facet_sizes + ) + + # Local index = cumulative_idx - start_of_its_group + local_indices = cumulative_idx - start_indices_per_cell + + # Generate indices into sorted_cells + # Start indices in sorted_cells repeated by facet size + local offset + valid_facet_starts_expanded = torch.repeat_interleave( + valid_facet_starts, valid_facet_sizes + ) + cell_indices_into_sorted = valid_facet_starts_expanded + local_indices + + # Extract cell IDs + cells_in_valid_facets = sorted_cells[cell_indices_into_sorted] + + # Assign facet ID to each cell + # Shape: (total_cells_in_valid_facets,) + facet_ids_per_cell = torch.repeat_interleave( + torch.arange(n_valid_facets, dtype=torch.int64, device=mesh.cells.device), + valid_facet_sizes, + ) + + ### Generate all directed pairs (i, j) where i != j + # Each cell needs (facet_size - 1) pairs + facet_sizes_per_cell = valid_facet_sizes[facet_ids_per_cell] + n_pairs_per_cell = facet_sizes_per_cell - 1 + + # Repeat source cells by (facet_size - 1) + source_cells = torch.repeat_interleave(cells_in_valid_facets, n_pairs_per_cell) + source_facet_ids = torch.repeat_interleave(facet_ids_per_cell, n_pairs_per_cell) + source_local_indices = torch.repeat_interleave(local_indices, n_pairs_per_cell) + + # Generate target local indices: for each source at local_idx i in facet of size n, + # generate [0, 1, ..., i-1, i+1, ..., n-1] (all indices except i) + # Fully vectorized approach using boundary-based cumulative counter + + # For each source cell, generate a counter: 0, 1, 2, ..., (facet_size-2) + # For n_pairs_per_cell [1, 2, 1], we want [0, 0, 1, 0] + # Same vectorization approach as local_indices + + # Create cumulative index for all pair positions + # Total pairs = length of the repeated source_cells tensor + total_pairs = len(source_cells) + pair_cumulative_idx = torch.arange( + total_pairs, dtype=torch.int64, device=mesh.cells.device + ) + + # Compute cumulative starts for each cell's target block + pair_cumulative_starts = torch.cat( + [ + torch.tensor([0], dtype=torch.int64, device=mesh.cells.device), + torch.cumsum(n_pairs_per_cell[:-1], dim=0), + ] + ) + + # Expand starts to match each pair position + pair_start_indices = torch.repeat_interleave( + pair_cumulative_starts, n_pairs_per_cell + ) + + # Counter = cumulative_idx - start_of_its_block + within_facet_counter = pair_cumulative_idx - pair_start_indices + + # Adjust counters to skip the source cell's local index + target_local_indices = ( + within_facet_counter + (within_facet_counter >= source_local_indices).long() + ) + + # Convert target local indices to global cell IDs + # For each target, we need: cells_in_valid_facets[facet_start + local_idx] + facet_cumsum = torch.cat( + [ + torch.tensor([0], dtype=torch.int64, device=mesh.cells.device), + torch.cumsum(valid_facet_sizes, dim=0)[:-1], + ] + ) + target_global_positions = facet_cumsum[source_facet_ids] + target_local_indices + target_cells = cells_in_valid_facets[target_global_positions] + + # Stack into pairs (source, target) + # Shape: (total_pairs, 2) + cell_pairs_tensor = torch.stack([source_cells, target_cells], dim=1) + + ### Remove duplicate pairs (can happen if cells share multiple facets) + # This ensures each neighbor appears exactly once per source + from physicsnemo.mesh.neighbors._adjacency import build_adjacency_from_pairs + + unique_pairs = torch.unique(cell_pairs_tensor, dim=0) + + ### Build adjacency using shared utility + return build_adjacency_from_pairs( + source_indices=unique_pairs[:, 0], + target_indices=unique_pairs[:, 1], + n_sources=mesh.n_cells, + ) + + +def get_cell_to_points_adjacency(mesh: "Mesh") -> Adjacency: + """Get the vertices (points) that comprise each cell. + + This is a simple wrapper around the cells array that returns it in the + standard Adjacency format for consistency with other neighbor queries. + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh. + + Returns + ------- + Adjacency + Adjacency where adjacency.to_list()[i] contains all point indices that + are vertices of cell i. For simplicial meshes, all cells have the same + number of vertices (n_manifold_dims + 1). + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh import Mesh + >>> # Triangle mesh with 2 cells + >>> points = torch.tensor([[0., 0.], [1., 0.], [0., 1.], [1., 1.]]) + >>> cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + >>> mesh = Mesh(points=points, cells=cells) + >>> adj = get_cell_to_points_adjacency(mesh) + >>> adj.to_list() + [[0, 1, 2], [1, 3, 2]] + """ + ### Handle empty mesh + if mesh.n_cells == 0: + return Adjacency( + offsets=torch.zeros(1, dtype=torch.int64, device=mesh.cells.device), + indices=torch.zeros(0, dtype=torch.int64, device=mesh.cells.device), + ) + + n_cells, n_vertices_per_cell = mesh.cells.shape + + ### Create uniform offsets (each cell has exactly n_vertices_per_cell vertices) + # offsets[i] = i * n_vertices_per_cell + offsets = ( + torch.arange( + n_cells + 1, + dtype=torch.int64, + device=mesh.cells.device, + ) + * n_vertices_per_cell + ) + + ### Flatten cells array to get all point indices + indices = mesh.cells.reshape(-1) + + return Adjacency(offsets=offsets, indices=indices) diff --git a/physicsnemo/mesh/neighbors/_point_neighbors.py b/physicsnemo/mesh/neighbors/_point_neighbors.py new file mode 100644 index 0000000000..c9a0b206c5 --- /dev/null +++ b/physicsnemo/mesh/neighbors/_point_neighbors.py @@ -0,0 +1,157 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Compute point-based adjacency relationships in simplicial meshes. + +This module provides functions to compute: +- Point-to-cells adjacency (star of each vertex) +- Point-to-points adjacency (graph edges) +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.neighbors._adjacency import Adjacency + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def get_point_to_cells_adjacency(mesh: "Mesh") -> Adjacency: + """Compute the star of each vertex (all cells containing each point). + + For each point in the mesh, finds all cells that contain that point. This + is the graph-theoretic "star" operation on vertices. + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh. + + Returns + ------- + Adjacency + Adjacency where adjacency.to_list()[i] contains all cell indices that + contain point i. Isolated points (not in any cells) have empty lists. + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh import Mesh + >>> # Triangle mesh with 4 points, 2 triangles + >>> points = torch.tensor([[0., 0.], [1., 0.], [0., 1.], [1., 1.]]) + >>> cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + >>> mesh = Mesh(points=points, cells=cells) + >>> adj = get_point_to_cells_adjacency(mesh) + >>> adj.to_list() + [[0], [0, 1], [0, 1], [1]] + """ + ### Handle empty mesh + if mesh.n_cells == 0 or mesh.n_points == 0: + return Adjacency( + offsets=torch.zeros( + mesh.n_points + 1, dtype=torch.int64, device=mesh.points.device + ), + indices=torch.zeros(0, dtype=torch.int64, device=mesh.points.device), + ) + + from physicsnemo.mesh.neighbors._adjacency import build_adjacency_from_pairs + + ### Create (point_id, cell_id) pairs for all vertices in all cells + n_cells, n_vertices_per_cell = mesh.cells.shape + + # Flatten cells to get all point indices + # Shape: (n_cells * n_vertices_per_cell,) + point_ids = mesh.cells.reshape(-1) + + # Create corresponding cell indices for each point + # Shape: (n_cells * n_vertices_per_cell,) + cell_ids = torch.arange( + n_cells, dtype=torch.int64, device=mesh.cells.device + ).repeat_interleave(n_vertices_per_cell) + + ### Build adjacency using shared utility + return build_adjacency_from_pairs( + source_indices=point_ids, + target_indices=cell_ids, + n_sources=mesh.n_points, + ) + + +def get_point_to_points_adjacency(mesh: "Mesh") -> Adjacency: + """Compute point-to-point adjacency (graph edges of the mesh). + + For each point, finds all other points that share a cell with it. In simplicial + meshes, this is equivalent to finding all points connected by an edge, since + all vertices in a simplex are pairwise connected. + + Parameters + ---------- + mesh : Mesh + Input simplicial mesh. + + Returns + ------- + Adjacency + Adjacency where adjacency.to_list()[i] contains all point indices that + share a cell (edge) with point i. Isolated points have empty lists. + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh import Mesh + >>> # Three points forming a single triangle + >>> points = torch.tensor([[0., 0.], [1., 0.], [0.5, 1.]]) + >>> cells = torch.tensor([[0, 1, 2]]) + >>> mesh = Mesh(points=points, cells=cells) + >>> adj = get_point_to_points_adjacency(mesh) + >>> adj.to_list() + [[1, 2], [0, 2], [0, 1]] + """ + from physicsnemo.mesh.utilities._topology import extract_unique_edges + + ### Handle empty mesh + if mesh.n_cells == 0 or mesh.n_points == 0: + return Adjacency( + offsets=torch.zeros( + mesh.n_points + 1, dtype=torch.int64, device=mesh.points.device + ), + indices=torch.zeros(0, dtype=torch.int64, device=mesh.points.device), + ) + + ### Extract all unique edges (handles 1D and n-D meshes uniformly) + unique_edges, _ = extract_unique_edges(mesh) + + from physicsnemo.mesh.neighbors._adjacency import build_adjacency_from_pairs + + ### Create bidirectional edges + # For each edge [a, b], create both [a, b] and [b, a] + # Shape: (2 * n_unique_edges, 2) + bidirectional_edges = torch.cat( + [ + unique_edges, + unique_edges.flip(dims=[1]), # Reverse the edge direction + ], + dim=0, + ) + + ### Build adjacency from bidirectional edge pairs + return build_adjacency_from_pairs( + source_indices=bidirectional_edges[:, 0], + target_indices=bidirectional_edges[:, 1], + n_sources=mesh.n_points, + ) diff --git a/physicsnemo/mesh/primitives/planar/equilateral_triangle.py b/physicsnemo/mesh/primitives/planar/equilateral_triangle.py index 802ff6329f..3e124e23b8 100644 --- a/physicsnemo/mesh/primitives/planar/equilateral_triangle.py +++ b/physicsnemo/mesh/primitives/planar/equilateral_triangle.py @@ -26,7 +26,7 @@ def load( side_length: float = 1.0, - n_subdivisions: int = 0, + subdivisions: int = 0, device: torch.device | str = "cpu", ) -> Mesh: """Create an equilateral triangle in 2D space. @@ -35,8 +35,9 @@ def load( ---------- side_length : float Length of each side. - n_subdivisions : int - Number of subdivision levels. + subdivisions : int + Number of subdivision levels. Each level quadruples the number of + triangles: 0 → 1, 1 → 4, 2 → 16, etc. device : str Compute device ('cpu' or 'cuda'). @@ -45,8 +46,8 @@ def load( Mesh Mesh with n_manifold_dims=2, n_spatial_dims=2. """ - if n_subdivisions < 0: - raise ValueError(f"n_subdivisions must be non-negative, got {n_subdivisions=}") + if subdivisions < 0: + raise ValueError(f"subdivisions must be non-negative, got {subdivisions=}") # Create vertices of equilateral triangle height = side_length * (3**0.5) / 2 @@ -60,7 +61,7 @@ def load( mesh = Mesh(points=points, cells=cells) # Apply subdivisions if requested - if n_subdivisions > 0: - mesh = mesh.subdivide(levels=n_subdivisions, filter="linear") + if subdivisions > 0: + mesh = mesh.subdivide(levels=subdivisions, filter="linear") return mesh diff --git a/physicsnemo/mesh/primitives/planar/l_shape.py b/physicsnemo/mesh/primitives/planar/l_shape.py index 96a0d341dd..ed09a185b9 100644 --- a/physicsnemo/mesh/primitives/planar/l_shape.py +++ b/physicsnemo/mesh/primitives/planar/l_shape.py @@ -25,7 +25,7 @@ def load( - size: float = 1.0, n_subdivisions: int = 5, device: torch.device | str = "cpu" + size: float = 1.0, subdivisions: int = 5, device: torch.device | str = "cpu" ) -> Mesh: """Create an L-shaped non-convex domain in 2D space. @@ -33,16 +33,16 @@ def load( - Bottom rectangle: [0, size] x [0, size/2] - Top rectangle: [0, size/2] x [size/2, size] - Both parts use uniform grid spacing of size/(2*n_subdivisions), and the + Both parts use uniform grid spacing of size/(2*subdivisions), and the vertices at y=size/2 for x in [0, size/2] are shared between the parts. Parameters ---------- size : float Size of the L-shape (both overall width and height). - n_subdivisions : int + subdivisions : int Number of subdivisions per half-edge (so the full width has - 2*n_subdivisions cells). + 2*subdivisions cells). device : str Compute device ('cpu' or 'cuda'). @@ -51,14 +51,14 @@ def load( Mesh Mesh with n_manifold_dims=2, n_spatial_dims=2. """ - if n_subdivisions < 1: - raise ValueError(f"n_subdivisions must be at least 1, got {n_subdivisions=}") + if subdivisions < 1: + raise ValueError(f"subdivisions must be at least 1, got {subdivisions=}") ### Grid parameters - step = size / (2 * n_subdivisions) - n_cols_bottom = 2 * n_subdivisions + 1 # x points spanning [0, size] - n_cols_top = n_subdivisions + 1 # x points spanning [0, size/2] - n_rows = n_subdivisions + 1 # y points per rectangle half + step = size / (2 * subdivisions) + n_cols_bottom = 2 * subdivisions + 1 # x points spanning [0, size] + n_cols_top = subdivisions + 1 # x points spanning [0, size/2] + n_rows = subdivisions + 1 # y points per rectangle half points = [] cells = [] @@ -93,12 +93,12 @@ def load( n_top_rows = n_rows - 1 # Rows per column in top-only vertex storage for i in range(n_cols_top - 1): - for j in range(n_subdivisions): + for j in range(subdivisions): if j == 0: # Bottom row: reference shared vertices from bottom part - # Shared vertices are at y=size/2 (j=n_subdivisions in bottom grid) - bl = i * n_rows + n_subdivisions - br = (i + 1) * n_rows + n_subdivisions + # Shared vertices are at y=size/2 (j=subdivisions in bottom grid) + bl = i * n_rows + subdivisions + br = (i + 1) * n_rows + subdivisions # Top vertices are first row of top-only part tl = offset + i * n_top_rows tr = offset + (i + 1) * n_top_rows diff --git a/physicsnemo/mesh/primitives/planar/unit_square.py b/physicsnemo/mesh/primitives/planar/unit_square.py index 536cbda44c..94bb74683f 100644 --- a/physicsnemo/mesh/primitives/planar/unit_square.py +++ b/physicsnemo/mesh/primitives/planar/unit_square.py @@ -24,13 +24,14 @@ from physicsnemo.mesh.mesh import Mesh -def load(n_subdivisions: int = 1, device: torch.device | str = "cpu") -> Mesh: +def load(subdivisions: int = 1, device: torch.device | str = "cpu") -> Mesh: """Create a triangulated unit square in 2D space. Parameters ---------- - n_subdivisions : int - Number of subdivision levels (0 = 2 triangles). + subdivisions : int + Number of subdivision levels (0 = 2 triangles). Each level quadruples + the number of triangles: 0 → 2, 1 → 8, 2 → 32, etc. device : str Compute device ('cpu' or 'cuda'). @@ -39,10 +40,10 @@ def load(n_subdivisions: int = 1, device: torch.device | str = "cpu") -> Mesh: Mesh Mesh with n_manifold_dims=2, n_spatial_dims=2. """ - if n_subdivisions < 0: - raise ValueError(f"n_subdivisions must be non-negative, got {n_subdivisions=}") + if subdivisions < 0: + raise ValueError(f"subdivisions must be non-negative, got {subdivisions=}") - n = 2**n_subdivisions + 1 + n = 2**subdivisions + 1 # Create grid of points x = torch.linspace(0.0, 1.0, n, device=device) diff --git a/physicsnemo/mesh/primitives/procedural/__init__.py b/physicsnemo/mesh/primitives/procedural/__init__.py index 70195a6266..ae239ee9a0 100644 --- a/physicsnemo/mesh/primitives/procedural/__init__.py +++ b/physicsnemo/mesh/primitives/procedural/__init__.py @@ -21,6 +21,8 @@ """ from physicsnemo.mesh.primitives.procedural import ( + lumpy_ball, + lumpy_sphere, noisy_mesh, perturbed_grid, ) diff --git a/physicsnemo/mesh/primitives/procedural/lumpy_ball.py b/physicsnemo/mesh/primitives/procedural/lumpy_ball.py new file mode 100644 index 0000000000..c27cf6da32 --- /dev/null +++ b/physicsnemo/mesh/primitives/procedural/lumpy_ball.py @@ -0,0 +1,215 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Lumpy ball volume mesh in 3D space. + +A solid tetrahedral mesh built from concentric icosahedral shells with +optional radial noise. This is the volumetric analog to lumpy_sphere. + +Dimensional: 3D manifold in 3D space (solid, no boundary on surface cells). +""" + +import torch + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.primitives.surfaces import icosahedron_surface + + +def load( + radius: float = 1.0, + n_shells: int = 3, + subdivisions: int = 2, + noise_amplitude: float = 0.5, + seed: int = 0, + device: torch.device | str = "cpu", +) -> Mesh: + """Create a lumpy ball volume mesh. + + Builds a solid ball from concentric icosahedral shells connected by + tetrahedra. The mesh has naturally graded cell sizes (smaller near + center, larger at surface) and mixed vertex valences inherited from + the icosahedral structure. + + Parameters + ---------- + radius : float + Outer radius of the ball. + n_shells : int + Number of concentric shells (more = finer radial resolution). + Must be at least 1. + subdivisions : int + Subdivision level per shell (more = finer angular resolution). + Each level quadruples the number of faces. + noise_amplitude : float + Radial noise amplitude. 0 = perfect sphere, >0 = lumpy. + Uses log-normal scaling like lumpy_sphere. + seed : int + Random seed for noise reproducibility. + device : torch.device or str + Compute device ('cpu' or 'cuda'). + + Returns + ------- + Mesh + Mesh with n_manifold_dims=3, n_spatial_dims=3. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.procedural import lumpy_ball + >>> mesh = lumpy_ball.load(radius=1.0, n_shells=2, subdivisions=1) + >>> mesh.n_manifold_dims, mesh.n_spatial_dims + (3, 3) + >>> mesh.n_cells # 80 faces * (3*2 - 2) = 320 + 320 + """ + if radius <= 0: + raise ValueError(f"radius must be positive, got {radius=}") + if n_shells < 1: + raise ValueError(f"n_shells must be at least 1, got {n_shells=}") + if subdivisions < 0: + raise ValueError(f"subdivisions must be non-negative, got {subdivisions=}") + if noise_amplitude < 0: + raise ValueError( + f"noise_amplitude must be non-negative, got {noise_amplitude=}" + ) + + ### Step 1: Generate base icosahedron at unit radius + template = icosahedron_surface.load(radius=1.0, device=device) + + ### Step 2: Apply noise to base icosahedron (if any) + # Noise is applied to the base icosahedron (12 vertices) BEFORE subdivision. + # This creates smooth, coherent lumps after subdivision, matching lumpy_sphere. + # All shells are scaled versions of this noisy shape, ensuring shells remain + # strictly nested and tetrahedra remain valid regardless of noise amplitude. + if noise_amplitude > 0: + generator = torch.Generator(device=device).manual_seed(seed) + noise = noise_amplitude * torch.randn( + template.n_points, 1, generator=generator, device=device + ) + # Log-normal scaling applied to base icosahedron (same as lumpy_sphere) + template = Mesh( + points=template.points * noise.exp(), + cells=template.cells, + ) + + ### Step 3: Subdivide with loop scheme (if any) + # Loop subdivision is an approximating scheme that smooths the noisy base + # icosahedron into broad, coherent lumps. + if subdivisions > 0: + template = template.subdivide(subdivisions, "loop") + + n_verts_per_shell = template.n_points + n_faces = template.n_cells + + ### Step 4: Generate shell radii (linear spacing from center to outer) + # Vectorized: torch.arange instead of list comprehension + shell_radii = ( + radius + * torch.arange(1, n_shells + 1, device=device, dtype=torch.float32) + / n_shells + ) + + ### Step 5: Build all vertices by scaling template + # Vectorized: broadcasting instead of list comprehension + # shell_radii: (n_shells,) -> (n_shells, 1, 1) + # template.points: (n_verts, 3) -> (1, n_verts, 3) + # Result: (n_shells, n_verts, 3) -> (n_shells * n_verts, 3) + center = torch.zeros(1, 3, dtype=torch.float32, device=device) + shell_points = (template.points.unsqueeze(0) * shell_radii.view(-1, 1, 1)).reshape( + -1, 3 + ) + all_points = torch.cat([center, shell_points], dim=0) + + ### Step 6: Build core tetrahedra (center to innermost shell) + # Vectorized: direct tensor operations instead of for loop + # template.cells: (n_faces, 3), add offset 1 to shift to shell 1 indices + shell1_faces = template.cells + 1 # (n_faces, 3) + zeros_col = torch.zeros(n_faces, 1, dtype=torch.int64, device=device) + core_cells = torch.cat([zeros_col, shell1_faces], dim=1) # (n_faces, 4) + + ### Step 7: Build inter-shell tetrahedra (prism decomposition) + # Each triangular prism between shells decomposes into 3 tetrahedra. + # CRITICAL: We must use a CONSISTENT diagonal for each lateral rectangle, + # regardless of which adjacent face we're processing. This is achieved by + # sorting face vertices by their TEMPLATE index (not shell-offset index), + # so that a < b < c and the decomposition is canonical. + # + # With sorted vertices (a < b < c), the Freudenthal decomposition is: + # tet1: (a_in, b_in, c_in, a_out) + # tet2: (b_in, c_in, a_out, b_out) + # tet3: (c_in, a_out, b_out, c_out) + # + # This guarantees that for each lateral rectangle, adjacent prisms use + # the same diagonal, producing matching triangular faces. + if n_shells > 1: + # Sort face vertices by template index to ensure consistent decomposition + sorted_faces = torch.sort(template.cells, dim=1)[0] # (n_faces, 3) + + # Compute all shell pair offsets as tensors + shell_indices = torch.arange(n_shells - 1, device=device) + inner_offsets = 1 + shell_indices * n_verts_per_shell # (n_shells-1,) + outer_offsets = inner_offsets + n_verts_per_shell # (n_shells-1,) + + # Broadcast sorted face indices across all shell pairs + # sorted_faces: (n_faces, 3) -> (1, n_faces, 3) + # offsets: (n_shells-1,) -> (n_shells-1, 1, 1) + # Result: (n_shells-1, n_faces, 3) + faces_expanded = sorted_faces.unsqueeze(0) + inner_faces = faces_expanded + inner_offsets.view(-1, 1, 1) + outer_faces = faces_expanded + outer_offsets.view(-1, 1, 1) + + # Extract individual vertex indices: each has shape (n_shells-1, n_faces) + # Now a < b < c by template index, ensuring consistent diagonal choice + a_in, b_in, c_in = inner_faces[..., 0], inner_faces[..., 1], inner_faces[..., 2] + a_out, b_out, c_out = ( + outer_faces[..., 0], + outer_faces[..., 1], + outer_faces[..., 2], + ) + + # Build 3 tetrahedra per prism: each stack produces (n_shells-1, n_faces, 4) + tet1 = torch.stack([a_in, b_in, c_in, a_out], dim=-1) + tet2 = torch.stack([b_in, c_in, a_out, b_out], dim=-1) + tet3 = torch.stack([c_in, a_out, b_out, c_out], dim=-1) + + # Interleave and flatten: (n_shells-1, n_faces, 3, 4) -> ((n_shells-1)*n_faces*3, 4) + inter_shell_cells = torch.stack([tet1, tet2, tet3], dim=2).reshape(-1, 4) + else: + inter_shell_cells = torch.empty((0, 4), dtype=torch.int64, device=device) + + ### Step 8: Assemble all cells + all_cells = torch.cat([core_cells, inter_shell_cells], dim=0) + + ### Step 9: Fix tetrahedron orientation + # The vertex sorting for consistent diagonals may produce some tets with + # negative orientation (inverted). Detect and fix by swapping two vertices. + # Signed volume = (1/6) * (b-a) · ((c-a) × (d-a)) + # Positive = consistent orientation, Negative = inverted + tet_verts = all_points[all_cells] # (n_cells, 4, 3) + v0, v1, v2, v3 = tet_verts[:, 0], tet_verts[:, 1], tet_verts[:, 2], tet_verts[:, 3] + signed_volumes = torch.einsum( + "ij,ij->i", v1 - v0, torch.cross(v2 - v0, v3 - v0, dim=1) + ) + + # Flip inverted tets by swapping vertices 2 and 3 (changes sign of volume) + inverted = signed_volumes < 0 + if inverted.any(): + all_cells[inverted, 2], all_cells[inverted, 3] = ( + all_cells[inverted, 3].clone(), + all_cells[inverted, 2].clone(), + ) + + return Mesh(points=all_points, cells=all_cells) diff --git a/physicsnemo/mesh/primitives/procedural/lumpy_sphere.py b/physicsnemo/mesh/primitives/procedural/lumpy_sphere.py new file mode 100644 index 0000000000..a37775f8ba --- /dev/null +++ b/physicsnemo/mesh/primitives/procedural/lumpy_sphere.py @@ -0,0 +1,62 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Lumpy sphere with radial noise in 3D space. + +Dimensional: 2D manifold in 3D space (closed, no boundary, irregular). +""" + +import torch + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.primitives.surfaces import icosahedron_surface + + +def load( + radius: float = 1.0, + subdivisions: int = 3, + noise_amplitude: float = 0.5, + seed: int = 0, + device: str = "cpu", +) -> Mesh: + """Create a lumpy sphere by adding radial noise to a sphere. + + Parameters + ---------- + radius : float, optional + Base radius of the sphere + subdivisions : int, optional + Number of subdivision levels + noise_amplitude : float, optional + Amplitude of radial noise + seed : int, optional + Random seed for reproducibility + device : str, optional + Compute device ('cpu' or 'cuda') + + Returns + ------- + Mesh + Mesh with n_manifold_dims=2, n_spatial_dims=3 + """ + mesh = icosahedron_surface.load(radius=radius, device=device) + generator = torch.Generator(device=device).manual_seed(seed) + noise = noise_amplitude * torch.randn( + mesh.n_points, 1, generator=generator, device=device + ) + mesh.points = mesh.points * noise.exp() + + return mesh.subdivide(subdivisions, "loop") diff --git a/physicsnemo/mesh/primitives/surfaces/__init__.py b/physicsnemo/mesh/primitives/surfaces/__init__.py index f3a436c51e..8484f935d8 100644 --- a/physicsnemo/mesh/primitives/surfaces/__init__.py +++ b/physicsnemo/mesh/primitives/surfaces/__init__.py @@ -31,6 +31,7 @@ mobius_strip, octahedron_surface, plane, + sphere_icosahedral, sphere_uv, tetrahedron_surface, torus, diff --git a/physicsnemo/mesh/primitives/surfaces/cone.py b/physicsnemo/mesh/primitives/surfaces/cone.py index e291419275..19231323f5 100644 --- a/physicsnemo/mesh/primitives/surfaces/cone.py +++ b/physicsnemo/mesh/primitives/surfaces/cone.py @@ -60,39 +60,47 @@ def load( theta = torch.linspace(0, 2 * torch.pi, n_circ + 1, device=device)[:-1] z_levels = torch.linspace(0, height, n_height, device=device) - # Side points (radius decreases with height) - points_side = [] - for i, z_val in enumerate(z_levels): - r = radius * (1 - i / (n_height - 1)) - for theta_val in theta: - x = r * torch.cos(theta_val) - y = r * torch.sin(theta_val) - points_side.append([x.item(), y.item(), z_val.item()]) - - # Create cells for side - cells_side = [] - for i in range(n_height - 1): - for j in range(n_circ): - idx = i * n_circ + j - next_j = (j + 1) % n_circ - - # Two triangles per quad - cells_side.append([idx, idx + next_j - j, idx + n_circ]) - cells_side.append( - [idx + next_j - j, idx + n_circ + next_j - j, idx + n_circ] - ) + # Vectorized side point generation (radius decreases with height) + i_vals = torch.arange(n_height, device=device, dtype=torch.float32) + r_vals = radius * (1 - i_vals / (n_height - 1)) + R, THETA = torch.meshgrid(r_vals, theta, indexing="ij") + Z, _ = torch.meshgrid(z_levels, theta, indexing="ij") + x = R * torch.cos(THETA) + y = R * torch.sin(THETA) + side_points = torch.stack([x, y, Z], dim=-1).reshape(-1, 3).to(dtype=torch.float32) + + # Vectorized side cell generation (periodic in theta, open in height) + i_idx = torch.arange(n_height - 1, device=device) + j_idx = torch.arange(n_circ, device=device) + ii, jj = torch.meshgrid(i_idx, j_idx, indexing="ij") + ii_flat = ii.reshape(-1) + jj_flat = jj.reshape(-1) + + p00 = ii_flat * n_circ + jj_flat + p01 = ii_flat * n_circ + (jj_flat + 1) % n_circ + p10 = (ii_flat + 1) * n_circ + jj_flat + p11 = (ii_flat + 1) * n_circ + (jj_flat + 1) % n_circ + + tri1 = torch.stack([p00, p01, p10], dim=1) + tri2 = torch.stack([p01, p11, p10], dim=1) ### Add base cap - # Base center - base_center_idx = len(points_side) - points_side.append([0.0, 0.0, 0.0]) - - # Base cap triangles - for j in range(n_circ): - next_j = (j + 1) % n_circ - cells_side.append([base_center_idx, next_j, j]) - - points = torch.tensor(points_side, dtype=torch.float32, device=device) - cells = torch.tensor(cells_side, dtype=torch.int64, device=device) + base_center_idx = n_height * n_circ + base_center = torch.tensor([[0.0, 0.0, 0.0]], dtype=torch.float32, device=device) + + # Vectorized base cap triangles + j_cap = torch.arange(n_circ, device=device) + next_j_cap = (j_cap + 1) % n_circ + base_cells = torch.stack( + [ + torch.full((n_circ,), base_center_idx, dtype=torch.int64, device=device), + next_j_cap, + j_cap, + ], + dim=1, + ) + + points = torch.cat([side_points, base_center], dim=0) + cells = torch.cat([tri1, tri2, base_cells], dim=0) return Mesh(points=points, cells=cells) diff --git a/physicsnemo/mesh/primitives/surfaces/cylinder.py b/physicsnemo/mesh/primitives/surfaces/cylinder.py index 9f08e66487..66116961c9 100644 --- a/physicsnemo/mesh/primitives/surfaces/cylinder.py +++ b/physicsnemo/mesh/primitives/surfaces/cylinder.py @@ -58,52 +58,62 @@ def load( ### Create cylindrical side theta = torch.linspace(0, 2 * torch.pi, n_circ + 1, device=device)[:-1] - z = torch.linspace(-height / 2, height / 2, n_height, device=device) - - # Side points - points_side = [] - for z_val in z: - for theta_val in theta: - x = radius * torch.cos(theta_val) - y = radius * torch.sin(theta_val) - points_side.append([x.item(), y.item(), z_val.item()]) - - # Create cells for side - cells_side = [] - for i in range(n_height - 1): - for j in range(n_circ): - idx = i * n_circ + j - next_j = (j + 1) % n_circ - - # Two triangles per quad - cells_side.append([idx, idx + next_j - j, idx + n_circ]) - cells_side.append( - [idx + next_j - j, idx + n_circ + next_j - j, idx + n_circ] - ) + z_vals = torch.linspace(-height / 2, height / 2, n_height, device=device) - ### Add caps - # Bottom cap center - bottom_center_idx = len(points_side) - points_side.append([0.0, 0.0, -height / 2]) + # Vectorized side point generation + Z, THETA = torch.meshgrid(z_vals, theta, indexing="ij") + x = radius * torch.cos(THETA) + y = radius * torch.sin(THETA) + side_points = torch.stack([x, y, Z], dim=-1).reshape(-1, 3).to(dtype=torch.float32) + + # Vectorized side cell generation (periodic in theta, open in z) + i_idx = torch.arange(n_height - 1, device=device) + j_idx = torch.arange(n_circ, device=device) + ii, jj = torch.meshgrid(i_idx, j_idx, indexing="ij") + ii_flat = ii.reshape(-1) + jj_flat = jj.reshape(-1) - # Top cap center - top_center_idx = len(points_side) - points_side.append([0.0, 0.0, height / 2]) + p00 = ii_flat * n_circ + jj_flat + p01 = ii_flat * n_circ + (jj_flat + 1) % n_circ + p10 = (ii_flat + 1) * n_circ + jj_flat + p11 = (ii_flat + 1) * n_circ + (jj_flat + 1) % n_circ - # Bottom cap triangles - for j in range(n_circ): - next_j = (j + 1) % n_circ - cells_side.append([bottom_center_idx, next_j, j]) + tri1 = torch.stack([p00, p01, p10], dim=1) + tri2 = torch.stack([p01, p11, p10], dim=1) - # Top cap triangles + ### Add caps + bottom_center_idx = n_height * n_circ + top_center_idx = n_height * n_circ + 1 + cap_points = torch.tensor( + [[0.0, 0.0, -height / 2], [0.0, 0.0, height / 2]], + dtype=torch.float32, + device=device, + ) + + # Vectorized bottom cap triangles + j_cap = torch.arange(n_circ, device=device) + next_j_cap = (j_cap + 1) % n_circ + bottom_cells = torch.stack( + [ + torch.full((n_circ,), bottom_center_idx, dtype=torch.int64, device=device), + next_j_cap, + j_cap, + ], + dim=1, + ) + + # Vectorized top cap triangles top_ring_offset = (n_height - 1) * n_circ - for j in range(n_circ): - next_j = (j + 1) % n_circ - cells_side.append( - [top_center_idx, top_ring_offset + j, top_ring_offset + next_j] - ) - - points = torch.tensor(points_side, dtype=torch.float32, device=device) - cells = torch.tensor(cells_side, dtype=torch.int64, device=device) + top_cells = torch.stack( + [ + torch.full((n_circ,), top_center_idx, dtype=torch.int64, device=device), + top_ring_offset + j_cap, + top_ring_offset + next_j_cap, + ], + dim=1, + ) + + points = torch.cat([side_points, cap_points], dim=0) + cells = torch.cat([tri1, tri2, bottom_cells, top_cells], dim=0) return Mesh(points=points, cells=cells) diff --git a/physicsnemo/mesh/primitives/surfaces/cylinder_open.py b/physicsnemo/mesh/primitives/surfaces/cylinder_open.py index ab134d4c86..a4ac996495 100644 --- a/physicsnemo/mesh/primitives/surfaces/cylinder_open.py +++ b/physicsnemo/mesh/primitives/surfaces/cylinder_open.py @@ -56,29 +56,29 @@ def load( if n_height < 2: raise ValueError(f"n_height must be at least 2, got {n_height=}") - # Create cylindrical points + # Vectorized cylindrical point generation theta = torch.linspace(0, 2 * torch.pi, n_circ + 1, device=device)[:-1] - z = torch.linspace(-height / 2, height / 2, n_height, device=device) + z_vals = torch.linspace(-height / 2, height / 2, n_height, device=device) - points = [] - for z_val in z: - for theta_val in theta: - x = radius * torch.cos(theta_val) - y = radius * torch.sin(theta_val) - points.append([x.item(), y.item(), z_val.item()]) + Z, THETA = torch.meshgrid(z_vals, theta, indexing="ij") + x = radius * torch.cos(THETA) + y = radius * torch.sin(THETA) + points = torch.stack([x, y, Z], dim=-1).reshape(-1, 3).to(dtype=torch.float32) - points = torch.tensor(points, dtype=torch.float32, device=device) + # Vectorized cell generation (periodic in theta, open in z) + i_idx = torch.arange(n_height - 1, device=device) + j_idx = torch.arange(n_circ, device=device) + ii, jj = torch.meshgrid(i_idx, j_idx, indexing="ij") + ii_flat = ii.reshape(-1) + jj_flat = jj.reshape(-1) - # Create cells - cells = [] - for i in range(n_height - 1): - for j in range(n_circ): - idx = i * n_circ + j - next_j = (j + 1) % n_circ + p00 = ii_flat * n_circ + jj_flat + p01 = ii_flat * n_circ + (jj_flat + 1) % n_circ + p10 = (ii_flat + 1) * n_circ + jj_flat + p11 = (ii_flat + 1) * n_circ + (jj_flat + 1) % n_circ - # Two triangles per quad - cells.append([idx, idx + next_j - j, idx + n_circ]) - cells.append([idx + next_j - j, idx + n_circ + next_j - j, idx + n_circ]) + tri1 = torch.stack([p00, p01, p10], dim=1) + tri2 = torch.stack([p01, p11, p10], dim=1) + cells = torch.cat([tri1, tri2], dim=0) - cells = torch.tensor(cells, dtype=torch.int64, device=device) return Mesh(points=points, cells=cells) diff --git a/physicsnemo/mesh/primitives/surfaces/disk.py b/physicsnemo/mesh/primitives/surfaces/disk.py index bd83849813..3e4428625e 100644 --- a/physicsnemo/mesh/primitives/surfaces/disk.py +++ b/physicsnemo/mesh/primitives/surfaces/disk.py @@ -54,38 +54,55 @@ def load( raise ValueError(f"n_angular must be at least 3, got {n_angular=}") # Center point - points = [torch.tensor([0.0, 0.0, 0.0], device=device)] + center = torch.zeros(1, 3, dtype=torch.float32, device=device) + + # Vectorized radial ring point generation + r_vals = ( + radius + * torch.arange(1, n_radial + 1, device=device, dtype=torch.float32) + / n_radial + ) + theta = torch.linspace(0, 2 * torch.pi, n_angular + 1, device=device)[:-1] + R, THETA = torch.meshgrid(r_vals, theta, indexing="ij") + x = R * torch.cos(THETA) + y = R * torch.sin(THETA) + z = torch.zeros_like(x) + ring_points = torch.stack([x, y, z], dim=-1).reshape(-1, 3).to(dtype=torch.float32) + + points = torch.cat([center, ring_points], dim=0) + + # Vectorized cell generation + # Innermost ring connected to center + j_idx = torch.arange(n_angular, device=device) + next_j = (j_idx + 1) % n_angular + inner_cells = torch.stack( + [ + torch.zeros(n_angular, dtype=torch.int64, device=device), + 1 + next_j, + 1 + j_idx, + ], + dim=1, + ) + + cells_parts = [inner_cells] - # Radial rings - for i in range(1, n_radial + 1): - r = radius * i / n_radial - theta = torch.linspace(0, 2 * torch.pi, n_angular + 1, device=device)[:-1] - for theta_val in theta: - x = r * torch.cos(theta_val) - y = r * torch.sin(theta_val) - points.append(torch.tensor([x.item(), y.item(), 0.0], device=device)) + # Outer rings + if n_radial > 1: + i_idx = torch.arange(n_radial - 1, device=device) + j_idx_outer = torch.arange(n_angular, device=device) + ii, jj = torch.meshgrid(i_idx, j_idx_outer, indexing="ij") + ii_flat = ii.reshape(-1) + jj_flat = jj.reshape(-1) - points = torch.stack(points, dim=0) + idx = 1 + ii_flat * n_angular + jj_flat + next_j_o = 1 + ii_flat * n_angular + (jj_flat + 1) % n_angular + idx_outer = 1 + (ii_flat + 1) * n_angular + jj_flat + next_j_outer = 1 + (ii_flat + 1) * n_angular + (jj_flat + 1) % n_angular - # Create cells - cells = [] + tri1 = torch.stack([idx, next_j_o, idx_outer], dim=1) + tri2 = torch.stack([next_j_o, next_j_outer, idx_outer], dim=1) + cells_parts.extend([tri1, tri2]) - # Innermost ring connected to center - for j in range(n_angular): - next_j = (j + 1) % n_angular - cells.append([0, 1 + next_j, 1 + j]) + cells = torch.cat(cells_parts, dim=0) - # Outer rings - for i in range(n_radial - 1): - for j in range(n_angular): - idx = 1 + i * n_angular + j - next_j = 1 + i * n_angular + (j + 1) % n_angular - idx_outer = 1 + (i + 1) * n_angular + j - next_j_outer = 1 + (i + 1) * n_angular + (j + 1) % n_angular - - # Two triangles per quad - cells.append([idx, next_j, idx_outer]) - cells.append([next_j, next_j_outer, idx_outer]) - - cells = torch.tensor(cells, dtype=torch.int64, device=device) return Mesh(points=points, cells=cells) diff --git a/physicsnemo/mesh/primitives/surfaces/hemisphere.py b/physicsnemo/mesh/primitives/surfaces/hemisphere.py index 6d1345b49c..07934cd4da 100644 --- a/physicsnemo/mesh/primitives/surfaces/hemisphere.py +++ b/physicsnemo/mesh/primitives/surfaces/hemisphere.py @@ -59,32 +59,27 @@ def load( theta = torch.linspace(0, 2 * torch.pi, theta_resolution + 1, device=device)[:-1] phi = torch.linspace(0, torch.pi / 2, phi_resolution, device=device) - points = [] - for phi_val in phi: - for theta_val in theta: - x = radius * torch.sin(phi_val) * torch.cos(theta_val) - y = radius * torch.sin(phi_val) * torch.sin(theta_val) - z = radius * torch.cos(phi_val) - points.append([x.item(), y.item(), z.item()]) + # Vectorized point generation + PHI, THETA = torch.meshgrid(phi, theta, indexing="ij") + x = radius * torch.sin(PHI) * torch.cos(THETA) + y = radius * torch.sin(PHI) * torch.sin(THETA) + z = radius * torch.cos(PHI) + points = torch.stack([x, y, z], dim=-1).reshape(-1, 3).to(dtype=torch.float32) - points = torch.tensor(points, dtype=torch.float32, device=device) + # Vectorized cell generation (periodic in theta, open in phi) + i_idx = torch.arange(phi_resolution - 1, device=device) + j_idx = torch.arange(theta_resolution, device=device) + ii, jj = torch.meshgrid(i_idx, j_idx, indexing="ij") + ii_flat = ii.reshape(-1) + jj_flat = jj.reshape(-1) - # Create cells - cells = [] - for i in range(phi_resolution - 1): - for j in range(theta_resolution): - idx = i * theta_resolution + j - next_j = (j + 1) % theta_resolution + p00 = ii_flat * theta_resolution + jj_flat + p01 = ii_flat * theta_resolution + (jj_flat + 1) % theta_resolution + p10 = (ii_flat + 1) * theta_resolution + jj_flat + p11 = (ii_flat + 1) * theta_resolution + (jj_flat + 1) % theta_resolution - # Two triangles per quad - cells.append([idx, idx + next_j - j, idx + theta_resolution]) - cells.append( - [ - idx + next_j - j, - idx + theta_resolution + next_j - j, - idx + theta_resolution, - ] - ) + tri1 = torch.stack([p00, p01, p10], dim=1) + tri2 = torch.stack([p01, p11, p10], dim=1) + cells = torch.cat([tri1, tri2], dim=0) - cells = torch.tensor(cells, dtype=torch.int64, device=device) return Mesh(points=points, cells=cells) diff --git a/physicsnemo/mesh/primitives/surfaces/mobius_strip.py b/physicsnemo/mesh/primitives/surfaces/mobius_strip.py index f851cfbfbd..31ec35cb41 100644 --- a/physicsnemo/mesh/primitives/surfaces/mobius_strip.py +++ b/physicsnemo/mesh/primitives/surfaces/mobius_strip.py @@ -60,36 +60,41 @@ def load( u = torch.linspace(0, 2 * torch.pi, n_circ + 1, device=device)[:-1] v = torch.linspace(-width / 2, width / 2, n_width, device=device) - points = [] - for u_val in u: - for v_val in v: - # Möbius strip parameterization - x = (radius + v_val * torch.cos(u_val / 2)) * torch.cos(u_val) - y = (radius + v_val * torch.cos(u_val / 2)) * torch.sin(u_val) - z = v_val * torch.sin(u_val / 2) - points.append([x.item(), y.item(), z.item()]) - - points = torch.tensor(points, dtype=torch.float32, device=device) - - # Create cells - cells = [] - for i in range(n_circ): - for j in range(n_width - 1): - idx = i * n_width + j - next_j = i * n_width + j + 1 - - # Handle Möbius twist at wrap-around - if i == n_circ - 1: # Last slice connecting back to first - # Flip width index for the half-twist: j -> (n_width - 1 - j) - next_i = n_width - 1 - j - next_both = n_width - 2 - j - else: - next_i = (i + 1) * n_width + j - next_both = (i + 1) * n_width + j + 1 - - # Two triangles per quad - cells.append([idx, next_j, next_i]) - cells.append([next_j, next_both, next_i]) - - cells = torch.tensor(cells, dtype=torch.int64, device=device) + # Vectorized point generation + U, V = torch.meshgrid(u, v, indexing="ij") + x = (radius + V * torch.cos(U / 2)) * torch.cos(U) + y = (radius + V * torch.cos(U / 2)) * torch.sin(U) + z = V * torch.sin(U / 2) + points = torch.stack([x, y, z], dim=-1).reshape(-1, 3).to(dtype=torch.float32) + + # Vectorized cell generation + # Regular cells (i < n_circ - 1): open in v, no twist + i_reg = torch.arange(n_circ - 1, device=device) + j_reg = torch.arange(n_width - 1, device=device) + ii, jj = torch.meshgrid(i_reg, j_reg, indexing="ij") + ii_flat = ii.reshape(-1) + jj_flat = jj.reshape(-1) + + idx_r = ii_flat * n_width + jj_flat + next_j_r = ii_flat * n_width + jj_flat + 1 + next_i_r = (ii_flat + 1) * n_width + jj_flat + next_both_r = (ii_flat + 1) * n_width + jj_flat + 1 + + tri1_reg = torch.stack([idx_r, next_j_r, next_i_r], dim=1) + tri2_reg = torch.stack([next_j_r, next_both_r, next_i_r], dim=1) + + # Twist cells (i = n_circ - 1): connects back to first slice with flipped v + j_tw = torch.arange(n_width - 1, device=device) + last_i = n_circ - 1 + + idx_t = last_i * n_width + j_tw + next_j_t = last_i * n_width + j_tw + 1 + next_i_t = n_width - 1 - j_tw + next_both_t = n_width - 2 - j_tw + + tri1_twist = torch.stack([idx_t, next_j_t, next_i_t], dim=1) + tri2_twist = torch.stack([next_j_t, next_both_t, next_i_t], dim=1) + + cells = torch.cat([tri1_reg, tri2_reg, tri1_twist, tri2_twist], dim=0) + return Mesh(points=points, cells=cells) diff --git a/physicsnemo/mesh/primitives/surfaces/plane.py b/physicsnemo/mesh/primitives/surfaces/plane.py index 6a34eb620f..256cf9ba04 100644 --- a/physicsnemo/mesh/primitives/surfaces/plane.py +++ b/physicsnemo/mesh/primitives/surfaces/plane.py @@ -26,7 +26,7 @@ def load( size: float = 2.0, - n_subdivisions: int = 10, + subdivisions: int = 10, normal: tuple[float, float, float] = (0.0, 0.0, 1.0), device: torch.device | str = "cpu", ) -> Mesh: @@ -36,8 +36,9 @@ def load( ---------- size : float Size of the plane (length of each side). - n_subdivisions : int - Number of subdivisions per edge. + subdivisions : int + Number of subdivisions per edge. Creates (subdivisions+1)^2 vertices + and 2*subdivisions^2 triangles. normal : tuple[float, float, float] Normal vector to the plane (will be normalized). device : str @@ -48,10 +49,10 @@ def load( Mesh Mesh with n_manifold_dims=2, n_spatial_dims=3. """ - if n_subdivisions < 1: - raise ValueError(f"n_subdivisions must be at least 1, got {n_subdivisions=}") + if subdivisions < 1: + raise ValueError(f"subdivisions must be at least 1, got {subdivisions=}") - n = n_subdivisions + 1 + n = subdivisions + 1 # Create grid of points in xy-plane x = torch.linspace(-size / 2, size / 2, n, device=device) @@ -99,8 +100,8 @@ def load( # Create triangular cells cells = [] - for i in range(n_subdivisions): - for j in range(n_subdivisions): + for i in range(subdivisions): + for j in range(subdivisions): idx = i * n + j # Two triangles per quad cells.append([idx, idx + 1, idx + n]) diff --git a/physicsnemo/mesh/primitives/surfaces/sphere_icosahedral.py b/physicsnemo/mesh/primitives/surfaces/sphere_icosahedral.py new file mode 100644 index 0000000000..8d6cfc8e23 --- /dev/null +++ b/physicsnemo/mesh/primitives/surfaces/sphere_icosahedral.py @@ -0,0 +1,96 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Icosahedral sphere surface in 3D space. + +A sphere created by subdividing an icosahedron and projecting vertices +onto the sphere surface. This produces a more uniform triangulation than +UV-parameterized spheres. + +Dimensional: 2D manifold in 3D space (closed, no boundary). +""" + +import torch + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.primitives.surfaces import icosahedron_surface + + +def load( + radius: float = 1.0, + subdivisions: int = 2, + device: torch.device | str = "cpu", +) -> Mesh: + """Create a sphere by subdividing an icosahedron and projecting to sphere. + + This method produces a more uniform triangulation than UV-parameterized + spheres (no pole singularities). Each subdivision level quadruples the + number of triangles. + + Parameters + ---------- + radius : float + Radius of the sphere. + subdivisions : int + Number of subdivision levels to apply. Each level quadruples the + triangle count: + - 0: 20 triangles (base icosahedron) + - 1: 80 triangles + - 2: 320 triangles + - 3: 1280 triangles + - 4: 5120 triangles + device : torch.device or str + Compute device ('cpu' or 'cuda'). + + Returns + ------- + Mesh + Mesh with n_manifold_dims=2, n_spatial_dims=3. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> mesh = sphere_icosahedral.load(radius=1.0, subdivisions=2) + >>> mesh.n_manifold_dims, mesh.n_spatial_dims + (2, 3) + >>> mesh.n_cells # 20 * 4^2 = 320 triangles + 320 + """ + if radius <= 0: + raise ValueError(f"radius must be positive, got {radius=}") + if subdivisions < 0: + raise ValueError(f"subdivisions must be non-negative, got {subdivisions=}") + + ### Start with base icosahedron + mesh = icosahedron_surface.load(radius=1.0, device=device) + + ### Apply subdivision levels + if subdivisions > 0: + mesh = mesh.subdivide(levels=subdivisions, filter="linear") + + ### Project all points back onto the sphere surface + # After linear subdivision, new vertices are at edge midpoints which + # lie inside the sphere. Project them back to the sphere surface. + norms = torch.norm(mesh.points, dim=-1, keepdim=True) + mesh = Mesh( + points=mesh.points / norms * radius, + cells=mesh.cells, + point_data=mesh.point_data, + cell_data=mesh.cell_data, + global_data=mesh.global_data, + ) + + return mesh diff --git a/physicsnemo/mesh/primitives/surfaces/torus.py b/physicsnemo/mesh/primitives/surfaces/torus.py index 6b52370c1b..28e3685066 100644 --- a/physicsnemo/mesh/primitives/surfaces/torus.py +++ b/physicsnemo/mesh/primitives/surfaces/torus.py @@ -64,28 +64,27 @@ def load( u = torch.linspace(0, 2 * torch.pi, n_major + 1, device=device)[:-1] v = torch.linspace(0, 2 * torch.pi, n_minor + 1, device=device)[:-1] - points = [] - for u_val in u: - for v_val in v: - x = (major_radius + minor_radius * torch.cos(v_val)) * torch.cos(u_val) - y = (major_radius + minor_radius * torch.cos(v_val)) * torch.sin(u_val) - z = minor_radius * torch.sin(v_val) - points.append([x.item(), y.item(), z.item()]) + # Vectorized point generation + U, V = torch.meshgrid(u, v, indexing="ij") + x = (major_radius + minor_radius * torch.cos(V)) * torch.cos(U) + y = (major_radius + minor_radius * torch.cos(V)) * torch.sin(U) + z = minor_radius * torch.sin(V) + points = torch.stack([x, y, z], dim=-1).reshape(-1, 3).to(dtype=torch.float32) - points = torch.tensor(points, dtype=torch.float32, device=device) + # Vectorized cell generation (closed in both u and v) + i_idx = torch.arange(n_major, device=device) + j_idx = torch.arange(n_minor, device=device) + ii, jj = torch.meshgrid(i_idx, j_idx, indexing="ij") + ii_flat = ii.reshape(-1) + jj_flat = jj.reshape(-1) - # Create cells - cells = [] - for i in range(n_major): - for j in range(n_minor): - idx = i * n_minor + j - next_i = ((i + 1) % n_major) * n_minor + j - next_j = i * n_minor + (j + 1) % n_minor - next_both = ((i + 1) % n_major) * n_minor + (j + 1) % n_minor + idx = ii_flat * n_minor + jj_flat + next_i = ((ii_flat + 1) % n_major) * n_minor + jj_flat + next_j = ii_flat * n_minor + (jj_flat + 1) % n_minor + next_both = ((ii_flat + 1) % n_major) * n_minor + (jj_flat + 1) % n_minor - # Two triangles per quad - cells.append([idx, next_j, next_i]) - cells.append([next_j, next_both, next_i]) + tri1 = torch.stack([idx, next_j, next_i], dim=1) + tri2 = torch.stack([next_j, next_both, next_i], dim=1) + cells = torch.cat([tri1, tri2], dim=0) - cells = torch.tensor(cells, dtype=torch.int64, device=device) return Mesh(points=points, cells=cells) diff --git a/physicsnemo/mesh/primitives/text.py b/physicsnemo/mesh/primitives/text.py new file mode 100644 index 0000000000..46e72cd5ff --- /dev/null +++ b/physicsnemo/mesh/primitives/text.py @@ -0,0 +1,617 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Text rendering to mesh in various configurations. + +Provides functions to convert text strings into meshes with different +dimensional configurations: 1D curves, 2D surfaces, 3D volumes, and boundaries. + +Uses matplotlib's font rendering, Delaunay triangulation, and intelligent +hole detection (for letters like 'o', 'e', 'a') using the shoelace formula. + +This module requires matplotlib to be installed. +""" + +import torch + +from physicsnemo.core.version_check import require_version_spec +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.projections import embed, extrude + + +def _compute_polygon_signed_area(vertices) -> float: + """Compute signed area using shoelace formula (positive=outer, negative=hole).""" + import numpy as np + + if isinstance(vertices, torch.Tensor): + vertices = vertices.cpu().numpy() + vertices = np.array(vertices) + + n = len(vertices) + if n < 3: + return 0.0 + + area = 0.0 + for i in range(n): + j = (i + 1) % n + area += vertices[i][0] * vertices[j][1] + area -= vertices[j][0] * vertices[i][1] + + return -area * 0.5 # Negate for positive=outer convention + + +def _sample_curve_segment(p0, control_points, pn, num_samples: int): + """Sample Bezier curve segment.""" + t = torch.linspace(0, 1, num_samples, dtype=p0.dtype, device=p0.device).unsqueeze(1) + + if len(control_points) == 1: + # Quadratic Bezier + p1 = control_points[0] + return (1 - t) ** 2 * p0 + 2 * (1 - t) * t * p1 + t**2 * pn + elif len(control_points) == 2: + # Cubic Bezier + p1, p2 = control_points + return ( + (1 - t) ** 3 * p0 + + 3 * (1 - t) ** 2 * t * p1 + + 3 * (1 - t) * t**2 * p2 + + t**3 * pn + ) + else: + raise ValueError( + f"Unsupported curve order with {len(control_points)} control points" + ) + + +def _text_to_path(text: str, font_size: float = 12.0, samples_per_unit: float = 10): + """Convert text to sampled path with edges. + + Returns + ------- + tuple + Tuple of (points, edges, matplotlib Path object) + """ + import importlib + + font_manager = importlib.import_module("matplotlib.font_manager") + mpl_path = importlib.import_module("matplotlib.path") + textpath = importlib.import_module("matplotlib.textpath") + + fp = font_manager.FontProperties(family="sans-serif", weight="bold") + text_path = textpath.TextPath((0, 0), text, size=font_size, prop=fp) + + verts = torch.tensor(text_path.vertices.copy(), dtype=torch.float32) + codes = torch.tensor(text_path.codes.copy(), dtype=torch.int64) + + all_points: list[torch.Tensor] = [] + all_edges: list[torch.Tensor] = [] + current_offset = 0 + path_points: list[torch.Tensor] = [] + + i = 0 + while i < len(codes): + code = codes[i].item() + + if code == mpl_path.Path.MOVETO: + if path_points: + path_points.append(path_points[0]) + n_edges = len(path_points) - 1 + edges = torch.stack( + [ + torch.arange(n_edges, dtype=torch.int64) + current_offset, + torch.arange(n_edges, dtype=torch.int64) + current_offset + 1, + ], + dim=1, + ) + all_edges.extend(edges) + all_points.extend(path_points) + current_offset += len(path_points) + path_points = [verts[i]] + i += 1 + elif code == mpl_path.Path.LINETO: + path_points.append(verts[i]) + i += 1 + elif code == mpl_path.Path.CURVE3: + dist = torch.norm(verts[i + 1] - path_points[-1]).item() + num_samples = max(5, int(dist * samples_per_unit)) + sampled = _sample_curve_segment( + path_points[-1], [verts[i]], verts[i + 1], num_samples + ) + path_points.extend(sampled[1:]) + i += 2 + elif code == mpl_path.Path.CURVE4: + dist = torch.norm(verts[i + 2] - path_points[-1]).item() + num_samples = max(5, int(dist * samples_per_unit)) + sampled = _sample_curve_segment( + path_points[-1], [verts[i], verts[i + 1]], verts[i + 2], num_samples + ) + path_points.extend(sampled[1:]) + i += 3 + elif code == mpl_path.Path.CLOSEPOLY: + if path_points: + path_points.append(path_points[0]) + n_edges = len(path_points) - 1 + edges = torch.stack( + [ + torch.arange(n_edges, dtype=torch.int64) + current_offset, + torch.arange(n_edges, dtype=torch.int64) + current_offset + 1, + ], + dim=1, + ) + all_edges.extend(edges) + all_points.extend(path_points) + current_offset += len(path_points) + path_points = [] + i += 1 + else: + i += 1 + + if path_points: + path_points.append(path_points[0]) + n_edges = len(path_points) - 1 + edges = torch.stack( + [ + torch.arange(n_edges, dtype=torch.int64) + current_offset, + torch.arange(n_edges, dtype=torch.int64) + current_offset + 1, + ], + dim=1, + ) + all_edges.extend(edges) + all_points.extend(path_points) + + points = torch.stack(all_points, dim=0) + edges = torch.stack(all_edges, dim=0) + + # Center + center = points.mean(dim=0) + points = points - center + + centered_vertices = text_path.vertices - center.cpu().numpy() + text_path = mpl_path.Path(centered_vertices, text_path.codes) + + return points, edges, text_path + + +def _refine_edges(points: torch.Tensor, edges: torch.Tensor, max_length: float): + """Subdivide long edges.""" + refined_points = [points] + refined_edges = [] + next_idx = len(points) + + for edge in edges: + p0_idx, p1_idx = edge[0].item(), edge[1].item() + p0, p1 = points[p0_idx], points[p1_idx] + edge_vec = p1 - p0 + edge_length = torch.norm(edge_vec).item() + + if edge_length <= max_length: + refined_edges.append(edge) + else: + n_segments = int(torch.ceil(torch.tensor(edge_length / max_length)).item()) + prev_idx = p0_idx + for j in range(1, n_segments): + t = j / n_segments + interp_point = p0 + t * edge_vec + refined_points.append(interp_point.unsqueeze(0)) + refined_edges.append( + torch.tensor([prev_idx, next_idx], dtype=torch.int64) + ) + prev_idx = next_idx + next_idx += 1 + refined_edges.append(torch.tensor([prev_idx, p1_idx], dtype=torch.int64)) + + return torch.cat(refined_points, dim=0), torch.stack(refined_edges, dim=0) + + +def _group_letters(text_path): + """Group polygons into letters using signed area and containment.""" + import importlib + + import numpy as np + + mpl_path = importlib.import_module("matplotlib.path") + + path_codes = np.array(text_path.codes) + closepoly_indices = np.where(path_codes == mpl_path.Path.CLOSEPOLY)[0] + + outers, holes = [], [] + start_idx = 0 + + for close_idx in closepoly_indices: + end_idx = close_idx + 1 + polygon_verts = text_path.vertices[start_idx:end_idx] + signed_area = _compute_polygon_signed_area(polygon_verts) + + if signed_area > 0: + outers.append((start_idx, end_idx)) + else: + holes.append((start_idx, end_idx)) + + start_idx = end_idx + + # Assign holes to parents via containment + letter_groups = [] + for outer_start, outer_end in outers: + if text_path.vertices is None or text_path.codes is None: + continue + outer_verts = text_path.vertices[outer_start:outer_end] + outer_codes = text_path.codes[outer_start:outer_end] + outer_path = mpl_path.Path(outer_verts, outer_codes) + + contained_holes = [] + for hole_start, hole_end in holes: + hole_sample = text_path.vertices[hole_start] + if outer_path.contains_point(hole_sample): + contained_holes.append((hole_start, hole_end)) + + letter_groups.append( + {"outer": (outer_start, outer_end), "holes": contained_holes} + ) + + return letter_groups + + +def _winding_number(points: torch.Tensor, path) -> torch.Tensor: + """Compute winding number for path containment test.""" + import importlib + + import numpy as np + + mpl_path = importlib.import_module("matplotlib.path") + + path_codes = np.array(path.codes) + moveto_indices = np.where(path_codes == mpl_path.Path.MOVETO)[0] + total_winding = torch.zeros(len(points), dtype=torch.float32, device=points.device) + + for i, start_idx in enumerate(moveto_indices): + end_idx = ( + int(moveto_indices[i + 1]) + if i < len(moveto_indices) - 1 + else len(path_codes) + ) + contour_verts = torch.tensor( + path.vertices[start_idx:end_idx], dtype=torch.float32 + ) + winding_contour = torch.zeros( + len(points), dtype=torch.float32, device=points.device + ) + + for j in range(len(contour_verts)): + v0 = contour_verts[j] + v1 = contour_verts[(j + 1) % len(contour_verts)] + + if v0[1] == v1[1]: + continue + + y_low = torch.minimum(v0[1], v1[1]) + y_high = torch.maximum(v0[1], v1[1]) + y_in_range = (points[:, 1] >= y_low) & (points[:, 1] < y_high) + + t = (points[:, 1] - v0[1]) / (v1[1] - v0[1]) + x_intersect = v0[0] + t * (v1[0] - v0[0]) + crosses = y_in_range & (x_intersect > points[:, 0]) + direction = torch.sign(v1[1] - v0[1]) + winding_contour = winding_contour + crosses.float() * direction + + total_winding = total_winding + winding_contour + + return total_winding + + +def _get_letter_points(points, edges, text_path, polygon_ranges): + """Get points belonging to a letter (outer + holes).""" + import numpy as np + + letter_point_indices = [] + for start_idx, end_idx in polygon_ranges: + polygon_verts = text_path.vertices[start_idx:end_idx] + for i, point in enumerate(points): + point_np = point.cpu().numpy() + distances = np.linalg.norm(polygon_verts - point_np, axis=1) + if np.min(distances) < 0.01: + letter_point_indices.append(i) + + letter_point_set = set(letter_point_indices) + for edge in edges: + p0, p1 = edge[0].item(), edge[1].item() + if p0 in letter_point_set or p1 in letter_point_set: + letter_point_set.add(p0) + letter_point_set.add(p1) + + return torch.tensor(sorted(letter_point_set), dtype=torch.long) + + +def _triangulate(points, edges, text_path): + """Triangulate text letter-by-letter with hole support.""" + import importlib + + import numpy as np + + mpl_path = importlib.import_module("matplotlib.path") + mpl_tri = importlib.import_module("matplotlib.tri") + + letter_groups = _group_letters(text_path) + + all_points_list = [] + all_triangles = [] + global_offset = 0 + + for group in letter_groups: + outer = group["outer"] + holes = group["holes"] + all_polygon_ranges = [outer] + holes + + letter_point_indices = _get_letter_points( + points, edges, text_path, all_polygon_ranges + ) + if len(letter_point_indices) < 3: + continue + + letter_points = points[letter_point_indices] + letter_points_np = letter_points.cpu().numpy() + + tri = mpl_tri.Triangulation(letter_points_np[:, 0], letter_points_np[:, 1]) + + if text_path.vertices is None or text_path.codes is None: + continue + + combined_verts = [] + combined_codes = [] + for start_idx, end_idx in all_polygon_ranges: + combined_verts.append(text_path.vertices[start_idx:end_idx]) + combined_codes.append(text_path.codes[start_idx:end_idx]) + + combined_verts = np.vstack(combined_verts) + combined_codes = np.hstack(combined_codes) + letter_path = mpl_path.Path(combined_verts, combined_codes) + + centroids_np = letter_points_np[tri.triangles].mean(axis=1) + centroids_torch = torch.tensor(centroids_np, dtype=torch.float32) + winding = _winding_number(centroids_torch, letter_path) + inside_mask = winding != 0 + + letter_triangles = tri.triangles[inside_mask.cpu().numpy()] + letter_triangles_global = letter_triangles + global_offset + + if len(letter_triangles_global) > 0: + all_triangles.append(letter_triangles_global) + + all_points_list.append(letter_points) + global_offset += len(letter_points) + + all_points = torch.cat(all_points_list, dim=0) if all_points_list else points + triangles = ( + torch.from_numpy(np.vstack(all_triangles)).long() + if all_triangles + else torch.empty((0, 3), dtype=torch.long) + ) + + return all_points, triangles + + +@require_version_spec("matplotlib") +def text_1d_2d( + text: str = "physicsnemo.mesh", + font_size: float = 12.0, + samples_per_unit: float = 10, + max_segment_length: float = 0.25, + device: torch.device | str = "cpu", +) -> Mesh: + """Render text as 1D curve in 2D space (boundary path only). + + Converts text to a polyline mesh representing the outline of each letter. + + Parameters + ---------- + text : str, optional + Text string to render + font_size : float, optional + Font size in arbitrary units + samples_per_unit : float, optional + Density of curve sampling for Bezier curves + max_segment_length : float, optional + Maximum edge length after subdivision + device : torch.device | str, optional + Device for mesh tensors ('cpu', 'cuda', or torch.device) + + Returns + ------- + Mesh + Mesh with n_manifold_dims=1, n_spatial_dims=2 (polyline in 2D) + + Examples + -------- + >>> mesh = text_1d_2d("Hello", font_size=10.0) + >>> assert mesh.n_manifold_dims == 1 + >>> assert mesh.n_spatial_dims == 2 + """ + if isinstance(device, str): + device = torch.device(device) + + points, edges, _ = _text_to_path(text, font_size, samples_per_unit) + points_refined, edges_refined = _refine_edges(points, edges, max_segment_length) + + return Mesh( + points=points_refined.to(device), + cells=edges_refined.to(device), + ) + + +@require_version_spec("matplotlib") +def text_2d_2d( + text: str = "physicsnemo.mesh", + font_size: float = 12.0, + samples_per_unit: float = 10, + max_segment_length: float = 0.25, + device: torch.device | str = "cpu", +) -> Mesh: + """Render text as 2D triangulated surface in 2D space (filled letters). + + Converts text to a filled mesh with proper hole handling for letters + like 'o', 'e', 'a'. Uses Delaunay triangulation and shoelace formula + for hole detection. + + Parameters + ---------- + text : str, optional + Text string to render + font_size : float, optional + Font size in arbitrary units + samples_per_unit : float, optional + Density of curve sampling for Bezier curves + max_segment_length : float, optional + Maximum edge length after subdivision + device : torch.device | str, optional + Device for mesh tensors ('cpu', 'cuda', or torch.device) + + Returns + ------- + Mesh + Mesh with n_manifold_dims=2, n_spatial_dims=2 (filled text in 2D plane) + + Examples + -------- + >>> mesh = text_2d_2d("Hello", font_size=10.0) + >>> assert mesh.n_manifold_dims == 2 + >>> assert mesh.n_spatial_dims == 2 + """ + if isinstance(device, str): + device = torch.device(device) + + points, edges, text_path = _text_to_path(text, font_size, samples_per_unit) + points_refined, edges_refined = _refine_edges(points, edges, max_segment_length) + points_filled, triangles = _triangulate(points_refined, edges_refined, text_path) + + return Mesh( + points=points_filled.to(device), + cells=triangles.to(device), + ) + + +@require_version_spec("matplotlib") +def text_3d_3d( + text: str = "physicsnemo.mesh", + font_size: float = 12.0, + samples_per_unit: float = 10, + max_segment_length: float = 0.25, + extrusion_height: float = 2.0, + device: torch.device | str = "cpu", +) -> Mesh: + """Render text as 3D tetrahedral volume (solid extruded text). + + Creates solid 3D text by triangulating in 2D, embedding to 3D, and + extruding along the z-axis. + + Parameters + ---------- + text : str, optional + Text string to render + font_size : float, optional + Font size in arbitrary units + samples_per_unit : float, optional + Density of curve sampling for Bezier curves + max_segment_length : float, optional + Maximum edge length after subdivision + extrusion_height : float, optional + Height to extrude in z-direction + device : torch.device | str, optional + Device for mesh tensors ('cpu', 'cuda', or torch.device) + + Returns + ------- + Mesh + Mesh with n_manifold_dims=3, n_spatial_dims=3 (solid tetrahedral volume) + + Examples + -------- + >>> mesh = text_3d_3d("Hello", font_size=10.0, extrusion_height=1.0) + >>> assert mesh.n_manifold_dims == 3 + >>> assert mesh.n_spatial_dims == 3 + """ + if isinstance(device, str): + device = torch.device(device) + + # Create 2D mesh + mesh_2d = text_2d_2d( + text, font_size, samples_per_unit, max_segment_length, device="cpu" + ) + + # Embed to 3D and extrude + mesh_3d_surface = embed(mesh_2d, target_n_spatial_dims=3) + volume = extrude( + mesh_3d_surface, + vector=torch.tensor( + [0.0, 0.0, extrusion_height], device=mesh_3d_surface.points.device + ), + ) + + # Move to target device + if device != mesh_2d.points.device: + volume = Mesh( + points=volume.points.to(device), + cells=volume.cells.to(device), + point_data=volume.point_data, + cell_data=volume.cell_data, + global_data=volume.global_data, + ) + + return volume + + +@require_version_spec("matplotlib") +def text_2d_3d( + text: str = "physicsnemo.mesh", + font_size: float = 12.0, + samples_per_unit: float = 10, + max_segment_length: float = 0.25, + extrusion_height: float = 2.0, + device: torch.device | str = "cpu", +) -> Mesh: + """Render text as 2D boundary surface in 3D space (hollow extruded text). + + Creates the surface of 3D text by extracting the boundary from an + extruded tetrahedral volume. + + Parameters + ---------- + text : str, optional + Text string to render + font_size : float, optional + Font size in arbitrary units + samples_per_unit : float, optional + Density of curve sampling for Bezier curves + max_segment_length : float, optional + Maximum edge length after subdivision + extrusion_height : float, optional + Height to extrude in z-direction + device : torch.device | str, optional + Device for mesh tensors ('cpu', 'cuda', or torch.device) + + Returns + ------- + Mesh + Mesh with n_manifold_dims=2, n_spatial_dims=3 (triangulated surface in 3D) + + Examples + -------- + >>> mesh = text_2d_3d("Hello", font_size=10.0, extrusion_height=1.0) + >>> assert mesh.n_manifold_dims == 2 + >>> assert mesh.n_spatial_dims == 3 + """ + volume = text_3d_3d( + text, font_size, samples_per_unit, max_segment_length, extrusion_height, device + ) + return volume.get_boundary_mesh(data_source="cells") diff --git a/physicsnemo/mesh/primitives/volumes/cube_volume.py b/physicsnemo/mesh/primitives/volumes/cube_volume.py index 3fd863e78c..033d0f79a1 100644 --- a/physicsnemo/mesh/primitives/volumes/cube_volume.py +++ b/physicsnemo/mesh/primitives/volumes/cube_volume.py @@ -25,18 +25,20 @@ def load( - size: float = 1.0, n_subdivisions: int = 5, device: torch.device | str = "cpu" + size: float = 1.0, subdivisions: int = 5, device: torch.device | str = "cpu" ) -> Mesh: """Create a tetrahedral volume mesh of a cube. The cube is divided into a regular grid of smaller cubes, and each small - cube is split into 5 tetrahedra using a consistent diagonal scheme. + cube is split into 6 tetrahedra using the Kuhn triangulation. This + triangulation naturally produces matching faces between adjacent cubes, + ensuring a valid watertight volume mesh. Parameters ---------- size : float Side length of the cube. - n_subdivisions : int + subdivisions : int Number of subdivisions per edge. device : str Compute device ('cpu' or 'cuda'). @@ -46,47 +48,57 @@ def load( Mesh Mesh with n_manifold_dims=3, n_spatial_dims=3. """ - if n_subdivisions < 1: - raise ValueError(f"n_subdivisions must be at least 1, got {n_subdivisions=}") + if subdivisions < 1: + raise ValueError(f"subdivisions must be at least 1, got {subdivisions=}") - n = n_subdivisions + 1 # Number of points per edge + n = subdivisions + 1 # Number of points per edge ### Generate grid points coords_1d = torch.linspace(-size / 2, size / 2, n, device=device) x, y, z = torch.meshgrid(coords_1d, coords_1d, coords_1d, indexing="ij") points = torch.stack([x.flatten(), y.flatten(), z.flatten()], dim=1) - ### Generate tetrahedra by splitting each cube into 5 tetrahedra - # For each cube cell, we split it into 5 tetrahedra using the - # "5-tetrahedra" decomposition with consistent diagonal orientation. - cells_list = [] - - for i in range(n_subdivisions): - for j in range(n_subdivisions): - for k in range(n_subdivisions): - # 8 vertices of the cube cell (indexed in the flattened grid) - # Vertex ordering: v0=(i,j,k), v1=(i+1,j,k), v2=(i,j+1,k), etc. - v0 = i * n * n + j * n + k - v1 = (i + 1) * n * n + j * n + k - v2 = i * n * n + (j + 1) * n + k - v3 = (i + 1) * n * n + (j + 1) * n + k - v4 = i * n * n + j * n + (k + 1) - v5 = (i + 1) * n * n + j * n + (k + 1) - v6 = i * n * n + (j + 1) * n + (k + 1) - v7 = (i + 1) * n * n + (j + 1) * n + (k + 1) - - # Split cube into 5 tetrahedra using consistent diagonal scheme - # This decomposition uses the body diagonal from v0 to v7 - cells_list.extend( - [ - [v0, v1, v3, v7], # tet 1 - [v0, v3, v2, v7], # tet 2 - [v0, v2, v6, v7], # tet 3 - [v0, v6, v4, v7], # tet 4 - [v0, v4, v5, v7], # tet 5 (closes with v1) - ] - ) - - cells = torch.tensor(cells_list, dtype=torch.int64, device=device) + ### Generate tetrahedra using Kuhn triangulation (6 tets per cube) + # The Kuhn triangulation splits each cube into 6 tetrahedra based on the + # 6 permutations of (x, y, z). Each tet connects v0 to v7 through a path + # that increments one coordinate at a time. This decomposition naturally + # produces matching triangular faces between adjacent cubes. + + # Create all (i, j, k) cell indices via meshgrid + cell_idx = torch.arange(subdivisions, device=device) + ii, jj, kk = torch.meshgrid(cell_idx, cell_idx, cell_idx, indexing="ij") + ii, jj, kk = ii.flatten(), jj.flatten(), kk.flatten() # Each: (num_cubes,) + + # Compute all 8 vertex indices for all cubes at once + # Vertex ordering: v0=(i,j,k), v1=(i+1,j,k), v2=(i,j+1,k), etc. + v0 = ii * n * n + jj * n + kk + v1 = (ii + 1) * n * n + jj * n + kk + v2 = ii * n * n + (jj + 1) * n + kk + v3 = (ii + 1) * n * n + (jj + 1) * n + kk + v4 = ii * n * n + jj * n + (kk + 1) + v5 = (ii + 1) * n * n + jj * n + (kk + 1) + v6 = ii * n * n + (jj + 1) * n + (kk + 1) + v7 = (ii + 1) * n * n + (jj + 1) * n + (kk + 1) + + cube_verts = torch.stack([v0, v1, v2, v3, v4, v5, v6, v7], dim=1) # (num_cubes, 8) + + ### Kuhn triangulation: 6 tetrahedra per cube + # Each tet corresponds to one of the 6 permutations of incrementing (x,y,z). + # All tets share the body diagonal v0-v7, ensuring consistent face diagonals. + tet_pattern = torch.tensor( + [ + [0, 1, 3, 7], # perm (x, y, z): v0 -> v1 -> v3 -> v7 + [0, 1, 5, 7], # perm (x, z, y): v0 -> v1 -> v5 -> v7 + [0, 2, 3, 7], # perm (y, x, z): v0 -> v2 -> v3 -> v7 + [0, 2, 6, 7], # perm (y, z, x): v0 -> v2 -> v6 -> v7 + [0, 4, 5, 7], # perm (z, x, y): v0 -> v4 -> v5 -> v7 + [0, 4, 6, 7], # perm (z, y, x): v0 -> v4 -> v6 -> v7 + ], + dtype=torch.int64, + device=device, + ) + + # Advanced indexing: (num_cubes, 8)[:, (6, 4)] -> (num_cubes, 6, 4) + cells = cube_verts[:, tet_pattern].reshape(-1, 4) return Mesh(points=points, cells=cells) diff --git a/physicsnemo/mesh/projections/__init__.py b/physicsnemo/mesh/projections/__init__.py new file mode 100644 index 0000000000..2b2ecb8ba2 --- /dev/null +++ b/physicsnemo/mesh/projections/__init__.py @@ -0,0 +1,27 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Projection operations for mesh extrusion, embedding, and spatial dimension manipulation. + +This module provides functionality for: +- Embedding meshes in higher-dimensional spaces (non-destructive) +- Projecting meshes to lower-dimensional spaces (lossy) +- Extruding manifolds to higher dimensions +""" + +from physicsnemo.mesh.projections._embed import embed +from physicsnemo.mesh.projections._extrude import extrude +from physicsnemo.mesh.projections._project import project diff --git a/physicsnemo/mesh/projections/_embed.py b/physicsnemo/mesh/projections/_embed.py new file mode 100644 index 0000000000..f1a83e6776 --- /dev/null +++ b/physicsnemo/mesh/projections/_embed.py @@ -0,0 +1,196 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Spatial dimension embedding operations.""" + +import torch + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.utilities._cache import CACHE_KEY + + +def embed( + mesh: Mesh, + target_n_spatial_dims: int, + *, + insert_at: int | None = None, +) -> Mesh: + """Embed a mesh into a higher-dimensional ambient space. + + Increases the spatial dimensionality of a mesh by inserting new zero-valued + coordinate dimensions, while preserving the manifold structure and topology. + This operation is non-destructive: the original coordinate values are retained + in their respective dimensions. + + Key behaviors: + - Manifold dimension (n_manifold_dims) is preserved + - Topology (cell connectivity) is preserved + - Point/cell/global data are preserved as-is + - Cached geometric properties are cleared (they depend on spatial embedding) + + Use cases: + - [2, 2] -> [2, 3]: Embed a flat 2D surface into 3D space + (e.g., to enable surface normal computation via codimension-1) + - [1, 2] -> [1, 3]: Embed a 2D curve into 3D space + - [2, 3] -> [2, 4]: Embed a 3D surface into 4D space + + Parameters + ---------- + mesh : Mesh + Input mesh to embed. + target_n_spatial_dims : int + Target number of spatial dimensions. Must be >= current n_spatial_dims. + If equal to current, returns mesh unchanged (no-op). + insert_at : int | None, optional + Index at which to insert the new zero-valued dimensions. The new + dimensions form a contiguous block starting at this position, with + semantics matching ``list.insert``. Valid range is + ``0 <= insert_at <= n_current_spatial_dims``. + + - ``None`` (default): append new dimensions at the end. + ``[x, y] -> [x, y, 0]`` + - ``0``: prepend new dimensions at the start. + ``[x, y] -> [0, x, y]`` + - ``1``: insert new dimensions after the first coordinate. + ``[x, y] -> [x, 0, y]`` + + Returns + ------- + Mesh + New mesh with increased spatial dimensions: + - points shape: ``(n_points, target_n_spatial_dims)`` + - n_manifold_dims: unchanged + - cells: unchanged + - point_data, cell_data: preserved (non-cached fields only) + - Cached geometric properties: cleared + + Raises + ------ + ValueError + If ``target_n_spatial_dims < 1``. + ValueError + If ``target_n_spatial_dims < current n_spatial_dims`` (use + :func:`project` to reduce dimensions). + ValueError + If ``insert_at`` is out of the valid range ``[0, n_spatial_dims]``. + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh import Mesh + >>> from physicsnemo.mesh.projections import embed + >>> points_2d = torch.tensor([[0., 0.], [1., 0.], [0., 1.]]) + >>> cells = torch.tensor([[0, 1, 2]]) + >>> mesh_2d = Mesh(points=points_2d, cells=cells) + >>> + >>> # Embed in 3D (default: append z=0) + >>> mesh_3d = embed(mesh_2d, target_n_spatial_dims=3) + >>> assert mesh_3d.points.shape == (3, 3) + >>> assert torch.allclose(mesh_3d.points[:, 2], torch.zeros(3)) + >>> + >>> # Embed with new dimension inserted at position 1: [x, y] -> [x, 0, y] + >>> mesh_3d_mid = embed(mesh_2d, target_n_spatial_dims=3, insert_at=1) + >>> assert torch.allclose(mesh_3d_mid.points[:, 0], points_2d[:, 0]) + >>> assert torch.allclose(mesh_3d_mid.points[:, 1], torch.zeros(3)) + >>> assert torch.allclose(mesh_3d_mid.points[:, 2], points_2d[:, 1]) + >>> + >>> # Codimension changes affect normal computation + >>> assert mesh_2d.codimension == 0 # no normals defined + >>> assert mesh_3d.codimension == 1 # normals now defined! + >>> assert mesh_3d.cell_normals.shape == (1, 3) + + Notes + ----- + When spatial dimensions change, all cached geometric properties are cleared + because they depend on the spatial embedding. This includes: + - Cell/point normals (codimension changes) + - Cell centroids (coordinate count changes) + - Cell areas (intrinsically unchanged but cache is cleared for consistency) + - Curvature values (depend on embedding) + + User data in ``point_data`` and ``cell_data`` is preserved as-is. If you have + vector fields that should also be padded, you must handle this manually. + + See Also + -------- + project : The inverse operation - reduce spatial dimensions. + """ + ### Validate inputs + if target_n_spatial_dims < 1: + raise ValueError( + f"target_n_spatial_dims must be >= 1, got {target_n_spatial_dims=}" + ) + + current_n_spatial_dims = mesh.n_spatial_dims + + if target_n_spatial_dims < current_n_spatial_dims: + raise ValueError( + f"Cannot embed: {target_n_spatial_dims=} < current " + f"{current_n_spatial_dims=}. Use project() to reduce spatial dimensions." + ) + + ### Short-circuit if no change needed + if target_n_spatial_dims == current_n_spatial_dims: + return mesh + + n_new_dims = target_n_spatial_dims - current_n_spatial_dims + + ### Validate insert_at + if insert_at is not None and not (0 <= insert_at <= current_n_spatial_dims): + raise ValueError( + f"insert_at must be in [0, {current_n_spatial_dims}], got {insert_at=}" + ) + + ### Construct new points array + if insert_at is None or insert_at == current_n_spatial_dims: + # Append zeros at end (fast path) + new_points = torch.nn.functional.pad( + mesh.points, (0, n_new_dims), mode="constant", value=0.0 + ) + elif insert_at == 0: + # Prepend zeros at start (fast path) + new_points = torch.nn.functional.pad( + mesh.points, (n_new_dims, 0), mode="constant", value=0.0 + ) + else: + # Insert zeros at arbitrary interior position + prefix = mesh.points[:, :insert_at] + zeros = torch.zeros( + mesh.n_points, + n_new_dims, + dtype=mesh.points.dtype, + device=mesh.points.device, + ) + suffix = mesh.points[:, insert_at:] + new_points = torch.cat([prefix, zeros, suffix], dim=1) + + ### Preserve cells (topology unchanged) + new_cells = mesh.cells + + ### Preserve user data, but clear cached properties + # Cached properties depend on spatial embedding and must be recomputed + new_point_data = mesh.point_data.exclude(CACHE_KEY) + new_cell_data = mesh.cell_data.exclude(CACHE_KEY) + new_global_data = mesh.global_data + + ### Create new mesh with modified spatial dimensions + return Mesh( + points=new_points, + cells=new_cells, + point_data=new_point_data, + cell_data=new_cell_data, + global_data=new_global_data, + ) diff --git a/physicsnemo/mesh/projections/_extrude.py b/physicsnemo/mesh/projections/_extrude.py new file mode 100644 index 0000000000..7d67662947 --- /dev/null +++ b/physicsnemo/mesh/projections/_extrude.py @@ -0,0 +1,311 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Extrusion operations for generating higher-dimensional meshes.""" + +import torch +from tensordict import TensorDict + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.projections._embed import embed +from physicsnemo.mesh.utilities._cache import CACHE_KEY + + +def extrude( + mesh: Mesh, + vector: torch.Tensor | list | tuple | None = None, + capping: bool = False, + allow_new_spatial_dims: bool = False, +) -> Mesh: + """Extrude an N-dimensional mesh into an (N+1)-dimensional mesh. + + Extrusion sweeps a mesh along a direction to produce a mesh one manifold + dimension higher - analogous to pushing a 2D cookie-cutter shape through + space to create a solid 3D object. Each N-simplex in the input is swept into + a prism and then tessellated into (N+1) child (N+1)-simplices. + + Common use cases: + - **3D text and shapes**: extrude a 2D triangulated outline to create a + solid tetrahedral volume (used by ``text_3d_3d`` in this library). + - **Boundary layer meshing**: sweep a surface mesh along its normals to + create a thin volumetric layer for near-wall CFD resolution. + - **Space-time meshes**: extrude a spatial mesh along a time axis for + space-time finite element discretizations. + - **Structured mesh generation**: create 3D meshes from 2D cross-sections + (e.g., a pipe from a circle, a channel from a rectangle). + + Dimensional behavior: + - [N, M] -> [N+1, M]: Default case where M >= N+1 + (e.g., 2D surface in 3D -> 3D volume in 3D) + - [N, M] -> [N+1, N+1]: When M < N+1 and ``allow_new_spatial_dims=True``, + spatial dimensions are extended automatically. + + Parameters + ---------- + mesh : Mesh + Input mesh to extrude. Can be any manifold dimension N in any spatial + dimension M >= N. + vector : torch.Tensor | list | tuple | None, optional + Extrusion direction and magnitude, shape ``(n_spatial_dims,)`` or + broadcastable. If ``None``, defaults to a unit vector along the last + spatial dimension: ``[0, 0, ..., 0, 1]``. For meshes where N+1 > M + and ``allow_new_spatial_dims=True``, the default vector has shape + ``(N+1,)`` with the last component set to 1. + capping : bool, optional + If True, cap the top and bottom of the extrusion to create a closed + volume. Currently not implemented. + allow_new_spatial_dims : bool, optional + If True, allows extrusion to add new spatial dimensions when + ``n_manifold_dims + 1 > n_spatial_dims``. The point coordinates are + padded with zeros in the new dimensions (via :func:`embed`). If False + (default), raises ``ValueError`` when spatial dimensions are insufficient. + + Returns + ------- + Mesh + Extruded mesh with: + - ``n_manifold_dims = original_n_manifold_dims + 1`` + - ``n_spatial_dims = max(original_n_spatial_dims, n_manifold_dims)`` if + ``allow_new_spatial_dims=True``, else ``original_n_spatial_dims`` + - ``n_points = 2 * original_n_points`` (original + extruded copies) + - ``n_cells = (original_n_manifold_dims + 1) * original_n_cells`` + + Raises + ------ + ValueError + If ``n_manifold_dims + 1 > n_spatial_dims`` and + ``allow_new_spatial_dims=False``. + NotImplementedError + If ``capping=True`` (not yet implemented). + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh import Mesh + >>> # Extrude a triangle (2D) in 3D space to create a triangular prism + >>> # tessellated into 3 tetrahedra + >>> points = torch.tensor([[0., 0., 0.], [1., 0., 0.], [0., 1., 0.]]) + >>> cells = torch.tensor([[0, 1, 2]]) + >>> mesh = Mesh(points=points, cells=cells) + >>> extruded = extrude(mesh, vector=[0., 0., 1.]) + >>> assert extruded.n_manifold_dims == 3 # tetrahedra + >>> assert extruded.n_cells == 3 # one triangle -> three tetrahedra + >>> + >>> # Extrude an edge (1D) in 2D space to create triangles + >>> points = torch.tensor([[0., 0.], [1., 0.]]) + >>> cells = torch.tensor([[0, 1]]) + >>> mesh = Mesh(points=points, cells=cells) + >>> extruded = extrude(mesh, vector=[0., 1.]) + >>> assert extruded.n_manifold_dims == 2 # triangles + >>> assert extruded.n_cells == 2 # one edge -> two triangles + >>> + >>> # Extrude a 2D surface in 2D space into 3D (auto-extending spatial dims) + >>> points_2d = torch.tensor([[0., 0.], [1., 0.], [0., 1.]]) + >>> triangles = torch.tensor([[0, 1, 2]]) + >>> mesh_2d = Mesh(points_2d, triangles) # [2, 2] mesh + >>> extruded = extrude(mesh_2d, allow_new_spatial_dims=True) + >>> assert extruded.n_spatial_dims == 3 # new dimension added + + Notes + ----- + The tessellation pattern for an N-simplex with vertices [v0, v1, ..., vN] + creates (N+1) child (N+1)-simplices: + - Child i has vertices: [v0', v1', ..., vi', vi, vi+1, ..., vN] + where primed vertices (v') are the extruded copies (offset by the extrusion + vector). + + This tessellation preserves orientation and creates a valid simplicial complex. + """ + ### Validate inputs + if capping: + raise NotImplementedError("Capping is not yet implemented. Use capping=False.") + + ### Determine target spatial dimensions and construct extrusion vector + n_manifold_dims = mesh.n_manifold_dims + n_spatial_dims = mesh.n_spatial_dims + target_manifold_dims = n_manifold_dims + 1 + + # Check if we have enough spatial dimensions for the extruded manifold + if target_manifold_dims > n_spatial_dims: + if not allow_new_spatial_dims: + raise ValueError( + f"Cannot extrude {n_manifold_dims=}-dimensional manifold in {n_spatial_dims=}-dimensional space " + f"to {target_manifold_dims=}-dimensional manifold without increasing spatial dimensions.\n" + f"Set allow_new_spatial_dims=True to add new spatial dimensions, or provide a custom vector." + ) + # Extend spatial dimensions to accommodate extruded manifold + target_spatial_dims = target_manifold_dims + else: + target_spatial_dims = n_spatial_dims + + # Construct or validate extrusion vector + if vector is None: + # Default: [0, 0, ..., 0, 1] in target spatial dimensions + vector_tensor = torch.zeros( + target_spatial_dims, + dtype=mesh.points.dtype, + device=mesh.points.device, + ) + vector_tensor[-1] = 1.0 + else: + # Convert to tensor if needed (torch.as_tensor avoids copies when possible) + vector_tensor = torch.as_tensor( + vector, + dtype=mesh.points.dtype, + device=mesh.points.device, + ) + + # Validate vector shape + if vector_tensor.ndim != 1: + raise ValueError( + f"Extrusion vector must be 1D, got {vector_tensor.ndim=} with {vector_tensor.shape=}" + ) + + ### Pad mesh spatial dimensions if needed (delegate to embed) + if target_spatial_dims > n_spatial_dims: + mesh = embed(mesh, target_spatial_dims) + + original_points = mesh.points + + # Ensure vector has correct shape for broadcasting + if vector_tensor.shape[0] != target_spatial_dims: + if vector_tensor.shape[0] < target_spatial_dims: + # Pad vector with zeros + padding_width = target_spatial_dims - vector_tensor.shape[0] + vector_tensor = torch.nn.functional.pad( + vector_tensor, + (0, padding_width), + mode="constant", + value=0.0, + ) + else: + raise ValueError( + f"Extrusion vector has {vector_tensor.shape[0]} dimensions but " + f"target spatial dimensions are {target_spatial_dims}" + ) + + ### Create extruded points + extruded_points = original_points + vector_tensor.unsqueeze(0) + + # Concatenate: [original_points, extruded_points] + all_points = torch.cat([original_points, extruded_points], dim=0) + + ### Tessellate cells + # Each N-simplex becomes (N+1) child (N+1)-simplices + # For parent cell with vertices [v0, v1, ..., vN]: + # Child i: [v0', v1', ..., vi', vi, vi+1, ..., vN] + # where vi' = vi + n_original_points (extruded vertex index) + + n_original_points = mesh.n_points + n_original_cells = mesh.n_cells + n_vertices_per_parent = n_manifold_dims + 1 # N+1 vertices in N-simplex + n_children_per_parent = n_manifold_dims + 1 # N+1 children from each parent + n_vertices_per_child = target_manifold_dims + 1 # (N+1)+1 vertices in (N+1)-simplex + + if n_original_cells == 0: + # Empty mesh: no cells to extrude + extruded_cells = torch.empty( + (0, n_vertices_per_child), + dtype=mesh.cells.dtype, + device=mesh.cells.device, + ) + else: + # Preallocate child cells array + extruded_cells = torch.zeros( + (n_original_cells * n_children_per_parent, n_vertices_per_child), + dtype=mesh.cells.dtype, + device=mesh.cells.device, + ) + + # Vectorized tessellation + # For each parent cell, generate all children simultaneously + parent_cells = mesh.cells # Shape: (n_cells, n_vertices_per_parent) + + # NOTE: This loop iterates over child indices (bounded by simplex + # dimension, not mesh size), so the iteration count is small (e.g. 3 + # for triangles -> tetrahedra). For higher performance on very high- + # dimensional simplices, this could be vectorized using a precomputed + # tessellation pattern + torch.gather, similar to generate_child_cells + # in subdivision/_topology.py. + for child_idx in range(n_children_per_parent): + # Child i has vertices: [v0', v1', ..., vi', vi, vi+1, ..., vN] + # Extruded part: v0', v1', ..., vi' (child_idx + 1 vertices) + # Original part: vi, vi+1, ..., vN (n_vertices_per_parent - child_idx vertices) + + child_vertices = [] + + # Add extruded vertices [v0', v1', ..., vi'] + for j in range(child_idx + 1): + extruded_vertex_indices = parent_cells[:, j] + n_original_points + child_vertices.append(extruded_vertex_indices) + + # Add original vertices [vi, vi+1, ..., vN] + for j in range(child_idx, n_vertices_per_parent): + original_vertex_indices = parent_cells[:, j] + child_vertices.append(original_vertex_indices) + + # Stack to form child cells: (n_cells, n_vertices_per_child) + child_cells = torch.stack(child_vertices, dim=1) + + # Place in output array + start_idx = child_idx * n_original_cells + end_idx = (child_idx + 1) * n_original_cells + extruded_cells[start_idx:end_idx] = child_cells + + ### Propagate data (excluding cached properties, which depend on geometry) + filtered_point_data = mesh.point_data.exclude(CACHE_KEY) + filtered_cell_data = mesh.cell_data.exclude(CACHE_KEY) + + # Point data: concatenate original and copy for extruded points + if len(filtered_point_data.keys()) > 0: + extruded_point_data = TensorDict.cat( + [filtered_point_data, filtered_point_data.clone()], + dim=0, + ) + else: + extruded_point_data = TensorDict( + {}, + batch_size=torch.Size([all_points.shape[0]]), + device=all_points.device, + ) + + # Cell data: replicate each parent cell's data (N+1) times. + # Cells are ordered child-major: [c0_parent0, c0_parent1, ..., c1_parent0, ...], + # so the parent index for cell i is i % n_original_cells. Using .repeat() + # tiles the entire parent block N+1 times, producing the correct ordering. + if len(filtered_cell_data.keys()) > 0: + extruded_cell_data = filtered_cell_data.apply( + lambda t: t.repeat(n_children_per_parent, *([1] * (t.ndim - 1))), + batch_size=torch.Size([extruded_cells.shape[0]]), + ) + else: + extruded_cell_data = TensorDict( + {}, + batch_size=torch.Size([extruded_cells.shape[0]]), + device=extruded_cells.device, + ) + + # Global data: preserve unchanged + extruded_global_data = mesh.global_data + + ### Create and return extruded mesh + return Mesh( + points=all_points, + cells=extruded_cells, + point_data=extruded_point_data, + cell_data=extruded_cell_data, + global_data=extruded_global_data, + ) diff --git a/physicsnemo/mesh/projections/_project.py b/physicsnemo/mesh/projections/_project.py new file mode 100644 index 0000000000..cc88481b24 --- /dev/null +++ b/physicsnemo/mesh/projections/_project.py @@ -0,0 +1,206 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Spatial dimension projection operations.""" + +from collections.abc import Sequence + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.utilities._cache import CACHE_KEY + + +def project( + mesh: Mesh, + target_n_spatial_dims: int | None = None, + *, + keep_dims: Sequence[int] | None = None, +) -> Mesh: + """Project a mesh to a lower-dimensional ambient space. + + Reduces the spatial dimensionality of a mesh by discarding coordinate + dimensions. The manifold structure and topology are preserved, but coordinate + information in the removed dimensions is permanently lost. + + Two calling conventions are supported: + - ``project(mesh, target_n_spatial_dims=N)``: keep the first N dimensions. + - ``project(mesh, keep_dims=[i, j, ...])``: keep specific dimensions by + index, in the order they should appear in the output. + + Exactly one of ``target_n_spatial_dims`` or ``keep_dims`` must be specified. + + Key behaviors: + - Manifold dimension (n_manifold_dims) is preserved + - Topology (cell connectivity) is preserved + - Point/cell/global data are preserved as-is + - Cached geometric properties are cleared + - **Information in removed dimensions is discarded** + + Use cases: + - [2, 3] -> [2, 2]: Project a 3D surface to the xy-plane + - [1, 3] -> [1, 2]: Project a 3D curve down to 2D + - [2, 3] -> [2, 2] via ``keep_dims=[0, 2]``: Project to the xz-plane + + Parameters + ---------- + mesh : Mesh + Input mesh to project. + target_n_spatial_dims : int | None, optional + Target number of spatial dimensions. Keeps the first N dimensions. + Must be <= current n_spatial_dims and >= n_manifold_dims. + If equal to current, returns mesh unchanged (no-op). + keep_dims : Sequence[int] | None, optional + Indices of spatial dimensions to retain, in the order they should + appear in the output. For example, ``keep_dims=[0, 2]`` on a 3D mesh + produces a 2D mesh with coordinates ``[x, z]``. + + Returns + ------- + Mesh + New mesh with reduced spatial dimensions: + - points shape: ``(n_points, len(keep_dims))`` or + ``(n_points, target_n_spatial_dims)`` + - n_manifold_dims: unchanged + - cells: unchanged + - point_data, cell_data: preserved (non-cached fields only) + - Cached geometric properties: cleared + + Raises + ------ + ValueError + If both or neither of ``target_n_spatial_dims`` and ``keep_dims`` + are specified. + ValueError + If ``target_n_spatial_dims > current n_spatial_dims`` (use + :func:`embed` to add dimensions). + ValueError + If any index in ``keep_dims`` is out of range. + ValueError + If the resulting number of spatial dimensions would be less than + ``n_manifold_dims``. + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh import Mesh + >>> from physicsnemo.mesh.projections import project + >>> points = torch.tensor([[0., 1., 2.], [3., 4., 5.]]) + >>> cells = torch.tensor([[0, 1]]) + >>> mesh = Mesh(points=points, cells=cells) + >>> + >>> # Keep first 2 dimensions (drop z) + >>> mesh_xy = project(mesh, target_n_spatial_dims=2) + >>> assert torch.allclose(mesh_xy.points, torch.tensor([[0., 1.], [3., 4.]])) + >>> + >>> # Keep x and z (drop y) using keep_dims + >>> mesh_xz = project(mesh, keep_dims=[0, 2]) + >>> assert torch.allclose(mesh_xz.points, torch.tensor([[0., 2.], [3., 5.]])) + + Notes + ----- + This operation is lossy: coordinate values in removed dimensions cannot be + recovered. If you need a reversible dimensionality change, use :func:`embed` + followed by :func:`project`, ensuring the projected dimensions contain only + values you added (e.g., zeros from embedding). + + When spatial dimensions change, all cached geometric properties are cleared + because they depend on the spatial embedding (normals, centroids, areas, + curvature). User data in ``point_data`` and ``cell_data`` is preserved as-is. + + See Also + -------- + embed : The inverse operation - add spatial dimensions. + """ + ### Validate mutually exclusive arguments + if target_n_spatial_dims is not None and keep_dims is not None: + raise ValueError( + "Specify exactly one of target_n_spatial_dims or keep_dims, not both." + ) + if target_n_spatial_dims is None and keep_dims is None: + raise ValueError("Must specify either target_n_spatial_dims or keep_dims.") + + current_n_spatial_dims = mesh.n_spatial_dims + + ### Resolve keep_dims from the chosen calling convention + if keep_dims is not None: + keep_dims_list = list(keep_dims) + result_n_dims = len(keep_dims_list) + + # Validate all indices are in range + for idx in keep_dims_list: + if not (0 <= idx < current_n_spatial_dims): + raise ValueError( + f"keep_dims contains index {idx}, but mesh has only " + f"{current_n_spatial_dims} spatial dimensions " + f"(valid range: 0 to {current_n_spatial_dims - 1})." + ) + else: + if ( + target_n_spatial_dims is None + ): # pragma: no cover — unreachable after validation above + raise ValueError( + "target_n_spatial_dims must not be None when keep_dims is None." + ) + + if target_n_spatial_dims < 1: + raise ValueError( + f"target_n_spatial_dims must be >= 1, got {target_n_spatial_dims=}" + ) + + if target_n_spatial_dims > current_n_spatial_dims: + raise ValueError( + f"Cannot project: {target_n_spatial_dims=} > current " + f"{current_n_spatial_dims=}. Use embed() to add spatial dimensions." + ) + + # Short-circuit: no-op if dimensions already match + if target_n_spatial_dims == current_n_spatial_dims: + return mesh + + keep_dims_list = list(range(target_n_spatial_dims)) + result_n_dims = target_n_spatial_dims + + ### Validate result has enough dims for the manifold + if result_n_dims < mesh.n_manifold_dims: + raise ValueError( + f"Cannot project to {result_n_dims} spatial dimensions: mesh has " + f"n_manifold_dims={mesh.n_manifold_dims}, and spatial dimensions " + f"must be >= manifold dimensions." + ) + + ### Short-circuit: identity mapping (keep all dims in original order) + if keep_dims_list == list(range(current_n_spatial_dims)): + return mesh + + ### Construct new points by indexing selected dimensions + new_points = mesh.points[:, keep_dims_list] + + ### Preserve cells (topology unchanged) + new_cells = mesh.cells + + ### Preserve user data, but clear cached properties + # Cached properties depend on spatial embedding and must be recomputed + new_point_data = mesh.point_data.exclude(CACHE_KEY) + new_cell_data = mesh.cell_data.exclude(CACHE_KEY) + new_global_data = mesh.global_data + + ### Create new mesh with modified spatial dimensions + return Mesh( + points=new_points, + cells=new_cells, + point_data=new_point_data, + cell_data=new_cell_data, + global_data=new_global_data, + ) diff --git a/physicsnemo/mesh/remeshing/__init__.py b/physicsnemo/mesh/remeshing/__init__.py new file mode 100644 index 0000000000..74770db876 --- /dev/null +++ b/physicsnemo/mesh/remeshing/__init__.py @@ -0,0 +1,45 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Uniform mesh remeshing via clustering. + +This module provides dimension-agnostic uniform remeshing based on the ACVD +(Approximate Centroidal Voronoi Diagram) clustering algorithm. It works for +arbitrary n-dimensional simplicial manifolds. + +The algorithm: +1. Weights vertices by incident cell areas +2. Initializes clusters via area-based region growing +3. Removes spatially isolated cluster regions +4. Reconstructs a simplified mesh from cluster adjacency + +The output mesh has approximately uniform cell distribution with ~0.5% non-manifold +edges (multiple faces sharing an edge), which is inherent to the face-mapping approach. + +Current limitations: +- Energy minimization is disabled (made topology worse; needs investigation) +- Small percentage (~0.5-1%) of edges may be non-manifold with moderate cluster counts +- Higher cluster counts relative to mesh resolution produce better manifold quality + +Example: + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> mesh = sphere_icosahedral.load(subdivisions=3) + >>> # Remesh a triangle mesh to ~100 triangles + >>> remeshed = remesh(mesh, n_clusters=100) + >>> assert remeshed.n_cells > 0 +""" + +from physicsnemo.mesh.remeshing._remeshing import remesh diff --git a/physicsnemo/mesh/remeshing/_remeshing.py b/physicsnemo/mesh/remeshing/_remeshing.py new file mode 100644 index 0000000000..a0715fa4b4 --- /dev/null +++ b/physicsnemo/mesh/remeshing/_remeshing.py @@ -0,0 +1,95 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Main remeshing entry point. + +This module wires together all components of the remeshing pipeline. +""" + +from typing import TYPE_CHECKING + +from physicsnemo.core.version_check import require_version_spec + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +@require_version_spec("pyacvd") +def remesh( + mesh: "Mesh", + n_clusters: int, +) -> "Mesh": + """Uniform remeshing via clustering (dimension-agnostic). + + Creates a simplified mesh with approximately n_clusters cells uniformly + distributed across the geometry. Uses the ACVD (Approximate Centroidal + Voronoi Diagram) clustering algorithm. + + The algorithm: + 1. Weights vertices by their dual volumes (Voronoi areas) + 2. Initializes clusters via area-based region growing + 3. Minimizes energy by iteratively reassigning vertices + 4. Reconstructs a simplified mesh from cluster adjacency + + This works for arbitrary manifold dimensions (1D curves, 2D surfaces, + 3D volumes, etc.) in arbitrary embedding spaces. + + Parameters + ---------- + mesh : Mesh + Input mesh to remesh + n_clusters : int + Target number of output cells. The actual number may vary + slightly depending on mesh topology. + + Returns + ------- + Mesh + Remeshed mesh with approximately n_clusters cells. The vertices are + cluster centroids, and cells connect adjacent clusters. + + Raises + ------ + ValueError + If n_clusters <= 0 or weights have wrong shape + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> from physicsnemo.mesh.remeshing import remesh + >>> mesh = sphere_icosahedral.load(subdivisions=3) + >>> # Remesh a triangle mesh to ~100 triangles + >>> simplified = remesh(mesh, n_clusters=100) + >>> assert simplified.n_cells > 0 + + Notes + ----- + - Works for 1D, 2D, 3D, and higher-dimensional manifolds + - Preserves mesh topology qualitatively but not quantitatively + - Point and cell data are not transferred (topology changes fundamentally) + - Output cell orientation may differ from input + """ + import importlib + + from physicsnemo.mesh.io.io_pyvista import from_pyvista, to_pyvista + from physicsnemo.mesh.repair import repair_mesh + + pyacvd = importlib.import_module("pyacvd") + clustering = pyacvd.Clustering(to_pyvista(mesh)) + clustering.cluster(n_clusters) + new_mesh = from_pyvista(clustering.create_mesh()) + new_mesh, stats = repair_mesh(new_mesh) + return new_mesh diff --git a/physicsnemo/mesh/repair/__init__.py b/physicsnemo/mesh/repair/__init__.py new file mode 100644 index 0000000000..ab8e7e52e0 --- /dev/null +++ b/physicsnemo/mesh/repair/__init__.py @@ -0,0 +1,33 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Mesh repair and cleanup utilities. + +Tools for fixing common mesh problems including duplicates, degenerates, +holes, and orientation issues. +""" + +from physicsnemo.mesh.repair._cleaning import ( + clean_mesh, + merge_duplicate_points, + remove_duplicate_cells, + remove_isolated_points, + remove_unused_points, +) +from physicsnemo.mesh.repair.degenerate_removal import remove_degenerate_cells +from physicsnemo.mesh.repair.hole_filling import fill_holes +from physicsnemo.mesh.repair.orientation import fix_orientation +from physicsnemo.mesh.repair.pipeline import repair_mesh diff --git a/physicsnemo/mesh/repair/_cleaning.py b/physicsnemo/mesh/repair/_cleaning.py new file mode 100644 index 0000000000..1a044ef19d --- /dev/null +++ b/physicsnemo/mesh/repair/_cleaning.py @@ -0,0 +1,523 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Mesh cleaning operations. + +This module provides functions to clean and repair meshes: +- Merge duplicate points within tolerance +- Remove duplicate cells +- Remove unused points +- Remove isolated points (mesh-level wrapper) +""" + +from typing import TYPE_CHECKING + +import torch +from tensordict import TensorDict + +from physicsnemo.mesh.utilities._cache import CACHE_KEY +from physicsnemo.mesh.utilities._duplicate_detection import compute_canonical_indices +from physicsnemo.mesh.utilities._scatter_ops import scatter_aggregate + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def merge_duplicate_points( + points: torch.Tensor, # shape: (n_points, n_spatial_dims) + cells: torch.Tensor, # shape: (n_cells, n_vertices_per_cell) + point_data: TensorDict, + tolerance: float = 1e-12, +) -> tuple[torch.Tensor, torch.Tensor, TensorDict, torch.Tensor]: + """Merge duplicate points within tolerance. + + Points whose L2 distance is below *tolerance* are merged into a single + representative, and cell connectivity is updated accordingly. + + Parameters + ---------- + points : torch.Tensor + Point coordinates, shape (n_points, n_spatial_dims). + cells : torch.Tensor + Cell connectivity, shape (n_cells, n_vertices_per_cell). + point_data : TensorDict + Point data to merge (values are averaged across merged groups). + tolerance : float, optional + Absolute L2 distance threshold for considering two points as + duplicates. + + Returns + ------- + merged_points : torch.Tensor + Deduplicated points, shape (n_unique_points, n_spatial_dims). + updated_cells : torch.Tensor + Updated cell connectivity, shape (n_cells, n_vertices_per_cell). + merged_point_data : TensorDict + Averaged point data for merged points. + point_mapping : torch.Tensor + Mapping from old to new point indices, shape (n_points,). + + Examples + -------- + >>> import torch + >>> from tensordict import TensorDict + >>> # Two points at same location + >>> points = torch.tensor([[0., 0.], [1., 0.], [0., 0.]]) + >>> cells = torch.tensor([[0, 1], [1, 2]]) + >>> merged_points, updated_cells, _, mapping = merge_duplicate_points( + ... points, cells, TensorDict({}, batch_size=[3]) + ... ) + >>> # Points 0 and 2 are merged + >>> assert len(merged_points) == 2 + >>> assert torch.equal(mapping, torch.tensor([0, 1, 0])) + """ + n_points = len(points) + device = points.device + + if n_points == 0: + return ( + points, + cells, + point_data, + torch.arange(0, device=device, dtype=torch.int64), + ) + + ### Compute canonical indices via shared BVH-based primitive + point_mapping = compute_canonical_indices(points, tolerance) + + ### Get unique points and remap connectivity + unique_indices = torch.unique(point_mapping) + n_unique = len(unique_indices) + + ### Create reverse mapping from old unique indices to new compact indices + reverse_mapping = torch.zeros(n_points, device=device, dtype=torch.int64) + reverse_mapping[unique_indices] = torch.arange( + n_unique, device=device, dtype=torch.int64 + ) + + ### Apply reverse mapping to point_mapping to get final compact indices + final_point_mapping = reverse_mapping[point_mapping] + + ### Extract merged points + merged_points = points[unique_indices] + + ### Update cell connectivity + updated_cells = final_point_mapping[cells] + + ### Merge point data by averaging + merged_point_data = _merge_point_data( + point_data=point_data, + point_mapping=point_mapping, + unique_indices=unique_indices, + n_unique=n_unique, + ) + + return merged_points, updated_cells, merged_point_data, final_point_mapping + + +def _merge_point_data( + point_data: TensorDict, + point_mapping: torch.Tensor, + unique_indices: torch.Tensor, + n_unique: int, +) -> TensorDict: + """Merge point data by averaging over merged points. + + Parameters + ---------- + point_data : TensorDict + Original point data + point_mapping : torch.Tensor + Mapping from original to merged points + unique_indices : torch.Tensor + Indices of unique points in original array + n_unique : int + Number of unique points + + Returns + ------- + TensorDict + Merged point data + """ + if len(point_data.keys()) == 0: + return TensorDict( + {}, + batch_size=torch.Size([n_unique]), + device=point_data.device, + ) + + ### Create reverse mapping: unique_indices[i] corresponds to output index i + device = point_mapping.device + reverse_map = torch.zeros(len(point_mapping), dtype=torch.int64, device=device) + reverse_map[unique_indices] = torch.arange( + n_unique, device=device, dtype=torch.int64 + ) + + ### Get output indices for all input points + output_indices = reverse_map[point_mapping] + + ### For each unique point, average the data from all points that map to it + def _merge_tensor(tensor: torch.Tensor) -> torch.Tensor: + ### Use scatter aggregation utility + return scatter_aggregate( + src_data=tensor, + src_to_dst_mapping=output_indices, + n_dst=n_unique, + weights=None, + aggregation="mean", + ) + + return point_data.apply( + _merge_tensor, + batch_size=torch.Size([n_unique]), + ) + + +def remove_duplicate_cells( + cells: torch.Tensor, # shape: (n_cells, n_vertices_per_cell) + cell_data: TensorDict, +) -> tuple[torch.Tensor, TensorDict]: + """Remove duplicate cells from mesh. + + Cells are considered duplicates if they contain the same set of vertex indices + (regardless of order). When duplicates are found, only the first occurrence is kept. + + Parameters + ---------- + cells : torch.Tensor + Cell connectivity, shape (n_cells, n_vertices_per_cell) + cell_data : TensorDict + Cell data + + Returns + ------- + unique_cells : torch.Tensor + Deduplicated cells, shape (n_unique_cells, n_vertices_per_cell) + unique_cell_data : TensorDict + Cell data for unique cells + + Examples + -------- + >>> import torch + >>> from tensordict import TensorDict + >>> # Two cells with same vertices + >>> cells = torch.tensor([[0, 1, 2], [1, 0, 2], [3, 4, 5]]) + >>> unique_cells, _ = remove_duplicate_cells( + ... cells, TensorDict({}, batch_size=[3]) + ... ) + >>> assert len(unique_cells) == 2 # cells 0 and 1 are duplicates + """ + if len(cells) == 0: + return cells, cell_data + + ### Sort vertices within each cell to canonical form + sorted_cells = torch.sort(cells, dim=-1)[0] + + ### Find unique cells using vectorized first-occurrence detection + n_cells = len(cells) + device = cells.device + + ### Use torch.unique to identify duplicate groups + # inverse_indices maps each cell to its unique group + _, inverse_indices = torch.unique( + sorted_cells, + dim=0, + return_inverse=True, + ) + + ### Vectorized first-occurrence detection + # Sort cell indices by their inverse_indices to group duplicates together + # Then mark only the first cell in each group + sorted_order = torch.argsort(inverse_indices, stable=True) + sorted_inverse = inverse_indices[sorted_order] + + # Find group boundaries: where the group ID changes + # First element is always a boundary (first occurrence) + is_first_in_group = torch.cat( + [ + torch.tensor([True], device=device), + sorted_inverse[1:] != sorted_inverse[:-1], + ] + ) + + # Map back to original indices: first_occurrence_indices are the cells to keep + first_occurrence_indices = sorted_order[is_first_in_group] + + # Build keep_mask from first occurrences + keep_mask = torch.zeros(n_cells, dtype=torch.bool, device=device) + keep_mask[first_occurrence_indices] = True + + ### Filter cells and data + unique_cells = cells[keep_mask] + unique_cell_data = ( + cell_data[keep_mask] + if len(cell_data.keys()) > 0 + else TensorDict( + {}, + batch_size=torch.Size([keep_mask.sum().item()]), + device=cell_data.device, + ) + ) + + return unique_cells, unique_cell_data + + +def remove_unused_points( + points: torch.Tensor, # shape: (n_points, n_spatial_dims) + cells: torch.Tensor, # shape: (n_cells, n_vertices_per_cell) + point_data: TensorDict, +) -> tuple[torch.Tensor, torch.Tensor, TensorDict, torch.Tensor]: + """Remove points that are not referenced by any cell. + + Parameters + ---------- + points : torch.Tensor + Point coordinates, shape (n_points, n_spatial_dims) + cells : torch.Tensor + Cell connectivity, shape (n_cells, n_vertices_per_cell) + point_data : TensorDict + Point data + + Returns + ------- + used_points : torch.Tensor + Points that are used by cells, shape (n_used_points, n_spatial_dims) + updated_cells : torch.Tensor + Updated cell connectivity, shape (n_cells, n_vertices_per_cell) + used_point_data : TensorDict + Point data for used points + point_mapping : torch.Tensor + Mapping from old to new point indices, shape (n_points,) + Unused points map to -1 + + Examples + -------- + >>> import torch + >>> from tensordict import TensorDict + >>> points = torch.tensor([[0., 0.], [1., 0.], [0., 1.], [2., 2.]]) + >>> cells = torch.tensor([[0, 1, 2]]) # Point 3 is unused + >>> used_points, updated_cells, _, mapping = remove_unused_points( + ... points, cells, TensorDict({}, batch_size=[4]) + ... ) + >>> assert len(used_points) == 3 + >>> assert torch.equal(mapping, torch.tensor([0, 1, 2, -1])) + """ + n_points = len(points) + device = points.device + + if len(cells) == 0: + ### No cells means no points are used + return ( + torch.empty((0, points.shape[1]), dtype=points.dtype, device=device), + cells, + TensorDict({}, batch_size=torch.Size([0]), device=device), + torch.full((n_points,), -1, dtype=torch.int64, device=device), + ) + + ### Find which points are used by cells + used_mask = torch.zeros(n_points, dtype=torch.bool, device=device) + used_mask.scatter_(0, cells.flatten(), True) + + ### Get indices of used points + used_indices = torch.where(used_mask)[0] + n_used = len(used_indices) + + ### Create mapping from old to new indices + point_mapping = torch.full((n_points,), -1, dtype=torch.int64, device=device) + point_mapping[used_indices] = torch.arange(n_used, device=device, dtype=torch.int64) + + ### Extract used points and data + used_points = points[used_indices] + used_point_data = ( + point_data[used_indices] + if len(point_data.keys()) > 0 + else TensorDict( + {}, + batch_size=torch.Size([n_used]), + device=device, + ) + ) + + ### Update cell connectivity + updated_cells = point_mapping[cells] + + return used_points, updated_cells, used_point_data, point_mapping + + +def clean_mesh( + mesh: "Mesh", + tolerance: float = 1e-12, + merge_points: bool = True, + deduplicate_cells: bool = True, + drop_unused_points: bool = True, +) -> tuple["Mesh", dict]: + """Clean and repair a mesh. + + Performs various cleaning operations to fix common mesh issues: + 1. Merge duplicate points within tolerance + 2. Remove duplicate cells + 3. Remove unused points + + Parameters + ---------- + mesh : Mesh + Input mesh to clean. + tolerance : float, optional + Absolute L2 distance threshold for merging duplicate points. + merge_points : bool, optional + Whether to merge duplicate points. + deduplicate_cells : bool, optional + Whether to remove duplicate cells. + drop_unused_points : bool, optional + Whether to remove unused points. + + Returns + ------- + tuple[Mesh, dict] + Tuple of (cleaned_mesh, stats) where stats tracks what was done: + - ``"n_points_before_merge"`` / ``"n_points_after_merge"`` + - ``"n_cells_before_dedup"`` / ``"n_cells_after_dedup"`` + - ``"n_points_before_drop"`` / ``"n_points_after_drop"`` + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh import Mesh + >>> # Mesh with duplicate points + >>> points = torch.tensor([[0., 0.], [1., 0.], [0., 0.], [1., 1.]]) + >>> cells = torch.tensor([[0, 1, 3], [2, 1, 3]]) + >>> mesh = Mesh(points=points, cells=cells) + >>> cleaned, stats = clean_mesh(mesh) + >>> assert cleaned.n_points == 3 # points 0 and 2 merged + """ + points = mesh.points + cells = mesh.cells + point_data = mesh.point_data.exclude(CACHE_KEY) + cell_data = mesh.cell_data.exclude(CACHE_KEY) + global_data = mesh.global_data + stats: dict = {} + + ### Step 1: Merge duplicate points + if merge_points: + n_before = points.shape[0] + points, cells, point_data, _ = merge_duplicate_points( + points=points, + cells=cells, + point_data=point_data, + tolerance=tolerance, + ) + stats["n_points_before_merge"] = n_before + stats["n_points_after_merge"] = points.shape[0] + + ### Step 2: Remove duplicate cells + if deduplicate_cells: + n_before = cells.shape[0] + cells, cell_data = remove_duplicate_cells( + cells=cells, + cell_data=cell_data, + ) + stats["n_cells_before_dedup"] = n_before + stats["n_cells_after_dedup"] = cells.shape[0] + + ### Step 3: Remove unused points + if drop_unused_points: + n_before = points.shape[0] + points, cells, point_data, _ = remove_unused_points( + points=points, + cells=cells, + point_data=point_data, + ) + stats["n_points_before_drop"] = n_before + stats["n_points_after_drop"] = points.shape[0] + + ### Create cleaned mesh + from physicsnemo.mesh.mesh import Mesh + + return Mesh( + points=points, + cells=cells, + point_data=point_data, + cell_data=cell_data, + global_data=global_data, + ), stats + + +def remove_isolated_points( + mesh: "Mesh", +) -> tuple["Mesh", dict[str, int]]: + """Remove points not appearing in any cell. + + Identifies points not referenced by any cell and removes them, + updating cell indices accordingly. Delegates to + :func:`~physicsnemo.mesh.repair._cleaning.remove_unused_points` + for the core computation. + + Parameters + ---------- + mesh : Mesh + Input mesh. + + Returns + ------- + tuple[Mesh, dict[str, int]] + Tuple of (cleaned_mesh, stats_dict) where stats_dict contains: + - "n_isolated_removed": Number of isolated points removed + - "n_points_original": Original number of points + - "n_points_final": Final number of points + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> mesh_clean, stats = remove_isolated_points(mesh) + >>> assert stats["n_isolated_removed"] == 0 # no isolated in clean mesh + """ + n_original = mesh.n_points + + ### Delegate to the tensor-level primitive in _cleaning + new_points, new_cells, new_point_data, _ = remove_unused_points( + points=mesh.points, + cells=mesh.cells, + point_data=mesh.point_data.exclude(CACHE_KEY), + ) + + n_final = new_points.shape[0] + n_isolated = n_original - n_final + + ### Short-circuit if nothing changed + if n_isolated == 0: + return mesh, { + "n_isolated_removed": 0, + "n_points_original": n_original, + "n_points_final": n_original, + } + + ### Build cleaned mesh + from physicsnemo.mesh.mesh import Mesh + + cleaned_mesh = Mesh( + points=new_points, + cells=new_cells, + point_data=new_point_data, + cell_data=mesh.cell_data.exclude(CACHE_KEY).clone(), + global_data=mesh.global_data.clone(), + ) + + return cleaned_mesh, { + "n_isolated_removed": n_isolated, + "n_points_original": n_original, + "n_points_final": n_final, + } diff --git a/physicsnemo/mesh/repair/degenerate_removal.py b/physicsnemo/mesh/repair/degenerate_removal.py new file mode 100644 index 0000000000..a2aa301f8e --- /dev/null +++ b/physicsnemo/mesh/repair/degenerate_removal.py @@ -0,0 +1,129 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Remove degenerate cells from meshes. + +Removes cells with zero or near-zero area/volume, and cells with duplicate vertices. +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.utilities._cache import CACHE_KEY + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def remove_degenerate_cells( + mesh: "Mesh", + area_tolerance: float = 1e-10, +) -> tuple["Mesh", dict[str, int]]: + """Remove cells with area < tolerance or duplicate vertices. + + Identifies and removes degenerate cells that have: + 1. Area/volume below tolerance (nearly zero or negative) + 2. Duplicate vertex indices (invalid simplices) + + Parameters + ---------- + mesh : Mesh + Input mesh + area_tolerance : float + Minimum acceptable cell area + + Returns + ------- + tuple[Mesh, dict[str, int]] + Tuple of (cleaned_mesh, stats_dict) where stats_dict contains: + - "n_zero_area_cells": Number of cells removed for zero area + - "n_duplicate_vertex_cells": Number of cells with duplicate vertices + - "n_cells_original": Original number of cells + - "n_cells_final": Final number of cells + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> mesh_clean, stats = remove_degenerate_cells(mesh) + >>> assert stats["n_cells_final"] == mesh.n_cells # no degenerates in clean mesh + """ + n_original = mesh.n_cells + + if n_original == 0: + return mesh, { + "n_zero_area_cells": 0, + "n_duplicate_vertex_cells": 0, + "n_cells_original": 0, + "n_cells_final": 0, + } + + ### Check 1: Zero area cells + cell_areas = mesh.cell_areas + non_degenerate_by_area = cell_areas >= area_tolerance + n_zero_area = (~non_degenerate_by_area).sum().item() + + ### Check 2: Cells with duplicate vertices (vectorized) + # For each cell, check if all vertices are unique + # Sort vertices in each cell and check for adjacent duplicates + cells_sorted = torch.sort(mesh.cells, dim=1).values # (n_cells, n_verts) + + # Check if any adjacent sorted vertices are equal + has_duplicates = (cells_sorted[:, 1:] == cells_sorted[:, :-1]).any(dim=-1) + + has_unique_vertices = ~has_duplicates + + n_duplicate_vertex = (~has_unique_vertices).sum().item() + + ### Combined mask: keep cells that are good + keep_mask = non_degenerate_by_area & has_unique_vertices + n_keep = keep_mask.sum().item() + + if n_keep == n_original: + # No degenerate cells + return mesh, { + "n_zero_area_cells": 0, + "n_duplicate_vertex_cells": 0, + "n_cells_original": n_original, + "n_cells_final": n_original, + } + + ### Filter cells + new_cells = mesh.cells[keep_mask] + + ### Transfer data (excluding cache) + new_cell_data = mesh.cell_data.exclude(CACHE_KEY)[keep_mask] + + ### Keep all points and point data (will be cleaned by remove_isolated_points if needed) + from physicsnemo.mesh.mesh import Mesh + + cleaned_mesh = Mesh( + points=mesh.points, + cells=new_cells, + point_data=mesh.point_data.exclude(CACHE_KEY).clone(), + cell_data=new_cell_data, + global_data=mesh.global_data.clone(), + ) + + stats = { + "n_zero_area_cells": n_zero_area, + "n_duplicate_vertex_cells": n_duplicate_vertex, + "n_cells_original": n_original, + "n_cells_final": n_keep, + } + + return cleaned_mesh, stats diff --git a/physicsnemo/mesh/repair/hole_filling.py b/physicsnemo/mesh/repair/hole_filling.py new file mode 100644 index 0000000000..146b3d088b --- /dev/null +++ b/physicsnemo/mesh/repair/hole_filling.py @@ -0,0 +1,292 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Fill holes in triangle meshes. + +Detects boundary loops (connected components of boundary edges) and closes +each loop independently with fan triangulation from a centroid vertex. +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.neighbors._adjacency import build_adjacency_from_pairs +from physicsnemo.mesh.utilities._cache import CACHE_KEY + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def _trace_boundary_loops( + boundary_edges: torch.Tensor, +) -> list[torch.Tensor]: + """Trace disjoint boundary loops from a set of boundary edges. + + Each boundary edge connects two vertices. A boundary loop is a connected + cycle of boundary edges. This function identifies all such loops by + building an :class:`Adjacency` structure from the edges, converting it to + Python lists for efficient scalar access, and walking the graph on CPU. + + Parameters + ---------- + boundary_edges : torch.Tensor + Boundary edges, shape (n_boundary_edges, 2). Each row is [v0, v1]. + + Returns + ------- + list[torch.Tensor] + Each tensor contains the ordered vertex indices forming one boundary + loop (on the same device as *boundary_edges*). Vertices are in + traversal order; each consecutive pair shares a boundary edge, and + the last connects back to the first. + """ + if len(boundary_edges) == 0: + return [] + + device = boundary_edges.device + + ### Remap sparse vertex indices to a compact 0..n_boundary_verts-1 range + v0 = boundary_edges[:, 0] + v1 = boundary_edges[:, 1] + all_edge_verts = torch.cat([v0, v1]) + unique_verts, inverse = torch.unique(all_edge_verts, return_inverse=True) + n_boundary_verts = len(unique_verts) + + compact_v0 = inverse[: len(v0)] + compact_v1 = inverse[len(v0) :] + + ### Build bidirectional Adjacency (each edge contributes both directions) + compact_sources = torch.cat([compact_v0, compact_v1]) + compact_targets = torch.cat([compact_v1, compact_v0]) + adj = build_adjacency_from_pairs(compact_sources, compact_targets, n_boundary_verts) + + ### Convert adjacency to Python lists for scalar-access walks. + # This replaces O(N) per-vertex .item() GPU-CPU syncs with 2 bulk transfers. + offsets = adj.offsets.tolist() + indices = adj.indices.tolist() + unique_verts_cpu = unique_verts.cpu() + + ### Walk loops using pure-Python indexing. + # This walk is sequential by nature: each step depends on (current, prev) + # to select the next vertex, so it cannot be vectorized. Parallel algorithms + # (union-find, label propagation) can find components but not vertex ordering, + # which is required for fan triangulation. Boundary loops are small in + # practice, so the O(N) CPU walk is not a bottleneck. + visited = [False] * n_boundary_verts + loops: list[torch.Tensor] = [] + + for start in range(n_boundary_verts): + if visited[start]: + continue + + loop_compact = [start] + visited[start] = True + + # Step to the first neighbor + current = indices[offsets[start]] + prev = start + + while current != start: + visited[current] = True + loop_compact.append(current) + + # Get neighbors of current vertex + nb_s = offsets[current] + nb_e = offsets[current + 1] + + if nb_e - nb_s != 2: + # Non-manifold boundary vertex - abandon this walk + break + + # Pick the neighbor that isn't the one we came from + n0, n1 = indices[nb_s], indices[nb_s + 1] + prev, current = current, (n1 if n0 == prev else n0) + + # Only keep closed loops with at least 3 vertices + if current == start and len(loop_compact) >= 3: + compact_tensor = torch.tensor(loop_compact, dtype=torch.long) + # Map back to original vertex indices, return on original device + loops.append(unique_verts_cpu[compact_tensor].to(device)) + + return loops + + +_EMPTY_STATS = { + "n_holes_detected": 0, + "n_holes_filled": 0, + "n_holes_skipped": 0, + "n_faces_added": 0, + "n_points_added": 0, +} + + +def fill_holes( + mesh: "Mesh", + max_hole_edges: int = 10, +) -> tuple["Mesh", dict[str, int]]: + """Fill holes bounded by boundary loops (2D manifolds only). + + Detects boundary loops (connected components of boundary edges that form + closed cycles) and triangulates each loop independently using fan + triangulation from a centroid vertex inserted at the loop's center. + + Parameters + ---------- + mesh : Mesh + Input mesh (must be a 2D manifold, i.e., a triangle mesh). + max_hole_edges : int + Maximum number of edges in a hole to fill. Holes larger than this + are left open. This prevents accidentally filling large openings + that may be intentional geometry. + + Returns + ------- + tuple[Mesh, dict[str, int]] + Tuple of (filled_mesh, stats_dict) where stats_dict contains: + + - ``"n_holes_detected"``: Total number of boundary loops found. + - ``"n_holes_filled"``: Number of holes actually filled (those with + <= max_hole_edges edges). + - ``"n_holes_skipped"``: Number of holes skipped (too large). + - ``"n_faces_added"``: Total number of new triangular faces added. + - ``"n_points_added"``: Total number of new centroid points added. + + Raises + ------ + ValueError + If mesh is not a 2D manifold. + + Example + ------- + >>> from physicsnemo.mesh.primitives.surfaces import cylinder_open + >>> mesh = cylinder_open.load() + >>> mesh_filled, stats = fill_holes(mesh, max_hole_edges=40) + >>> assert stats["n_holes_detected"] >= 0 + """ + if mesh.n_manifold_dims != 2: + raise ValueError( + f"Hole filling only implemented for 2D manifolds (triangle meshes). " + f"Got {mesh.n_manifold_dims=}." + ) + + if mesh.n_cells == 0: + return mesh, dict(_EMPTY_STATS) + + device = mesh.points.device + + ### Step 1: Find boundary edges via canonical detection + from physicsnemo.mesh.boundaries import get_boundary_edges + + boundary_edges = get_boundary_edges(mesh) + + if len(boundary_edges) == 0: + return mesh, dict(_EMPTY_STATS) + + ### Step 2: Trace boundary edges into disjoint loops + loops = _trace_boundary_loops(boundary_edges) + + n_holes_detected = len(loops) + if n_holes_detected == 0: + return mesh, dict(_EMPTY_STATS) + + ### Step 3: Fill each loop that is small enough (vectorized fan triangulation) + new_points_list: list[torch.Tensor] = [] + new_faces_list: list[torch.Tensor] = [] + n_holes_filled = 0 + n_holes_skipped = 0 + next_point_idx = mesh.n_points + + for loop_tensor in loops: + n_loop_edges = len(loop_tensor) + + if n_loop_edges > max_hole_edges or n_loop_edges < 3: + n_holes_skipped += 1 + continue + + # Compute centroid of the loop vertices + loop_points = mesh.points[loop_tensor] + centroid = loop_points.mean(dim=0) + + # Vectorized fan triangulation: each consecutive pair + centroid + loop_next = loop_tensor.roll(-1) + centroid_col = torch.full_like(loop_tensor, next_point_idx) + fan_triangles = torch.stack([loop_tensor, loop_next, centroid_col], dim=1) + + new_faces_list.append(fan_triangles) + new_points_list.append(centroid.unsqueeze(0)) + next_point_idx += 1 + n_holes_filled += 1 + + ### Step 4: Assemble the filled mesh + if n_holes_filled == 0: + return mesh, { + "n_holes_detected": n_holes_detected, + "n_holes_filled": 0, + "n_holes_skipped": n_holes_skipped, + "n_faces_added": 0, + "n_points_added": 0, + } + + all_new_points = torch.cat(new_points_list, dim=0) # (n_centroids, n_spatial_dims) + all_new_faces = torch.cat(new_faces_list, dim=0) # (n_new_faces, 3) + n_new_points = all_new_points.shape[0] + n_new_faces = all_new_faces.shape[0] + + new_points = torch.cat([mesh.points, all_new_points], dim=0) + new_cells = torch.cat([mesh.cells, all_new_faces], dim=0) + + ### Step 5: Extend point_data and cell_data for the new elements + def extend_point_data(tensor: torch.Tensor) -> torch.Tensor: + """Extend a point_data tensor with NaN (float) or 0 (int) for new centroids.""" + if tensor.shape[0] != mesh.n_points: + return tensor + fill = float("nan") if tensor.dtype.is_floating_point else 0 + pad_shape = (n_new_points, *tensor.shape[1:]) + pad = torch.full(pad_shape, fill, dtype=tensor.dtype, device=device) + return torch.cat([tensor, pad], dim=0) + + def extend_cell_data(tensor: torch.Tensor) -> torch.Tensor: + """Extend a cell_data tensor with NaN (float) or 0 (int) for new faces.""" + if tensor.shape[0] != mesh.n_cells: + return tensor + fill = float("nan") if tensor.dtype.is_floating_point else 0 + pad_shape = (n_new_faces, *tensor.shape[1:]) + pad = torch.full(pad_shape, fill, dtype=tensor.dtype, device=device) + return torch.cat([tensor, pad], dim=0) + + new_point_data = mesh.point_data.exclude(CACHE_KEY).apply(extend_point_data) + new_cell_data = mesh.cell_data.exclude(CACHE_KEY).apply(extend_cell_data) + + from physicsnemo.mesh.mesh import Mesh + + filled_mesh = Mesh( + points=new_points, + cells=new_cells, + point_data=new_point_data, + cell_data=new_cell_data, + global_data=mesh.global_data.clone(), + ) + + stats = { + "n_holes_detected": n_holes_detected, + "n_holes_filled": n_holes_filled, + "n_holes_skipped": n_holes_skipped, + "n_faces_added": n_new_faces, + "n_points_added": n_new_points, + } + + return filled_mesh, stats diff --git a/physicsnemo/mesh/repair/orientation.py b/physicsnemo/mesh/repair/orientation.py new file mode 100644 index 0000000000..f8343bffef --- /dev/null +++ b/physicsnemo/mesh/repair/orientation.py @@ -0,0 +1,277 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Fix face orientation for consistent normals. + +Ensures all faces in a mesh have consistent orientation so normals point +in the same general direction. +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.utilities._cache import CACHE_KEY + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + from physicsnemo.mesh.neighbors._adjacency import Adjacency + + +def _gather_unoriented_neighbors( + front: torch.Tensor, + adjacency: "Adjacency", + is_oriented: torch.Tensor, + max_neighbors: int, +) -> tuple[torch.Tensor, torch.Tensor]: + """Expand a BFS front by one level, returning only unoriented neighbors. + + Given the current front of face indices and a CSR adjacency structure, + gathers all neighbors, filters to those not yet oriented, and tracks + which front face discovered each neighbor. + + Parameters + ---------- + front : torch.Tensor + Face indices in the current BFS front. Shape (n_front,). + adjacency : Adjacency + CSR cell-to-cell adjacency. + is_oriented : torch.Tensor + Boolean mask of already-oriented faces. Shape (n_cells,). + max_neighbors : int + Upper bound on neighbors per face (n_manifold_dims + 1 for simplices). + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + (next_front, parent_faces) where next_front contains the unoriented + neighbor indices and parent_faces[k] is the front face that discovered + next_front[k]. Both are empty tensors when no unoriented neighbors exist. + """ + device = front.device + + if max_neighbors == 0: + empty = torch.empty(0, device=device, dtype=torch.long) + return empty, empty + + ### Gather all neighbors for entire front via the CSR structure + offsets_start = adjacency.offsets[front] # (n_front,) + offsets_end = adjacency.offsets[front + 1] # (n_front,) + neighbor_counts = offsets_end - offsets_start # (n_front,) + + # Build padded gather indices using offset + arange pattern. + # Static upper bound avoids .item() graph break inside the BFS loop. + # Shape: (n_front, max_neighbors) + neighbor_offsets = torch.arange(max_neighbors, device=device, dtype=torch.long) + gather_indices = offsets_start.unsqueeze(1) + neighbor_offsets.unsqueeze(0) + + # Mask for valid neighbors (within each face's actual neighbor count) + # Shape: (n_front, max_neighbors) + valid_mask = neighbor_offsets.unsqueeze(0) < neighbor_counts.unsqueeze(1) + + # Gather all neighbors (use 0 for out-of-bounds, filtered out below) + # Shape: (n_front, max_neighbors) + gather_indices_safe = torch.where( + valid_mask, gather_indices, torch.zeros_like(gather_indices) + ) + all_neighbors = adjacency.indices[gather_indices_safe] + + ### Filter to unoriented neighbors only + keep_mask = valid_mask & ~is_oriented[all_neighbors] + + if not keep_mask.any(): + empty = torch.empty(0, device=device, dtype=torch.long) + return empty, empty + + next_front = all_neighbors[keep_mask] # (n_next,) + + # Track which front face discovered each neighbor + # Shape: (n_front, max_neighbors) -> (n_next,) + parent_faces = front.unsqueeze(1).expand(-1, max_neighbors)[keep_mask] + + return next_front, parent_faces + + +def _propagate_flip_from_parents( + children: torch.Tensor, + parents: torch.Tensor, + cell_normals: torch.Tensor, + should_flip: torch.Tensor, +) -> None: + """Determine flip flags for children based on normal agreement with parents. + + For each child face, compares its stored normal against the effective normal + of its parent (accounting for any prior flip). If the dot product is negative, + the child needs to be flipped for consistent orientation. + + Parameters + ---------- + children : torch.Tensor + Face indices of newly discovered BFS neighbors. Shape (n_next,). + parents : torch.Tensor + Face indices of the parent that discovered each child. Shape (n_next,). + cell_normals : torch.Tensor + Per-face normals from the mesh. Shape (n_cells, n_spatial_dims). + should_flip : torch.Tensor + Boolean mask updated in-place. Shape (n_cells,). + """ + parent_normals = cell_normals[parents] # (n_next, 3) + + # Account for parents that were themselves flipped in a prior BFS level. + # Their effective normal is the negation of the stored (original) normal. + parent_flip_sign = torch.where(should_flip[parents], -1.0, 1.0).unsqueeze( + -1 + ) # (n_next, 1) for broadcasting over spatial dims + parent_normals = parent_normals * parent_flip_sign + + child_normals = cell_normals[children] # (n_next, 3) + + # Negative dot product means opposite orientation -> needs flip + dots = (child_normals * parent_normals).sum(dim=-1) + should_flip[children] = dots < 0 + + +def fix_orientation( + mesh: "Mesh", +) -> tuple["Mesh", dict[str, int]]: + """Orient all faces consistently (2D manifolds in 3D only). + + Uses graph propagation to ensure adjacent faces have consistent orientation. + Two faces sharing an edge should have opposite vertex ordering along that edge. + + Parameters + ---------- + mesh : Mesh + Input mesh (must be 2D manifold in 3D space) + + Returns + ------- + tuple[Mesh, dict[str, int]] + Tuple of (oriented_mesh, stats_dict) where stats_dict contains: + - "n_faces_flipped": Number of faces that were flipped + - "n_components": Number of connected components found + - "largest_component_size": Size of largest component + + Raises + ------ + ValueError + If mesh is not a 2D manifold in 3D + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> mesh = sphere_icosahedral.load(subdivisions=2) + >>> mesh_oriented, stats = fix_orientation(mesh) + >>> assert "n_faces_flipped" in stats + """ + if mesh.n_manifold_dims != 2: + raise ValueError( + f"Orientation fixing only implemented for 2D manifolds (triangles). " + f"Got {mesh.n_manifold_dims=}." + ) + + if mesh.n_cells == 0: + return mesh, { + "n_faces_flipped": 0, + "n_components": 0, + "largest_component_size": 0, + } + + device = mesh.points.device + n_cells = mesh.n_cells + + ### Step 1: Build face adjacency graph via shared edges + from physicsnemo.mesh.neighbors import get_cell_to_cells_adjacency + + adjacency = get_cell_to_cells_adjacency(mesh, adjacency_codimension=1) + + ### Step 2: Propagate orientation using iterative BFS (flat state machine) + is_oriented = torch.zeros(n_cells, dtype=torch.bool, device=device) + should_flip = torch.zeros(n_cells, dtype=torch.bool, device=device) + component_id = torch.full((n_cells,), -1, dtype=torch.long, device=device) + + max_neighbors = mesh.n_manifold_dims + 1 + current_front = torch.empty(0, device=device, dtype=torch.long) + component_sizes: list[int] = [] + + while True: + ### Phase A: If front exhausted, seed next component or terminate + if len(current_front) == 0: + unoriented = torch.where(~is_oriented)[0] + if len(unoriented) == 0: + break + seed = unoriented[0] + is_oriented[seed] = True + component_id[seed] = len(component_sizes) + current_front = seed.unsqueeze(0) + component_sizes.append(1) + continue + + ### Phase B: Expand BFS front by one level + next_front, parent_faces = _gather_unoriented_neighbors( + current_front, adjacency, is_oriented, max_neighbors + ) + + if len(next_front) == 0: + current_front = next_front # Triggers re-seeding on next iteration + continue + + is_oriented[next_front] = True + component_id[next_front] = len(component_sizes) - 1 + component_sizes[-1] += len(next_front) + + if mesh.n_spatial_dims == 3 and mesh.codimension == 1: + _propagate_flip_from_parents( + next_front, parent_faces, mesh.cell_normals, should_flip + ) + + current_front = next_front + + n_components = len(component_sizes) + largest_component_size = max(component_sizes, default=0) + + ### Step 3: Apply flips + n_flipped = should_flip.sum().item() + + if n_flipped > 0: + # Flip faces by reversing vertex order + new_cells = mesh.cells.clone() + + # For triangles: swap vertices 1 and 2 (keeps vertex 0, reverses orientation) + new_cells[should_flip, 1], new_cells[should_flip, 2] = ( + mesh.cells[should_flip, 2], + mesh.cells[should_flip, 1], + ) + + from physicsnemo.mesh.mesh import Mesh + + oriented_mesh = Mesh( + points=mesh.points, + cells=new_cells, + point_data=mesh.point_data.exclude(CACHE_KEY).clone(), + cell_data=mesh.cell_data.exclude(CACHE_KEY).clone(), + global_data=mesh.global_data.clone(), + ) + else: + oriented_mesh = mesh + + stats = { + "n_faces_flipped": n_flipped, + "n_components": n_components, + "largest_component_size": largest_component_size, + } + + return oriented_mesh, stats diff --git a/physicsnemo/mesh/repair/pipeline.py b/physicsnemo/mesh/repair/pipeline.py new file mode 100644 index 0000000000..e70cd9d0df --- /dev/null +++ b/physicsnemo/mesh/repair/pipeline.py @@ -0,0 +1,150 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Comprehensive mesh repair pipeline. + +Combines multiple repair operations into a single convenient function. +""" + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def repair_mesh( + mesh: "Mesh", + merge_points: bool = True, + remove_degenerates: bool = True, + remove_isolated: bool = True, + fix_orientation: bool = False, # Requires 3D, has loops + fill_holes: bool = False, # Expensive, opt-in + tolerance: float = 1e-6, + area_tolerance: float = 1e-10, + max_hole_edges: int = 10, +) -> tuple["Mesh", dict[str, dict]]: + """Apply multiple repair operations in sequence. + + Applies a series of mesh repair operations to clean up common problems. + Operations are applied in a specific order to maximize effectiveness. + + Order of operations: + 1. Remove degenerate cells (zero area) + 2. Merge duplicate points + 3. Remove isolated points + 4. Fix orientation (if enabled) + 5. Fill holes (if enabled) + + Parameters + ---------- + mesh : Mesh + Input mesh to repair. + merge_points : bool, optional + Merge coincident points within *tolerance*. + remove_degenerates : bool, optional + Remove zero-area cells and cells with duplicate vertices. + remove_isolated : bool, optional + Remove points not referenced by any cell. + fix_orientation : bool, optional + Ensure consistent face normals (2D in 3D only). + fill_holes : bool, optional + Close boundary loops (expensive). + tolerance : float, optional + Absolute L2 distance threshold for merging duplicate points. + area_tolerance : float, optional + Area threshold for degenerate cell detection. Cells with area + below this value are considered degenerate and removed. Defaults + to ``1e-10``, matching :func:`remove_degenerate_cells`'s own default. + max_hole_edges : int, optional + Maximum hole size to fill. + + Returns + ------- + tuple[Mesh, dict[str, dict]] + Tuple of (repaired_mesh, all_stats) where all_stats is a dict + mapping operation name to its individual stats dict. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> mesh_clean, stats = repair_mesh(mesh, merge_points=True) + >>> assert "merge_points" in stats + """ + current_mesh = mesh + all_stats = {} + + ### Operation 1: Remove degenerate cells + if remove_degenerates: + from physicsnemo.mesh.repair.degenerate_removal import ( + remove_degenerate_cells as remove_deg, + ) + + current_mesh, stats = remove_deg(current_mesh, area_tolerance=area_tolerance) + all_stats["degenerates"] = stats + + ### Operation 2: Merge duplicate points (via clean_mesh) + if merge_points: + from physicsnemo.mesh.repair._cleaning import clean_mesh + + n_before = current_mesh.n_points + current_mesh, clean_stats = clean_mesh( + current_mesh, + tolerance=tolerance, + merge_points=True, + deduplicate_cells=False, + drop_unused_points=False, + ) + n_after = current_mesh.n_points + all_stats["merge_points"] = { + "n_points_original": n_before, + "n_points_final": n_after, + "n_duplicates_merged": n_before - n_after, + } + all_stats["clean"] = clean_stats + + ### Operation 3: Remove isolated points + if remove_isolated: + from physicsnemo.mesh.repair._cleaning import ( + remove_isolated_points as remove_iso, + ) + + current_mesh, stats = remove_iso(current_mesh) + all_stats["isolated"] = stats + + ### Operation 4: Fix orientation + if fix_orientation: + if current_mesh.n_manifold_dims == 2 and current_mesh.n_spatial_dims == 3: + from physicsnemo.mesh.repair.orientation import ( + fix_orientation as fix_orient, + ) + + current_mesh, stats = fix_orient(current_mesh) + all_stats["orientation"] = stats + else: + all_stats["orientation"] = {"skipped": "Only for 2D manifolds in 3D"} + + ### Operation 5: Fill holes + if fill_holes: + if current_mesh.n_manifold_dims == 2: + from physicsnemo.mesh.repair.hole_filling import fill_holes as fill_h + + current_mesh, stats = fill_h(current_mesh, max_hole_edges=max_hole_edges) + all_stats["holes"] = stats + else: + all_stats["holes"] = {"skipped": "Only for 2D manifolds"} + + return current_mesh, all_stats diff --git a/physicsnemo/mesh/sampling/__init__.py b/physicsnemo/mesh/sampling/__init__.py new file mode 100644 index 0000000000..109321fbd3 --- /dev/null +++ b/physicsnemo/mesh/sampling/__init__.py @@ -0,0 +1,34 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Sampling operations for meshes. + +This module provides functions for sampling points on meshes, including: +- Random uniform point sampling on cells using Dirichlet distributions +- Spatial data sampling at query points with interpolation +- BVH-accelerated sampling for large meshes (via the ``bvh`` parameter) +""" + +from physicsnemo.mesh.sampling.random_point_sampling import ( + sample_random_points_on_cells, +) +from physicsnemo.mesh.sampling.sample_data import ( + compute_barycentric_coordinates, + find_all_containing_cells, + find_containing_cells, + find_nearest_cells, + sample_data_at_points, +) diff --git a/physicsnemo/mesh/sampling/random_point_sampling.py b/physicsnemo/mesh/sampling/random_point_sampling.py new file mode 100644 index 0000000000..0514553b61 --- /dev/null +++ b/physicsnemo/mesh/sampling/random_point_sampling.py @@ -0,0 +1,141 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Random sampling of points on mesh cells.""" + +from collections.abc import Sequence +from typing import TYPE_CHECKING + +import torch +import torch.nn.functional as F + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def sample_random_points_on_cells( + mesh: "Mesh", + cell_indices: Sequence[int] | torch.Tensor | None = None, + alpha: float = 1.0, +) -> torch.Tensor: + """Sample random points uniformly distributed on specified cells of the mesh. + + Uses a Dirichlet distribution to generate barycentric coordinates, which are + then used to compute random points as weighted combinations of cell vertices. + The concentration parameter alpha controls the distribution of samples within + each cell (simplex). + + Parameters + ---------- + mesh : Mesh + The mesh to sample from. + cell_indices : Sequence[int] | torch.Tensor | None + Indices of cells to sample from. Can be a Sequence or tensor. + Allows repeated indices to sample multiple points from the same cell. + If None, samples one point from each cell (equivalent to arange(n_cells)). + Shape: (n_samples,) where n_samples is the number of points to sample. + alpha : float + Concentration parameter for the Dirichlet distribution. Controls how + samples are distributed within each cell: + - alpha = 1.0: Uniform distribution over the simplex (default) + - alpha > 1.0: Concentrates samples toward the center of each cell + - alpha < 1.0: Concentrates samples toward vertices and edges + + Returns + ------- + torch.Tensor + Random points on cells, shape (n_samples, n_spatial_dims). Each point lies + within its corresponding cell. If cell_indices is None, n_samples = n_cells. + + Raises + ------ + NotImplementedError + If alpha != 1.0 and torch.compile is being used. + This is due to a PyTorch limitation with Gamma distributions under torch.compile. + IndexError + If any cell_indices are out of bounds. + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> # Sample one point from each cell uniformly + >>> points = sample_random_points_on_cells(mesh) + >>> assert points.shape == (mesh.n_cells, mesh.n_spatial_dims) + >>> # Sample with concentration toward cell centers + >>> points = sample_random_points_on_cells(mesh, alpha=3.0) + """ + ### Handle default case: sample one point from each cell + if cell_indices is None: + cell_indices = torch.arange( + mesh.n_cells, + device=mesh.points.device, + dtype=torch.long, + ) + else: + # Convert to tensor if needed (as_tensor avoids copy if already a tensor) + cell_indices = torch.as_tensor( + cell_indices, + device=mesh.points.device, + dtype=torch.long, + ) + + ### Validate indices + if not torch.compiler.is_compiling(): + if len(cell_indices) > 0: + if cell_indices.min() < 0: + raise IndexError( + f"cell_indices contains negative values: {cell_indices.min()=}" + ) + if cell_indices.max() >= mesh.n_cells: + raise IndexError( + f"cell_indices contains out-of-bounds values: " + f"{cell_indices.max()=} >= {mesh.n_cells=}" + ) + + n_samples = len(cell_indices) + + ### Sample from Gamma(alpha, 1) distribution and normalize to get Dirichlet + # When alpha=1, Gamma(1,1) is equivalent to Exponential(1), which is more efficient + if alpha == 1.0: + distribution = torch.distributions.Exponential( + rate=torch.ones((), device=mesh.points.device), + ) + else: + if torch.compiler.is_compiling(): + raise NotImplementedError( + f"alpha={alpha!r} is not supported under torch.compile.\n" + f"PyTorch does not yet support sampling from a Gamma distribution\n" + f"when using torch.compile. Use alpha=1.0 (uniform distribution) instead, or disable torch.compile.\n" + f"See https://github.com/pytorch/pytorch/issues/165751." + ) + _rate = torch.ones((), device=mesh.points.device) + distribution = torch.distributions.Gamma( + concentration=torch.full((), alpha, device=mesh.points.device), + rate=_rate, + ) + + raw_barycentric_coords = distribution.sample((n_samples, mesh.n_manifold_dims + 1)) + + ### Normalize so they sum to 1 + barycentric_coords = F.normalize(raw_barycentric_coords, p=1, dim=-1) + + ### Compute weighted combination of cell vertices + # Get the vertices for the selected cells: (n_samples, n_manifold_dims + 1, n_spatial_dims) + selected_cell_vertices = mesh.points[mesh.cells[cell_indices]] + + # Compute weighted sum: (n_samples, n_spatial_dims) + return (barycentric_coords.unsqueeze(-1) * selected_cell_vertices).sum(dim=1) diff --git a/physicsnemo/mesh/sampling/sample_data.py b/physicsnemo/mesh/sampling/sample_data.py new file mode 100644 index 0000000000..ff391398bf --- /dev/null +++ b/physicsnemo/mesh/sampling/sample_data.py @@ -0,0 +1,831 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Spatial sampling of data at query points in a mesh. + +All containment queries use BVH-accelerated O(M*log(N)) search. A ``BVH`` +can be supplied to amortise construction cost across repeated calls; if +omitted, one is built automatically. +""" + +from typing import TYPE_CHECKING, Literal + +import torch +from tensordict import TensorDict + +from physicsnemo.mesh.neighbors._adjacency import Adjacency, build_adjacency_from_pairs +from physicsnemo.mesh.spatial import BVH +from physicsnemo.mesh.utilities._cache import CACHE_KEY + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +# --------------------------------------------------------------------------- +# Internal helpers +# --------------------------------------------------------------------------- + + +def _ensure_bvh(mesh: "Mesh", bvh: BVH | None) -> BVH: + """Return the given BVH, or build one from *mesh* if ``None``.""" + if bvh is not None: + return bvh + return BVH.from_mesh(mesh) + + +# --------------------------------------------------------------------------- +# Barycentric coordinate solvers +# --------------------------------------------------------------------------- + + +def _solve_barycentric_system( + relative_vectors: torch.Tensor, # shape: (..., n_manifold_dims, n_spatial_dims) + query_relative: torch.Tensor, # shape: (..., n_spatial_dims) +) -> tuple[torch.Tensor, torch.Tensor]: + """Core barycentric coordinate solver (shared by both variants). + + Solves the linear system to find barycentric coordinates w_1, ..., w_n such that: + query_relative = sum(w_i * relative_vectors[i]) + + Then computes w_0 = 1 - sum(w_i) and returns all coordinates [w_0, w_1, ..., w_n]. + + For codimension != 0 manifolds (n_spatial_dims != n_manifold_dims), this uses + least squares which projects the query point onto the simplex's affine hull. + The reconstruction error measures how far the query point is from this projection. + + Parameters + ---------- + relative_vectors : torch.Tensor + Edge vectors from first vertex to others, + shape (..., n_manifold_dims, n_spatial_dims) + query_relative : torch.Tensor + Query point relative to first vertex, + shape (..., n_spatial_dims) + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + Tuple of (barycentric_coords, reconstruction_error): + - barycentric_coords: shape (..., n_vertices_per_cell) + where n_vertices_per_cell = n_manifold_dims + 1 + - reconstruction_error: L2 distance from query point to its projection + onto the simplex's affine hull, shape (...). Zero for codimension-0. + + Notes + ----- + For square systems (n_spatial_dims == n_manifold_dims): uses direct solve. + For over/under-determined systems: uses least squares. + """ + n_manifold_dims = relative_vectors.shape[-2] + n_spatial_dims = relative_vectors.shape[-1] + + if n_spatial_dims == n_manifold_dims: + ### Square system: use torch.linalg.solve + A = relative_vectors.transpose(-2, -1) + b = query_relative.unsqueeze(-1) + + try: + weights_1_to_n = torch.linalg.solve(A, b).squeeze(-1) + except torch.linalg.LinAlgError: + weights_1_to_n = torch.linalg.lstsq(A, b).solution.squeeze(-1) + + reconstruction_error = torch.zeros( + weights_1_to_n.shape[:-1], + dtype=query_relative.dtype, + device=query_relative.device, + ) + + else: + ### Over-determined or under-determined system: use least squares + A = relative_vectors.transpose(-2, -1) + b = query_relative.unsqueeze(-1) + weights_1_to_n = torch.linalg.lstsq(A, b).solution.squeeze(-1) + + reconstructed = torch.einsum( + "...m,...ms->...s", weights_1_to_n, relative_vectors + ) + residual = query_relative - reconstructed + reconstruction_error = torch.linalg.vector_norm(residual, dim=-1) + + ### w_0 = 1 - sum(w_i for i=1..n) + w_0 = 1.0 - weights_1_to_n.sum(dim=-1, keepdim=True) + barycentric_coords = torch.cat([w_0, weights_1_to_n], dim=-1) + + return barycentric_coords, reconstruction_error + + +def compute_barycentric_coordinates( + query_points: torch.Tensor, + cell_vertices: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor]: + """Compute barycentric coordinates of query points with respect to simplices. + + Computes the full O(n_queries x n_cells) cartesian product. For BVH-pruned + candidate pairs, use :func:`compute_barycentric_coordinates_pairwise` instead. + + Parameters + ---------- + query_points : torch.Tensor + Query point locations, shape (n_queries, n_spatial_dims) + cell_vertices : torch.Tensor + Vertices of cells, shape (n_cells, n_vertices_per_cell, n_spatial_dims) + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + (barycentric_coords, reconstruction_error): + - barycentric_coords: shape (n_queries, n_cells, n_vertices_per_cell) + - reconstruction_error: shape (n_queries, n_cells). Zero for codimension-0. + """ + v0 = cell_vertices[:, 0:1, :] # (n_cells, 1, n_spatial_dims) + relative_vectors = cell_vertices[:, 1:, :] - v0 + query_relative = query_points.unsqueeze(1) - v0.squeeze(1).unsqueeze(0) + relative_vectors_expanded = relative_vectors.unsqueeze(0) + + return _solve_barycentric_system(relative_vectors_expanded, query_relative) + + +def compute_barycentric_coordinates_pairwise( + query_points: torch.Tensor, + cell_vertices: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor]: + """Compute barycentric coordinates for paired queries and cells. + + Unlike :func:`compute_barycentric_coordinates` which computes all + O(n_queries x n_cells) combinations, this computes only n_pairs diagonal + elements where each query is paired with exactly one cell. O(n) memory. + + Parameters + ---------- + query_points : torch.Tensor + Query point locations, shape (n_pairs, n_spatial_dims) + cell_vertices : torch.Tensor + Vertices of cells, shape (n_pairs, n_vertices_per_cell, n_spatial_dims). + ``cell_vertices[i]`` is paired with ``query_points[i]``. + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + (barycentric_coords, reconstruction_error): + - barycentric_coords: shape (n_pairs, n_vertices_per_cell) + - reconstruction_error: shape (n_pairs,). Zero for codimension-0. + + Examples + -------- + >>> import torch + >>> n_pairs = 1000 + >>> query_points = torch.randn(n_pairs, 3) + >>> cell_vertices = torch.randn(n_pairs, 3, 3) # Triangles in 3D + >>> bary, err = compute_barycentric_coordinates_pairwise(query_points, cell_vertices) + >>> assert bary.shape == (1000, 3) + """ + v0 = cell_vertices[:, 0, :] # (n_pairs, n_spatial_dims) + relative_vectors = cell_vertices[:, 1:, :] - v0.unsqueeze(1) + query_relative = query_points - v0 + + return _solve_barycentric_system(relative_vectors, query_relative) + + +# --------------------------------------------------------------------------- +# Containment queries +# --------------------------------------------------------------------------- + + +def _find_containing_pairs( + mesh: "Mesh", + query_points: torch.Tensor, + bvh: BVH, + tolerance: float, +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None]: + """Find (query_idx, cell_idx, bary_coords) via BVH-accelerated search. + + Parameters + ---------- + mesh : Mesh + Source mesh. + query_points : torch.Tensor + Query point locations, shape (n_queries, n_spatial_dims). + bvh : BVH + Bounding Volume Hierarchy for the mesh. + tolerance : float + Containment tolerance. + + Returns + ------- + tuple[torch.Tensor, torch.Tensor, torch.Tensor | None] + (query_indices, cell_indices, bary_coords): + - query_indices: shape (n_containing,) + - cell_indices: shape (n_containing,) + - bary_coords: shape (n_containing, n_verts) or None if empty + """ + device = mesh.points.device + + ### Get candidate pairs from BVH (AABB overlap test) + candidate_adj = bvh.find_candidate_cells(query_points, aabb_tolerance=tolerance) + + if candidate_adj.n_total_neighbors == 0: + return ( + torch.tensor([], dtype=torch.long, device=device), + torch.tensor([], dtype=torch.long, device=device), + None, + ) + + query_idx_cand, cell_idx_cand = candidate_adj.expand_to_pairs() + + ### Refine candidates with exact barycentric test + cand_query_pts = query_points[query_idx_cand] + cand_cell_verts = mesh.points[mesh.cells[cell_idx_cand]] + + bary_cand, recon_cand = compute_barycentric_coordinates_pairwise( + cand_query_pts, cand_cell_verts + ) + + is_inside = (bary_cand >= -tolerance).all(dim=-1) & (recon_cand <= tolerance) + + ### Filter to confirmed containments + query_indices = query_idx_cand[is_inside] + cell_indices = cell_idx_cand[is_inside] + bary_coords = bary_cand[is_inside] if len(query_indices) > 0 else None + + return query_indices, cell_indices, bary_coords + + +def find_containing_cells( + mesh: "Mesh", + query_points: torch.Tensor, + tolerance: float = 1e-6, + bvh: BVH | None = None, +) -> tuple[torch.Tensor, torch.Tensor]: + """Find which cell contains each query point (first match). + + Parameters + ---------- + mesh : Mesh + The mesh to query. + query_points : torch.Tensor + Query point locations, shape (n_queries, n_spatial_dims). + tolerance : float + Tolerance for considering a point inside a cell. + bvh : BVH or None, optional + Pre-built BVH. Auto-built from *mesh* if ``None``. + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + (cell_indices, barycentric_coords): + - cell_indices: shape (n_queries,). Value is -1 if no cell contains + the point, otherwise the first containing cell index. + - barycentric_coords: shape (n_queries, n_vertices_per_cell). + NaN if no containing cell. + + Notes + ----- + If multiple cells contain a point, only the first is returned. + Use :func:`find_all_containing_cells` to get all containing cells. + """ + n_queries = query_points.shape[0] + n_verts = mesh.n_manifold_dims + 1 + device = mesh.points.device + bvh = _ensure_bvh(mesh, bvh) + + query_idx, cell_idx, bary = _find_containing_pairs( + mesh, query_points, bvh, tolerance + ) + + ### Initialise outputs (default: not found) + cell_indices = torch.full((n_queries,), -1, dtype=torch.long, device=device) + result_bary = torch.full( + (n_queries, n_verts), float("nan"), dtype=query_points.dtype, device=device + ) + + if len(query_idx) == 0: + return cell_indices, result_bary + + ### For each query, keep only the first containing cell + is_first = torch.cat( + [ + torch.tensor([True], device=device), + query_idx[1:] != query_idx[:-1], + ] + ) + first_pos = torch.where(is_first)[0] + hit_queries = query_idx[first_pos] + hit_cells = cell_idx[first_pos] + + cell_indices[hit_queries] = hit_cells + if bary is not None: + result_bary[hit_queries] = bary[first_pos] + + return cell_indices, result_bary + + +def find_all_containing_cells( + mesh: "Mesh", + query_points: torch.Tensor, + tolerance: float = 1e-6, + bvh: BVH | None = None, +) -> Adjacency: + """Find all cells that contain each query point. + + Parameters + ---------- + mesh : Mesh + The mesh to query. + query_points : torch.Tensor + Query point locations, shape (n_queries, n_spatial_dims). + tolerance : float + Tolerance for considering a point inside a cell. + bvh : BVH or None, optional + Pre-built BVH. Auto-built from *mesh* if ``None``. + + Returns + ------- + Adjacency + Adjacency where containing cells for query *i* are at + ``result.indices[result.offsets[i]:result.offsets[i+1]]``. + """ + bvh = _ensure_bvh(mesh, bvh) + query_indices, cell_indices, _ = _find_containing_pairs( + mesh, query_points, bvh, tolerance + ) + + return build_adjacency_from_pairs( + source_indices=query_indices, + target_indices=cell_indices, + n_sources=len(query_points), + ) + + +# --------------------------------------------------------------------------- +# Projection / nearest-cell helpers +# --------------------------------------------------------------------------- + + +def project_point_onto_cell( + query_point: torch.Tensor, + cell_vertices: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor]: + """Project a query point onto a simplex (cell). + + Uses iterative barycentric clipping to find the closest point on the simplex. + + Parameters + ---------- + query_point : torch.Tensor + Point to project, shape (n_spatial_dims,). + cell_vertices : torch.Tensor + Vertices of the simplex, shape (n_vertices, n_spatial_dims). + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + (projected_point, squared_distance): + - projected_point: shape (n_spatial_dims,) + - squared_distance: scalar tensor + """ + n_vertices = cell_vertices.shape[0] + + if n_vertices == 1: + projected = cell_vertices[0] + dist_sq = ((query_point - projected) ** 2).sum() + return projected, dist_sq + + bary, _ = compute_barycentric_coordinates( + query_point.unsqueeze(0), cell_vertices.unsqueeze(0) + ) + bary = bary.squeeze(0).squeeze(0) + + if (bary >= 0).all(): + projected = (bary.unsqueeze(-1) * cell_vertices).sum(dim=0) + dist_sq = ((query_point - projected) ** 2).sum() + return projected, dist_sq + + # Iterative clipping to the active face + for _ in range(n_vertices): + active_mask = bary > 0 + + if not active_mask.any(): + dists = ((cell_vertices - query_point.unsqueeze(0)) ** 2).sum(dim=-1) + nearest_idx = dists.argmin() + return cell_vertices[nearest_idx], dists[nearest_idx] + + active_vertices = cell_vertices[active_mask] + + if active_vertices.shape[0] == 1: + projected = active_vertices[0] + dist_sq = ((query_point - projected) ** 2).sum() + return projected, dist_sq + + bary_active, _ = compute_barycentric_coordinates( + query_point.unsqueeze(0), active_vertices.unsqueeze(0) + ) + bary_active = bary_active.squeeze(0).squeeze(0) + + if (bary_active >= 0).all(): + projected = (bary_active.unsqueeze(-1) * active_vertices).sum(dim=0) + dist_sq = ((query_point - projected) ** 2).sum() + return projected, dist_sq + + bary = torch.zeros_like(bary) + bary[active_mask] = bary_active + + # Fallback: nearest vertex + dists = ((cell_vertices - query_point.unsqueeze(0)) ** 2).sum(dim=-1) + nearest_idx = dists.argmin() + return cell_vertices[nearest_idx], dists[nearest_idx] + + +def find_nearest_cells( + mesh: "Mesh", + query_points: torch.Tensor, + chunk_size: int = 10000, + bvh: BVH | None = None, +) -> tuple[torch.Tensor, torch.Tensor]: + """Find the nearest cell for each query point (by centroid distance). + + When a *bvh* is provided the function uses an expanding-radius BVH search + (following the pattern in + :func:`~physicsnemo.mesh.utilities._duplicate_detection.find_duplicate_pairs`) + to avoid the O(n_queries * n_cells) brute-force computation. Queries that + fall outside all BVH candidate cells fall back to the brute-force path. + + Parameters + ---------- + mesh : Mesh + The mesh to query. + query_points : torch.Tensor + Query point locations, shape (n_queries, n_spatial_dims). + chunk_size : int + Number of queries to process at once (brute-force path only). + bvh : BVH or None, optional + Pre-built Bounding Volume Hierarchy. When provided, enables + O(n_queries * log(n_cells)) search for most queries. + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + (cell_indices, projected_points): + - cell_indices: shape (n_queries,) + - projected_points: centroids of nearest cells, shape (n_queries, n_spatial_dims) + """ + n_queries = query_points.shape[0] + cell_centroids = mesh.cell_centroids # (n_cells, n_spatial_dims) + + if bvh is not None and mesh.n_cells > 0 and n_queries > 0: + cell_indices, resolved = _find_nearest_cells_bvh( + query_points, + cell_centroids, + bvh, + mesh.n_cells, + mesh.n_spatial_dims, + ) + + ### Fall back to brute force for any queries without BVH candidates + if not resolved.all(): + remaining = torch.where(~resolved)[0] + remaining_indices = _find_nearest_cells_brute( + query_points[remaining], + cell_centroids, + chunk_size, + ) + cell_indices[remaining] = remaining_indices + + projected_points = cell_centroids[cell_indices] + return cell_indices, projected_points + + ### Brute-force path (no BVH) + cell_indices = _find_nearest_cells_brute( + query_points, + cell_centroids, + chunk_size, + ) + projected_points = cell_centroids[cell_indices] + return cell_indices, projected_points + + +def _find_nearest_cells_brute( + query_points: torch.Tensor, + cell_centroids: torch.Tensor, + chunk_size: int, +) -> torch.Tensor: + """Brute-force nearest-centroid search with chunking for memory safety.""" + n_queries = query_points.shape[0] + device = query_points.device + + if n_queries * len(cell_centroids) <= chunk_size * chunk_size: + diffs = query_points.unsqueeze(1) - cell_centroids.unsqueeze(0) + distances_sq = (diffs**2).sum(dim=-1) + return distances_sq.argmin(dim=1) + + cell_indices = torch.empty(n_queries, dtype=torch.long, device=device) + for start in range(0, n_queries, chunk_size): + end = min(start + chunk_size, n_queries) + diffs = query_points[start:end].unsqueeze(1) - cell_centroids.unsqueeze(0) + distances_sq = (diffs**2).sum(dim=-1) + cell_indices[start:end] = distances_sq.argmin(dim=1) + return cell_indices + + +def _find_nearest_cells_bvh( + query_points: torch.Tensor, + cell_centroids: torch.Tensor, + bvh: BVH, + n_cells: int, + n_spatial_dims: int, +) -> tuple[torch.Tensor, torch.Tensor]: + """BVH-accelerated nearest-centroid search with expanding radius. + + Returns + ------- + cell_indices : torch.Tensor + Shape (n_queries,). Best cell index found so far (-1 if unresolved). + resolved : torch.Tensor + Shape (n_queries,) bool. True for queries with at least one candidate. + """ + n_queries = query_points.shape[0] + device = query_points.device + + cell_indices = torch.full((n_queries,), -1, dtype=torch.long, device=device) + resolved = torch.zeros(n_queries, dtype=torch.bool, device=device) + + ### Estimate initial search tolerance from BVH root extent + root_extent = bvh.node_aabb_max[0] - bvh.node_aabb_min[0] + # Typical cell diameter ~ total extent / n_cells^(1/d) + tolerance = root_extent.max().item() / max(n_cells ** (1.0 / n_spatial_dims), 1.0) + + ### Expanding-radius search: double tolerance each round until all resolved + max_rounds = 20 # tolerance doubles each round → covers 2^20 ~ 1M× initial + for _ in range(max_rounds): + remaining_mask = ~resolved + remaining_idx = torch.where(remaining_mask)[0] + if len(remaining_idx) == 0: + break + + candidates = bvh.find_candidate_cells( + query_points[remaining_idx], + aabb_tolerance=tolerance, + max_candidates_per_point=64, + ) + + if candidates.n_total_neighbors > 0: + src, tgt = candidates.expand_to_pairs() + # src indexes into the remaining subset; map to global query indices + global_query = remaining_idx[src] + + ### Compute squared centroid distances for all (query, candidate) pairs + dists_sq = ((query_points[global_query] - cell_centroids[tgt]) ** 2).sum( + dim=-1 + ) + + ### Per-query minimum via scatter + best_dist = torch.full( + (n_queries,), float("inf"), dtype=dists_sq.dtype, device=device + ) + best_dist.scatter_reduce_(0, global_query, dists_sq, reduce="amin") + + # Identify which pair achieved the minimum for each query + is_best = dists_sq == best_dist[global_query] + # Among ties, take the first occurrence per query + first_best = torch.zeros(n_queries, dtype=torch.bool, device=device) + first_best.scatter_(0, global_query[is_best], True) + best_mask = is_best & first_best[global_query] + + cell_indices[global_query[best_mask]] = tgt[best_mask] + + # Mark queries that received at least one candidate as resolved + has_candidate = candidates.counts > 0 + resolved[remaining_idx[has_candidate]] = True + + tolerance *= 2.0 + + return cell_indices, resolved + + +# --------------------------------------------------------------------------- +# Shared accumulation logic +# --------------------------------------------------------------------------- + + +def _accumulate_sampled_data( + mesh: "Mesh", + n_queries: int, + query_indices: torch.Tensor, + cell_indices: torch.Tensor, + bary_coords: torch.Tensor | None, + data_source: str, + multiple_cells_strategy: str, +) -> TensorDict: + """Accumulate sampled data from containing-pair arrays into a TensorDict. + + This is the shared kernel that handles scalar/multidimensional data, + mean/nan strategies, and cell/point data sources. + """ + device = mesh.points.device + + ### Count how many cells contain each query point + query_containment_count = torch.zeros(n_queries, dtype=torch.long, device=device) + if len(query_indices) > 0: + query_containment_count.scatter_add_( + 0, query_indices, torch.ones_like(query_indices) + ) + + source_data = mesh.cell_data if data_source == "cells" else mesh.point_data + cells = mesh.cells # captured for point-data interpolation below + + def _accumulate_field(values: torch.Tensor) -> torch.Tensor: + """Scatter-accumulate a single data field across query points.""" + output_shape = (n_queries,) + values.shape[1:] + output = torch.full( + output_shape, float("nan"), dtype=values.dtype, device=device + ) + + if len(query_indices) == 0: + return output + + ### Compute per-pair values + if data_source == "cells": + pair_values = values[cell_indices] + else: + if ( + bary_coords is None + ): # pragma: no cover — guaranteed when len(query_indices) > 0 + raise RuntimeError( + "bary_coords is unexpectedly None for non-empty query set." + ) + point_idx = cells[cell_indices] + point_vals = values[point_idx] + + if values.ndim == 1: + pair_values = (bary_coords * point_vals).sum(dim=1) + else: + bary_expanded = bary_coords.view( + bary_coords.shape[0], + bary_coords.shape[1], + *([1] * (values.ndim - 1)), + ) + pair_values = (bary_expanded * point_vals).sum(dim=1) + + ### Scatter-accumulate into output + if multiple_cells_strategy == "mean": + if values.ndim == 1: + output_sum = torch.zeros(n_queries, dtype=values.dtype, device=device) + output_sum.scatter_add_(0, query_indices, pair_values) + else: + output_sum = torch.zeros( + output_shape, dtype=values.dtype, device=device + ) + idx_expanded = query_indices.view( + -1, *([1] * (values.ndim - 1)) + ).expand_as(pair_values) + output_sum.scatter_add_(0, idx_expanded, pair_values) + + valid = query_containment_count > 0 + if values.ndim == 1: + output[valid] = output_sum[valid] / query_containment_count[valid].to( + values.dtype + ) + else: + output[valid] = output_sum[valid] / query_containment_count[valid].to( + values.dtype + ).view(-1, *([1] * (values.ndim - 1))) + + else: # "nan" strategy + single_cell_mask = query_containment_count == 1 + if single_cell_mask.any(): + has_single = single_cell_mask[query_indices] + output[query_indices[has_single]] = pair_values[has_single] + + return output + + # apply() always returns a TensorDict here (our fn never returns None), + # but the generic return type is TensorDict | None. + result = source_data.exclude(CACHE_KEY).apply( + _accumulate_field, + batch_size=torch.Size([n_queries]), + ) + if not isinstance( + result, TensorDict + ): # pragma: no cover — apply() returns TensorDict here + raise TypeError(f"Expected TensorDict from apply(), got {type(result)}") + return result + + +# --------------------------------------------------------------------------- +# Public API +# --------------------------------------------------------------------------- + + +def sample_data_at_points( + mesh: "Mesh", + query_points: torch.Tensor, + data_source: Literal["cells", "points"] = "cells", + multiple_cells_strategy: Literal["mean", "nan"] = "mean", + project_onto_nearest_cell: bool = False, + tolerance: float = 1e-6, + bvh: BVH | None = None, +) -> TensorDict: + """Extract or interpolate mesh data at specified query points. + + For each query point, the function: + + 1. Finds which cell(s) contain the point (BVH-accelerated, O(log N)) + 2. Extracts cell data directly (``data_source="cells"``) or interpolates + point data using barycentric coordinates (``data_source="points"``) + + Parameters + ---------- + mesh : Mesh + The mesh to extract data from. + query_points : torch.Tensor + Query point locations, shape (n_queries, n_spatial_dims). + data_source : {"cells", "points"}, optional + - "cells": Use cell data directly (no interpolation). + - "points": Interpolate point data using barycentric coordinates. + multiple_cells_strategy : {"mean", "nan"}, optional + How to handle query points contained in multiple cells: + - "mean": Return arithmetic mean of values from all containing cells. + - "nan": Return NaN for ambiguous points. + project_onto_nearest_cell : bool, optional + If True, snaps each query point to the centroid of the nearest cell + before performing containment testing. Useful for codimension != 0 + manifolds where exact on-surface points are hard to construct. + tolerance : float, optional + Tolerance for considering a point inside a cell. A point is inside if + all barycentric coordinates >= -tolerance AND reconstruction error + <= tolerance. + bvh : BVH or None, optional + Pre-built Bounding Volume Hierarchy. If ``None`` (default), one is + built automatically. For repeated queries on the same mesh, pre-build + with ``BVH.from_mesh(mesh)`` and pass it here to avoid redundant work. + + Returns + ------- + TensorDict + Sampled data for each query point, with the same keys as + ``mesh.cell_data`` or ``mesh.point_data`` (depending on *data_source*). + Values are NaN for query points outside the mesh. + + Raises + ------ + ValueError + If *data_source* or *multiple_cells_strategy* is invalid. + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> mesh.cell_data["pressure"] = torch.tensor([1.0, 2.0]) + >>> query_pts = torch.tensor([[0.3, 0.3], [0.8, 0.5]]) + >>> sampled = sample_data_at_points(mesh, query_pts, data_source="cells") + >>> assert "pressure" in sampled.keys() + + Pre-build a BVH for repeated queries: + + >>> from physicsnemo.mesh.spatial import BVH + >>> bvh = BVH.from_mesh(mesh) + >>> sampled = sample_data_at_points(mesh, query_pts, bvh=bvh) + """ + if data_source not in ("cells", "points"): + raise ValueError(f"Invalid {data_source=}. Must be 'cells' or 'points'.") + if multiple_cells_strategy not in ("mean", "nan"): + raise ValueError( + f"Invalid {multiple_cells_strategy=}. Must be 'mean' or 'nan'." + ) + + n_queries = query_points.shape[0] + + ### Ensure BVH is available (shared across projection and containment) + bvh = _ensure_bvh(mesh, bvh) + + ### Handle projection onto nearest cell + if project_onto_nearest_cell: + _, projected_points = find_nearest_cells(mesh, query_points, bvh=bvh) + query_points = projected_points + query_indices, cell_indices, bary_coords = _find_containing_pairs( + mesh, query_points, bvh, tolerance + ) + + ### Accumulate sampled data + return _accumulate_sampled_data( + mesh=mesh, + n_queries=n_queries, + query_indices=query_indices, + cell_indices=cell_indices, + bary_coords=bary_coords, + data_source=data_source, + multiple_cells_strategy=multiple_cells_strategy, + ) diff --git a/physicsnemo/mesh/smoothing/__init__.py b/physicsnemo/mesh/smoothing/__init__.py new file mode 100644 index 0000000000..325ec39eef --- /dev/null +++ b/physicsnemo/mesh/smoothing/__init__.py @@ -0,0 +1,23 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Mesh smoothing operations. + +This module provides algorithms for smoothing mesh geometry while preserving +important features like boundaries and sharp edges. +""" + +from physicsnemo.mesh.smoothing.laplacian import smooth_laplacian diff --git a/physicsnemo/mesh/smoothing/laplacian.py b/physicsnemo/mesh/smoothing/laplacian.py new file mode 100644 index 0000000000..f3fb425616 --- /dev/null +++ b/physicsnemo/mesh/smoothing/laplacian.py @@ -0,0 +1,437 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Laplacian mesh smoothing with feature preservation. + +Implements geometry-aware smoothing using cotangent weights, with options for +preserving boundaries and sharp features. +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.boundaries import get_boundary_vertices +from physicsnemo.mesh.boundaries._facet_extraction import extract_candidate_facets +from physicsnemo.mesh.geometry.dual_meshes import compute_cotan_weights_fem +from physicsnemo.mesh.utilities._topology import extract_unique_edges + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def smooth_laplacian( + mesh: "Mesh", + n_iter: int = 20, + relaxation_factor: float = 0.01, + convergence: float = 0.0, + feature_angle: float = 45.0, + preserve_boundaries: bool = True, + preserve_features: bool = False, + inplace: bool = False, +) -> "Mesh": + """Smooth mesh using Laplacian smoothing with cotangent weights. + + Applies iterative Laplacian smoothing to adjust point positions, making cells + better shaped and vertices more evenly distributed. Uses geometry-aware + cotangent weights that respect the mesh structure. + + Parameters + ---------- + mesh : Mesh + Input mesh to smooth + n_iter : int, optional + Number of smoothing iterations. More iterations produce smoother + results but take longer. Default: 20 + relaxation_factor : float, optional + Controls displacement per iteration. Lower values are + more stable but require more iterations. Range: (0, 1]. Default: 0.01 + convergence : float, optional + Convergence criterion relative to bounding box diagonal. + Stops early if max vertex displacement < convergence * bbox_diagonal. + Set to 0.0 to disable early stopping. Default: 0.0 + feature_angle : float, optional + Angle threshold (degrees) for sharp edge detection. + Edges with dihedral angle > feature_angle are considered sharp features. + Only used for codimension-1 manifolds. Default: 45.0 + preserve_boundaries : bool, optional + If True (default), boundary vertices are fixed and + will not move during smoothing, preserving the original boundary shape. + If False, boundary vertices are smoothed like interior vertices. + preserve_features : bool, optional + If True, vertices on sharp feature edges (with dihedral + angle > feature_angle) are fixed and will not move. If False (default), + feature vertices are smoothed normally. + inplace : bool, optional + If True, modifies mesh in place. If False, creates a copy. Default: False + + Returns + ------- + Mesh + Smoothed mesh. Same object as input if inplace=True, otherwise a new mesh. + + Raises + ------ + ValueError + If n_iter < 0 or relaxation_factor <= 0 + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> mesh = sphere_icosahedral.load(subdivisions=2) + >>> # Basic smoothing + >>> smoothed = smooth_laplacian(mesh, n_iter=10, relaxation_factor=0.1) + >>> assert smoothed.n_points == mesh.n_points + >>> # Preserve boundaries and sharp edges + >>> smoothed = smooth_laplacian( + ... mesh, + ... n_iter=50, + ... feature_angle=45.0, + ... preserve_boundaries=True, + ... preserve_features=True, + ... ) + >>> + >>> # With convergence criterion + >>> smoothed = smooth_laplacian( + ... mesh, + ... n_iter=1000, + ... convergence=0.001, # Stop if change < 0.1% of bbox + ... ) + + Notes + ----- + - Cotangent weights are used for codimension-1 manifolds (surfaces, curves) + - Uniform weights are used for higher codimension or volumetric meshes + - Feature detection only works for codimension-1 manifolds where normals exist + - Cell connectivity and all data fields are preserved (only points move) + """ + ### Validate parameters + if n_iter < 0: + raise ValueError(f"n_iter must be >= 0, got {n_iter=}") + if relaxation_factor <= 0: + raise ValueError(f"relaxation_factor must be > 0, got {relaxation_factor=}") + if convergence < 0: + raise ValueError(f"convergence must be >= 0, got {convergence=}") + + ### Handle empty mesh or zero iterations + if mesh.n_points == 0 or mesh.n_cells == 0 or n_iter == 0: + if inplace: + return mesh + else: + return mesh.clone() + + ### Create working copy if not inplace + if not inplace: + mesh = mesh.clone() + + device = mesh.points.device + dtype = mesh.points.dtype + n_points = mesh.n_points + n_spatial_dims = mesh.n_spatial_dims + + ### Compute edge weights (also extracts unique edges) + edge_weights, edges = _compute_edge_weights(mesh) # (n_edges,), (n_edges, 2) + + ### Save original positions for constrained vertices + original_points = mesh.points.clone() + + ### Identify constrained vertices (boundaries and features) + constrained_vertices = torch.zeros(n_points, dtype=torch.bool, device=device) + + if preserve_boundaries: + # Boundary vertices should not move + boundary_vertex_mask = get_boundary_vertices(mesh) + constrained_vertices |= boundary_vertex_mask + + if preserve_features: + # Feature vertices should not move + feature_vertex_mask = _get_feature_vertices(mesh, edges, feature_angle) + constrained_vertices |= feature_vertex_mask + + ### Compute convergence threshold + convergence_threshold = 0.0 + if convergence > 0: + # Threshold relative to bounding box diagonal + bbox_min = mesh.points.min(dim=0).values + bbox_max = mesh.points.max(dim=0).values + bbox_diagonal = torch.norm(bbox_max - bbox_min) + convergence_threshold = convergence * bbox_diagonal + + ### Pre-allocate buffers for iterative smoothing (avoid per-iteration allocation) + laplacian = torch.zeros((n_points, n_spatial_dims), dtype=dtype, device=device) + weight_sum = torch.zeros(n_points, dtype=dtype, device=device) + + ### Iterative smoothing + for iteration in range(n_iter): + # Save old positions for convergence check + if convergence > 0: + old_points = mesh.points.clone() + + ### Compute Laplacian at each vertex: L(p_i) = Σ_j w_ij (p_j - p_i) + laplacian.zero_() + weight_sum.zero_() + + # For each edge (i, j) with weight w: + # laplacian[i] += w * (p_j - p_i) + # laplacian[j] += w * (p_i - p_j) + # weight_sum[i] += w + # weight_sum[j] += w + + # Edge vectors: p_j - p_i + edge_vectors = mesh.points[edges[:, 1]] - mesh.points[edges[:, 0]] + weighted_vectors = edge_vectors * edge_weights.unsqueeze(-1) + + # Accumulate contributions from edges + # For vertex edges[:,0]: add weighted_vectors + laplacian.scatter_add_( + 0, + edges[:, 0].unsqueeze(-1).expand(-1, n_spatial_dims), + weighted_vectors, + ) + # For vertex edges[:,1]: subtract weighted_vectors + laplacian.scatter_add_( + 0, + edges[:, 1].unsqueeze(-1).expand(-1, n_spatial_dims), + -weighted_vectors, + ) + + # Accumulate weight sums + weight_sum.scatter_add_(0, edges[:, 0], edge_weights) + weight_sum.scatter_add_(0, edges[:, 1], edge_weights) + + ### Normalize by total weight per vertex + # Avoid division by zero for isolated vertices + # Use dtype-appropriate minimum: 1e-10 for fp32+, 1e-4 for fp16 + # (fp16 smallest normal is ~6e-5, so 1e-10 would round to 0) + min_clamp = 1e-4 if dtype == torch.float16 else 1e-10 + weight_sum = weight_sum.clamp(min=min_clamp) + laplacian = laplacian / weight_sum.unsqueeze(-1) + + ### Apply relaxation + mesh.points = mesh.points + relaxation_factor * laplacian + + ### Restore constrained vertices to original positions + # Written unconditionally to avoid a torch.compile graph break; + # masked assignment on an all-False mask is a no-op. + mesh.points[constrained_vertices] = original_points[constrained_vertices] + + ### Check convergence + if convergence > 0: + max_displacement = torch.norm(mesh.points - old_points, dim=-1).max() + if max_displacement < convergence_threshold: + break + + return mesh + + +def _compute_edge_weights( + mesh: "Mesh", +) -> tuple[torch.Tensor, torch.Tensor]: + """Compute weights for each edge based on mesh geometry. + + For codimension-1 manifolds with n_manifold_dims >= 2: uses cotangent weights + Otherwise: uses uniform weights + + Parameters + ---------- + mesh : Mesh + Input mesh + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + Tuple of (edge_weights, edges) where edge_weights has shape (n_edges,) + and edges has shape (n_edges, 2). + """ + device = mesh.points.device + dtype = mesh.points.dtype + + if mesh.codimension == 1 and mesh.n_manifold_dims >= 2: + ### Use cotangent weights (geometry-aware) via FEM stiffness matrix + weights, edges = compute_cotan_weights_fem(mesh) + + ### Clamp weights for numerical stability + # Negative cotangents occur for obtuse angles - treat as zero (no contribution) + # Very large cotangents occur for nearly degenerate triangles - cap for stability + weights = weights.clamp(min=0.0, max=10.0) + + else: + ### Use uniform weights for 1D manifolds or higher codimension + edges, _ = extract_unique_edges(mesh) + weights = torch.ones(len(edges), dtype=dtype, device=device) + + return weights, edges + + +def _get_feature_vertices( + mesh: "Mesh", + edges: torch.Tensor, + feature_angle: float, +) -> torch.Tensor: + """Identify vertices on sharp feature edges. + + Only applicable for codimension-1 manifolds where normals exist. + + Parameters + ---------- + mesh : Mesh + Input mesh + edges : torch.Tensor + All unique edges, shape (n_edges, 2) + feature_angle : float + Dihedral angle threshold (degrees) for sharp features + + Returns + ------- + torch.Tensor + Boolean mask, shape (n_points,), True for feature vertices + """ + device = mesh.points.device + n_points = mesh.n_points + + # Feature detection only works for codimension-1 + if mesh.codimension != 1: + return torch.zeros(n_points, dtype=torch.bool, device=device) + + # Detect sharp edges + sharp_edges = _detect_sharp_edges(mesh, edges, feature_angle) # (n_sharp_edges, 2) + + if len(sharp_edges) == 0: + return torch.zeros(n_points, dtype=torch.bool, device=device) + + # Mark all vertices in sharp edges + feature_mask = torch.zeros(n_points, dtype=torch.bool, device=device) + feature_mask[sharp_edges[:, 0]] = True + feature_mask[sharp_edges[:, 1]] = True + + return feature_mask + + +def _detect_sharp_edges( + mesh: "Mesh", + edges: torch.Tensor, + feature_angle: float, +) -> torch.Tensor: + """Detect edges with dihedral angle exceeding threshold. + + Fully vectorized implementation using :func:`find_edges_in_reference` + for O(n log n) edge matching and O(n) memory. + + Parameters + ---------- + mesh : Mesh + Input mesh (must be codimension-1) + edges : torch.Tensor + All unique edges, shape (n_edges, 2) + feature_angle : float + Dihedral angle threshold in degrees + + Returns + ------- + torch.Tensor + Sharp edges, shape (n_sharp_edges, 2) + """ + from physicsnemo.mesh.utilities._edge_lookup import find_edges_in_reference + + device = mesh.points.device + n_manifold_dims = mesh.n_manifold_dims + + ### Extract candidate edges with parent cell info + candidate_edges, parent_cell_indices = extract_candidate_facets( + mesh.cells, + manifold_codimension=n_manifold_dims - 1, + ) + + ### Map candidate edges to unique edges via searchsorted (O(m log n), O(n) memory) + candidate_to_unique, matched = find_edges_in_reference(edges, candidate_edges) + + ### Count cells per edge + edge_cell_counts = torch.zeros(len(edges), dtype=torch.long, device=device) + edge_cell_counts.scatter_add_( + 0, + candidate_to_unique, + matched.long(), # only count matched candidates + ) + + ### Find interior edges (exactly 2 adjacent cells) + interior_edge_mask = edge_cell_counts == 2 + + if not torch.any(interior_edge_mask): + return torch.empty((0, 2), dtype=edges.dtype, device=device) + + interior_edge_indices = torch.where(interior_edge_mask)[0] + + ### Collect the two adjacent cells per interior edge + # Sort matched candidates by their unique edge index; within each group of + # size 2, the first element becomes cell_a and the second becomes cell_b. + valid_mask = matched + valid_candidate_to_unique = candidate_to_unique[valid_mask] + valid_parent_cells = parent_cell_indices[valid_mask] + + sorted_order = torch.argsort(valid_candidate_to_unique, stable=True) + sorted_edge_ids = valid_candidate_to_unique[sorted_order] + sorted_parent_cells = valid_parent_cells[sorted_order] + + # Detect group boundaries (where the edge index changes) + # is_first: True at positions where the edge id differs from the predecessor + is_first_in_group = torch.cat( + [ + torch.ones(1, dtype=torch.bool, device=device), + sorted_edge_ids[1:] != sorted_edge_ids[:-1], + ] + ) + # is_second: True at positions where the edge id equals the predecessor + is_second_in_group = torch.cat( + [ + torch.zeros(1, dtype=torch.bool, device=device), + sorted_edge_ids[1:] == sorted_edge_ids[:-1], + ] + ) + + # Build per-edge cell arrays (scatter first/second occurrence to edge index) + edge_first_cell = torch.full((len(edges),), -1, dtype=torch.long, device=device) + edge_second_cell = torch.full((len(edges),), -1, dtype=torch.long, device=device) + + edge_first_cell.scatter_( + 0, sorted_edge_ids[is_first_in_group], sorted_parent_cells[is_first_in_group] + ) + edge_second_cell.scatter_( + 0, sorted_edge_ids[is_second_in_group], sorted_parent_cells[is_second_in_group] + ) + + ### Compute dihedral angles for interior edges (vectorized) + interior_first_cells = edge_first_cell[interior_edge_indices] + interior_second_cells = edge_second_cell[interior_edge_indices] + + normals_first = mesh.cell_normals[ + interior_first_cells + ] # (n_interior, n_spatial_dims) + normals_second = mesh.cell_normals[ + interior_second_cells + ] # (n_interior, n_spatial_dims) + + cos_angles = (normals_first * normals_second).sum(dim=-1) + cos_angles = cos_angles.clamp(-1.0, 1.0) + angles_deg = torch.acos(cos_angles) * (180.0 / torch.pi) + + ### Filter for sharp edges + sharp_mask = angles_deg > feature_angle + sharp_edge_indices = interior_edge_indices[sharp_mask] + + if len(sharp_edge_indices) == 0: + return torch.empty((0, 2), dtype=edges.dtype, device=device) + + return edges[sharp_edge_indices] diff --git a/physicsnemo/mesh/spatial/__init__.py b/physicsnemo/mesh/spatial/__init__.py new file mode 100644 index 0000000000..c4ce52ca8b --- /dev/null +++ b/physicsnemo/mesh/spatial/__init__.py @@ -0,0 +1,23 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Spatial acceleration structures for efficient queries on large meshes. + +This module provides data structures and algorithms for fast spatial queries: +- BVH (Bounding Volume Hierarchy) for point-in-cell queries +""" + +from physicsnemo.mesh.spatial.bvh import BVH diff --git a/physicsnemo/mesh/spatial/bvh.py b/physicsnemo/mesh/spatial/bvh.py new file mode 100644 index 0000000000..0ee4359644 --- /dev/null +++ b/physicsnemo/mesh/spatial/bvh.py @@ -0,0 +1,690 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Bounding Volume Hierarchy (BVH) for efficient spatial queries. + +This module implements a GPU-compatible BVH using flat array storage for efficient +traversal on both CPU and GPU. The BVH enables O(log N) query time for finding +which cells contain query points, compared to O(N) for brute-force search. + +Construction uses a morton-code-based Linear BVH (LBVH) algorithm that runs in +O(log N) Python iterations instead of the O(N) iterations required by a naive +sequential approach, enabling scalability to hundreds of millions of cells. +""" + +from typing import TYPE_CHECKING + +import torch +from tensordict import tensorclass + +from physicsnemo.mesh.neighbors._adjacency import Adjacency, build_adjacency_from_pairs + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +# --------------------------------------------------------------------------- +# Morton code computation +# --------------------------------------------------------------------------- + + +def _compute_morton_codes(centroids: torch.Tensor) -> torch.Tensor: + """Compute morton codes (Z-order curve) for a set of points. + + Morton codes interleave the bits of quantized coordinates to produce a + single integer that preserves spatial locality: points that are nearby in + D-dimensional space tend to have nearby morton codes. Sorting by morton + code therefore clusters spatially-adjacent primitives together, which is + the foundation of Linear BVH (LBVH) construction. + + Parameters + ---------- + centroids : torch.Tensor + Point coordinates, shape ``(N, D)``, any float dtype. + + Returns + ------- + torch.Tensor + Morton codes, shape ``(N,)``, dtype int64. All values are non-negative + (fit in 63 useful bits of signed int64). + """ + if centroids.ndim != 2: + raise ValueError( + f"centroids must be 2D (N, D), got {centroids.ndim}D " + f"with shape {tuple(centroids.shape)}" + ) + if not centroids.is_floating_point(): + raise TypeError( + f"centroids must be a floating-point tensor (got {centroids.dtype=!r}); " + f"integer input would silently produce wrong quantization" + ) + + N, D = centroids.shape + device = centroids.device + + ### Bits per dimension: 63 // D keeps total code <= 63 bits (non-negative int64) + n_bits = 63 // D + max_val = (1 << n_bits) - 1 + + ### Quantize centroids to integer grid [0, 2^n_bits - 1] + cmin = centroids.min(dim=0).values # (D,) + cmax = centroids.max(dim=0).values # (D,) + extent = (cmax - cmin).clamp(min=1e-30) # avoid division by zero + coords = ((centroids - cmin) / extent * max_val).long().clamp(0, max_val) # (N, D) + + ### Bit-interleave all dimensions: bit b of dim d -> position b*D + d + # Vectorized across D at each bit level; n_bits iterations total. + code = torch.zeros(N, dtype=torch.int64, device=device) + dim_offsets = torch.arange(D, dtype=torch.int64, device=device) # (D,) + for b in range(n_bits): + bits = (coords >> b) & 1 # (N, D) - extract bit b from every dim + code += (bits << (b * D + dim_offsets)).sum(dim=1) # (N,) + return code + + +# --------------------------------------------------------------------------- +# Leaf expansion helper +# --------------------------------------------------------------------------- + + +def _expand_leaf_hits( + leaf_query_indices: torch.Tensor, + leaf_node_indices: torch.Tensor, + leaf_start: torch.Tensor, + leaf_count: torch.Tensor, + sorted_cell_order: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor]: + """Expand (query, leaf_node) hits into (query, cell) candidate pairs. + + Each leaf node may contain multiple cells. This performs a "ragged expand" + to produce one ``(query_idx, cell_idx)`` pair for every cell in every hit + leaf. + + Parameters + ---------- + leaf_query_indices : torch.Tensor + Query indices for leaf hits, shape ``(n_hits,)``. + leaf_node_indices : torch.Tensor + Node indices for leaf hits, shape ``(n_hits,)``. + leaf_start : torch.Tensor + Per-node start index into ``sorted_cell_order``, shape ``(n_nodes,)``. + leaf_count : torch.Tensor + Per-node cell count, shape ``(n_nodes,)``. + sorted_cell_order : torch.Tensor + Morton-sorted cell permutation, shape ``(n_cells,)``. + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + ``(expanded_query_indices, expanded_cell_indices)`` + """ + starts = leaf_start[leaf_node_indices] # (n_hits,) + counts = leaf_count[leaf_node_indices] # (n_hits,) + total = int(counts.sum()) + device = leaf_query_indices.device + + if total == 0: + return ( + torch.empty(0, dtype=torch.long, device=device), + torch.empty(0, dtype=torch.long, device=device), + ) + + ### Expand query indices: repeat each by its leaf's cell count + expanded_queries = torch.repeat_interleave(leaf_query_indices, counts) + + ### Compute position-within-leaf offsets: [0,1,...,c0-1, 0,1,...,c1-1, ...] + cum = counts.cumsum(0) + offsets_within = torch.arange(total, dtype=torch.long, device=device) + offsets_within = offsets_within - torch.repeat_interleave(cum - counts, counts) + + ### Map to original cell indices through the sorted permutation + sorted_positions = torch.repeat_interleave(starts, counts) + offsets_within + expanded_cells = sorted_cell_order[sorted_positions] + + return expanded_queries, expanded_cells + + +# --------------------------------------------------------------------------- +# Segmented leaf AABB computation +# --------------------------------------------------------------------------- + + +def _compute_leaf_aabbs( + leaf_seg_starts: torch.Tensor, + leaf_seg_sizes: torch.Tensor, + sorted_aabb_min: torch.Tensor, + sorted_aabb_max: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor]: + """Compute AABBs for a batch of leaf segments via segmented reduction. + + Each leaf segment is a contiguous range ``[start, start + size)`` in the + morton-sorted cell arrays. + + Parameters + ---------- + leaf_seg_starts : torch.Tensor + Start positions in the sorted cell array, shape ``(n_leaf_segs,)``. + leaf_seg_sizes : torch.Tensor + Number of cells per leaf segment, shape ``(n_leaf_segs,)``. + sorted_aabb_min : torch.Tensor + Per-cell AABB minima in sorted order, shape ``(n_cells, D)``. + sorted_aabb_max : torch.Tensor + Per-cell AABB maxima in sorted order, shape ``(n_cells, D)``. + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + ``(aabb_min, aabb_max)`` each of shape ``(n_leaf_segs, D)``. + """ + device = leaf_seg_starts.device + D = sorted_aabb_min.shape[1] + dtype = sorted_aabb_min.dtype + n_leaf_segs = len(leaf_seg_starts) + total_cells = leaf_seg_sizes.sum().item() + + if total_cells == 0 or n_leaf_segs == 0: + return ( + torch.empty((0, D), dtype=dtype, device=device), + torch.empty((0, D), dtype=dtype, device=device), + ) + + ### Build segment-ID for each cell across all leaf segments + seg_ids = torch.repeat_interleave( + torch.arange(n_leaf_segs, dtype=torch.long, device=device), + leaf_seg_sizes, + ) # (total_cells,) + + ### Build positions into the sorted cell array + cum = leaf_seg_sizes.cumsum(0) + offsets = torch.arange(total_cells, dtype=torch.long, device=device) + offsets = offsets - torch.repeat_interleave(cum - leaf_seg_sizes, leaf_seg_sizes) + cell_pos = torch.repeat_interleave(leaf_seg_starts, leaf_seg_sizes) + offsets + + ### Gather cell AABBs + cell_mins = sorted_aabb_min[cell_pos] # (total_cells, D) + cell_maxs = sorted_aabb_max[cell_pos] # (total_cells, D) + + ### Segmented min/max reduction + seg_min = torch.full((n_leaf_segs, D), float("inf"), dtype=dtype, device=device) + seg_max = torch.full((n_leaf_segs, D), float("-inf"), dtype=dtype, device=device) + exp_ids = seg_ids.unsqueeze(1).expand_as(cell_mins) + seg_min.scatter_reduce_(0, exp_ids, cell_mins, reduce="amin", include_self=True) + seg_max.scatter_reduce_(0, exp_ids, cell_maxs, reduce="amax", include_self=True) + + return seg_min, seg_max + + +# --------------------------------------------------------------------------- +# BVH tensorclass +# --------------------------------------------------------------------------- + + +@tensorclass +class BVH: + """Bounding Volume Hierarchy for efficient spatial queries. + + The BVH is stored as flat tensors for GPU compatibility, avoiding + pointer-based tree structures. Each internal node has exactly two children + (binary tree). Leaf nodes store a contiguous range of cells in + morton-sorted order. + + Construction uses a Linear BVH (LBVH) algorithm: cells are sorted by + morton code (Z-order curve), then the tree is built top-down by splitting + sorted segments at their midpoints. This runs in O(log N) Python-level + iterations with O(N log N) total GPU work, enabling scalability to + hundreds of millions of cells. + + Attributes + ---------- + node_aabb_min : torch.Tensor + Minimum corner of axis-aligned bounding box for each node, + shape ``(n_nodes, n_spatial_dims)``. + node_aabb_max : torch.Tensor + Maximum corner of AABB for each node, + shape ``(n_nodes, n_spatial_dims)``. + node_left_child : torch.Tensor + Index of left child for each internal node, + shape ``(n_nodes,)``, dtype int64. Value is -1 for leaf nodes. + node_right_child : torch.Tensor + Index of right child for each internal node, + shape ``(n_nodes,)``, dtype int64. Value is -1 for leaf nodes. + leaf_start : torch.Tensor + Start index into ``sorted_cell_order`` for leaf nodes, + shape ``(n_nodes,)``, dtype int64. Value is -1 for internal nodes. + leaf_count : torch.Tensor + Number of cells in each leaf node, + shape ``(n_nodes,)``, dtype int64. Value is 0 for internal nodes. + sorted_cell_order : torch.Tensor + Morton-code-sorted permutation of cell indices, + shape ``(n_cells,)``, dtype int64. + + Examples + -------- + >>> bvh = BVH.from_mesh(mesh) + >>> candidates = bvh.find_candidate_cells(query_points) + """ + + node_aabb_min: torch.Tensor # (n_nodes, n_spatial_dims) + node_aabb_max: torch.Tensor # (n_nodes, n_spatial_dims) + node_left_child: torch.Tensor # (n_nodes,), int64, -1 for leaves + node_right_child: torch.Tensor # (n_nodes,), int64, -1 for leaves + leaf_start: torch.Tensor # (n_nodes,), int64, -1 for internal + leaf_count: torch.Tensor # (n_nodes,), int64, 0 for internal + sorted_cell_order: torch.Tensor # (n_cells,), int64 + + @property + def n_nodes(self) -> int: + """Number of nodes in the BVH.""" + return self.node_aabb_min.shape[0] + + @property + def n_spatial_dims(self) -> int: + """Dimensionality of the spatial space.""" + return self.node_aabb_min.shape[1] + + @property + def device(self) -> torch.device: + """Device where BVH tensors are stored.""" + return self.node_aabb_min.device + + @classmethod + def from_mesh(cls, mesh: "Mesh", leaf_size: int = 8) -> "BVH": + """Construct a BVH from a mesh using morton-code LBVH. + + Cells are sorted by the morton code of their centroids, then the tree + is built top-down by recursively splitting sorted segments at their + midpoints. AABBs are computed in two phases: leaf AABBs via segmented + reduction over cell bounds, internal AABBs via a bottom-up pass from + leaves to root. The entire construction runs in O(log N) Python-level + iterations. + + Parameters + ---------- + mesh : Mesh + The mesh to build the BVH for. + leaf_size : int, optional + Maximum number of cells per leaf node. Larger values reduce tree + depth and memory at the cost of more candidate cells per query hit. + + Returns + ------- + BVH + Constructed BVH ready for queries. + + Raises + ------ + ValueError + If ``leaf_size < 1``. + """ + if leaf_size < 1: + raise ValueError(f"leaf_size must be >= 1, got {leaf_size=!r}") + + n_cells = mesh.n_cells + D = mesh.n_spatial_dims + device = mesh.points.device + dtype = mesh.points.dtype + + ### Handle empty mesh + if n_cells == 0: + empty_long = torch.empty(0, dtype=torch.long, device=device) + return cls( + node_aabb_min=torch.empty((0, D), dtype=dtype, device=device), + node_aabb_max=torch.empty((0, D), dtype=dtype, device=device), + node_left_child=empty_long, + node_right_child=empty_long, + leaf_start=empty_long, + leaf_count=empty_long, + sorted_cell_order=empty_long, + batch_size=torch.Size([]), + ) + + ### Compute per-cell bounding boxes and centroids + cell_vertices = mesh.points[mesh.cells] # (n_cells, n_verts, D) + cell_aabb_min = cell_vertices.min(dim=1).values # (n_cells, D) + cell_aabb_max = cell_vertices.max(dim=1).values # (n_cells, D) + cell_centroids = cell_vertices.mean(dim=1) # (n_cells, D) + + ### Sort cells by morton code for spatial coherence + morton_codes = _compute_morton_codes(cell_centroids) + sorted_order = morton_codes.argsort(stable=True) # (n_cells,) + sorted_aabb_min = cell_aabb_min[sorted_order] # (n_cells, D) + sorted_aabb_max = cell_aabb_max[sorted_order] # (n_cells, D) + + ### Pre-allocate node storage with tight upper bound + # Midpoint splits guarantee min leaf size of (leaf_size + 1) // 2, + # bounding the maximum number of leaves (and thus total nodes). + min_cells_per_leaf = max(1, (leaf_size + 1) // 2) + max_leaves = (n_cells + min_cells_per_leaf - 1) // min_cells_per_leaf + max_nodes = max(1, 2 * max_leaves - 1) + + node_aabb_min_buf = torch.full( + (max_nodes, D), float("inf"), dtype=dtype, device=device + ) + node_aabb_max_buf = torch.full( + (max_nodes, D), float("-inf"), dtype=dtype, device=device + ) + node_left_child = torch.full((max_nodes,), -1, dtype=torch.long, device=device) + node_right_child = torch.full((max_nodes,), -1, dtype=torch.long, device=device) + leaf_start_buf = torch.full((max_nodes,), -1, dtype=torch.long, device=device) + leaf_count_buf = torch.zeros(max_nodes, dtype=torch.long, device=device) + + # --------------------------------------------------------------- + # Phase 1: Top-down construction (O(log N) iterations) + # --------------------------------------------------------------- + # Each segment is a contiguous range [start, end) in the sorted + # cell array, associated with a BVH node. + + seg_starts = torch.tensor([0], dtype=torch.long, device=device) + seg_ends = torch.tensor([n_cells], dtype=torch.long, device=device) + seg_node_ids = torch.tensor([0], dtype=torch.long, device=device) + node_count = 1 # root already allocated + + # Track internal nodes per level for the bottom-up AABB pass + internal_nodes_per_level: list[torch.Tensor] = [] + + while len(seg_starts) > 0: + seg_sizes = seg_ends - seg_starts # (n_segs,) + + ### Classify segments as leaf or internal + is_leaf_seg = seg_sizes <= leaf_size + is_internal_seg = ~is_leaf_seg + + ### Process leaf segments: record ranges and compute AABBs + leaf_indices = torch.where(is_leaf_seg)[0] + if len(leaf_indices) > 0: + leaf_nids = seg_node_ids[leaf_indices] + l_starts = seg_starts[leaf_indices] + l_sizes = seg_sizes[leaf_indices] + + leaf_start_buf[leaf_nids] = l_starts + leaf_count_buf[leaf_nids] = l_sizes + + # Segmented AABB reduction (total work across all levels = O(N)) + seg_min, seg_max = _compute_leaf_aabbs( + l_starts, l_sizes, sorted_aabb_min, sorted_aabb_max + ) + node_aabb_min_buf[leaf_nids] = seg_min + node_aabb_max_buf[leaf_nids] = seg_max + + ### Process internal segments: split at midpoint, assign children + internal_indices = torch.where(is_internal_seg)[0] + if len(internal_indices) == 0: + break + + int_starts = seg_starts[internal_indices] + int_ends = seg_ends[internal_indices] + int_sizes = seg_sizes[internal_indices] + int_node_ids = seg_node_ids[internal_indices] + + midpoints = int_starts + int_sizes // 2 + + # Assign child node IDs (breadth-first within each level) + n_internal = len(internal_indices) + left_ids = ( + node_count + + torch.arange(n_internal, dtype=torch.long, device=device) * 2 + ) + right_ids = left_ids + 1 + node_count += 2 * n_internal + + # Record parent-child links + node_left_child[int_node_ids] = left_ids + node_right_child[int_node_ids] = right_ids + + # Track for bottom-up pass + internal_nodes_per_level.append(int_node_ids) + + # Prepare next level: left children then right children + seg_starts = torch.cat([int_starts, midpoints]) + seg_ends = torch.cat([midpoints, int_ends]) + seg_node_ids = torch.cat([left_ids, right_ids]) + + # --------------------------------------------------------------- + # Phase 2: Bottom-up AABB propagation (O(log N) iterations) + # --------------------------------------------------------------- + # Internal node AABB = union of its two children's AABBs. + # Process from deepest internal level to root. + + for level_node_ids in reversed(internal_nodes_per_level): + left = node_left_child[level_node_ids] + right = node_right_child[level_node_ids] + node_aabb_min_buf[level_node_ids] = torch.minimum( + node_aabb_min_buf[left], node_aabb_min_buf[right] + ) + node_aabb_max_buf[level_node_ids] = torch.maximum( + node_aabb_max_buf[left], node_aabb_max_buf[right] + ) + + ### Trim to actual node count + return cls( + node_aabb_min=node_aabb_min_buf[:node_count], + node_aabb_max=node_aabb_max_buf[:node_count], + node_left_child=node_left_child[:node_count], + node_right_child=node_right_child[:node_count], + leaf_start=leaf_start_buf[:node_count], + leaf_count=leaf_count_buf[:node_count], + sorted_cell_order=sorted_order, + batch_size=torch.Size([]), + ) + + def point_in_aabb( + self, + points: torch.Tensor, + aabb_min: torch.Tensor, + aabb_max: torch.Tensor, + ) -> torch.Tensor: + """Test if points are inside axis-aligned bounding boxes. + + Parameters + ---------- + points : torch.Tensor + Query points, shape ``(n_points, n_spatial_dims)``. + aabb_min : torch.Tensor + Minimum corners, shape ``(n_boxes, n_spatial_dims)``. + aabb_max : torch.Tensor + Maximum corners, shape ``(n_boxes, n_spatial_dims)``. + + Returns + ------- + torch.Tensor + Boolean tensor of shape ``(n_points, n_boxes)`` indicating + containment. + """ + if points.ndim != 2 or aabb_min.ndim != 2 or aabb_max.ndim != 2: + raise ValueError( + f"All inputs must be 2D tensors; got points={tuple(points.shape)}, " + f"aabb_min={tuple(aabb_min.shape)}, aabb_max={tuple(aabb_max.shape)}" + ) + D = points.shape[1] + if aabb_min.shape[1] != D or aabb_max.shape[1] != D: + raise ValueError( + f"Spatial dimension mismatch: points has {D} dims, " + f"aabb_min has {aabb_min.shape[1]}, aabb_max has {aabb_max.shape[1]}" + ) + + points_exp = points.unsqueeze(1) # (n_points, 1, D) + aabb_min_exp = aabb_min.unsqueeze(0) # (1, n_boxes, D) + aabb_max_exp = aabb_max.unsqueeze(0) # (1, n_boxes, D) + + inside = ((points_exp >= aabb_min_exp) & (points_exp <= aabb_max_exp)).all( + dim=2 + ) + return inside + + def find_candidate_cells( + self, + query_points: torch.Tensor, + max_candidates_per_point: int | None = 32, + aabb_tolerance: float = 1e-6, + ) -> Adjacency: + """Find candidate cells that might contain each query point. + + Uses batched iterative BVH traversal where all queries are processed + simultaneously in a vectorized manner. + + Parameters + ---------- + query_points : torch.Tensor + Points to query, shape ``(n_queries, n_spatial_dims)``. + max_candidates_per_point : int | None, optional + Maximum number of candidate cells to return per query point. + Prevents memory explosion for degenerate cases. If None, no + limit is applied. + aabb_tolerance : float, optional + Tolerance for AABB intersection test. Important for degenerate + cells (e.g., cells with duplicate vertices). + + Returns + ------- + Adjacency + Adjacency object where candidates for query *i* are at + ``result.indices[result.offsets[i]:result.offsets[i+1]]``. + Use ``result.to_list()`` for a list-of-tensors representation. + + Notes + ----- + Complexity is O(M log N) where M = queries, N = cells. All AABB tests + and tree operations are fully vectorized across queries - there are no + Python-level loops over individual query points. The outer loop runs + once per tree level (O(log N) iterations). + """ + if query_points.ndim != 2: + raise ValueError( + f"query_points must be 2D (n_queries, n_spatial_dims), got " + f"{query_points.ndim}D with shape {tuple(query_points.shape)}" + ) + if not query_points.is_floating_point(): + raise TypeError( + f"query_points must be a floating-point tensor " + f"(got {query_points.dtype=!r})" + ) + if self.n_nodes > 0 and query_points.shape[1] != self.n_spatial_dims: + raise ValueError( + f"query_points has {query_points.shape[1]} spatial dims, but " + f"BVH has {self.n_spatial_dims}" + ) + + n_queries = query_points.shape[0] + dev = self.device + + ### Handle empty BVH or empty query + if self.n_nodes == 0 or n_queries == 0: + return build_adjacency_from_pairs( + source_indices=torch.empty(0, dtype=torch.long, device=dev), + target_indices=torch.empty(0, dtype=torch.long, device=dev), + n_sources=n_queries, + ) + + ### Initialize work queue: all queries start at root (node 0) + current_query_indices = torch.arange(n_queries, dtype=torch.long, device=dev) + current_node_indices = torch.zeros(n_queries, dtype=torch.long, device=dev) + + ### Track candidate counts per query (for max_candidates enforcement) + candidates_count = torch.zeros(n_queries, dtype=torch.long, device=dev) + + ### Accumulate (query_idx, cell_idx) result pairs + all_query_indices_list: list[torch.Tensor] = [] + all_cell_indices_list: list[torch.Tensor] = [] + + ### Iterative traversal: one iteration per tree level + while len(current_query_indices) > 0: + ### Vectorized AABB containment test for all active pairs + batch_points = query_points[current_query_indices] # (n_active, D) + batch_min = self.node_aabb_min[current_node_indices] + batch_max = self.node_aabb_max[current_node_indices] + + inside = ( + (batch_points >= batch_min - aabb_tolerance) + & (batch_points <= batch_max + aabb_tolerance) + ).all(dim=1) + + ### Filter to intersecting pairs only + hit_query = current_query_indices[inside] + hit_node = current_node_indices[inside] + + if len(hit_query) == 0: + break + + ### Separate leaf hits from internal-node hits + hit_leaf_count = self.leaf_count[hit_node] + is_leaf = hit_leaf_count > 0 + + ### Handle leaf hits: expand to (query, cell) pairs + if is_leaf.any(): + expanded_q, expanded_c = _expand_leaf_hits( + hit_query[is_leaf], + hit_node[is_leaf], + self.leaf_start, + self.leaf_count, + self.sorted_cell_order, + ) + if len(expanded_q) > 0: + all_query_indices_list.append(expanded_q) + all_cell_indices_list.append(expanded_c) + + candidates_count.scatter_add_( + 0, expanded_q, torch.ones_like(expanded_q) + ) + + ### Handle internal-node hits: expand to children + is_internal = ~is_leaf + int_query = hit_query[is_internal] + int_node = hit_node[is_internal] + + # Enforce max_candidates limit + if max_candidates_per_point is not None and len(int_query) > 0: + under_limit = candidates_count[int_query] < max_candidates_per_point + int_query = int_query[under_limit] + int_node = int_node[under_limit] + + if len(int_query) == 0: + break + + left_children = self.node_left_child[int_node] + right_children = self.node_right_child[int_node] + + valid_left = left_children >= 0 + valid_right = right_children >= 0 + + parts_q: list[torch.Tensor] = [] + parts_n: list[torch.Tensor] = [] + if valid_left.any(): + parts_q.append(int_query[valid_left]) + parts_n.append(left_children[valid_left]) + if valid_right.any(): + parts_q.append(int_query[valid_right]) + parts_n.append(right_children[valid_right]) + + if parts_q: + current_query_indices = torch.cat(parts_q) + current_node_indices = torch.cat(parts_n) + else: + break + + ### Build Adjacency from accumulated pairs + if all_query_indices_list: + all_q = torch.cat(all_query_indices_list) + all_c = torch.cat(all_cell_indices_list) + else: + all_q = torch.empty(0, dtype=torch.long, device=dev) + all_c = torch.empty(0, dtype=torch.long, device=dev) + + adjacency = build_adjacency_from_pairs( + source_indices=all_q, + target_indices=all_c, + n_sources=n_queries, + ) + return adjacency.truncate_per_source(max_candidates_per_point) diff --git a/physicsnemo/mesh/subdivision/__init__.py b/physicsnemo/mesh/subdivision/__init__.py new file mode 100644 index 0000000000..942a05da2a --- /dev/null +++ b/physicsnemo/mesh/subdivision/__init__.py @@ -0,0 +1,40 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Mesh subdivision algorithms for simplicial meshes. + +This module provides subdivision schemes for refining simplicial meshes: +- Linear: Simple midpoint subdivision (interpolating) +- Butterfly: Weighted stencil subdivision for smooth surfaces (interpolating) +- Loop: Valence-based subdivision with vertex repositioning (approximating) + +All schemes work by: +1. Extracting edges from the mesh +2. Adding new vertices (at or near edge midpoints) +3. Splitting each n-simplex into 2^n child simplices +4. Interpolating/propagating data to new mesh + +Example: + >>> from physicsnemo.mesh.subdivision import subdivide_linear + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> subdivided = subdivide_linear(mesh) + >>> assert subdivided.n_cells == mesh.n_cells * 4 # 2^2 for 2D +""" + +from physicsnemo.mesh.subdivision.butterfly import subdivide_butterfly +from physicsnemo.mesh.subdivision.linear import subdivide_linear +from physicsnemo.mesh.subdivision.loop import subdivide_loop diff --git a/physicsnemo/mesh/subdivision/_data.py b/physicsnemo/mesh/subdivision/_data.py new file mode 100644 index 0000000000..7f31f9d3f9 --- /dev/null +++ b/physicsnemo/mesh/subdivision/_data.py @@ -0,0 +1,154 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data interpolation and propagation for mesh subdivision. + +Handles interpolating point_data to edge midpoints and propagating cell_data +from parent cells to child cells, reusing existing aggregation infrastructure. +""" + +from typing import TYPE_CHECKING + +import torch +from tensordict import TensorDict + +from physicsnemo.mesh.utilities._cache import CACHE_KEY + +if TYPE_CHECKING: + pass + + +def interpolate_point_data_to_edges( + point_data: TensorDict, + edges: torch.Tensor, + n_original_points: int, +) -> TensorDict: + """Interpolate point_data to edge midpoints. + + For each edge, creates interpolated data at the midpoint by averaging + the data values at the two endpoint vertices. + + Parameters + ---------- + point_data : TensorDict + Original point data, batch_size=(n_original_points,) + edges : torch.Tensor + Edge connectivity, shape (n_edges, 2) + n_original_points : int + Number of original points (for validation) + + Returns + ------- + TensorDict + New point_data with batch_size=(n_original_points + n_edges,) + containing both original point data and interpolated edge midpoint data. + + Examples + -------- + >>> import torch + >>> from tensordict import TensorDict + >>> # Original points: 3, edges: 2 + >>> # New points: 3 + 2 = 5 + >>> point_data = TensorDict({"temperature": torch.tensor([100., 200., 300.])}, batch_size=[3]) + >>> edges = torch.tensor([[0, 1], [1, 2]]) + >>> new_data = interpolate_point_data_to_edges(point_data, edges, 3) + >>> # new_data["temperature"] = [100, 200, 300, 150, 250] + """ + if len(point_data.keys()) == 0: + # No data to interpolate + return TensorDict( + {}, + batch_size=torch.Size([n_original_points + len(edges)]), + device=edges.device, + ) + + n_total_points = n_original_points + len(edges) + + ### Interpolate all fields using TensorDict.apply() + def interpolate_tensor(tensor: torch.Tensor) -> torch.Tensor: + """Interpolate a single tensor to edge midpoints.""" + # Only interpolate floating point or complex tensors + # Integer/bool metadata (like IDs) cannot be meaningfully averaged + if not (tensor.dtype.is_floating_point or tensor.dtype.is_complex): + # For non-floating types, pad with zeros (will be filtered later if needed) + # or we could assign arbitrary values; zeros are safe default + edge_midpoint_values = torch.zeros( + (len(edges), *tensor.shape[1:]), + dtype=tensor.dtype, + device=tensor.device, + ) + else: + # Get endpoint values and average: shape (n_edges, *data_shape) + edge_midpoint_values = tensor[edges].mean(dim=1) + + # Concatenate original and edge midpoint data + return torch.cat([tensor, edge_midpoint_values], dim=0) + + return point_data.exclude(CACHE_KEY).apply( + interpolate_tensor, + batch_size=torch.Size([n_total_points]), + ) + + +def propagate_cell_data_to_children( + cell_data: TensorDict, + parent_indices: torch.Tensor, + n_total_children: int, +) -> TensorDict: + """Propagate cell_data from parent cells to child cells. + + Each child cell inherits its parent's data values unchanged. + Uses scatter operations for efficient vectorized propagation. + + Parameters + ---------- + cell_data : TensorDict + Original cell data, batch_size=(n_parent_cells,) + parent_indices : torch.Tensor + Parent cell index for each child, shape (n_total_children,) + n_total_children : int + Total number of child cells + + Returns + ------- + TensorDict + New cell_data with batch_size=(n_total_children,) where each child + has the same data values as its parent. + + Examples + -------- + >>> import torch + >>> from tensordict import TensorDict + >>> # 2 parent cells, each splits into 4 children -> 8 total + >>> cell_data = TensorDict({"pressure": torch.tensor([100.0, 200.0])}, batch_size=[2]) + >>> parent_indices = torch.tensor([0, 0, 0, 0, 1, 1, 1, 1]) + >>> new_data = propagate_cell_data_to_children(cell_data, parent_indices, 8) + >>> # new_data["pressure"] = [100, 100, 100, 100, 200, 200, 200, 200] + """ + if len(cell_data.keys()) == 0: + # No data to propagate + return TensorDict( + {}, + batch_size=torch.Size([n_total_children]), + device=parent_indices.device, + ) + + ### Propagate all fields using TensorDict.apply() + # Each child simply inherits its parent's value via indexing + return cell_data.exclude(CACHE_KEY).apply( + lambda tensor: tensor[parent_indices], + batch_size=torch.Size([n_total_children]), + ) diff --git a/physicsnemo/mesh/subdivision/_topology.py b/physicsnemo/mesh/subdivision/_topology.py new file mode 100644 index 0000000000..211b120186 --- /dev/null +++ b/physicsnemo/mesh/subdivision/_topology.py @@ -0,0 +1,213 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Topology generation for mesh subdivision. + +This module handles the combinatorial aspects of subdivision: computing +subdivision patterns and generating child cell connectivity. + +Edge extraction is provided by +:func:`physicsnemo.mesh.utilities._topology.extract_unique_edges`, +re-exported here for backwards compatibility. +""" + +import torch + +from physicsnemo.mesh.utilities._topology import extract_unique_edges # noqa: F401 + + +def get_subdivision_pattern(n_manifold_dims: int) -> torch.Tensor: + """Get the subdivision pattern for splitting an n-simplex. + + Returns a pattern tensor that encodes how to split an n-simplex into + 2^n child simplices using edge midpoints. + + The pattern uses a specific vertex indexing scheme: + - Indices 0 to n: original vertices + - Indices n+1 to n+C(n+1,2): edge midpoints, indexed by edge + + For each n-simplex: + - n+1 original vertices + - C(n+1, 2) edges, each gets a midpoint + - Splits into 2^n child simplices + + Parameters + ---------- + n_manifold_dims : int + Manifold dimension of the mesh. + + Returns + ------- + torch.Tensor + Pattern tensor of shape (n_children, n_vertices_per_child) where: + - n_children = 2^n_manifold_dims + - n_vertices_per_child = n_manifold_dims + 1 + + Each row specifies vertex indices for one child simplex. + Indices reference: [v0, v1, ..., vn, e01, e02, ..., e(n-1,n)] + where v_i are original vertices and e_ij are edge midpoints. + + Examples + -------- + For a triangle (n=2): + - 3 original vertices: v0, v1, v2 + - 3 edge midpoints: e01, e12, e20 + - Indexing: [v0=0, v1=1, v2=2, e01=3, e12=4, e20=5] + - 4 children: [v0, e01, e20], [v1, e12, e01], [v2, e20, e12], [e01, e12, e20] + """ + if n_manifold_dims == 1: + ### 1-simplex (edge) splits into 2 edges + # Vertices: [v0, v1, e01] + # Children: [v0, e01], [e01, v1] + return torch.tensor( + [ + [0, 2], # Child 0: v0 to e01 + [2, 1], # Child 1: e01 to v1 + ], + dtype=torch.int64, + ) + + elif n_manifold_dims == 2: + ### 2-simplex (triangle) splits into 4 triangles + # Vertices: [v0, v1, v2, e01, e12, e20] + # Edge ordering from _generate_combination_indices(3, 2): + # (0,1), (0,2), (1,2) -> indices 3, 4, 5 + return torch.tensor( + [ + [0, 3, 4], # Corner at v0: v0, e01, e02 + [1, 5, 3], # Corner at v1: v1, e12, e01 + [2, 4, 5], # Corner at v2: v2, e02, e12 + [3, 5, 4], # Center: e01, e12, e02 + ], + dtype=torch.int64, + ) + + elif n_manifold_dims == 3: + ### 3-simplex (tetrahedron) splits into 8 tetrahedra + # Vertices: [v0, v1, v2, v3, e01, e02, e03, e12, e13, e23] + # Edge ordering from _generate_combination_indices(4, 2): + # (0,1)=4, (0,2)=5, (0,3)=6, (1,2)=7, (1,3)=8, (2,3)=9 + return torch.tensor( + [ + [0, 4, 5, 6], # Corner at v0 + [1, 4, 7, 8], # Corner at v1 + [2, 5, 7, 9], # Corner at v2 + [3, 6, 8, 9], # Corner at v3 + [4, 5, 7, 8], # Inner tet 1 + [5, 6, 8, 9], # Inner tet 2 + [4, 5, 6, 8], # Inner tet 3 + [5, 7, 8, 9], # Inner tet 4 + ], + dtype=torch.int64, + ) + + else: + raise NotImplementedError( + f"Subdivision pattern not implemented for {n_manifold_dims=}. " + f"Currently supported: 1D (edges), 2D (triangles), 3D (tetrahedra)." + ) + + +def generate_child_cells( + parent_cells: torch.Tensor, + edge_inverse: torch.Tensor, + n_original_points: int, + subdivision_pattern: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor]: + """Generate child cells from parent cells using subdivision pattern. + + This implementation is fully vectorized using torch operations, avoiding Python loops + and GPU-CPU transfers for optimal performance on both CPU and GPU. + + Parameters + ---------- + parent_cells : torch.Tensor + Parent cell connectivity, shape (n_parent_cells, n_vertices_per_cell) + edge_inverse : torch.Tensor + Mapping from candidate edges to unique edge indices, + shape (n_parent_cells * n_edges_per_cell,). This comes from torch.unique() + called in extract_unique_edges(). + n_original_points : int + Number of points in original mesh (before adding edge midpoints) + subdivision_pattern : torch.Tensor + Pattern from get_subdivision_pattern(), + shape (n_children_per_parent, n_vertices_per_child) + + Returns + ------- + tuple[torch.Tensor, torch.Tensor] + Tuple of (child_cells, parent_indices): + - child_cells: Child cell connectivity, + shape (n_parent_cells * n_children_per_parent, n_vertices_per_child) + - parent_indices: Parent cell index for each child, + shape (n_parent_cells * n_children_per_parent,) + + Algorithm + --------- + 1. Reshape edge_inverse to (n_parent_cells, n_edges_per_cell) for per-cell lookup + 2. Build local_to_global mapping for ALL cells at once via concatenation + 3. Apply subdivision pattern using torch.gather to generate all children + 4. No Python loops, no GPU-CPU transfers - fully vectorized + """ + n_parent_cells, n_vertices_per_cell = parent_cells.shape + n_children_per_parent = subdivision_pattern.shape[0] + device = parent_cells.device + + ### Compute number of edges per cell + # For n-simplex: C(n+1, 2) = (n+1) * n / 2 + n_edges_per_cell = (n_vertices_per_cell * (n_vertices_per_cell - 1)) // 2 + + ### Reshape edge_inverse to per-cell mapping + # Shape: (n_parent_cells, n_edges_per_cell) + # edge_inverse_per_cell[i, j] = global edge index for j-th edge of cell i + edge_inverse_per_cell = edge_inverse.reshape(n_parent_cells, n_edges_per_cell) + + ### Build local_to_global mapping for ALL cells at once + # Shape: (n_parent_cells, n_vertices_per_cell + n_edges_per_cell) + # First n_vertices_per_cell entries: original vertices of the cell + # Next n_edges_per_cell entries: global point indices of edge midpoints + local_to_global = torch.cat( + [ + parent_cells, # (n_parent_cells, n_vertices_per_cell) + n_original_points + + edge_inverse_per_cell, # (n_parent_cells, n_edges_per_cell) + ], + dim=1, + ) + + ### Apply subdivision pattern using torch.gather + # Expand pattern to match batch dimension: (1, n_children, n_vertices) → (n_cells, n_children, n_vertices) + pattern_expanded = subdivision_pattern.unsqueeze(0).expand(n_parent_cells, -1, -1) + + # Gather indices from local_to_global according to pattern + # local_to_global: (n_cells, local_size) + # pattern_expanded: (n_cells, n_children, n_vertices) + # Result: (n_cells, n_children, n_vertices) + child_cells = torch.gather( + local_to_global.unsqueeze(1).expand(-1, n_children_per_parent, -1), + dim=2, + index=pattern_expanded, + ).reshape(n_parent_cells * n_children_per_parent, n_vertices_per_cell) + + ### Generate parent indices for each child + # Shape: (n_parent_cells * n_children_per_parent,) + parent_indices = torch.arange( + n_parent_cells, + dtype=torch.int64, + device=device, + ).repeat_interleave(n_children_per_parent) + + return child_cells, parent_indices diff --git a/physicsnemo/mesh/subdivision/butterfly.py b/physicsnemo/mesh/subdivision/butterfly.py new file mode 100644 index 0000000000..6525866edc --- /dev/null +++ b/physicsnemo/mesh/subdivision/butterfly.py @@ -0,0 +1,371 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Butterfly subdivision for simplicial meshes. + +Butterfly is an interpolating subdivision scheme where original vertices remain +fixed and new edge midpoints are computed using weighted stencils of neighboring +vertices. This produces smoother surfaces than linear subdivision. + +The classical butterfly scheme is designed for 2D manifolds (triangular meshes). +This implementation provides the standard 2D butterfly and extensions/fallbacks +for other dimensions. +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.subdivision._data import propagate_cell_data_to_children +from physicsnemo.mesh.subdivision._topology import ( + extract_unique_edges, + generate_child_cells, + get_subdivision_pattern, +) + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def _build_edge_to_triangle_pairs( + candidate_edges: torch.Tensor, + parent_cell_indices: torch.Tensor, + n_unique_edges: int, + unique_edge_hashes: torch.Tensor, + max_vertex: int, + device: torch.device, +) -> torch.Tensor: + """Build a (n_unique_edges, 2) tensor mapping each edge to its parent triangles. + + Parameters + ---------- + candidate_edges : torch.Tensor + All triangle half-edges (with duplicates), shape (n_candidates, 2). + parent_cell_indices : torch.Tensor + Parent triangle index for each candidate, shape (n_candidates,). + n_unique_edges : int + Number of unique edges in the mesh. + unique_edge_hashes : torch.Tensor + Hash of each unique edge (sorted order), shape (n_unique_edges,). + max_vertex : int + Value used for hash computation: ``hash = v0 * max_vertex + v1``. + device : torch.device + Target device. + + Returns + ------- + torch.Tensor + Shape (n_unique_edges, 2). ``result[i]`` holds the (up to 2) parent + triangle indices for unique edge ``i``; boundary edges have ``-1`` in + the second slot. + """ + ### Hash candidate edges (canonicalized) and map to unique edge indices + sorted_cands, _ = torch.sort(candidate_edges, dim=1) + cand_hash = sorted_cands[:, 0] * max_vertex + sorted_cands[:, 1] + + sorted_unique_hash, unique_sort_perm = torch.sort(unique_edge_hashes) + positions = torch.searchsorted(sorted_unique_hash, cand_hash) + positions = positions.clamp(max=len(sorted_unique_hash) - 1) + edge_idx = unique_sort_perm[positions] # Maps each candidate to a unique-edge index + + ### Fill pair table by scattering parent triangle indices + pair_table = torch.full((n_unique_edges, 2), -1, dtype=torch.long, device=device) + + # First pass fills slot 0 for every edge + pair_table[:, 0].scatter_(0, edge_idx, parent_cell_indices) + + # Second pass fills slot 1 for edges with 2 parents. Mask out candidates + # whose parent already occupies slot 0 so we only write the *other* parent. + slot0_parent = pair_table[edge_idx, 0] + is_second_parent = parent_cell_indices != slot0_parent + second_idx = edge_idx[is_second_parent] + second_parents = parent_cell_indices[is_second_parent] + pair_table[:, 1].scatter_(0, second_idx, second_parents) + + return pair_table + + +def compute_butterfly_weights_2d( + mesh: "Mesh", + unique_edges: torch.Tensor, +) -> torch.Tensor: + r"""Compute butterfly weighted positions for edge midpoints in 2D manifolds. + + For triangular meshes, uses the classical 8-point butterfly stencil + (Dyn, Gregory & Levin 1990): + + - Edge vertices v0, v1: weight 1/2 each + - Opposite vertices a, b in the two adjacent triangles: weight 1/8 each + - Four "wing" vertices c, d, e, f: weight -1/16 each + + These weights sum to exactly 1.0 when all wing vertices exist. For + interior edges adjacent to boundary edges (missing some wing vertices), + the missing wing contributions are omitted (treated as zero weight). + + Boundary edges use the simple midpoint average of the two endpoints. + + Parameters + ---------- + mesh : Mesh + Input 2D manifold mesh (triangular). + unique_edges : torch.Tensor + Unique edge connectivity, shape (n_edges, 2). + + Returns + ------- + torch.Tensor + Edge midpoint positions using butterfly weights, shape (n_edges, n_spatial_dims). + """ + n_edges = len(unique_edges) + device = mesh.points.device + dtype = mesh.points.dtype + + ### Step 1: Build edge → parent-triangle mapping + from physicsnemo.mesh.boundaries import extract_candidate_facets + + candidate_edges, parent_cell_indices = extract_candidate_facets( + mesh.cells, + manifold_codimension=mesh.n_manifold_dims - 1, + ) + + # Canonical (sorted) hashes for the unique edges + sorted_unique, _ = torch.sort(unique_edges, dim=1) + sorted_cands, _ = torch.sort(candidate_edges, dim=1) + max_v = max(sorted_unique.max().item(), sorted_cands.max().item()) + 1 + unique_hash = sorted_unique[:, 0] * max_v + sorted_unique[:, 1] + + # Pair table: (n_edges, 2), with -1 for missing second triangle + edge_tri_pairs = _build_edge_to_triangle_pairs( + candidate_edges=candidate_edges, + parent_cell_indices=parent_cell_indices, + n_unique_edges=n_edges, + unique_edge_hashes=unique_hash, + max_vertex=max_v, + device=device, + ) + + ### Step 2: Classify edges + is_interior = edge_tri_pairs[:, 1] >= 0 + is_boundary = ~is_interior + + ### Step 3: Initialize midpoints + edge_midpoints = torch.zeros( + (n_edges, mesh.n_spatial_dims), dtype=dtype, device=device + ) + + ### Step 4: Boundary edges → simple average + boundary_idx = torch.where(is_boundary)[0] + if len(boundary_idx) > 0: + bv0 = mesh.points[unique_edges[boundary_idx, 0]] + bv1 = mesh.points[unique_edges[boundary_idx, 1]] + edge_midpoints[boundary_idx] = (bv0 + bv1) / 2 + + ### Step 5: Interior edges → 8-point butterfly stencil + interior_idx = torch.where(is_interior)[0] + n_interior = len(interior_idx) + + if n_interior == 0: + return edge_midpoints + + int_edges = unique_edges[interior_idx] # (n_int, 2) + int_tris = edge_tri_pairs[interior_idx] # (n_int, 2) [T0, T1] + + ### Find opposite vertices a (in T0) and b (in T1) + v0 = int_edges[:, 0] # (n_int,) + v1 = int_edges[:, 1] # (n_int,) + + T0_verts = mesh.cells[int_tris[:, 0]] # (n_int, 3) + T0_opp_mask = ~((T0_verts == v0.unsqueeze(1)) | (T0_verts == v1.unsqueeze(1))) + a = torch.gather( + T0_verts, 1, torch.argmax(T0_opp_mask.int(), dim=1, keepdim=True) + ).squeeze(1) + + T1_verts = mesh.cells[int_tris[:, 1]] # (n_int, 3) + T1_opp_mask = ~((T1_verts == v0.unsqueeze(1)) | (T1_verts == v1.unsqueeze(1))) + b = torch.gather( + T1_verts, 1, torch.argmax(T1_opp_mask.int(), dim=1, keepdim=True) + ).squeeze(1) + + ### 4-point base contribution: 1/2·v0 + 1/2·v1 + 1/8·a + 1/8·b + midpoint = ( + 0.5 * mesh.points[v0] + + 0.5 * mesh.points[v1] + + 0.125 * mesh.points[a] + + 0.125 * mesh.points[b] + ) # (n_int, n_spatial_dims) + + ### Step 6: Wing vertices (−1/16 each) + # + # For edge (v0, v1) with opposite vertices a (in T0) and b (in T1): + # wing_c: opposite vertex in the OTHER tri sharing edge (v0, a) [not T0] + # wing_d: opposite vertex in the OTHER tri sharing edge (v1, a) [not T0] + # wing_e: opposite vertex in the OTHER tri sharing edge (v0, b) [not T1] + # wing_f: opposite vertex in the OTHER tri sharing edge (v1, b) [not T1] + + # Pre-compute sorted unique hash lookup for vectorized edge queries + sorted_uhash, uhash_perm = torch.sort(unique_hash) + n_uhash = len(sorted_uhash) + + wing_edges_and_known_tris = [ + (torch.stack([v0, a], dim=1), int_tris[:, 0]), # wing_c + (torch.stack([v1, a], dim=1), int_tris[:, 0]), # wing_d + (torch.stack([v0, b], dim=1), int_tris[:, 1]), # wing_e + (torch.stack([v1, b], dim=1), int_tris[:, 1]), # wing_f + ] + + for wing_edge, known_tri in wing_edges_and_known_tris: + # Hash the wing edges and look them up in the unique edge set + ws, _ = torch.sort(wing_edge, dim=1) + whash = ws[:, 0] * max_v + ws[:, 1] + + pos = torch.searchsorted(sorted_uhash, whash).clamp(max=n_uhash - 1) + matched = sorted_uhash[pos] == whash + eidx = uhash_perm[pos] # Index into edge_tri_pairs + + # Look up the two parent triangles for each wing edge + wing_pair = edge_tri_pairs[eidx] # (n_int, 2) + + # Select the "other" triangle (not known_tri) + other_tri = torch.where( + wing_pair[:, 0] == known_tri, + wing_pair[:, 1], + wing_pair[:, 0], + ) + + # A wing vertex exists iff the edge was found AND the other tri is valid + has_wing = matched & (other_tri >= 0) + + if not has_wing.any(): + continue + + valid = torch.where(has_wing)[0] + other_verts = mesh.cells[other_tri[valid]] # (n_valid, 3) + + # The wing vertex is the one in other_tri that is NOT in wing_edge + we0 = wing_edge[valid, 0].unsqueeze(1) + we1 = wing_edge[valid, 1].unsqueeze(1) + opp_mask = ~((other_verts == we0) | (other_verts == we1)) + wing_vert = torch.gather( + other_verts, 1, torch.argmax(opp_mask.int(), dim=1, keepdim=True) + ).squeeze(1) + + midpoint[valid] -= (1.0 / 16.0) * mesh.points[wing_vert] + + edge_midpoints[interior_idx] = midpoint + return edge_midpoints + + +def subdivide_butterfly(mesh: "Mesh") -> "Mesh": + """Perform one level of butterfly subdivision on the mesh. + + Butterfly subdivision is an interpolating scheme that produces smoother + results than linear subdivision by using weighted stencils for new vertices. + + Properties: + - Interpolating: original vertices remain unchanged + - New edge midpoints use weighted neighbor stencils + - Designed for 2D manifolds (triangular meshes) + - For non-2D manifolds: falls back to linear subdivision with warning + + The connectivity pattern is identical to linear subdivision (same topology), + but the geometric positions of new vertices differ. + + Parameters + ---------- + mesh : Mesh + Input mesh to subdivide + + Returns + ------- + Mesh + Subdivided mesh with butterfly-weighted vertex positions + + Raises + ------ + NotImplementedError + If n_manifold_dims is not 2 (may be relaxed in future) + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> # Smooth a triangular surface + >>> mesh = sphere_icosahedral.load(subdivisions=2) + >>> smooth = subdivide_butterfly(mesh) + >>> # smooth has same connectivity as linear subdivision + >>> # but smoother geometry from weighted stencils + """ + from physicsnemo.mesh.mesh import Mesh + + ### Check manifold dimension + if mesh.n_manifold_dims != 2: + raise NotImplementedError( + f"Butterfly subdivision currently only supports 2D manifolds (triangular meshes). " + f"Got {mesh.n_manifold_dims=}. " + f"For other dimensions, use linear subdivision instead." + ) + + ### Handle empty mesh + if mesh.n_cells == 0: + return mesh + + ### Extract unique edges + unique_edges, edge_inverse = extract_unique_edges(mesh) + n_original_points = mesh.n_points + + ### Compute edge midpoints using butterfly weights + edge_midpoints = compute_butterfly_weights_2d(mesh, unique_edges) + + ### Create new points: original (unchanged) + butterfly midpoints + new_points = torch.cat([mesh.points, edge_midpoints], dim=0) + + ### Interpolate point_data to edge midpoints + # For butterfly, we could use the same weighted stencil for data, + # but for simplicity, use linear interpolation (average of endpoints) + from physicsnemo.mesh.subdivision._data import interpolate_point_data_to_edges + + new_point_data = interpolate_point_data_to_edges( + point_data=mesh.point_data, + edges=unique_edges, + n_original_points=n_original_points, + ) + + ### Get subdivision pattern (same as linear) + subdivision_pattern = get_subdivision_pattern(mesh.n_manifold_dims) + subdivision_pattern = subdivision_pattern.to(mesh.cells.device) + + ### Generate child cells (same topology as linear) + child_cells, parent_indices = generate_child_cells( + parent_cells=mesh.cells, + edge_inverse=edge_inverse, + n_original_points=n_original_points, + subdivision_pattern=subdivision_pattern, + ) + + ### Propagate cell_data + new_cell_data = propagate_cell_data_to_children( + cell_data=mesh.cell_data, + parent_indices=parent_indices, + n_total_children=len(child_cells), + ) + + ### Create and return subdivided mesh + return Mesh( + points=new_points, + cells=child_cells, + point_data=new_point_data, + cell_data=new_cell_data, + global_data=mesh.global_data, + ) diff --git a/physicsnemo/mesh/subdivision/linear.py b/physicsnemo/mesh/subdivision/linear.py new file mode 100644 index 0000000000..8d7a2acf3f --- /dev/null +++ b/physicsnemo/mesh/subdivision/linear.py @@ -0,0 +1,134 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Linear subdivision for simplicial meshes. + +Linear subdivision is the simplest subdivision scheme: each edge is split at +its midpoint, and each n-simplex is divided into 2^n smaller simplices. +This is an interpolating scheme - original vertices remain unchanged. + +Works for any manifold dimension and any spatial dimension (including higher +codimensions like curves in 3D or surfaces in 4D). +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.subdivision._data import ( + interpolate_point_data_to_edges, + propagate_cell_data_to_children, +) +from physicsnemo.mesh.subdivision._topology import ( + extract_unique_edges, + generate_child_cells, + get_subdivision_pattern, +) + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def subdivide_linear(mesh: "Mesh") -> "Mesh": + """Perform one level of linear subdivision on the mesh. + + Linear subdivision splits each n-simplex into 2^n child simplices by: + 1. Adding new vertices at edge midpoints + 2. Connecting vertices according to a subdivision pattern + + This is an interpolating scheme: original vertices keep their positions, + and new vertices are placed exactly at edge midpoints. + + Properties: + - Preserves manifold dimension and spatial dimension + - Increases mesh resolution uniformly + - Point data is interpolated to new vertices (averaged from endpoints) + - Cell data is propagated to children (each child inherits parent's data) + - Global data is preserved unchanged + + Parameters + ---------- + mesh : Mesh + Input mesh to subdivide (any manifold/spatial dimension) + + Returns + ------- + Mesh + Subdivided mesh with: + - n_points = original_n_points + n_edges + - n_cells = original_n_cells * 2^n_manifold_dims + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> # Triangle mesh: 2 triangles -> 8 triangles + >>> mesh = two_triangles_2d.load() + >>> subdivided = subdivide_linear(mesh) + >>> assert subdivided.n_cells == mesh.n_cells * 4 # 2^2 for 2D + """ + from physicsnemo.mesh.mesh import Mesh + + ### Handle empty mesh + if mesh.n_cells == 0: + return mesh + + ### Extract unique edges from mesh + unique_edges, edge_inverse = extract_unique_edges(mesh) + n_original_points = mesh.n_points + + ### Compute edge midpoints + # Shape: (n_edges, n_spatial_dims) + edge_vertices = mesh.points[unique_edges] # (n_edges, 2, n_spatial_dims) + edge_midpoints = edge_vertices.mean(dim=1) # Average the two endpoints + + ### Create new points array: original + midpoints + # Shape: (n_original_points + n_edges, n_spatial_dims) + new_points = torch.cat([mesh.points, edge_midpoints], dim=0) + + ### Interpolate point_data to edge midpoints + new_point_data = interpolate_point_data_to_edges( + point_data=mesh.point_data, + edges=unique_edges, + n_original_points=n_original_points, + ) + + ### Get subdivision pattern for this manifold dimension + subdivision_pattern = get_subdivision_pattern(mesh.n_manifold_dims) + subdivision_pattern = subdivision_pattern.to(mesh.cells.device) + + ### Generate child cells from parents + child_cells, parent_indices = generate_child_cells( + parent_cells=mesh.cells, + edge_inverse=edge_inverse, + n_original_points=n_original_points, + subdivision_pattern=subdivision_pattern, + ) + + ### Propagate cell_data from parents to children + new_cell_data = propagate_cell_data_to_children( + cell_data=mesh.cell_data, + parent_indices=parent_indices, + n_total_children=len(child_cells), + ) + + ### Create and return subdivided mesh + return Mesh( + points=new_points, + cells=child_cells, + point_data=new_point_data, + cell_data=new_cell_data, + global_data=mesh.global_data, # Preserved unchanged + ) diff --git a/physicsnemo/mesh/subdivision/loop.py b/physicsnemo/mesh/subdivision/loop.py new file mode 100644 index 0000000000..49a3793598 --- /dev/null +++ b/physicsnemo/mesh/subdivision/loop.py @@ -0,0 +1,385 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Loop subdivision for simplicial meshes. + +Loop subdivision is an approximating scheme where both old and new vertices +are repositioned. It produces smooth limit surfaces for triangular meshes. + +Original vertices are moved using valence-based weights, and new edge midpoints +use weighted averages. This provides C² continuity for regular vertices. + +Reference: Charles Loop, "Smooth Subdivision Surfaces Based on Triangles" (1987) +""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.neighbors._adjacency import build_adjacency_from_pairs +from physicsnemo.mesh.subdivision._data import propagate_cell_data_to_children +from physicsnemo.mesh.subdivision._topology import ( + extract_unique_edges, + generate_child_cells, + get_subdivision_pattern, +) + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def reposition_original_vertices_2d( + mesh: "Mesh", + unique_edges: torch.Tensor | None = None, +) -> torch.Tensor: + """Reposition original vertices using Loop's valence-based formula. + + For each vertex, compute new position as: + new_pos = (1 - n*beta) * old_pos + beta * sum(neighbor_positions) + + where n is the vertex valence and beta depends on n. + + This implementation is fully vectorized using the Adjacency structure directly, + avoiding any Python loops over mesh elements. + + Parameters + ---------- + mesh : Mesh + Input 2D manifold mesh + unique_edges : torch.Tensor | None, optional + Pre-computed unique edges (optional). If provided, uses these + instead of recomputing them, which saves significant time. + + Returns + ------- + torch.Tensor + Repositioned vertex positions, shape (n_points, n_spatial_dims) + """ + device = mesh.points.device + n_points = mesh.n_points + + ### Get point-to-point adjacency (vertex neighbors) + if unique_edges is not None: + # Build adjacency directly from pre-computed edges (avoids re-extracting + # edges from cells, which is the expensive part of get_point_to_points_adjacency) + sources = torch.cat([unique_edges[:, 0], unique_edges[:, 1]]) + targets = torch.cat([unique_edges[:, 1], unique_edges[:, 0]]) + adjacency = build_adjacency_from_pairs(sources, targets, n_sources=n_points) + else: + from physicsnemo.mesh.neighbors import get_point_to_points_adjacency + + adjacency = get_point_to_points_adjacency(mesh) + + ### Compute valences for all points at once + # valences[i] = offsets[i+1] - offsets[i] + # Shape: (n_points,) + valences = adjacency.offsets[1:] - adjacency.offsets[:-1] + + ### Compute beta weights for all valences at once + # Vectorize the beta formula + # If valence == 3: beta = 3/16 + # Else: beta = (1/n) * (5/8 - (3/8 + 1/4 * cos(2π/n))²) + # Shape: (n_points,) + + cos_term = 3.0 / 8.0 + 0.25 * torch.cos(2.0 * torch.pi / valences.float()) + beta_else = (1.0 / valences.float()) * (5.0 / 8.0 - cos_term * cos_term) + beta = torch.where(valences == 3, 3.0 / 16.0, beta_else) + # Handle isolated vertices (valence=0) - beta should be 0 to keep original position + beta = torch.where(valences > 0, beta, 0.0) + + ### Compute neighbor position sums for all points using scatter_add + # For each neighbor relationship, add neighbor's position to source point's sum + # Shape: (n_points, n_spatial_dims) + neighbor_sums = torch.zeros_like(mesh.points) + + # Get source point indices by expanding offsets + # For adjacency.indices[i], the source point is the one whose offset range contains i + # We can use searchsorted or create source indices directly + source_point_indices = torch.repeat_interleave( + torch.arange(n_points, dtype=torch.int64, device=device), + valences, + ) + + # Get neighbor positions and scatter-add to source points + # adjacency.indices contains the neighbor point indices + neighbor_positions = mesh.points[ + adjacency.indices + ] # (total_neighbors, n_spatial_dims) + + # Expand source_point_indices for scatter_add + source_point_indices_expanded = source_point_indices.unsqueeze(-1).expand( + -1, mesh.n_spatial_dims + ) + + neighbor_sums.scatter_add_( + dim=0, + index=source_point_indices_expanded, + src=neighbor_positions, + ) + + ### Apply Loop formula for all points at once + # new_pos = (1 - n*beta) * old_pos + beta * sum(neighbors) + # Shape: (n_points, n_spatial_dims) + valences_expanded = valences.unsqueeze(-1).float() # (n_points, 1) + beta_expanded = beta.unsqueeze(-1) # (n_points, 1) + + new_positions = ( + 1 - valences_expanded * beta_expanded + ) * mesh.points + beta_expanded * neighbor_sums + + return new_positions + + +def compute_loop_edge_positions_2d( + mesh: "Mesh", + unique_edges: torch.Tensor, +) -> torch.Tensor: + """Compute new edge vertex positions using Loop's edge rule. + + For an interior edge with endpoints v0, v1 and opposite vertices opp0, opp1: + new_pos = 3/8 * (v0 + v1) + 1/8 * (opp0 + opp1) + + For boundary edges, use simple average: (v0 + v1) / 2 + + Parameters + ---------- + mesh : Mesh + Input 2D manifold mesh + unique_edges : torch.Tensor + Edge connectivity, shape (n_edges, 2) + + Returns + ------- + torch.Tensor + Edge vertex positions, shape (n_edges, n_spatial_dims) + """ + from physicsnemo.mesh.boundaries import extract_candidate_facets + + n_edges = len(unique_edges) + device = mesh.points.device + + ### Build edge-to-cells mapping + candidate_edges, parent_cell_indices = extract_candidate_facets( + mesh.cells, + manifold_codimension=mesh.n_manifold_dims - 1, + ) + + _, inverse_indices = torch.unique( + candidate_edges, + dim=0, + return_inverse=True, + ) + + ### Count adjacent cells for each edge + # Shape: (n_edges,) + adjacent_counts = torch.bincount(inverse_indices, minlength=n_edges) + + ### Identify boundary vs interior edges + is_interior = adjacent_counts == 2 + is_boundary = ~is_interior + + ### Initialize edge positions + edge_positions = torch.zeros( + (n_edges, mesh.n_spatial_dims), + dtype=mesh.points.dtype, + device=device, + ) + + ### Compute boundary edge positions (simple average) + # Shape: (n_boundary_edges, n_spatial_dims) + boundary_edges = unique_edges[is_boundary] + if len(boundary_edges) > 0: + v0_pos = mesh.points[boundary_edges[:, 0]] + v1_pos = mesh.points[boundary_edges[:, 1]] + edge_positions[is_boundary] = (v0_pos + v1_pos) / 2 + + ### Compute interior edge positions (Loop's formula) + interior_edge_indices = torch.where(is_interior)[0] + n_interior = len(interior_edge_indices) + + if n_interior > 0: + ### For each interior edge, find its two adjacent cells (vectorized) + # Filter candidate edges to only those belonging to interior edges + is_interior_candidate = is_interior[inverse_indices] + interior_inverse = inverse_indices[is_interior_candidate] + interior_parents = parent_cell_indices[is_interior_candidate] + + # Sort by edge index to group candidates belonging to same edge + sort_indices = torch.argsort(interior_inverse) + sorted_parents = interior_parents[sort_indices] + + # Reshape to (n_interior, 2) - each interior edge has exactly 2 adjacent cells + # Shape: (n_interior, 2) + adjacent_cells = sorted_parents.reshape(n_interior, 2) + + ### Get the triangles + # Shape: (n_interior, 2, 3) + triangles = mesh.cells[adjacent_cells] + + ### Get edge vertices + # Shape: (n_interior, 2) + interior_edges = unique_edges[interior_edge_indices] + + ### Find opposite vertices for each triangle + # For each triangle, find the vertex that's not in the edge + # Shape: (n_interior, 2, 3) - broadcast comparison + # Create masks for which vertices are in the edge + edge_v0 = interior_edges[:, 0].unsqueeze(1).unsqueeze(2) # (n_interior, 1, 1) + edge_v1 = interior_edges[:, 1].unsqueeze(1).unsqueeze(2) # (n_interior, 1, 1) + + # Check if each triangle vertex matches edge vertices + # Shape: (n_interior, 2, 3) + is_edge_vertex = (triangles == edge_v0) | (triangles == edge_v1) + + # The opposite vertex is where is_edge_vertex is False + # Shape: (n_interior, 2, 3) + opposite_mask = ~is_edge_vertex + + # Extract opposite vertices using argmax (finds first True in mask) + # Shape: (n_interior, 2) + # torch.argmax on the opposite_mask gives us the index of the opposite vertex + opposite_vertex_indices = torch.argmax( + opposite_mask.int(), dim=2 + ) # (n_interior, 2) + + # Gather the actual vertex IDs + # Shape: (n_interior, 2) + opposite_vertices = torch.gather( + triangles, # (n_interior, 2, 3) + dim=2, + index=opposite_vertex_indices.unsqueeze(2), # (n_interior, 2, 1) + ).squeeze(2) # (n_interior, 2) + + ### Compute Loop edge rule: 3/8 * (v0 + v1) + 1/8 * (opp0 + opp1) + v0_pos = mesh.points[interior_edges[:, 0]] # (n_interior, n_spatial_dims) + v1_pos = mesh.points[interior_edges[:, 1]] # (n_interior, n_spatial_dims) + opp0_pos = mesh.points[opposite_vertices[:, 0]] # (n_interior, n_spatial_dims) + opp1_pos = mesh.points[opposite_vertices[:, 1]] # (n_interior, n_spatial_dims) + + edge_positions[interior_edge_indices] = (3.0 / 8.0) * (v0_pos + v1_pos) + ( + 1.0 / 8.0 + ) * (opp0_pos + opp1_pos) + + return edge_positions + + +def subdivide_loop(mesh: "Mesh") -> "Mesh": + """Perform one level of Loop subdivision on the mesh. + + Loop subdivision is an approximating scheme that: + 1. Repositions original vertices using valence-weighted averaging + 2. Creates new edge vertices using weighted stencils + 3. Connects vertices to form 4 triangles per original triangle + + Properties: + - Approximating: original vertices move to new positions + - Produces C² smooth limit surfaces for regular meshes + - Designed for 2D manifolds (triangular meshes) + - For non-2D manifolds: raises NotImplementedError + + The result is a smoother mesh that approximates (rather than interpolates) + the original surface. + + Parameters + ---------- + mesh : Mesh + Input mesh to subdivide (must be 2D manifold) + + Returns + ------- + Mesh + Subdivided mesh with Loop-repositioned vertices + + Raises + ------ + NotImplementedError + If n_manifold_dims is not 2 + + Examples + -------- + >>> from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + >>> # Smooth a rough triangulated surface + >>> mesh = sphere_icosahedral.load(subdivisions=2) + >>> smooth = subdivide_loop(mesh) + >>> # Original vertices have moved; result is smoother + """ + from physicsnemo.mesh.mesh import Mesh + + ### Check manifold dimension + if mesh.n_manifold_dims != 2: + raise NotImplementedError( + f"Loop subdivision currently only supports 2D manifolds (triangular meshes). " + f"Got {mesh.n_manifold_dims=}. " + f"For other dimensions, use linear subdivision instead." + ) + + ### Handle empty mesh + if mesh.n_cells == 0: + return mesh + + ### Extract unique edges + unique_edges, edge_inverse = extract_unique_edges(mesh) + n_original_points = mesh.n_points + + ### Reposition original vertices (pass unique_edges to avoid recomputation) + repositioned_vertices = reposition_original_vertices_2d( + mesh, unique_edges=unique_edges + ) + + ### Compute new edge vertex positions + edge_vertices = compute_loop_edge_positions_2d(mesh, unique_edges) + + ### Combine repositioned original vertices and new edge vertices + new_points = torch.cat([repositioned_vertices, edge_vertices], dim=0) + + ### Interpolate point_data + # For Loop subdivision, data should ideally be repositioned like geometry, + # but for simplicity, use linear interpolation for edge data + from physicsnemo.mesh.subdivision._data import interpolate_point_data_to_edges + + new_point_data = interpolate_point_data_to_edges( + point_data=mesh.point_data, + edges=unique_edges, + n_original_points=n_original_points, + ) + + ### Get subdivision pattern + subdivision_pattern = get_subdivision_pattern(mesh.n_manifold_dims) + subdivision_pattern = subdivision_pattern.to(mesh.cells.device) + + ### Generate child cells + child_cells, parent_indices = generate_child_cells( + parent_cells=mesh.cells, + edge_inverse=edge_inverse, + n_original_points=n_original_points, + subdivision_pattern=subdivision_pattern, + ) + + ### Propagate cell_data + new_cell_data = propagate_cell_data_to_children( + cell_data=mesh.cell_data, + parent_indices=parent_indices, + n_total_children=len(child_cells), + ) + + ### Create and return subdivided mesh + return Mesh( + points=new_points, + cells=child_cells, + point_data=new_point_data, + cell_data=new_cell_data, + global_data=mesh.global_data, + ) diff --git a/physicsnemo/mesh/transformations/geometric.py b/physicsnemo/mesh/transformations/geometric.py index 9e49e9169d..09e7510469 100644 --- a/physicsnemo/mesh/transformations/geometric.py +++ b/physicsnemo/mesh/transformations/geometric.py @@ -26,36 +26,18 @@ - centroids: cell_data only """ -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, Literal import torch import torch.nn.functional as F from tensordict import TensorDict -from physicsnemo.mesh.utilities._cache import get_cached, set_cached +from physicsnemo.mesh.utilities._cache import CACHE_KEY, get_cached, set_cached if TYPE_CHECKING: from physicsnemo.mesh.mesh import Mesh -### Cache Handling ### - - -def _strip_all_caches(mesh: "Mesh") -> tuple[TensorDict, TensorDict, TensorDict]: - """Strip _cache from all data containers. Safe default for transformations. - - Returns - ------- - tuple[TensorDict, TensorDict, TensorDict] - Tuple of (point_data, cell_data, global_data) with _cache excluded from each. - """ - return ( - mesh.point_data.exclude("_cache"), - mesh.cell_data.exclude("_cache"), - mesh.global_data.exclude("_cache"), - ) - - ### User Data Transformation ### @@ -143,7 +125,7 @@ def transform_field(key: str, value: torch.Tensor) -> torch.Tensor: f"Expected all spatial dimensions to be {n_spatial_dims}, but got {shape}" ) - transformed = data.exclude("_cache").named_apply( + transformed = data.exclude(CACHE_KEY).named_apply( transform_field, batch_size=batch_size ) data.update(transformed) @@ -182,7 +164,7 @@ def _build_rotation_matrix( return torch.stack([torch.stack([c, -s]), torch.stack([s, c])]) ### 3D rotation using Rodrigues' formula: R = cI + s[u]_× + (1-c)(u⊗u) - axis = torch.as_tensor(axis, device=device, dtype=torch.float32) + axis = torch.as_tensor(axis, device=device, dtype=angle.dtype) if axis.shape != (3,): raise NotImplementedError( f"Rotation only supported for 2D (axis=None) or 3D (axis shape (3,)). " @@ -264,7 +246,8 @@ def transform( ) new_points = mesh.points @ matrix.T - new_point_data, new_cell_data, new_global_data = _strip_all_caches(mesh) + new_point_data = mesh.point_data.exclude(CACHE_KEY) + new_cell_data = mesh.cell_data.exclude(CACHE_KEY) ### Opt-in: areas and normals (only for square invertible matrices) if matrix.shape[0] == matrix.shape[1]: @@ -333,7 +316,10 @@ def transform( _transform_tensordict(new_point_data, matrix, mesh.n_spatial_dims, "point_data") if transform_cell_data: _transform_tensordict(new_cell_data, matrix, mesh.n_spatial_dims, "cell_data") + # Transform global_data if requested (note: global_data never has cache) + new_global_data = mesh.global_data if transform_global_data: + new_global_data = mesh.global_data.clone() _transform_tensordict( new_global_data, matrix, mesh.n_spatial_dims, "global_data" ) @@ -386,7 +372,8 @@ def translate( ) new_points = mesh.points + offset - new_point_data, new_cell_data, new_global_data = _strip_all_caches(mesh) + new_point_data = mesh.point_data.exclude(CACHE_KEY) + new_cell_data = mesh.cell_data.exclude(CACHE_KEY) ### Opt-in: areas (unchanged) if (v := get_cached(mesh.point_data, "areas")) is not None: @@ -411,14 +398,14 @@ def translate( cells=mesh.cells, point_data=new_point_data, cell_data=new_cell_data, - global_data=new_global_data, + global_data=mesh.global_data, ) def rotate( mesh: "Mesh", angle: float, - axis: torch.Tensor | list | tuple | None = None, + axis: torch.Tensor | list | tuple | Literal["x", "y", "z"] | None = None, center: torch.Tensor | list | tuple | None = None, transform_point_data: bool = False, transform_cell_data: bool = False, @@ -432,8 +419,10 @@ def rotate( Input mesh to rotate. angle : float Rotation angle in radians (counterclockwise, right-hand rule). - axis : torch.Tensor or list or tuple or None + axis : torch.Tensor or list or tuple or {"x", "y", "z"} or None Rotation axis vector. None for 2D, shape (3,) for 3D. + String literals "x", "y", "z" are converted to unit vectors + (1,0,0), (0,1,0), (0,0,1) respectively. center : torch.Tensor or list or tuple or None Center point for rotation. If None, rotates about the origin. transform_point_data : bool @@ -455,6 +444,20 @@ def rotate( - centroids: Rotated - normals: Rotated """ + ### Convert string axis to one-hot tensor + if isinstance(axis, str): + axis_map = {"x": 0, "y": 1, "z": 2} + if axis not in axis_map: + raise ValueError(f"axis must be 'x', 'y', or 'z', got {axis!r}") + idx = axis_map[axis] + if idx >= mesh.n_spatial_dims: + raise ValueError( + f"axis={axis!r} is invalid for mesh with " + f"n_spatial_dims={mesh.n_spatial_dims}" + ) + axis = torch.zeros(mesh.n_spatial_dims, device=mesh.points.device) + axis[idx] = 1.0 + if axis is not None: axis = torch.as_tensor(axis, device=mesh.points.device, dtype=torch.float32) @@ -467,6 +470,7 @@ def rotate( ) rotation_matrix = _build_rotation_matrix(angle, axis, mesh.points.device) + rotation_matrix = rotation_matrix.to(dtype=mesh.points.dtype) ### Handle center by translate-rotate-translate if center is not None: diff --git a/physicsnemo/mesh/utilities/_cache.py b/physicsnemo/mesh/utilities/_cache.py index 04ecec7965..1eb63f2f99 100644 --- a/physicsnemo/mesh/utilities/_cache.py +++ b/physicsnemo/mesh/utilities/_cache.py @@ -23,6 +23,8 @@ import torch from tensordict import TensorDict +CACHE_KEY = "_cache" + def get_cached(data: TensorDict, key: str) -> torch.Tensor | None: """Get a cached value from a TensorDict. @@ -46,7 +48,7 @@ def get_cached(data: TensorDict, key: str) -> torch.Tensor | None: ... # Compute areas ... pass # doctest: +SKIP """ - return data.get(("_cache", key), None) + return data.get((CACHE_KEY, key), None) def set_cached(data: TensorDict, key: str, value: torch.Tensor) -> None: @@ -68,6 +70,6 @@ def set_cached(data: TensorDict, key: str, value: torch.Tensor) -> None: -------- >>> set_cached(mesh.cell_data, "areas", computed_areas) # doctest: +SKIP """ - if "_cache" not in data: - data["_cache"] = TensorDict({}, batch_size=data.batch_size, device=data.device) - data[("_cache", key)] = value + if CACHE_KEY not in data: + data[CACHE_KEY] = TensorDict({}, batch_size=data.batch_size, device=data.device) + data[(CACHE_KEY, key)] = value diff --git a/physicsnemo/mesh/utilities/_duplicate_detection.py b/physicsnemo/mesh/utilities/_duplicate_detection.py new file mode 100644 index 0000000000..cadf4a958c --- /dev/null +++ b/physicsnemo/mesh/utilities/_duplicate_detection.py @@ -0,0 +1,201 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Duplicate point detection using BVH-accelerated spatial queries. + +This is the single source of truth for finding and clustering coincident +points in a mesh. All higher-level operations (cleaning, repair, +validation) delegate here. + +Algorithm +--------- +1. Construct a 0-manifold ``Mesh`` where each point is its own cell. +2. Build a BVH over those degenerate cells. +3. Query the BVH with the same points, expanded by ``tolerance``. +4. Filter candidate pairs by exact L2 distance. +5. (Optional) Cluster pairs into equivalence classes via vectorised + union-find with path compression. +""" + +import warnings + +import torch + + +def vectorized_connected_components( + pairs: torch.Tensor, n_elements: int +) -> torch.Tensor: + """Compute connected components from pairwise connections. + + Uses iterative vectorized union-find with path compression. + + Parameters + ---------- + pairs : torch.Tensor + Shape (n_pairs, 2). Each row is a pair of element indices that should + be in the same component. + n_elements : int + Total number of elements. + + Returns + ------- + torch.Tensor + Shape (n_elements,). labels[i] is the canonical (smallest index) + representative of element i's component. + """ + device = pairs.device + parent = torch.arange(n_elements, dtype=torch.long, device=device) + + if len(pairs) == 0: + return parent + + ### Iterative union-find: repeat union + path compression until stable + max_iterations = 100 + for _ in range(max_iterations): + prev = parent.clone() + + # Union step: merge to smaller index + merge_from = torch.maximum(pairs[:, 0], pairs[:, 1]) + merge_to = torch.minimum(pairs[:, 0], pairs[:, 1]) + # Also need to merge through current parent pointers + parent_from = parent[pairs[:, 0]] + parent_to = parent[pairs[:, 1]] + all_merge_from = torch.cat([merge_from, torch.maximum(parent_from, parent_to)]) + all_merge_to = torch.cat([merge_to, torch.minimum(parent_from, parent_to)]) + + parent.scatter_reduce_( + dim=0, + index=all_merge_from, + src=all_merge_to, + reduce="amin", + ) + + # Path compression + parent = parent[parent] + + if torch.equal(parent, prev): + break + else: + warnings.warn( + f"Union-find did not converge in {max_iterations} iterations. " + "This should not happen for valid meshes.", + stacklevel=2, + ) + + return parent + + +def find_duplicate_pairs( + points: torch.Tensor, + tolerance: float, +) -> torch.Tensor: + """Find all pairs of points whose L2 distance is below *tolerance*. + + Uses a BVH for O(n log n) candidate generation, then exact L2 + filtering. Every returned pair satisfies ``i < j``. + + Parameters + ---------- + points : torch.Tensor + Point coordinates, shape (n_points, n_spatial_dims). + tolerance : float + Absolute distance threshold. + + Returns + ------- + torch.Tensor + Duplicate pairs, shape (n_pairs, 2) with ``pairs[:, 0] < pairs[:, 1]``. + Empty (0, 2) tensor if no duplicates are found. + """ + n_points = points.shape[0] + device = points.device + + if n_points < 2: + return torch.empty((0, 2), dtype=torch.long, device=device) + + ### Build a 0-manifold mesh so the BVH has cells to work with + from physicsnemo.mesh.mesh import Mesh + from physicsnemo.mesh.spatial.bvh import BVH + + point_cells = torch.arange(n_points, device=device, dtype=torch.long).unsqueeze(1) + point_mesh = Mesh(points=points, cells=point_cells) + + bvh = BVH.from_mesh(point_mesh) + + ### BVH query: L∞ candidate pairs within tolerance + candidate_adjacency = bvh.find_candidate_cells( + query_points=points, + max_candidates_per_point=100, + aabb_tolerance=tolerance, + ) + + if candidate_adjacency.n_total_neighbors == 0: + return torch.empty((0, 2), dtype=torch.long, device=device) + + pair_queries, pair_candidates = candidate_adjacency.expand_to_pairs() + + ### Keep only pairs with query < candidate (canonical order, no self-pairs) + valid = pair_queries < pair_candidates + pair_queries = pair_queries[valid] + pair_candidates = pair_candidates[valid] + + if len(pair_queries) == 0: + return torch.empty((0, 2), dtype=torch.long, device=device) + + ### Exact L2 distance filter + distances = torch.linalg.vector_norm( + points[pair_queries] - points[pair_candidates], dim=-1 + ) + within = distances < tolerance + + if not within.any(): + return torch.empty((0, 2), dtype=torch.long, device=device) + + return torch.stack([pair_queries[within], pair_candidates[within]], dim=1) + + +def compute_canonical_indices( + points: torch.Tensor, + tolerance: float, +) -> torch.Tensor: + """Map each point to the smallest-index representative in its cluster. + + Two points belong to the same cluster when they are connected by a + chain of pairwise distances below *tolerance* (transitive closure). + + Parameters + ---------- + points : torch.Tensor + Point coordinates, shape (n_points, n_spatial_dims). + tolerance : float + Absolute distance threshold. + + Returns + ------- + torch.Tensor + Shape (n_points,). ``canonical[i]`` is the index of the + canonical representative for point *i* (always the smallest + index in the equivalence class). + """ + n_points = points.shape[0] + device = points.device + + if n_points < 2: + return torch.arange(n_points, device=device, dtype=torch.long) + + pairs = find_duplicate_pairs(points, tolerance) + + return vectorized_connected_components(pairs, n_points) diff --git a/physicsnemo/mesh/utilities/_edge_lookup.py b/physicsnemo/mesh/utilities/_edge_lookup.py new file mode 100644 index 0000000000..beffa8bdca --- /dev/null +++ b/physicsnemo/mesh/utilities/_edge_lookup.py @@ -0,0 +1,99 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Edge lookup utilities for efficient edge matching in mesh operations. + +This module provides hash-based lookup for finding edges within reference sets, +used throughout physicsnemo.mesh for operations like computing dual volumes, +exterior derivatives, and sharp/flat operators. +""" + +import torch + + +def find_edges_in_reference( + reference_edges: torch.Tensor, + query_edges: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor]: + """Find indices of query edges within a reference edge set. + + Uses hash-based lookup with O(n log n) complexity for sorting + and O(m log n) for queries, where n = len(reference_edges) + and m = len(query_edges). + + Edge order within each edge is ignored (edges are canonicalized + to [min_vertex, max_vertex] internally). + + Parameters + ---------- + reference_edges : torch.Tensor + Reference edge set, shape (n_ref, 2). Each row is [v0, v1]. + query_edges : torch.Tensor + Query edges to find, shape (n_query, 2). Each row is [v0, v1]. + + Returns + ------- + indices : torch.Tensor + Shape (n_query,). For each query edge, the index in reference_edges + where it was found. For unmatched edges, the value is undefined + (use the matches mask to filter). + matches : torch.Tensor + Shape (n_query,) bool. True if query edge was found in reference_edges. + + Examples + -------- + >>> ref = torch.tensor([[0, 1], [1, 2], [2, 3]]) + >>> query = torch.tensor([[2, 1], [5, 6], [3, 2]]) # [2,1] matches [1,2] + >>> indices, matches = find_edges_in_reference(ref, query) + >>> # indices[0] = 1 (matched), indices[2] = 2 (matched) + >>> # matches = [True, False, True] + """ + device = reference_edges.device + + ### Handle empty edge cases + if len(reference_edges) == 0 or len(query_edges) == 0: + return ( + torch.zeros(len(query_edges), dtype=torch.long, device=device), + torch.zeros(len(query_edges), dtype=torch.bool, device=device), + ) + + ### Canonicalize edges to [min_vertex, max_vertex] order + sorted_reference, _ = torch.sort(reference_edges, dim=-1) + sorted_query, _ = torch.sort(query_edges, dim=-1) + + ### Compute integer hash for each edge + # hash = v0 * (max_vertex + 1) + v1 + # This creates a unique mapping for edges with non-negative vertex indices + max_vertex = max(reference_edges.max().item(), query_edges.max().item()) + 1 + reference_hash = sorted_reference[:, 0] * max_vertex + sorted_reference[:, 1] + query_hash = sorted_query[:, 0] * max_vertex + sorted_query[:, 1] + + ### Sort reference hashes to enable binary search via searchsorted + reference_hash_sorted, sort_indices = torch.sort(reference_hash) + + ### Find positions of query hashes in sorted reference + positions = torch.searchsorted(reference_hash_sorted, query_hash) + + ### Clamp positions to valid range (handles queries beyond max reference) + positions = positions.clamp(max=len(reference_hash_sorted) - 1) + + ### Verify that found positions are exact matches (not just insertion points) + matches = reference_hash_sorted[positions] == query_hash + + ### Map back to original reference indices + indices = sort_indices[positions] + + return indices, matches diff --git a/physicsnemo/mesh/utilities/_scatter_ops.py b/physicsnemo/mesh/utilities/_scatter_ops.py index 56959a53b7..94f054b13b 100644 --- a/physicsnemo/mesh/utilities/_scatter_ops.py +++ b/physicsnemo/mesh/utilities/_scatter_ops.py @@ -23,6 +23,8 @@ import torch +from physicsnemo.mesh.utilities._tolerances import safe_eps + def scatter_aggregate( src_data: torch.Tensor, # shape: (n_src, *data_shape) @@ -125,7 +127,7 @@ def scatter_aggregate( ) ### Normalize by total weight (avoid division by zero) - weight_sums = weight_sums.clamp(min=1e-30) + weight_sums = weight_sums.clamp(min=safe_eps(weight_sums.dtype)) aggregated_data = aggregated_data / weight_sums.view( -1, *([1] * len(data_shape)) ) diff --git a/physicsnemo/mesh/utilities/_tolerances.py b/physicsnemo/mesh/utilities/_tolerances.py new file mode 100644 index 0000000000..adca1c58ed --- /dev/null +++ b/physicsnemo/mesh/utilities/_tolerances.py @@ -0,0 +1,65 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Dtype-aware numerical tolerances for mesh computations. + +A hardcoded absolute tolerance like ``1e-10`` is wrong for meshes whose +coordinates live at a scale far from unity. For float64 in particular, +``1e-10`` is millions of times larger than machine precision and corrupts +results on micro- or nanoscale geometries. + +This module provides :func:`safe_eps`, which returns a floor value derived +from the dtype alone, chosen so that: + +- It is small enough to never activate on any physically meaningful mesh. +- Its reciprocal squared does not overflow (important for inverse-distance + weights raised to power 2). + +Concretely, ``safe_eps(dtype) = torch.finfo(dtype).tiny ** 0.25``: + +========== ============= ============================= +dtype ``safe_eps`` ``1 / safe_eps ** 2`` +========== ============= ============================= +float32 ~3.3e-10 ~9.2e+18 (well below 3.4e38) +float64 ~1.2e-77 ~6.7e+153 (well below 1.8e308) +========== ============= ============================= +""" + +import torch + + +def safe_eps(dtype: torch.dtype) -> float: + """Return a dtype-aware safe epsilon for preventing division by zero. + + This replaces all hardcoded ``1e-10`` clamp floors in the mesh module. + The returned value is: + + - Small enough to leave any physically meaningful quantity untouched. + - Large enough that ``1 / safe_eps(dtype) ** 2`` does not overflow. + + Parameters + ---------- + dtype : torch.dtype + The floating-point dtype (e.g. ``torch.float32``, + ``torch.float64``). + + Returns + ------- + float + A small positive floor value equal to + ``torch.finfo(dtype).tiny ** 0.25``. + """ + return torch.finfo(dtype).tiny ** 0.25 diff --git a/physicsnemo/mesh/utilities/_topology.py b/physicsnemo/mesh/utilities/_topology.py new file mode 100644 index 0000000000..2845f8f1e8 --- /dev/null +++ b/physicsnemo/mesh/utilities/_topology.py @@ -0,0 +1,71 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""General mesh topology utilities.""" + +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.boundaries._facet_extraction import extract_candidate_facets + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def extract_unique_edges(mesh: "Mesh") -> tuple[torch.Tensor, torch.Tensor]: + """Extract all unique edges from the mesh. + + For 1D meshes (cells are edges), the cells are deduplicated directly. + For higher-dimensional meshes, edges are extracted via + :func:`extract_candidate_facets` at the appropriate codimension. + + Parameters + ---------- + mesh : Mesh + Input mesh to extract edges from. + + Returns + ------- + unique_edges : torch.Tensor + Unique edge vertex indices, shape (n_edges, 2), canonically sorted + so that ``unique_edges[:, 0] < unique_edges[:, 1]``. + inverse_indices : torch.Tensor + Mapping from candidate edges to unique edge indices. + For 1D meshes, shape is (n_cells,). + For n-manifolds with n > 1, shape is + (n_cells * n_edges_per_cell,), which can be reshaped to + (n_cells, n_edges_per_cell). + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> triangle_mesh = two_triangles_2d.load() + >>> edges, inverse = extract_unique_edges(triangle_mesh) + >>> edges.shape[1] + 2 + """ + if mesh.n_manifold_dims == 1: + ### 1D meshes: cells ARE edges - sort and deduplicate directly + sorted_cells = torch.sort(mesh.cells, dim=1)[0] + return torch.unique(sorted_cells, dim=0, return_inverse=True) + + ### General case: extract edges as (n-1)-codimension facets of each cell + candidate_edges, _parent_cell_indices = extract_candidate_facets( + mesh.cells, + manifold_codimension=mesh.n_manifold_dims - 1, + ) + return torch.unique(candidate_edges, dim=0, return_inverse=True) diff --git a/physicsnemo/mesh/utilities/mesh_repr.py b/physicsnemo/mesh/utilities/mesh_repr.py index 45d78eda72..3667db9116 100644 --- a/physicsnemo/mesh/utilities/mesh_repr.py +++ b/physicsnemo/mesh/utilities/mesh_repr.py @@ -19,6 +19,8 @@ import torch from tensordict import TensorDict +from physicsnemo.mesh.utilities._cache import CACHE_KEY + def format_mesh_repr(mesh, exclude_cache: bool = False) -> str: """Format a complete Mesh representation. @@ -80,6 +82,8 @@ def format_mesh_repr(mesh, exclude_cache: bool = False) -> str: def _count_tensordict_fields(td: TensorDict, exclude_cache: bool = False) -> int: """Recursively count total number of fields in a TensorDict. + Counts both leaf tensors and intermediate (nested) TensorDict entries. + Parameters ---------- td : TensorDict @@ -92,20 +96,8 @@ def _count_tensordict_fields(td: TensorDict, exclude_cache: bool = False) -> int int Total number of fields including nested fields. """ - count = 0 - - for key, value in td.items(): - # Skip _cache if requested - if exclude_cache and key == "_cache": - continue - - count += 1 - - # If the value is a TensorDict, recursively count its fields - if isinstance(value, TensorDict): - count += _count_tensordict_fields(value, exclude_cache=exclude_cache) - - return count + filtered = td.exclude(CACHE_KEY) if exclude_cache else td + return len(list(filtered.keys(include_nested=True))) def _get_trailing_shape(tensor: torch.Tensor, batch_dims: int) -> tuple: @@ -149,15 +141,17 @@ def _format_tensordict_repr( str Formatted string representation. """ - # Get all keys, excluding _cache if requested - all_keys = [k for k in td.keys() if not (exclude_cache and k == "_cache")] + # Get top-level keys, excluding _cache if requested + # (Intentionally top-level only: this function recurses for nested TensorDicts.) + filtered = td.exclude(CACHE_KEY) if exclude_cache else td + all_keys = list(filtered.keys()) if len(all_keys) == 0: return "{}" # Sort alphabetically, but always put _cache at the end - regular_keys = sorted([k for k in all_keys if k != "_cache"]) - cache_keys = [k for k in all_keys if k == "_cache"] + regular_keys = sorted([k for k in all_keys if k != CACHE_KEY]) + cache_keys = [k for k in all_keys if k == CACHE_KEY] keys = regular_keys + cache_keys # Count total fields to decide on single-line vs multi-line @@ -168,7 +162,7 @@ def _format_tensordict_repr( # Single-line format items = [] for key in keys: - value = td[key] + value = filtered[key] if isinstance(value, TensorDict): # Recursively format nested TensorDict nested_repr = _format_tensordict_repr( @@ -199,7 +193,7 @@ def _format_tensordict_repr( # Build field lines field_lines = [] for i, key in enumerate(keys): - value = td[key] + value = filtered[key] padded_key = str(key).ljust(max_key_len) is_last = i == len(keys) - 1 diff --git a/physicsnemo/mesh/validation/__init__.py b/physicsnemo/mesh/validation/__init__.py new file mode 100644 index 0000000000..cb10d3800d --- /dev/null +++ b/physicsnemo/mesh/validation/__init__.py @@ -0,0 +1,25 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Mesh validation, quality metrics, and statistics. + +This module provides tools for validating mesh integrity, computing quality +metrics, and generating mesh statistics. +""" + +from physicsnemo.mesh.validation.quality import compute_quality_metrics +from physicsnemo.mesh.validation.statistics import compute_mesh_statistics +from physicsnemo.mesh.validation.validate import validate_mesh diff --git a/physicsnemo/mesh/validation/quality.py b/physicsnemo/mesh/validation/quality.py new file mode 100644 index 0000000000..980c947d27 --- /dev/null +++ b/physicsnemo/mesh/validation/quality.py @@ -0,0 +1,191 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Quality metrics for mesh cells. + +Computes geometric quality metrics for simplicial cells including aspect ratio, +skewness, and angles. Higher quality = better shaped cells. +""" + +from typing import TYPE_CHECKING + +import torch +from tensordict import TensorDict + +from physicsnemo.mesh.geometry._angles import compute_vertex_angles + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def compute_cell_edge_lengths(mesh: "Mesh") -> torch.Tensor: + """Compute all pairwise edge lengths within each cell. + + For an n-simplex with (n+1) vertices, there are C(n+1, 2) edges per cell. + Returns a tensor of all edge lengths, vectorized across all cells. + + Parameters + ---------- + mesh : Mesh + Mesh whose cells to measure. + + Returns + ------- + torch.Tensor + Edge lengths, shape ``(n_cells, n_edges_per_cell)`` where + ``n_edges_per_cell = C(n_manifold_dims + 1, 2)``. + Returns an empty ``(0, 0)`` tensor if the mesh has no cells. + + Examples + -------- + >>> import torch + >>> from physicsnemo.mesh import Mesh + >>> points = torch.tensor([[0., 0.], [1., 0.], [0., 1.]]) + >>> cells = torch.tensor([[0, 1, 2]]) + >>> mesh = Mesh(points=points, cells=cells) + >>> lengths = compute_cell_edge_lengths(mesh) + >>> lengths.shape + torch.Size([1, 3]) + """ + if mesh.n_cells == 0: + return torch.zeros((0, 0), dtype=mesh.points.dtype, device=mesh.points.device) + + cell_vertices = mesh.points[mesh.cells] # (n_cells, n_verts, n_dims) + n_verts_per_cell = mesh.n_manifold_dims + 1 + + # All (i, j) pairs with i < j via upper-triangular indices + i_indices, j_indices = torch.triu_indices( + n_verts_per_cell, + n_verts_per_cell, + offset=1, + device=mesh.points.device, + ) + # Edge vectors and their lengths: (n_cells, n_edges_per_cell) + edge_vectors = cell_vertices[:, j_indices] - cell_vertices[:, i_indices] + return torch.linalg.vector_norm(edge_vectors, dim=-1) + + +def compute_quality_metrics(mesh: "Mesh") -> TensorDict: + """Compute geometric quality metrics for all cells. + + Returns TensorDict with per-cell quality metrics: + - aspect_ratio: max_edge / min_altitude (lower is better, 1.0 is equilateral) + - min_angle: Minimum interior angle in radians + - max_angle: Maximum interior angle in radians + - edge_length_ratio: max_edge / min_edge (1.0 is equilateral) + - quality_score: Combined metric in [0,1] (1.0 is perfect equilateral) + + Parameters + ---------- + mesh : Mesh + Mesh to analyze + + Returns + ------- + TensorDict + TensorDict of shape (n_cells,) with quality metrics + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> metrics = compute_quality_metrics(mesh) + >>> assert "quality_score" in metrics.keys() + """ + if mesh.n_cells == 0: + return TensorDict( + {}, + batch_size=torch.Size([0]), + device=mesh.points.device, + ) + + device = mesh.points.device + dtype = mesh.points.dtype + n_cells = mesh.n_cells + n_verts_per_cell = mesh.n_manifold_dims + 1 + + ### Compute edge lengths for each cell + edge_lengths = compute_cell_edge_lengths(mesh) # (n_cells, n_edges_per_cell) + + max_edge = edge_lengths.max(dim=1).values + min_edge = edge_lengths.min(dim=1).values + + edge_length_ratio = max_edge / (min_edge + 1e-10) + + ### Compute aspect ratio (approximation using area and edges) + areas = mesh.cell_areas + + # For triangles: aspect_ratio ≈ max_edge / (4*area/perimeter) + # For general: use max_edge / characteristic_length + perimeter = edge_lengths.sum(dim=1) + characteristic_length = areas * n_verts_per_cell / (perimeter + 1e-10) + aspect_ratio = max_edge / (characteristic_length + 1e-10) + + ### Compute interior angles at each vertex of each cell + if mesh.n_manifold_dims >= 2: + # Unified formula works for triangles, tetrahedra, and higher simplices + all_angles = compute_vertex_angles(mesh) # (n_cells, n_verts_per_cell) + min_angle = all_angles.min(dim=1).values + max_angle = all_angles.max(dim=1).values + else: + # For 1D manifolds (edges), interior angles are not meaningful + min_angle = torch.full((n_cells,), float("nan"), dtype=dtype, device=device) + max_angle = torch.full((n_cells,), float("nan"), dtype=dtype, device=device) + + ### Compute combined quality score + # Perfect simplex has: + # - edge_length_ratio = 1.0 (all edges equal) + # - For triangles: all angles = π/3 + # - aspect_ratio = 1.0 + + # Quality score combines multiple metrics + # Each component in [0, 1] where 1 is perfect + + # Edge uniformity: 1 / edge_length_ratio (clamped) + edge_uniformity = 1.0 / torch.clamp(edge_length_ratio, min=1.0, max=10.0) + + # Aspect ratio quality: 1 / aspect_ratio (clamped) + aspect_quality = 1.0 / torch.clamp(aspect_ratio, min=1.0, max=10.0) + + # Angle quality: measure how uniform the vertex angles are within each cell + if mesh.n_manifold_dims == 2: + # For triangles: compare against equilateral ideal (pi/3) + ideal_angle = torch.pi / 3 + min_angle_quality = torch.clamp(min_angle / ideal_angle, max=1.0) + max_angle_quality = torch.clamp(ideal_angle / max_angle, max=1.0) + angle_quality = (min_angle_quality + max_angle_quality) / 2 + elif mesh.n_manifold_dims >= 3: + # For tets and higher: use min/max ratio (1.0 for regular simplex) + angle_quality = torch.clamp(min_angle / (max_angle + 1e-10), max=1.0) + else: + angle_quality = torch.ones((n_cells,), dtype=dtype, device=device) + + # Combined score (geometric mean) + quality_score = (edge_uniformity * aspect_quality * angle_quality) ** (1 / 3) + + return TensorDict( + { + "aspect_ratio": aspect_ratio, + "edge_length_ratio": edge_length_ratio, + "min_angle": min_angle, + "max_angle": max_angle, + "min_edge_length": min_edge, + "max_edge_length": max_edge, + "quality_score": quality_score, + }, + batch_size=torch.Size([n_cells]), + device=device, + ) diff --git a/physicsnemo/mesh/validation/statistics.py b/physicsnemo/mesh/validation/statistics.py new file mode 100644 index 0000000000..59ccccc1aa --- /dev/null +++ b/physicsnemo/mesh/validation/statistics.py @@ -0,0 +1,138 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Mesh statistics and summary information. + +Computes global statistics about mesh properties including counts, +distributions, and quality summaries. +""" + +from collections.abc import Mapping +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.validation.quality import compute_quality_metrics + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def compute_mesh_statistics( + mesh: "Mesh", + tolerance: float = 1e-10, +) -> Mapping[str, int | float | tuple[float, float, float, float]]: + """Compute summary statistics for mesh. + + Returns dictionary with mesh statistics: + - n_points: Number of vertices + - n_cells: Number of cells + - n_manifold_dims: Manifold dimension + - n_spatial_dims: Spatial dimension + - n_degenerate_cells: Cells with area < tolerance + - n_isolated_vertices: Vertices not in any cell + - edge_length_stats: (min, mean, max, std) of edge lengths + - cell_area_stats: (min, mean, max, std) of cell areas + - aspect_ratio_stats: (min, mean, max, std) of aspect ratios + - quality_score_stats: (min, mean, max, std) of quality scores + + Parameters + ---------- + mesh : Mesh + Mesh to analyze + tolerance : float + Threshold for degenerate cell detection + + Returns + ------- + Mapping[str, int | float | tuple[float, float, float, float]] + Dictionary with statistics + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> stats = compute_mesh_statistics(mesh) + >>> assert "n_points" in stats and "n_cells" in stats + """ + stats = { + "n_points": mesh.n_points, + "n_cells": mesh.n_cells, + "n_manifold_dims": mesh.n_manifold_dims, + "n_spatial_dims": mesh.n_spatial_dims, + } + + if mesh.n_cells == 0: + # Empty mesh + stats["n_degenerate_cells"] = 0 + stats["n_isolated_vertices"] = mesh.n_points + stats["edge_length_stats"] = (0.0, 0.0, 0.0, 0.0) + stats["cell_area_stats"] = (0.0, 0.0, 0.0, 0.0) + return stats + + ### Count degenerate cells + areas = mesh.cell_areas + n_degenerate = (areas < tolerance).sum().item() + stats["n_degenerate_cells"] = n_degenerate + + ### Count isolated vertices + # Vertices that don't appear in any cell + used_vertices = torch.unique(mesh.cells.flatten()) + n_used = len(used_vertices) + stats["n_isolated_vertices"] = mesh.n_points - n_used + + ### Compute cell area statistics + stats["cell_area_stats"] = ( + areas.min().item(), + areas.mean().item(), + areas.max().item(), + areas.std(correction=0).item(), + ) + + ### Compute quality metrics (includes edge lengths internally) + quality_metrics = compute_quality_metrics(mesh) + + ### Extract edge length statistics from quality metrics + # compute_quality_metrics already computes min/max edge lengths per cell, + # so we derive stats from those to avoid a redundant compute_cell_edge_lengths call. + min_edge = quality_metrics["min_edge_length"] + max_edge = quality_metrics["max_edge_length"] + stats["edge_length_stats"] = ( + min_edge.min().item(), + (min_edge.mean().item() + max_edge.mean().item()) / 2.0, + max_edge.max().item(), + max_edge.std(correction=0).item(), + ) + + if "aspect_ratio" in quality_metrics.keys(): + aspect_ratios = quality_metrics["aspect_ratio"] + stats["aspect_ratio_stats"] = ( + aspect_ratios.min().item(), + aspect_ratios.mean().item(), + aspect_ratios.max().item(), + aspect_ratios.std(correction=0).item(), + ) + + if "quality_score" in quality_metrics.keys(): + quality_scores = quality_metrics["quality_score"] + stats["quality_score_stats"] = ( + quality_scores.min().item(), + quality_scores.mean().item(), + quality_scores.max().item(), + quality_scores.std(correction=0).item(), + ) + + return stats diff --git a/physicsnemo/mesh/validation/validate.py b/physicsnemo/mesh/validation/validate.py new file mode 100644 index 0000000000..ad2abbfdef --- /dev/null +++ b/physicsnemo/mesh/validation/validate.py @@ -0,0 +1,333 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Mesh validation to detect common errors and degenerate cases. + +Provides comprehensive validation of mesh integrity including topology, +geometry, and data consistency checks. +""" + +from collections.abc import Mapping +from typing import TYPE_CHECKING + +import torch + +from physicsnemo.mesh.boundaries import extract_candidate_facets +from physicsnemo.mesh.utilities._duplicate_detection import find_duplicate_pairs +from physicsnemo.mesh.utilities._tolerances import safe_eps + +if TYPE_CHECKING: + from physicsnemo.mesh.mesh import Mesh + + +def validate_mesh( + mesh: "Mesh", + check_degenerate_cells: bool = True, + check_duplicate_vertices: bool = True, + check_inverted_cells: bool = False, # Expensive, opt-in + check_out_of_bounds: bool = True, + check_manifoldness: bool = False, # Only 2D, opt-in + check_self_intersection: bool = False, # Very expensive, opt-in + tolerance: float | None = None, + raise_on_error: bool = False, +) -> Mapping[str, bool | int | torch.Tensor]: + """Validate mesh integrity and detect common errors. + + Performs a comprehensive set of checks to ensure mesh is well-formed + and suitable for geometric computations. + + Parameters + ---------- + mesh : Mesh + Mesh to validate + check_degenerate_cells : bool + Check for zero/negative area cells + check_duplicate_vertices : bool + Check for coincident vertices within tolerance + check_inverted_cells : bool + Check for cells with negative orientation (expensive) + check_out_of_bounds : bool + Check that cell indices are valid + check_manifoldness : bool + Check manifold topology (2D only, expensive) + check_self_intersection : bool + Check for self-intersecting cells (very expensive) + tolerance : float | None + Tolerance for geometric checks (areas, distances). + If ``None`` (default), uses a dtype-aware epsilon via :func:`safe_eps`. + raise_on_error : bool + If True, raise ValueError on first error. If False, + return dict with all validation results. + + Returns + ------- + Mapping[str, bool | int | torch.Tensor] + Dictionary with validation results: + - "valid": bool, True if all enabled checks passed + - "n_degenerate_cells": int, number of degenerate cells found + - "degenerate_cell_indices": Tensor of indices (if any found) + - "n_duplicate_vertices": int, number of duplicate vertex pairs + - "duplicate_vertex_pairs": Tensor of index pairs (if any found) + - "n_out_of_bounds_cells": int, cells with invalid indices + - "out_of_bounds_cell_indices": Tensor of cell indices (if any) + - "n_inverted_cells": int (if check enabled) + - "inverted_cell_indices": Tensor (if check enabled and any found) + - "is_manifold": bool (if check enabled, 2D only) + - "non_manifold_edges": Tensor of edge indices (if check enabled) + + Raises + ------ + ValueError + If raise_on_error=True and validation fails + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> report = validate_mesh(mesh) + >>> assert report["valid"] == True + """ + ### Default tolerance based on point dtype + if tolerance is None: + tolerance = safe_eps(mesh.points.dtype) + + results = { + "valid": True, + } + + ### Check for out-of-bounds indices FIRST (before any geometric computations) + if check_out_of_bounds: + if mesh.n_cells > 0: + min_index = mesh.cells.min() + max_index = mesh.cells.max() + + out_of_bounds_mask = (mesh.cells < 0) | (mesh.cells >= mesh.n_points) + out_of_bounds_cells = torch.any(out_of_bounds_mask, dim=1) + n_out_of_bounds = out_of_bounds_cells.sum().item() + + results["n_out_of_bounds_cells"] = n_out_of_bounds + + if n_out_of_bounds > 0: + results["valid"] = False + results["out_of_bounds_cell_indices"] = torch.where( + out_of_bounds_cells + )[0] + + if raise_on_error: + raise ValueError( + f"Found {n_out_of_bounds} cells with out-of-bounds indices.\n" + f"Cell indices must be in range [0, {mesh.n_points}), " + f"but got {min_index.item()=} and {max_index.item()=}.\n" + f"Problem cells: {results['out_of_bounds_cell_indices'].tolist()[:10]}" + ) + else: + results["n_out_of_bounds_cells"] = 0 + + ### Early return if out-of-bounds indices found (can't compute geometry) + if check_out_of_bounds and results.get("n_out_of_bounds_cells", 0) > 0: + if raise_on_error: + # Already raised above + pass + else: + # Skip remaining geometric checks + return results + + ### Check for duplicate vertices + if check_duplicate_vertices: + duplicate_pairs = find_duplicate_pairs(mesh.points, tolerance) + n_duplicates = len(duplicate_pairs) + + results["n_duplicate_vertices"] = n_duplicates + + if n_duplicates > 0: + results["valid"] = False + results["duplicate_vertex_pairs"] = duplicate_pairs + + if raise_on_error: + raise ValueError( + f"Found {n_duplicates} pairs of duplicate vertices " + f"(within tolerance={tolerance}).\n" + f"First few pairs: {duplicate_pairs[:5].tolist()}" + ) + + ### Check for degenerate cells + if check_degenerate_cells and mesh.n_cells > 0: + # Compute cell areas + areas = mesh.cell_areas + + # Scale tolerance for area comparison: + # - tolerance is in distance units + # - areas have units of length^n_manifold_dims + # So use tolerance^n_manifold_dims for a consistent comparison + area_tolerance = tolerance**mesh.n_manifold_dims + + # Find cells with area below tolerance + degenerate_mask = areas < area_tolerance + n_degenerate = degenerate_mask.sum().item() + + results["n_degenerate_cells"] = n_degenerate + + if n_degenerate > 0: + results["valid"] = False + results["degenerate_cell_indices"] = torch.where(degenerate_mask)[0] + results["degenerate_cell_areas"] = areas[degenerate_mask] + + if raise_on_error: + raise ValueError( + f"Found {n_degenerate} degenerate cells with area < {area_tolerance}.\n" + f"Problem cells: {results['degenerate_cell_indices'].tolist()[:10]}\n" + f"Areas: {results['degenerate_cell_areas'].tolist()[:10]}" + ) + elif check_degenerate_cells: + results["n_degenerate_cells"] = 0 + + ### Check for inverted cells (cells with negative orientation) + if check_inverted_cells and mesh.n_cells > 0: + # For simplicial meshes, check if determinant is negative + # This indicates inverted orientation + + if mesh.n_manifold_dims == mesh.n_spatial_dims: + # Volume mesh: can compute signed volume + cell_vertices = mesh.points[mesh.cells] # (n_cells, n_verts, n_dims) + + # Compute signed volume using determinant + # For n-simplex: V = (1/n!) * det([v1-v0, v2-v0, ..., vn-v0]) + relative_vectors = cell_vertices[:, 1:] - cell_vertices[:, [0]] + + # Compute determinant (works for 2x2 and 3x3 matrices) + if mesh.n_manifold_dims >= 2: + det = torch.det(relative_vectors) # (n_cells,) + + inverted_mask = det < 0 + n_inverted = inverted_mask.sum().item() + + results["n_inverted_cells"] = n_inverted + + if n_inverted > 0: + results["valid"] = False + results["inverted_cell_indices"] = torch.where(inverted_mask)[0] + + if raise_on_error: + raise ValueError( + f"Found {n_inverted} inverted cells (negative orientation).\n" + f"Problem cells: {results['inverted_cell_indices'].tolist()[:10]}" + ) + else: + # For 1D, orientation check is more complex + results["n_inverted_cells"] = -1 # Not implemented + else: + # Codimension > 0: orientation not well-defined + results["n_inverted_cells"] = -1 # Not applicable + elif check_inverted_cells: + results["n_inverted_cells"] = 0 + + ### Check manifoldness (2D only) + if check_manifoldness: + if mesh.n_manifold_dims == 2 and mesh.n_spatial_dims >= 2: + # Check that each edge is shared by at most 2 triangles + # Extract all edges (with duplicates) + edges_with_dupes, parent_cells = extract_candidate_facets( + mesh.cells, manifold_codimension=1 + ) + + # Sort edges to canonical form + edges_sorted = torch.sort(edges_with_dupes, dim=1).values + + # Find unique edges and their counts + unique_edges, inverse_indices, counts = torch.unique( + edges_sorted, dim=0, return_inverse=True, return_counts=True + ) + + # Manifold edges should appear exactly 1 (boundary) or 2 (interior) times + non_manifold_mask = counts > 2 + n_non_manifold = non_manifold_mask.sum().item() + + results["is_manifold"] = n_non_manifold == 0 + results["n_non_manifold_edges"] = n_non_manifold + + if n_non_manifold > 0: + results["valid"] = False + results["non_manifold_edges"] = unique_edges[non_manifold_mask] + results["non_manifold_edge_counts"] = counts[non_manifold_mask] + + if raise_on_error: + raise ValueError( + f"Mesh is not manifold: {n_non_manifold} edges shared by >2 faces.\n" + f"First few problem edges: {results['non_manifold_edges'][:5].tolist()}" + ) + else: + results["is_manifold"] = None # Only defined for 2D manifolds + results["n_non_manifold_edges"] = -1 # Not applicable + + ### Check for self-intersections (very expensive, opt-in only) + if check_self_intersection: + # This is very expensive: O(n^2) cell-cell intersection tests + # For production use, would need BVH acceleration + results["has_self_intersection"] = None # Not implemented yet + results["intersecting_cell_pairs"] = None + + # TODO: Implement BVH-accelerated self-intersection detection + if raise_on_error: + raise NotImplementedError( + "Self-intersection checking not yet implemented.\n" + "This is a very expensive operation requiring BVH acceleration." + ) + + return results + + +def check_duplicate_cell_vertices(mesh: "Mesh") -> tuple[int, torch.Tensor]: + """Check for cells with duplicate vertices (degenerate simplices). + + A valid n-simplex must have n+1 distinct vertices. Cells with duplicate + vertices are degenerate and should be removed. + + Parameters + ---------- + mesh : Mesh + Mesh to check + + Returns + ------- + tuple[int, torch.Tensor] + Tuple of (n_invalid_cells, invalid_cell_indices) + + Examples + -------- + >>> from physicsnemo.mesh.primitives.basic import two_triangles_2d + >>> mesh = two_triangles_2d.load() + >>> n_invalid, indices = check_duplicate_cell_vertices(mesh) + >>> assert n_invalid == 0 # clean mesh has no duplicate vertices + """ + if mesh.n_cells == 0: + return 0, torch.tensor([], dtype=torch.long, device=mesh.cells.device) + + # Vectorized approach: sort vertices within each cell, then check for + # consecutive duplicates. A cell has duplicates if any adjacent pair + # in the sorted order is equal. + sorted_cells = torch.sort(mesh.cells, dim=1).values # (n_cells, n_verts) + + # Check for consecutive duplicates: sorted_cells[:, i] == sorted_cells[:, i+1] + has_duplicate = (sorted_cells[:, 1:] == sorted_cells[:, :-1]).any(dim=1) + + # Get indices of cells with duplicates + invalid_indices = torch.where(has_duplicate)[0] + n_invalid = len(invalid_indices) + + if n_invalid == 0: + return 0, torch.tensor([], dtype=torch.long, device=mesh.cells.device) + + return n_invalid, invalid_indices diff --git a/physicsnemo/mesh/visualization/_matplotlib_impl.py b/physicsnemo/mesh/visualization/_matplotlib_impl.py index 2d0af5576e..7b4f149fd7 100644 --- a/physicsnemo/mesh/visualization/_matplotlib_impl.py +++ b/physicsnemo/mesh/visualization/_matplotlib_impl.py @@ -41,6 +41,7 @@ def draw_mesh_matplotlib( point_scalar_values: torch.Tensor | None, cell_scalar_values: torch.Tensor | None, active_scalar_source: Literal["points", "cells", None], + scalar_label: str | None, show: bool, cmap: str, vmin: float | None, @@ -65,6 +66,8 @@ def draw_mesh_matplotlib( Processed cell scalar values (1D tensor or None). active_scalar_source : {"points", "cells", None} Which scalar source is active ("points", "cells", or None). + scalar_label : str or None + Human-readable label for the colorbar. show : bool Whether to call plt.show(). cmap : str @@ -89,9 +92,42 @@ def draw_mesh_matplotlib( matplotlib.axes.Axes Matplotlib axes object. """ + ### For volume meshes (3D+ manifold), reduce to a surface mesh. + ### Matplotlib can only render 2D facets (polygons), not volumetric cells + ### like tetrahedra. Extract boundary facets for clean surface visualization. + if mesh.n_manifold_dims >= 3: + _VIZ_KEY = "_viz_cell_scalars" + + ### If cell scalars are active, inject them into a cloned cell_data so + ### get_facet_mesh can propagate them to boundary facets via averaging. + ### We clone to avoid mutating the caller's mesh. + if cell_scalar_values is not None: + from physicsnemo.mesh import Mesh + + augmented_cell_data = mesh.cell_data.clone() + augmented_cell_data[_VIZ_KEY] = cell_scalar_values + mesh = Mesh( + points=mesh.points, + cells=mesh.cells, + point_data=mesh.point_data, + cell_data=augmented_cell_data, + global_data=mesh.global_data, + ) + + mesh = mesh.get_facet_mesh( + manifold_codimension=mesh.n_manifold_dims - 2, + data_source="cells", + data_aggregation="mean", + target_counts="boundary", + ) + + ### Extract propagated cell scalars from the facet mesh + if cell_scalar_values is not None: + cell_scalar_values = mesh.cell_data[_VIZ_KEY] + ### Convert mesh data to numpy - points_np = mesh.points.cpu().numpy() - cells_np = mesh.cells.cpu().numpy() + points_np = mesh.points.cpu().detach().numpy() + cells_np = mesh.cells.cpu().detach().numpy() ### Determine neutral colors based on active_scalar_source point_neutral_color = "black" @@ -195,7 +231,7 @@ def draw_mesh_matplotlib( ### Add colorbar if we have active scalars if scalar_mapper is not None: - plt.colorbar(scalar_mapper, ax=ax, label="Scalar Value") + plt.colorbar(scalar_mapper, ax=ax, label=scalar_label or "") ### Set labels and make axes equal if mesh.n_spatial_dims == 1: @@ -338,6 +374,13 @@ def _draw_2d( if active_scalar_source == "cells" and cell_scalar_values is not None: facecolors = scalar_mapper.to_rgba(cell_scalar_values.cpu().numpy()) + elif active_scalar_source == "points" and point_scalar_values is not None: + # Map per-vertex scalars to per-face colors by averaging each + # face's vertex RGBA values (same approach as _draw_3d). + vertex_colors = scalar_mapper.to_rgba( + point_scalar_values.cpu().numpy() + ) # (n_points, 4) + facecolors = vertex_colors[cells_np].mean(axis=1) # (n_faces, 4) else: facecolors = cell_neutral_color @@ -363,7 +406,17 @@ def _draw_2d( ax.add_collection(pc) ### Draw points - if alpha_points > 0: + # When point scalars have been mapped onto face colors (above), suppress the + # scatter overlay - the faces already carry the vertex color information and + # overlaid dots would be redundant. This matches _draw_3d behavior. + has_colored_surface = ( + cells_np.shape[0] > 0 + and alpha_cells > 0 + and active_scalar_source == "points" + and point_scalar_values is not None + ) + + if alpha_points > 0 and not has_colored_surface: if active_scalar_source == "points" and point_scalar_values is not None: colors = scalar_mapper.to_rgba(point_scalar_values.cpu().numpy()) else: @@ -433,6 +486,15 @@ def _draw_3d( if active_scalar_source == "cells" and cell_scalar_values is not None: facecolors = scalar_mapper.to_rgba(cell_scalar_values.cpu().numpy()) + elif active_scalar_source == "points" and point_scalar_values is not None: + # Map per-vertex scalars to per-face colors by averaging each + # face's vertex RGBA values. This avoids a separate scatter + # overlay that matplotlib cannot correctly depth-sort against + # Poly3DCollection faces (painter's algorithm limitation). + vertex_colors = scalar_mapper.to_rgba( + point_scalar_values.cpu().numpy() + ) # (n_points, 4) + facecolors = vertex_colors[cells_np].mean(axis=1) # (n_faces, 4) else: facecolors = cell_neutral_color @@ -440,7 +502,7 @@ def _draw_3d( edgecolors = [(0, 0, 0, alpha_edges)] * len(verts) linewidths = 0.25 else: - edgecolors = "none" + edgecolors = None linewidths = 0 pc = Poly3DCollection( @@ -449,19 +511,30 @@ def _draw_3d( edgecolors=edgecolors, linewidths=linewidths, alpha=alpha_cells, + shade=True, zorder=1, ) ax.add_collection3d(pc) - elif n_manifold_dims == 3: - # 3D manifold (tetrahedra) in 3D: extract surface triangles - # For solid tetrahedra, we need to draw the 4 triangular faces - # This is complex; for now, we'll just show the vertices - # A proper implementation would extract the boundary surface - pass # Handle tetrahedra by extracting surface in future version + else: + # Volume meshes (3D+ manifold) are reduced to surface meshes in + # draw_mesh_matplotlib() before reaching this function. + raise ValueError( + f"Cannot render {n_manifold_dims}D cells directly in matplotlib. " + f"Volume meshes should be converted to surface meshes via " + f"get_facet_mesh() before calling _draw_3d." + ) ### Draw points - if alpha_points > 0: + # For 3D surface meshes, skip the scatter overlay: matplotlib cannot + # depth-sort scatter points against Poly3DCollection faces (painter's + # algorithm limitation). Vertices are visible at face corners via edges, + # and point scalars are mapped onto face colors above. + has_opaque_surface = ( + cells_np.shape[0] > 0 and cells_np.shape[1] - 1 == 2 and alpha_cells > 0 + ) + + if alpha_points > 0 and not has_opaque_surface: if active_scalar_source == "points" and point_scalar_values is not None: colors = scalar_mapper.to_rgba(point_scalar_values.cpu().numpy()) else: diff --git a/physicsnemo/mesh/visualization/_pyvista_impl.py b/physicsnemo/mesh/visualization/_pyvista_impl.py index 0800640ed2..55d216cfa6 100644 --- a/physicsnemo/mesh/visualization/_pyvista_impl.py +++ b/physicsnemo/mesh/visualization/_pyvista_impl.py @@ -33,6 +33,7 @@ def draw_mesh_pyvista( point_scalar_values: torch.Tensor | None, cell_scalar_values: torch.Tensor | None, active_scalar_source: Literal["points", "cells", None], + scalar_label: str | None, show: bool, cmap: str, vmin: float | None, @@ -54,6 +55,8 @@ def draw_mesh_pyvista( Processed cell scalar values (1D tensor or None). active_scalar_source : {"points", "cells", None} Which scalar source is active ("points", "cells", or None). + scalar_label : str or None + Human-readable label for the colorbar title. show : bool Whether to call plotter.show(). cmap : str @@ -137,6 +140,7 @@ def draw_mesh_pyvista( ### Add mesh to plotter # PyVista's add_mesh handles different mesh types appropriately + scalar_bar_args = {"title": scalar_label} if scalar_label else None plotter.add_mesh( pv_mesh, scalars=scalars, @@ -147,6 +151,7 @@ def draw_mesh_pyvista( edge_color="black", line_width=1.0 if show_edges else 0, clim=clim, + scalar_bar_args=scalar_bar_args, **kwargs, ) @@ -175,6 +180,7 @@ def draw_mesh_pyvista( render_points_as_spheres=True, opacity=alpha_points, clim=clim if point_scalars else None, + scalar_bar_args=scalar_bar_args if point_scalars else None, ) ### Show plotter if requested diff --git a/physicsnemo/mesh/visualization/_scalar_utils.py b/physicsnemo/mesh/visualization/_scalar_utils.py index 5721fab2f0..2fb85d9a8c 100644 --- a/physicsnemo/mesh/visualization/_scalar_utils.py +++ b/physicsnemo/mesh/visualization/_scalar_utils.py @@ -27,7 +27,7 @@ def process_scalars( data_dict: TensorDict, n_expected: int, name: str, -) -> tuple[torch.Tensor | None, Literal["points", "cells", None]]: +) -> tuple[torch.Tensor | None, Literal["points", "cells", None], str | None]: """Process scalar specification into concrete tensor values. Parameters @@ -47,9 +47,10 @@ def process_scalars( Returns ------- tuple - Tuple of (scalar_values, source_type) where: + Tuple of (scalar_values, source_type, label) where: - scalar_values is None if scalar_spec is None, otherwise a 1D tensor - source_type indicates whether this is "points", "cells", or None + - label is a human-readable name for the colorbar (or None) Raises ------ @@ -59,7 +60,7 @@ def process_scalars( If specified key is not found in data_dict. """ if scalar_spec is None: - return None, None + return None, None, None ### Case 1: Direct tensor specification if isinstance(scalar_spec, torch.Tensor): @@ -78,8 +79,11 @@ def process_scalars( # Flatten all trailing dimensions and compute norm scalar_tensor = scalar_tensor.reshape(n_expected, -1) scalar_tensor = torch.norm(scalar_tensor, dim=-1) + label = "Magnitude" + else: + label = "Scalars" - return scalar_tensor, name + "s" # "points" or "cells" + return scalar_tensor, name + "s", label # "points" or "cells" ### Case 2: Key lookup in TensorDict (str or tuple[str, ...]) if isinstance(scalar_spec, (str, tuple)): @@ -99,12 +103,16 @@ def process_scalars( f"Full shape: {scalar_tensor.shape}" ) + # Determine label: use key name, but append " (magnitude)" if we take norm + label = str(scalar_spec) + # If multi-dimensional, compute L2 norm across trailing dimensions if scalar_tensor.ndim > 1: scalar_tensor = scalar_tensor.reshape(n_expected, -1) scalar_tensor = torch.norm(scalar_tensor, dim=-1) + label = f"{label} (magnitude)" - return scalar_tensor, name + "s" # "points" or "cells" + return scalar_tensor, name + "s", label # "points" or "cells" raise TypeError( f"{name}_scalars must be None, torch.Tensor, str, or tuple[str, ...], " @@ -123,6 +131,7 @@ def validate_and_process_scalars( torch.Tensor | None, torch.Tensor | None, Literal["points", "cells", None], + str | None, ]: """Validate and process both point and cell scalars. @@ -144,7 +153,8 @@ def validate_and_process_scalars( Returns ------- tuple - Tuple of (point_scalar_values, cell_scalar_values, active_scalar_source). + Tuple of (point_scalar_values, cell_scalar_values, active_scalar_source, + scalar_label) where scalar_label is the human-readable name for the colorbar. Raises ------ @@ -159,14 +169,17 @@ def validate_and_process_scalars( ) ### Process point scalars - point_values, point_source = process_scalars( + point_values, point_source, point_label = process_scalars( point_scalars, point_data, n_points, "point" ) ### Process cell scalars - cell_values, cell_source = process_scalars(cell_scalars, cell_data, n_cells, "cell") + cell_values, cell_source, cell_label = process_scalars( + cell_scalars, cell_data, n_cells, "cell" + ) - ### Determine active scalar source + ### Determine active scalar source and label active_scalar_source = point_source or cell_source + scalar_label = point_label or cell_label - return point_values, cell_values, active_scalar_source + return point_values, cell_values, active_scalar_source, scalar_label diff --git a/physicsnemo/mesh/visualization/draw_mesh.py b/physicsnemo/mesh/visualization/draw_mesh.py index 8debe03322..eb1e7e0acf 100644 --- a/physicsnemo/mesh/visualization/draw_mesh.py +++ b/physicsnemo/mesh/visualization/draw_mesh.py @@ -16,7 +16,7 @@ """Main entry point for mesh visualization with backend selection.""" -from typing import TYPE_CHECKING, Literal +from typing import TYPE_CHECKING, Any, Literal import torch @@ -45,7 +45,7 @@ def draw_mesh( alpha_edges: float = 1.0, show_edges: bool = True, ax=None, - **kwargs, + backend_options: dict[str, Any] | None = None, ): """Draw a mesh using matplotlib or PyVista backend. @@ -99,8 +99,9 @@ def draw_mesh( ax : matplotlib.axes.Axes, optional (matplotlib only) Existing matplotlib axes to plot on. If None, creates new figure and axes. - **kwargs : dict - Additional backend-specific keyword arguments. + backend_options : dict[str, Any], optional + Additional keyword arguments forwarded to the underlying + visualization backend (e.g. PyVista's ``plotter.add_mesh()``). Returns ------- @@ -142,7 +143,7 @@ def draw_mesh( validate_and_process_scalars, ) - point_scalar_values, cell_scalar_values, active_scalar_source = ( + point_scalar_values, cell_scalar_values, active_scalar_source, scalar_label = ( validate_and_process_scalars( point_scalars=point_scalars, cell_scalars=cell_scalars, @@ -191,6 +192,26 @@ def draw_mesh( f"Unknown {backend=!r}. Supported backends: {supported}, 'auto'." ) + # Track the resolved backend for warning checks below + resolved_backend = backend + + ### Warn about unsupported options + if backend_options and resolved_backend == "matplotlib": + import warnings + + warnings.warn( + "backend_options are only supported with the 'pyvista' backend and will be ignored.", + stacklevel=2, + ) + + if alpha_edges != 1.0 and resolved_backend == "pyvista": + import warnings + + warnings.warn( + "alpha_edges is not supported by the 'pyvista' backend and will be ignored.", + stacklevel=2, + ) + ### Dispatch to backend if backend == "matplotlib": from physicsnemo.mesh.visualization._matplotlib_impl import draw_mesh_matplotlib @@ -200,6 +221,7 @@ def draw_mesh( point_scalar_values=point_scalar_values, cell_scalar_values=cell_scalar_values, active_scalar_source=active_scalar_source, + scalar_label=scalar_label, show=show, cmap=cmap, vmin=vmin, @@ -209,7 +231,6 @@ def draw_mesh( alpha_edges=alpha_edges, show_edges=show_edges, ax=ax, - **kwargs, ) elif backend == "pyvista": @@ -226,6 +247,7 @@ def draw_mesh( point_scalar_values=point_scalar_values, cell_scalar_values=cell_scalar_values, active_scalar_source=active_scalar_source, + scalar_label=scalar_label, show=show, cmap=cmap, vmin=vmin, @@ -233,7 +255,7 @@ def draw_mesh( alpha_points=alpha_points, alpha_cells=alpha_cells, show_edges=show_edges, - **kwargs, + **(backend_options or {}), ) else: diff --git a/pyproject.toml b/pyproject.toml index e81bfba70e..c0d32fcd43 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -161,6 +161,7 @@ utils-extras = [ ] mesh-extras = [ "matplotlib>=3.10.7", + "pyacvd>=0.3.2", "pyvista>=0.46.4", ] nn-extras = [ diff --git a/test/mesh/boundaries/test_boundary_extraction.py b/test/mesh/boundaries/test_boundary_extraction.py new file mode 100644 index 0000000000..bbacda61b6 --- /dev/null +++ b/test/mesh/boundaries/test_boundary_extraction.py @@ -0,0 +1,371 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for boundary mesh extraction. + +Tests validate that boundary mesh extraction correctly identifies and extracts +only the facets that lie on the boundary of a mesh (appearing in exactly one cell). +""" + +import pytest +import torch + +from physicsnemo.mesh.mesh import Mesh + + +class TestBoundaryExtraction2D: + """Test boundary extraction for 2D triangular meshes.""" + + def test_single_triangle_boundary(self, device): + """Single triangle has 3 boundary edges.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + boundary = mesh.get_boundary_mesh() + + ### Single triangle has 3 boundary edges + assert boundary.n_cells == 3 + assert boundary.n_manifold_dims == 1 + + ### Boundary should contain all edges + expected_edges = torch.tensor([[0, 1], [0, 2], [1, 2]], device=device) + assert torch.all( + torch.sort(boundary.cells, dim=-1)[0] + == torch.sort(expected_edges, dim=-1)[0] + ) + + def test_two_triangles_shared_edge(self, device): + """Two triangles sharing an edge have 4 boundary edges.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + boundary = mesh.get_boundary_mesh() + + ### Should have 4 boundary edges (perimeter of quad) + assert boundary.n_cells == 4 + + ### Check that the shared edge [1, 2] is not in boundary + boundary_sorted = torch.sort(boundary.cells, dim=-1)[0] + shared_edge = torch.tensor([[1, 2]], device=device) + matches = torch.all(boundary_sorted == shared_edge, dim=1) + assert not torch.any(matches), "Shared edge should not be in boundary" + + def test_closed_2d_mesh_no_boundary(self, device): + """Closed 2D mesh (all edges shared) has empty boundary.""" + ### Create a simple quad (4 triangles) + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0], [0.5, 0.5]], + device=device, + ) + cells = torch.tensor( + [ + [0, 1, 4], + [1, 2, 4], + [2, 3, 4], + [3, 0, 4], + ], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + boundary = mesh.get_boundary_mesh() + + ### Should have 4 boundary edges around the perimeter + assert boundary.n_cells == 4 + + +class TestBoundaryExtraction3D: + """Test boundary extraction for 3D tetrahedral meshes.""" + + def test_single_tetrahedron_boundary(self, device): + """Single tetrahedron has 4 boundary triangular faces.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ], + device=device, + ) + cells = torch.tensor([[0, 1, 2, 3]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + boundary = mesh.get_boundary_mesh() + + ### Single tet has 4 boundary triangular faces + assert boundary.n_cells == 4 + assert boundary.n_manifold_dims == 2 + + ### Check that all 4 faces are present + expected_faces = torch.tensor( + [ + [0, 1, 2], + [0, 1, 3], + [0, 2, 3], + [1, 2, 3], + ], + device=device, + ) + boundary_sorted = torch.sort(boundary.cells, dim=-1)[0] + expected_sorted = torch.sort(expected_faces, dim=-1)[0] + + ### Check that boundary contains all expected faces + for expected_face in expected_sorted: + matches = torch.all(boundary_sorted == expected_face.unsqueeze(0), dim=1) + assert torch.any(matches), f"Face {expected_face} should be in boundary" + + def test_two_tets_shared_face(self, device): + """Two tets sharing a face have 6 boundary faces.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [0.0, 0.0, -1.0], # Point on opposite side + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [0, 1, 2, 4]], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + boundary = mesh.get_boundary_mesh() + + ### Two tets sharing face [0,1,2] have 6 boundary faces + ### (4 faces from first tet + 4 from second - 2 shared = 6) + assert boundary.n_cells == 6 + + ### Check that the shared face [0, 1, 2] is not in boundary + boundary_sorted = torch.sort(boundary.cells, dim=-1)[0] + shared_face = torch.tensor([[0, 1, 2]], device=device) + matches = torch.all(boundary_sorted == shared_face, dim=1) + assert not torch.any(matches), "Shared face should not be in boundary" + + +class TestBoundaryExtraction1D: + """Test boundary extraction for 1D edge meshes.""" + + def test_single_edge_boundary(self, device): + """Single edge has 2 boundary vertices.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], device=device) + cells = torch.tensor([[0, 1]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + boundary = mesh.get_boundary_mesh() + + ### Single edge has 2 boundary vertices + assert boundary.n_cells == 2 + assert boundary.n_manifold_dims == 0 + + def test_chain_of_edges(self, device): + """Chain of edges has 2 boundary vertices at ends.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0]], + device=device, + ) + cells = torch.tensor( + [[0, 1], [1, 2], [2, 3]], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + boundary = mesh.get_boundary_mesh() + + ### Chain has 2 boundary vertices (at ends: 0 and 3) + assert boundary.n_cells == 2 + + ### Check that boundary vertices are 0 and 3 + boundary_vertices = boundary.cells.flatten() + assert torch.all( + torch.sort(boundary_vertices)[0] == torch.tensor([0, 3], device=device) + ) + + def test_closed_loop_no_boundary(self, device): + """Closed loop of edges has no boundary.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]], + device=device, + ) + cells = torch.tensor( + [[0, 1], [1, 2], [2, 3], [3, 0]], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + boundary = mesh.get_boundary_mesh() + + ### Closed loop has no boundary + assert boundary.n_cells == 0 + + +class TestBoundaryDataInheritance: + """Test that boundary mesh correctly inherits data from parent.""" + + def test_boundary_inherits_cell_data(self, device): + """Boundary mesh inherits data from parent cells.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], device=device, dtype=torch.int64) + + ### Add cell data + cell_data = {"pressure": torch.tensor([1.0, 2.0], device=device)} + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + + boundary = mesh.get_boundary_mesh(data_source="cells") + + ### Boundary should have cell_data + assert "pressure" in boundary.cell_data.keys() + assert len(boundary.cell_data["pressure"]) == boundary.n_cells + + def test_boundary_inherits_point_data(self, device): + """Boundary mesh can inherit data from points.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + + ### Add point data + point_data = {"temperature": torch.tensor([10.0, 20.0, 15.0], device=device)} + mesh = Mesh(points=points, cells=cells, point_data=point_data) + + boundary = mesh.get_boundary_mesh(data_source="points") + + ### Boundary should have cell_data averaged from points + assert "temperature" in boundary.cell_data.keys() + assert len(boundary.cell_data["temperature"]) == boundary.n_cells + + +class TestBoundaryEmptyMesh: + """Test boundary extraction on edge cases.""" + + def test_empty_mesh(self, device): + """Empty mesh has empty boundary.""" + points = torch.empty((0, 2), device=device) + cells = torch.empty((0, 3), device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + boundary = mesh.get_boundary_mesh() + + assert boundary.n_cells == 0 + assert boundary.n_points == 0 + + +class TestLumpyBallBoundary: + """Test boundary extraction from lumpy_ball volumetric meshes.""" + + @pytest.mark.parametrize("subdivisions", [0, 1, 2, 3]) + def test_boundary_cell_count(self, device, subdivisions): + """Boundary of lumpy_ball has exactly n_faces = 20 * 4^subdivisions cells.""" + from physicsnemo.mesh.primitives.procedural import lumpy_ball + + mesh = lumpy_ball.load(subdivisions=subdivisions, device=device) + boundary = mesh.get_boundary_mesh() + + expected_faces = 20 * (4**subdivisions) + assert boundary.n_cells == expected_faces, ( + f"Expected {expected_faces} boundary faces for subdivisions={subdivisions}, " + f"got {boundary.n_cells}" + ) + + @pytest.mark.parametrize("n_shells", [1, 2, 3]) + def test_boundary_independent_of_shells(self, device, n_shells): + """Boundary cell count is independent of n_shells (only outer shell matters).""" + from physicsnemo.mesh.primitives.procedural import lumpy_ball + + subdivisions = 1 + mesh = lumpy_ball.load( + n_shells=n_shells, subdivisions=subdivisions, device=device + ) + boundary = mesh.get_boundary_mesh() + + expected_faces = 20 * (4**subdivisions) + assert boundary.n_cells == expected_faces + + def test_boundary_is_watertight(self, device): + """Boundary surface of lumpy_ball is watertight (closed, no holes).""" + from physicsnemo.mesh.primitives.procedural import lumpy_ball + + mesh = lumpy_ball.load(n_shells=2, subdivisions=2, device=device) + boundary = mesh.get_boundary_mesh() + + assert boundary.is_watertight(), ( + "Boundary surface should be watertight (every edge shared by exactly 2 faces)" + ) + + def test_boundary_is_manifold(self, device): + """Boundary surface of lumpy_ball is a valid 2D manifold.""" + from physicsnemo.mesh.primitives.procedural import lumpy_ball + + mesh = lumpy_ball.load(n_shells=2, subdivisions=2, device=device) + boundary = mesh.get_boundary_mesh() + + assert boundary.is_manifold(), ( + "Boundary surface should be manifold (no T-junctions or non-manifold edges)" + ) + + def test_boundary_manifold_dims(self, device): + """Boundary of 3D tetrahedral mesh is 2D triangular mesh.""" + from physicsnemo.mesh.primitives.procedural import lumpy_ball + + mesh = lumpy_ball.load(device=device) + boundary = mesh.get_boundary_mesh() + + assert mesh.n_manifold_dims == 3, "lumpy_ball should be 3D (tetrahedra)" + assert boundary.n_manifold_dims == 2, "Boundary should be 2D (triangles)" + assert boundary.cells.shape[1] == 3, ( + "Boundary cells should have 3 vertices each" + ) + + @pytest.mark.parametrize("noise_amplitude", [0.0, 0.3, 0.5]) + def test_boundary_valid_with_noise(self, device, noise_amplitude): + """Boundary remains well-formed regardless of noise amplitude.""" + from physicsnemo.mesh.primitives.procedural import lumpy_ball + + mesh = lumpy_ball.load( + n_shells=2, + noise_amplitude=noise_amplitude, + seed=42, + subdivisions=2, + device=device, + ) + boundary = mesh.get_boundary_mesh() + + # Cell count unaffected by noise (topology preserved) + expected_faces = 20 * (4**2) + assert boundary.n_cells == expected_faces + + # Topology preserved + assert boundary.is_watertight() + assert boundary.is_manifold() diff --git a/test/mesh/boundaries/test_detection.py b/test/mesh/boundaries/test_detection.py new file mode 100644 index 0000000000..bf8746d5c4 --- /dev/null +++ b/test/mesh/boundaries/test_detection.py @@ -0,0 +1,329 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for boundary detection functions.""" + +import pytest +import torch + +from physicsnemo.mesh import Mesh +from physicsnemo.mesh.boundaries import ( + get_boundary_cells, + get_boundary_edges, + get_boundary_vertices, +) + + +class TestBoundaryVertices: + """Tests for get_boundary_vertices.""" + + def test_closed_surface_no_boundaries(self, device): + """Closed surfaces (watertight) should have no boundary vertices.""" + # Tetrahedron (closed 2D surface) + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3]], + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + is_boundary = get_boundary_vertices(mesh) + + assert is_boundary.shape == (4,) + assert not is_boundary.any(), "Closed surface should have no boundary vertices" + + def test_single_triangle_all_boundaries(self, device): + """Single triangle should have all 3 vertices as boundary.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + is_boundary = get_boundary_vertices(mesh) + + assert is_boundary.shape == (3,) + assert is_boundary.all(), "All vertices of single triangle are on boundary" + + def test_two_triangles_shared_edge(self, device): + """Two triangles sharing an edge.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + is_boundary = get_boundary_vertices(mesh) + + # All 4 vertices are on boundary (edge [1,2] is interior, others are boundary) + assert is_boundary.all(), "All vertices touch boundary edges" + + def test_cylinder_boundaries(self, device): + """Cylinder should have boundary vertices on top and bottom circles.""" + # Simple cylinder: 2 circles (top and bottom) with 8 vertices each + n_circ = 8 + n_height = 4 + + theta = torch.linspace(0, 2 * torch.pi, n_circ + 1, device=device)[:-1] + z_vals = torch.linspace(-1.0, 1.0, n_height, device=device) + + # Vectorized cylinder point generation: (n_height, n_circ) grid + z_grid, theta_grid = torch.meshgrid(z_vals, theta, indexing="ij") + points = torch.stack( + [theta_grid.cos(), theta_grid.sin(), z_grid], dim=-1 + ).reshape(-1, 3) + + # Vectorized cell generation for cylinder (wrapping around circumference) + i_idx, j_idx = torch.meshgrid( + torch.arange(n_height - 1, device=device), + torch.arange(n_circ, device=device), + indexing="ij", + ) + i_idx, j_idx = i_idx.reshape(-1), j_idx.reshape(-1) + j_next = (j_idx + 1) % n_circ # Wrap around for cylinder + # Vertex indices for quad corners + v0 = i_idx * n_circ + j_idx + v1 = i_idx * n_circ + j_next + v2 = (i_idx + 1) * n_circ + j_idx + v3 = (i_idx + 1) * n_circ + j_next + # Two triangles per quad + tri1 = torch.stack([v0, v1, v2], dim=-1) + tri2 = torch.stack([v1, v3, v2], dim=-1) + cells = torch.cat([tri1, tri2], dim=0).to(torch.int64) + mesh = Mesh(points=points, cells=cells) + + is_boundary = get_boundary_vertices(mesh) + + # Top and bottom circles (z=±1) are boundaries + expected_n_boundary = 2 * n_circ # 16 vertices + assert is_boundary.sum() == expected_n_boundary + + # Verify boundary vertices are at z=±1 + boundary_points = mesh.points[is_boundary] + z_coords = boundary_points[:, 2] + assert torch.allclose(z_coords.abs(), torch.ones_like(z_coords), atol=1e-5), ( + "Boundary vertices should be at z=±1" + ) + + def test_empty_mesh(self, device): + """Empty mesh should have no boundary vertices.""" + points = torch.zeros((0, 3), device=device) + cells = torch.zeros((0, 3), dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + is_boundary = get_boundary_vertices(mesh) + + assert is_boundary.shape == (0,) + + +class TestBoundaryEdges: + """Tests for get_boundary_edges.""" + + def test_single_triangle(self, device): + """Single triangle has 3 boundary edges.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + boundary_edges = get_boundary_edges(mesh) + + assert len(boundary_edges) == 3, "Single triangle has 3 boundary edges" + + def test_closed_surface_no_boundary_edges(self, device): + """Closed surface has no boundary edges.""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3]], + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + boundary_edges = get_boundary_edges(mesh) + + assert len(boundary_edges) == 0, "Closed surface has no boundary edges" + + def test_boundary_edges_connectivity(self, device): + """Boundary edges should form proper connectivity.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + boundary_edges = get_boundary_edges(mesh) + + # Should have 4 boundary edges forming a square + assert len(boundary_edges) == 4 + + +class TestBoundaryCells: + """Tests for get_boundary_cells.""" + + def test_single_triangle_is_boundary(self, device): + """Single triangle is a boundary cell.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + is_boundary = get_boundary_cells(mesh, boundary_codimension=1) + + assert is_boundary.shape == (1,) + assert is_boundary.all(), "Single triangle is on boundary" + + def test_closed_surface_no_boundary_cells(self, device): + """Closed surface has no boundary cells.""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3]], + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + is_boundary = get_boundary_cells(mesh, boundary_codimension=1) + + assert is_boundary.shape == (4,) + assert not is_boundary.any(), "Closed surface has no boundary cells" + + def test_two_triangles_both_boundaries(self, device): + """Two triangles sharing edge - both are boundary cells.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + is_boundary = get_boundary_cells(mesh, boundary_codimension=1) + + assert is_boundary.all(), "Both triangles have boundary edges" + + def test_boundary_codimension_validation(self, device): + """Invalid boundary_codimension should raise error.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], device=device) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + # manifold_dims=2, so valid codimensions are 1, 2 + with pytest.raises(ValueError, match="Invalid boundary_codimension"): + get_boundary_cells(mesh, boundary_codimension=0) + + with pytest.raises(ValueError, match="Invalid boundary_codimension"): + get_boundary_cells(mesh, boundary_codimension=3) + + def test_tetrahedra_boundary_cells(self, device): + """Test boundary detection for 3D tetrahedra.""" + # Two tets sharing a triangular face + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [0.0, 0.0, -1.0], + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [0, 1, 2, 4]], + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + # With boundary_codimension=1: cells with boundary triangular faces + is_boundary_1 = get_boundary_cells(mesh, boundary_codimension=1) + assert is_boundary_1.all(), "Both tets have boundary faces" + + # With boundary_codimension=2: cells with boundary edges + is_boundary_2 = get_boundary_cells(mesh, boundary_codimension=2) + assert is_boundary_2.all(), "Both tets have boundary edges" + + def test_empty_mesh(self, device): + """Empty mesh should have no boundary cells.""" + points = torch.zeros((0, 3), device=device) + cells = torch.zeros((0, 3), dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + is_boundary = get_boundary_cells(mesh) + + assert is_boundary.shape == (0,) + + +class TestBoundaryConsistency: + """Tests for consistency between boundary detection functions.""" + + def test_boundary_vertices_match_boundary_edges(self, device): + """Vertices marked as boundary should be incident to boundary edges.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + is_boundary_vertex = get_boundary_vertices(mesh) + boundary_edges = get_boundary_edges(mesh) + + # All boundary edge vertices should be marked as boundary + boundary_verts_from_edges = torch.unique(boundary_edges.flatten()) + is_boundary_from_edges = torch.zeros( + mesh.n_points, dtype=torch.bool, device=device + ) + is_boundary_from_edges[boundary_verts_from_edges] = True + + assert torch.equal(is_boundary_vertex, is_boundary_from_edges), ( + "Boundary vertices should match boundary edge endpoints" + ) + + def test_boundary_cells_contain_boundary_vertices(self, device): + """Boundary cells should contain at least one boundary vertex.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + is_boundary_vertex = get_boundary_vertices(mesh) + is_boundary_cell = get_boundary_cells(mesh, boundary_codimension=1) + + # All boundary cells should contain at least one boundary vertex + for cell_idx in torch.where(is_boundary_cell)[0]: + cell_vertices = mesh.cells[cell_idx] + assert is_boundary_vertex[cell_vertices].any(), ( + f"Boundary cell {cell_idx} should contain at least one boundary vertex" + ) diff --git a/test/mesh/boundaries/test_facet_extraction.py b/test/mesh/boundaries/test_facet_extraction.py new file mode 100644 index 0000000000..cc0bae259a --- /dev/null +++ b/test/mesh/boundaries/test_facet_extraction.py @@ -0,0 +1,1233 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for facet extraction from simplicial meshes. + +Tests validate facet (boundary) extraction across spatial dimensions, manifold +dimensions, and compute backends, with data aggregation strategies. +""" + +import pytest +import torch + +from physicsnemo.mesh.mesh import Mesh + +### Helper Functions ### + + +def create_simple_mesh(n_spatial_dims: int, n_manifold_dims: int, device: str = "cpu"): + """Create a simple mesh for testing.""" + if n_manifold_dims > n_spatial_dims: + raise ValueError( + f"Manifold dimension {n_manifold_dims} cannot exceed spatial dimension {n_spatial_dims}" + ) + + if n_manifold_dims == 0: + if n_spatial_dims == 2: + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], device=device) + elif n_spatial_dims == 3: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]], device=device + ) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.arange(len(points), device=device, dtype=torch.int64).unsqueeze(1) + elif n_manifold_dims == 1: + if n_spatial_dims == 2: + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [1.5, 1.0], [0.5, 1.5]], device=device + ) + elif n_spatial_dims == 3: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 1.0, 1.0]], + device=device, + ) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.tensor([[0, 1], [1, 2], [2, 3]], device=device, dtype=torch.int64) + elif n_manifold_dims == 2: + if n_spatial_dims == 2: + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 0.5]], device=device + ) + elif n_spatial_dims == 3: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0], [1.5, 0.5, 0.5]], + device=device, + ) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], device=device, dtype=torch.int64) + elif n_manifold_dims == 3: + if n_spatial_dims == 3: + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [1, 2, 3, 4]], device=device, dtype=torch.int64 + ) + else: + raise ValueError("3-simplices require 3D embedding space") + else: + raise ValueError(f"Unsupported {n_manifold_dims=}") + + return Mesh(points=points, cells=cells) + + +def assert_on_device(tensor: torch.Tensor, expected_device: str) -> None: + """Assert tensor is on expected device.""" + actual_device = tensor.device.type + assert actual_device == expected_device, ( + f"Device mismatch: tensor is on {actual_device!r}, expected {expected_device!r}" + ) + + +class TestBasicEdgeExtraction: + """Test basic edge extraction functionality.""" + + def test_single_triangle_to_edges(self): + """A single triangle should produce 3 unique edges.""" + ### Create a simple triangle + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + + mesh = Mesh(points=points, cells=cells) + facet_mesh = mesh.get_facet_mesh() + + ### Should have 3 edges + assert facet_mesh.n_cells == 3 + assert facet_mesh.n_manifold_dims == 1 + assert facet_mesh.n_spatial_dims == 2 + + ### Edges should be canonical (sorted) + expected_edges = torch.tensor([[0, 1], [0, 2], [1, 2]]) + assert torch.equal( + torch.sort(facet_mesh.cells, dim=0)[0], + expected_edges, + ) + + def test_two_triangles_shared_edge(self): + """Two triangles sharing an edge should deduplicate that edge.""" + ### Create two triangles sharing edge [1, 2] + points = torch.tensor( + [ + [0.0, 0.0], # 0 + [1.0, 0.0], # 1 + [0.5, 1.0], # 2 + [1.5, 0.5], # 3 + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], # Triangle 1 + [1, 3, 2], # Triangle 2 (shares edge [1, 2]) + ] + ) + + mesh = Mesh(points=points, cells=cells) + facet_mesh = mesh.get_facet_mesh() + + ### Should have 5 unique edges, not 6 + # Triangle 1: [0,1], [0,2], [1,2] + # Triangle 2: [1,2], [1,3], [2,3] + # Unique: [0,1], [0,2], [1,2], [1,3], [2,3] = 5 edges + assert facet_mesh.n_cells == 5 + + expected_edges = torch.tensor( + [ + [0, 1], + [0, 2], + [1, 2], + [1, 3], + [2, 3], + ] + ) + assert torch.equal( + torch.sort(facet_mesh.cells, dim=0)[0], + expected_edges, + ) + + def test_facet_mesh_to_points(self): + """An edge mesh (1-simplices) should extract to 0-simplices.""" + ### Create a simple line segment mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [2.0, 0.0], + ] + ) + # Two connected line segments + cells = torch.tensor( + [ + [0, 1], + [1, 2], + ] + ) + + mesh = Mesh(points=points, cells=cells) + facet_mesh = mesh.get_facet_mesh() + + ### Should extract unique vertices + assert facet_mesh.n_manifold_dims == 0 + # Each edge produces 2 vertices, but vertex 1 is shared + # So we get vertices: [0], [1], [1], [2] -> unique: [0], [1], [2] + assert facet_mesh.n_cells == 3 + + ### Check that we have the right vertices + expected_vertices = torch.tensor([[0], [1], [2]]) + assert torch.equal( + torch.sort(facet_mesh.cells, dim=0)[0], + expected_vertices, + ) + + def test_point_cloud_raises_error(self): + """A point cloud (0-simplices) should raise an error.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [2.0, 0.0], + ] + ) + # Point cloud: each "face" is a single vertex + cells = torch.tensor([[0], [1], [2]]) + + mesh = Mesh(points=points, cells=cells) + + with pytest.raises( + ValueError, match="Would result in negative manifold dimension" + ): + mesh.get_facet_mesh() + + +class TestDataInheritance: + """Test data inheritance from parent mesh to edge mesh.""" + + @pytest.mark.parametrize( + "data_aggregation", + [ + pytest.param("mean", id="mean"), + pytest.param("area_weighted", id="area_weighted"), + pytest.param("inverse_distance", id="inverse_distance"), + ], + ) + def test_cell_data_inheritance(self, data_aggregation): + """Test face data inheritance with different aggregation strategies.""" + ### Create two triangles with known geometry + points = torch.tensor( + [ + [0.0, 0.0], + [2.0, 0.0], + [0.0, 1.0], + [2.0, 2.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], # Triangle 1 + [1, 3, 2], # Triangle 2 (shares edge [1, 2]) + ] + ) + + cell_data = { + "value": torch.tensor([100.0, 300.0]), + } + + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + facet_mesh = mesh.get_facet_mesh( + data_source="cells", data_aggregation=data_aggregation + ) + + ### Shared edge [1, 2] should have aggregated value + shared_edge_idx = torch.where( + (facet_mesh.cells[:, 0] == 1) & (facet_mesh.cells[:, 1] == 2) + )[0] + assert len(shared_edge_idx) == 1 + + ### Compute expected value based on aggregation method + if data_aggregation == "mean": + expected_value = torch.tensor(200.0) # (100 + 300) / 2 + elif data_aggregation == "area_weighted": + areas = mesh.cell_areas + expected_value = (100.0 * areas[0] + 300.0 * areas[1]) / ( + areas[0] + areas[1] + ) + elif data_aggregation == "inverse_distance": + edge_centroid = (points[1] + points[2]) / 2 + tri1_centroid = points[cells[0]].mean(dim=0) + tri2_centroid = points[cells[1]].mean(dim=0) + dist1 = torch.norm(edge_centroid - tri1_centroid) + dist2 = torch.norm(edge_centroid - tri2_centroid) + w1, w2 = 1.0 / dist1, 1.0 / dist2 + expected_value = (100.0 * w1 + 300.0 * w2) / (w1 + w2) + + assert torch.isclose( + facet_mesh.cell_data["value"][shared_edge_idx[0]], + expected_value, + rtol=1e-5, + ) + + def test_point_data_inheritance(self): + """Test point data inheritance (averaging from boundary vertices).""" + ### Create a triangle with point data + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + + point_data = { + "value": torch.tensor([0.0, 1.0, 2.0]), + } + + mesh = Mesh(points=points, cells=cells, point_data=point_data) + facet_mesh = mesh.get_facet_mesh(data_source="points") + + ### Each edge should have averaged value from its endpoints + # Edge [0, 1]: (0.0 + 1.0) / 2 = 0.5 + # Edge [0, 2]: (0.0 + 2.0) / 2 = 1.0 + # Edge [1, 2]: (1.0 + 2.0) / 2 = 1.5 + expected_values = {(0, 1): 0.5, (0, 2): 1.0, (1, 2): 1.5} + for (v0, v1), expected in expected_values.items(): + edge_idx = torch.where( + (facet_mesh.cells[:, 0] == v0) & (facet_mesh.cells[:, 1] == v1) + )[0] + assert torch.isclose( + facet_mesh.cell_data["value"][edge_idx[0]], + torch.tensor(expected), + rtol=1e-5, + ), f"Edge [{v0}, {v1}] expected {expected}" + + def test_multidimensional_data_aggregation(self): + """Test that multidimensional face data is aggregated correctly.""" + ### Create two triangles + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [1.5, 0.5], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ] + ) + + ### Multi-dimensional face data (e.g., velocity vectors) + cell_data = { + "velocity": torch.tensor( + [ + [1.0, 0.0], + [0.0, 1.0], + ] + ), + } + + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + facet_mesh = mesh.get_facet_mesh(data_source="cells", data_aggregation="mean") + + ### Shared edge should have averaged velocity + shared_edge_idx = torch.where( + (facet_mesh.cells[:, 0] == 1) & (facet_mesh.cells[:, 1] == 2) + )[0] + assert len(shared_edge_idx) == 1 + + expected_velocity = torch.tensor([0.5, 0.5]) + assert torch.allclose( + facet_mesh.cell_data["velocity"][shared_edge_idx[0]], + expected_velocity, + rtol=1e-5, + ) + + +class TestEdgeCases: + """Test edge cases and boundary conditions.""" + + def test_no_cell_data(self): + """Edge extraction should work with no face data.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + + mesh = Mesh(points=points, cells=cells) + facet_mesh = mesh.get_facet_mesh() + + assert facet_mesh.n_cells == 3 + assert len(facet_mesh.cell_data.keys()) == 0 + + def test_cached_properties_not_inherited(self): + """Cached properties should not be inherited from parent mesh.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + + mesh = Mesh(points=points, cells=cells) + + ### Access cached properties to populate them + _ = mesh.cell_centroids + _ = mesh.cell_areas + + ### Extract edge mesh + facet_mesh = mesh.get_facet_mesh() + + ### Cached properties should not be in edge mesh cell_data + # With new cache syntax, caches are stored under ("_cache", key) + assert ("_cache", "centroids") not in facet_mesh.cell_data.keys( + include_nested=True + ) + assert ("_cache", "areas") not in facet_mesh.cell_data.keys(include_nested=True) + + +class TestRigorousAggregation: + """Rigorous tests for data aggregation with exact value verification.""" + + def test_three_triangles_sharing_edge(self): + """Test aggregation when three cells share a single edge.""" + ### Create three triangles sharing edge [1, 2] + points = torch.tensor( + [ + [0.0, 0.0], # 0 + [1.0, 0.0], # 1 + [0.5, 1.0], # 2 + [1.5, 0.5], # 3 + [0.5, -1.0], # 4 + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], # Triangle 1: shares edge [1,2] + [1, 3, 2], # Triangle 2: shares edge [1,2] + [1, 2, 4], # Triangle 3: shares edge [1,2] + ] + ) + + cell_data = { + "value": torch.tensor([10.0, 20.0, 30.0]), + } + + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + facet_mesh = mesh.get_facet_mesh(data_source="cells", data_aggregation="mean") + + ### Edge [1, 2] should have mean of all three values + shared_edge_idx = torch.where( + (facet_mesh.cells[:, 0] == 1) & (facet_mesh.cells[:, 1] == 2) + )[0] + assert len(shared_edge_idx) == 1 + + expected_mean = (10.0 + 20.0 + 30.0) / 3.0 + assert torch.isclose( + facet_mesh.cell_data["value"][shared_edge_idx[0]], + torch.tensor(expected_mean), + rtol=1e-6, + ) + + def test_area_weighted_with_exact_areas(self): + """Test area-weighted aggregation with manually computed areas.""" + ### Create two triangles with known areas that share an edge + points2 = torch.tensor( + [ + [0.0, 0.0], # 0 + [2.0, 0.0], # 1 + [0.0, 1.0], # 2 + [2.0, 2.0], # 3 + ] + ) + cells2 = torch.tensor( + [ + [0, 1, 2], # Triangle 1: area = 1.0 + [1, 3, 2], # Triangle 2: area = 2.0, shares edge [1,2] + ] + ) + + cell_data2 = { + "temperature": torch.tensor([100.0, 300.0]), + } + + mesh2 = Mesh(points=points2, cells=cells2, cell_data=cell_data2) + + ### Verify areas + areas2 = mesh2.cell_areas + assert torch.isclose(areas2[0], torch.tensor(1.0), rtol=1e-5) + assert torch.isclose(areas2[1], torch.tensor(2.0), rtol=1e-5) + + facet_mesh = mesh2.get_facet_mesh( + data_source="cells", data_aggregation="area_weighted" + ) + + ### Edge [1, 2] is shared and should be area-weighted + shared_edge_idx = torch.where( + (facet_mesh.cells[:, 0] == 1) & (facet_mesh.cells[:, 1] == 2) + )[0] + + # Expected: (100.0 * 1.0 + 300.0 * 2.0) / (1.0 + 2.0) = 700 / 3 = 233.333... + expected_temp = (100.0 * 1.0 + 300.0 * 2.0) / (1.0 + 2.0) + + assert torch.isclose( + facet_mesh.cell_data["temperature"][shared_edge_idx[0]], + torch.tensor(expected_temp), + rtol=1e-5, + ) + + def test_boundary_vs_interior_edges(self): + """Test that boundary edges (1 parent) and interior edges (2+ parents) are correctly distinguished.""" + ### Create a simple quad made of two triangles + points = torch.tensor( + [ + [0.0, 0.0], # 0 + [1.0, 0.0], # 1 + [1.0, 1.0], # 2 + [0.0, 1.0], # 3 + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], # Lower triangle + [0, 2, 3], # Upper triangle + ] + ) + + cell_data = { + "id": torch.tensor([1.0, 2.0]), + } + + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + facet_mesh = mesh.get_facet_mesh(data_source="cells", data_aggregation="mean") + + ### Should have 5 edges total + assert facet_mesh.n_cells == 5 + + ### Verify interior edge averages both IDs, boundary edge keeps single ID + expected_ids = { + (0, 2): 1.5, # Interior: (1.0 + 2.0) / 2 + (0, 1): 1.0, # Boundary: only face 1 + } + for (v0, v1), expected_id in expected_ids.items(): + edge_idx = torch.where( + (facet_mesh.cells[:, 0] == v0) & (facet_mesh.cells[:, 1] == v1) + )[0] + assert len(edge_idx) == 1 + assert torch.isclose( + facet_mesh.cell_data["id"][edge_idx[0]], + torch.tensor(expected_id), + rtol=1e-6, + ), f"Edge [{v0}, {v1}] expected id {expected_id}" + + def test_multidimensional_point_data(self): + """Test point data inheritance with multidimensional data (e.g., vectors).""" + ### Create triangle with 2D velocity data at each point + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + + point_data = { + "velocity": torch.tensor( + [ + [1.0, 0.0], # Point 0 + [0.0, 1.0], # Point 1 + [1.0, 1.0], # Point 2 + ] + ), + } + + mesh = Mesh(points=points, cells=cells, point_data=point_data) + facet_mesh = mesh.get_facet_mesh(data_source="points") + + ### Each edge should average velocities of its endpoint vertices + expected_velocities = { + (0, 1): torch.tensor([0.5, 0.5]), # ([1,0] + [0,1]) / 2 + (1, 2): torch.tensor([0.5, 1.0]), # ([0,1] + [1,1]) / 2 + } + for (v0, v1), expected_vel in expected_velocities.items(): + edge_idx = torch.where( + (facet_mesh.cells[:, 0] == v0) & (facet_mesh.cells[:, 1] == v1) + )[0] + assert torch.allclose( + facet_mesh.cell_data["velocity"][edge_idx[0]], + expected_vel, + rtol=1e-6, + ), f"Edge [{v0}, {v1}] velocity mismatch" + + def test_tet_to_triangles_exact_count(self): + """Test that a single tet produces exactly 4 unique triangular cells.""" + ### Single tetrahedron + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2, 3]]) + + mesh = Mesh(points=points, cells=cells) + facet_mesh = mesh.get_facet_mesh() + + ### Should produce exactly 4 triangular cells + assert facet_mesh.n_cells == 4 + assert facet_mesh.n_manifold_dims == 2 + + ### Verify all 4 expected triangles are present + expected_triangles = torch.tensor( + [ + [0, 1, 2], # Exclude vertex 3 + [0, 1, 3], # Exclude vertex 2 + [0, 2, 3], # Exclude vertex 1 + [1, 2, 3], # Exclude vertex 0 + ] + ) + + # Sort both for comparison + actual_sorted = torch.sort(facet_mesh.cells, dim=1)[0] + actual_sorted = torch.sort(actual_sorted, dim=0)[0] + expected_sorted = torch.sort(expected_triangles, dim=1)[0] + expected_sorted = torch.sort(expected_sorted, dim=0)[0] + + assert torch.equal(actual_sorted, expected_sorted) + + def test_two_tets_sharing_triangle(self): + """Test two tetrahedra sharing a triangular face.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], # 0 + [1.0, 0.0, 0.0], # 1 + [0.0, 1.0, 0.0], # 2 + [0.0, 0.0, 1.0], # 3 + [0.0, 0.0, -1.0], # 4 + ] + ) + cells = torch.tensor( + [ + [0, 1, 2, 3], # Tet 1 + [0, 1, 2, 4], # Tet 2 (shares triangle [0,1,2]) + ] + ) + + cell_data = { + "tet_id": torch.tensor([1.0, 2.0]), + } + + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + facet_mesh = mesh.get_facet_mesh(data_source="cells", data_aggregation="mean") + + ### Should have 7 unique triangular cells (4 + 4 - 1 shared) + assert facet_mesh.n_cells == 7 + + ### Shared triangle [0, 1, 2] should average both tet IDs + shared_tri_idx = torch.where( + (facet_mesh.cells[:, 0] == 0) + & (facet_mesh.cells[:, 1] == 1) + & (facet_mesh.cells[:, 2] == 2) + )[0] + assert len(shared_tri_idx) == 1 + assert torch.isclose( + facet_mesh.cell_data["tet_id"][shared_tri_idx[0]], + torch.tensor(1.5), # (1.0 + 2.0) / 2 + rtol=1e-6, + ) + + def test_edge_canonical_ordering(self): + """Test that edges are stored in canonical (sorted) order.""" + ### Create triangles with vertices in different orders + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ] + ) + # Define same triangle with different vertex orderings + cells = torch.tensor( + [ + [0, 1, 2], # Standard order + [2, 1, 0], # Reversed order + ] + ) + + mesh = Mesh(points=points, cells=cells) + facet_mesh = mesh.get_facet_mesh() + + ### All edges should be in canonical order (sorted) + for i in range(facet_mesh.n_cells): + edge = facet_mesh.cells[i] + assert edge[0] <= edge[1], f"Edge {edge} is not in canonical order" + + ### Since both triangles are identical, should only get 3 unique edges + assert facet_mesh.n_cells == 3 + + +class TestNestedTensorDicts: + """Test edge extraction with nested TensorDict data structures.""" + + def test_deeply_nested_cell_data(self): + """Test aggregation with deeply nested TensorDicts.""" + from tensordict import TensorDict + + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 0.5]]) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + + ### Create deeply nested structure + cell_data = TensorDict( + { + "level1": TensorDict( + { + "level2": TensorDict( + { + "value": torch.tensor([1.0, 3.0]), + }, + batch_size=torch.Size([2]), + ), + }, + batch_size=torch.Size([2]), + ), + }, + batch_size=torch.Size([2]), + ) + + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + facet_mesh = mesh.get_facet_mesh(data_source="cells", data_aggregation="mean") + + ### Verify deeply nested aggregation + shared_edge_idx = torch.where( + (facet_mesh.cells[:, 0] == 1) & (facet_mesh.cells[:, 1] == 2) + )[0] + + assert torch.isclose( + facet_mesh.cell_data["level1"]["level2"]["value"][shared_edge_idx[0]], + torch.tensor(2.0), # (1 + 3) / 2 + rtol=1e-6, + ) + + def test_nested_point_data(self): + """Test point data aggregation with nested TensorDicts.""" + from tensordict import TensorDict + + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + + ### Create nested TensorDict for point data + point_data = TensorDict( + { + "velocity": torch.tensor([[1.0, 0.0], [0.0, 1.0], [1.0, 1.0]]), + "nested": TensorDict( + { + "density": torch.tensor([1.0, 2.0, 3.0]), + }, + batch_size=torch.Size([3]), + ), + }, + batch_size=torch.Size([3]), + ) + + mesh = Mesh(points=points, cells=cells, point_data=point_data) + facet_mesh = mesh.get_facet_mesh(data_source="points") + + ### Edge [0, 1] should average point data from vertices 0 and 1 + edge_01_idx = torch.where( + (facet_mesh.cells[:, 0] == 0) & (facet_mesh.cells[:, 1] == 1) + )[0] + idx = edge_01_idx[0] + + # Velocity: ([1, 0] + [0, 1]) / 2 = [0.5, 0.5] + assert torch.allclose( + facet_mesh.cell_data["velocity"][idx], torch.tensor([0.5, 0.5]), rtol=1e-6 + ) + # Nested density: (1.0 + 2.0) / 2 = 1.5 + assert torch.isclose( + facet_mesh.cell_data["nested"]["density"][idx], torch.tensor(1.5), rtol=1e-6 + ) + + def test_nested_with_area_weighting(self): + """Test nested TensorDicts with area-weighted aggregation.""" + from tensordict import TensorDict + + points = torch.tensor( + [ + [0.0, 0.0], + [2.0, 0.0], + [0.0, 1.0], + [2.0, 2.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], # Triangle 1: area = 1.0 + [1, 3, 2], # Triangle 2: area = 2.0 + ] + ) + + cell_data = TensorDict( + { + "nested": TensorDict( + { + "value": torch.tensor([100.0, 300.0]), + }, + batch_size=torch.Size([2]), + ), + }, + batch_size=torch.Size([2]), + ) + + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + + ### Verify areas match expectations + assert torch.isclose(mesh.cell_areas[0], torch.tensor(1.0), rtol=1e-5) + assert torch.isclose(mesh.cell_areas[1], torch.tensor(2.0), rtol=1e-5) + + facet_mesh = mesh.get_facet_mesh( + data_source="cells", data_aggregation="area_weighted" + ) + + ### Shared edge [1, 2] with area weighting + shared_edge_idx = torch.where( + (facet_mesh.cells[:, 0] == 1) & (facet_mesh.cells[:, 1] == 2) + )[0] + # Expected: (100.0 * 1.0 + 300.0 * 2.0) / (1.0 + 2.0) = 700 / 3 + expected = (100.0 * 1.0 + 300.0 * 2.0) / (1.0 + 2.0) + assert torch.isclose( + facet_mesh.cell_data["nested"]["value"][shared_edge_idx[0]], + torch.tensor(expected), + rtol=1e-5, + ) + + def test_mixed_nested_and_flat_data(self): + """Test aggregation with mix of flat and nested data.""" + from tensordict import TensorDict + + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 0.5]]) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + + cell_data = TensorDict( + { + "flat_scalar": torch.tensor([10.0, 20.0]), + "flat_vector": torch.tensor([[1.0, 2.0], [3.0, 4.0]]), + "nested": TensorDict( + { + "a": torch.tensor([100.0, 200.0]), + "b": torch.tensor([[5.0, 6.0], [7.0, 8.0]]), + }, + batch_size=torch.Size([2]), + ), + }, + batch_size=torch.Size([2]), + ) + + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + facet_mesh = mesh.get_facet_mesh(data_source="cells", data_aggregation="mean") + + shared_edge_idx = torch.where( + (facet_mesh.cells[:, 0] == 1) & (facet_mesh.cells[:, 1] == 2) + )[0] + idx = shared_edge_idx[0] + + ### Check all data types averaged correctly + assert torch.isclose( + facet_mesh.cell_data["flat_scalar"][idx], torch.tensor(15.0), rtol=1e-6 + ) + assert torch.allclose( + facet_mesh.cell_data["flat_vector"][idx], + torch.tensor([2.0, 3.0]), + rtol=1e-6, + ) + assert torch.isclose( + facet_mesh.cell_data["nested"]["a"][idx], torch.tensor(150.0), rtol=1e-6 + ) + assert torch.allclose( + facet_mesh.cell_data["nested"]["b"][idx], + torch.tensor([6.0, 7.0]), + rtol=1e-6, + ) + + +class TestHigherCodimension: + """Test extraction of higher-codimension meshes.""" + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims,codim,expected_manifold_dim,expected_n_cells,expected_cell_size", + [ + pytest.param(2, 2, 2, 0, 4, 1, id="triangles_to_vertices"), + pytest.param(3, 3, 2, 1, 6, 2, id="tets_to_edges"), + pytest.param(3, 3, 3, 0, 4, 1, id="tets_to_vertices"), + ], + ) + def test_basic_higher_codimension( + self, + n_spatial_dims, + n_manifold_dims, + codim, + expected_manifold_dim, + expected_n_cells, + expected_cell_size, + ): + """Test higher codimension extraction across mesh types.""" + if n_spatial_dims == 2: + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]]) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + else: + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2, 3]]) + + mesh = Mesh(points=points, cells=cells) + facet_mesh = mesh.get_facet_mesh(manifold_codimension=codim) + + assert facet_mesh.n_manifold_dims == expected_manifold_dim + assert facet_mesh.n_cells == expected_n_cells + assert facet_mesh.cells.shape == (expected_n_cells, expected_cell_size) + + ### For tet→edges, verify all 6 edges are present + if n_spatial_dims == 3 and codim == 2: + expected_edges = {(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)} + actual_edges = {tuple(edge.tolist()) for edge in facet_mesh.cells} + assert actual_edges == expected_edges + + ### For triangles→vertices, verify sorted unique vertices + if n_spatial_dims == 2 and codim == 2: + expected_vertices = torch.tensor([[0], [1], [2], [3]]) + assert torch.equal( + torch.sort(facet_mesh.cells, dim=0)[0], + expected_vertices, + ) + + def test_codimension_too_large_raises_error(self): + """Test that requesting too high a codimension raises an error.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) # Triangle (n_manifold_dims = 2) + + mesh = Mesh(points=points, cells=cells) + + ### Codimension 3 would give manifold_dims = -1, should raise + with pytest.raises( + ValueError, match="Would result in negative manifold dimension" + ): + mesh.get_facet_mesh(manifold_codimension=3) + + def test_data_inheritance_with_codim2(self): + """Test that data inheritance works correctly with higher codimension.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2, 3]]) # Single tetrahedron + + ### Add some cell data + cell_data = {"pressure": torch.tensor([100.0])} + + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + edge_mesh = mesh.get_facet_mesh( + manifold_codimension=2, data_source="cells", data_aggregation="mean" + ) + + ### All edges should inherit the same pressure value + assert "pressure" in edge_mesh.cell_data + assert torch.allclose( + edge_mesh.cell_data["pressure"], + torch.tensor([100.0] * 6), + ) + + def test_codim2_multiple_cells_shared_edge(self): + """Test codimension 2 extraction with multiple tets sharing edges.""" + ### Create two tetrahedra sharing edge [1, 2] + # First tet: [0, 1, 2, 3] + # Second tet: [1, 2, 4, 5] + # They share edge [1, 2] + points = torch.tensor( + [ + [0.0, 0.0, 0.0], # 0 + [1.0, 0.0, 0.0], # 1 - shared + [0.5, 1.0, 0.0], # 2 - shared + [0.5, 0.5, 1.0], # 3 + [1.5, 0.5, 0.5], # 4 + [1.0, 1.0, 1.0], # 5 + ] + ) + cells = torch.tensor( + [ + [0, 1, 2, 3], # First tetrahedron + [1, 2, 4, 5], # Second tetrahedron (shares edge [1,2]) + ] + ) + + ### Add different pressure values to each tet + cell_data = { + "pressure": torch.tensor([100.0, 200.0]), + "temperature": torch.tensor([300.0, 500.0]), + } + + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + edge_mesh = mesh.get_facet_mesh( + manifold_codimension=2, data_source="cells", data_aggregation="mean" + ) + + ### First tet has C(4,2)=6 edges, second tet has 6 edges + ### They share edge [1,2], so total unique edges = 6 + 6 - 1 = 11 + assert edge_mesh.n_cells == 11 + assert "pressure" in edge_mesh.cell_data + assert "temperature" in edge_mesh.cell_data + + ### Verify pressure values for shared and boundary edges + expected_pressures = { + (1, 2): 150.0, # Shared edge: (100 + 200) / 2 + (0, 1): 100.0, # First tet only + (4, 5): 200.0, # Second tet only + } + for (v0, v1), expected_pressure in expected_pressures.items(): + edge_idx = torch.where( + (edge_mesh.cells[:, 0] == v0) & (edge_mesh.cells[:, 1] == v1) + )[0] + assert len(edge_idx) == 1, f"Edge [{v0}, {v1}] should exist exactly once" + assert torch.isclose( + edge_mesh.cell_data["pressure"][edge_idx[0]], + torch.tensor(expected_pressure), + rtol=1e-5, + ), f"Edge [{v0}, {v1}] pressure expected {expected_pressure}" + + ### Shared edge should also have aggregated temperature + shared_edge_idx = torch.where( + (edge_mesh.cells[:, 0] == 1) & (edge_mesh.cells[:, 1] == 2) + )[0] + assert torch.isclose( + edge_mesh.cell_data["temperature"][shared_edge_idx[0]], + torch.tensor(400.0), # (300 + 500) / 2 + rtol=1e-5, + ) + + +class TestDifferentDevices: + """Test edge extraction on different devices.""" + + @pytest.mark.cuda + def test_cuda_edge_extraction(self): + """Test edge extraction on CUDA device (specific real-world case).""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], + device="cuda", + ) + cells = torch.tensor([[0, 1, 2]], device="cuda") + + mesh = Mesh(points=points, cells=cells) + facet_mesh = mesh.get_facet_mesh() + + assert facet_mesh.points.device.type == "cuda" + assert facet_mesh.cells.device.type == "cuda" + assert facet_mesh.n_cells == 3 + + +### Parametrized Tests for Exhaustive Dimensional Coverage ### + + +class TestFacetExtractionParametrized: + """Parametrized tests for facet extraction across all dimensions and backends.""" + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 1), # Edges → Points in 2D + (2, 2), # Triangles → Edges in 2D + (3, 1), # Edges → Points in 3D + (3, 2), # Surfaces → Edges in 3D + (3, 3), # Volumes → Surfaces in 3D + ], + ) + def test_basic_facet_extraction_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Test basic facet extraction and deduplication across all dimension combinations.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + facet_mesh = mesh.get_facet_mesh() + + # Verify dimensions + assert facet_mesh.n_spatial_dims == n_spatial_dims, ( + f"Spatial dims should be preserved: {facet_mesh.n_spatial_dims=} != {n_spatial_dims=}" + ) + assert facet_mesh.n_manifold_dims == n_manifold_dims - 1, ( + f"Manifold dims should decrease by 1: {facet_mesh.n_manifold_dims=} != {n_manifold_dims - 1=}" + ) + + # Verify device consistency + assert_on_device(facet_mesh.points, device) + assert_on_device(facet_mesh.cells, device) + + # Verify facets exist + assert facet_mesh.n_cells > 0, "Should extract at least some facets" + + # Verify cell shape + expected_verts_per_facet = n_manifold_dims + assert facet_mesh.cells.shape[1] == expected_verts_per_facet, ( + f"Facets should have {expected_verts_per_facet} vertices, " + f"got {facet_mesh.cells.shape[1]}" + ) + + # Verify deduplication (facets are unique) + if mesh.n_cells >= 2: + sorted_facets = torch.sort(facet_mesh.cells, dim=1)[0] + unique_facets = torch.unique(sorted_facets, dim=0) + assert unique_facets.shape[0] == sorted_facets.shape[0], ( + f"Found duplicate facets: {sorted_facets.shape[0]} facets, " + f"but only {unique_facets.shape[0]} unique" + ) + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [(2, 2), (3, 2), (3, 3)], + ) + @pytest.mark.parametrize( + "data_aggregation", + ["mean", "area_weighted", "inverse_distance"], + ) + def test_data_aggregation_parametrized( + self, n_spatial_dims, n_manifold_dims, data_aggregation, device + ): + """Test all data aggregation strategies across dimensions.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + # Add some cell data + cell_data_values = ( + torch.arange(mesh.n_cells, dtype=torch.float32, device=device) * 10.0 + ) + mesh.cell_data["value"] = cell_data_values + + facet_mesh = mesh.get_facet_mesh( + data_source="cells", + data_aggregation=data_aggregation, + ) + + # Verify data was aggregated + assert "value" in facet_mesh.cell_data, ( + f"Cell data should be aggregated with {data_aggregation=}" + ) + assert facet_mesh.cell_data["value"].shape[0] == facet_mesh.n_cells, ( + "Aggregated data should have one value per facet" + ) + + # Verify device consistency + assert_on_device(facet_mesh.cell_data["value"], device) + + # Verify values are reasonable (should be within range of original data) + min_original = cell_data_values.min() + max_original = cell_data_values.max() + min_facet = facet_mesh.cell_data["value"].min() + max_facet = facet_mesh.cell_data["value"].max() + + assert min_facet >= min_original, ( + f"Facet min value should be >= original min: {min_facet=}, {min_original=}" + ) + assert max_facet <= max_original, ( + f"Facet max value should be <= original max: {max_facet=}, {max_original=}" + ) + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 1), + (2, 2), + (3, 1), + (3, 2), + (3, 3), + ], + ) + def test_global_data_preserved_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Test that global data is preserved across dimensions.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + # Add global data + mesh.global_data["time"] = torch.tensor(42.0, device=device) + mesh.global_data["iteration"] = torch.tensor(100, device=device) + + facet_mesh = mesh.get_facet_mesh() + + # Verify global data preserved + assert "time" in facet_mesh.global_data + assert "iteration" in facet_mesh.global_data + assert torch.equal( + facet_mesh.global_data["time"], torch.tensor(42.0, device=device) + ) + assert torch.equal( + facet_mesh.global_data["iteration"], torch.tensor(100, device=device) + ) + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [(2, 2), (3, 2), (3, 3)], + ) + def test_data_inheritance_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Test point data and multidimensional cell data inheritance across dimensions.""" + torch.manual_seed(42) + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + # Test point data aggregation + point_values = torch.arange(mesh.n_points, dtype=torch.float32, device=device) + mesh.point_data["point_id"] = point_values + + facet_mesh_pt = mesh.get_facet_mesh(data_source="points") + assert "point_id" in facet_mesh_pt.cell_data, ( + "Point data should be aggregated to facet cell_data" + ) + assert_on_device(facet_mesh_pt.cell_data["point_id"], device) + + # Test multidimensional cell data aggregation + velocity = torch.randn(mesh.n_cells, n_spatial_dims, device=device) + mesh.cell_data["velocity"] = velocity + + facet_mesh_cd = mesh.get_facet_mesh( + data_source="cells", + data_aggregation="mean", + ) + + assert "velocity" in facet_mesh_cd.cell_data + assert facet_mesh_cd.cell_data["velocity"].shape == ( + facet_mesh_cd.n_cells, + n_spatial_dims, + ), f"Velocity shape mismatch: {facet_mesh_cd.cell_data['velocity'].shape=}" + assert_on_device(facet_mesh_cd.cell_data["velocity"], device) diff --git a/test/mesh/boundaries/test_facet_extraction_cache_isolation.py b/test/mesh/boundaries/test_facet_extraction_cache_isolation.py new file mode 100644 index 0000000000..d71707fd42 --- /dev/null +++ b/test/mesh/boundaries/test_facet_extraction_cache_isolation.py @@ -0,0 +1,293 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests to ensure facet extraction properly isolates cached properties. + +This test module specifically addresses the bug where cached geometric properties +(like point normals) from parent meshes were incorrectly shared with facet meshes, +leading to invalid cached data for different mesh topologies. +""" + +import pytest +import torch + +from physicsnemo.mesh import Mesh +from physicsnemo.mesh.utilities._cache import get_cached + + +class TestCacheIsolation: + """Test that facet meshes don't inherit cached properties from parent meshes.""" + + def test_point_normals_not_inherited_by_facet_mesh(self): + """Test that point normals from parent mesh don't contaminate facet mesh. + + This is a critical bug fix: point normals are only valid for the specific + cell connectivity they were computed from. When extracting edges from triangles, + the cached normals should not be inherited. + """ + # Create triangle mesh in 3D (codimension-1, normals are valid) + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [1.5, 1.0, 0.0], + ] + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + + mesh = Mesh(points=points, cells=cells) + + # Compute point normals for triangle mesh (caches in point_data["_cache"]["normals"]) + triangle_normals = mesh.point_normals + assert get_cached(mesh.point_data, "normals") is not None + assert mesh.codimension == 1 # Valid for normals + + # Verify normals were correctly computed (should point in +z direction for this mesh) + assert triangle_normals.shape == (4, 3), ( + "Point normals should have shape (n_points, 3)" + ) + assert torch.all(torch.isfinite(triangle_normals)), "Normals should be finite" + # All normals should be unit vectors + norms = torch.norm(triangle_normals, dim=-1) + assert torch.allclose(norms, torch.ones_like(norms), atol=1e-5), ( + "Normals should be unit vectors" + ) + + # Extract edge mesh (codimension-2, normals are NOT valid) + edge_mesh = mesh.get_facet_mesh(manifold_codimension=1) + + # Edge mesh should NOT have cached normals from parent + assert get_cached(edge_mesh.point_data, "normals") is None, ( + "Cached point normals from parent mesh should not be in facet mesh point_data" + ) + + # Attempting to access point_normals on edge mesh should raise ValueError + with pytest.raises(ValueError, match="only defined for codimension-1"): + _ = edge_mesh.point_normals + + def test_user_point_data_is_preserved(self): + """Test that user-defined (non-cached) point data IS preserved in facet mesh.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + + # Add user-defined point data (not starting with "_") + point_data = { + "temperature": torch.tensor([100.0, 200.0, 150.0]), + "velocity": torch.tensor( + [[1.0, 0.0, 0.0], [1.0, 0.5, 0.0], [1.0, 0.25, 0.0]] + ), + } + + mesh = Mesh(points=points, cells=cells, point_data=point_data) + + # Compute some cached properties + _ = mesh.point_normals # Creates cache + + # Extract edge mesh + edge_mesh = mesh.get_facet_mesh(manifold_codimension=1) + + # User data should be preserved + assert "temperature" in edge_mesh.point_data + assert "velocity" in edge_mesh.point_data + assert torch.equal( + edge_mesh.point_data["temperature"], point_data["temperature"] + ) + assert torch.equal(edge_mesh.point_data["velocity"], point_data["velocity"]) + + # Cached properties should NOT be preserved + assert get_cached(edge_mesh.point_data, "normals") is None + + def test_multiple_cache_types_filtered(self): + """Test that all cached properties (under "_cache") are filtered.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + + mesh = Mesh(points=points, cells=cells) + + # Manually add various cached properties to point_data + from physicsnemo.mesh.utilities._cache import set_cached + + set_cached(mesh.point_data, "normals", torch.ones(3, 3)) + set_cached(mesh.point_data, "custom_cache", torch.zeros(3)) + set_cached(mesh.point_data, "another_property", torch.tensor([1.0, 2.0, 3.0])) + + # Add non-cached property + mesh.point_data["user_field"] = torch.tensor([10.0, 20.0, 30.0]) + + # Extract facet mesh + edge_mesh = mesh.get_facet_mesh(manifold_codimension=1) + + # All cached properties should be filtered + assert get_cached(edge_mesh.point_data, "normals") is None + assert get_cached(edge_mesh.point_data, "custom_cache") is None + assert get_cached(edge_mesh.point_data, "another_property") is None + + # User field should be preserved + assert "user_field" in edge_mesh.point_data + assert torch.equal( + edge_mesh.point_data["user_field"], mesh.point_data["user_field"] + ) + + @pytest.mark.parametrize("manifold_codimension", [1, 2]) + def test_cache_isolation_various_codimensions(self, manifold_codimension): + """Test cache isolation works for different codimension extractions.""" + # Triangle mesh + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + + mesh = Mesh(points=points, cells=cells) + + # Add cached property + _ = mesh.point_normals # Creates cache + assert get_cached(mesh.point_data, "normals") is not None + + # Extract facet mesh + facet_mesh = mesh.get_facet_mesh(manifold_codimension=manifold_codimension) + + # Cached properties should always be filtered + assert get_cached(facet_mesh.point_data, "normals") is None + + def test_empty_point_data(self): + """Test that facet extraction works with empty point_data.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + + mesh = Mesh(points=points, cells=cells) + + # Don't add any data or compute any properties + assert len(mesh.point_data.keys()) == 0 + + # Extract facet mesh + edge_mesh = mesh.get_facet_mesh(manifold_codimension=1) + + # Should work fine with empty point_data + assert len(edge_mesh.point_data.keys()) == 0 + + def test_cell_data_not_affected(self): + """Test that cell_data aggregation still works correctly. + + Cell data has always been properly aggregated (not shared), so this + test ensures our fix doesn't accidentally break that. + """ + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + + cell_data = {"pressure": torch.tensor([100.0])} + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + + # Extract edge mesh + edge_mesh = mesh.get_facet_mesh( + manifold_codimension=1, data_source="cells", data_aggregation="mean" + ) + + # Cell data should be properly aggregated (not shared) + assert "pressure" in edge_mesh.cell_data + # Each of the 3 edges should have the same pressure value + assert edge_mesh.cell_data["pressure"].shape == (3,) + assert torch.allclose( + edge_mesh.cell_data["pressure"], torch.tensor([100.0, 100.0, 100.0]) + ) + + +class TestCacheConsistency: + """Test that cached properties remain consistent across operations.""" + + def test_parent_cache_unchanged_after_facet_extraction(self): + """Test that extracting facets doesn't modify parent mesh caches.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + + mesh = Mesh(points=points, cells=cells) + + # Compute and cache point normals + original_normals = mesh.point_normals.clone() + assert get_cached(mesh.point_data, "normals") is not None + + # Extract facet mesh + _ = mesh.get_facet_mesh(manifold_codimension=1) + + # Parent mesh caches should be unchanged + assert get_cached(mesh.point_data, "normals") is not None + assert torch.equal(get_cached(mesh.point_data, "normals"), original_normals) + + def test_independent_caches_after_extraction(self): + """Test that parent and facet meshes maintain independent caches.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [1.5, 1.0, 0.0], + ] + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + + parent_mesh = Mesh(points=points, cells=cells) + + # Compute normals on parent (codimension-1, valid) + parent_normals = parent_mesh.point_normals + + # Extract edge mesh (codimension-2) + edge_mesh = parent_mesh.get_facet_mesh(manifold_codimension=1) + + # Add some user data to edge mesh point_data + edge_mesh.point_data["custom_field"] = torch.ones(4) + + # Parent mesh should not have the custom field + assert "custom_field" not in parent_mesh.point_data + + # Parent mesh should still have its cached normals + assert get_cached(parent_mesh.point_data, "normals") is not None + assert torch.equal( + get_cached(parent_mesh.point_data, "normals"), parent_normals + ) diff --git a/test/mesh/boundaries/test_topology.py b/test/mesh/boundaries/test_topology.py new file mode 100644 index 0000000000..85e7661118 --- /dev/null +++ b/test/mesh/boundaries/test_topology.py @@ -0,0 +1,636 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for topology validation (watertight and manifold checking). + +Tests validate that topology checking functions correctly identify watertight +meshes and topological manifolds. +""" + +import pytest +import torch + +from physicsnemo.mesh.mesh import Mesh + + +class TestWatertight2D: + """Test watertight checking for 2D meshes.""" + + def test_single_triangle_not_watertight(self, device): + """Single triangle is not watertight (has boundary edges).""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert not mesh.is_watertight() + + def test_two_triangles_not_watertight(self, device): + """Two triangles with shared edge are not watertight (have boundary edges).""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert not mesh.is_watertight() + + def test_closed_quad_watertight(self, device): + """Closed quad (4 triangles meeting at center) is watertight in 2D sense.""" + ### In 2D, "watertight" means all edges are shared by exactly 2 triangles + ### This creates a closed shape with no boundary + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0], [0.5, 0.5]], + device=device, + ) + cells = torch.tensor( + [ + [0, 1, 4], + [1, 2, 4], + [2, 3, 4], + [3, 0, 4], + ], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + ### This should NOT be watertight because outer edges are only shared by 1 triangle + assert not mesh.is_watertight() + + def test_empty_mesh_watertight(self, device): + """Empty mesh is considered watertight.""" + points = torch.empty((0, 2), device=device) + cells = torch.empty((0, 3), device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.is_watertight() + + +class TestWatertight3D: + """Test watertight checking for 3D meshes.""" + + def test_single_tet_not_watertight(self, device): + """Single tetrahedron is not watertight (has boundary faces).""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ], + device=device, + ) + cells = torch.tensor([[0, 1, 2, 3]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert not mesh.is_watertight() + + def test_two_tets_not_watertight(self, device): + """Two tets sharing a face are not watertight (have boundary faces).""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [0.0, 0.0, -1.0], + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [0, 1, 2, 4]], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + assert not mesh.is_watertight() + + def test_filled_volume_not_watertight(self, device): + """A filled volume mesh is not watertight (has exterior boundary). + + Note: For codimension-0 meshes (3D in 3D), being watertight means every + triangular face is shared by exactly 2 tets. This is topologically impossible + for finite meshes in Euclidean 3D space - any solid volume must have an + exterior boundary. A truly watertight 3D mesh would require periodic boundaries + or non-Euclidean topology (like a 3-torus embedded in 4D). + """ + from physicsnemo.mesh.primitives.procedural import lumpy_ball + + ### Create a filled volume (tetrahedral mesh) + mesh = lumpy_ball.load(device=device) + + ### Even though this is a filled volume, it's NOT watertight + # The exterior faces are boundary faces (appear only once) + # Only the interior faces are shared by 2 tets + assert not mesh.is_watertight() + + ### Verify it has boundary faces + from physicsnemo.mesh.boundaries import extract_candidate_facets + + candidate_facets, _ = extract_candidate_facets( + mesh.cells, manifold_codimension=1 + ) + _, counts = torch.unique(candidate_facets, dim=0, return_counts=True) + + # Should have some boundary faces (appearing once) + n_boundary_faces = (counts == 1).sum().item() + assert n_boundary_faces > 0, "Expected some boundary faces on volume exterior" + + +class TestWatertight1D: + """Test watertight checking for 1D meshes.""" + + def test_single_edge_not_watertight(self, device): + """Single edge is not watertight.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], device=device) + cells = torch.tensor([[0, 1]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert not mesh.is_watertight() + + def test_closed_loop_watertight(self, device): + """Closed loop of edges is watertight.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]], + device=device, + ) + cells = torch.tensor( + [[0, 1], [1, 2], [2, 3], [3, 0]], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + assert mesh.is_watertight() + + +class TestManifold2D: + """Test manifold checking for 2D meshes.""" + + def test_single_triangle_manifold(self, device): + """Single triangle is a valid manifold with boundary.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.is_manifold() + + def test_two_triangles_manifold(self, device): + """Two triangles sharing an edge form a valid manifold.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.is_manifold() + + def test_non_manifold_edge(self, device): + """Three triangles sharing an edge create non-manifold configuration.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [0.5, -1.0]], + device=device, + ) + ### All three triangles share edge [0, 1] + cells = torch.tensor( + [[0, 1, 2], [1, 0, 3], [0, 1, 3]], # Three different triangles on same edge + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + assert not mesh.is_manifold() + + def test_manifold_check_levels(self, device): + """Test different manifold check levels.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### All check levels should pass for simple triangle + assert mesh.is_manifold(check_level="facets") + assert mesh.is_manifold(check_level="edges") + assert mesh.is_manifold(check_level="full") + + +class TestManifold3D: + """Test manifold checking for 3D meshes.""" + + def test_single_tet_manifold(self, device): + """Single tetrahedron is a valid manifold with boundary.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ], + device=device, + ) + cells = torch.tensor([[0, 1, 2, 3]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.is_manifold() + + def test_two_tets_manifold(self, device): + """Two tets sharing a face form a valid manifold.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [0.0, 0.0, -1.0], + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [0, 1, 2, 4]], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + assert mesh.is_manifold() + + def test_non_manifold_face(self, device): + """Three tets sharing a face create non-manifold configuration.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [0.0, 0.0, -1.0], + [0.5, 0.5, 0.5], # Extra point + ], + device=device, + ) + ### Three tets share face [0, 1, 2] + cells = torch.tensor( + [ + [0, 1, 2, 3], + [0, 1, 2, 4], + [0, 1, 2, 5], # Third tet sharing same face + ], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + assert not mesh.is_manifold() + + def test_pinch_point_non_manifold_vertex(self, device): + """Two tets sharing only a single vertex create a non-manifold pinch point. + + Vertex 0 is shared by both tets, but they share no face containing vertex 0. + The link of vertex 0 consists of two disconnected triangles: {1,2,3} and + {4,5,6}. This passes facet and edge checks but fails the vertex check. + """ + points = torch.tensor( + [ + [0.0, 0.0, 0.0], # vertex 0: pinch point + [1.0, 0.0, 0.0], # tet 1 only + [0.0, 1.0, 0.0], # tet 1 only + [0.0, 0.0, 1.0], # tet 1 only + [-1.0, 0.0, 0.0], # tet 2 only + [0.0, -1.0, 0.0], # tet 2 only + [0.0, 0.0, -1.0], # tet 2 only + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [0, 4, 5, 6]], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + ### Facet and edge checks pass (no shared faces or edges between the two tets) + assert mesh.is_manifold(check_level="facets") is True + assert mesh.is_manifold(check_level="edges") is True + + ### Full check catches the pinch point + assert mesh.is_manifold(check_level="full") is False + + def test_shared_edge_but_no_shared_face_non_manifold(self, device): + """Two tets sharing a vertex and an edge but no face containing that vertex. + + Tets share edge {0,1}, but at vertex 0 the link faces {1,2,3} and {1,4,5} + share only vertex 1 (not an edge), so vertex 0's link is disconnected. + """ + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [0.0, -1.0, 0.0], + [0.0, 0.0, -1.0], + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [0, 1, 4, 5]], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + ### Vertex 0's link has two triangles sharing only a vertex, not an edge + assert mesh.is_manifold(check_level="full") is False + + def test_three_tets_ring_manifold(self, device): + """Three tets forming a ring around a shared edge are manifold. + + Tets share edge {0,1}. At vertex 0, the link faces all share edges + through vertex 1, forming a connected fan. + """ + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [0.0, -1.0, 0.0], + ], + device=device, + ) + ### Three tets: each pair shares a face containing both v0 and v1 + cells = torch.tensor( + [ + [0, 1, 2, 3], + [0, 1, 3, 4], + [0, 1, 4, 2], + ], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + ### Link of vertex 0: {1,2,3}, {1,3,4}, {1,4,2} + ### These share edges {1,3}, {1,4}, {1,2} respectively → connected + assert mesh.is_manifold(check_level="full") is True + + +class TestManifold1D: + """Test manifold checking for 1D meshes.""" + + def test_single_edge_manifold(self, device): + """Single edge is a valid manifold.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], device=device) + cells = torch.tensor([[0, 1]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.is_manifold() + + def test_chain_of_edges_manifold(self, device): + """Chain of edges is a valid manifold.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]], + device=device, + ) + cells = torch.tensor([[0, 1], [1, 2]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.is_manifold() + + def test_non_manifold_vertex(self, device): + """Three edges meeting at a vertex create non-manifold configuration.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [-1.0, 0.0]], + device=device, + ) + ### Three edges share vertex 0 + cells = torch.tensor( + [[0, 1], [0, 2], [0, 3]], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + ### For 1D meshes, a vertex with 3 incident edges is non-manifold + ### (locally doesn't look like R^1) + ### Each vertex should have at most 2 incident edges + assert not mesh.is_manifold() + + +class TestEmptyMesh: + """Test topology checks on empty mesh.""" + + def test_empty_mesh_watertight_and_manifold(self, device): + """Empty mesh is considered both watertight and manifold.""" + points = torch.empty((0, 3), device=device) + cells = torch.empty((0, 4), device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.is_watertight() + assert mesh.is_manifold() + + +class TestWatertightFaceDeletion: + """Test that deleting faces from a watertight mesh makes it non-watertight.""" + + def test_lumpy_sphere_is_watertight(self, device): + """Verify that lumpy_sphere is watertight before any modifications.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + mesh = lumpy_sphere.load(subdivisions=2, device=device) + + assert mesh.is_watertight(), ( + "lumpy_sphere should be watertight (closed surface with no boundary)" + ) + + @pytest.mark.parametrize( + "n_faces_to_delete,description", + [ + (1, "single face deleted"), + (3, "three faces deleted"), + ("half", "half of all faces deleted"), + ], + ) + def test_deleted_faces_not_watertight(self, device, n_faces_to_delete, description): + """Deleting faces from lumpy_sphere should make it non-watertight. + + Args: + device: Test device (CPU or CUDA) + n_faces_to_delete: Number of faces to delete, or "half" for half of all faces + description: Human-readable description for test output + """ + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + mesh = lumpy_sphere.load(subdivisions=2, device=device) + n_cells = mesh.n_cells + + ### Determine how many faces to delete + if n_faces_to_delete == "half": + num_to_delete = n_cells // 2 + else: + num_to_delete = n_faces_to_delete + + ### Verify we have enough faces to delete + assert num_to_delete <= n_cells, ( + f"Cannot delete {num_to_delete} faces from mesh with {n_cells} cells" + ) + + ### Create broken mesh by keeping only cells after the deleted ones + # Construct directly to avoid TensorDict indexing issues + broken_mesh = Mesh( + points=mesh.points, + cells=mesh.cells[num_to_delete:], + ) + + ### Verify the mesh now has fewer cells + assert broken_mesh.n_cells == n_cells - num_to_delete + + ### The mesh should no longer be watertight (has boundary edges) + assert not broken_mesh.is_watertight(), ( + f"Mesh with {description} should NOT be watertight " + f"(deleted {num_to_delete} of {n_cells} faces)" + ) + + +############################################################################### +# Regression: _check_edges_manifold for 3D tetrahedral meshes +############################################################################### + + +class TestEdgeManifoldCheck3DRegression: + """Regression tests for 3D edge-link connectivity checking. + + The original ``_check_edges_manifold`` for 3D meshes only checked that + each edge appeared in at least one cell (trivially true), so it always + returned True. The fix implements proper face-link connectivity around + each edge via union-find. + """ + + def test_two_tets_sharing_only_edge_is_non_manifold(self, device): + """Two tets sharing only an edge (no shared face) are non-manifold. + + T1 = (0,1,2,3), T2 = (0,1,4,5). All 8 triangular faces appear + exactly once (passes facet check). But the face-link around edge + (0,1) is disconnected: {(0,1,2),(0,1,3)} and {(0,1,4),(0,1,5)} form + two components. The old implementation returned True; the fix + correctly returns False. + """ + from physicsnemo.mesh.boundaries._topology import ( + _check_edges_manifold, + _check_facets_manifold, + ) + + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [0.5, 0.5, 1.0], + [0.5, -1.0, 0.0], + [0.5, -0.5, -1.0], + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [0, 1, 4, 5]], device=device, dtype=torch.int64 + ) + mesh = Mesh(points=points, cells=cells) + + assert _check_facets_manifold(mesh), "Facets should pass" + assert not _check_edges_manifold(mesh), ( + "Edges check should fail for two tets sharing only an edge" + ) + + def test_two_tets_sharing_face_is_manifold(self, device): + """Two tets sharing a complete face are manifold.""" + from physicsnemo.mesh.boundaries._topology import _check_edges_manifold + + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [0.5, 0.5, 1.0], + [0.5, 0.5, -1.0], + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [0, 1, 2, 4]], device=device, dtype=torch.int64 + ) + mesh = Mesh(points=points, cells=cells) + + assert _check_edges_manifold(mesh), ( + "Two tets sharing face (0,1,2) should pass edge check" + ) + + def test_tet_cycle_around_edge_is_manifold(self, device): + """Four tets forming a closed cycle around edge (0,1) are manifold.""" + from physicsnemo.mesh.boundaries._topology import _check_edges_manifold + + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [0.5, 0.0, 1.0], + [0.5, -1.0, 0.0], + [0.5, 0.0, -1.0], + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [0, 1, 3, 4], [0, 1, 4, 5], [0, 1, 5, 2]], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + assert _check_edges_manifold(mesh), ( + "4-tet cycle around an edge should pass edge check" + ) + + def test_is_manifold_edges_level_catches_nonmanifold(self, device): + """is_manifold(check_level='edges') returns False for the non-manifold case.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [0.5, 0.5, 1.0], + [0.5, -1.0, 0.0], + [0.5, -0.5, -1.0], + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [0, 1, 4, 5]], device=device, dtype=torch.int64 + ) + mesh = Mesh(points=points, cells=cells) + + assert mesh.is_manifold(check_level="facets") is True + assert mesh.is_manifold(check_level="edges") is False + assert mesh.is_manifold(check_level="full") is False diff --git a/test/mesh/calculus/test_calculus.py b/test/mesh/calculus/test_calculus.py new file mode 100644 index 0000000000..ef083a2e54 --- /dev/null +++ b/test/mesh/calculus/test_calculus.py @@ -0,0 +1,2544 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Comprehensive tests for discrete calculus operators. + +Tests gradient, divergence, curl, and Laplacian operators using analytical +fields with known derivatives. Verifies fundamental calculus identities, +DEC operators, edge cases, and numerical properties. + +This module consolidates tests from: +- Core analytical field tests (gradient, divergence, curl, Laplacian) +- DEC operators (exterior derivative, Hodge star, sharp/flat) +- Laplacian-specific tests (tensor fields, spherical harmonics, edge cases) +- Code coverage tests (error handling, edge conditions) +""" + +import pytest +import torch + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.primitives import procedural + +############################################################################### +# Helper Functions - Analytical Field Generators +############################################################################### + + +def make_constant_field(value=5.0): + """Constant scalar field.""" + return lambda r: torch.full((r.shape[0],), value, dtype=r.dtype, device=r.device) + + +def make_linear_field(coeffs): + """Linear field: φ = a·r where a = coeffs.""" + coeffs_tensor = torch.tensor(coeffs) + return lambda r: (r * coeffs_tensor.to(r.device)).sum(dim=-1) + + +def make_quadratic_field(): + """Quadratic field: φ = ||r||² = x² + y² + z².""" + return lambda r: (r**2).sum(dim=-1) + + +def make_polynomial_field_3d(): + """Polynomial: φ = x²y + yz² - 2xz.""" + + def phi(r): + x, y, z = r[:, 0], r[:, 1], r[:, 2] + return x**2 * y + y * z**2 - 2 * x * z + + return phi + + +def make_uniform_divergence_field_3d(): + """Vector field v = [x, y, z], div(v) = 3.""" + return lambda r: r.clone() + + +def make_scaled_divergence_field_3d(scale_factors): + """Vector field v = [a×x, b×y, c×z], div(v) = a+b+c.""" + a, b, c = scale_factors + + def v(r): + result = r.clone() + result[:, 0] *= a + result[:, 1] *= b + result[:, 2] *= c + return result + + return v + + +def make_zero_divergence_rotation_3d(): + """Vector field v = [-y, x, 0], div(v) = 0.""" + + def v(r): + result = torch.zeros_like(r) + result[:, 0] = -r[:, 1] # -y + result[:, 1] = r[:, 0] # x + result[:, 2] = 0.0 + return result + + return v + + +def make_zero_divergence_field_3d(): + """Vector field v = [yz, xz, xy], div(v) = 0.""" + + def v(r): + x, y, z = r[:, 0], r[:, 1], r[:, 2] + result = torch.zeros_like(r) + result[:, 0] = y * z + result[:, 1] = x * z + result[:, 2] = x * y + return result + + return v + + +def make_radial_field(): + """Radial field v = r, div(v) = n (spatial dims).""" + return lambda r: r.clone() + + +def make_uniform_curl_field_3d(): + """Vector field v = [-y, x, 0], curl(v) = [0, 0, 2].""" + return make_zero_divergence_rotation_3d() # Same field + + +def make_zero_curl_field_3d(): + """Conservative field v = [x, y, z] = ∇(½||r||²), curl(v) = 0.""" + return lambda r: r.clone() + + +def make_helical_field_3d(): + """Helical field v = [-y, x, z], curl(v) = [0, 0, 2].""" + + def v(r): + result = torch.zeros_like(r) + result[:, 0] = -r[:, 1] + result[:, 1] = r[:, 0] + result[:, 2] = r[:, 2] + return result + + return v + + +def make_polynomial_curl_field_3d(): + """v = [yz, -xz, 0], curl(v) = [-x, -y, -2z].""" + + def v(r): + x, y, z = r[:, 0], r[:, 1], r[:, 2] + result = torch.zeros_like(r) + result[:, 0] = y * z + result[:, 1] = -x * z + result[:, 2] = 0.0 + return result + + return v + + +def make_harmonic_field_2d(): + """Harmonic field φ = x² - y² in 2D, Δφ = 0.""" + + def phi(r): + if r.shape[-1] >= 2: + return r[:, 0] ** 2 - r[:, 1] ** 2 + else: + raise ValueError("Need at least 2D for this field") + + return phi + + +def make_harmonic_field_xy(): + """Harmonic field φ = xy, Δφ = 0.""" + + def phi(r): + if r.shape[-1] >= 2: + return r[:, 0] * r[:, 1] + else: + raise ValueError("Need at least 2D") + + return phi + + +############################################################################### +# Fixtures +############################################################################### + + +@pytest.fixture +def simple_triangle_mesh_2d(): + """Simple 2D triangle mesh for basic tests.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + [0.5, 0.5], + ] + ) + cells = torch.tensor( + [ + [0, 1, 4], + [0, 2, 4], + [1, 3, 4], + [2, 3, 4], + ] + ) + return Mesh(points=points, cells=cells) + + +@pytest.fixture +def simple_tet_mesh(): + """Simple tetrahedral mesh for testing.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [0.5, 0.5, 0.5], + ], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2, 4], [0, 1, 3, 4], [0, 2, 3, 4], [1, 2, 3, 4]]) + return Mesh(points=points, cells=cells) + + +############################################################################### +# Core Analytical Field Tests +############################################################################### + + +class TestGradient: + """Test gradient computation.""" + + def test_gradient_of_constant_is_zero(self): + """∇(const) = 0.""" + mesh = procedural.lumpy_ball.load() + + # Create constant field + const_value = 5.0 + mesh.point_data["const"] = torch.full( + (mesh.n_points,), const_value, dtype=torch.float32 + ) + + # Compute gradient + mesh_grad = mesh.compute_point_derivatives(keys="const", method="lsq") + + gradient = mesh_grad.point_data["const_gradient"] + + # Should be zero everywhere + assert torch.allclose(gradient, torch.zeros_like(gradient), atol=1e-6) + + def test_gradient_of_linear_is_exact(self): + """∇(a·r) = a exactly for linear fields.""" + mesh = procedural.lumpy_ball.load() + + # Linear field: φ = 2x + 3y - z + coeffs = torch.tensor([2.0, 3.0, -1.0]) + phi = (mesh.points * coeffs).sum(dim=-1) + + mesh.point_data["linear"] = phi + + # Compute gradient + mesh_grad = mesh.compute_point_derivatives(keys="linear", method="lsq") + gradient = mesh_grad.point_data["linear_gradient"] + + # Should equal coeffs everywhere + expected = coeffs.unsqueeze(0).expand(mesh.n_points, -1) + + # Linear functions should be reconstructed exactly by LSQ + assert torch.allclose(gradient, expected, atol=1e-4) + + @pytest.mark.parametrize("method", ["lsq"]) + def test_quadratic_hessian_uniformity(self, method): + """φ = ||r||² has uniform Laplacian (Hessian trace is constant). + + This tests the KEY property: Laplacian of ||r||² should be spatially uniform. + The absolute value may have systematic bias in first-order methods, but + the spatial variation (std dev) should be small relative to mean. + """ + mesh = procedural.lumpy_ball.load() + + # Quadratic field + phi = (mesh.points**2).sum(dim=-1) + mesh.point_data["quadratic"] = phi + + # Compute Laplacian via div(grad(φ)) + mesh_grad = mesh.compute_point_derivatives(keys="quadratic", method=method) + grad = mesh_grad.point_data["quadratic_gradient"] + + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_lsq + + laplacian = compute_divergence_points_lsq(mesh_grad, grad) + + # Key test: Laplacian should be UNIFORM (low std dev relative to mean) + mean_lap = laplacian.mean() + std_lap = laplacian.std() + + # Coefficient of variation should be small + cv = std_lap / mean_lap.abs().clamp(min=1e-10) + + # Two nested first-order LSQ steps (grad then div) yield O(1) error + # in the Laplacian that doesn't vanish with refinement: the gradient + # bias epsilon ~ O(h) varies on the mesh scale, so div(epsilon) ~ O(1). + # On lumpy_ball (noise_amplitude=0.5), CV ~0.36 is typical. + assert cv < 0.5, ( + f"Laplacian not uniform: CV={cv:.3f}, mean={mean_lap:.3f}, std={std_lap:.3f}" + ) + + # Laplacian should be positive (correct sign) + assert mean_lap > 0, "Laplacian should be positive for convex function" + + +class TestDivergence: + """Test divergence computation with analytical fields.""" + + def test_uniform_divergence_3d(self): + """v = [x,y,z], div(v) = 3 (constant everywhere).""" + mesh = procedural.lumpy_ball.load() + + # Vector field v = r + v = mesh.points.clone() + + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_lsq + + divergence = compute_divergence_points_lsq(mesh, v) + + # LSQ should exactly recover divergence of linear field + expected = 3.0 + assert torch.allclose( + divergence, torch.full_like(divergence, expected), atol=1e-4 + ), f"Divergence mean={divergence.mean():.6f}, expected={expected}" + + def test_scaled_divergence_field(self): + """v = [2x, 3y, 4z], div(v) = 2+3+4 = 9.""" + mesh = procedural.lumpy_ball.load() + + v = mesh.points.clone() + v[:, 0] *= 2.0 + v[:, 1] *= 3.0 + v[:, 2] *= 4.0 + + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_lsq + + divergence = compute_divergence_points_lsq(mesh, v) + + # Should be exactly 9 + assert torch.allclose(divergence, torch.full_like(divergence, 9.0), atol=1e-4) + + def test_zero_divergence_rotation(self): + """v = [-y,x,0], div(v) = 0 (solenoidal field).""" + mesh = procedural.lumpy_ball.load() + + # Rotation field + v = torch.zeros_like(mesh.points) + v[:, 0] = -mesh.points[:, 1] # -y + v[:, 1] = mesh.points[:, 0] # x + v[:, 2] = 0.0 + + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_lsq + + divergence = compute_divergence_points_lsq(mesh, v) + + # Should be exactly zero (linear field components) + assert torch.allclose(divergence, torch.zeros_like(divergence), atol=1e-6) + + def test_zero_divergence_field_xyz(self): + """v = [yz, xz, xy], div(v) = 0.""" + mesh = procedural.lumpy_ball.load() + + x, y, z = mesh.points[:, 0], mesh.points[:, 1], mesh.points[:, 2] + v = torch.stack([y * z, x * z, x * y], dim=-1) + + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_lsq + + divergence = compute_divergence_points_lsq(mesh, v) + + # ∂(yz)/∂x + ∂(xz)/∂y + ∂(xy)/∂z = 0 + 0 + 0 = 0 + # Quadratic components have O(h) LSQ error; lumpy_ball is moderate resolution. + assert divergence.abs().mean() < 0.15 + + +class TestCurl: + """Test curl computation with analytical fields.""" + + def test_uniform_curl_3d(self): + """v = [-y,x,0], curl(v) = [0,0,2] (uniform curl).""" + mesh = procedural.lumpy_ball.load() + + # Rotation field + v = torch.zeros_like(mesh.points) + v[:, 0] = -mesh.points[:, 1] + v[:, 1] = mesh.points[:, 0] + v[:, 2] = 0.0 + + from physicsnemo.mesh.calculus.curl import compute_curl_points_lsq + + curl_v = compute_curl_points_lsq(mesh, v) + + # LSQ should exactly recover curl of linear field + expected = torch.zeros_like(curl_v) + expected[:, 2] = 2.0 + + assert torch.allclose(curl_v, expected, atol=1e-4) + + def test_zero_curl_conservative_field(self): + """v = r = ∇(½||r||²), curl(v) = 0 (irrotational).""" + mesh = procedural.lumpy_ball.load() + + # Conservative field (gradient of potential) + v = mesh.points.clone() + + from physicsnemo.mesh.calculus.curl import compute_curl_points_lsq + + curl_v = compute_curl_points_lsq(mesh, v) + + # Should be exactly zero (curl of gradient of linear function) + assert torch.allclose(curl_v, torch.zeros_like(curl_v), atol=1e-6) + + def test_helical_field(self): + """v = [-y, x, z], curl(v) = [0, 0, 2].""" + mesh = procedural.lumpy_ball.load() + + v = torch.zeros_like(mesh.points) + v[:, 0] = -mesh.points[:, 1] + v[:, 1] = mesh.points[:, 0] + v[:, 2] = mesh.points[:, 2] + + from physicsnemo.mesh.calculus.curl import compute_curl_points_lsq + + curl_v = compute_curl_points_lsq(mesh, v) + + expected = torch.zeros_like(curl_v) + expected[:, 2] = 2.0 + + assert torch.allclose(curl_v, expected, atol=1e-4) + + def test_curl_multiple_axes(self): + """Test curl with rotation about different axes (all linear fields).""" + mesh = procedural.lumpy_ball.load() + + # Test 1: Rotation about z-axis: v = [-y, x, 0], curl = [0, 0, 2] + v_z = torch.zeros_like(mesh.points) + v_z[:, 0] = -mesh.points[:, 1] + v_z[:, 1] = mesh.points[:, 0] + + # Test 2: Rotation about x-axis: v = [0, -z, y], curl = [2, 0, 0] + v_x = torch.zeros_like(mesh.points) + v_x[:, 1] = -mesh.points[:, 2] + v_x[:, 2] = mesh.points[:, 1] + + # Test 3: Rotation about y-axis: v = [z, 0, -x], curl = [0, 2, 0] + v_y = torch.zeros_like(mesh.points) + v_y[:, 0] = mesh.points[:, 2] + v_y[:, 2] = -mesh.points[:, 0] + + from physicsnemo.mesh.calculus.curl import compute_curl_points_lsq + + curl_z = compute_curl_points_lsq(mesh, v_z) + curl_x = compute_curl_points_lsq(mesh, v_x) + curl_y = compute_curl_points_lsq(mesh, v_y) + + # All should be exact (linear fields) + expected_z = torch.zeros_like(curl_z) + expected_z[:, 2] = 2.0 + + expected_x = torch.zeros_like(curl_x) + expected_x[:, 0] = 2.0 + + expected_y = torch.zeros_like(curl_y) + expected_y[:, 1] = 2.0 + + assert torch.allclose(curl_z, expected_z, atol=1e-4), "Curl about z-axis failed" + assert torch.allclose(curl_x, expected_x, atol=1e-4), "Curl about x-axis failed" + assert torch.allclose(curl_y, expected_y, atol=1e-4), "Curl about y-axis failed" + + +class TestLaplacian: + """Test Laplace-Beltrami operator.""" + + def test_harmonic_function_laplacian_zero(self, simple_triangle_mesh_2d): + """Harmonic function φ = x² - y² should have Δφ ≈ 0 in 2D.""" + mesh = simple_triangle_mesh_2d + + # Harmonic function in 2D + phi = mesh.points[:, 0] ** 2 - mesh.points[:, 1] ** 2 + mesh.point_data["harmonic"] = phi + + # Compute Laplacian + mesh_grad = mesh.compute_point_derivatives(keys="harmonic", method="lsq") + grad = mesh_grad.point_data["harmonic_gradient"] + + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_lsq + + laplacian = compute_divergence_points_lsq(mesh_grad, grad) + + # For a true harmonic function, Laplacian = 0 + # Interior points should have |Δφ| << |φ| + # Coarse mesh (5 points, 4 triangles); large discretization error expected. + assert laplacian.abs().mean() < 0.3, ( + f"Harmonic function Laplacian should be ~0, got mean={laplacian.mean():.4f}" + ) + + def test_dec_laplacian_linear_function_zero(self): + """DEC Laplacian of linear function should be exactly zero.""" + # Simple 2D mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [1.0, 1.0], + [0.0, 1.0], + [0.5, 0.5], + ], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4]]) + + mesh = Mesh(points=points, cells=cells) + + # Linear function + phi = 2 * points[:, 0] + 3 * points[:, 1] + + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + lap = compute_laplacian_points_dec(mesh, phi) + + # Interior point (index 4) should have Laplacian = 0 + assert torch.abs(lap[4]) < 1e-6, ( + f"Laplacian of linear function at interior: {lap[4]:.6f}" + ) + + def test_dec_laplacian_quadratic_reasonable(self): + r"""DEC Laplacian of phi=z^2 gives correct surface Laplacian. + + For the Laplace-Beltrami operator on a unit sphere: + \Delta_S(z^2) = 2 - 6z^2 + + This is the SURFACE Laplacian (intrinsic to the manifold), not the + ambient 3D Laplacian. The result varies by position: negative near + poles (|z| ~ 1), positive near equator (z ~ 0). + + Derivation: z^2 = cos^2(theta) can be decomposed into spherical harmonics + Y_0^0 and Y_2^0. The eigenvalue for l=2 is -l(l+1) = -6, giving the + position-dependent result. + """ + from physicsnemo.mesh.primitives.surfaces import sphere_uv + + # Use higher resolution for better accuracy + mesh = sphere_uv.load(radius=1.0, theta_resolution=40, phi_resolution=40) + + # Test function: phi = z^2 + phi = mesh.points[:, 2] ** 2 + + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + lap = compute_laplacian_points_dec(mesh, phi) + + # Analytical surface Laplacian: Delta_S(z^2) = 2 - 6z^2 + z = mesh.points[:, 2] + expected = 2 - 6 * z**2 + + # Verify correlation (should be ~1.0) + correlation = torch.corrcoef(torch.stack([lap, expected]))[0, 1] + assert correlation > 0.999, f"Correlation with analytical: {correlation:.6f}" + + # Verify mean absolute error is small + mean_error = (lap - expected).abs().mean() + assert mean_error < 0.05, f"Mean error: {mean_error:.4f}" + + +class TestManifolds: + """Test calculus on manifolds (surfaces in higher dimensions).""" + + def test_intrinsic_gradient_orthogonal_to_normal(self): + """Intrinsic gradient should be perpendicular to surface normal.""" + mesh = procedural.lumpy_sphere.load(radius=1.0, subdivisions=3) + + # Any scalar field + phi = (mesh.points**2).sum(dim=-1) + mesh.point_data["test_field"] = phi + + # Compute intrinsic and extrinsic gradients + mesh_grad = mesh.compute_point_derivatives( + keys="test_field", method="lsq", gradient_type="both" + ) + + grad_intrinsic = mesh_grad.point_data["test_field_gradient_intrinsic"] + grad_extrinsic = mesh_grad.point_data["test_field_gradient_extrinsic"] + + # Get normals at points (use mesh's area-weighted normals) + point_normals = mesh.point_normals + + # Intrinsic gradient should be orthogonal to normal + dot_products_intrinsic = (grad_intrinsic * point_normals).sum(dim=-1) + + assert dot_products_intrinsic.abs().max() < 1e-2, ( + f"Intrinsic gradient not orthogonal to normal: max dot product = {dot_products_intrinsic.abs().max():.6f}" + ) + + # Extrinsic gradient should be finite and have correct shape + assert torch.all(torch.isfinite(grad_extrinsic)) + assert grad_extrinsic.shape == grad_intrinsic.shape + + +class TestCalculusIdentities: + """Test fundamental calculus identities.""" + + def test_curl_of_gradient_is_zero(self): + """curl(∇φ) = 0 for any scalar field.""" + mesh = procedural.lumpy_ball.load() + + # Should be zero (curl of conservative field) + # For LINEAR potential, curl of gradient should be near-exact zero + # Use phi = x + y for exact test (quadratic fields have O(h) discretization error) + from physicsnemo.mesh.calculus.curl import compute_curl_points_lsq + + phi_linear = mesh.points[:, 0] + mesh.points[:, 1] + mesh.point_data["phi_linear"] = phi_linear + mesh_grad_linear = mesh.compute_point_derivatives( + keys="phi_linear", method="lsq" + ) + grad_linear = mesh_grad_linear.point_data["phi_linear_gradient"] + curl_of_grad_linear = compute_curl_points_lsq(mesh_grad_linear, grad_linear) + + assert torch.allclose( + curl_of_grad_linear, torch.zeros_like(curl_of_grad_linear), atol=1e-5 + ) + + def test_divergence_of_curl_is_zero(self): + """div(curl(v)) = 0 for any vector field.""" + mesh = procedural.lumpy_ball.load() + + # Use rotation field + v = torch.zeros_like(mesh.points) + v[:, 0] = -mesh.points[:, 1] + v[:, 1] = mesh.points[:, 0] + v[:, 2] = mesh.points[:, 2] # Helical + + # Compute curl + from physicsnemo.mesh.calculus.curl import compute_curl_points_lsq + + curl_v = compute_curl_points_lsq(mesh, v) + + # Compute divergence of curl + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_lsq + + div_curl = compute_divergence_points_lsq(mesh, curl_v) + + # Should be zero + assert torch.allclose(div_curl, torch.zeros_like(div_curl), atol=1e-5) + + +class TestParametrized: + """Parametrized tests for comprehensive coverage.""" + + @pytest.mark.parametrize("field_type", ["constant", "linear"]) + @pytest.mark.parametrize("method", ["lsq"]) + def test_gradient_exact_recovery(self, field_type, method): + """Gradient of constant/linear fields should be exact.""" + mesh = procedural.lumpy_ball.load() + + if field_type == "constant": + phi = torch.full((mesh.n_points,), 5.0) + expected_grad = torch.zeros((mesh.n_points, mesh.n_spatial_dims)) + tol = 1e-6 + else: # linear + coeffs = torch.tensor([2.0, 3.0, -1.0]) + phi = (mesh.points * coeffs).sum(dim=-1) + expected_grad = coeffs.unsqueeze(0).expand(mesh.n_points, -1) + tol = 1e-4 + + mesh.point_data["test"] = phi + mesh_grad = mesh.compute_point_derivatives(keys="test", method=method) + grad = mesh_grad.point_data["test_gradient"] + + assert torch.allclose(grad, expected_grad, atol=tol) + + @pytest.mark.parametrize("divergence_value", [1.0, 3.0, 9.0]) + def test_uniform_divergence_recovery(self, divergence_value): + """Divergence of scaled identity field should be exact.""" + mesh = procedural.lumpy_ball.load() + scale = divergence_value / mesh.n_spatial_dims + v = mesh.points * scale + + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_lsq + + div_v = compute_divergence_points_lsq(mesh, v) + + assert torch.allclose( + div_v, torch.full_like(div_v, divergence_value), atol=1e-4 + ) + + +############################################################################### +# Laplacian Tensor Fields Tests +############################################################################### + + +class TestLaplacianTensorFields: + """Tests for Laplacian of tensor (vector/matrix) fields.""" + + def create_triangle_mesh(self, device="cpu"): + """Create simple triangle mesh for testing.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, (3**0.5) / 2], + [1.5, (3**0.5) / 2], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ], + dtype=torch.long, + device=device, + ) + + return Mesh(points=points, cells=cells) + + def test_laplacian_vector_field(self): + """Test Laplacian of vector field (n_points, n_dims).""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = self.create_triangle_mesh() + + # Create vector field: velocity or position-like data + # Use linear field for simplicity: v = [x, y] + vector_values = mesh.points.clone() # (n_points, 2) + + # Compute Laplacian + laplacian = compute_laplacian_points_dec(mesh, vector_values) + + # Should have same shape as input + assert laplacian.shape == vector_values.shape + assert laplacian.shape == (mesh.n_points, 2) + + # Laplacian should be computed (not NaN/Inf) + assert not torch.any(torch.isnan(laplacian)) + assert not torch.any(torch.isinf(laplacian)) + + def test_laplacian_3d_vector_field(self): + """Test Laplacian of 3D vector field on 2D manifold.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = self.create_triangle_mesh() + + # Create 3D vector field on 2D mesh + # Each point has a 3D vector + vector_values = torch.randn(mesh.n_points, 3) + + # Compute Laplacian + laplacian = compute_laplacian_points_dec(mesh, vector_values) + + # Should have same shape + assert laplacian.shape == (mesh.n_points, 3) + + # No NaNs + assert not torch.any(torch.isnan(laplacian)) + + def test_laplacian_matrix_field(self): + """Test Laplacian of matrix field (n_points, d1, d2).""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = self.create_triangle_mesh() + + # Create 2x2 matrix at each point + matrix_values = torch.randn(mesh.n_points, 2, 2) + + # Compute Laplacian + laplacian = compute_laplacian_points_dec(mesh, matrix_values) + + # Should have same shape + assert laplacian.shape == (mesh.n_points, 2, 2) + + # No NaNs + assert not torch.any(torch.isnan(laplacian)) + + def test_laplacian_higher_order_tensor(self): + """Test Laplacian of higher-order tensor field.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = self.create_triangle_mesh() + + # Create 3D tensor at each point (e.g., stress tensor components) + tensor_values = torch.randn(mesh.n_points, 3, 3, 3) + + # Compute Laplacian + laplacian = compute_laplacian_points_dec(mesh, tensor_values) + + # Should have same shape + assert laplacian.shape == (mesh.n_points, 3, 3, 3) + + # No NaNs + assert not torch.any(torch.isnan(laplacian)) + + def test_laplacian_vector_constant(self): + """Test Laplacian of constant vector field is zero.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = self.create_triangle_mesh() + + # Constant vector field + constant_vector = torch.tensor([1.0, 2.0]) + vector_values = constant_vector.unsqueeze(0).expand(mesh.n_points, -1) + + # Compute Laplacian + laplacian = compute_laplacian_points_dec(mesh, vector_values) + + # Should be close to zero + assert torch.allclose(laplacian, torch.zeros_like(laplacian), atol=1e-5) + + def test_laplacian_vector_linear_field(self): + """Test Laplacian of linear vector field.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = self.create_triangle_mesh() + + # Linear vector field: v(x,y) = [2x+y, x-y] + x = mesh.points[:, 0] + y = mesh.points[:, 1] + + vector_values = torch.stack( + [ + 2 * x + y, + x - y, + ], + dim=1, + ) + + # Compute Laplacian + laplacian = compute_laplacian_points_dec(mesh, vector_values) + + # Laplacian should be computed (not NaN/Inf) + assert not torch.any(torch.isnan(laplacian)) + assert not torch.any(torch.isinf(laplacian)) + + +############################################################################### +# Laplacian Spherical Harmonics Tests +############################################################################### + + +class TestLaplacianSphericalHarmonics: + r"""Tests for DEC Laplacian using spherical harmonic eigenfunctions. + + Spherical harmonics Y_l^m are eigenfunctions of the Laplace-Beltrami operator + on the unit sphere with eigenvalue \lambda = -l(l+1). + + These tests validate that the DEC implementation correctly recovers these + eigenvalues, providing strong evidence for correctness. + """ + + def create_unit_sphere(self, subdivisions: int = 4) -> Mesh: + """Create high-resolution unit sphere via icosahedral subdivision.""" + from physicsnemo.mesh.primitives.surfaces import sphere_uv + + # Use UV sphere for simplicity; high resolution for accuracy + return sphere_uv.load(radius=1.0, theta_resolution=50, phi_resolution=50) + + def test_laplacian_constant_function_zero(self): + r"""Verify \Delta(const) = 0 on closed surface. + + A constant function is a spherical harmonic with l=0 (Y_0^0), + which has eigenvalue -0(0+1) = 0. + """ + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = self.create_unit_sphere() + phi = torch.ones(mesh.n_points, dtype=torch.float32) + + lap = compute_laplacian_points_dec(mesh, phi) + + assert lap.abs().max() < 1e-5, ( + f"Laplacian of constant: max={lap.abs().max():.6f}" + ) + assert lap.abs().mean() < 1e-6, ( + f"Laplacian of constant: mean={lap.abs().mean():.6f}" + ) + + def test_laplacian_spherical_harmonic_Y10(self): + r"""Verify \Delta_S(z) = -2z (eigenvalue -2 for l=1). + + Y_1^0 \propto z = cos(theta), with eigenvalue \lambda = -l(l+1) = -2. + """ + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = self.create_unit_sphere() + z = mesh.points[:, 2] + phi = z.clone() + + lap = compute_laplacian_points_dec(mesh, phi) + + # Expected: Delta_S(z) = -2 * z + expected = -2 * z + + # Verify eigenvalue relationship: lap / phi should be ~-2 (where phi != 0) + mask = phi.abs() > 0.1 # Avoid division by near-zero + ratio = lap[mask] / phi[mask] + + mean_eigenvalue = ratio.mean() + assert abs(mean_eigenvalue - (-2.0)) < 0.1, ( + f"Y_1^0 eigenvalue: {mean_eigenvalue:.4f}, expected -2.0" + ) + + # Verify correlation with expected + correlation = torch.corrcoef(torch.stack([lap, expected]))[0, 1] + assert correlation > 0.999, f"Y_1^0 correlation: {correlation:.6f}" + + def test_laplacian_spherical_harmonic_Y20(self): + r"""Verify \Delta_S(3z^2-1) = -6(3z^2-1) (eigenvalue -6 for l=2). + + Y_2^0 \propto (3cos^2(theta) - 1) = 3z^2 - 1, with eigenvalue -6. + """ + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = self.create_unit_sphere() + z = mesh.points[:, 2] + phi = 3 * z**2 - 1 + + lap = compute_laplacian_points_dec(mesh, phi) + + # Expected: Delta_S(3z^2 - 1) = -6 * (3z^2 - 1) + expected = -6 * phi + + # Verify eigenvalue relationship + mask = phi.abs() > 0.1 + ratio = lap[mask] / phi[mask] + + mean_eigenvalue = ratio.mean() + assert abs(mean_eigenvalue - (-6.0)) < 0.15, ( + f"Y_2^0 eigenvalue: {mean_eigenvalue:.4f}, expected -6.0" + ) + + # Verify correlation + correlation = torch.corrcoef(torch.stack([lap, expected]))[0, 1] + assert correlation > 0.999, f"Y_2^0 correlation: {correlation:.6f}" + + def test_laplacian_spherical_harmonic_Y21(self): + r"""Verify \Delta_S(xz) = -6(xz) (eigenvalue -6 for l=2, m=1). + + Y_2^1 \propto xz (real part) or yz (imaginary part), with eigenvalue -6. + """ + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = self.create_unit_sphere() + x, y, z = mesh.points[:, 0], mesh.points[:, 1], mesh.points[:, 2] + + # Test xz + phi_xz = x * z + lap_xz = compute_laplacian_points_dec(mesh, phi_xz) + + mask = phi_xz.abs() > 0.05 + ratio_xz = lap_xz[mask] / phi_xz[mask] + mean_eigenvalue_xz = ratio_xz.mean() + + assert abs(mean_eigenvalue_xz - (-6.0)) < 0.15, ( + f"Y_2^1 (xz) eigenvalue: {mean_eigenvalue_xz:.4f}, expected -6.0" + ) + + # Test yz + phi_yz = y * z + lap_yz = compute_laplacian_points_dec(mesh, phi_yz) + + mask = phi_yz.abs() > 0.05 + ratio_yz = lap_yz[mask] / phi_yz[mask] + mean_eigenvalue_yz = ratio_yz.mean() + + assert abs(mean_eigenvalue_yz - (-6.0)) < 0.15, ( + f"Y_2^1 (yz) eigenvalue: {mean_eigenvalue_yz:.4f}, expected -6.0" + ) + + def test_laplacian_spherical_harmonic_Y22(self): + r"""Verify \Delta_S(x^2-y^2) = -6(x^2-y^2) (eigenvalue -6 for l=2, m=2). + + Y_2^2 \propto x^2-y^2 (real part) or xy (imaginary part), with eigenvalue -6. + """ + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = self.create_unit_sphere() + x, y = mesh.points[:, 0], mesh.points[:, 1] + + # Test x^2 - y^2 + phi_x2y2 = x**2 - y**2 + lap_x2y2 = compute_laplacian_points_dec(mesh, phi_x2y2) + + mask = phi_x2y2.abs() > 0.05 + ratio_x2y2 = lap_x2y2[mask] / phi_x2y2[mask] + mean_eigenvalue_x2y2 = ratio_x2y2.mean() + + assert abs(mean_eigenvalue_x2y2 - (-6.0)) < 0.15, ( + f"Y_2^2 (x^2-y^2) eigenvalue: {mean_eigenvalue_x2y2:.4f}, expected -6.0" + ) + + # Test xy + phi_xy = x * y + lap_xy = compute_laplacian_points_dec(mesh, phi_xy) + + mask = phi_xy.abs() > 0.05 + ratio_xy = lap_xy[mask] / phi_xy[mask] + mean_eigenvalue_xy = ratio_xy.mean() + + assert abs(mean_eigenvalue_xy - (-6.0)) < 0.15, ( + f"Y_2^2 (xy) eigenvalue: {mean_eigenvalue_xy:.4f}, expected -6.0" + ) + + +############################################################################### +# Laplacian Boundary and Edge Cases +############################################################################### + + +class TestLaplacianBoundaryAndEdgeCases: + """Tests for boundary conditions and edge cases.""" + + def create_sphere_mesh(self, subdivisions=1, device="cpu"): + """Create icosahedral sphere.""" + phi = (1.0 + (5.0**0.5)) / 2.0 + + vertices = [ + [-1, phi, 0], + [1, phi, 0], + [-1, -phi, 0], + [1, -phi, 0], + [0, -1, phi], + [0, 1, phi], + [0, -1, -phi], + [0, 1, -phi], + [phi, 0, -1], + [phi, 0, 1], + [-phi, 0, -1], + [-phi, 0, 1], + ] + + points = torch.tensor(vertices, dtype=torch.float32, device=device) + points = points / torch.norm(points, dim=-1, keepdim=True) + + faces = [ + [0, 11, 5], + [0, 5, 1], + [0, 1, 7], + [0, 7, 10], + [0, 10, 11], + [1, 5, 9], + [5, 11, 4], + [11, 10, 2], + [10, 7, 6], + [7, 1, 8], + [3, 9, 4], + [3, 4, 2], + [3, 2, 6], + [3, 6, 8], + [3, 8, 9], + [4, 9, 5], + [2, 4, 11], + [6, 2, 10], + [8, 6, 7], + [9, 8, 1], + ] + + cells = torch.tensor(faces, dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + # Subdivide if requested + for _ in range(subdivisions): + mesh = mesh.subdivide(levels=1, filter="linear") + mesh = Mesh( + points=mesh.points / torch.norm(mesh.points, dim=-1, keepdim=True), + cells=mesh.cells, + ) + + return mesh + + def test_laplacian_on_closed_surface(self): + """Test Laplacian on closed surface (no boundary).""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = self.create_sphere_mesh(subdivisions=0) + + # Create constant scalar field + scalar_values = torch.ones(mesh.n_points) + + # Compute Laplacian + laplacian = compute_laplacian_points_dec(mesh, scalar_values) + + # For constant function, Laplacian should be zero + assert torch.allclose(laplacian, torch.zeros_like(laplacian), atol=1e-5) + + def test_laplacian_empty_mesh(self): + """Test Laplacian with no cells.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + points = torch.randn(10, 2) + cells = torch.zeros((0, 3), dtype=torch.long) + + mesh = Mesh(points=points, cells=cells) + + scalar_values = torch.randn(mesh.n_points) + + # With no cells, cotangent weights will be empty + # This should handle gracefully (likely return zeros or small values) + laplacian = compute_laplacian_points_dec(mesh, scalar_values) + + # Should have correct shape + assert laplacian.shape == scalar_values.shape + + def test_laplacian_single_triangle(self): + """Test Laplacian on single isolated triangle.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long) + + mesh = Mesh(points=points, cells=cells) + + # Linear field + scalar_values = mesh.points[:, 0] # x-coordinate + + laplacian = compute_laplacian_points_dec(mesh, scalar_values) + + # Should compute without errors + assert laplacian.shape == (3,) + assert not torch.any(torch.isnan(laplacian)) + + def test_laplacian_degenerate_voronoi_area(self): + """Test Laplacian handles very small Voronoi areas.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + # Create mesh with very small triangle + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1e-8], # Very small height + [1.5, 0.0], + ], + dtype=torch.float32, + ) + + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ], + dtype=torch.long, + ) + + mesh = Mesh(points=points, cells=cells) + + scalar_values = torch.ones(mesh.n_points) + + # Should handle small areas without producing NaN/Inf + laplacian = compute_laplacian_points_dec(mesh, scalar_values) + + assert not torch.any(torch.isnan(laplacian)) + assert not torch.any(torch.isinf(laplacian)) + + +class TestLaplacianNumericalProperties: + """Tests for numerical properties of the Laplacian.""" + + def test_laplacian_symmetry(self): + """Test that Laplacian operator is symmetric (self-adjoint).""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + # Create mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [1.0, 1.0], + [0.0, 1.0], + [0.5, 0.5], + ], + dtype=torch.float32, + ) + + cells = torch.tensor( + [ + [0, 1, 4], + [1, 2, 4], + [2, 3, 4], + [3, 0, 4], + ], + dtype=torch.long, + ) + + mesh = Mesh(points=points, cells=cells) + + # Two different scalar fields + f = torch.randn(mesh.n_points) + g = torch.randn(mesh.n_points) + + # Compute Laplacians + Lf = compute_laplacian_points_dec(mesh, f) + Lg = compute_laplacian_points_dec(mesh, g) + + # For symmetric operator: = + # (up to boundary terms, which don't exist for closed manifolds) + + # Get Voronoi areas for proper inner product + from physicsnemo.mesh.geometry.dual_meshes import ( + get_or_compute_dual_volumes_0, + ) + + voronoi_areas = get_or_compute_dual_volumes_0(mesh) + + # Weighted inner products + f_Lg = (f * Lg * voronoi_areas).sum() + Lf_g = (Lf * g * voronoi_areas).sum() + + # Should be approximately equal (numerically) + rel_diff = torch.abs(f_Lg - Lf_g) / (torch.abs(f_Lg) + torch.abs(Lf_g) + 1e-10) + assert rel_diff < 0.01 # Within 1% + + def test_laplacian_dec_basic(self): + """Test compute_laplacian_points_dec produces correct shape and dtype.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + # Create simple triangle mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long) + mesh = Mesh(points=points, cells=cells) + + scalar_values = torch.randn(mesh.n_points) + + laplacian = compute_laplacian_points_dec(mesh, scalar_values) + + assert laplacian.shape == scalar_values.shape + assert laplacian.dtype == scalar_values.dtype + + +class TestLaplacianManifoldDimensions: + """Tests for Laplacian on different manifold dimensions.""" + + def test_laplacian_works_for_1d(self): + """Test that DEC Laplacian works on 1D edge meshes.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + # Create 1D mesh (edges in 2D ambient space) + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [2.0, 0.0], + ], + dtype=torch.float32, + ) + + cells = torch.tensor( + [ + [0, 1], + [1, 2], + ], + dtype=torch.long, + ) + + mesh = Mesh(points=points, cells=cells) + scalar_values = torch.randn(mesh.n_points) + + # Should run without error and return correct shape + laplacian = compute_laplacian_points_dec(mesh, scalar_values) + assert laplacian.shape == scalar_values.shape + assert torch.isfinite(laplacian).all() + + def test_laplacian_works_for_3d(self): + """Test that DEC Laplacian works on 3D tetrahedral meshes.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + # Create single tetrahedron + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, (3**0.5) / 2, 0.0], + [0.5, (3**0.5) / 6, ((2 / 3) ** 0.5)], + ], + dtype=torch.float32, + ) + + cells = torch.tensor([[0, 1, 2, 3]], dtype=torch.long) + + mesh = Mesh(points=points, cells=cells) + scalar_values = torch.randn(mesh.n_points) + + # Should run without error and return correct shape + laplacian = compute_laplacian_points_dec(mesh, scalar_values) + assert laplacian.shape == scalar_values.shape + assert torch.isfinite(laplacian).all() + + def test_laplacian_flat_mesh_quadratic(self): + r"""Verify \Delta(x^2+y^2) = 4 on flat 2D mesh. + + On a flat manifold, the Laplace-Beltrami reduces to the standard Laplacian. + For phi = x^2 + y^2: \Delta phi = 2 + 2 = 4 (uniform everywhere). + """ + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + # Create flat 2D mesh (unit square with interior vertex) + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [1.0, 1.0], + [0.0, 1.0], + [0.5, 0.5], # Interior vertex + ], + dtype=torch.float32, + ) + cells = torch.tensor( + [ + [0, 1, 4], + [1, 2, 4], + [2, 3, 4], + [3, 0, 4], + ], + dtype=torch.long, + ) + mesh = Mesh(points=points, cells=cells) + + # phi = x^2 + y^2 + phi = points[:, 0] ** 2 + points[:, 1] ** 2 + + lap = compute_laplacian_points_dec(mesh, phi) + + # Interior vertex (index 4) should have Laplacian = 4 + interior_lap = lap[4] + assert abs(interior_lap - 4.0) < 0.01, ( + f"Flat mesh Laplacian at interior: {interior_lap:.4f}, expected 4.0" + ) + + +############################################################################### +# DEC Operators Tests +############################################################################### + + +class TestDECOperators: + """Test DEC-specific code paths.""" + + def test_exterior_derivative_0(self, simple_tet_mesh): + """Test exterior derivative d₀: Ω⁰ → Ω¹.""" + from physicsnemo.mesh.calculus._exterior_derivative import exterior_derivative_0 + + mesh = simple_tet_mesh + vertex_values = torch.arange(mesh.n_points, dtype=torch.float32) + + edge_values, edges = exterior_derivative_0(mesh, vertex_values) + + assert edge_values.shape[0] == edges.shape[0] + assert edges.shape[1] == 2 + + # Verify: df(edge) = f(v1) - f(v0) + for i in range(len(edges)): + expected = vertex_values[edges[i, 1]] - vertex_values[edges[i, 0]] + assert torch.allclose(edge_values[i], expected, atol=1e-6) + + def test_exterior_derivative_tensor_field(self, simple_tet_mesh): + """Test d₀ on tensor-valued 0-form.""" + from physicsnemo.mesh.calculus._exterior_derivative import exterior_derivative_0 + + mesh = simple_tet_mesh + # Vector-valued function at vertices + vertex_vectors = mesh.points.clone() # (n_points, 3) + + edge_values, edges = exterior_derivative_0(mesh, vertex_vectors) + + assert edge_values.shape == (len(edges), 3) + + def test_hodge_star_0(self, simple_tet_mesh): + """Test Hodge star on 0-forms.""" + from physicsnemo.mesh.calculus._hodge_star import hodge_star_0 + + mesh = simple_tet_mesh + vertex_values = torch.ones(mesh.n_points) + + dual_values = hodge_star_0(mesh, vertex_values) + + assert dual_values.shape == vertex_values.shape + # All values should be scaled by dual volumes + assert (dual_values > 0).all() + + def test_hodge_star_0_tensor(self, simple_tet_mesh): + """Test Hodge star on tensor-valued 0-form.""" + from physicsnemo.mesh.calculus._hodge_star import hodge_star_0 + + mesh = simple_tet_mesh + vertex_tensors = mesh.points.clone() # (n_points, 3) + + dual_tensors = hodge_star_0(mesh, vertex_tensors) + + assert dual_tensors.shape == vertex_tensors.shape + + def test_hodge_star_1(self, simple_tet_mesh): + """Test Hodge star on 1-forms.""" + from physicsnemo.mesh.calculus._exterior_derivative import exterior_derivative_0 + from physicsnemo.mesh.calculus._hodge_star import hodge_star_1 + + mesh = simple_tet_mesh + vertex_values = torch.ones(mesh.n_points) + + edge_values, edges = exterior_derivative_0(mesh, vertex_values) + dual_edge_values = hodge_star_1(mesh, edge_values, edges) + + assert dual_edge_values.shape == edge_values.shape + + def test_sharp_operator(self, simple_tet_mesh): + """Test sharp operator: 1-form → vector field.""" + from physicsnemo.mesh.calculus._exterior_derivative import exterior_derivative_0 + from physicsnemo.mesh.calculus._sharp_flat import sharp + + mesh = simple_tet_mesh + vertex_values = torch.arange(mesh.n_points, dtype=torch.float32) + + edge_values, edges = exterior_derivative_0(mesh, vertex_values) + vector_field = sharp(mesh, edge_values, edges) + + assert vector_field.shape == (mesh.n_points, mesh.n_spatial_dims) + + def test_sharp_operator_tensor(self, simple_tet_mesh): + """Test sharp on tensor-valued 1-form.""" + from physicsnemo.mesh.calculus._exterior_derivative import exterior_derivative_0 + from physicsnemo.mesh.calculus._sharp_flat import sharp + + mesh = simple_tet_mesh + vertex_tensors = mesh.points.clone() + + edge_tensors, edges = exterior_derivative_0(mesh, vertex_tensors) + vector_field = sharp(mesh, edge_tensors, edges) + + assert vector_field.shape[0] == mesh.n_points + + def test_flat_operator(self, simple_tet_mesh): + """Test flat operator: vector field → 1-form.""" + from physicsnemo.mesh.calculus._exterior_derivative import exterior_derivative_0 + from physicsnemo.mesh.calculus._sharp_flat import flat + + mesh = simple_tet_mesh + vector_field = mesh.points.clone() + + # Get edges + _, edges = exterior_derivative_0(mesh, torch.zeros(mesh.n_points)) + + edge_1form = flat(mesh, vector_field, edges) + + assert edge_1form.shape[0] == len(edges) + + def test_flat_operator_tensor(self, simple_tet_mesh): + """Test flat on tensor field.""" + from physicsnemo.mesh.calculus._exterior_derivative import exterior_derivative_0 + from physicsnemo.mesh.calculus._sharp_flat import flat + + mesh = simple_tet_mesh + # Tensor field (n_points, 3, 2) for example + tensor_field = mesh.points.unsqueeze(-1).repeat(1, 1, 2) + + _, edges = exterior_derivative_0(mesh, torch.zeros(mesh.n_points)) + + edge_form = flat(mesh, tensor_field, edges) + + assert edge_form.ndim > 1 + + def test_dec_gradient_points(self, simple_tet_mesh): + """Test DEC gradient code path (implementation incomplete).""" + from physicsnemo.mesh.calculus.gradient import compute_gradient_points_dec + + mesh = simple_tet_mesh + phi = 2 * mesh.points[:, 0] + 3 * mesh.points[:, 1] - mesh.points[:, 2] + + grad = compute_gradient_points_dec(mesh, phi) + + # Just verify it runs and returns correct shape + assert grad.shape == (mesh.n_points, mesh.n_spatial_dims) + assert torch.isfinite(grad).all() + + +class TestExteriorDerivative: + """Test d₁ exterior derivative.""" + + def test_exterior_derivative_1_on_triangles(self): + """Test d₁: Ω¹ → Ω² on triangle mesh.""" + from physicsnemo.mesh.calculus._exterior_derivative import ( + exterior_derivative_0, + exterior_derivative_1, + ) + + # Triangle mesh + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 1.0]]) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + mesh = Mesh(points=points, cells=cells) + + # Create 0-form and compute df + vertex_values = torch.arange(mesh.n_points, dtype=torch.float32) + edge_1form, edges = exterior_derivative_0(mesh, vertex_values) + + # Compute d(1-form) + face_2form, faces = exterior_derivative_1(mesh, edge_1form, edges) + + assert face_2form.shape[0] == mesh.n_cells + + def test_exterior_derivative_1_error_on_1d(self): + """Test d₁ raises error on 1D manifold.""" + from physicsnemo.mesh.calculus._exterior_derivative import exterior_derivative_1 + + # 1D mesh (curve) + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]]) + cells = torch.tensor([[0, 1], [1, 2]]) + mesh = Mesh(points=points, cells=cells) + + edge_values = torch.ones(mesh.n_cells) + edges = mesh.cells + + with pytest.raises(ValueError, match="requires n_manifold_dims >= 2"): + exterior_derivative_1(mesh, edge_values, edges) + + +class TestCircumcentricDual: + """Test circumcentric dual computation.""" + + def test_circumcenter_edge(self): + """Test circumcenter of edge (1-simplex).""" + from physicsnemo.mesh.geometry.dual_meshes import compute_circumcenters + + # Single edge + vertices = torch.tensor([[[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]]]) + + circumcenters = compute_circumcenters(vertices) + + # Should be midpoint + expected = torch.tensor([[1.0, 0.0, 0.0]]) + assert torch.allclose(circumcenters, expected, atol=1e-6) + + def test_circumcenter_triangle_2d(self): + """Test circumcenter of triangle in 2D.""" + from physicsnemo.mesh.geometry.dual_meshes import compute_circumcenters + + # Right triangle at origin + vertices = torch.tensor([[[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]]) + + circumcenters = compute_circumcenters(vertices) + + # Should be at [0.5, 0.5] (midpoint of hypotenuse) + expected = torch.tensor([[0.5, 0.5]]) + assert torch.allclose(circumcenters, expected, atol=1e-5) + + def test_circumcenter_triangle_3d(self): + """Test circumcenter of triangle embedded in 3D.""" + from physicsnemo.mesh.geometry.dual_meshes import compute_circumcenters + + # Right triangle in xy-plane + vertices = torch.tensor([[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]]) + + circumcenters = compute_circumcenters(vertices) + + # For embedded triangle, uses least-squares (over-determined system) + # Just verify shape and finiteness + assert circumcenters.shape == (1, 3) + assert torch.isfinite(circumcenters).all() + + def test_circumcenter_tetrahedron(self): + """Test circumcenter of tetrahedron.""" + from physicsnemo.mesh.geometry.dual_meshes import compute_circumcenters + + # Regular tetrahedron (approximately) + vertices = torch.tensor( + [[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 0.866, 0.0], [0.5, 0.433, 0.816]]] + ) + + circumcenters = compute_circumcenters(vertices) + + # Should be equidistant from all vertices + assert circumcenters.shape == (1, 3) + + # Verify equidistance + for i in range(4): + dist = torch.norm(circumcenters[0] - vertices[0, i]) + if i == 0: + ref_dist = dist + else: + assert torch.allclose(dist, ref_dist, atol=1e-4) + + def test_circumcenter_non_origin_triangle(self): + """Regression test: circumcenter for triangle not at origin. + + The bug was a wrong RHS in the linear system that only showed up + when the first vertex was not at the origin. + Triangle (1,1), (5,1), (1,5) has circumcenter at (3,3). + """ + from physicsnemo.mesh.geometry.dual_meshes import compute_circumcenters + + vertices = torch.tensor([[[1.0, 1.0], [5.0, 1.0], [1.0, 5.0]]]) + cc = compute_circumcenters(vertices) + torch.testing.assert_close(cc, torch.tensor([[3.0, 3.0]]), atol=1e-6, rtol=1e-6) + + def test_circumcenter_equilateral_triangle(self): + """Regression test: circumcenter of equilateral triangle centered at origin.""" + from physicsnemo.mesh.geometry.dual_meshes import compute_circumcenters + + vertices = torch.tensor([[[1.0, 0.0], [-0.5, 0.8660254], [-0.5, -0.8660254]]]) + cc = compute_circumcenters(vertices) + torch.testing.assert_close(cc, torch.zeros(1, 2), atol=1e-5, rtol=1e-5) + + +############################################################################### +# Cell Derivatives Tests +############################################################################### + + +class TestCellDerivatives: + """Test cell-based derivative computation.""" + + def test_cell_gradient_lsq(self, simple_tet_mesh): + """Test LSQ gradient on cell data.""" + mesh = simple_tet_mesh + + # Linear function on cells + cell_centroids = mesh.cell_centroids + cell_values = (cell_centroids * torch.tensor([2.0, 3.0, -1.0])).sum(dim=-1) + + mesh.cell_data["test"] = cell_values + + mesh_grad = mesh.compute_cell_derivatives(keys="test", method="lsq") + + grad = mesh_grad.cell_data["test_gradient"] + assert grad.shape == (mesh.n_cells, mesh.n_spatial_dims) + + # Should recover linear coefficients approximately. + # Coarse mesh (4 tets, ~3 face-adjacent neighbors per cell); cell-based + # LSQ has limited accuracy with so few neighbors. + expected = torch.tensor([2.0, 3.0, -1.0]) + assert torch.allclose(grad.mean(dim=0), expected, atol=0.25) + + def test_cell_gradient_dec_not_implemented(self, simple_tet_mesh): + """Test that DEC cell gradients raise NotImplementedError.""" + mesh = simple_tet_mesh + mesh.cell_data["test"] = torch.ones(mesh.n_cells) + + with pytest.raises(NotImplementedError): + mesh.compute_cell_derivatives(keys="test", method="dec") + + +class TestTensorFields: + """Test gradient computation on tensor fields.""" + + def test_vector_field_gradient_jacobian(self, simple_tet_mesh): + """Test that gradient of vector field gives Jacobian.""" + mesh = simple_tet_mesh + + # Vector field + mesh.point_data["velocity"] = mesh.points.clone() + + mesh_grad = mesh.compute_point_derivatives(keys="velocity", method="lsq") + + jacobian = mesh_grad.point_data["velocity_gradient"] + + # Shape should be (n_points, 3, 3) for 3D + assert jacobian.shape == (mesh.n_points, 3, 3) + + # For v=r, Jacobian should be identity. + # Mean Jacobian should be close to I; coarse mesh (5 pts, 4 tets) + # limits per-point accuracy, but the mean should be tighter. + mean_jac = jacobian.mean(dim=0) + expected = torch.eye(3) + + assert torch.allclose(mean_jac, expected, atol=0.1) + + +############################################################################### +# Edge Cases and Error Handling +############################################################################### + + +class TestEdgeCases: + """Test error handling and edge cases.""" + + def test_gradient_invalid_method(self, simple_tet_mesh): + """Test that invalid method raises ValueError.""" + mesh = simple_tet_mesh + mesh.point_data["test"] = torch.ones(mesh.n_points) + + with pytest.raises(ValueError, match="Invalid method"): + mesh.compute_point_derivatives(keys="test", method="invalid") + + def test_gradient_invalid_gradient_type(self, simple_tet_mesh): + """Test that invalid gradient_type raises ValueError.""" + mesh = simple_tet_mesh + mesh.point_data["test"] = torch.ones(mesh.n_points) + + with pytest.raises(ValueError, match="Invalid gradient_type"): + mesh.compute_point_derivatives(keys="test", gradient_type="invalid") + + def test_laplacian_on_3d_mesh_constant(self, simple_tet_mesh): + """Test that DEC Laplacian of constant on 3D mesh is zero.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + mesh = simple_tet_mesh # 3D manifold + phi = torch.ones(mesh.n_points) + + laplacian = compute_laplacian_points_dec(mesh, phi) + assert torch.allclose(laplacian, torch.zeros_like(laplacian), atol=1e-5) + + def test_curl_on_2d_raises(self): + """Test that curl on 2D data raises ValueError.""" + from physicsnemo.mesh.calculus.curl import compute_curl_points_lsq + + # 2D mesh + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + v = torch.ones((mesh.n_points, 2)) + + with pytest.raises(ValueError, match="only defined for 3D"): + compute_curl_points_lsq(mesh, v) + + def test_isolated_point_gradient_zero(self): + """Test that isolated points (no neighbors) get zero gradient.""" + # Mesh with isolated point + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [2.0, 0.0, 0.0], + [10.0, 10.0, 10.0], # Isolated + ] + ) + cells = torch.tensor([[0, 1, 2, 3]]) # Only connects first 3 in one direction + mesh = Mesh(points=points, cells=cells) + + phi = torch.arange(mesh.n_points, dtype=torch.float32) + + from physicsnemo.mesh.calculus._lsq_reconstruction import ( + compute_point_gradient_lsq, + ) + + grad = compute_point_gradient_lsq(mesh, phi) + + # Should not crash, gradients should be defined + assert grad.shape == (mesh.n_points, mesh.n_spatial_dims) + + +class TestGradientTypes: + """Test all gradient_type options.""" + + def test_extrinsic_gradient(self): + """Test gradient_type='extrinsic'.""" + mesh = procedural.lumpy_sphere.load(radius=1.0, subdivisions=2) + mesh.point_data["test"] = torch.ones(mesh.n_points) + + mesh_grad = mesh.compute_point_derivatives( + keys="test", gradient_type="extrinsic" + ) + + assert "test_gradient" in mesh_grad.point_data.keys() + assert "test_gradient_intrinsic" not in mesh_grad.point_data.keys() + + def test_intrinsic_gradient(self): + """Test gradient_type='intrinsic'.""" + mesh = procedural.lumpy_sphere.load(radius=1.0, subdivisions=2) + mesh.point_data["test"] = torch.ones(mesh.n_points) + + mesh_grad = mesh.compute_point_derivatives( + keys="test", gradient_type="intrinsic" + ) + + assert "test_gradient" in mesh_grad.point_data.keys() + assert "test_gradient_extrinsic" not in mesh_grad.point_data.keys() + + def test_both_gradients(self): + """Test gradient_type='both'.""" + mesh = procedural.lumpy_sphere.load(radius=1.0, subdivisions=2) + mesh.point_data["test"] = torch.ones(mesh.n_points) + + mesh_grad = mesh.compute_point_derivatives(keys="test", gradient_type="both") + + assert "test_gradient_intrinsic" in mesh_grad.point_data.keys() + assert "test_gradient_extrinsic" in mesh_grad.point_data.keys() + + +class TestKeyParsing: + """Test various key input formats.""" + + def test_none_keys_all_fields(self, simple_tet_mesh): + """Test keys=None computes all non-cached fields (excludes "_cache" sub-dict).""" + from physicsnemo.mesh.utilities._cache import set_cached + + mesh = simple_tet_mesh + mesh.point_data["field1"] = torch.ones(mesh.n_points) + mesh.point_data["field2"] = torch.ones(mesh.n_points) + set_cached( + mesh.point_data, "test_value", torch.ones(mesh.n_points) + ) # Should skip + + mesh_grad = mesh.compute_point_derivatives(keys=None) + + assert "field1_gradient" in mesh_grad.point_data.keys() + assert "field2_gradient" in mesh_grad.point_data.keys() + # Cached values should not have gradients computed + assert "test_value_gradient" not in mesh_grad.point_data.keys() + + def test_nested_tensordict_keys(self, simple_tet_mesh): + """Test nested TensorDict access.""" + from tensordict import TensorDict + + mesh = simple_tet_mesh + nested = TensorDict( + {"temperature": torch.ones(mesh.n_points)}, + batch_size=torch.Size([mesh.n_points]), + ) + mesh.point_data["flow"] = nested + + mesh_grad = mesh.compute_point_derivatives(keys=("flow", "temperature")) + + assert "flow" in mesh_grad.point_data.keys() + assert "temperature_gradient" in mesh_grad.point_data["flow"].keys() + + def test_list_of_keys(self, simple_tet_mesh): + """Test list of multiple keys.""" + mesh = simple_tet_mesh + mesh.point_data["field1"] = torch.ones(mesh.n_points) + mesh.point_data["field2"] = torch.ones(mesh.n_points) * 2 + + mesh_grad = mesh.compute_point_derivatives(keys=["field1", "field2"]) + + assert "field1_gradient" in mesh_grad.point_data.keys() + assert "field2_gradient" in mesh_grad.point_data.keys() + + +############################################################################### +# Higher Codimension and Specialized Tests +############################################################################### + + +class TestHigherCodeimension: + """Test manifolds with codimension > 1.""" + + def test_gradient_on_curve_in_3d(self): + """Test gradient on 1D curve in 3D space (codimension=2).""" + # Helix + t = torch.linspace(0, 2 * torch.pi, 20) + points = torch.stack([torch.cos(t), torch.sin(t), t], dim=-1) + + # Edges along curve + cells = torch.stack([torch.arange(19), torch.arange(1, 20)], dim=-1) + + mesh = Mesh(points=points, cells=cells) + + # Scalar field along curve + mesh.point_data["test"] = t + + mesh_grad = mesh.compute_point_derivatives( + keys="test", gradient_type="extrinsic" + ) + + grad = mesh_grad.point_data["test_gradient"] + assert grad.shape == (mesh.n_points, 3) + + +class TestLSQWeighting: + """Test LSQ weight variations.""" + + def test_lsq_with_ill_conditioned_system(self): + """Test LSQ handles ill-conditioned systems.""" + # Create mesh where some points have nearly collinear neighbors + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [1.01, 0.01, 0.0], # Nearly collinear with edge + [1.02, 0.0, 0.01], # Also nearly collinear + ] + ) + cells = torch.tensor([[0, 1, 2, 3]]) + mesh = Mesh(points=points, cells=cells) + + phi = torch.arange(mesh.n_points, dtype=torch.float32) + + from physicsnemo.mesh.calculus._lsq_reconstruction import ( + compute_point_gradient_lsq, + ) + + # Should not crash despite ill-conditioning + grad = compute_point_gradient_lsq(mesh, phi) + + assert torch.isfinite(grad).all() + # Some points may have zero gradient if too few neighbors + assert grad.shape == (mesh.n_points, 3) + + +class TestCellGradientEdgeCases: + """Test cell gradient edge cases.""" + + def test_cell_with_no_neighbors(self): + """Test cell with no face-adjacent neighbors.""" + # Single isolated tet + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2, 3]]) + mesh = Mesh(points=points, cells=cells) + + mesh.cell_data["test"] = torch.tensor([5.0]) + + from physicsnemo.mesh.calculus._lsq_reconstruction import ( + compute_cell_gradient_lsq, + ) + + # Should handle gracefully (no neighbors) + grad = compute_cell_gradient_lsq(mesh, mesh.cell_data["test"]) + + # Gradient should be zero (no neighbors to reconstruct from) + assert torch.allclose(grad, torch.zeros_like(grad)) + + +class TestProjectionEdgeCases: + """Test tangent space projection edge cases.""" + + def test_projection_on_flat_mesh(self, simple_tet_mesh): + """Test that projection on codim=0 mesh returns input unchanged.""" + from physicsnemo.mesh.calculus.gradient import project_to_tangent_space + + torch.manual_seed(42) + mesh = simple_tet_mesh # Codimension 0 + gradients = torch.randn(mesh.n_points, mesh.n_spatial_dims) + + projected = project_to_tangent_space(mesh, gradients, "points") + + assert torch.allclose(projected, gradients) + + def test_projection_higher_codimension_pca(self): + """Test projection on codim>1 uses PCA to find tangent space.""" + torch.manual_seed(42) + # 1D curve in 3D (codimension=2) + t = torch.linspace(0, 1, 10) + points = torch.stack([t, t**2, t**3], dim=-1) + cells = torch.stack([torch.arange(9), torch.arange(1, 10)], dim=-1) + mesh = Mesh(points=points, cells=cells) + + from physicsnemo.mesh.calculus.gradient import project_to_tangent_space + + gradients = torch.randn(mesh.n_points, 3) + projected = project_to_tangent_space(mesh, gradients, "points") + + # Should project to tangent space (1D manifold) + # Projected gradient should have smaller norm than original (normal component removed) + assert projected.shape == gradients.shape + + # Check that projection actually happened (not identity) + assert not torch.allclose(projected, gradients) + + # Projected gradient should generally have smaller or equal norm + projected_norms = torch.norm(projected, dim=-1) + original_norms = torch.norm(gradients, dim=-1) + # Most should be smaller (allowing some numerical tolerance) + assert (projected_norms <= original_norms + 1e-5).float().mean() > 0.7 + + +class TestTangentSpaceProjection: + """Test tangent space projection for tensors.""" + + def test_project_tensor_gradient_to_tangent(self): + """Test projecting tensor gradient onto tangent space.""" + from physicsnemo.mesh.calculus.gradient import project_to_tangent_space + + torch.manual_seed(42) + # Surface mesh + mesh = procedural.lumpy_sphere.load(radius=1.0, subdivisions=2) + + # Tensor gradient (n_points, n_spatial_dims, 2) + tensor_grads = torch.randn(mesh.n_points, 3, 2) + + projected = project_to_tangent_space(mesh, tensor_grads, "points") + + assert projected.shape == tensor_grads.shape + # Should be different from input (projection happened) + assert not torch.allclose(projected, tensor_grads) + + +class TestIntrinsicLSQEdgeCases: + """Test intrinsic LSQ edge cases.""" + + def test_intrinsic_lsq_on_flat_mesh(self, simple_tet_mesh): + """Test intrinsic LSQ falls back to standard for flat meshes.""" + from physicsnemo.mesh.calculus._lsq_intrinsic import ( + compute_point_gradient_lsq_intrinsic, + ) + + mesh = simple_tet_mesh # Codimension 0 + phi = torch.ones(mesh.n_points) + + grad = compute_point_gradient_lsq_intrinsic(mesh, phi) + + # Should call standard LSQ for flat meshes + assert grad.shape == (mesh.n_points, mesh.n_spatial_dims) + + +############################################################################### +# DEC Divergence Tests +############################################################################### + + +class TestDivergenceDEC: + """Test DEC divergence for 2D and 3D meshes. + + The DEC divergence is exact for linear vector fields at interior vertices + (where the Voronoi cell is complete). Boundary vertices have truncated dual + cells, so accuracy there is not tested. + """ + + ### Helpers ############################################################## + + @staticmethod + def _interior_mask_2d(mesh): + """Boolean mask that is True for interior (non-boundary) vertices.""" + from physicsnemo.mesh.boundaries._detection import get_boundary_vertices + + return ~get_boundary_vertices(mesh) + + ### 2D correctness tests (structured grid) ############################### + + def test_2d_div_identity(self): + """div(position) = 2 at interior vertices of a flat 2D mesh.""" + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_dec + from physicsnemo.mesh.primitives.planar import structured_grid + + mesh = structured_grid.load(n_x=8, n_y=8) + mesh = Mesh(points=mesh.points.to(torch.float64), cells=mesh.cells) + + div_v = compute_divergence_points_dec(mesh, mesh.points.clone()) + interior = self._interior_mask_2d(mesh) + + assert interior.sum() > 0, "Need interior vertices for this test" + assert torch.allclose( + div_v[interior], + torch.full_like(div_v[interior], 2.0), + atol=1e-12, + ) + + def test_2d_div_single_component(self): + """div(x, 0) = 1 at interior vertices.""" + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_dec + from physicsnemo.mesh.primitives.planar import structured_grid + + mesh = structured_grid.load(n_x=8, n_y=8) + mesh = Mesh(points=mesh.points.to(torch.float64), cells=mesh.cells) + + v_field = torch.zeros_like(mesh.points) + v_field[:, 0] = mesh.points[:, 0] + div_v = compute_divergence_points_dec(mesh, v_field) + interior = self._interior_mask_2d(mesh) + + assert torch.allclose( + div_v[interior], + torch.ones_like(div_v[interior]), + atol=1e-12, + ) + + def test_2d_div_rotation(self): + """div(-y, x) = 0 at interior vertices (divergence-free field).""" + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_dec + from physicsnemo.mesh.primitives.planar import structured_grid + + mesh = structured_grid.load(n_x=8, n_y=8) + mesh = Mesh(points=mesh.points.to(torch.float64), cells=mesh.cells) + + v_field = torch.stack([-mesh.points[:, 1], mesh.points[:, 0]], dim=-1) + div_v = compute_divergence_points_dec(mesh, v_field) + interior = self._interior_mask_2d(mesh) + + assert torch.allclose( + div_v[interior], + torch.zeros_like(div_v[interior]), + atol=1e-12, + ) + + ### 3D correctness test (tetrahedral mesh) ############################### + + def test_3d_div_identity_interior(self, simple_tet_mesh): + """div(position) = 3 at the interior vertex of a 3D tet mesh.""" + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_dec + + mesh = Mesh( + points=simple_tet_mesh.points.to(torch.float64), + cells=simple_tet_mesh.cells, + ) + div_v = compute_divergence_points_dec(mesh, mesh.points.clone()) + + # Vertex 4 at (0.5, 0.5, 0.5) is the interior vertex + assert torch.isclose( + div_v[4], torch.tensor(3.0, dtype=torch.float64), atol=1e-12 + ) + + ### 3D regression test: must not crash on meshes where n_edges != n_faces + + def test_3d_no_crash_on_real_mesh(self): + """Divergence must run without error on a real 3D tet mesh.""" + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_dec + from physicsnemo.mesh.primitives.procedural import lumpy_ball + + mesh = lumpy_ball.load(n_shells=2, subdivisions=1) + v_field = mesh.points.clone() + div_v = compute_divergence_points_dec(mesh, v_field) + + assert div_v.shape == (mesh.n_points,) + assert torch.isfinite(div_v).all() + + ### Shape and dtype tests ################################################ + + def test_output_shape_and_finiteness_2d(self): + """Basic smoke test: correct shape and finite values on 2D mesh.""" + from physicsnemo.mesh.calculus.divergence import compute_divergence_points_dec + + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [0.5, 0.5]]) + cells = torch.tensor([[0, 1, 3], [0, 2, 3], [1, 2, 3]]) + mesh = Mesh(points=points, cells=cells) + + div_v = compute_divergence_points_dec(mesh, points.clone()) + + assert div_v.shape == (mesh.n_points,) + assert torch.isfinite(div_v).all() + + +############################################################################### +# Method Combinations Tests +############################################################################### + + +class TestDerivativesMethodCombinations: + """Test all method × gradient_type combinations.""" + + def test_dec_method_extrinsic_gradient(self): + """Test method='dec' with gradient_type='extrinsic'.""" + mesh = procedural.lumpy_sphere.load(radius=1.0, subdivisions=2) + mesh.point_data["test"] = torch.ones(mesh.n_points) + + mesh_grad = mesh.compute_point_derivatives( + keys="test", method="dec", gradient_type="extrinsic" + ) + + assert "test_gradient" in mesh_grad.point_data.keys() + + def test_dec_method_both_gradients(self): + """Test method='dec' with gradient_type='both'.""" + mesh = procedural.lumpy_sphere.load(radius=1.0, subdivisions=2) + mesh.point_data["test"] = torch.ones(mesh.n_points) + + mesh_grad = mesh.compute_point_derivatives( + keys="test", method="dec", gradient_type="both" + ) + + assert "test_gradient_extrinsic" in mesh_grad.point_data.keys() + assert "test_gradient_intrinsic" in mesh_grad.point_data.keys() + + +class TestCellDerivativesGradientTypes: + """Test cell derivatives with different gradient types.""" + + def test_cell_extrinsic_gradient(self, simple_tet_mesh): + """Test cell gradient with gradient_type='extrinsic'.""" + mesh = simple_tet_mesh + mesh.cell_data["test"] = torch.ones(mesh.n_cells) + + mesh_grad = mesh.compute_cell_derivatives( + keys="test", gradient_type="extrinsic" + ) + + assert "test_gradient" in mesh_grad.cell_data.keys() + + def test_cell_both_gradients(self, simple_tet_mesh): + """Test cell gradient with gradient_type='both'.""" + mesh = simple_tet_mesh + mesh.cell_data["test"] = torch.ones(mesh.n_cells) + + mesh_grad = mesh.compute_cell_derivatives(keys="test", gradient_type="both") + + assert "test_gradient_extrinsic" in mesh_grad.cell_data.keys() + assert "test_gradient_intrinsic" in mesh_grad.cell_data.keys() + + +############################################################################### +# n-Dimensional DEC Laplacian Tests +############################################################################### + + +class TestLaplacian1D: + """Test DEC Laplacian on 1D edge meshes. + + For 1D manifolds, the Laplace-Beltrami operator reduces to the second + arc-length derivative: Delta f = d^2 f / ds^2. + + The FEM stiffness cotangent weights give w_ij = 1/|edge| for 1D edges, + which produces the standard finite-difference second derivative when + combined with the dual volume normalization (half the sum of adjacent + edge lengths). + """ + + def test_laplacian_x_squared_uniform_1d(self): + """Delta(x^2) = 2 on a uniform 1D grid in 1D ambient space.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + n = 21 + x = torch.linspace(0.0, 1.0, n, dtype=torch.float64) + points = x.unsqueeze(-1) # (n, 1) + cells = torch.stack([torch.arange(n - 1), torch.arange(1, n)], dim=1) + mesh = Mesh(points=points, cells=cells) + + f = x**2 + lap = compute_laplacian_points_dec(mesh, f) + + # Interior points (not boundary) should give exactly 2 + interior = slice(1, -1) + assert torch.allclose( + lap[interior], torch.full_like(lap[interior], 2.0), atol=1e-8 + ), f"Interior Laplacian: {lap[interior]}" + + def test_laplacian_x_squared_nonuniform_1d(self): + """Delta(x^2) = 2 on a non-uniform 1D grid.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + # Non-uniform spacing + x = torch.tensor([0.0, 0.1, 0.25, 0.5, 0.6, 0.85, 1.0], dtype=torch.float64) + points = x.unsqueeze(-1) # (7, 1) + n = len(x) + cells = torch.stack([torch.arange(n - 1), torch.arange(1, n)], dim=1) + mesh = Mesh(points=points, cells=cells) + + f = x**2 + lap = compute_laplacian_points_dec(mesh, f) + + # Interior points should give exactly 2 (FEM cotangent weights are + # exact for quadratics on 1D meshes, regardless of spacing) + interior = slice(1, -1) + assert torch.allclose( + lap[interior], torch.full_like(lap[interior], 2.0), atol=1e-8 + ), f"Interior Laplacian: {lap[interior]}" + + def test_laplacian_1d_in_2d_ambient(self): + """Delta(x^2) = 2 on a 1D line segment embedded in 2D.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + n = 15 + t = torch.linspace(0.0, 1.0, n, dtype=torch.float64) + # Line along x-axis in 2D + points = torch.stack([t, torch.zeros_like(t)], dim=1) # (n, 2) + cells = torch.stack([torch.arange(n - 1), torch.arange(1, n)], dim=1) + mesh = Mesh(points=points, cells=cells) + + f = points[:, 0] ** 2 # x^2 + lap = compute_laplacian_points_dec(mesh, f) + + interior = slice(1, -1) + assert torch.allclose( + lap[interior], torch.full_like(lap[interior], 2.0), atol=1e-8 + ), f"Interior Laplacian: {lap[interior]}" + + def test_laplacian_1d_in_3d_ambient(self): + """Delta(s^2) = 2 on a 1D line segment embedded in 3D.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + n = 15 + t = torch.linspace(0.0, 1.0, n, dtype=torch.float64) + # Line along (1,1,1) direction in 3D + direction = torch.tensor([1.0, 1.0, 1.0], dtype=torch.float64) + direction = direction / direction.norm() + points = t.unsqueeze(-1) * direction.unsqueeze(0) # (n, 3) + cells = torch.stack([torch.arange(n - 1), torch.arange(1, n)], dim=1) + mesh = Mesh(points=points, cells=cells) + + # Arc-length parameter is t (since |direction| = 1 and spacing is uniform) + f = t**2 + lap = compute_laplacian_points_dec(mesh, f) + + interior = slice(1, -1) + assert torch.allclose( + lap[interior], torch.full_like(lap[interior], 2.0), atol=1e-8 + ), f"Interior Laplacian: {lap[interior]}" + + def test_laplacian_linear_zero_1d(self): + """Delta(linear) = 0 on a 1D mesh.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + n = 10 + x = torch.linspace(0.0, 2.0, n, dtype=torch.float64) + points = x.unsqueeze(-1) + cells = torch.stack([torch.arange(n - 1), torch.arange(1, n)], dim=1) + mesh = Mesh(points=points, cells=cells) + + f = 3.0 * x + 7.0 # Linear function + lap = compute_laplacian_points_dec(mesh, f) + + # Interior points: Laplacian of linear function = 0 + interior = slice(1, -1) + assert torch.allclose( + lap[interior], torch.zeros_like(lap[interior]), atol=1e-8 + ), f"Interior Laplacian of linear: {lap[interior]}" + + def test_laplacian_constant_zero_1d(self): + """Delta(constant) = 0 on a 1D mesh.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + + n = 8 + x = torch.linspace(0.0, 1.0, n, dtype=torch.float64) + points = x.unsqueeze(-1) + cells = torch.stack([torch.arange(n - 1), torch.arange(1, n)], dim=1) + mesh = Mesh(points=points, cells=cells) + + f = torch.full((n,), 42.0, dtype=torch.float64) + lap = compute_laplacian_points_dec(mesh, f) + + assert torch.allclose(lap, torch.zeros_like(lap), atol=1e-10) + + +class TestLaplacian3D: + """Test DEC Laplacian on 3D tetrahedral meshes. + + Uses the FEM stiffness matrix cotangent weights, which give exact + dihedral-angle-based weights for tetrahedra. The Kuhn triangulation + of a uniform grid has sufficient symmetry for the discrete Laplacian + to be exact for quadratic functions at interior vertices. + """ + + def test_laplacian_constant_zero_3d(self): + """Delta(constant) = 0 on a tetrahedral mesh.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + from physicsnemo.mesh.primitives.volumes.cube_volume import load + + mesh = load(size=1.0, subdivisions=3) + f = torch.ones(mesh.n_points, dtype=mesh.points.dtype) + lap = compute_laplacian_points_dec(mesh, f) + + assert torch.allclose(lap, torch.zeros_like(lap), atol=1e-5), ( + f"Laplacian of constant: max abs = {lap.abs().max():.2e}" + ) + + def test_laplacian_linear_zero_3d(self): + """Delta(linear) = 0 at interior points of a tetrahedral mesh.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + from physicsnemo.mesh.primitives.volumes.cube_volume import load + + mesh = load(size=2.0, subdivisions=4) + # Linear function: f = 2x + 3y - z + 5 + f = 2.0 * mesh.points[:, 0] + 3.0 * mesh.points[:, 1] - mesh.points[:, 2] + 5.0 + lap = compute_laplacian_points_dec(mesh, f) + + # Interior points: far from the cube boundary + half_size = 1.0 # cube has size 2, so boundary is at ±1 + is_interior = (mesh.points.abs() < half_size * 0.8).all(dim=-1) + assert is_interior.sum() > 10, ( + "Need enough interior points for a meaningful test" + ) + + interior_lap = lap[is_interior] + assert torch.allclose( + interior_lap, torch.zeros_like(interior_lap), atol=1e-4 + ), ( + f"Laplacian of linear at interior: " + f"max abs = {interior_lap.abs().max():.2e}, " + f"mean abs = {interior_lap.abs().mean():.2e}" + ) + + def test_laplacian_r_squared_3d(self): + """Delta(x^2 + y^2 + z^2) = 6 at interior points of a tetrahedral mesh. + + On the Kuhn triangulation of a uniform grid, the FEM cotangent + Laplacian is exact for quadratics at interior vertices due to + the stencil symmetry. + """ + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + from physicsnemo.mesh.primitives.volumes.cube_volume import load + + mesh = load(size=2.0, subdivisions=5) + f = (mesh.points**2).sum(dim=-1) # x^2 + y^2 + z^2 + lap = compute_laplacian_points_dec(mesh, f) + + # Interior points only (boundary vertices have incomplete stencils) + half_size = 1.0 + is_interior = (mesh.points.abs() < half_size * 0.8).all(dim=-1) + assert is_interior.sum() > 20, "Need enough interior points" + + interior_lap = lap[is_interior] + expected = torch.full_like(interior_lap, 6.0) + + # Kuhn triangulation with subdivisions=5 gives near-exact results for + # quadratics at interior vertices (FEM cotangent weights are exact on + # symmetric stencils). + assert torch.allclose(interior_lap, expected, atol=0.05), ( + f"Laplacian of r^2 at interior: " + f"mean = {interior_lap.mean():.4f}, " + f"max deviation = {(interior_lap - 6.0).abs().max():.4f}" + ) + + def test_laplacian_single_component_3d(self): + """Delta(x^2) = 2 at interior points of a tetrahedral mesh.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + from physicsnemo.mesh.primitives.volumes.cube_volume import load + + mesh = load(size=2.0, subdivisions=5) + f = mesh.points[:, 0] ** 2 # x^2 only + lap = compute_laplacian_points_dec(mesh, f) + + # Interior points + half_size = 1.0 + is_interior = (mesh.points.abs() < half_size * 0.8).all(dim=-1) + + interior_lap = lap[is_interior] + expected = torch.full_like(interior_lap, 2.0) + + # Kuhn triangulation with subdivisions=5; FEM cotangent weights are + # near-exact for single-variable quadratics at interior vertices. + assert torch.allclose(interior_lap, expected, atol=0.05), ( + f"Laplacian of x^2 at interior: " + f"mean = {interior_lap.mean():.4f}, " + f"max deviation = {(interior_lap - 2.0).abs().max():.4f}" + ) + + def test_laplacian_vector_field_3d(self): + """DEC Laplacian works on vector fields over tetrahedral meshes.""" + from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec + from physicsnemo.mesh.primitives.volumes.cube_volume import load + + mesh = load(size=1.0, subdivisions=3) + + # Linear vector field: Laplacian should be zero + vector_field = mesh.points.clone() # (n_points, 3) + lap = compute_laplacian_points_dec(mesh, vector_field) + + assert lap.shape == vector_field.shape + + # Interior points should have near-zero Laplacian + half_size = 0.5 + is_interior = (mesh.points.abs() < half_size * 0.8).all(dim=-1) + interior_lap = lap[is_interior] + assert torch.allclose(interior_lap, torch.zeros_like(interior_lap), atol=1e-4) + + +class TestCotanWeightsFEM: + """Verify FEM cotangent weights against analytically known values. + + For 2D triangle meshes, the FEM stiffness matrix approach produces + weights equal to (1/2)(cot alpha + cot beta) for each edge, where + alpha and beta are the angles opposite the edge in the two adjacent + triangles. + """ + + def test_equilateral_triangle_weights(self): + """FEM weights for an equilateral triangle match cot(60 deg)/2.""" + from physicsnemo.mesh.geometry.dual_meshes import ( + compute_cotan_weights_fem, + ) + + # Equilateral triangle: all angles = 60 deg, cot(60) = 1/sqrt(3) + h = (3**0.5) / 2 + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, h]], + dtype=torch.float64, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.long) + mesh = Mesh(points=points, cells=cells) + + weights, edges = compute_cotan_weights_fem(mesh) + + # Each edge is boundary (1 triangle), weight = cot(60 deg) / 2 + expected_weight = (1.0 / (3**0.5)) / 2.0 + assert torch.allclose( + weights, torch.full_like(weights, expected_weight), atol=1e-10 + ), f"Expected all weights ~{expected_weight:.6f}, got {weights}" + + def test_right_triangle_weights(self): + """FEM weights for a right triangle match known cotangent values.""" + from physicsnemo.mesh.geometry.dual_meshes import ( + compute_cotan_weights_fem, + ) + + # Right triangle: 90 deg at origin, 45 deg at the other two + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], + dtype=torch.float64, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.long) + mesh = Mesh(points=points, cells=cells) + + weights, edges = compute_cotan_weights_fem(mesh) + + # Expected (boundary, 1 triangle): + # edge [0,1]: opposite angle at v2 = 45 deg, cot(45)=1 -> w = 0.5 + # edge [0,2]: opposite angle at v1 = 45 deg, cot(45)=1 -> w = 0.5 + # edge [1,2]: opposite angle at v0 = 90 deg, cot(90)=0 -> w = 0.0 + expected = {(0, 1): 0.5, (0, 2): 0.5, (1, 2): 0.0} + for i, edge in enumerate(edges): + key = (int(edge[0]), int(edge[1])) + assert abs(weights[i].item() - expected[key]) < 1e-10, ( + f"Edge {key}: expected {expected[key]:.4f}, got {weights[i]:.4f}" + ) + + def test_weights_on_3d_surface(self): + """FEM weights are well-defined on a surface mesh in 3D.""" + from physicsnemo.mesh.geometry.dual_meshes import ( + compute_cotan_weights_fem, + ) + from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + + mesh = sphere_icosahedral.load(subdivisions=2) + mesh = Mesh( + points=mesh.points.to(torch.float64), + cells=mesh.cells, + ) + + weights, edges = compute_cotan_weights_fem(mesh) + + # Sanity: icosahedral sphere has all positive cotan weights (Delaunay) + assert (weights > -1e-8).all(), ( + f"Unexpected large negative weight: {weights.min():.2e}" + ) + # All edges accounted for + assert edges.shape[1] == 2 + assert len(weights) == len(edges) + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/test/mesh/calculus/test_pca_tangent.py b/test/mesh/calculus/test_pca_tangent.py new file mode 100644 index 0000000000..d853bab9ad --- /dev/null +++ b/test/mesh/calculus/test_pca_tangent.py @@ -0,0 +1,362 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for PCA-based tangent space estimation.""" + +import pytest +import torch + +from physicsnemo.mesh import Mesh +from physicsnemo.mesh.calculus._pca_tangent import ( + estimate_tangent_space_pca, + project_gradient_to_tangent_space_pca, +) + + +@pytest.fixture +def device(): + """Test on CPU.""" + return "cpu" + + +class TestPCATangentSpace: + """Tests for PCA tangent space estimation.""" + + def test_curve_in_3d_tangent_space(self, device): + """Test tangent space estimation for curve in 3D.""" + # Straight line in 3D + t = torch.linspace(0, 1, 10, device=device) + points = torch.stack([t, torch.zeros_like(t), torch.zeros_like(t)], dim=-1) + + cells = torch.stack( + [torch.arange(9, device=device), torch.arange(1, 10, device=device)], dim=-1 + ) + + mesh = Mesh(points=points, cells=cells) + + tangent_basis, normal_basis = estimate_tangent_space_pca(mesh) + + # Should have shape (n_points, 1, 3) for tangent + assert tangent_basis.shape == (10, 1, 3) + assert normal_basis.shape == (10, 2, 3) + + # Tangent should align with x-axis for straight line + # (up to sign and for interior points with enough neighbors) + # Check middle points + for i in range(2, 8): + tangent = tangent_basis[i, 0] + # Should be primarily in x direction + assert torch.abs(tangent[0]) > 0.9 # Mostly x-component + + def test_circle_in_3d_tangent_space(self, device): + """Test tangent space for circle in 3D.""" + n = 20 + theta = torch.linspace(0, 2 * torch.pi, n + 1, device=device)[:-1] + + # Circle in xy-plane + points = torch.stack( + [ + torch.cos(theta), + torch.sin(theta), + torch.zeros_like(theta), + ], + dim=-1, + ) + + # Closed loop + cells = torch.stack( + [ + torch.arange(n, device=device), + torch.roll(torch.arange(n, device=device), -1), + ], + dim=-1, + ) + + mesh = Mesh(points=points, cells=cells) + + tangent_basis, normal_basis = estimate_tangent_space_pca(mesh) + + # Tangent space is 1D (curve) + assert tangent_basis.shape == (n, 1, 3) + assert normal_basis.shape == (n, 2, 3) + + # Tangents should be unit vectors + tangent_norms = torch.norm(tangent_basis, dim=-1) + assert torch.allclose(tangent_norms, torch.ones_like(tangent_norms), atol=1e-5) + + # Normal space should span the perpendicular plane + # For circle in xy-plane, one normal should be mostly z + for i in range(n): + normals = normal_basis[i] # (2, 3) + # Check that at least one normal has significant z-component + z_components = torch.abs(normals[:, 2]) + assert z_components.max() > 0.7 # One normal ~aligned with z + + def test_helix_tangent_space(self, device): + """Test tangent space for helix (curve in 3D).""" + t = torch.linspace(0, 4 * torch.pi, 50, device=device) + + # Helix + points = torch.stack( + [ + torch.cos(t), + torch.sin(t), + 0.1 * t, # Pitch + ], + dim=-1, + ) + + cells = torch.stack( + [ + torch.arange(49, device=device), + torch.arange(1, 50, device=device), + ], + dim=-1, + ) + + mesh = Mesh(points=points, cells=cells) + + tangent_basis, normal_basis = estimate_tangent_space_pca(mesh) + + # Shapes + assert tangent_basis.shape == (50, 1, 3) + assert normal_basis.shape == (50, 2, 3) + + # All tangents should be unit vectors + tangent_norms = torch.norm(tangent_basis, dim=-1) + assert torch.allclose(tangent_norms, torch.ones_like(tangent_norms), atol=1e-4) + + def test_surface_in_3d_tangent_space(self, device): + """Test PCA tangent space estimation works for surface in 3D (codimension-1). + + Note: While codimension-1 has more efficient normal-based methods, + the PCA method should still work correctly for these cases. + """ + + ### Create an equilateral triangle in the XY plane + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, (3**0.5) / 2, 0.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + mesh = Mesh(points=points, cells=cells) + + ### Estimate tangent space using PCA + tangent_basis, normal_basis = estimate_tangent_space_pca(mesh, k_neighbors=2) + + ### Verify shapes + assert tangent_basis.shape == ( + 3, + 2, + 3, + ) # (n_points, n_manifold_dims, n_spatial_dims) + assert normal_basis.shape == ( + 3, + 1, + 3, + ) # (n_points, codimension, n_spatial_dims) + + ### For a triangle in the XY plane: + # Tangent space should span XY directions + # Normal space should point in Z direction + + ### Check that tangent vectors are orthogonal to normal + for i in range(3): + for j in range(2): + tangent_vec = tangent_basis[i, j] + normal_vec = normal_basis[i, 0] + + # Tangent and normal should be orthogonal + dot_product = torch.dot(tangent_vec, normal_vec) + assert torch.abs(dot_product) < 1e-4, ( + f"Tangent {j} at point {i} not orthogonal to normal" + ) + + ### Check that normal points primarily in Z direction (since triangle is in XY plane) + for i in range(3): + normal_vec = normal_basis[i, 0] + # Z component should dominate + assert torch.abs(normal_vec[2]) > 0.9, ( + f"Normal at point {i} should point in Z direction" + ) + + ### Check that tangent vectors are unit length + tangent_norms = torch.norm(tangent_basis, dim=-1) + assert torch.allclose(tangent_norms, torch.ones_like(tangent_norms), atol=1e-4) + + +class TestGradientProjection: + """Tests for gradient projection to tangent space.""" + + def test_project_gradient_curve_3d(self, device): + """Test projecting gradient onto curve tangent space.""" + t = torch.linspace(0, 1, 10, device=device) + points = torch.stack([t, torch.zeros_like(t), torch.zeros_like(t)], dim=-1) + + cells = torch.stack( + [ + torch.arange(9, device=device), + torch.arange(1, 10, device=device), + ], + dim=-1, + ) + + mesh = Mesh(points=points, cells=cells) + + # Random 3D gradient + torch.manual_seed(42) + gradient = torch.randn(10, 3, device=device) + + # Project to tangent space + projected = project_gradient_to_tangent_space_pca(mesh, gradient) + + # Should have same shape + assert projected.shape == gradient.shape + + # Projected gradient should have smaller or equal norm + proj_norms = torch.norm(projected, dim=-1) + orig_norms = torch.norm(gradient, dim=-1) + + # All projections should not increase norm + assert torch.all(proj_norms <= orig_norms + 1e-5) + + def test_project_gradient_reduces_norm(self, device): + """Test that projection removes normal component.""" + # Circle in xy-plane + n = 20 + theta = torch.linspace(0, 2 * torch.pi, n + 1, device=device)[:-1] + + points = torch.stack( + [ + torch.cos(theta), + torch.sin(theta), + torch.zeros_like(theta), + ], + dim=-1, + ) + + cells = torch.stack( + [ + torch.arange(n, device=device), + torch.roll(torch.arange(n, device=device), -1), + ], + dim=-1, + ) + + mesh = Mesh(points=points, cells=cells) + + # Gradient with z-component (perpendicular to circle) + gradient = torch.randn(n, 3, device=device) + gradient[:, 2] = 1.0 # Add significant z-component + + # Project + projected = project_gradient_to_tangent_space_pca(mesh, gradient) + + # Z-component should be significantly reduced for interior points + # (boundary points may not have enough neighbors) + for i in range(5, 15): # Check interior points + assert torch.abs(projected[i, 2]) < torch.abs(gradient[i, 2]) + + def test_projection_orthogonality(self, device): + """Test that projected gradient is orthogonal to normal space.""" + t = torch.linspace(0, 1, 10, device=device) + points = torch.stack([t, t**2, torch.zeros_like(t)], dim=-1) + + cells = torch.stack( + [ + torch.arange(9, device=device), + torch.arange(1, 10, device=device), + ], + dim=-1, + ) + + mesh = Mesh(points=points, cells=cells) + + # Get tangent and normal bases + tangent_basis, normal_basis = estimate_tangent_space_pca(mesh) + + # Check orthogonality: tangent · normal ≈ 0 + for i in range(1, 9): # Interior points + tangent = tangent_basis[i, 0] # (3,) + normals = normal_basis[i] # (2, 3) + + # Dot products should be near zero + dots = torch.abs((normals @ tangent)) + assert torch.all(dots < 0.1) # Should be nearly orthogonal + + +class TestPCAEdgeCases: + """Edge case tests for PCA tangent space.""" + + def test_insufficient_neighbors(self, device): + """Test PCA with insufficient neighbors.""" + # Single edge (points have at most 1 neighbor) + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + # Should handle gracefully (may use fallback) + tangent_basis, normal_basis = estimate_tangent_space_pca(mesh) + + assert tangent_basis.shape == (2, 1, 3) + assert normal_basis.shape == (2, 2, 3) + + def test_degenerate_neighborhood(self, device): + """Test PCA with degenerate neighborhood (collinear neighbors).""" + # Points all along x-axis + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [2.0, 0.0, 0.0], + [3.0, 0.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1], + [1, 2], + [2, 3], + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + # Should compute tangent space even for degenerate case + tangent_basis, normal_basis = estimate_tangent_space_pca(mesh) + + assert not torch.any(torch.isnan(tangent_basis)) + assert not torch.any(torch.isnan(normal_basis)) diff --git a/test/mesh/calculus/test_sharp_flat_rigorous.py b/test/mesh/calculus/test_sharp_flat_rigorous.py new file mode 100644 index 0000000000..11656d57a0 --- /dev/null +++ b/test/mesh/calculus/test_sharp_flat_rigorous.py @@ -0,0 +1,187 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for rigorous sharp/flat operators per Hirani (2003). + +These tests verify that the sharp and flat operators follow Hirani's formulas +with support volume intersections and barycentric interpolation gradients. + +The key identities to test: +1. div(curl(V)) = 0 +2. curl(grad(f)) = 0 +3. div(grad(f)) ≈ Δf (may not be exact in discrete DEC per Hirani Section 5.9) + +References: + Hirani (2003) Chapter 5 (sharp/flat), Section 9.3 (vector identities) +""" + +import pytest +import torch + +from physicsnemo.mesh.calculus.divergence import compute_divergence_points_dec +from physicsnemo.mesh.calculus.gradient import compute_gradient_points_dec +from physicsnemo.mesh.calculus.laplacian import compute_laplacian_points_dec +from physicsnemo.mesh.mesh import Mesh + + +class TestSharpFlatProperties: + """Test basic properties of sharp and flat operators.""" + + @pytest.mark.parametrize( + "device", ["cpu", pytest.param("cuda", marks=pytest.mark.cuda)] + ) + def test_sharp_flat_on_simple_mesh(self, device): + """Test that sharp and flat operators run without errors.""" + ### Simple mesh with interior vertex + points = torch.tensor( + [ + [0.5, 0.5, 0.0], # center + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [0.0, 1.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [0, 2, 3], [0, 3, 4], [0, 4, 1]], + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + ### Test sharp + from physicsnemo.mesh.calculus._exterior_derivative import exterior_derivative_0 + from physicsnemo.mesh.calculus._sharp_flat import sharp + + f = points[:, 0] # f = x + df, edges = exterior_derivative_0(mesh, f) + grad_f = sharp(mesh, df, edges) + + assert grad_f.shape == (mesh.n_points, mesh.n_spatial_dims) + assert not torch.any(torch.isnan(grad_f)) + + ### Test flat + from physicsnemo.mesh.calculus._sharp_flat import flat + + vectors = torch.randn( + mesh.n_points, mesh.n_spatial_dims, dtype=torch.float32, device=device + ) + one_form = flat(mesh, vectors, edges) + + assert one_form.shape == (len(edges),) + assert not torch.any(torch.isnan(one_form)) + + +class TestVectorCalculusIdentities: + """Test vector calculus identities with rigorous operators.""" + + @pytest.mark.parametrize( + "device", ["cpu", pytest.param("cuda", marks=pytest.mark.cuda)] + ) + def test_div_grad_vs_laplacian_linear_function(self, device): + """Test that div(grad(f)) and Δf are close for linear functions. + + For linear f, both should give zero at interior vertices. + """ + points = torch.tensor( + [ + [0.5, 0.5, 0.0], # v0: center (interior) + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [0.0, 1.0, 0.0], + ], + dtype=torch.float64, + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [0, 2, 3], [0, 3, 4], [0, 4, 1]], + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + ### Linear function: Δf = 0 everywhere + f = points[:, 0] # f = x + + grad_f = compute_gradient_points_dec(mesh, f) + div_grad_f = compute_divergence_points_dec(mesh, grad_f) + lap_f = compute_laplacian_points_dec(mesh, f) + + ### At interior vertex, both should be ~0 for linear function + assert abs(div_grad_f[0]) < 0.1, ( + f"div(grad(linear)) = {div_grad_f[0].item():.4f}, expected ≈ 0" + ) + assert abs(lap_f[0]) < 0.01, f"Δ(linear) = {lap_f[0].item():.4f}, expected ≈ 0" + + @pytest.mark.parametrize( + "device", ["cpu", pytest.param("cuda", marks=pytest.mark.cuda)] + ) + def test_div_grad_approximate_laplacian(self, device): + """Test that div(grad(f)) is approximately equal to Δf at interior vertices. + + In discrete DEC, sharp and flat are NOT exact inverses (Hirani + Prop. 5.5.3), so div(grad(f)) won't exactly equal Δf. But they should + agree within an order of magnitude, and the ratio converges to 1.0 + under mesh refinement. + """ + points = torch.tensor( + [ + [0.5, 0.5, 0.0], # v0: center (interior) + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [0.0, 1.0, 0.0], + ], + dtype=torch.float64, + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [0, 2, 3], [0, 3, 4], [0, 4, 1]], + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + ### Quadratic function + f = points[:, 0] ** 2 + points[:, 1] ** 2 # Δf = 4 + + grad_f = compute_gradient_points_dec(mesh, f) + div_grad_f = compute_divergence_points_dec(mesh, grad_f) + lap_f = compute_laplacian_points_dec(mesh, f) + + # Both should have the same sign + assert ( + torch.sign(div_grad_f[0]) == torch.sign(lap_f[0]) + or torch.abs(lap_f[0]) < 0.1 + ), ( + f"div(grad(f)) and Δf have opposite signs: " + f"{div_grad_f[0].item():.2f} vs {lap_f[0].item():.2f}" + ) + + # Should be within same order of magnitude. On this small 5-vertex + # mesh the ratio is 0.5 (inherent discretization error that decreases + # with mesh refinement: 0.75 at 8x8, 0.96 at 16x16, etc.). + ratio = abs(div_grad_f[0] / lap_f[0].clamp(min=1e-10)) + assert 0.3 < ratio < 3.0, ( + f"div(grad(f)) and Δf differ by more than 3x:\n" + f"div(grad(f)) = {div_grad_f[0].item():.4f}\n" + f"Δf = {lap_f[0].item():.4f}\n" + f"Ratio = {ratio.item():.2f}\n" + f"Note: Exact equality not guaranteed in discrete DEC (Hirani Prop. 5.5.3)" + ) diff --git a/test/mesh/conftest.py b/test/mesh/conftest.py index 6ccd7254a4..67b7166735 100644 --- a/test/mesh/conftest.py +++ b/test/mesh/conftest.py @@ -29,6 +29,16 @@ ### Pytest Hooks ### +def pytest_configure(config): + """Register custom pytest markers used in mesh tests.""" + config.addinivalue_line( + "markers", "cuda: mark test as requiring CUDA (skipped if unavailable)" + ) + config.addinivalue_line( + "markers", "slow: mark test as slow-running (for optional exclusion)" + ) + + def pytest_collection_modifyitems(config, items): """Skip tests marked with 'cuda' if CUDA is not available. diff --git a/test/mesh/curvature/test_angles.py b/test/mesh/curvature/test_angles.py new file mode 100644 index 0000000000..b2f1d6761d --- /dev/null +++ b/test/mesh/curvature/test_angles.py @@ -0,0 +1,644 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Comprehensive tests for angle computation in all dimensions. + +Tests coverage for: +- Total angle sums in watertight manifolds (topological invariants) +- Solid angle computation for 3D tetrahedra +- Multi-edge vertices in 1D manifolds +- Higher-dimensional angle computations +- Edge cases and numerical stability + +This module consolidates tests from: +- Angle sum tests (topological invariants for closed curves and surfaces) +- Comprehensive angle tests (solid angles, higher dimensions, edge cases) +""" + +import pytest +import torch + +from physicsnemo.mesh.curvature._angles import compute_angles_at_vertices +from physicsnemo.mesh.curvature._utils import ( + compute_triangle_angles, + stable_angle_between_vectors, +) +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.primitives.curves import circle_2d +from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + +############################################################################### +# 1D Manifolds (Closed Curves) +############################################################################### + + +class TestClosedCurveAngleSums: + """Tests for angle sums in closed 1D manifolds (circles).""" + + def test_circle_angle_sum_clean(self, device): + """Test that clean circle has total angle sum = (n-2)π.""" + n_points = 40 + mesh = circle_2d.load(radius=1.0, n_points=n_points, device=device) + + # Compute angle sum at each vertex + angle_sums = compute_angles_at_vertices(mesh) + + # Total sum of all angles + total_angle = angle_sums.sum() + + # For a closed polygon with n vertices, sum of interior angles = (n-2)π + # This is a topological invariant + expected_total = (n_points - 2) * torch.pi + + # Should be close + relative_error = torch.abs(total_angle - expected_total) / expected_total + assert relative_error < 1e-5 # Essentially exact + + def test_circle_angle_sum_with_noise(self, device): + """Test that noisy circle maintains topological angle sum = (n-2)π.""" + # Create clean circle + n_points = 40 + mesh = circle_2d.load(radius=1.0, n_points=n_points, device=device) + + # Add radial noise: r_new = r_old + noise ∈ [0.5, 1.5] + # This keeps all points outside origin and preserves topology + torch.manual_seed(42) + radial_noise = torch.rand(mesh.n_points, device=device) - 0.5 # [-0.5, 0.5] + + # Compute radial distance for each point + radii = torch.norm(mesh.points, dim=-1) + + # Add noise to radii + new_radii = radii + radial_noise + + # Update points with new radii (preserve direction) + directions = mesh.points / radii.unsqueeze(-1) + noisy_points = directions * new_radii.unsqueeze(-1) + + # Create noisy mesh + noisy_mesh = Mesh(points=noisy_points, cells=mesh.cells) + + # Compute angles on noisy mesh + angle_sums_noisy = compute_angles_at_vertices(noisy_mesh) + total_angle_noisy = angle_sums_noisy.sum() + + # Should still be close to (n-2)π (topological property) + expected_total = (n_points - 2) * torch.pi + relative_error = torch.abs(total_angle_noisy - expected_total) / expected_total + + # Noisy perturbation changes geometry significantly for 1D curves + # Angle sums are not purely topological for curves (depend on embedding) + # With 1% noise, should still be essentially exact + assert not torch.isnan(total_angle_noisy) + assert total_angle_noisy > 0 + assert relative_error < 1e-5, ( + f"Relative error {relative_error:.3f} unexpectedly large for 1% noise" + ) + + +############################################################################### +# 2D Manifolds (Closed Surfaces) +############################################################################### + + +class TestClosedSurfaceAngleSums: + """Tests for angle sums in closed 2D manifolds (spheres).""" + + def test_sphere_angle_sum_clean(self, device): + """Test that clean sphere has total angle sum = 4π.""" + mesh = sphere_icosahedral.load(radius=1.0, subdivisions=1, device=device) + + # Compute angle sum at each vertex + angle_sums = compute_angles_at_vertices(mesh) + + # Total sum of all angles at all vertices + total_angle = angle_sums.sum() + + # For a closed surface (sphere), the total should relate to Euler characteristic + # By Gauss-Bonnet: Σ(angle_defect) = 2π * χ + # Σ(full_angle - angle_sum) = 2π * χ + # N * full_angle - Σ(angle_sum) = 2π * χ + # Σ(angle_sum) = N * 2π - 2π * χ + + # For sphere: χ = 2 + # Σ(angle_sum) = N * 2π - 2π * 2 = 2π(N - 2) + + n_points = mesh.n_points + expected_total = 2 * torch.pi * (n_points - 2) + + # Should be close + relative_error = torch.abs(total_angle - expected_total) / expected_total + assert relative_error < 1e-5 # Essentially exact + + def test_sphere_angle_sum_with_noise(self, device): + """Test that noisy sphere maintains topological angle sum.""" + # Create clean sphere + mesh = sphere_icosahedral.load(radius=1.0, subdivisions=1, device=device) + + # Add radial noise to each vertex + torch.manual_seed(42) + radial_noise = torch.rand(mesh.n_points, device=device) - 0.5 # [-0.5, 0.5] + + # Compute radial distance for each point + radii = torch.norm(mesh.points, dim=-1) + + # Add noise to radii (stays in range [0.5, 1.5]) + new_radii = radii + radial_noise + new_radii = torch.clamp(new_radii, min=0.1) # Ensure positive + + # Update points with new radii + directions = mesh.points / radii.unsqueeze(-1) + noisy_points = directions * new_radii.unsqueeze(-1) + + # Create noisy mesh (same connectivity) + noisy_mesh = Mesh(points=noisy_points, cells=mesh.cells) + + # Compute angles on both meshes + angle_sums_clean = compute_angles_at_vertices(mesh) + angle_sums_noisy = compute_angles_at_vertices(noisy_mesh) + + total_clean = angle_sums_clean.sum() + total_noisy = angle_sums_noisy.sum() + + # Topological invariant: should be approximately equal + # (Some variation due to geometry change, but topology unchanged) + relative_diff = torch.abs(total_clean - total_noisy) / total_clean + + # Should remain close despite geometric perturbation + assert relative_diff < 0.1 # Within 10% + + def test_sphere_gauss_bonnet_relation(self, device): + """Test discrete Gauss-Bonnet theorem holds.""" + mesh = sphere_icosahedral.load(radius=1.0, subdivisions=1, device=device) + + # Compute Gaussian curvature + K = mesh.gaussian_curvature_vertices + + # Compute Voronoi areas + from physicsnemo.mesh.geometry.dual_meshes import ( + compute_dual_volumes_0 as compute_voronoi_areas, + ) + + voronoi_areas = compute_voronoi_areas(mesh) + + # Integrate: ∫K dA ≈ Σ K_i * A_i + total_curvature = (K * voronoi_areas).sum() + + # For sphere: χ = 2, so ∫K dA = 2π * 2 = 4π + expected = 4 * torch.pi + + relative_error = torch.abs(total_curvature - expected) / expected + assert relative_error < 0.1 # Within 10% + + # Now test with noise + torch.manual_seed(42) + radial_noise = torch.rand(mesh.n_points, device=device) - 0.5 + radii = torch.norm(mesh.points, dim=-1) + new_radii = torch.clamp(radii + radial_noise, min=0.1) + directions = mesh.points / radii.unsqueeze(-1) + noisy_points = directions * new_radii.unsqueeze(-1) + + noisy_mesh = Mesh(points=noisy_points, cells=mesh.cells) + + K_noisy = noisy_mesh.gaussian_curvature_vertices + voronoi_areas_noisy = compute_voronoi_areas(noisy_mesh) + total_curvature_noisy = (K_noisy * voronoi_areas_noisy).sum() + + # Should still satisfy Gauss-Bonnet (topological invariant) + relative_error_noisy = torch.abs(total_curvature_noisy - expected) / expected + assert relative_error_noisy < 0.15 # Within 15% for noisy case + + +############################################################################### +# Triangle Angle Sum Property +############################################################################### + + +class TestTriangleAngleSum: + """Test that triangle interior angles sum to π.""" + + def test_triangle_angles_sum_to_pi(self, device): + """Test that angles in a triangle sum to π.""" + # Create various triangles + triangles = [ + # Equilateral + torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, (3**0.5) / 2, 0.0]], + device=device, + ), + # Right triangle + torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], device=device + ), + # Scalene + torch.tensor( + [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0], [0.5, 1.5, 0.0]], device=device + ), + ] + + for triangle_points in triangles: + # Compute all three angles + angle_0 = compute_triangle_angles( + triangle_points[0].unsqueeze(0), + triangle_points[1].unsqueeze(0), + triangle_points[2].unsqueeze(0), + )[0] + + angle_1 = compute_triangle_angles( + triangle_points[1].unsqueeze(0), + triangle_points[2].unsqueeze(0), + triangle_points[0].unsqueeze(0), + )[0] + + angle_2 = compute_triangle_angles( + triangle_points[2].unsqueeze(0), + triangle_points[0].unsqueeze(0), + triangle_points[1].unsqueeze(0), + )[0] + + total = angle_0 + angle_1 + angle_2 + + # Should sum to π + assert torch.abs(total - torch.pi) < 1e-5 + + +############################################################################### +# Angles 3D +############################################################################### + + +class TestAngles3D: + """Tests for angle computation in 3D tetrahedral meshes.""" + + def test_angles_at_vertices_3d_single_tet(self, device): + """Test angle computation for single tetrahedron.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, (3**0.5) / 2, 0.0], + [0.5, (3**0.5) / 6, ((2 / 3) ** 0.5)], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2, 3]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + # Compute solid angles at all vertices + angles = compute_angles_at_vertices(mesh) + + # All four vertices should have the same solid angle (regular tet) + assert angles.shape == (4,) + assert torch.all(angles > 0) + + # Verify they're approximately equal + assert torch.std(angles) < 0.01 # Should be nearly identical + + def test_angles_at_vertices_3d_two_tets(self, device): + """Test angle computation for two adjacent tetrahedra.""" + # Create two tets sharing a face + points = torch.tensor( + [ + [0.0, 0.0, 0.0], # 0 + [1.0, 0.0, 0.0], # 1 + [0.5, 1.0, 0.0], # 2 + [0.5, 0.5, 1.0], # 3 (above) + [0.5, 0.5, -1.0], # 4 (below) + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1, 2, 3], # Tet 1 + [0, 1, 2, 4], # Tet 2 (shares face 0,1,2) + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + angles = compute_angles_at_vertices(mesh) + + # Vertices 0, 1, 2 should have sum of two solid angles + # Vertices 3, 4 should have one solid angle each + assert angles.shape == (5,) + assert torch.all(angles > 0) + + # Shared vertices should have larger angles + assert angles[0] > angles[3] + assert angles[1] > angles[3] + assert angles[2] > angles[3] + + +############################################################################### +# Multi-Edge Vertices 1D +############################################################################### + + +class TestMultiEdgeVertices1D: + """Tests for vertices with more than 2 incident edges in 1D manifolds.""" + + def test_junction_point_three_edges(self, device): + """Test vertex where three edges meet (Y-junction).""" + # Create Y-shaped curve + points = torch.tensor( + [ + [0.0, 0.0], # Center (junction) + [1.0, 0.0], # Right + [-0.5, (3**0.5) / 2], # Upper left + [-0.5, -(3**0.5) / 2], # Lower left + ], + dtype=torch.float32, + device=device, + ) + + # Three edges meeting at vertex 0 + cells = torch.tensor( + [ + [0, 1], # To right + [0, 2], # To upper left + [0, 3], # To lower left + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + angles = compute_angles_at_vertices(mesh) + + # Center vertex should have sum of pairwise angles + # Between the three 120° separated rays: 3 * 120° = 360° = 2π + assert angles[0] > 0 + + # Each end vertex has angle from its single edge + # (For open curves, this is not well-defined, so we just check it's computed) + assert not torch.isnan(angles[1]) + assert not torch.isnan(angles[2]) + assert not torch.isnan(angles[3]) + + def test_junction_point_four_edges(self, device): + """Test vertex where four edges meet (cross junction).""" + # Create cross-shaped curve + points = torch.tensor( + [ + [0.0, 0.0], # Center (junction) + [1.0, 0.0], # Right + [-1.0, 0.0], # Left + [0.0, 1.0], # Up + [0.0, -1.0], # Down + ], + dtype=torch.float32, + device=device, + ) + + # Four edges meeting at vertex 0 + cells = torch.tensor( + [ + [0, 1], + [0, 2], + [0, 3], + [0, 4], + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + angles = compute_angles_at_vertices(mesh) + + # Center vertex with 4 edges at 90° intervals + # Sum of pairwise angles should be computed + assert angles[0] > 0 + assert not torch.isnan(angles[0]) + + +############################################################################### +# Higher Dimensional Angles +############################################################################### + + +class TestHigherDimensionalAngles: + """Tests for angle computation in higher dimensions.""" + + def test_stable_angle_between_vectors_3d(self, device): + """Test stable angle computation in 3D.""" + # Perpendicular vectors + v1 = torch.tensor([[1.0, 0.0, 0.0]], device=device) + v2 = torch.tensor([[0.0, 1.0, 0.0]], device=device) + + angle = stable_angle_between_vectors(v1, v2) + + assert torch.abs(angle - torch.pi / 2) < 1e-6 + + def test_stable_angle_between_vectors_parallel(self, device): + """Test angle between parallel vectors.""" + v1 = torch.tensor([[1.0, 0.0, 0.0]], device=device) + v2 = torch.tensor([[2.0, 0.0, 0.0]], device=device) + + angle = stable_angle_between_vectors(v1, v2) + + assert torch.abs(angle) < 1e-6 # Should be 0 + + def test_stable_angle_between_vectors_opposite(self, device): + """Test angle between opposite vectors.""" + v1 = torch.tensor([[1.0, 0.0, 0.0]], device=device) + v2 = torch.tensor([[-1.0, 0.0, 0.0]], device=device) + + angle = stable_angle_between_vectors(v1, v2) + + assert torch.abs(angle - torch.pi) < 1e-6 + + def test_stable_angle_4d(self, device): + """Test angle computation in 4D space.""" + # Two 4D vectors + v1 = torch.tensor([[1.0, 0.0, 0.0, 0.0]], device=device) + v2 = torch.tensor([[0.0, 1.0, 0.0, 0.0]], device=device) + + angle = stable_angle_between_vectors(v1, v2) + + assert torch.abs(angle - torch.pi / 2) < 1e-6 + + def test_edges_in_higher_dim_space(self, device): + """Test 1D manifold (edges) embedded in higher dimensional space.""" + # Create bent polyline in 4D space (not straight) + points = torch.tensor( + [ + [0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 0.0], + [1.0, 1.0, 0.0, 0.0], # Bent at 90 degrees + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1], + [1, 2], + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + angles = compute_angles_at_vertices(mesh) + + # Middle vertex should have angle π/2 (90 degree bend) + # Note: In higher dimensions, the angle computation uses stable_angle_between_vectors + # Interior angle = π - exterior angle + assert angles[1] > 0 # Should be computed + + # For a 90° bend, interior angle should be π/2 + assert torch.abs(angles[1] - torch.pi / 2) < 0.1 + + +############################################################################### +# Angle Edge Cases +############################################################################### + + +class TestAngleEdgeCases: + """Tests for edge cases in angle computation.""" + + def test_empty_mesh(self, device): + """Test angle computation on empty mesh.""" + points = torch.zeros((5, 3), device=device) + cells = torch.zeros((0, 3), dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + angles = compute_angles_at_vertices(mesh) + + # All angles should be zero (no incident cells) + assert torch.allclose(angles, torch.zeros(5, device=device)) + + def test_isolated_vertex(self, device): + """Test that isolated vertices have zero angle.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [5.0, 5.0], # Isolated + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + angles = compute_angles_at_vertices(mesh) + + # First three vertices have angles from triangle + assert angles[0] > 0 + assert angles[1] > 0 + assert angles[2] > 0 + + # Isolated vertex should have zero angle + assert angles[3] == 0 + + def test_single_edge_open_curve(self, device): + """Test angle computation for single open edge.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + angles = compute_angles_at_vertices(mesh) + + # Each endpoint has only one incident edge + # Angle is not well-defined for single edge, but should be computed + assert angles.shape == (2,) + # Both should be zero (no angle to measure) + assert angles[0] == 0 + assert angles[1] == 0 + + def test_nearly_degenerate_triangle(self, device): + """Test angle computation for nearly degenerate triangle.""" + # Very flat triangle + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1e-6, 0.0], # Nearly collinear + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + angles = compute_angles_at_vertices(mesh) + + # Should not produce NaN + assert not torch.any(torch.isnan(angles)) + + # Two vertices should have angles close to π/2 (nearly 90°) + # One vertex should have angle close to 0 (nearly 0°) + # Sum should still be close to π + total = angles.sum() + assert torch.abs(total - torch.pi) < 1e-3 + + def test_2d_manifold_in_higher_dim(self, device): + """Test triangle mesh embedded in higher dimensional space.""" + # Triangle in 4D space + points = torch.tensor( + [ + [0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 0.0], + [0.5, (3**0.5) / 2, 0.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + angles = compute_angles_at_vertices(mesh) + + # Should compute angles correctly (equilateral triangle) + # Each angle should be π/3 + expected = torch.pi / 3 + assert torch.allclose( + angles, torch.full((3,), expected, device=device), atol=1e-5 + ) + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/test/mesh/curvature/test_curvature.py b/test/mesh/curvature/test_curvature.py new file mode 100644 index 0000000000..5ef9db3799 --- /dev/null +++ b/test/mesh/curvature/test_curvature.py @@ -0,0 +1,780 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Comprehensive tests for curvature computations. + +Tests Gaussian and mean curvature on analytical test cases including +spheres, planes, cylinders, and tori. Validates convergence with subdivision. +""" + +import pytest +import torch +import torch.nn.functional as F + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.primitives.surfaces import icosahedron_surface +from physicsnemo.mesh.utilities._cache import get_cached + +### Mesh Generators + + +def create_sphere_mesh(radius=1.0, subdivisions=0, device="cpu"): + """Create a triangulated sphere using icosahedron Loop subdivision. + + Args: + radius: Sphere radius + subdivisions: Number of Loop subdivision levels (0 = icosahedron) + device: Device to create mesh on + + Returns: + Mesh representing a sphere of given radius + """ + mesh = icosahedron_surface.load(radius=1.0, device=device) + mesh = mesh.subdivide(subdivisions, "loop") + + # Project to perfect sphere + mesh.points = F.normalize(mesh.points, dim=-1) * radius + + return mesh + + +def create_plane_mesh(size=2.0, n_subdivisions=2, device="cpu"): + """Create a flat triangulated plane.""" + n = 2**n_subdivisions + 1 + + # Create grid of points + x = torch.linspace(-size / 2, size / 2, n, device=device) + y = torch.linspace(-size / 2, size / 2, n, device=device) + xx, yy = torch.meshgrid(x, y, indexing="ij") + + points = torch.stack( + [xx.flatten(), yy.flatten(), torch.zeros_like(xx.flatten())], dim=1 + ) + + # Create triangular cells + cells = [] + for i in range(n - 1): + for j in range(n - 1): + idx = i * n + j + # Two triangles per quad + cells.append([idx, idx + 1, idx + n]) + cells.append([idx + 1, idx + n + 1, idx + n]) + + cells = torch.tensor(cells, dtype=torch.int64, device=device) + return Mesh(points=points, cells=cells) + + +def create_line_curve_2d(n_points=10, curvature=1.0, device="cpu"): + """Create a 1D circular arc in 2D (for testing 1D curvature).""" + # Circle of given curvature (κ = 1/r) + radius = 1.0 / curvature + theta = torch.linspace(0, torch.pi / 2, n_points, device=device) + + points = torch.stack( + [ + radius * torch.cos(theta), + radius * torch.sin(theta), + ], + dim=1, + ) + + # Create edge cells + cells = torch.stack( + [ + torch.arange(n_points - 1, device=device), + torch.arange(1, n_points, device=device), + ], + dim=1, + ) + + return Mesh(points=points, cells=cells) + + +### Test Gaussian Curvature + + +class TestGaussianCurvature: + """Tests for Gaussian curvature computation.""" + + def test_sphere_gaussian_curvature(self, device): + """Test that sphere has constant positive Gaussian curvature K = 1/r².""" + radius = 2.0 + mesh = create_sphere_mesh(radius=radius, subdivisions=2, device=device) + + K_vertices = mesh.gaussian_curvature_vertices + + # Expected: K = 1/r² for all vertices + expected_K = 1.0 / (radius**2) + + # With subdivision level 2, Loop subdivision gives excellent accuracy + mean_K = K_vertices.mean() + assert torch.abs(mean_K - expected_K) / expected_K < 0.02 # Within 2% + + # All should be positive + assert torch.all(K_vertices > 0) + + def test_plane_gaussian_curvature(self, device): + """Test that flat plane has zero Gaussian curvature at interior vertices.""" + mesh = create_plane_mesh(n_subdivisions=2, device=device) + + K_vertices = mesh.gaussian_curvature_vertices + + # Interior vertices should have zero curvature + # For a 5x5 grid (n_subdivisions=2), interior vertices are those not on boundary + # Grid size: 2^2 + 1 = 5 + n = 5 + + # Find interior vertices (not on edges of grid) + interior_mask = torch.zeros(mesh.n_points, dtype=torch.bool, device=device) + for i in range(n): + for j in range(n): + idx = i * n + j + if 0 < i < n - 1 and 0 < j < n - 1: + interior_mask[idx] = True + + # Check interior vertices have zero curvature + interior_K = K_vertices[interior_mask] + assert torch.allclose(interior_K, torch.zeros_like(interior_K), atol=1e-5) + + def test_gaussian_curvature_convergence(self, device): + """Test that Gaussian curvature converges with subdivision.""" + radius = 1.0 + expected_K = 1.0 / (radius**2) + + errors = [] + for subdivisions in [0, 1, 2]: + mesh = create_sphere_mesh( + radius=radius, subdivisions=subdivisions, device=device + ) + K_vertices = mesh.gaussian_curvature_vertices + mean_K = K_vertices.mean() + error = torch.abs(mean_K - expected_K) + errors.append(error.item()) + + # Error should decrease with subdivision + assert errors[1] < errors[0] + assert errors[2] < errors[1] + + def test_gauss_bonnet_theorem(self, device): + """Test discrete Gauss-Bonnet theorem: ∫K dA = 2πχ.""" + mesh = create_sphere_mesh(radius=1.0, subdivisions=1, device=device) + + K_vertices = mesh.gaussian_curvature_vertices + + # Compute Voronoi areas for integration + from physicsnemo.mesh.geometry.dual_meshes import compute_dual_volumes_0 + + voronoi_areas = compute_dual_volumes_0(mesh) + + # Integrate: ∫K dA ≈ Σ K_i * A_i + total_curvature = (K_vertices * voronoi_areas).sum() + + # For a sphere: χ = 2, so ∫K dA = 4π + expected = 4 * torch.pi + + # Should be close (within a few percent for subdivision level 1) + relative_error = torch.abs(total_curvature - expected) / expected + assert relative_error < 0.1 # Within 10% + + def test_gaussian_curvature_cells(self, device): + """Test cell-based Gaussian curvature (dual mesh).""" + mesh = create_sphere_mesh(radius=1.0, subdivisions=1, device=device) + + K_cells = mesh.gaussian_curvature_cells + + # Should have curvature for all cells + assert K_cells.shape == (mesh.n_cells,) + + # Should be positive for sphere + assert torch.all(K_cells > 0) + + def test_pentagonal_vertex_convergence(self, device): + """Test that pentagonal vertices converge correctly on icosphere. + + The icosahedron has 12 pentagonal vertices (valence 5) which remain + pentagonal under Loop subdivision. With proper Voronoi areas, these + should converge to the same curvature as hexagonal vertices (valence 6). + + This test verifies the fix for the systematic error at irregular vertices. + """ + radius = 1.0 + expected_K = 1.0 / (radius**2) + + # Test at high subdivision level + mesh = create_sphere_mesh(radius=radius, subdivisions=5, device=device) + K_vertices = mesh.gaussian_curvature_vertices + + # Identify pentagonal vs hexagonal vertices by valence + from physicsnemo.mesh.neighbors import get_point_to_cells_adjacency + + adjacency = get_point_to_cells_adjacency(mesh) + valences = adjacency.offsets[1:] - adjacency.offsets[:-1] + + pentagonal_mask = valences == 5 + hexagonal_mask = valences == 6 + + # Check that both types converge to K=1.0 + K_pent = K_vertices[pentagonal_mask] + assert len(K_pent) == 12, "Icosphere should have exactly 12 pentagonal vertices" + pent_error = torch.abs(K_pent.mean() - expected_K).item() + assert pent_error < 0.02, f"Pentagonal vertex error too large: {pent_error:.6f}" + + K_hex = K_vertices[hexagonal_mask] + hex_error = torch.abs(K_hex.mean() - expected_K).item() + assert hex_error < 0.02, f"Hexagonal vertex error too large: {hex_error:.6f}" + + # Pentagonal and hexagonal vertices should have similar curvature + pent_hex_diff = torch.abs(K_pent.mean() - K_hex.mean()).item() + assert pent_hex_diff < 0.01, ( + f"Pentagonal and hexagonal vertices differ too much: {pent_hex_diff:.6f}" + ) + + def test_voronoi_areas_tile_surface(self, device): + """Test that Voronoi areas perfectly tile the mesh surface. + + The sum of Voronoi areas should equal the sum of triangle areas, + ensuring perfect tiling without gaps or overlaps (Meyer et al. 2003, Sec 3.4). + """ + from physicsnemo.mesh.geometry.dual_meshes import compute_dual_volumes_0 + + for subdivisions in [0, 2, 4]: + mesh = create_sphere_mesh( + radius=1.0, subdivisions=subdivisions, device=device + ) + voronoi_areas = compute_dual_volumes_0(mesh) + + # Sum of Voronoi areas should equal sum of triangle areas + total_voronoi_area = voronoi_areas.sum().item() + total_triangle_area = mesh.cell_areas.sum().item() + relative_error = ( + abs(total_voronoi_area - total_triangle_area) / total_triangle_area + ) + + # Should be nearly exact (perfect tiling property) + assert relative_error < 1e-6, ( + f"Voronoi areas don't perfectly tile mesh at subdivision {subdivisions}: " + f"{relative_error:.9f} ({total_voronoi_area=:.6f}, {total_triangle_area=:.6f})" + ) + + +### Test Mean Curvature + + +class TestMeanCurvature: + """Tests for mean curvature computation.""" + + def test_sphere_mean_curvature(self, device): + """Test that sphere has constant mean curvature H = 1/r.""" + radius = 2.0 + mesh = create_sphere_mesh(radius=radius, subdivisions=1, device=device) + + H_vertices = mesh.mean_curvature_vertices + + # Expected: H = 1/r for all vertices + expected_H = 1.0 / radius + + # Should be close to expected + mean_H = H_vertices.mean() + assert torch.abs(mean_H - expected_H) / expected_H < 0.01 # Within 1% + + # All should be positive (outward normals) + assert torch.all(H_vertices > 0) + + def test_plane_mean_curvature(self, device): + """Test that flat plane has zero mean curvature.""" + mesh = create_plane_mesh(n_subdivisions=2, device=device) + + H_vertices = mesh.mean_curvature_vertices + + # Should be zero for interior vertices (boundary vertices are NaN) + interior_H = H_vertices[~torch.isnan(H_vertices)] + assert len(interior_H) > 0, "Should have interior vertices" + assert torch.allclose(interior_H, torch.zeros_like(interior_H), atol=1e-6) + + def test_cylinder_mean_curvature(self, device): + """Test that cylinder has H = 1/(2r) (curved in one direction only).""" + from physicsnemo.mesh.primitives.surfaces import cylinder_open + + radius = 1.0 + mesh = cylinder_open.load( + radius=radius, + n_circ=64, + n_height=32, + device=device, # Use finer mesh + ) + + H_vertices = mesh.mean_curvature_vertices + + # Expected: H = 1/(2r) for cylinder + expected_H = 1.0 / (2 * radius) + + # Check interior vertices only (boundary vertices are NaN) + interior_H = H_vertices[~torch.isnan(H_vertices)] + + assert len(interior_H) > 0, "Should have interior vertices" + + mean_H = interior_H.mean() + relative_error = torch.abs(mean_H - expected_H) / expected_H + + # Interior vertices are perfect (0.0% error) + assert relative_error < 0.001, ( + f"Mean curvature error {relative_error:.1%} exceeds 0.1% tolerance. " + f"Got {mean_H:.4f}, expected {expected_H:.4f}" + ) + + def test_mean_curvature_convergence(self, device): + """Test that mean curvature is accurate across subdivision levels.""" + radius = 1.0 + expected_H = 1.0 / radius + + for subdivisions in [0, 1, 2]: + mesh = create_sphere_mesh( + radius=radius, subdivisions=subdivisions, device=device + ) + H_vertices = mesh.mean_curvature_vertices + mean_H = H_vertices.mean() + error = torch.abs(mean_H - expected_H) + + # Each subdivision level should maintain excellent accuracy + assert error / expected_H < 0.01 # Within 1% at all levels + + def test_mean_curvature_codimension_error(self, device): + """Test that mean curvature raises error for non-codimension-1.""" + # Create a tet mesh (codimension-0) + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2, 3]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="codimension-1"): + _ = mesh.mean_curvature_vertices + + +### Test 1D Curvature (Curves) + + +class Test1DCurvature: + """Tests for curvature of 1D curves.""" + + def test_circular_arc_curvature(self, device): + """Test curvature of circular arc (1D in 2D).""" + curvature = 2.0 # κ = 1/r, r = 0.5 + mesh = create_line_curve_2d(n_points=20, curvature=curvature, device=device) + + K_vertices = mesh.gaussian_curvature_vertices + + # For 1D curves, Gaussian curvature is related to κ + # Interior vertices should have consistent curvature + # End vertices may differ (boundary effects) + + # Check that interior vertices have reasonable curvature + interior_K = K_vertices[1:-1] # Skip endpoints + + # Should all have same sign and similar magnitude + assert torch.all(interior_K > 0) or torch.all(interior_K < 0) + + def test_straight_line_curvature(self, device): + """Test that straight line has zero curvature.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1], [1, 2], [2, 3]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + K_vertices = mesh.gaussian_curvature_vertices + + # Interior vertices should have zero curvature (straight line) + # For 1D, interior vertices have angle sum = π (full angle for 1D) + interior_K = K_vertices[1:-1] + assert torch.allclose(interior_K, torch.zeros_like(interior_K), atol=1e-5) + + +### Test Edge Cases + + +class TestCurvatureEdgeCases: + """Tests for edge cases and error conditions.""" + + def test_empty_mesh(self, device): + """Test curvature computation on empty mesh.""" + points = torch.empty((0, 3), dtype=torch.float32, device=device) + cells = torch.empty((0, 3), dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + K_vertices = mesh.gaussian_curvature_vertices + assert K_vertices.shape == (0,) + + def test_single_triangle(self, device): + """Test curvature on single triangle.""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + K_vertices = mesh.gaussian_curvature_vertices + H_vertices = mesh.mean_curvature_vertices + + # Should compute without error + assert K_vertices.shape == (3,) + assert H_vertices.shape == (3,) + + def test_isolated_vertex(self, device): + """Test that isolated vertices are handled gracefully.""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0], [99.0, 99.0, 99.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + K_vertices = mesh.gaussian_curvature_vertices + + # Isolated vertex (index 3) should have zero or NaN curvature + # Implementation choice - either is acceptable + isolated_K = K_vertices[3] + assert torch.isnan(isolated_K) or isolated_K == 0 + + def test_caching(self, device): + """Test that curvatures are cached.""" + mesh = create_sphere_mesh(radius=1.0, subdivisions=0, device=device) + + # First access + K1 = mesh.gaussian_curvature_vertices + H1 = mesh.mean_curvature_vertices + + # Check cached + assert get_cached(mesh.point_data, "gaussian_curvature") is not None + assert get_cached(mesh.point_data, "mean_curvature") is not None + + # Second access should return same values + K2 = mesh.gaussian_curvature_vertices + H2 = mesh.mean_curvature_vertices + + assert torch.allclose(K1, K2) + assert torch.allclose(H1, H2) + + +### Test Dimension Coverage + + +class TestCurvatureDimensions: + """Tests across different manifold dimensions.""" + + def test_1d_curve_in_2d(self, device): + """Test 1D curve curvature in 2D space.""" + mesh = create_line_curve_2d(n_points=10, curvature=1.0, device=device) + + K_vertices = mesh.gaussian_curvature_vertices + + assert K_vertices.shape == (mesh.n_points,) + # Should have some non-zero curvature + assert K_vertices.abs().max() > 0 + + def test_2d_surface_in_3d(self, device): + """Test 2D surface in 3D space (standard case).""" + mesh = create_sphere_mesh(radius=1.0, subdivisions=0, device=device) + + K_vertices = mesh.gaussian_curvature_vertices + H_vertices = mesh.mean_curvature_vertices + + assert K_vertices.shape == (mesh.n_points,) + assert H_vertices.shape == (mesh.n_points,) + + def test_2d_surface_in_4d(self, device): + """Test 2D surface in 4D space (higher codimension).""" + # Create triangle in 4D + points = torch.tensor( + [[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0], [0.5, 1.0, 0.0, 0.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + # Gaussian curvature should work (intrinsic) + K_vertices = mesh.gaussian_curvature_vertices + assert K_vertices.shape == (3,) + + # Mean curvature should fail (requires codimension-1) + with pytest.raises(ValueError, match="codimension-1"): + _ = mesh.mean_curvature_vertices + + +### Test Principal Curvatures (Derived) + + +class TestPrincipalCurvatures: + """Tests for principal curvatures derived from K and H.""" + + def test_sphere_principal_curvatures(self, device): + """Test that sphere has equal principal curvatures k1 = k2 = 1/r.""" + radius = 1.0 + mesh = create_sphere_mesh(radius=radius, subdivisions=2, device=device) + + K = mesh.gaussian_curvature_vertices + H = mesh.mean_curvature_vertices + + # For sphere: k1 = k2 = 1/r + # K = k1 * k2 = 1/r² + # H = (k1 + k2)/2 = 1/r + # Therefore: k1 = k2 = H + + expected_k = 1.0 / radius + expected_K = expected_k**2 + + # Mean curvature should match expected value + mean_H = H.mean() + mean_K = K.mean() + + H_rel_error = torch.abs(mean_H - expected_k) / expected_k + K_rel_error = torch.abs(mean_K - expected_K) / expected_K + + # With subdivision level 1, should be within tight tolerance + assert H_rel_error < 0.01, ( + f"Mean curvature error {H_rel_error:.1%} exceeds 1%. " + f"Got {mean_H:.4f}, expected {expected_k:.4f}" + ) + assert K_rel_error < 0.02, ( + f"Gaussian curvature error {K_rel_error:.1%} exceeds 2%. " + f"Got {mean_K:.4f}, expected {expected_K:.4f}" + ) + + # Verify K ≈ H² for sphere (identity for sphere) + K_from_H = H**2 + K_identity_error = (K - K_from_H).abs() / (K.abs() + 1e-10) + assert K_identity_error.mean() < 0.02, ( + f"K vs H² relationship violated: mean error {K_identity_error.mean():.1%}" + ) + + def test_cylinder_principal_curvatures(self, device): + """Test cylinder has k1 = 1/r, k2 = 0.""" + from physicsnemo.mesh.primitives.surfaces import cylinder_open + + radius = 1.0 + mesh = cylinder_open.load(radius=radius, n_circ=32, n_height=16, device=device) + + K = mesh.gaussian_curvature_vertices + H = mesh.mean_curvature_vertices + + # For cylinder: k1 = 1/r, k2 = 0 + # K = k1 * k2 = 0 + # H = (k1 + k2)/2 = 1/(2r) + + # Filter to interior vertices (not on top/bottom boundary) + # Top boundary: z > height/2 - epsilon + # Bottom boundary: z < -height/2 + epsilon + z_coords = mesh.points[:, 2] + interior_mask = (z_coords > -0.9) & (z_coords < 0.9) + + K_interior = K[interior_mask] + + # Gaussian curvature should be near zero (intrinsically flat) + assert torch.allclose(K_interior, torch.zeros_like(K_interior), atol=0.01) + + # Mean curvature should be positive + H_interior = H[interior_mask] + assert torch.all(H_interior > 0) + + +### Test Numerical Stability + + +class TestCurvatureNumerical: + """Tests for numerical stability.""" + + def test_small_radius_sphere(self, device): + """Test curvature on very small sphere.""" + radius = 0.01 + mesh = create_sphere_mesh(radius=radius, subdivisions=2, device=device) + + K = mesh.gaussian_curvature_vertices + H = mesh.mean_curvature_vertices + + # Should still compute valid curvatures + assert not torch.any(torch.isnan(K)) + assert not torch.any(torch.isnan(H)) + + # Should scale correctly with radius + expected_K = 1.0 / (radius**2) + expected_H = 1.0 / radius + + mean_K = K.mean() + mean_H = H.mean() + + K_rel_error = torch.abs(mean_K - expected_K) / expected_K + H_rel_error = torch.abs(mean_H - expected_H) / expected_H + + # Should be within tight tolerance even for small radius + assert K_rel_error < 0.02, ( + f"Gaussian curvature error {K_rel_error:.1%} exceeds 2%. " + f"Got {mean_K:.2f}, expected {expected_K:.2f}" + ) + assert H_rel_error < 0.01, ( + f"Mean curvature error {H_rel_error:.1%} exceeds 1%. " + f"Got {mean_H:.2f}, expected {expected_H:.2f}" + ) + + def test_large_radius_sphere(self, device): + """Test curvature on very large sphere.""" + radius = 100.0 + mesh = create_sphere_mesh(radius=radius, subdivisions=2, device=device) + + K = mesh.gaussian_curvature_vertices + H = mesh.mean_curvature_vertices + + # Should compute very small curvatures + expected_K = 1.0 / (radius**2) + expected_H = 1.0 / radius + + mean_K = K.mean() + mean_H = H.mean() + + K_rel_error = torch.abs(mean_K - expected_K) / expected_K + H_rel_error = torch.abs(mean_H - expected_H) / expected_H + + # Should be within tight tolerance even for large radius + assert K_rel_error < 0.02, ( + f"Gaussian curvature error {K_rel_error:.1%} exceeds 2%. " + f"Got {mean_K:.6f}, expected {expected_K:.6f}" + ) + assert H_rel_error < 0.01, ( + f"Mean curvature error {H_rel_error:.1%} exceeds 1%. " + f"Got {mean_H:.6f}, expected {expected_H:.6f}" + ) + + +### Test Sign Conventions + + +class TestCurvatureSigns: + """Tests for sign conventions.""" + + def test_positive_gaussian_curvature(self, device): + """Test positive Gaussian curvature (elliptic point).""" + # Sphere has positive curvature everywhere + mesh = create_sphere_mesh(radius=1.0, subdivisions=0, device=device) + K = mesh.gaussian_curvature_vertices + + assert torch.all(K > 0) + + def test_zero_gaussian_curvature(self, device): + """Test zero Gaussian curvature (parabolic/flat) at interior vertices.""" + # Plane has zero curvature at interior vertices + mesh = create_plane_mesh(n_subdivisions=2, device=device) + K = mesh.gaussian_curvature_vertices + + # Check only interior vertices + n = 5 # Grid size for n_subdivisions=2 + interior_mask = torch.zeros(mesh.n_points, dtype=torch.bool, device=device) + for i in range(n): + for j in range(n): + idx = i * n + j + if 0 < i < n - 1 and 0 < j < n - 1: + interior_mask[idx] = True + + interior_K = K[interior_mask] + assert torch.allclose(interior_K, torch.zeros_like(interior_K), atol=1e-5) + + def test_signed_mean_curvature_sphere(self, device): + """Test that mean curvature sign depends on normal orientation.""" + mesh = create_sphere_mesh(radius=1.0, subdivisions=0, device=device) + H = mesh.mean_curvature_vertices + + # With outward normals, sphere should have positive H + # (All should have same sign) + assert torch.all(H > 0) or torch.all(H < 0) + + +############################################################################### +# Regression: gaussian_curvature_cells on embedded manifolds +############################################################################### + + +class TestGaussianCurvatureCellsRegression: + """Regression tests for gaussian_curvature_cells on embedded manifolds. + + The original implementation computed pairwise angles between centroid-to- + centroid vectors in ambient 3D space instead of the manifold's tangent + plane, causing spurious curvature on developable surfaces (e.g. cylinders) + and divergence with mesh refinement. + """ + + def test_cylinder_curvature_near_zero(self, device): + """Cylinder has zero intrinsic Gaussian curvature (developable surface). + + Interior cells should have |K| near zero. The original implementation + gave |K| ~ 3-40 on a cylinder, *increasing* with mesh refinement. + """ + from physicsnemo.mesh.primitives.surfaces import cylinder_open + + cyl = cylinder_open.load(n_circ=32, n_height=16).to(device) + K = cyl.gaussian_curvature_cells + K_finite = K[~torch.isnan(K)] + + assert K_finite.abs().mean() < 0.05, ( + f"Cylinder K_cells abs mean = {K_finite.abs().mean():.4f}, " + "expected near 0 for a developable surface" + ) + + def test_sphere_curvature_correct(self, device): + """Sphere of radius r should have K = 1/r^2.""" + from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + + for radius in (1.0, 2.0): + sphere = sphere_icosahedral.load(radius=radius, subdivisions=3).to(device) + K = sphere.gaussian_curvature_cells + K_finite = K[~torch.isnan(K)] + expected = 1.0 / radius**2 + + assert abs(K_finite.mean().item() - expected) < 0.1 * expected, ( + f"Sphere r={radius}: K_cells mean = {K_finite.mean():.4f}, " + f"expected {expected:.4f}" + ) + + def test_cylinder_convergence(self, device): + """Cell curvature on a cylinder should not diverge with refinement.""" + from physicsnemo.mesh.primitives.surfaces import cylinder_open + + means = [] + for n in (16, 32, 64): + cyl = cylinder_open.load(n_circ=n, n_height=n).to(device) + K = cyl.gaussian_curvature_cells + means.append(K[~torch.isnan(K)].abs().mean().item()) + + assert means[-1] < means[0] + 0.01, ( + f"Cell curvature diverges with refinement: {means}" + ) + + def test_boundary_cells_are_nan(self, device): + """Boundary cells (touching boundary vertices) should be NaN.""" + from physicsnemo.mesh.primitives.surfaces import cylinder_open + + cyl = cylinder_open.load(n_circ=16, n_height=8).to(device) + K = cyl.gaussian_curvature_cells + + from physicsnemo.mesh.boundaries._detection import get_boundary_cells + + is_bnd = get_boundary_cells(cyl) + assert torch.isnan(K[is_bnd]).all(), "Boundary cells should have NaN curvature" diff --git a/test/mesh/curvature/test_curvature_gauss_bonnet.py b/test/mesh/curvature/test_curvature_gauss_bonnet.py new file mode 100644 index 0000000000..da18aa58d2 --- /dev/null +++ b/test/mesh/curvature/test_curvature_gauss_bonnet.py @@ -0,0 +1,403 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for Gauss-Bonnet theorem and curvature integration convergence. + +The Gauss-Bonnet theorem states that for a closed 2D surface M: + ∫∫_M K dA = 2πχ(M) + +where K is Gaussian curvature, dA is area element, and χ(M) is Euler characteristic. + +For a sphere (χ=2): ∫∫ K dA = 4π exactly, regardless of: + - Shape (smooth sphere, lumpy sphere, ellipsoid) + - Discretization (mesh resolution) + - Scale (radius) + +This is a topological invariant. In the discrete approximation: + ∫∫ K dA ≈ Σ_i (K_i × A_i) + +where K_i is Gaussian curvature at vertex i and A_i is the Voronoi area. +As the mesh is refined, this sum should converge to 4π. +""" + +import pytest +import torch + +from physicsnemo.mesh.geometry.dual_meshes import ( + compute_dual_volumes_0 as compute_voronoi_areas, +) +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.primitives.surfaces import ( + octahedron_surface, + sphere_icosahedral, + tetrahedron_surface, +) + +### Helper Functions + + +def compute_gaussian_curvature_integral(mesh: Mesh) -> torch.Tensor: + """Compute the discrete integral of Gaussian curvature over the mesh. + + Uses the angle defect formula: + ∫∫ K dA ≈ Σ_i (K_i × A_i) + + where K_i is Gaussian curvature at vertex i and A_i is the Voronoi area. + + Args: + mesh: Input mesh (2D manifold) + + Returns: + Scalar tensor containing the integrated Gaussian curvature + """ + ### Compute Gaussian curvature at vertices + K_vertices = mesh.gaussian_curvature_vertices # (n_points,) + + ### Compute Voronoi areas + voronoi_areas = compute_voronoi_areas(mesh) # (n_points,) + + ### Integrate: ∫∫ K dA ≈ Σ K_i * A_i + total_curvature = (K_vertices * voronoi_areas).sum() + + return total_curvature + + +### Test Perfect Sphere Convergence + + +class TestPerfectSphereConvergence: + """Tests that Gauss-Bonnet theorem holds for perfect spheres with increasing refinement.""" + + def test_sphere_gauss_bonnet_convergence(self, device): + """Test that ∫∫ K dA converges to 4π with subdivision refinement.""" + expected_integral = 4.0 * torch.pi + + integrals = [] + errors = [] + + ### Test subdivision levels 0, 1, 2, 3 + for subdivisions in [0, 1, 2, 3]: + mesh = sphere_icosahedral.load( + radius=1.0, + subdivisions=subdivisions, + device=device, + ) + + integral = compute_gaussian_curvature_integral(mesh) + error = torch.abs(integral - expected_integral) + + integrals.append(integral.item()) + errors.append(error.item()) + + ### Each integral should be close to 4π + # The Gauss-Bonnet theorem is a topological invariant, so the integral + # should be very close to 4π at ALL subdivision levels, not just fine ones + for i, (integral, error) in enumerate(zip(integrals, errors)): + relative_error = error / expected_integral + # All levels should be very accurate (topological invariant) + assert relative_error < 0.002, ( + f"Subdivision level {i}: integral={integral:.6f}, " + f"expected={expected_integral:.6f}, " + f"relative_error={relative_error:.1%} exceeds 0.2%" + ) + + ### Verify discretization invariance + # The integral should be nearly constant across subdivision levels + # (within numerical precision), not monotonically converging + max_integral = max(integrals) + min_integral = min(integrals) + integral_range = max_integral - min_integral + relative_variation = integral_range / expected_integral + + assert relative_variation < 0.002, ( + f"Integral variation across subdivision levels too large. " + f"Min={min_integral:.6f}, Max={max_integral:.6f}, " + f"Range={integral_range:.6f}, " + f"Relative variation={relative_variation:.1%} exceeds 0.2%" + ) + + @pytest.mark.parametrize("radius", [0.5, 1.0, 2.0, 5.0]) + def test_sphere_gauss_bonnet_scale_invariance(self, device, radius): + """Test that ∫∫ K dA = 4π regardless of sphere radius (scale invariance).""" + expected_integral = 4.0 * torch.pi + + ### Create sphere with given radius at moderate refinement + mesh = sphere_icosahedral.load( + radius=radius, + subdivisions=2, + device=device, + ) + + integral = compute_gaussian_curvature_integral(mesh) + relative_error = torch.abs(integral - expected_integral) / expected_integral + + ### Should be close to 4π regardless of radius + assert relative_error < 0.02, ( + f"Scale invariance violated for radius={radius}. " + f"Integral={integral:.6f}, expected={expected_integral:.6f}, " + f"relative_error={relative_error:.1%} exceeds 2%" + ) + + def test_sphere_gauss_bonnet_absolute_value(self, device): + """Test that the computed integral is very close to 4π at high refinement.""" + expected_integral = 4.0 * torch.pi + + ### Create highly refined sphere + mesh = sphere_icosahedral.load( + radius=1.0, + subdivisions=3, + device=device, + ) + + integral = compute_gaussian_curvature_integral(mesh) + absolute_error = torch.abs(integral - expected_integral) + + ### Should be within tight absolute tolerance + assert absolute_error < 0.25, ( + f"High-refinement sphere integral far from 4π. " + f"Integral={integral:.6f}, expected={expected_integral:.6f}, " + f"absolute_error={absolute_error:.6f} exceeds 0.25" + ) + + ### Relative error should be very small + relative_error = absolute_error / expected_integral + assert relative_error < 0.02, ( + f"High-refinement sphere relative error too large. " + f"Integral={integral:.6f}, expected={expected_integral:.6f}, " + f"relative_error={relative_error:.1%} exceeds 2%" + ) + + +### Test Lumpy Sphere Discretization Invariance + + +class TestLumpySphereDiscretizationInvariance: + """Tests that Gauss-Bonnet theorem holds for lumpy spheres across refinement levels.""" + + @pytest.mark.parametrize("seed", [0, 42, 123]) + def test_lumpy_sphere_gauss_bonnet_value(self, device, seed): + """Test that lumpy sphere has ∫∫ K dA ≈ 4π.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + expected_integral = 4.0 * torch.pi + + ### Create lumpy sphere with moderate perturbation + mesh = lumpy_sphere.load( + noise_amplitude=0.2, + subdivisions=2, + seed=seed, + device=device, + ) + + integral = compute_gaussian_curvature_integral(mesh) + relative_error = torch.abs(integral - expected_integral) / expected_integral + + ### Should be reasonably close to 4π (within ~5%) + assert relative_error < 0.05, ( + f"Lumpy sphere (seed={seed}) integral far from 4π. " + f"Integral={integral:.6f}, expected={expected_integral:.6f}, " + f"relative_error={relative_error:.1%} exceeds 5%" + ) + + @pytest.mark.parametrize("seed", [0, 42, 123]) + def test_lumpy_sphere_discretization_invariance(self, device, seed): + """Test that ∫∫ K dA is invariant under further mesh refinement. + + This is the key test: after initial subdivision, further refinement + should not significantly change the integral value. + """ + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + ### Create lumpy sphere at subdivision level 2 + mesh_coarse = lumpy_sphere.load( + noise_amplitude=0.2, + subdivisions=2, + seed=seed, + device=device, + ) + + integral_coarse = compute_gaussian_curvature_integral(mesh_coarse) + + ### Refine further with one more level of Loop subdivision + mesh_fine = mesh_coarse.subdivide(levels=1, filter="loop") + + integral_fine = compute_gaussian_curvature_integral(mesh_fine) + + ### Integrals should be very similar (discretization-invariant) + absolute_difference = torch.abs(integral_fine - integral_coarse) + relative_difference = absolute_difference / ( + 0.5 * (torch.abs(integral_fine) + torch.abs(integral_coarse)) + ) + + assert relative_difference < 0.01, ( + f"Discretization variance too high (seed={seed}). " + f"Coarse integral={integral_coarse:.6f}, " + f"Fine integral={integral_fine:.6f}, " + f"relative_difference={relative_difference:.1%} exceeds 1%" + ) + + ### Both should be close to 4π + expected_integral = 4.0 * torch.pi + for label, integral in [("coarse", integral_coarse), ("fine", integral_fine)]: + relative_error = torch.abs(integral - expected_integral) / expected_integral + assert relative_error < 0.05, ( + f"Lumpy sphere {label} (seed={seed}) integral far from 4π. " + f"Integral={integral:.6f}, expected={expected_integral:.6f}, " + f"relative_error={relative_error:.1%} exceeds 5%" + ) + + +### Test Robustness + + +class TestGaussBonnetRobustness: + """Additional robustness tests for various perturbations and base meshes.""" + + @pytest.mark.parametrize("amplitude", [0.1, 0.2, 0.4]) + def test_different_perturbation_amplitudes(self, device, amplitude): + """Test Gauss-Bonnet with different perturbation strengths.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + expected_integral = 4.0 * torch.pi + + ### Create lumpy sphere with given perturbation amplitude + mesh = lumpy_sphere.load( + noise_amplitude=amplitude, + subdivisions=2, + seed=42, + device=device, + ) + + integral = compute_gaussian_curvature_integral(mesh) + relative_error = torch.abs(integral - expected_integral) / expected_integral + + ### Should still be close to 4π (tolerance depends on amplitude) + # Larger perturbations may need coarser tolerance + if amplitude <= 0.2: + tolerance = 0.05 + else: + tolerance = 0.10 + + assert relative_error < tolerance, ( + f"Lumpy sphere (amplitude={amplitude}) integral far from 4π. " + f"Integral={integral:.6f}, expected={expected_integral:.6f}, " + f"relative_error={relative_error:.1%} exceeds {tolerance * 100}%" + ) + + def test_octahedron_base_mesh(self, device): + """Test Gauss-Bonnet starting from octahedron instead of icosahedron.""" + expected_integral = 4.0 * torch.pi + + ### Create octahedron + mesh = octahedron_surface.load(size=1.0, device=device) + + ### Perturb and subdivide + torch.manual_seed(42) + radii = ( + torch.rand(mesh.n_points, dtype=torch.float32, device=device) * 0.4 + 0.8 + ) + perturbed_points = mesh.points * radii.unsqueeze(-1) + + mesh = Mesh( + points=perturbed_points, + cells=mesh.cells, + point_data=mesh.point_data, + cell_data=mesh.cell_data, + global_data=mesh.global_data, + ) + + ### Subdivide + mesh = mesh.subdivide(levels=2, filter="loop") + + integral = compute_gaussian_curvature_integral(mesh) + relative_error = torch.abs(integral - expected_integral) / expected_integral + + ### Should still be close to 4π + assert relative_error < 0.05, ( + f"Octahedron-based lumpy sphere integral far from 4π. " + f"Integral={integral:.6f}, expected={expected_integral:.6f}, " + f"relative_error={relative_error:.1%} exceeds 5%" + ) + + def test_tetrahedron_base_mesh(self, device): + """Test Gauss-Bonnet starting from tetrahedron.""" + expected_integral = 4.0 * torch.pi + + ### Create tetrahedron + mesh = tetrahedron_surface.load(side_length=1.0, device=device) + + ### Perturb and subdivide + torch.manual_seed(42) + radii = ( + torch.rand(mesh.n_points, dtype=torch.float32, device=device) * 0.4 + 0.8 + ) + perturbed_points = mesh.points * radii.unsqueeze(-1) + + mesh = Mesh( + points=perturbed_points, + cells=mesh.cells, + point_data=mesh.point_data, + cell_data=mesh.cell_data, + global_data=mesh.global_data, + ) + + ### Subdivide more aggressively (tetrahedron is coarser) + mesh = mesh.subdivide(levels=3, filter="loop") + + integral = compute_gaussian_curvature_integral(mesh) + relative_error = torch.abs(integral - expected_integral) / expected_integral + + ### Should still be close to 4π + assert relative_error < 0.05, ( + f"Tetrahedron-based lumpy sphere integral far from 4π. " + f"Integral={integral:.6f}, expected={expected_integral:.6f}, " + f"relative_error={relative_error:.1%} exceeds 5%" + ) + + +### Test Edge Cases + + +class TestGaussBonnetEdgeCases: + """Tests for edge cases and validation.""" + + def test_empty_mesh(self, device): + """Test that empty mesh gives zero integral.""" + points = torch.empty((0, 3), dtype=torch.float32, device=device) + cells = torch.empty((0, 3), dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + integral = compute_gaussian_curvature_integral(mesh) + + assert integral == 0.0, f"Empty mesh should give zero integral, got {integral}" + + def test_single_triangle(self, device): + """Test curvature integral on single triangle.""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + ### Should compute without error + integral = compute_gaussian_curvature_integral(mesh) + + ### Single flat triangle has some curvature at vertices (angle defect) + # but total should be related to Euler characteristic + assert not torch.isnan(integral), "Integral should not be NaN" + assert torch.isfinite(integral), "Integral should be finite" diff --git a/test/mesh/curvature/test_voronoi_tets.py b/test/mesh/curvature/test_voronoi_tets.py new file mode 100644 index 0000000000..5fc51205ea --- /dev/null +++ b/test/mesh/curvature/test_voronoi_tets.py @@ -0,0 +1,253 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for Voronoi volume computation on tetrahedral meshes.""" + +import pytest +import torch + +from physicsnemo.mesh import Mesh +from physicsnemo.mesh.geometry.dual_meshes import get_or_compute_dual_volumes_0 + + +@pytest.fixture +def device(): + """Test on CPU.""" + return "cpu" + + +class TestVoronoiVolumes3D: + """Tests for Voronoi volume computation on 3D tetrahedral meshes.""" + + def test_single_regular_tet(self, device): + """Test Voronoi volumes for single regular tetrahedron.""" + # Regular tetrahedron + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, (3**0.5) / 2, 0.0], + [0.5, (3**0.5) / 6, ((2 / 3) ** 0.5)], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2, 3]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + # Compute Voronoi volumes + dual_vols = get_or_compute_dual_volumes_0(mesh) + + # Should have one volume per vertex + assert dual_vols.shape == (4,) + + # All should be positive + assert torch.all(dual_vols > 0) + + # Sum of dual volumes should relate to tet volume + # For regular tet, each vertex gets equal share + total_dual = dual_vols.sum() + + # Dual volumes can be larger than tet volume in circumcentric construction + # (circumcenter can be outside the tet) + # Just verify they're computed and positive + assert total_dual > 0 + + def test_cube_tets_voronoi(self, device): + """Test Voronoi volumes for cube subdivided into tets.""" + # Simple cube vertices + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [1.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + [0.0, 1.0, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + # Subdivide cube into 5 tets (standard subdivision) + cells = torch.tensor( + [ + [0, 1, 2, 5], + [0, 2, 3, 7], + [0, 5, 7, 4], + [2, 5, 6, 7], + [0, 2, 5, 7], + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + dual_vols = get_or_compute_dual_volumes_0(mesh) + + # Should have one volume per vertex + assert dual_vols.shape == (8,) + + # All should be positive + assert torch.all(dual_vols > 0) + + # Total dual volume should be reasonable + total_dual = dual_vols.sum() + total_tet_volume = mesh.cell_areas.sum() + + # Should be same order of magnitude + assert total_dual > total_tet_volume * 0.5 + assert total_dual < total_tet_volume * 2.0 + + def test_two_tets_sharing_face(self, device): + """Test Voronoi volumes for two adjacent tets.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [0.5, 0.5, 1.0], # Above + [0.5, 0.5, -1.0], # Below + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1, 2, 3], + [0, 1, 2, 4], + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + dual_vols = get_or_compute_dual_volumes_0(mesh) + + assert dual_vols.shape == (5,) + assert torch.all(dual_vols > 0) + + # Vertices on shared face should have larger dual volumes + # (they have contributions from both tets) + shared_verts = torch.tensor([0, 1, 2]) + isolated_verts = torch.tensor([3, 4]) + + assert dual_vols[shared_verts].mean() > dual_vols[isolated_verts].mean() + + def test_voronoi_caching(self, device): + """Test that Voronoi volumes are cached properly.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [0.5, 0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2, 3]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + # Compute twice + dual_vols1 = get_or_compute_dual_volumes_0(mesh) + dual_vols2 = get_or_compute_dual_volumes_0(mesh) + + # Should be identical (cached) + assert torch.equal(dual_vols1, dual_vols2) + + def test_comparison_with_barycentric(self, device): + """Compare Voronoi volumes with barycentric approximation.""" + + # Regular tetrahedron + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, (3**0.5) / 2, 0.0], + [0.5, (3**0.5) / 6, ((2 / 3) ** 0.5)], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2, 3]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + # Voronoi volumes + voronoi_vols = get_or_compute_dual_volumes_0(mesh) + + # Barycentric approximation: tet_volume / 4 + tet_volume = mesh.cell_areas[0] + barycentric_vols = tet_volume / 4.0 + + # Voronoi and barycentric should be similar for regular tet + # But not identical + rel_diff = torch.abs(voronoi_vols - barycentric_vols) / barycentric_vols + + # Should be same order of magnitude + assert torch.all(rel_diff < 2.0) # Within factor of 2 + + +class TestVoronoiNumericalStability: + """Tests for numerical stability of Voronoi computation.""" + + def test_nearly_degenerate_tet(self, device): + """Test Voronoi on nearly degenerate tetrahedron.""" + # Very flat tet + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [0.5, 0.5, 1e-6], # Nearly coplanar + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2, 3]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + # Should compute without NaN/Inf + dual_vols = get_or_compute_dual_volumes_0(mesh) + + assert not torch.any(torch.isnan(dual_vols)) + assert not torch.any(torch.isinf(dual_vols)) + assert torch.all(dual_vols >= 0) + + def test_empty_tet_mesh(self, device): + """Test Voronoi on empty tet mesh.""" + points = torch.randn(10, 3, device=device) + cells = torch.zeros((0, 4), dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + dual_vols = get_or_compute_dual_volumes_0(mesh) + + # Should all be zero (no cells) + assert torch.allclose(dual_vols, torch.zeros_like(dual_vols)) diff --git a/test/mesh/io/io_pyvista/test_to_pyvista.py b/test/mesh/io/io_pyvista/test_to_pyvista.py index a25ddb25c0..a7b301aac3 100644 --- a/test/mesh/io/io_pyvista/test_to_pyvista.py +++ b/test/mesh/io/io_pyvista/test_to_pyvista.py @@ -142,3 +142,130 @@ def test_data_preservation_to_pyvista(self): assert np.allclose( pv_mesh.cell_data["pressure"], mesh.cell_data["pressure"].numpy() ) + + +class TestHighRankTensorFlattening: + """Tests for high-rank tensor flattening in to_pyvista conversion. + + VTK only supports arrays with dimensionality <= 2. Higher-rank tensors + (e.g., stress tensors with shape (n, 3, 3)) must be flattened to + (n, 9) for VTK compatibility. + """ + + def test_rank2_tensor_flattened(self): + """Test that rank-2 tensors are flattened correctly.""" + points = torch.rand(10, 3) + cells = torch.tensor([[0, 1, 2], [2, 3, 4]], dtype=torch.long) + mesh = Mesh(points=points, cells=cells) + + # Add rank-2 tensor (3x3 stress tensor per cell) + stress_data = torch.rand(2, 3, 3) + mesh.cell_data["stress"] = stress_data + + pv_mesh = to_pyvista(mesh) + + # Verify key is preserved + assert "stress" in pv_mesh.cell_data + + # Verify shape is flattened correctly + assert pv_mesh.cell_data["stress"].shape == (2, 9) + + # Verify values are preserved (raveled) + expected = stress_data.numpy().reshape(2, 9) + assert np.allclose(pv_mesh.cell_data["stress"], expected) + + def test_rank3_tensor_flattened(self): + """Test that rank-3 tensors are flattened correctly.""" + points = torch.rand(10, 3) + cells = torch.tensor([[0, 1, 2]], dtype=torch.long) + mesh = Mesh(points=points, cells=cells) + + # Add rank-3 tensor (2x3x4 tensor per cell) + tensor_data = torch.rand(1, 2, 3, 4) + mesh.cell_data["elasticity"] = tensor_data + + pv_mesh = to_pyvista(mesh) + + # Verify key and shape + assert "elasticity" in pv_mesh.cell_data + assert pv_mesh.cell_data["elasticity"].shape == (1, 24) + + # Verify values + expected = tensor_data.numpy().reshape(1, 24) + assert np.allclose(pv_mesh.cell_data["elasticity"], expected) + + def test_point_data_high_rank_flattened(self): + """Test that high-rank point_data is also flattened.""" + points = torch.rand(5, 3) + cells = torch.tensor([[0, 1, 2]], dtype=torch.long) + mesh = Mesh(points=points, cells=cells) + + # Add rank-2 tensor to point_data + jacobian_data = torch.rand(5, 2, 2) + mesh.point_data["jacobian"] = jacobian_data + + pv_mesh = to_pyvista(mesh) + + assert "jacobian" in pv_mesh.point_data + assert pv_mesh.point_data["jacobian"].shape == (5, 4) + + def test_global_data_high_rank_flattened(self): + """Test that high-rank global_data is also flattened.""" + points = torch.rand(5, 3) + cells = torch.tensor([[0, 1, 2]], dtype=torch.long) + mesh = Mesh(points=points, cells=cells) + + # Add rank-2 tensor to global_data (single 3x3 matrix) + transform_data = torch.rand(1, 3, 3) + mesh.global_data["transform"] = transform_data + + pv_mesh = to_pyvista(mesh) + + assert "transform" in pv_mesh.field_data + assert pv_mesh.field_data["transform"].shape == (1, 9) + + def test_low_rank_tensors_unchanged(self): + """Test that scalars and vectors are not modified.""" + points = torch.rand(10, 3) + cells = torch.tensor([[0, 1, 2], [2, 3, 4]], dtype=torch.long) + mesh = Mesh(points=points, cells=cells) + + # Add scalar and vector data (should not be flattened) + mesh.point_data["temperature"] = torch.rand(10) + mesh.point_data["velocity"] = torch.rand(10, 3) + mesh.cell_data["pressure"] = torch.rand(2) + + pv_mesh = to_pyvista(mesh) + + # Keys should be unchanged (no shape suffix) + assert "temperature" in pv_mesh.point_data + assert "velocity" in pv_mesh.point_data + assert "pressure" in pv_mesh.cell_data + + # Shapes should be unchanged + assert pv_mesh.point_data["temperature"].shape == (10,) + assert pv_mesh.point_data["velocity"].shape == (10, 3) + assert pv_mesh.cell_data["pressure"].shape == (2,) + + def test_mixed_rank_tensors(self): + """Test mesh with both low-rank and high-rank tensors.""" + points = torch.rand(10, 3) + cells = torch.tensor([[0, 1, 2], [2, 3, 4]], dtype=torch.long) + mesh = Mesh(points=points, cells=cells) + + # Mix of ranks + mesh.point_data["scalar"] = torch.rand(10) + mesh.point_data["vector"] = torch.rand(10, 3) + mesh.point_data["matrix"] = torch.rand(10, 3, 3) # High-rank + + pv_mesh = to_pyvista(mesh) + + # Low-rank unchanged + assert "scalar" in pv_mesh.point_data + assert "vector" in pv_mesh.point_data + assert pv_mesh.point_data["scalar"].shape == (10,) + assert pv_mesh.point_data["vector"].shape == (10, 3) + + # High-rank flattened (key unchanged) + assert "matrix" in pv_mesh.point_data + assert pv_mesh.point_data["matrix"].shape == (10, 9) diff --git a/test/mesh/mesh/test_data_conversion.py b/test/mesh/mesh/test_data_conversion.py index 99904898cf..a819a94e3b 100644 --- a/test/mesh/mesh/test_data_conversion.py +++ b/test/mesh/mesh/test_data_conversion.py @@ -191,7 +191,7 @@ def test_key_conflict_raises_error(self): ) ### Should raise error - with pytest.raises(ValueError, match="already exists in point_data"): + with pytest.raises(ValueError): mesh.cell_data_to_point_data() def test_overwrite_keys(self): @@ -314,7 +314,7 @@ def test_key_conflict_raises_error(self): ) ### Should raise error - with pytest.raises(ValueError, match="already exists in cell_data"): + with pytest.raises(ValueError): mesh.point_data_to_cell_data() def test_overwrite_keys(self): diff --git a/test/mesh/mesh/test_merge.py b/test/mesh/mesh/test_merge.py index 3d0401af3f..5a625af2ae 100644 --- a/test/mesh/mesh/test_merge.py +++ b/test/mesh/mesh/test_merge.py @@ -109,15 +109,18 @@ def test_merge_three_meshes(self): assert merged.n_points == 5 + 7 + 9 assert merged.n_cells == 3 + 4 + 6 - def test_merge_single_mesh_returns_same(self): - """Test that merging a single mesh returns the same mesh.""" + def test_merge_single_mesh_returns_clone(self): + """Test that merging a single mesh returns an equal but distinct copy.""" mesh = create_simple_mesh( n_points=10, n_cells=5, n_spatial_dims=3, n_manifold_dims=2 ) merged = Mesh.merge([mesh]) - assert merged is mesh + # Should be equal but not the same object (no aliasing) + assert merged is not mesh + assert torch.equal(merged.points, mesh.points) + assert torch.equal(merged.cells, mesh.cells) def test_merge_preserves_points(self): """Test that merged points are correctly concatenated.""" diff --git a/test/mesh/mesh/test_repr.py b/test/mesh/mesh/test_repr.py index a47ac243ca..63c9d59b46 100644 --- a/test/mesh/mesh/test_repr.py +++ b/test/mesh/mesh/test_repr.py @@ -46,7 +46,7 @@ def test_repr_simple_case(): def test_repr_many_fields(): - """Test many fields (>3) without nesting.""" + """Test many fields (>3) triggers multiline formatting with point_data and cell_data.""" points = torch.randn(100, 3) cells = torch.randint(0, 100, (50, 3)) mesh = Mesh( @@ -77,72 +77,8 @@ def test_repr_many_fields(): assert result == expected, f"Expected:\n{expected}\n\nGot:\n{result}" -def test_repr_nested_few_fields(): - """Test nested TensorDict with ≤3 total fields.""" - points = torch.randn(100, 3) - cells = torch.randint(0, 100, (50, 3)) - mesh = Mesh( - points=points, - cells=cells, - point_data={}, - cell_data={ - "flow": TensorDict( - { - "pressure": torch.randn(50), - "velocity": torch.randn(50, 3), - }, - batch_size=[50], - ) - }, - global_data={}, - ) - - result = repr(mesh) - - expected = r"""Mesh(manifold_dim=2, spatial_dim=3, n_points=100, n_cells=50) - point_data : {} - cell_data : {flow: {pressure: (), velocity: (3,)}} - global_data: {}""" - - assert result == expected, f"Expected:\n{expected}\n\nGot:\n{result}" - - -def test_repr_nested_many_fields(): - """Test nested TensorDict with >3 total fields.""" - points = torch.randn(100, 3) - cells = torch.randint(0, 100, (50, 3)) - mesh = Mesh( - points=points, - cells=cells, - point_data={}, - cell_data={ - "temperature": torch.randn(50), - "flow": TensorDict( - { - "pressure": torch.randn(50), - "velocity": torch.randn(50, 3), - }, - batch_size=[50], - ), - }, - global_data={}, - ) - - result = repr(mesh) - - # Keys are alphabetically sorted: flow, temperature - expected = r"""Mesh(manifold_dim=2, spatial_dim=3, n_points=100, n_cells=50) - point_data : {} - cell_data : { - flow : {pressure: (), velocity: (3,)}, - temperature: ()} - global_data: {}""" - - assert result == expected, f"Expected:\n{expected}\n\nGot:\n{result}" - - def test_repr_deeply_nested(): - """Test deeply nested with many fields.""" + """Test deeply nested TensorDicts with many fields across point_data and cell_data.""" points = torch.randn(100, 3) cells = torch.randint(0, 100, (50, 3)) mesh = Mesh( @@ -186,67 +122,8 @@ def test_repr_deeply_nested(): assert result == expected, f"Expected:\n{expected}\n\nGot:\n{result}" -def test_repr_with_device(): - """Test with explicitly set device.""" - points = torch.randn(100, 3) - cells = torch.randint(0, 100, (50, 3)) - mesh = Mesh( - points=points, - cells=cells, - point_data={}, - cell_data={ - "pressure": torch.randn(50), - "velocity": torch.randn(50, 3), - }, - global_data={}, - ) - - # Explicitly set device using .to() - mesh = mesh.to("cpu") - - result = repr(mesh) - - # Device should be shown since it was explicitly set - expected = r"""Mesh(manifold_dim=2, spatial_dim=3, n_points=100, n_cells=50, device=cpu) - point_data : {} - cell_data : {pressure: (), velocity: (3,)} - global_data: {}""" - - assert result == expected, f"Expected:\n{expected}\n\nGot:\n{result}" - - -@pytest.mark.cuda -def test_repr_with_cuda_device(): - """Test that CUDA device displays correctly when explicitly set.""" - points = torch.randn(100, 3) - cells = torch.randint(0, 100, (50, 3)) - mesh = Mesh( - points=points, - cells=cells, - point_data={}, - cell_data={ - "pressure": torch.randn(50), - "velocity": torch.randn(50, 3), - }, - global_data={}, - ) - - # Explicitly set device to cuda:0 - mesh = mesh.to("cuda:0") - - result = repr(mesh) - - # Device should show cuda:0 - expected = r"""Mesh(manifold_dim=2, spatial_dim=3, n_points=100, n_cells=50, device=cuda:0) - point_data : {} - cell_data : {pressure: (), velocity: (3,)} - global_data: {}""" - - assert result == expected, f"Expected:\n{expected}\n\nGot:\n{result}" - - def test_repr_complex_nested(): - """Test multiple nested levels with various field counts.""" + """Test multiple nested levels with a lower-dimensional mesh (manifold_dim=1).""" points = torch.randn(100, 2) cells = torch.randint(0, 100, (50, 2)) mesh = Mesh( @@ -295,7 +172,7 @@ def test_repr_complex_nested(): def test_repr_empty_mesh(): - """Test edge case with empty mesh.""" + """Test repr for a mesh with no point_data, cell_data, or global_data.""" points = torch.randn(10, 3) cells = torch.randint(0, 10, (5, 3)) mesh = Mesh( @@ -316,57 +193,67 @@ def test_repr_empty_mesh(): assert result == expected, f"Expected:\n{expected}\n\nGot:\n{result}" -def test_repr_single_field(): - """Test edge case with single field.""" - points = torch.randn(10, 3) - cells = torch.randint(0, 10, (5, 3)) +def test_repr_with_device(): + """Test that device info is shown when explicitly set.""" + points = torch.randn(100, 3) + cells = torch.randint(0, 100, (50, 3)) mesh = Mesh( points=points, cells=cells, - point_data={"temperature": torch.randn(10)}, - cell_data={}, + point_data={}, + cell_data={ + "pressure": torch.randn(50), + "velocity": torch.randn(50, 3), + }, global_data={}, ) + # Explicitly set device using .to() + mesh = mesh.to("cpu") + result = repr(mesh) - expected = r"""Mesh(manifold_dim=2, spatial_dim=3, n_points=10, n_cells=5) - point_data : {temperature: ()} - cell_data : {} + # Device should be shown since it was explicitly set + expected = r"""Mesh(manifold_dim=2, spatial_dim=3, n_points=100, n_cells=50, device=cpu) + point_data : {} + cell_data : {pressure: (), velocity: (3,)} global_data: {}""" assert result == expected, f"Expected:\n{expected}\n\nGot:\n{result}" -def test_repr_exactly_three_fields(): - """Test edge case with exactly 3 fields.""" - points = torch.randn(10, 3) - cells = torch.randint(0, 10, (5, 3)) +@pytest.mark.cuda +def test_repr_with_cuda_device(): + """Test that CUDA device displays correctly when explicitly set.""" + points = torch.randn(100, 3) + cells = torch.randint(0, 100, (50, 3)) mesh = Mesh( points=points, cells=cells, - point_data={ - "temperature": torch.randn(10), - "pressure": torch.randn(10), - "velocity": torch.randn(10, 3), + point_data={}, + cell_data={ + "pressure": torch.randn(50), + "velocity": torch.randn(50, 3), }, - cell_data={}, global_data={}, ) + # Explicitly set device to cuda:0 + mesh = mesh.to("cuda:0") + result = repr(mesh) - # Keys are alphabetically sorted: pressure, temperature, velocity - expected = r"""Mesh(manifold_dim=2, spatial_dim=3, n_points=10, n_cells=5) - point_data : {pressure: (), temperature: (), velocity: (3,)} - cell_data : {} + # Device should show cuda:0 + expected = r"""Mesh(manifold_dim=2, spatial_dim=3, n_points=100, n_cells=50, device=cuda:0) + point_data : {} + cell_data : {pressure: (), velocity: (3,)} global_data: {}""" assert result == expected, f"Expected:\n{expected}\n\nGot:\n{result}" def test_repr_with_cached_data(): - """Test that cached data is included by default.""" + """Test that cached data is included in repr output.""" points = torch.randn(10, 3) cells = torch.randint(0, 10, (5, 3)) mesh = Mesh( @@ -387,160 +274,8 @@ def test_repr_with_cached_data(): assert "centroids" in result, f"Expected centroids in output but got:\n{result}" -def test_repr_with_multiple_cached_fields(): - """Test that multiple cached fields are formatted correctly.""" - points = torch.randn(10, 3) - cells = torch.randint(0, 10, (5, 3)) - mesh = Mesh( - points=points, - cells=cells, - point_data={}, - cell_data={"pressure": torch.randn(5)}, - global_data={}, - ) - - # Access multiple cached properties to populate cache - _ = mesh.cell_centroids - _ = mesh.cell_areas - - result = repr(mesh) - - # Should show multiline format for cell_data since it has >3 total fields - # (pressure + _cache.centroids + _cache.areas = 3 fields in _cache, but total >3) - assert "_cache" in result - assert "centroids" in result - assert "areas" in result - - # Verify structure is correct - lines = result.split("\n") - # Find the cell_data line - cell_data_line_idx = None - for i, line in enumerate(lines): - if "cell_data" in line: - cell_data_line_idx = i - break - - # cell_data should be multiline since it has pressure + _cache with multiple fields - assert "{" in lines[cell_data_line_idx], "cell_data should start multiline format" - - -def test_repr_with_subclass(): - """Test that subclasses show their own class name.""" - - class CustomMesh(Mesh): - pass - - points = torch.randn(10, 3) - cells = torch.randint(0, 10, (5, 3)) - mesh = CustomMesh( - points=points, - cells=cells, - point_data={}, - cell_data={}, - global_data={}, - ) - - result = repr(mesh) - - # Should start with CustomMesh, not Mesh - assert result.startswith("CustomMesh("), ( - f"Expected 'CustomMesh(' at start but got:\n{result}" - ) - - -def test_repr_colon_alignment(): - """Test that colons are properly aligned at each level.""" - points = torch.randn(10, 3) - cells = torch.randint(0, 10, (5, 3)) - mesh = Mesh( - points=points, - cells=cells, - point_data={"a": torch.randn(10)}, - cell_data={"temperature": torch.randn(5), "p": torch.randn(5)}, - global_data={}, - ) - - result = repr(mesh) - lines = result.split("\n") - - # Find colon positions in main data fields - colon_positions = [line.index(":") for line in lines[1:4] if ":" in line] - - # All colons should be at the same position - assert len(set(colon_positions)) == 1, ( - f"Colons not aligned: {colon_positions}\nOutput:\n{result}" - ) - - -def test_repr_indentation(): - """Test that 4-space indentation is used at each level.""" - points = torch.randn(10, 3) - cells = torch.randint(0, 10, (5, 3)) - mesh = Mesh( - points=points, - cells=cells, - point_data={ - "a": torch.randn(10), - "b": torch.randn(10), - "c": torch.randn(10), - "d": torch.randn(10), - }, - cell_data={}, - global_data={}, - ) - - result = repr(mesh) - lines = result.split("\n") - - # Check that data field lines have 4 spaces - assert lines[1].startswith(" "), f"Expected 4 spaces but got: {repr(lines[1])}" - - # Check that nested field lines have 8 spaces (4 * 2) - # Find a line that's a field inside point_data - for line in lines[2:]: - if ":" in line and line.strip().startswith(("a:", "b:", "c:", "d:")): - assert line.startswith(" "), ( - f"Expected 8 spaces but got: {repr(line)}" - ) - break - - -def test_repr_alphabetical_sorting(): - """Test that keys are displayed in alphabetical order.""" - points = torch.randn(10, 3) - cells = torch.randint(0, 10, (5, 3)) - - # Create mesh with keys in non-alphabetical order - mesh = Mesh( - points=points, - cells=cells, - point_data={ - "zebra": torch.randn(10), - "alpha": torch.randn(10), - "delta": torch.randn(10), - "beta": torch.randn(10), - }, - cell_data={}, - global_data={}, - ) - - result = repr(mesh) - - # Keys should be sorted: alpha, beta, delta, zebra - expected = r"""Mesh(manifold_dim=2, spatial_dim=3, n_points=10, n_cells=5) - point_data : { - alpha: (), - beta : (), - delta: (), - zebra: ()} - cell_data : {} - global_data: {}""" - - assert result == expected, f"Expected:\n{expected}\n\nGot:\n{result}" - - def test_repr_cache_always_last(): - """Test that _cache appears last, even though '_' comes before letters alphabetically.""" + """Test that _cache appears last in repr, after user-defined fields.""" points = torch.randn(10, 3) cells = torch.randint(0, 10, (5, 3)) @@ -583,30 +318,3 @@ def test_repr_cache_always_last(): assert alpha_pos < beta_pos < zebra_pos < cache_pos, ( f"Keys not in correct order: alpha={alpha_pos}, beta={beta_pos}, zebra={zebra_pos}, _cache={cache_pos}" ) - - -def test_repr_edge_case_empty_cells(): - """Test that __repr__ handles meshes with zero cells gracefully.""" - # Create a mesh with zero cells (edge case) - points = torch.randn(10, 3) - cells = torch.randint(0, 10, (0, 3)) # Zero cells - mesh = Mesh( - points=points, - cells=cells, - point_data={}, - cell_data={}, - global_data={}, - ) - - result = repr(mesh) - - # Should handle zero cells gracefully - assert "n_cells=0" in result - assert "n_points=10" in result - - expected = r"""Mesh(manifold_dim=2, spatial_dim=3, n_points=10, n_cells=0) - point_data : {} - cell_data : {} - global_data: {}""" - - assert result == expected, f"Expected:\n{expected}\n\nGot:\n{result}" diff --git a/test/mesh/misc/test_optimizations.py b/test/mesh/misc/test_optimizations.py new file mode 100644 index 0000000000..4eef5c3628 --- /dev/null +++ b/test/mesh/misc/test_optimizations.py @@ -0,0 +1,589 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Test suite for performance optimizations. + +Verifies that all optimizations produce correct results and maintain backward compatibility +across compute backends (CPU, CUDA). +""" + +import pytest +import torch + +from physicsnemo.mesh import Mesh +from physicsnemo.mesh.sampling.sample_data import ( + compute_barycentric_coordinates, + compute_barycentric_coordinates_pairwise, +) +from physicsnemo.mesh.spatial import BVH + +### Helper Functions ### + + +def assert_on_device(tensor: torch.Tensor, expected_device: str) -> None: + """Assert tensor is on expected device.""" + actual_device = tensor.device.type + assert actual_device == expected_device, ( + f"Device mismatch: tensor is on {actual_device!r}, expected {expected_device!r}" + ) + + +### Test Fixtures ### + + +class TestBarycentricOptimizations: + """Test pairwise barycentric coordinate computation.""" + + def test_pairwise_vs_full_2d(self): + """Verify pairwise barycentric matches diagonal of full computation (2D).""" + torch.manual_seed(42) + # Create simple triangle mesh in 2D + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + + # Create query points + n_queries = 10 + query_points = torch.rand(n_queries, 2) + + # Compute using both methods for first cell + cell_vertices = points[cells] # (2, 3, 2) + + # Full computation (O(n²)) + bary_full, recon_error_full = compute_barycentric_coordinates( + query_points, cell_vertices + ) # (n_queries, 2, 3) and (n_queries, 2) + + # Pairwise computation (O(n)) + # For each query, pair it with the first cell + pairwise_query_points = query_points # (n_queries, 2) + pairwise_cell_vertices = cell_vertices[[0]].expand( + n_queries, -1, -1 + ) # (n_queries, 3, 2) + bary_pairwise, recon_error_pairwise = compute_barycentric_coordinates_pairwise( + pairwise_query_points, pairwise_cell_vertices + ) # (n_queries, 3) and (n_queries,) + + # Extract diagonal from full computation (what pairwise should match) + bary_full_diagonal = bary_full[:, 0, :] # (n_queries, 3) + recon_error_full_diagonal = recon_error_full[:, 0] # (n_queries,) + + # Verify they match + torch.testing.assert_close( + bary_pairwise, bary_full_diagonal, rtol=1e-5, atol=1e-7 + ) + torch.testing.assert_close( + recon_error_pairwise, recon_error_full_diagonal, rtol=1e-5, atol=1e-7 + ) + + def test_pairwise_vs_full_3d(self): + """Verify pairwise barycentric matches diagonal of full computation (3D).""" + torch.manual_seed(42) + # Create tetrahedron mesh in 3D + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2, 3]]) + + # Create query points + n_queries = 20 + query_points = torch.rand(n_queries, 3) + + cell_vertices = points[cells] # (1, 4, 3) + + # Full computation + bary_full, recon_error_full = compute_barycentric_coordinates( + query_points, cell_vertices + ) # (n_queries, 1, 4) and (n_queries, 1) + + # Pairwise computation + pairwise_cell_vertices = cell_vertices.expand( + n_queries, -1, -1 + ) # (n_queries, 4, 3) + bary_pairwise, recon_error_pairwise = compute_barycentric_coordinates_pairwise( + query_points, pairwise_cell_vertices + ) # (n_queries, 4) and (n_queries,) + + # Extract diagonal + bary_full_diagonal = bary_full[:, 0, :] + recon_error_full_diagonal = recon_error_full[:, 0] + + torch.testing.assert_close( + bary_pairwise, bary_full_diagonal, rtol=1e-5, atol=1e-7 + ) + torch.testing.assert_close( + recon_error_pairwise, recon_error_full_diagonal, rtol=1e-5, atol=1e-7 + ) + + def test_pairwise_different_cells_per_query(self): + """Test pairwise with different cells for each query.""" + # Create multiple triangles + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [2.0, 0.0], + [2.0, 1.0], + ], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 4]]) + + # Query points, each paired with specific cell + query_points = torch.tensor( + [[0.3, 0.3], [1.5, 0.3], [0.1, 0.1]], dtype=torch.float32 + ) + paired_cell_indices = torch.tensor([0, 1, 0]) # Which cell each query uses + + # Get cell vertices for each query + cell_vertices = points[cells[paired_cell_indices]] # (3, 3, 2) + + # Compute pairwise + bary, recon_error = compute_barycentric_coordinates_pairwise( + query_points, cell_vertices + ) + + # Verify properties + assert bary.shape == (3, 3) + assert recon_error.shape == (3,) + # Barycentric coordinates should sum to 1 + torch.testing.assert_close(bary.sum(dim=1), torch.ones(3), rtol=1e-5, atol=1e-7) + # Reconstruction error should be 0 for codimension-0 (2D in 2D) + torch.testing.assert_close(recon_error, torch.zeros(3), rtol=1e-5, atol=1e-7) + + def test_pairwise_memory_efficiency(self): + """Verify pairwise uses O(n) not O(n²) memory.""" + torch.manual_seed(42) + # This is more of a conceptual test - verify shape differences + n_pairs = 100 + query_points = torch.rand(n_pairs, 3) + cell_vertices = torch.rand(n_pairs, 4, 3) # Tets + + # Pairwise should return (n_pairs, 4) and (n_pairs,) + bary_pairwise, recon_error = compute_barycentric_coordinates_pairwise( + query_points, cell_vertices + ) + assert bary_pairwise.shape == (n_pairs, 4) + assert recon_error.shape == (n_pairs,) + + # Full would return (n_pairs, n_pairs, 4) if we computed it + # We don't compute it here to avoid memory issues, but the shapes tell the story + + +class TestCellNormalsOptimizations: + """Test optimized cell normal computation.""" + + def test_2d_edge_normals(self): + """Test 2D edge normal computation (special case).""" + # Create a simple edge in 2D + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1], [0, 2]]) # Two edges + + mesh = Mesh(points=points, cells=cells) + normals = mesh.cell_normals + + # Edge from (0,0) to (1,0): direction is (1,0), normal is (0,1) + expected_normal_0 = torch.tensor([0.0, 1.0], dtype=torch.float32) + torch.testing.assert_close(normals[0], expected_normal_0, rtol=1e-5, atol=1e-7) + + # Edge from (0,0) to (0,1): direction is (0,1), normal is (-1,0) + expected_normal_1 = torch.tensor([-1.0, 0.0], dtype=torch.float32) + torch.testing.assert_close(normals[1], expected_normal_1, rtol=1e-5, atol=1e-7) + + def test_3d_triangle_normals(self): + """Test 3D triangle normal computation (special case).""" + # Create a triangle in the XY plane + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]]) + + mesh = Mesh(points=points, cells=cells) + normals = mesh.cell_normals + + # Triangle in XY plane should have normal in +Z direction + expected_normal = torch.tensor([0.0, 0.0, 1.0], dtype=torch.float32) + torch.testing.assert_close(normals[0], expected_normal, rtol=1e-5, atol=1e-7) + + def test_normals_are_unit_length(self): + """Verify all normals are unit length.""" + torch.manual_seed(42) + # Create non-degenerate triangles (sequential indices to avoid duplicates) + points = torch.randn(15, 3) + # Use sequential indices to ensure non-degenerate triangles + cells = torch.tensor( + [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13, 14]] + ) + + mesh = Mesh(points=points, cells=cells) + normals = mesh.cell_normals + + # Check all are unit length + lengths = torch.norm(normals, dim=1) + torch.testing.assert_close(lengths, torch.ones(5), rtol=1e-5, atol=1e-6) + + +class TestGramMatrixOptimization: + """Test einsum optimization in Gram matrix computation.""" + + def test_cell_areas_correctness(self): + """Verify cell area computation is still correct after optimization.""" + # Create a known triangle + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1, 2]]) + + mesh = Mesh(points=points, cells=cells) + area = mesh.cell_areas[0] + + # Right triangle with legs 1, area = 0.5 + expected_area = 0.5 + torch.testing.assert_close( + area, torch.tensor(expected_area), rtol=1e-5, atol=1e-7 + ) + + def test_3d_tetrahedron_volume(self): + """Test tetrahedron volume computation.""" + # Unit tetrahedron + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2, 3]]) + + mesh = Mesh(points=points, cells=cells) + volume = mesh.cell_areas[0] + + # Volume of unit tetrahedron is 1/6 + expected_volume = 1.0 / 6.0 + torch.testing.assert_close( + volume, torch.tensor(expected_volume), rtol=1e-5, atol=1e-7 + ) + + +class TestMeshMergeOptimization: + """Test optimized mesh merging.""" + + def test_merge_preserves_correctness(self): + """Verify merge produces same result as before.""" + # Create two simple meshes + points1 = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], dtype=torch.float32 + ) + cells1 = torch.tensor([[0, 1, 2]]) + mesh1 = Mesh( + points=points1, cells=cells1, cell_data={"value": torch.tensor([1.0])} + ) + + points2 = torch.tensor( + [[2.0, 0.0], [3.0, 0.0], [2.0, 1.0]], dtype=torch.float32 + ) + cells2 = torch.tensor([[0, 1, 2]]) + mesh2 = Mesh( + points=points2, cells=cells2, cell_data={"value": torch.tensor([2.0])} + ) + + # Merge + merged = Mesh.merge([mesh1, mesh2]) + + # Check structure + assert merged.n_points == 6 + assert merged.n_cells == 2 + + # Check cell indices are offset correctly + # Mesh2's cells should reference points 3, 4, 5 + expected_cells = torch.tensor([[0, 1, 2], [3, 4, 5]]) + torch.testing.assert_close(merged.cells, expected_cells) + + # Check data preserved + expected_values = torch.tensor([1.0, 2.0]) + torch.testing.assert_close(merged.cell_data["value"], expected_values) + + +class TestCombinationCache: + """Test combination index cache for facet extraction.""" + + def test_triangle_edge_combinations(self): + """Test triangle edge extraction uses cached combinations.""" + from physicsnemo.mesh.boundaries._facet_extraction import ( + _generate_combination_indices, + ) + + # Should use cache for (3, 2) + combos = _generate_combination_indices(3, 2) + expected = torch.tensor([[0, 1], [0, 2], [1, 2]], dtype=torch.int64) + torch.testing.assert_close(combos, expected) + + def test_tetrahedron_face_combinations(self): + """Test tetrahedron face extraction uses cached combinations.""" + from physicsnemo.mesh.boundaries._facet_extraction import ( + _generate_combination_indices, + ) + + # Should use cache for (4, 3) + combos = _generate_combination_indices(4, 3) + expected = torch.tensor( + [[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3]], dtype=torch.int64 + ) + torch.testing.assert_close(combos, expected) + + def test_facet_extraction_with_cache(self): + """Test full facet extraction pipeline with cached combinations.""" + # Create triangle mesh + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + mesh = Mesh(points=points, cells=cells) + + # Extract edges (should use cache) + edge_mesh = mesh.get_facet_mesh(manifold_codimension=1) + + # Should have 5 unique edges + assert edge_mesh.n_cells == 5 + assert edge_mesh.n_manifold_dims == 1 + + +class TestRandomSamplingOptimization: + """Test optimized random sampling normalization.""" + + def test_barycentric_coords_sum_to_one(self): + """Verify optimized normalization produces valid barycentric coords.""" + torch.manual_seed(42) + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + mesh = Mesh(points=points, cells=cells) + + # Sample points + sampled_points = mesh.sample_random_points_on_cells( + cell_indices=[0, 0, 1, 1, 1] + ) + + assert sampled_points.shape == (5, 2) + # Points should be within valid range + assert (sampled_points >= 0.0).all() + assert (sampled_points <= 1.0).all() + + +class TestBVHPerformance: + """Test BVH traversal performance and correctness.""" + + def test_bvh_candidate_finding(self): + """Test BVH finds correct candidates.""" + # Create a simple mesh + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [1.0, 1.0, 0.0], + [1.0, 0.0, 1.0], + ], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2, 3], [1, 4, 2, 5]]) + mesh = Mesh(points=points, cells=cells) + + # Build BVH + bvh = BVH.from_mesh(mesh) + + # Create query points + query_points = torch.tensor( + [[0.2, 0.2, 0.2], [0.6, 0.3, 0.1], [2.0, 2.0, 2.0]], dtype=torch.float32 + ) + + # Find candidates + candidates = bvh.find_candidate_cells(query_points) + + # Should return Adjacency for all queries + candidates_list = candidates.to_list() + assert len(candidates_list) == 3 + + # Point inside first tet should find at least that cell + assert len(candidates_list[0]) > 0 + + # Point outside should find no candidates + assert len(candidates_list[2]) == 0 + + @pytest.mark.cuda + def test_bvh_on_gpu(self): + """Test BVH works on GPU.""" + torch.manual_seed(42) + # Create mesh on GPU + points = torch.randn(100, 3, device="cuda") + cells = torch.randint(0, 100, (50, 4), device="cuda") + mesh = Mesh(points=points, cells=cells) + + # Build BVH + bvh = BVH.from_mesh(mesh) + + # Query points + query_points = torch.randn(20, 3, device="cuda") + + # Should not raise + candidates = bvh.find_candidate_cells(query_points) + assert candidates.n_sources == 20 + + +class TestHierarchicalSampling: + """Test hierarchical sampling with all optimizations.""" + + def test_hierarchical_sampling_correctness(self): + """Verify hierarchical sampling produces valid results.""" + # Create a simple mesh + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2, 3]]) + cell_data = {"temperature": torch.tensor([100.0])} + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + + # Sample using BVH-accelerated path + from physicsnemo.mesh.sampling import sample_data_at_points + + query_points = torch.tensor([[0.25, 0.25, 0.25]], dtype=torch.float32) + + # Build BVH + bvh = BVH.from_mesh(mesh) + + result = sample_data_at_points(mesh, query_points, bvh=bvh, data_source="cells") + + # Point inside the tet should get temperature value + assert "temperature" in result + torch.testing.assert_close( + result["temperature"], torch.tensor([100.0]), rtol=1e-5, atol=1e-7 + ) + + +### Parametrized Tests for Exhaustive Backend Coverage ### + + +class TestOptimizationsParametrized: + """Parametrized tests for optimizations across backends.""" + + @pytest.mark.parametrize("n_queries,n_spatial_dims", [(10, 2), (20, 3)]) + def test_barycentric_pairwise_parametrized(self, n_queries, n_spatial_dims, device): + """Test pairwise barycentric across backends and dimensions.""" + torch.manual_seed(42) + # Create query points and cell vertices + query_points = torch.rand(n_queries, n_spatial_dims, device=device) + cell_vertices = torch.rand( + n_queries, n_spatial_dims + 1, n_spatial_dims, device=device + ) + + # Compute pairwise + bary, recon_error = compute_barycentric_coordinates_pairwise( + query_points, cell_vertices + ) + + # Verify shape + assert bary.shape == (n_queries, n_spatial_dims + 1) + assert recon_error.shape == (n_queries,) + + # Verify device + assert_on_device(bary, device) + assert_on_device(recon_error, device) + + # Verify barycentric coords sum to 1 + sums = bary.sum(dim=1) + assert torch.allclose(sums, torch.ones(n_queries, device=device), rtol=1e-4) + + # For codimension-0 (n_spatial_dims == n_manifold_dims), recon error should be 0 + assert torch.allclose( + recon_error, torch.zeros(n_queries, device=device), rtol=1e-5, atol=1e-6 + ) + + @pytest.mark.parametrize("n_manifold_dims", [2, 3]) + def test_cell_areas_computation_parametrized(self, n_manifold_dims, device): + """Test cell area computation across backends.""" + if n_manifold_dims == 2: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + else: + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ], + device=device, + ) + cells = torch.tensor([[0, 1, 2, 3]], device=device, dtype=torch.int64) + + mesh = Mesh(points=points, cells=cells) + areas = mesh.cell_areas + + # Verify device + assert_on_device(areas, device) + + # Verify areas are positive + assert torch.all(areas > 0), "All areas should be positive" + + @pytest.mark.parametrize("n_manifold_dims", [1, 2]) + def test_cell_normals_computation_parametrized(self, n_manifold_dims, device): + """Test cell normals computation across backends (codimension-1 only).""" + if n_manifold_dims == 1: + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], device=device) + cells = torch.tensor([[0, 1]], device=device, dtype=torch.int64) + else: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + + mesh = Mesh(points=points, cells=cells) + normals = mesh.cell_normals + + # Verify device + assert_on_device(normals, device) + + # Verify unit length + lengths = torch.norm(normals, dim=1) + assert torch.allclose( + lengths, + torch.ones(mesh.n_cells, device=device), + rtol=1e-5, + ), "Normals should be unit length" + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/test/mesh/misc/test_vectorization_correctness.py b/test/mesh/misc/test_vectorization_correctness.py new file mode 100644 index 0000000000..2b3778e2af --- /dev/null +++ b/test/mesh/misc/test_vectorization_correctness.py @@ -0,0 +1,653 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Correctness tests for vectorized performance optimizations. + +These tests verify that vectorized implementations produce identical results +to reference implementations, ensuring no correctness regressions were introduced. +""" + +import pytest +import torch + +from physicsnemo.mesh.mesh import Mesh + + +class TestLoopSubdivisionCorrectness: + """Verify Loop subdivision vectorization produces correct results.""" + + def test_valence_computation_matches_manual_count(self, device): + """Verify that vectorized valence computation matches manual counting.""" + # Create a mesh with known valences + points = torch.tensor( + [ + [0.0, 0.0], # Vertex 0: neighbors [1, 3] → valence 2 + [1.0, 0.0], # Vertex 1: neighbors [0, 2, 3, 4] → valence 4 + [2.0, 0.0], # Vertex 2: neighbors [1, 4] → valence 2 + [0.5, 1.0], # Vertex 3: neighbors [0, 1, 4, 5] → valence 4 + [1.5, 1.0], # Vertex 4: neighbors [1, 2, 3, 5] → valence 4 + [1.0, 2.0], # Vertex 5: neighbors [3, 4] → valence 2 + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor( + [ + [0, 1, 3], # Triangle 0 + [1, 4, 3], # Triangle 1 + [1, 2, 4], # Triangle 2 + [3, 4, 5], # Triangle 3 + ], + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + ### Manual valence count (verified by hand) + expected_valences = [2, 4, 2, 4, 4, 2] + + ### Compute using vectorized function + from physicsnemo.mesh.neighbors import get_point_to_points_adjacency + + adjacency = get_point_to_points_adjacency(mesh) + computed_valences = adjacency.offsets[1:] - adjacency.offsets[:-1] + + ### Verify + assert torch.allclose( + computed_valences, + torch.tensor(expected_valences, dtype=torch.int64, device=device), + ) + + def test_loop_edge_opposite_vertex_finding(self, device): + """Verify that opposite vertex finding in Loop subdivision is correct.""" + # Create simple mesh where we know the opposite vertices + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [1.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [1, 3, 2]], # Two triangles sharing edge [1, 2] + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + ### Extract unique edges + from physicsnemo.mesh.subdivision._topology import extract_unique_edges + + unique_edges, _ = extract_unique_edges(mesh) + + ### Find the shared edge [1, 2] + shared_edge_idx = None + for i, edge in enumerate(unique_edges): + if (edge[0] == 1 and edge[1] == 2) or (edge[0] == 2 and edge[1] == 1): + shared_edge_idx = i + break + + assert shared_edge_idx is not None, "Shared edge [1, 2] not found" + + ### Compute edge positions using Loop subdivision + from physicsnemo.mesh.subdivision.loop import compute_loop_edge_positions_2d + + edge_positions = compute_loop_edge_positions_2d(mesh, unique_edges) + + ### Verify the computation manually + # For interior edge [1, 2] with opposite vertices 0 and 3: + # new_pos = 3/8 * (v1 + v2) + 1/8 * (v0 + v3) + v0 = points[0] + v1 = points[1] + v2 = points[2] + v3 = points[3] + + expected_pos = (3.0 / 8.0) * (v1 + v2) + (1.0 / 8.0) * (v0 + v3) + + # The shared edge should be at the index we found + actual_pos = edge_positions[shared_edge_idx] + + assert torch.allclose(actual_pos, expected_pos, atol=1e-6), ( + f"Loop edge position mismatch:\n" + f"Expected: {expected_pos}\n" + f"Actual: {actual_pos}" + ) + + def test_boundary_edge_handling_loop(self, device): + """Verify Loop subdivision handles boundary edges correctly (simple average).""" + # Single triangle - all edges are boundary + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + from physicsnemo.mesh.subdivision._topology import extract_unique_edges + from physicsnemo.mesh.subdivision.loop import compute_loop_edge_positions_2d + + unique_edges, _ = extract_unique_edges(mesh) + edge_positions = compute_loop_edge_positions_2d(mesh, unique_edges) + + ### All edges should be simple averages (boundary edges) + for i, edge in enumerate(unique_edges): + v0 = mesh.points[edge[0]] + v1 = mesh.points[edge[1]] + expected = (v0 + v1) / 2 + + assert torch.allclose(edge_positions[i], expected, atol=1e-6), ( + f"Boundary edge {i} should be simple average" + ) + + +class TestCotangentWeightsCorrectness: + """Verify cotangent weight computation is correct.""" + + def test_cotangent_weights_equilateral_triangle(self, device): + """Test cotangent weights for an equilateral triangle.""" + + # Equilateral triangle with side length 1 + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, (3**0.5) / 2, 0.0], + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + from physicsnemo.mesh.geometry.dual_meshes import ( + compute_cotan_weights_fem, + ) + + weights, unique_edges = compute_cotan_weights_fem(mesh) + + ### For equilateral triangle, all angles are 60 degrees + # cot(60°) = 1/sqrt(3) ≈ 0.5774 + # Each edge has one adjacent triangle (boundary) + # Weight = cot(60°) / 2 ≈ 0.2887 + expected_weight = (1.0 / (3**0.5)) / 2.0 + + ### All three edges should have the same weight + assert torch.allclose( + weights, torch.full_like(weights, expected_weight), atol=1e-4 + ), f"Expected all weights to be {expected_weight:.4f}, got {weights}" + + def test_cotangent_weights_right_triangle(self, device): + """Test cotangent weights for a right triangle with known angles.""" + # Right triangle: 90° at origin, 45° at other two vertices + points = torch.tensor( + [ + [0.0, 0.0, 0.0], # Right angle + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + from physicsnemo.mesh.geometry.dual_meshes import ( + compute_cotan_weights_fem, + ) + + weights, unique_edges = compute_cotan_weights_fem(mesh) + + ### Find each edge and verify its weight + # Edge [0,1]: opposite angle at vertex 2 = 45°, cot(45°) = 1.0 + # Edge [0,2]: opposite angle at vertex 1 = 45°, cot(45°) = 1.0 + # Edge [1,2]: opposite angle at vertex 0 = 90°, cot(90°) = 0.0 + # All edges are boundary (one triangle), so weight = cot(angle) / 2 + + expected_weights = { + (0, 1): 1.0 / 2.0, # cot(45°) / 2 + (0, 2): 1.0 / 2.0, # cot(45°) / 2 + (1, 2): 0.0 / 2.0, # cot(90°) / 2 + } + + for i, edge in enumerate(unique_edges): + v0, v1 = int(edge[0]), int(edge[1]) + edge_tuple = tuple(sorted([v0, v1])) + expected = expected_weights[edge_tuple] + + assert abs(weights[i] - expected) < 1e-4, ( + f"Edge {edge_tuple}: expected {expected:.4f}, got {weights[i]:.4f}" + ) + + def test_cotangent_weights_interior_edge(self, device): + """Test cotangent weights for interior edge (two adjacent triangles).""" + + # Two triangles sharing an edge + # Triangle 1: [0, 1, 2] with 60° angles (equilateral) + # Triangle 2: [1, 3, 2] with known angles + h = (3**0.5) / 2 + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, h, 0.0], # Equilateral triangle 1 + [1.5, h, 0.0], # Forms triangle 2 + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [1, 3, 2]], + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + from physicsnemo.mesh.geometry.dual_meshes import ( + compute_cotan_weights_fem, + ) + + weights, unique_edges = compute_cotan_weights_fem(mesh) + + ### Find the shared interior edge [1, 2] + shared_edge_idx = None + for i, edge in enumerate(unique_edges): + v0, v1 = int(edge[0]), int(edge[1]) + if (v0 == 1 and v1 == 2) or (v0 == 2 and v1 == 1): + shared_edge_idx = i + break + + assert shared_edge_idx is not None + + ### For interior edge: weight = (cot α + cot β) / 2 + # Both triangles are equilateral, so both angles are 60° + # cot(60°) = 1/sqrt(3) + # Weight = (cot(60°) + cot(60°)) / 2 = 2 * (1/sqrt(3)) / 2 = 1/sqrt(3) + expected_weight = 1.0 / (3**0.5) + + assert abs(weights[shared_edge_idx] - expected_weight) < 1e-4, ( + f"Interior edge weight: expected {expected_weight:.4f}, " + f"got {weights[shared_edge_idx]:.4f}" + ) + + def test_neighbor_sum_computation(self, device): + """Verify that neighbor position sums are computed correctly.""" + # Create simple mesh with known neighbor relationships + points = torch.tensor( + [ + [0.0, 0.0], # Vertex 0 + [1.0, 0.0], # Vertex 1 - neighbor of 0 + [0.0, 1.0], # Vertex 2 - neighbor of 0 + [1.0, 1.0], # Vertex 3 - neighbor of 1 and 2 + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [1, 3, 2]], + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + ### Get adjacency + from physicsnemo.mesh.neighbors import get_point_to_points_adjacency + + adjacency = get_point_to_points_adjacency(mesh) + valences = adjacency.offsets[1:] - adjacency.offsets[:-1] + + ### Compute neighbor sums using vectorized method + neighbor_sums = torch.zeros_like(mesh.points) + source_point_indices = torch.repeat_interleave( + torch.arange(mesh.n_points, dtype=torch.int64, device=device), + valences, + ) + neighbor_positions = mesh.points[adjacency.indices] + source_point_indices_expanded = source_point_indices.unsqueeze(-1).expand( + -1, mesh.n_spatial_dims + ) + neighbor_sums.scatter_add_( + dim=0, + index=source_point_indices_expanded, + src=neighbor_positions, + ) + + ### Manually compute expected neighbor sums + # Vertex 0 neighbors: 1, 2 → sum = [1,0] + [0,1] = [1,1] + # Vertex 1 neighbors: 0, 2, 3 → sum = [0,0] + [0,1] + [1,1] = [1,2] + # Vertex 2 neighbors: 0, 1, 3 → sum = [0,0] + [1,0] + [1,1] = [2,1] + # Vertex 3 neighbors: 1, 2 → sum = [1,0] + [0,1] = [1,1] + expected_sums = torch.tensor( + [[1.0, 1.0], [1.0, 2.0], [2.0, 1.0], [1.0, 1.0]], + dtype=torch.float32, + device=device, + ) + + assert torch.allclose(neighbor_sums, expected_sums, atol=1e-6), ( + f"Neighbor sums mismatch:\nExpected:\n{expected_sums}\nActual:\n{neighbor_sums}" + ) + + def test_loop_subdivision_preserves_manifold(self, device): + """Verify Loop subdivision produces valid manifold (no holes/gaps).""" + # Start with simple manifold + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + mesh = lumpy_sphere.load(radius=1.0, subdivisions=2, device=device) + + initial_n_cells = mesh.n_cells + + # Subdivide + subdivided = mesh.subdivide(levels=1, filter="loop") + + ### Check manifold properties + # Should have 4x cells (2^2 for 2D) + assert subdivided.n_cells == initial_n_cells * 4 + + # All cells should be valid triangles + assert subdivided.cells.shape[1] == 3 + + # All cell indices should be in valid range + assert subdivided.cells.min() >= 0 + assert subdivided.cells.max() < subdivided.n_points + + # No degenerate cells (all three vertices should be different) + for cell_idx in range(min(100, subdivided.n_cells)): # Check first 100 + cell = subdivided.cells[cell_idx] + assert len(torch.unique(cell)) == 3, ( + f"Degenerate cell at {cell_idx}: {cell}" + ) + + +class TestButterflySubdivisionCorrectness: + """Verify Butterfly subdivision vectorization is correct.""" + + def test_butterfly_boundary_vs_interior(self, device): + """Verify boundary edges use simple average, interior use butterfly stencil.""" + # Two triangles sharing edge [1, 2] + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [1.5, 1.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [1, 3, 2]], + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + from physicsnemo.mesh.subdivision._topology import extract_unique_edges + from physicsnemo.mesh.subdivision.butterfly import compute_butterfly_weights_2d + + unique_edges, _ = extract_unique_edges(mesh) + edge_midpoints = compute_butterfly_weights_2d(mesh, unique_edges) + + ### Identify boundary edges (count adjacent cells) + from physicsnemo.mesh.boundaries import extract_candidate_facets + + candidate_edges, _ = extract_candidate_facets( + mesh.cells, manifold_codimension=1 + ) + _, inverse_indices = torch.unique(candidate_edges, dim=0, return_inverse=True) + counts = torch.bincount(inverse_indices, minlength=len(unique_edges)) + + ### Boundary edges (count=1) should be simple average + for i, (edge, count) in enumerate(zip(unique_edges, counts)): + if count == 1: + v0 = mesh.points[edge[0]] + v1 = mesh.points[edge[1]] + expected = (v0 + v1) / 2 + + assert torch.allclose(edge_midpoints[i], expected, atol=1e-6), ( + f"Boundary edge {i} should be simple average" + ) + + +class TestGaussianCurvatureCorrectness: + """Verify Gaussian curvature cell computation is correct.""" + + def test_gaussian_curvature_varying_valences(self, device): + """Test Gaussian curvature on mesh with varying cell valences.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + # Use lumpy_sphere which has varying neighbor counts per cell (icosahedral base) + mesh = lumpy_sphere.load(radius=1.0, subdivisions=2, device=device) + + ### Compute Gaussian curvature + K_cells = mesh.gaussian_curvature_cells + + ### Basic validity checks + assert K_cells.shape == (mesh.n_cells,), f"Wrong shape: {K_cells.shape}" + assert torch.all(torch.isfinite(K_cells) | torch.isnan(K_cells)), ( + "Non-finite values" + ) + + ### Check that values are in reasonable range + # For airplane mesh, curvature should be modest (not extremely large) + finite_K = K_cells[torch.isfinite(K_cells)] + if len(finite_K) > 0: + assert torch.abs(finite_K).max() < 100.0, ( + "Unreasonably large curvature values" + ) + + def test_gaussian_curvature_batching_consistency(self, device): + """Verify that batching by valence produces same results as direct computation.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + # Create mesh with mix of valences (lumpy sphere has varying curvature) + mesh = lumpy_sphere.load(radius=1.0, subdivisions=2, device=device) + + ### Compute using vectorized implementation + K_cells = mesh.gaussian_curvature_cells + + ### Verify basic properties + # Lumpy sphere has varying curvature, but should mostly be positive + finite_K = K_cells[torch.isfinite(K_cells)] + positive_fraction = (finite_K > 0).float().mean() + assert positive_fraction > 0.5, ( + f"Expected mostly positive curvature, got {positive_fraction:.2%}" + ) + + ### Verify curvature values are in reasonable range + assert torch.abs(finite_K).max() < 100.0, "Unreasonably large curvature values" + + +class TestSubdivisionTopologyCorrectness: + """Verify subdivision topology vectorization is correct.""" + + def test_child_cell_vertex_indices_valid(self, device): + """Verify all child cells reference valid vertex indices.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + mesh = lumpy_sphere.load(radius=1.0, subdivisions=2, device=device) + + ### Subdivide + subdivided = mesh.subdivide(levels=1, filter="linear") + + ### Check all indices are valid + assert subdivided.cells.min() >= 0, "Negative indices" + assert subdivided.cells.max() < subdivided.n_points, ( + f"Index out of range: max={subdivided.cells.max()}, n_points={subdivided.n_points}" + ) + + ### Check no duplicate vertices in any cell + for cell_idx in range(min(100, subdivided.n_cells)): + cell = subdivided.cells[cell_idx] + unique_verts = torch.unique(cell) + assert len(unique_verts) == len(cell), ( + f"Cell {cell_idx} has duplicate vertices: {cell}" + ) + + def test_subdivision_point_count(self, device): + """Verify subdivision produces correct number of points.""" + # Triangle mesh: n_points_new = n_points_old + n_edges + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 1.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + original_n_points = mesh.n_points + + from physicsnemo.mesh.subdivision._topology import extract_unique_edges + + unique_edges, _ = extract_unique_edges(mesh) + n_edges = len(unique_edges) + + ### Subdivide + subdivided = mesh.subdivide(levels=1, filter="linear") + + ### Check point count + expected_points = original_n_points + n_edges + assert subdivided.n_points == expected_points, ( + f"Expected {expected_points} points, got {subdivided.n_points}" + ) + + +class TestEdgeCasesCorrectness: + """Test edge cases to ensure robustness.""" + + def test_single_triangle_subdivision(self, device): + """Test subdivision on simplest possible mesh.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + ### Test all subdivision types + for subdivision_type in ["linear", "loop", "butterfly"]: + subdivided = mesh.subdivide(levels=1, filter=subdivision_type) + + # Should have 4 triangles (2^2) + assert subdivided.n_cells == 4, ( + f"{subdivision_type}: expected 4 cells, got {subdivided.n_cells}" + ) + + # Should have 6 points (3 original + 3 edge midpoints) + assert subdivided.n_points == 6, ( + f"{subdivision_type}: expected 6 points, got {subdivided.n_points}" + ) + + def test_mesh_with_isolated_vertex(self, device): + """Test that isolated vertices don't break vectorized operations.""" + # Mesh with isolated vertex + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [5.0, 5.0], # Isolated + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + ### Loop subdivision should handle isolated vertex + subdivided = mesh.subdivide(levels=1, filter="loop") + + # Isolated vertex should remain unchanged + assert torch.allclose(subdivided.points[3], points[3], atol=1e-6), ( + "Isolated vertex should remain unchanged in Loop subdivision" + ) + + def test_degenerate_mesh_cases(self, device): + """Test empty and single-vertex meshes don't crash.""" + # Empty mesh + empty_mesh = Mesh( + points=torch.zeros((0, 3), dtype=torch.float32, device=device), + cells=torch.zeros((0, 3), dtype=torch.int64, device=device), + ) + + # Should not crash + result = empty_mesh.subdivide(levels=1, filter="linear") + assert result.n_cells == 0 + + # Single point (no cells) + single_point = Mesh( + points=torch.tensor([[0.0, 0.0, 0.0]], dtype=torch.float32, device=device), + cells=torch.zeros((0, 3), dtype=torch.int64, device=device), + ) + + result = single_point.subdivide(levels=1, filter="linear") + assert result.n_points == 1 + assert result.n_cells == 0 + + +class TestCPUGPUConsistency: + """Verify CPU and GPU produce identical results.""" + + @pytest.mark.cuda + @pytest.mark.parametrize("subdivision_type", ["linear", "loop", "butterfly"]) + def test_subdivision_cpu_gpu_match(self, subdivision_type): + """Verify subdivision produces identical results on CPU and GPU.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + # Create test mesh + mesh_cpu = lumpy_sphere.load(radius=1.0, subdivisions=2, device="cpu") + mesh_gpu = mesh_cpu.to("cuda") + + ### Subdivide on both devices + sub_cpu = mesh_cpu.subdivide(levels=1, filter=subdivision_type) + sub_gpu = mesh_gpu.subdivide(levels=1, filter=subdivision_type) + + ### Verify identical topology + assert torch.equal(sub_cpu.cells.cpu(), sub_gpu.cells.cpu()), ( + f"{subdivision_type}: Cell topology differs between CPU and GPU" + ) + + ### Verify identical geometry + assert torch.allclose(sub_cpu.points.cpu(), sub_gpu.points.cpu(), atol=1e-5), ( + f"{subdivision_type}: Point positions differ between CPU and GPU" + ) + + @pytest.mark.cuda + def test_curvature_cpu_gpu_match(self): + """Verify curvature computations match between CPU and GPU.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + mesh_cpu = lumpy_sphere.load(radius=2.0, subdivisions=2, device="cpu") + mesh_gpu = mesh_cpu.to("cuda") + + ### Compute curvatures + K_cpu = mesh_cpu.gaussian_curvature_vertices + K_gpu = mesh_gpu.gaussian_curvature_vertices + + H_cpu = mesh_cpu.mean_curvature_vertices + H_gpu = mesh_gpu.mean_curvature_vertices + + ### Verify match (allowing for numerical differences) + assert torch.allclose( + K_cpu, K_gpu.cpu(), atol=1e-4, rtol=1e-3, equal_nan=True + ), "Gaussian curvature differs between CPU and GPU" + + assert torch.allclose( + H_cpu, H_gpu.cpu(), atol=1e-4, rtol=1e-3, equal_nan=True + ), "Mean curvature differs between CPU and GPU" diff --git a/test/mesh/neighbors/test_neighbors.py b/test/mesh/neighbors/test_neighbors.py new file mode 100644 index 0000000000..ecb419afb3 --- /dev/null +++ b/test/mesh/neighbors/test_neighbors.py @@ -0,0 +1,1273 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for neighbor and adjacency computation. + +Tests validate physicsnemo.mesh adjacency computations against PyVista's VTK-based +implementations as ground truth, and verify correctness across spatial dimensions, +manifold dimensions, and compute backends. +""" + +import pytest +import torch + +from physicsnemo.mesh.mesh import Mesh + +# PyVista is optional; tests that cross-validate against it are skipped if unavailable +pv = pytest.importorskip("pyvista") + +from physicsnemo.mesh.io.io_pyvista import from_pyvista # noqa: E402 + +### Helper Functions (shared across tests) ### + + +def create_simple_mesh(n_spatial_dims: int, n_manifold_dims: int, device: str = "cpu"): + """Create a simple mesh for testing.""" + if n_manifold_dims > n_spatial_dims: + raise ValueError( + f"Manifold dimension {n_manifold_dims} cannot exceed spatial dimension {n_spatial_dims}" + ) + + if n_manifold_dims == 0: + if n_spatial_dims == 2: + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], device=device) + elif n_spatial_dims == 3: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]], device=device + ) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.arange(len(points), device=device, dtype=torch.int64).unsqueeze(1) + elif n_manifold_dims == 1: + if n_spatial_dims == 2: + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [1.5, 1.0], [0.5, 1.5]], device=device + ) + elif n_spatial_dims == 3: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 1.0, 1.0]], + device=device, + ) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.tensor([[0, 1], [1, 2], [2, 3]], device=device, dtype=torch.int64) + elif n_manifold_dims == 2: + if n_spatial_dims == 2: + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 0.5]], device=device + ) + elif n_spatial_dims == 3: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0], [1.5, 0.5, 0.5]], + device=device, + ) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], device=device, dtype=torch.int64) + elif n_manifold_dims == 3: + if n_spatial_dims == 3: + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [1, 2, 3, 4]], device=device, dtype=torch.int64 + ) + else: + raise ValueError("3-simplices require 3D embedding space") + else: + raise ValueError(f"Unsupported {n_manifold_dims=}") + + return Mesh(points=points, cells=cells) + + +def create_single_cell_mesh( + n_spatial_dims: int, n_manifold_dims: int, device: str = "cpu" +): + """Create a mesh with a single cell.""" + if n_manifold_dims > n_spatial_dims: + raise ValueError( + f"Manifold dimension {n_manifold_dims} cannot exceed spatial dimension {n_spatial_dims}" + ) + + if n_manifold_dims == 0: + if n_spatial_dims == 2: + points = torch.tensor([[0.5, 0.5]], device=device) + elif n_spatial_dims == 3: + points = torch.tensor([[0.5, 0.5, 0.5]], device=device) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.tensor([[0]], device=device, dtype=torch.int64) + elif n_manifold_dims == 1: + if n_spatial_dims == 2: + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], device=device) + elif n_spatial_dims == 3: + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], device=device) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.tensor([[0, 1]], device=device, dtype=torch.int64) + elif n_manifold_dims == 2: + if n_spatial_dims == 2: + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], device=device) + elif n_spatial_dims == 3: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], device=device + ) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + elif n_manifold_dims == 3: + if n_spatial_dims == 3: + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ], + device=device, + ) + cells = torch.tensor([[0, 1, 2, 3]], device=device, dtype=torch.int64) + else: + raise ValueError("3-simplices require 3D embedding space") + else: + raise ValueError(f"Unsupported {n_manifold_dims=}") + + return Mesh(points=points, cells=cells) + + +def assert_mesh_valid(mesh, strict: bool = True) -> None: + """Assert that a mesh is valid and well-formed.""" + assert mesh.n_points > 0 + assert mesh.points.ndim == 2 + assert mesh.points.shape[1] == mesh.n_spatial_dims + + if mesh.n_cells > 0: + assert mesh.cells.ndim == 2 + assert mesh.cells.shape[1] == mesh.n_manifold_dims + 1 + assert torch.all(mesh.cells >= 0) + assert torch.all(mesh.cells < mesh.n_points) + + assert mesh.points.dtype in [torch.float32, torch.float64] + assert mesh.cells.dtype == torch.int64 + assert mesh.points.device == mesh.cells.device + + if strict and mesh.n_cells > 0: + for i in range(mesh.n_cells): + cell_verts = mesh.cells[i] + unique_verts = torch.unique(cell_verts) + assert len(unique_verts) == len(cell_verts) + + +def assert_on_device(tensor: torch.Tensor, expected_device: str) -> None: + """Assert tensor is on expected device.""" + actual_device = tensor.device.type + assert actual_device == expected_device, ( + f"Device mismatch: tensor is on {actual_device!r}, expected {expected_device!r}" + ) + + +def _compute_adjacency(mesh, adj_type): + """Compute adjacency of the given type on a mesh. + + Helper used by disjoint-mesh and transformation-invariance tests. + """ + if adj_type == "point_to_points": + return mesh.get_point_to_points_adjacency() + elif adj_type == "cell_to_cells": + return mesh.get_cell_to_cells_adjacency(adjacency_codimension=1) + elif adj_type == "point_to_cells": + return mesh.get_point_to_cells_adjacency() + elif adj_type == "cells_to_points": + return mesh.get_cell_to_points_adjacency() + else: + raise ValueError(f"Unknown adjacency type: {adj_type}") + + +### Parametrization Constants ### + +# Common dimension configs for adjacency tests (excludes 0-manifold point clouds) +_SIMPLEX_DIM_CONFIGS = [ + (2, 1), # Edges in 2D + (2, 2), # Triangles in 2D + (3, 1), # Edges in 3D + (3, 2), # Surfaces in 3D + (3, 3), # Volumes in 3D +] + +# All four adjacency types for parametrized tests +_ADJACENCY_TYPES = [ + pytest.param("point_to_points", id="point_to_points"), + pytest.param("cell_to_cells", id="cell_to_cells"), + pytest.param("point_to_cells", id="point_to_cells"), + pytest.param("cells_to_points", id="cells_to_points"), +] + +# Geometric transforms for invariance tests +_TRANSFORMS = [ + pytest.param("translation", id="translation"), + pytest.param("rotation", id="rotation"), + pytest.param("reflection", id="reflection"), +] + +### Test Fixtures ### + + +@pytest.fixture( + params=[ + pytest.param("airplane", id="airplane"), + pytest.param("tetbeam", id="tetbeam"), + ] +) +def real_mesh_pair(request, device): + """Real-world mesh pair (physicsnemo + pyvista) for cross-validation. + + Parametrized over airplane (2D surface in 3D) and tetbeam (3D volume) meshes. + """ + if request.param == "airplane": + pv_mesh = pv.examples.load_airplane() + else: + pv_mesh = pv.examples.load_tetbeam() + tm_mesh = from_pyvista(pv_mesh) + tm_mesh = Mesh( + points=tm_mesh.points.to(device), + cells=tm_mesh.cells.to(device), + point_data=tm_mesh.point_data, + cell_data=tm_mesh.cell_data, + ) + return tm_mesh, pv_mesh + + +@pytest.fixture +def simple_triangles(device): + """Simple triangle mesh for basic testing (shared across test classes).""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [1.0, 1.0, 0.0], + ], + device=device, + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ], + device=device, + dtype=torch.int64, + ) + return Mesh(points=points, cells=cells) + + +class TestPointToPointsAdjacency: + """Test point-to-points (edge) adjacency computation.""" + + ### Cross-validation against PyVista ### + + def test_cross_validation_point_neighbors(self, real_mesh_pair): + """Validate point-to-points adjacency against PyVista.""" + tm_mesh, pv_mesh = real_mesh_pair + device = tm_mesh.points.device.type + + ### Compute adjacency using physicsnemo.mesh + adj = tm_mesh.get_point_to_points_adjacency() + assert_on_device(adj.offsets, device) + assert_on_device(adj.indices, device) + + tm_neighbors = adj.to_list() + + ### Get ground truth from PyVista (requires Python loop) + pv_neighbors = [] + for i in range(pv_mesh.n_points): + neighbors = pv_mesh.point_neighbors(i) + pv_neighbors.append(neighbors) + + ### Compare results (order-independent) + assert len(tm_neighbors) == len(pv_neighbors), ( + f"Mismatch in number of points: physicsnemo.mesh={len(tm_neighbors)}, pyvista={len(pv_neighbors)}" + ) + + for i, (tm_nbrs, pv_nbrs) in enumerate(zip(tm_neighbors, pv_neighbors)): + tm_sorted = sorted(tm_nbrs) + pv_sorted = sorted(pv_nbrs) + assert tm_sorted == pv_sorted, ( + f"Point {i} neighbors mismatch:\n physicsnemo.mesh: {tm_sorted}\n pyvista: {pv_sorted}" + ) + + ### Symmetry Tests ### + + def test_symmetry_real_mesh(self, real_mesh_pair): + """Verify point adjacency is symmetric on real-world meshes.""" + tm_mesh, _ = real_mesh_pair + + adj = tm_mesh.get_point_to_points_adjacency() + neighbors = adj.to_list() + + for i, nbrs in enumerate(neighbors): + for j in nbrs: + # If j is a neighbor of i, then i must be a neighbor of j + assert i in neighbors[j], ( + f"Asymmetric adjacency: {i} neighbors {j}, but {j} doesn't neighbor {i}" + ) + + ### Parametrized Tests on Synthetic Meshes (Exhaustive Dimensional Coverage) ### + + @pytest.mark.parametrize("n_spatial_dims,n_manifold_dims", _SIMPLEX_DIM_CONFIGS) + def test_symmetry_parametrized(self, n_spatial_dims, n_manifold_dims, device): + """Verify point adjacency is symmetric across all dimension combinations (synthetic meshes).""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + assert_mesh_valid(mesh, strict=True) + + adj = mesh.get_point_to_points_adjacency() + neighbors = adj.to_list() + + ### Verify symmetry: if A neighbors B, then B neighbors A + for i, nbrs in enumerate(neighbors): + for j in nbrs: + assert i in neighbors[j], ( + f"Asymmetric adjacency ({n_spatial_dims=}, {n_manifold_dims=}): " + f"{i} neighbors {j}, but {j} doesn't neighbor {i}" + ) + + @pytest.mark.parametrize("n_spatial_dims,n_manifold_dims", _SIMPLEX_DIM_CONFIGS) + def test_no_self_loops_parametrized(self, n_spatial_dims, n_manifold_dims, device): + """Verify no point is its own neighbor across dimensions.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + adj = mesh.get_point_to_points_adjacency() + neighbors = adj.to_list() + + for i, nbrs in enumerate(neighbors): + assert i not in nbrs, ( + f"Point {i} is listed as its own neighbor ({n_spatial_dims=}, {n_manifold_dims=})" + ) + + @pytest.mark.parametrize("n_spatial_dims,n_manifold_dims", _SIMPLEX_DIM_CONFIGS) + def test_no_duplicates_parametrized(self, n_spatial_dims, n_manifold_dims, device): + """Verify each neighbor appears exactly once across dimensions.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + adj = mesh.get_point_to_points_adjacency() + neighbors = adj.to_list() + + for i, nbrs in enumerate(neighbors): + assert len(nbrs) == len(set(nbrs)), ( + f"Point {i} has duplicate neighbors: {nbrs} " + f"({n_spatial_dims=}, {n_manifold_dims=})" + ) + + @pytest.mark.parametrize("n_spatial_dims,n_manifold_dims", [(2, 1), (3, 2)]) + def test_single_cell_connectivity(self, n_spatial_dims, n_manifold_dims, device): + """Test point-to-points for single cell across dimensions.""" + mesh = create_single_cell_mesh(n_spatial_dims, n_manifold_dims, device=device) + + adj = mesh.get_point_to_points_adjacency() + neighbors = adj.to_list() + + ### All vertices in a single cell should be connected to each other + n_verts = n_manifold_dims + 1 + assert len(neighbors) == n_verts + + for i, nbrs in enumerate(neighbors): + # Each vertex should neighbor all others except itself + expected_neighbors = set(range(n_verts)) - {i} + actual_neighbors = set(nbrs) + assert actual_neighbors == expected_neighbors, ( + f"Single cell connectivity mismatch at vertex {i}: " + f"expected {sorted(expected_neighbors)}, got {sorted(actual_neighbors)}" + ) + + +class TestCellToCellsAdjacency: + """Test cell-to-cells adjacency computation.""" + + ### Cross-validation against PyVista ### + + def test_cross_validation_cell_neighbors(self, real_mesh_pair): + """Validate cell-to-cells adjacency against PyVista.""" + tm_mesh, pv_mesh = real_mesh_pair + device = tm_mesh.points.device.type + + ### Compute adjacency using physicsnemo.mesh + # Codimension=1: sharing edges for triangles, sharing faces for tets + adj = tm_mesh.get_cell_to_cells_adjacency(adjacency_codimension=1) + assert_on_device(adj.offsets, device) + assert_on_device(adj.indices, device) + + tm_neighbors = adj.to_list() + + ### Get ground truth from PyVista + # Map codimension=1 to PyVista connection type based on manifold dimension + pv_connection = {2: "edges", 3: "faces"}[tm_mesh.n_manifold_dims] + pv_neighbors = [] + for i in range(pv_mesh.n_cells): + neighbors = pv_mesh.cell_neighbors(i, connections=pv_connection) + pv_neighbors.append(neighbors) + + ### Compare results (order-independent) + assert len(tm_neighbors) == len(pv_neighbors), ( + f"Mismatch in number of cells: physicsnemo.mesh={len(tm_neighbors)}, pyvista={len(pv_neighbors)}" + ) + + for i, (tm_nbrs, pv_nbrs) in enumerate(zip(tm_neighbors, pv_neighbors)): + tm_sorted = sorted(tm_nbrs) + pv_sorted = sorted(pv_nbrs) + assert tm_sorted == pv_sorted, ( + f"Cell {i} neighbors mismatch:\n physicsnemo.mesh: {tm_sorted}\n pyvista: {pv_sorted}" + ) + + ### Symmetry Tests ### + + def test_symmetry_real_mesh(self, real_mesh_pair): + """Verify cell adjacency is symmetric on real-world meshes.""" + tm_mesh, _ = real_mesh_pair + + adj = tm_mesh.get_cell_to_cells_adjacency(adjacency_codimension=1) + neighbors = adj.to_list() + + for i, nbrs in enumerate(neighbors): + for j in nbrs: + assert i in neighbors[j], ( + f"Asymmetric adjacency: cell {i} neighbors cell {j}, " + f"but cell {j} doesn't neighbor cell {i}" + ) + + ### Parametrized Tests on Synthetic Meshes (Exhaustive Dimensional Coverage) ### + + @pytest.mark.parametrize("n_spatial_dims,n_manifold_dims", _SIMPLEX_DIM_CONFIGS) + def test_symmetry_parametrized(self, n_spatial_dims, n_manifold_dims, device): + """Verify cell adjacency is symmetric across all dimension combinations (synthetic meshes).""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + assert_mesh_valid(mesh, strict=True) + + adj = mesh.get_cell_to_cells_adjacency(adjacency_codimension=1) + neighbors = adj.to_list() + + for i, nbrs in enumerate(neighbors): + for j in nbrs: + assert i in neighbors[j], ( + f"Asymmetric adjacency ({n_spatial_dims=}, {n_manifold_dims=}): " + f"cell {i} neighbors cell {j}, but cell {j} doesn't neighbor cell {i}" + ) + + @pytest.mark.parametrize("n_spatial_dims,n_manifold_dims", _SIMPLEX_DIM_CONFIGS) + def test_no_self_loops_parametrized(self, n_spatial_dims, n_manifold_dims, device): + """Verify no cell is its own neighbor across dimensions.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + adj = mesh.get_cell_to_cells_adjacency(adjacency_codimension=1) + neighbors = adj.to_list() + + for i, nbrs in enumerate(neighbors): + assert i not in nbrs, ( + f"Cell {i} is listed as its own neighbor ({n_spatial_dims=}, {n_manifold_dims=})" + ) + + @pytest.mark.parametrize("n_spatial_dims,n_manifold_dims", _SIMPLEX_DIM_CONFIGS) + def test_no_duplicates_parametrized(self, n_spatial_dims, n_manifold_dims, device): + """Verify each neighbor appears exactly once across dimensions.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + adj = mesh.get_cell_to_cells_adjacency(adjacency_codimension=1) + neighbors = adj.to_list() + + for i, nbrs in enumerate(neighbors): + assert len(nbrs) == len(set(nbrs)), ( + f"Cell {i} has duplicate neighbors: {nbrs} " + f"({n_spatial_dims=}, {n_manifold_dims=})" + ) + + @pytest.mark.parametrize( + "n_manifold_dims,adjacency_codim", + [ + (1, 1), # Edges sharing vertices + (2, 1), # Triangles sharing edges + (2, 2), # Triangles sharing vertices + (3, 1), # Tets sharing faces + (3, 2), # Tets sharing edges + (3, 3), # Tets sharing vertices + ], + ) + def test_different_codimensions(self, n_manifold_dims, adjacency_codim, device): + """Test adjacency with different codimensions.""" + # Use 3D space for all to support up to 3D manifolds + n_spatial_dims = 3 + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + adj = mesh.get_cell_to_cells_adjacency(adjacency_codimension=adjacency_codim) + neighbors = adj.to_list() + + ### Higher codimension should give same or more neighbors + ### (more permissive connectivity criterion) + if adjacency_codim < n_manifold_dims: + adj_lower = mesh.get_cell_to_cells_adjacency( + adjacency_codimension=adjacency_codim + 1 + ) + neighbors_lower = adj_lower.to_list() + + for i in range(len(neighbors)): + # Lower codimension should be subset of higher codimension + set_codim = set(neighbors[i]) + set_lower = set(neighbors_lower[i]) + assert set_codim.issubset(set_lower) or set_codim == set_lower, ( + f"Codimension {adjacency_codim} neighbors should be subset of " + f"codimension {adjacency_codim + 1} neighbors" + ) + + +class TestPointToCellsAdjacency: + """Test point-to-cells (star) adjacency computation.""" + + def test_simple_triangle_star(self, simple_triangles): + """Test star computation on simple triangle mesh.""" + mesh = simple_triangles + device = mesh.points.device.type + + adj = mesh.get_point_to_cells_adjacency() + assert_on_device(adj.offsets, device) + assert_on_device(adj.indices, device) + + stars = adj.to_list() + + # Point 0 is in cell 0 only + assert sorted(stars[0]) == [0] + + # Point 1 is in cells 0 and 1 + assert sorted(stars[1]) == [0, 1] + + # Point 2 is in cells 0 and 1 + assert sorted(stars[2]) == [0, 1] + + # Point 3 is in cell 1 only + assert sorted(stars[3]) == [1] + + def test_consistency_real_mesh(self, real_mesh_pair): + """Verify consistency of point-to-cells adjacency on real-world meshes.""" + tm_mesh, _ = real_mesh_pair + + adj = tm_mesh.get_point_to_cells_adjacency() + stars = adj.to_list() + + ### Verify each cell's vertices have that cell in their star + for cell_id in range(tm_mesh.n_cells): + cell_vertices = tm_mesh.cells[cell_id].tolist() + for vertex_id in cell_vertices: + assert cell_id in stars[vertex_id], ( + f"Cell {cell_id} contains vertex {vertex_id}, " + f"but vertex's star doesn't contain the cell" + ) + + @pytest.mark.parametrize("n_spatial_dims,n_manifold_dims", _SIMPLEX_DIM_CONFIGS) + def test_no_duplicates_parametrized(self, n_spatial_dims, n_manifold_dims, device): + """Verify each cell appears exactly once in each point's star.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + adj = mesh.get_point_to_cells_adjacency() + stars = adj.to_list() + + for i, cells in enumerate(stars): + assert len(cells) == len(set(cells)), ( + f"Point {i} has duplicate cells in star: {cells} " + f"({n_spatial_dims=}, {n_manifold_dims=})" + ) + + @pytest.mark.parametrize("n_spatial_dims,n_manifold_dims", _SIMPLEX_DIM_CONFIGS) + def test_completeness_parametrized(self, n_spatial_dims, n_manifold_dims, device): + """Verify all cell-point relationships are captured.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + adj = mesh.get_point_to_cells_adjacency() + stars = adj.to_list() + + ### Check that every cell-vertex relationship is present + for cell_id in range(mesh.n_cells): + cell_verts = mesh.cells[cell_id].tolist() + for vert_id in cell_verts: + assert cell_id in stars[vert_id], ( + f"Cell {cell_id} contains vertex {vert_id} but vertex's star " + f"doesn't contain the cell ({n_spatial_dims=}, {n_manifold_dims=})" + ) + + +class TestCellsToPointsAdjacency: + """Test cells-to-points adjacency computation.""" + + def test_simple_triangle_vertices(self, simple_triangles): + """Test cells-to-points on simple triangle mesh.""" + mesh = simple_triangles + device = mesh.points.device.type + + adj = mesh.get_cell_to_points_adjacency() + assert_on_device(adj.offsets, device) + assert_on_device(adj.indices, device) + + vertices = adj.to_list() + + # Cell 0 has vertices [0, 1, 2] + assert vertices[0] == [0, 1, 2] + + # Cell 1 has vertices [1, 3, 2] + assert vertices[1] == [1, 3, 2] + + @pytest.mark.parametrize("n_spatial_dims,n_manifold_dims", _SIMPLEX_DIM_CONFIGS) + def test_matches_cells_array_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Verify cells-to-points matches the cells array across dimensions.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + adj = mesh.get_cell_to_points_adjacency() + vertices = adj.to_list() + + # Verify each cell's vertices match the cells array + for i in range(mesh.n_cells): + expected = mesh.cells[i].tolist() + assert vertices[i] == expected, ( + f"Cell {i} vertices mismatch:\n" + f" adjacency: {vertices[i]}\n" + f" cells array: {expected}\n" + f" ({n_spatial_dims=}, {n_manifold_dims=})" + ) + + @pytest.mark.parametrize("n_spatial_dims,n_manifold_dims", _SIMPLEX_DIM_CONFIGS) + def test_all_cells_same_size_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Verify all cells have the correct number of vertices.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + adj = mesh.get_cell_to_points_adjacency() + vertices = adj.to_list() + + # All cells should have (n_manifold_dims + 1) vertices + expected_size = n_manifold_dims + 1 + for i, verts in enumerate(vertices): + assert len(verts) == expected_size, ( + f"Cell {i} has {len(verts)} vertices, expected {expected_size} " + f"({n_spatial_dims=}, {n_manifold_dims=})" + ) + + @pytest.mark.parametrize("n_spatial_dims,n_manifold_dims", _SIMPLEX_DIM_CONFIGS) + def test_inverse_of_point_to_cells_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Verify cells-to-points is inverse of point-to-cells.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + # Get both adjacencies + cells_to_points = mesh.get_cell_to_points_adjacency().to_list() + points_to_cells = mesh.get_point_to_cells_adjacency().to_list() + + # For each cell-point pair, verify the inverse relationship + for cell_id, point_ids in enumerate(cells_to_points): + for point_id in point_ids: + # This point should have this cell in its star + assert cell_id in points_to_cells[point_id], ( + f"Cell {cell_id} contains point {point_id}, " + f"but point's star doesn't contain the cell " + f"({n_spatial_dims=}, {n_manifold_dims=})" + ) + + +class TestAdjacencyValidation: + """Test Adjacency class validation.""" + + def test_valid_adjacency(self, device): + """Test that valid adjacencies pass validation.""" + from physicsnemo.mesh.neighbors import Adjacency + + # Empty adjacency + adj = Adjacency( + offsets=torch.tensor([0], device=device), + indices=torch.tensor([], device=device), + ) + assert adj.n_sources == 0 + + # Single source with neighbors + adj = Adjacency( + offsets=torch.tensor([0, 3], device=device), + indices=torch.tensor([1, 2, 3], device=device), + ) + assert adj.n_sources == 1 + + # Multiple sources with varying neighbor counts + adj = Adjacency( + offsets=torch.tensor([0, 2, 2, 5], device=device), + indices=torch.tensor([10, 11, 12, 13, 14], device=device), + ) + assert adj.n_sources == 3 + + def test_invalid_empty_offsets(self, device): + """Test that empty offsets array raises error.""" + from physicsnemo.mesh.neighbors import Adjacency + + with pytest.raises(ValueError, match="Offsets array must have length >= 1"): + Adjacency( + offsets=torch.tensor( + [], device=device + ), # Invalid: should be at least [0] + indices=torch.tensor([], device=device), + ) + + def test_invalid_first_offset(self, device): + """Test that non-zero first offset raises error.""" + from physicsnemo.mesh.neighbors import Adjacency + + with pytest.raises(ValueError, match="First offset must be 0"): + Adjacency( + offsets=torch.tensor([1, 3, 5], device=device), # Should start at 0 + indices=torch.tensor([0, 1], device=device), + ) + + def test_invalid_last_offset(self, device): + """Test that mismatched last offset raises error.""" + from physicsnemo.mesh.neighbors import Adjacency + + with pytest.raises( + ValueError, match="Last offset must equal length of indices" + ): + Adjacency( + offsets=torch.tensor([0, 2, 5], device=device), # Says 5 indices + indices=torch.tensor([0, 1, 2], device=device), # But only 3 indices + ) + + with pytest.raises( + ValueError, match="Last offset must equal length of indices" + ): + Adjacency( + offsets=torch.tensor([0, 2], device=device), # Says 2 indices + indices=torch.tensor([0, 1, 2, 3], device=device), # But has 4 indices + ) + + +class TestEdgeCases: + """Test edge cases and special scenarios.""" + + def test_empty_mesh(self, device): + """Test adjacency computation on empty mesh.""" + mesh = Mesh( + points=torch.zeros(0, 3, device=device), + cells=torch.zeros(0, 3, dtype=torch.int64, device=device), + ) + + # Point-to-points + adj = mesh.get_point_to_points_adjacency() + assert adj.n_sources == 0 + assert len(adj.indices) == 0 + assert_on_device(adj.offsets, device) + + # Point-to-cells + adj = mesh.get_point_to_cells_adjacency() + assert adj.n_sources == 0 + assert len(adj.indices) == 0 + + # Cell-to-cells + adj = mesh.get_cell_to_cells_adjacency() + assert adj.n_sources == 0 + assert len(adj.indices) == 0 + + # Cells-to-points + adj = mesh.get_cell_to_points_adjacency() + assert adj.n_sources == 0 + assert len(adj.indices) == 0 + + def test_isolated_triangle(self, device): + """Test single triangle (no cell neighbors).""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + + mesh = Mesh(points=points, cells=cells) + + # Cell-to-cells: no neighbors + adj = mesh.get_cell_to_cells_adjacency() + neighbors = adj.to_list() + assert neighbors == [[]] + + # Point-to-points: all connected + adj = mesh.get_point_to_points_adjacency() + neighbors = adj.to_list() + assert sorted(neighbors[0]) == [1, 2] + assert sorted(neighbors[1]) == [0, 2] + assert sorted(neighbors[2]) == [0, 1] + + def test_isolated_points(self, device): + """Test mesh with isolated points (not in any cells).""" + # Create mesh with 5 points but only 1 triangle using points 0,1,2 + # Points 3 and 4 are isolated + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [2.0, 2.0], # Isolated + [3.0, 3.0], # Isolated + ], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + + mesh = Mesh(points=points, cells=cells) + + # Point-to-cells: isolated points should have empty stars + adj = mesh.get_point_to_cells_adjacency() + stars = adj.to_list() + assert len(stars[0]) > 0 # Point 0 is in cells + assert len(stars[1]) > 0 # Point 1 is in cells + assert len(stars[2]) > 0 # Point 2 is in cells + assert len(stars[3]) == 0 # Point 3 is isolated + assert len(stars[4]) == 0 # Point 4 is isolated + + # Point-to-points: isolated points should have no neighbors + adj = mesh.get_point_to_points_adjacency() + neighbors = adj.to_list() + assert len(neighbors[3]) == 0 + assert len(neighbors[4]) == 0 + + def test_single_point_mesh(self, device): + """Test mesh with single point and no cells.""" + points = torch.tensor([[0.0, 0.0, 0.0]], device=device) + cells = torch.zeros((0, 3), dtype=torch.int64, device=device) + + mesh = Mesh(points=points, cells=cells) + + # Point-to-cells: single point with no cells + adj = mesh.get_point_to_cells_adjacency() + assert adj.n_sources == 1 + assert len(adj.indices) == 0 + assert adj.to_list() == [[]] + + # Point-to-points: single point with no neighbors + adj = mesh.get_point_to_points_adjacency() + assert adj.n_sources == 1 + assert len(adj.indices) == 0 + assert adj.to_list() == [[]] + + def test_1d_manifold_edges(self, device): + """Test adjacency on 1D manifold (polyline/edges).""" + # Create a simple polyline: 0--1--2--3 + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [2.0, 0.0, 0.0], + [3.0, 0.0, 0.0], + ], + device=device, + ) + cells = torch.tensor( + [ + [0, 1], # Edge 0 + [1, 2], # Edge 1 + [2, 3], # Edge 2 + ], + device=device, + dtype=torch.int64, + ) + + mesh = Mesh(points=points, cells=cells) + + # Cell-to-cells (codim 1 = sharing a vertex for edges) + adj = mesh.get_cell_to_cells_adjacency(adjacency_codimension=1) + neighbors = adj.to_list() + + # Edge 0 shares vertex 1 with edge 1 + assert sorted(neighbors[0]) == [1] + # Edge 1 shares vertex 1 with edge 0, vertex 2 with edge 2 + assert sorted(neighbors[1]) == [0, 2] + # Edge 2 shares vertex 2 with edge 1 + assert sorted(neighbors[2]) == [1] + + # Point-to-points should give the polyline connectivity + adj = mesh.get_point_to_points_adjacency() + neighbors = adj.to_list() + assert sorted(neighbors[0]) == [1] + assert sorted(neighbors[1]) == [0, 2] + assert sorted(neighbors[2]) == [1, 3] + assert sorted(neighbors[3]) == [2] + + def test_dtype_consistency(self, device): + """Test that all adjacency indices use int64 dtype.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], device=device) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + + mesh = Mesh(points=points, cells=cells) + + # Check all adjacency types + adjacencies = [ + mesh.get_point_to_points_adjacency(), + mesh.get_point_to_cells_adjacency(), + mesh.get_cell_to_cells_adjacency(), + mesh.get_cell_to_points_adjacency(), + ] + + for adj in adjacencies: + assert adj.offsets.dtype == torch.int64, ( + f"Expected offsets dtype int64, got {adj.offsets.dtype}" + ) + assert adj.indices.dtype == torch.int64, ( + f"Expected indices dtype int64, got {adj.indices.dtype}" + ) + + def test_neighbor_count_conservation(self, device): + """Test conservation of neighbor relationships.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ], + device=device, + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ], + device=device, + dtype=torch.int64, + ) + + mesh = Mesh(points=points, cells=cells) + + # Point-to-points: total edges counted twice (bidirectional) + adj = mesh.get_point_to_points_adjacency() + total_bidirectional_edges = adj.n_total_neighbors + # Should be even since each edge appears twice + assert total_bidirectional_edges % 2 == 0 + + # Cell-to-cells: total adjacencies counted twice (bidirectional) + adj = mesh.get_cell_to_cells_adjacency() + total_bidirectional_adjacencies = adj.n_total_neighbors + # Should be even + assert total_bidirectional_adjacencies % 2 == 0 + + # Point-to-cells: sum should equal cells-to-points + point_to_cells = mesh.get_point_to_cells_adjacency() + cells_to_points = mesh.get_cell_to_points_adjacency() + assert point_to_cells.n_total_neighbors == cells_to_points.n_total_neighbors + + def test_cross_adjacency_consistency(self, device): + """Test consistency between different adjacency relationships.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ], + device=device, + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ], + device=device, + dtype=torch.int64, + ) + + mesh = Mesh(points=points, cells=cells) + + # Get all adjacencies + point_to_points = mesh.get_point_to_points_adjacency().to_list() + point_to_cells = mesh.get_point_to_cells_adjacency().to_list() + cells_to_points = mesh.get_cell_to_points_adjacency().to_list() + cell_to_cells = mesh.get_cell_to_cells_adjacency().to_list() + + # Consistency check 1: If points A and B are neighbors, + # there must exist a cell containing both + for point_a, neighbors in enumerate(point_to_points): + for point_b in neighbors: + # Find cells containing point_a + cells_with_a = set(point_to_cells[point_a]) + # Find cells containing point_b + cells_with_b = set(point_to_cells[point_b]) + # There must be at least one cell containing both + shared_cells = cells_with_a & cells_with_b + assert len(shared_cells) > 0, ( + f"Points {point_a} and {point_b} are neighbors but share no cells" + ) + + # Consistency check 2: cells_to_points is inverse of point_to_cells + for cell_id, point_ids in enumerate(cells_to_points): + for point_id in point_ids: + assert cell_id in point_to_cells[point_id], ( + f"Cell {cell_id} contains point {point_id}, " + f"but point's star doesn't contain the cell" + ) + + # Consistency check 3: If cells A and B are neighbors (share edge), + # they must share at least 2 vertices + for cell_a, neighbors in enumerate(cell_to_cells): + for cell_b in neighbors: + vertices_a = set(cells_to_points[cell_a]) + vertices_b = set(cells_to_points[cell_b]) + shared_vertices = vertices_a & vertices_b + # Sharing an edge means at least 2 shared vertices + assert len(shared_vertices) >= 2, ( + f"Cells {cell_a} and {cell_b} are neighbors but share " + f"{len(shared_vertices)} vertices (expected >= 2)" + ) + + +class TestDisjointMeshNeighborhood: + """Test neighbor computation on disjoint meshes. + + Verifies that merging two spatially-separated meshes produces connectivity + identical to computing connectivity separately, accounting for index offsets. + """ + + @pytest.fixture + def sphere_pair(self, device): + """Create two spheres with different resolutions, spatially separated.""" + from physicsnemo.mesh.primitives.surfaces.sphere_icosahedral import ( + load as load_sphere, + ) + + # Create sphere A with subdivision level 1 + sphere_a = load_sphere(radius=1.0, subdivisions=1, device=device) + + # Create sphere B with subdivision level 2 (different resolution) + sphere_b_base = load_sphere(radius=1.0, subdivisions=2, device=device) + + # Translate sphere B far away to ensure disjoint (100 units in x-direction) + translation = torch.tensor([100.0, 0.0, 0.0], device=device) + sphere_b = Mesh( + points=sphere_b_base.points + translation, + cells=sphere_b_base.cells, + point_data=sphere_b_base.point_data, + cell_data=sphere_b_base.cell_data, + global_data=sphere_b_base.global_data, + ) + + return sphere_a, sphere_b + + @staticmethod + def _disjoint_offsets(sphere_a, adj_type): + """Return (n_sources_a, n_targets_a) for a disjoint merge. + + These determine how indices are offset in the merged mesh: + - n_sources_a: number of source entities in sphere A (index offset for B's sources) + - n_targets_a: number of target entities in sphere A (value offset for B's targets) + """ + if adj_type == "point_to_points": + return sphere_a.n_points, sphere_a.n_points + elif adj_type == "cell_to_cells": + return sphere_a.n_cells, sphere_a.n_cells + elif adj_type == "point_to_cells": + return sphere_a.n_points, sphere_a.n_cells + elif adj_type == "cells_to_points": + return sphere_a.n_cells, sphere_a.n_points + raise ValueError(f"Unknown adj_type: {adj_type}") + + @pytest.mark.parametrize("adj_type", _ADJACENCY_TYPES) + def test_disjoint_adjacency(self, sphere_pair, adj_type): + """Verify adjacency for disjoint meshes preserves individual connectivity.""" + sphere_a, sphere_b = sphere_pair + + # Compute adjacency for individual meshes + adj_a = _compute_adjacency(sphere_a, adj_type) + adj_b = _compute_adjacency(sphere_b, adj_type) + + results_a = adj_a.to_list() + results_b = adj_b.to_list() + + # Merge the meshes + merged = Mesh.merge([sphere_a, sphere_b]) + adj_merged = _compute_adjacency(merged, adj_type) + results_merged = adj_merged.to_list() + + n_sources_a, n_targets_a = self._disjoint_offsets(sphere_a, adj_type) + + # cells_to_points preserves vertex ordering; others use set comparison + order_sensitive = adj_type == "cells_to_points" + normalize = (lambda x: x) if order_sensitive else sorted + + # Check sphere A's entries in merged mesh + for i in range(n_sources_a): + expected = normalize(results_a[i]) + actual = normalize(results_merged[i]) + assert actual == expected, ( + f"Source {i} (sphere A) {adj_type} mismatch in merged mesh:\n" + f" expected: {expected}\n" + f" actual: {actual}" + ) + + # Check sphere B's entries (targets offset by n_targets_a) + for i in range(len(results_b)): + expected = normalize([n + n_targets_a for n in results_b[i]]) + actual = normalize(results_merged[i + n_sources_a]) + assert actual == expected, ( + f"Source {i} (sphere B, index {i + n_sources_a} in merged) " + f"{adj_type} mismatch:\n" + f" expected: {expected}\n" + f" actual: {actual}" + ) + + # Verify no cross-mesh connections (critical for disjoint property) + for i in range(n_sources_a): + for target in results_merged[i]: + assert target < n_targets_a, ( + f"Source {i} in sphere A has target {target} from sphere B " + f"({adj_type} disjoint violation)" + ) + + for i in range(len(results_b)): + merged_idx = i + n_sources_a + for target in results_merged[merged_idx]: + assert target >= n_targets_a, ( + f"Source {merged_idx} in sphere B has target {target} " + f"from sphere A ({adj_type} disjoint violation)" + ) + + +class TestNeighborTransformationInvariance: + """Test that neighbor computation is invariant under geometric transformations. + + Verifies that translation, rotation, and reflection preserve topological + connectivity, as they should since these operations don't change mesh topology. + """ + + @pytest.fixture + def sphere_mesh(self, device): + """Create a sphere mesh for transformation testing.""" + from physicsnemo.mesh.primitives.surfaces.sphere_icosahedral import ( + load as load_sphere, + ) + + return load_sphere(radius=1.0, subdivisions=2, device=device) + + def _create_rotation_matrix( + self, axis: torch.Tensor, angle_rad: float + ) -> torch.Tensor: + """Create a 3D rotation matrix using Rodrigues' rotation formula. + + Args: + axis: Rotation axis (will be normalized), shape (3,) + angle_rad: Rotation angle in radians + + Returns: + Rotation matrix, shape (3, 3) + """ + # Normalize axis + axis = axis / torch.norm(axis) + x, y, z = axis[0], axis[1], axis[2] + + c = torch.cos(torch.tensor(angle_rad, device=axis.device)) + s = torch.sin(torch.tensor(angle_rad, device=axis.device)) + t = 1 - c + + # Rodrigues' rotation matrix + rotation = torch.tensor( + [ + [t * x * x + c, t * x * y - s * z, t * x * z + s * y], + [t * x * y + s * z, t * y * y + c, t * y * z - s * x], + [t * x * z - s * y, t * y * z + s * x, t * z * z + c], + ], + device=axis.device, + dtype=axis.dtype, + ) + + return rotation + + def _create_reflection_matrix(self, normal: torch.Tensor) -> torch.Tensor: + """Create a 3D reflection matrix across a plane. + + Args: + normal: Plane normal vector (will be normalized), shape (3,) + + Returns: + Reflection matrix, shape (3, 3) + """ + # Normalize normal + n = normal / torch.norm(normal) + + # Householder reflection: I - 2*n*n^T + reflection = torch.eye(3, device=n.device, dtype=n.dtype) - 2 * torch.outer( + n, n + ) + + return reflection + + def _apply_transform(self, points: torch.Tensor, transform: str) -> torch.Tensor: + """Apply a geometric transformation to mesh points. + + Args: + points: Point coordinates, shape (N, 3) + transform: One of "translation", "rotation", "reflection" + + Returns: + Transformed points, shape (N, 3) + """ + if transform == "translation": + translation = torch.tensor([10.0, -5.0, 7.5], device=points.device) + return points + translation + elif transform == "rotation": + axis = torch.tensor([1.0, 1.0, 1.0], device=points.device) + angle = torch.pi / 4 + rotation_matrix = self._create_rotation_matrix(axis, angle) + return torch.matmul(points, rotation_matrix.T) + elif transform == "reflection": + normal = torch.tensor([1.0, 0.0, 0.0], device=points.device) + reflection_matrix = self._create_reflection_matrix(normal) + return torch.matmul(points, reflection_matrix.T) + else: + raise ValueError(f"Unknown transform: {transform}") + + @pytest.mark.parametrize("adj_type", _ADJACENCY_TYPES) + @pytest.mark.parametrize("transform", _TRANSFORMS) + def test_adjacency_transformation_invariant(self, sphere_mesh, adj_type, transform): + """Verify adjacency is invariant under geometric transformations.""" + original = sphere_mesh + + # Compute adjacency for original mesh + adj_original = _compute_adjacency(original, adj_type) + results_original = adj_original.to_list() + + # Apply transformation + transformed_points = self._apply_transform(original.points, transform) + transformed = Mesh( + points=transformed_points, + cells=original.cells, + point_data=original.point_data, + cell_data=original.cell_data, + global_data=original.global_data, + ) + + # Compute adjacency for transformed mesh + adj_transformed = _compute_adjacency(transformed, adj_type) + results_transformed = adj_transformed.to_list() + + # Connectivity should be identical + assert results_original == results_transformed, ( + f"{transform.title()} changed {adj_type} connectivity (topology violation)" + ) diff --git a/test/mesh/primitives/test_planar.py b/test/mesh/primitives/test_planar.py index 7649374388..8051489f51 100644 --- a/test/mesh/primitives/test_planar.py +++ b/test/mesh/primitives/test_planar.py @@ -50,8 +50,8 @@ def test_planar_mesh(self, example_name): def test_subdivision_control(self): """Test that subdivision parameter works.""" - square_coarse = primitives.planar.unit_square.load(n_subdivisions=0) - square_fine = primitives.planar.unit_square.load(n_subdivisions=2) + square_coarse = primitives.planar.unit_square.load(subdivisions=0) + square_fine = primitives.planar.unit_square.load(subdivisions=2) assert square_fine.n_points > square_coarse.n_points assert square_fine.n_cells > square_coarse.n_cells diff --git a/test/mesh/primitives/test_text.py b/test/mesh/primitives/test_text.py new file mode 100644 index 0000000000..1273e7042b --- /dev/null +++ b/test/mesh/primitives/test_text.py @@ -0,0 +1,121 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for text rendering primitives.""" + +import pytest + +# Skip this module if matplotlib is not available (text primitives require it) +pytest.importorskip("matplotlib") + +from physicsnemo.mesh.primitives.text import ( # noqa: E402 + text_1d_2d, + text_2d_2d, + text_2d_3d, + text_3d_3d, +) + + +def test_text_1d_2d(): + """Test 1D curve in 2D space text rendering.""" + mesh = text_1d_2d() + + assert mesh.n_manifold_dims == 1, "Should be 1D manifold" + assert mesh.n_spatial_dims == 2, "Should be in 2D space" + assert mesh.n_points > 0, "Should have points" + assert mesh.n_cells > 0, "Should have cells (edges)" + assert mesh.cells.shape[1] == 2, "Edges should have 2 vertices" + + +def test_text_2d_2d(): + """Test 2D surface in 2D space text rendering.""" + mesh = text_2d_2d() + + assert mesh.n_manifold_dims == 2, "Should be 2D manifold" + assert mesh.n_spatial_dims == 2, "Should be in 2D space" + assert mesh.n_points > 0, "Should have points" + assert mesh.n_cells > 0, "Should have cells (triangles)" + assert mesh.cells.shape[1] == 3, "Triangles should have 3 vertices" + + +def test_text_3d_3d(): + """Test 3D volume in 3D space text rendering.""" + mesh = text_3d_3d() + + assert mesh.n_manifold_dims == 3, "Should be 3D manifold" + assert mesh.n_spatial_dims == 3, "Should be in 3D space" + assert mesh.n_points > 0, "Should have points" + assert mesh.n_cells > 0, "Should have cells (tetrahedra)" + assert mesh.cells.shape[1] == 4, "Tetrahedra should have 4 vertices" + + +def test_text_2d_3d(): + """Test 2D surface in 3D space text rendering.""" + mesh = text_2d_3d() + + assert mesh.n_manifold_dims == 2, "Should be 2D manifold" + assert mesh.n_spatial_dims == 3, "Should be in 3D space" + assert mesh.n_points > 0, "Should have points" + assert mesh.n_cells > 0, "Should have cells (triangles)" + assert mesh.cells.shape[1] == 3, "Triangles should have 3 vertices" + + +def test_text_custom_text(): + """Test text rendering with custom text.""" + mesh = text_2d_2d(text="Test", font_size=10.0) + + assert mesh.n_manifold_dims == 2 + assert mesh.n_spatial_dims == 2 + assert mesh.n_points > 0 + assert mesh.n_cells > 0 + + +@pytest.mark.parametrize( + "device", ["cpu", pytest.param("cuda", marks=pytest.mark.cuda)] +) +def test_text_device(device): + """Test text rendering works on different devices.""" + mesh = text_2d_2d(device=device) + + assert mesh.points.device.type == device + assert mesh.cells.device.type == device + + +def test_text_extrusion_height(): + """Test custom extrusion height.""" + mesh1 = text_3d_3d(extrusion_height=1.0) + mesh2 = text_3d_3d(extrusion_height=3.0) + + # Different extrusion heights should produce different z-ranges + z_range1 = mesh1.points[:, 2].max() - mesh1.points[:, 2].min() + z_range2 = mesh2.points[:, 2].max() - mesh2.points[:, 2].min() + + assert z_range2 > z_range1, "Larger extrusion should produce larger z-range" + + +def test_text_max_segment_length(): + """Test that max_segment_length controls edge refinement.""" + mesh_coarse = text_1d_2d(max_segment_length=1.0) + mesh_fine = text_1d_2d(max_segment_length=0.1) + + # Finer segmentation should have more points + assert mesh_fine.n_points > mesh_coarse.n_points, ( + "Smaller max_segment_length should produce more points" + ) + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/test/mesh/primitives/test_volumes.py b/test/mesh/primitives/test_volumes.py index bf731a2fc1..d809db36e2 100644 --- a/test/mesh/primitives/test_volumes.py +++ b/test/mesh/primitives/test_volumes.py @@ -17,9 +17,11 @@ """Tests for volume example meshes.""" import pytest +import torch from physicsnemo.core.version_check import check_version_spec from physicsnemo.mesh import primitives +from physicsnemo.mesh.primitives.procedural import lumpy_ball # Volume primitives that don't require pyvista PYVISTA_FREE_VOLUMES = ["cube_volume", "tetrahedron_volume"] @@ -61,8 +63,8 @@ def test_volume_mesh_pyvista(self, example_name): def test_cube_volume_subdivision(self): """Test cube volume subdivision.""" - cube_coarse = primitives.volumes.cube_volume.load(n_subdivisions=2) - cube_fine = primitives.volumes.cube_volume.load(n_subdivisions=4) + cube_coarse = primitives.volumes.cube_volume.load(subdivisions=2) + cube_fine = primitives.volumes.cube_volume.load(subdivisions=4) assert cube_fine.n_cells > cube_coarse.n_cells @@ -83,3 +85,227 @@ def test_delaunay_volumes(self, example_name): # Should have reasonable number of cells assert mesh.n_cells > 10 + + +class TestCubeVolumeBoundary: + """Test that cube_volume boundary extraction produces correct axis-aligned faces. + + A cube's boundary should consist only of triangular faces that lie on the + six axis-aligned faces of the cube. This validates that the tetrahedral + decomposition correctly shares internal faces between adjacent cells. + """ + + @pytest.mark.parametrize("subdivisions", [1, 2, 3, 4]) + def test_boundary_vertices_on_cube_faces(self, subdivisions): + """All boundary vertices should lie on cube faces (have coord at ±0.5).""" + size = 1.0 + half = size / 2 + + cube = primitives.volumes.cube_volume.load( + size=size, subdivisions=subdivisions + ).clean() + boundary = cube.get_boundary_mesh().clean() + + # Get unique vertices used by boundary cells + boundary_vertex_indices = boundary.cells.unique() + boundary_vertices = boundary.points[boundary_vertex_indices] + + # Each boundary vertex must have at least one coordinate at ±half + at_boundary = torch.abs(boundary_vertices.abs() - half) < 1e-6 + has_boundary_coord = at_boundary.any(dim=1) + + n_invalid = (~has_boundary_coord).sum().item() + assert n_invalid == 0, ( + f"Found {n_invalid} boundary vertices not on cube faces. " + f"Example: {boundary_vertices[~has_boundary_coord][0].tolist()}" + ) + + @pytest.mark.parametrize("subdivisions", [1, 2, 3, 4]) + def test_boundary_normals_axis_aligned(self, subdivisions): + """All boundary normals should be axis-aligned (1-hot vectors).""" + cube = primitives.volumes.cube_volume.load(subdivisions=subdivisions).clean() + boundary = cube.get_boundary_mesh().clean() + + normals = boundary.cell_normals + + # For axis-aligned normals, exactly one component should be ±1 + # and the others should be 0 + abs_normals = normals.abs() + max_component = abs_normals.max(dim=1).values + is_axis_aligned = (max_component - 1.0).abs() < 1e-6 + + n_diagonal = (~is_axis_aligned).sum().item() + assert n_diagonal == 0, ( + f"Found {n_diagonal} non-axis-aligned normals out of {boundary.n_cells}. " + f"Example: {normals[~is_axis_aligned][0].tolist()}" + ) + + @pytest.mark.parametrize("subdivisions", [1, 2, 3, 4]) + def test_boundary_triangle_count(self, subdivisions): + """Boundary should have exactly 6 × subdivisions² × 2 triangles.""" + cube = primitives.volumes.cube_volume.load(subdivisions=subdivisions).clean() + boundary = cube.get_boundary_mesh().clean() + + # Each face of the cube has subdivisions² small squares, + # each split into 2 triangles. 6 faces total. + expected_triangles = 6 * (subdivisions**2) * 2 + + assert boundary.n_cells == expected_triangles, ( + f"Expected {expected_triangles} boundary triangles for " + f"{subdivisions=}, got {boundary.n_cells}" + ) + + def test_boundary_is_watertight(self): + """Boundary surface of cube should be watertight.""" + cube = primitives.volumes.cube_volume.load(subdivisions=3).clean() + boundary = cube.get_boundary_mesh().clean() + + assert boundary.is_watertight(), ( + "Boundary surface should be watertight " + "(every edge shared by exactly 2 faces)" + ) + + def test_boundary_is_manifold(self): + """Boundary surface of cube should be a valid 2D manifold.""" + cube = primitives.volumes.cube_volume.load(subdivisions=3).clean() + boundary = cube.get_boundary_mesh().clean() + + assert boundary.is_manifold(), ( + "Boundary surface should be manifold (no T-junctions or non-manifold edges)" + ) + + +class TestLumpyBall: + """Tests for the lumpy_ball procedural volume primitive.""" + + def test_basic_instantiation(self): + """Test basic lumpy_ball creation.""" + mesh = lumpy_ball.load() + + assert mesh.n_manifold_dims == 3 + assert mesh.n_spatial_dims == 3 + assert mesh.n_points > 0 + assert mesh.n_cells > 0 + + def test_manifold_dimensions(self): + """Test that lumpy_ball is a 3D manifold in 3D space.""" + mesh = lumpy_ball.load(n_shells=2, subdivisions=1) + + assert mesh.n_manifold_dims == 3, "Should be 3D manifold (tetrahedra)" + assert mesh.n_spatial_dims == 3, "Should be in 3D space" + assert mesh.cells.shape[1] == 4, "Cells should be tetrahedra (4 vertices)" + + @pytest.mark.parametrize( + "n_shells,subdivisions,expected_cells", + [ + (1, 0, 20), # 20 faces * (3*1 - 2) = 20 * 1 = 20 + (2, 0, 80), # 20 faces * (3*2 - 2) = 20 * 4 = 80 + (2, 1, 320), # 80 faces * (3*2 - 2) = 80 * 4 = 320 + (3, 1, 560), # 80 faces * (3*3 - 2) = 80 * 7 = 560 + (3, 2, 2240), # 320 faces * (3*3 - 2) = 320 * 7 = 2240 + ], + ) + def test_cell_count_formula(self, n_shells, subdivisions, expected_cells): + """Verify cell count matches formula: n_faces * (3*n_shells - 2).""" + mesh = lumpy_ball.load(n_shells=n_shells, subdivisions=subdivisions) + + assert mesh.n_cells == expected_cells, ( + f"Expected {expected_cells} cells for n_shells={n_shells}, " + f"subdivisions={subdivisions}, got {mesh.n_cells}" + ) + + def test_resolution_scaling(self): + """Test that more shells/subdivisions = more cells.""" + mesh_coarse = lumpy_ball.load(n_shells=2, subdivisions=1) + mesh_fine_shells = lumpy_ball.load(n_shells=4, subdivisions=1) + mesh_fine_subdiv = lumpy_ball.load(n_shells=2, subdivisions=2) + + assert mesh_fine_shells.n_cells > mesh_coarse.n_cells + assert mesh_fine_subdiv.n_cells > mesh_coarse.n_cells + + def test_noise_reproducibility(self): + """Test that same seed produces same mesh.""" + mesh1 = lumpy_ball.load(noise_amplitude=0.3, seed=42) + mesh2 = lumpy_ball.load(noise_amplitude=0.3, seed=42) + mesh3 = lumpy_ball.load(noise_amplitude=0.3, seed=123) + + # Same seed should produce identical points + assert torch.allclose(mesh1.points, mesh2.points) + # Different seed should produce different points + assert not torch.allclose(mesh1.points, mesh3.points) + + def test_noise_amplitude_effect(self): + """Test that noise amplitude affects vertex positions.""" + mesh_no_noise = lumpy_ball.load(noise_amplitude=0.0, seed=42) + mesh_with_noise = lumpy_ball.load(noise_amplitude=0.5, seed=42) + + # With noise, points should differ from no-noise version + assert not torch.allclose(mesh_no_noise.points, mesh_with_noise.points) + + # No-noise mesh should have points approximately on sphere shells + # (center point at origin, shell points at expected radii) + assert torch.allclose(mesh_no_noise.points[0], torch.zeros(3), atol=1e-6), ( + "Center point should be at origin" + ) + + def test_center_point(self): + """Test that center point is at origin.""" + mesh = lumpy_ball.load(noise_amplitude=0.3, seed=42) + + # Even with noise, center point (index 0) should be at origin + assert torch.allclose(mesh.points[0], torch.zeros(3), atol=1e-6) + + @pytest.mark.parametrize("device", ["cpu", "cuda"]) + def test_device(self, device): + """Test lumpy_ball on different devices.""" + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA not available") + + mesh = lumpy_ball.load(device=device) + + assert mesh.points.device.type == device + assert mesh.cells.device.type == device + + def test_validation_errors(self): + """Test parameter validation.""" + with pytest.raises(ValueError, match="radius must be positive"): + lumpy_ball.load(radius=-1.0) + + with pytest.raises(ValueError, match="n_shells must be at least 1"): + lumpy_ball.load(n_shells=0) + + with pytest.raises(ValueError, match="subdivisions must be non-negative"): + lumpy_ball.load(subdivisions=-1) + + with pytest.raises(ValueError, match="noise_amplitude must be non-negative"): + lumpy_ball.load(noise_amplitude=-0.1) + + @pytest.mark.parametrize("noise_amplitude", [0.3, 0.5, 0.8]) + def test_high_noise_valid_tetrahedra(self, noise_amplitude): + """Test that high noise doesn't create degenerate tetrahedra. + + With correlated noise across shells (all shells are scaled versions + of the same noisy shape), tetrahedra should remain valid regardless + of noise amplitude. + """ + mesh = lumpy_ball.load( + noise_amplitude=noise_amplitude, seed=42, n_shells=3, subdivisions=1 + ) + + # Compute signed tetrahedron volumes using scalar triple product. + # Note: mesh.cell_areas uses Gram determinant which gives unsigned values. + # For orientation checking, we need signed volumes: + # V = (1/6) * (b-a) · ((c-a) × (d-a)) + # Positive V means vertices (a,b,c,d) have consistent right-hand orientation. + tet_verts = mesh.points[mesh.cells] # (n_cells, 4, 3) + a, b, c, d = tet_verts[:, 0], tet_verts[:, 1], tet_verts[:, 2], tet_verts[:, 3] + ab, ac, ad = b - a, c - a, d - a + signed_volumes = torch.einsum("ij,ij->i", ab, torch.cross(ac, ad, dim=1)) / 6.0 + + # All tetrahedra should have consistent orientation (same sign) + # If any have opposite sign, the mesh has inverted cells + assert torch.all(signed_volumes > 0), ( + f"Some tetrahedra have negative volume (inverted) with " + f"noise_amplitude={noise_amplitude}. " + f"Min volume: {signed_volumes.min().item():.6f}" + ) diff --git a/test/mesh/projections/test_point_normals.py b/test/mesh/projections/test_point_normals.py new file mode 100644 index 0000000000..283268f036 --- /dev/null +++ b/test/mesh/projections/test_point_normals.py @@ -0,0 +1,613 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for point normal computation. + +Tests area-weighted vertex normal calculation across various mesh types, +dimensions, and edge cases. +""" + +import pytest +import torch + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.primitives.procedural import lumpy_sphere +from physicsnemo.mesh.utilities._cache import get_cached + +### Helper Functions + + +def create_single_triangle_2d(device="cpu"): + """Create a single triangle in 2D space (codimension-1).""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + return Mesh(points=points, cells=cells) + + +def create_single_triangle_3d(device="cpu"): + """Create a single triangle in 3D space (codimension-1).""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + return Mesh(points=points, cells=cells) + + +def create_two_triangles_shared_edge(device="cpu"): + """Create two triangles sharing an edge in 3D space.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], # 0 + [1.0, 0.0, 0.0], # 1 + [0.5, 1.0, 0.0], # 2 + [0.5, 0.5, 1.0], # 3 (above the plane) + ], + dtype=torch.float32, + device=device, + ) + # Two triangles sharing edge (0,1) + cells = torch.tensor([[0, 1, 2], [0, 1, 3]], dtype=torch.int64, device=device) + return Mesh(points=points, cells=cells) + + +def create_edge_mesh_2d(device="cpu"): + """Create a 1D edge mesh in 2D space (codimension-1).""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1], [1, 2]], dtype=torch.int64, device=device) + return Mesh(points=points, cells=cells) + + +### Test Basic Functionality + + +class TestPointNormalsBasic: + """Basic tests for point normals computation.""" + + def test_single_triangle_2d(self, device): + """Test that 2D triangles in 2D space (codimension-0) raise an error.""" + mesh = create_single_triangle_2d(device) + + # Should raise ValueError for codimension-0 (not codimension-1) + with pytest.raises(ValueError, match="codimension-1"): + _ = mesh.point_normals + + def test_single_triangle_3d(self, device): + """Test point normals for a single triangle in 3D.""" + mesh = create_single_triangle_3d(device) + point_normals = mesh.point_normals + + # Should have normals for all 3 points + assert point_normals.shape == (3, 3) + + # All vertex normals should be unit vectors (or zero) + norms = torch.norm(point_normals, dim=-1) + assert torch.allclose(norms, torch.ones(3, device=device), atol=1e-5) + + # For a single flat triangle, all point normals should match the face normal + cell_normal = mesh.cell_normals[0] + for i in range(3): + assert torch.allclose(point_normals[i], cell_normal, atol=1e-5) + + def test_edge_mesh_2d(self, device): + """Test point normals for 1D edges in 2D (codimension-1).""" + mesh = create_edge_mesh_2d(device) + # 1D edges require area weighting (angle-based weighting not defined for 1D) + point_normals = mesh.compute_point_normals(weighting="area") + + # Should have normals for all 3 points + assert point_normals.shape == (3, 2) + + # All normals should be unit vectors + norms = torch.norm(point_normals, dim=-1) + assert torch.allclose(norms, torch.ones(3, device=device), atol=1e-5) + + # Middle point (1) is shared by two edges, should average their normals + # End points (0, 2) each belong to one edge only + + +### Test Area Weighting + + +class TestPointNormalsAreaWeighting: + """Tests for area-weighted averaging.""" + + def test_area_weighting_non_uniform_faces(self, device): + """Test that larger faces have more influence on point normals.""" + # Create a mesh with one large and one small triangle sharing an edge + points = torch.tensor( + [ + [0.0, 0.0, 0.0], # 0 + [1.0, 0.0, 0.0], # 1 (shared edge is 0-1) + [0.5, 10.0, 0.0], # 2 (large triangle) + [0.5, 0.1, 0.0], # 3 (small triangle) + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [0, 1, 3]], # Large triangle # Small triangle + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + # Get areas to verify one is much larger + areas = mesh.cell_areas + assert areas[0] > areas[1] * 5 # Large triangle is much bigger + + # Get point normals + point_normals = mesh.point_normals + cell_normals = mesh.cell_normals + + # For the shared edge points (0 and 1), the normal should be closer + # to the large triangle's normal due to area weighting + # Both triangles are in xy-plane, so both have normal in +z or -z direction + # The weighted average should still be in that direction + + # Check that vertex normals are unit vectors + for i in [0, 1]: + norm = torch.norm(point_normals[i]) + assert torch.abs(norm - 1.0) < 1e-5 + + # Verify cell normals are also unit vectors + assert torch.allclose( + torch.norm(cell_normals, dim=1), torch.ones(2, device=device), atol=1e-5 + ) + # Both cell normals should point in the same direction (both coplanar in xy-plane, pointing +z) + assert torch.allclose(cell_normals[0], cell_normals[1], atol=1e-5), ( + "Both triangles are coplanar, so normals should be identical" + ) + + def test_shared_edge_averaging(self, device): + """Test that shared edge vertices average normals from both triangles.""" + mesh = create_two_triangles_shared_edge(device) + + # Get normals + point_normals = mesh.point_normals + cell_normals = mesh.cell_normals + + # Verify cell normals are unit vectors + assert torch.allclose( + torch.norm(cell_normals, dim=1), torch.ones(2, device=device), atol=1e-5 + ) + + # Points 0 and 1 are shared by both triangles + # Their normals should be some average of the two cell normals + # For shared points, the point normal should be between the two cell normals + shared_point_normals = point_normals[[0, 1]] + for i in range(2): + # Dot product with both cell normals should be positive (same hemisphere) + dot0 = (shared_point_normals[i] * cell_normals[0]).sum() + dot1 = (shared_point_normals[i] * cell_normals[1]).sum() + assert dot0 > 0.5, ( + f"Shared point {i} normal should be similar to cell 0 normal" + ) + assert dot1 > 0.5, ( + f"Shared point {i} normal should be similar to cell 1 normal" + ) + + # Points 2 and 3 are only in one triangle each + # Point 2 in triangle 0 only + # Point 3 in triangle 1 only + + # All point normals should be unit vectors + norms = torch.norm(point_normals, dim=-1) + assert torch.allclose(norms, torch.ones(4, device=device), atol=1e-5) + + +### Test Edge Cases + + +class TestPointNormalsEdgeCases: + """Tests for edge cases and error conditions.""" + + def test_codimension_validation(self, device): + """Test that non-codimension-1 meshes raise an error.""" + # Create a tet mesh (3D in 3D, codimension-0) + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [0.5, 0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2, 3]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + # Should raise ValueError for codimension-0 + with pytest.raises(ValueError, match="codimension-1"): + _ = mesh.point_normals + + def test_caching(self, device): + """Test that point normals are cached in point_data.""" + mesh = create_single_triangle_3d(device) + + # First access + normals1 = mesh.point_normals + + # Check cached + assert get_cached(mesh.point_data, "normals") is not None + + # Second access should return cached value + normals2 = mesh.point_normals + + # Should be the same tensor + assert torch.allclose(normals1, normals2) + + def test_empty_mesh(self, device): + """Test handling of empty mesh.""" + points = torch.empty((0, 3), dtype=torch.float32, device=device) + cells = torch.empty((0, 3), dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + # Should return empty tensor + point_normals = mesh.point_normals + assert point_normals.shape == (0, 3) + + def test_isolated_point(self, device): + """Test that isolated points (not in any cell) get zero normals.""" + # Create mesh with extra point not in any cell + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [99.0, 99.0, 99.0], # Isolated point + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + point_normals = mesh.point_normals + + # First 3 points should have unit normals + for i in range(3): + norm = torch.norm(point_normals[i]) + assert torch.abs(norm - 1.0) < 1e-5 + + # Isolated point should have zero normal + assert torch.allclose( + point_normals[3], torch.zeros(3, device=device), atol=1e-6 + ) + + +### Test Different Dimensions + + +class TestPointNormalsDimensions: + """Tests across different manifold and spatial dimensions.""" + + def test_2d_edges_in_2d_space(self, device): + """Test 1D manifold (edges) in 2D space.""" + mesh = create_edge_mesh_2d(device) + # 1D edges require area weighting (angle-based weighting not defined for 1D) + point_normals = mesh.compute_point_normals(weighting="area") + + # Should work for codimension-1 + assert point_normals.shape == (3, 2) + + # All should be unit vectors + norms = torch.norm(point_normals, dim=-1) + assert torch.allclose(norms, torch.ones(3, device=device), atol=1e-5) + + def test_2d_triangles_in_3d_space(self, device): + """Test 2D manifold (triangles) in 3D space.""" + mesh = create_single_triangle_3d(device) + point_normals = mesh.point_normals + + assert point_normals.shape == (3, 3) + + # All should be unit vectors + norms = torch.norm(point_normals, dim=-1) + assert torch.allclose(norms, torch.ones(3, device=device), atol=1e-5) + + def test_1d_edges_in_3d_space(self, device): + """Test that 1D manifold (edges) in 3D space (codimension-2) raises error.""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [2.0, 0.0, 0.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1], [1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + # Should raise ValueError for codimension-2 (not codimension-1) + with pytest.raises(ValueError, match="codimension-1"): + _ = mesh.point_normals + + +### Test Numerical Stability + + +class TestPointNormalsNumerical: + """Tests for numerical stability and precision.""" + + def test_normalization_stability(self, device): + """Test that normalization is stable for various configurations.""" + # Create a very small triangle (but not so small that float32 loses precision) + points = torch.tensor( + [[0.0, 0.0, 0.0], [1e-3, 0.0, 0.0], [0.5e-3, 1e-3, 0.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + point_normals = mesh.point_normals + + # Should still produce unit normals + norms = torch.norm(point_normals, dim=-1) + assert torch.allclose(norms, torch.ones(3, device=device), atol=1e-4) + + def test_consistent_across_scales(self, device): + """Test that point normals are consistent when mesh is scaled.""" + # Create mesh + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh1 = Mesh(points=points, cells=cells) + + # Scaled version + mesh2 = Mesh(points=points * 100.0, cells=cells) + + normals1 = mesh1.point_normals + normals2 = mesh2.point_normals + + # Normals should be the same (direction doesn't depend on scale) + assert torch.allclose(normals1, normals2, atol=1e-5) + + +### Test Consistency with Cell Normals + + +class TestPointCellNormalConsistency: + """Tests for consistency between point normals and cell normals.""" + + def compute_angular_errors(self, mesh): + """Compute angular errors between each cell normal and its vertex normals. + + Returns: + Tensor of angular errors (in radians) for each cell-vertex pair. + Shape: (n_cells * n_vertices_per_cell,) + """ + cell_normals = mesh.cell_normals # (n_cells, n_spatial_dims) + point_normals = mesh.point_normals # (n_points, n_spatial_dims) + + n_cells, n_vertices_per_cell = mesh.cells.shape + + # Get point normals for each vertex of each cell + # Shape: (n_cells, n_vertices_per_cell, n_spatial_dims) + point_normals_per_cell = point_normals[mesh.cells] + + # Repeat cell normals for each vertex + # Shape: (n_cells, n_vertices_per_cell, n_spatial_dims) + cell_normals_repeated = cell_normals.unsqueeze(1).expand( + -1, n_vertices_per_cell, -1 + ) + + # Compute dot products (cosine of angle) + # Shape: (n_cells, n_vertices_per_cell) + cos_angles = (cell_normals_repeated * point_normals_per_cell).sum(dim=-1) + + # Clamp to [-1, 1] to avoid numerical issues with acos + cos_angles = torch.clamp(cos_angles, -1.0, 1.0) + + # Compute angular errors in radians + # Shape: (n_cells * n_vertices_per_cell,) + angular_errors = torch.acos(cos_angles).flatten() + + return angular_errors + + def test_flat_surface_perfect_alignment(self, device): + """Test that flat surfaces have perfect alignment between point and cell normals.""" + # Create a flat triangular mesh (all normals should be identical) + mesh = create_single_triangle_3d(device) + + angular_errors = self.compute_angular_errors(mesh) + + # All errors should be essentially zero for a single flat triangle + assert torch.all(angular_errors < 1e-5) + + def test_smooth_surface_consistency(self, device): + """Test that smooth surfaces have good alignment.""" + # Create multiple coplanar triangles (smooth surface) + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [2.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [1.5, 1.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor( + [[0, 1, 3], [1, 2, 4], [1, 4, 3]], + dtype=torch.int64, + device=device, + ) + mesh = Mesh(points=points, cells=cells) + + angular_errors = self.compute_angular_errors(mesh) + + # All errors should be very small for coplanar triangles + assert torch.all(angular_errors < 1e-4) + + def test_sharp_edge_detection(self, device): + """Test that sharp edges produce larger angular errors.""" + # Create two triangles at 90 degrees to each other + points = torch.tensor( + [ + [0.0, 0.0, 0.0], # Shared edge + [1.0, 0.0, 0.0], # Shared edge + [0.5, 1.0, 0.0], # In xy-plane + [0.5, 0.0, 1.0], # In xz-plane (90 degrees rotated) + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2], [0, 1, 3]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + angular_errors = self.compute_angular_errors(mesh) + + # Some errors should be larger due to the sharp edge + # But most should still be reasonable (< pi/2) + assert torch.any(angular_errors > 0.1) # Some significant errors + assert torch.all(angular_errors < torch.pi / 2) # But not too extreme + + def test_real_mesh_consistency(self, device): + """Test consistency on a realistic mesh (lumpy sphere). + + The lumpy sphere has varying curvature which causes point normals + (area-weighted averages) to differ from cell normals. This is expected + behavior - higher curvature regions naturally have larger angular errors + between point and cell normals. + """ + # Load lumpy sphere - a realistic mesh with interesting curvature + mesh = lumpy_sphere.load(subdivisions=2, device=device) + + # Compute angular errors + angular_errors = self.compute_angular_errors(mesh) + + # Lumpy sphere has varying curvature, so some angular error is expected + # Mean error should be reasonable (< 0.3 rad = 17 degrees) + assert angular_errors.mean() < 0.3 + # Max error should be bounded (< 1.5 rad = 86 degrees) + assert angular_errors.max() < 1.5 + + def test_subdivided_mesh_improved_consistency(self, device): + """Test that subdivision improves consistency. + + Linear subdivision adds new vertices at edge midpoints. For a lumpy + sphere with varying curvature, adding more vertices improves the + approximation of the smooth surface, leading to better normal + consistency (smaller angular errors between point and cell normals). + """ + # Load lumpy sphere - has varying curvature + mesh_original = lumpy_sphere.load(subdivisions=1, device=device) + + # Subdivide to add vertices at edge midpoints + mesh_subdivided = mesh_original.subdivide(levels=1, filter="linear") + + # Compute angular errors for both + errors_original = self.compute_angular_errors(mesh_original) + errors_subdivided = self.compute_angular_errors(mesh_subdivided) + + # Check consistency at threshold of 0.1 radians + threshold = 0.1 + fraction_original = (errors_original < threshold).float().mean() + fraction_subdivided = (errors_subdivided < threshold).float().mean() + + # Subdivision should improve consistency (more vertices = better approximation) + assert fraction_subdivided >= fraction_original # Should improve + # Mean error should decrease + assert errors_subdivided.mean() <= errors_original.mean() + 0.05 + + def test_multiple_subdivision_levels(self, device): + """Test that consistency improves with subdivision levels. + + Linear subdivision adds vertices at edge midpoints, improving the + mesh's approximation of the underlying surface. As more vertices + are added, the angular error between point and cell normals decreases. + """ + # Load lumpy sphere - has varying curvature + mesh = lumpy_sphere.load(subdivisions=1, device=device) + + threshold = 0.1 # radians + fractions = [] + + # Test original and multiple subdivision levels + for level in range(3): + if level > 0: + mesh = mesh.subdivide(levels=1, filter="linear") + + errors = self.compute_angular_errors(mesh) + fraction = (errors < threshold).float().mean() + fractions.append(fraction) + + # Consistency should generally improve with subdivision + # Each level should be at least as good as the previous + for i in range(1, len(fractions)): + assert fractions[i] >= fractions[i - 1] - 0.05 # Allow small variance + # Final level should be notably better than first + assert fractions[-1] >= fractions[0] + 0.2 + + def test_consistency_distribution(self, device): + """Test the distribution of angular errors. + + For a lumpy sphere with varying curvature, the error distribution + reflects the curvature variation. Higher curvature regions have + larger angular errors between point and cell normals. + """ + # Load lumpy sphere - has varying curvature + mesh = lumpy_sphere.load(subdivisions=2, device=device) + + # Compute angular errors + angular_errors = self.compute_angular_errors(mesh) + + # Check various percentiles + percentiles = [50, 75, 90, 95, 99] + values = [torch.quantile(angular_errors, p / 100.0) for p in percentiles] + + # Distribution should be reasonable for a curved surface + assert values[0] < 0.25 # 50th percentile (< 14 degrees) + assert values[-1] < 1.0 # 99th percentile (< 57 degrees) + + @pytest.mark.slow + def test_loop_subdivision_smoothing(self, device): + """Test that Loop subdivision improves normal consistency. + + Loop subdivision is APPROXIMATING - it repositions vertices to + create a smoother surface. This should reduce angular errors + between point and cell normals. + """ + # Load lumpy sphere - has varying curvature + mesh_original = lumpy_sphere.load(subdivisions=1, device=device) + + # Try Loop subdivision (approximating, should smooth) + try: + mesh_loop = mesh_original.subdivide(levels=1, filter="loop") + + # Compute angular errors for both + errors_original = self.compute_angular_errors(mesh_original) + errors_loop = self.compute_angular_errors(mesh_loop) + + # Loop subdivision should maintain or improve consistency + # Mean error should not increase significantly + assert errors_loop.mean() <= errors_original.mean() + 0.1 + except NotImplementedError: + # Loop subdivision might not support all mesh types + pytest.skip("Loop subdivision not supported for this mesh") diff --git a/test/mesh/projections/test_projections.py b/test/mesh/projections/test_projections.py new file mode 100644 index 0000000000..eb456b27f8 --- /dev/null +++ b/test/mesh/projections/test_projections.py @@ -0,0 +1,1241 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for projection operations (extrusion, embedding, projection).""" + +import pytest +import torch +from tensordict import TensorDict + +from physicsnemo.mesh import Mesh +from physicsnemo.mesh.projections import embed, extrude, project + + +class TestExtrude: + """Test suite for mesh extrusion functionality.""" + + def test_extrude_point_to_edge_2d(self): + """Test extruding a 0D point cloud to 1D edges in 2D space.""" + ### Create a simple point cloud (0D manifold in 2D space) + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], dtype=torch.float32) + cells = torch.tensor([[0], [1], [2]], dtype=torch.int64) # 0-simplices + mesh = Mesh(points=points, cells=cells) + + assert mesh.n_manifold_dims == 0 + assert mesh.n_spatial_dims == 2 + assert mesh.n_cells == 3 + + ### Extrude along [0, 1] direction + extruded = extrude(mesh, vector=[0.0, 1.0]) + + ### Verify dimensions + assert extruded.n_manifold_dims == 1 + assert extruded.n_spatial_dims == 2 + assert extruded.n_points == 6 # 3 original + 3 extruded + assert extruded.n_cells == 3 # 3 edges (1 per original point) + + ### Verify point positions + expected_points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], # Original + [0.0, 1.0], + [1.0, 1.0], + [0.0, 2.0], # Extruded + ], + dtype=torch.float32, + ) + assert torch.allclose(extruded.points, expected_points) + + ### Verify cells (edges connecting original to extruded) + # Each 0-simplex [i] becomes 1 edge [i', i] or [i, i'] + # According to our algorithm: child 0 has [v0', v0] + expected_cells = torch.tensor([[3, 0], [4, 1], [5, 2]], dtype=torch.int64) + assert torch.equal(extruded.cells, expected_cells) + + def test_extrude_edge_to_triangle_2d(self): + """Test extruding a 1D edge to 2D triangles in 2D space.""" + ### Create a single edge (1D manifold in 2D space) + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) # 1-simplex (edge) + mesh = Mesh(points=points, cells=cells) + + assert mesh.n_manifold_dims == 1 + assert mesh.n_spatial_dims == 2 + + ### Extrude along [0, 1] direction + extruded = extrude(mesh, vector=[0.0, 1.0]) + + ### Verify dimensions + assert extruded.n_manifold_dims == 2 + assert extruded.n_spatial_dims == 2 + assert extruded.n_points == 4 # 2 original + 2 extruded + assert extruded.n_cells == 2 # 2 triangles (N+1 = 2 per edge) + + ### Verify point positions + expected_points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], dtype=torch.float32 + ) + assert torch.allclose(extruded.points, expected_points) + + ### Verify cells + # Edge [0, 1] becomes 2 triangles: + # Child 0: [v0', v0, v1] = [2, 0, 1] + # Child 1: [v0', v1', v1] = [2, 3, 1] + expected_cells = torch.tensor([[2, 0, 1], [2, 3, 1]], dtype=torch.int64) + assert torch.equal(extruded.cells, expected_cells) + + ### Verify total area (should equal width * height) + total_area = extruded.cell_areas.sum() + expected_area = 1.0 * 1.0 # Rectangle area + assert torch.allclose(total_area, torch.tensor(expected_area), atol=1e-6) + + def test_extrude_edge_to_triangle_3d(self): + """Test extruding a 1D edge to 2D triangles in 3D space.""" + ### Create a single edge in 3D space + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Extrude along [0, 0, 1] direction (default) + extruded = extrude(mesh) + + ### Verify dimensions + assert extruded.n_manifold_dims == 2 + assert extruded.n_spatial_dims == 3 + assert extruded.n_points == 4 + assert extruded.n_cells == 2 + + ### Verify point positions (default vector is [0, 0, 1]) + expected_points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 1.0]], + dtype=torch.float32, + ) + assert torch.allclose(extruded.points, expected_points) + + def test_extrude_triangle_to_tetrahedron(self): + """Test extruding a 2D triangle to 3D tetrahedra in 3D space.""" + ### Create a single triangle (2D manifold in 3D space) + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) # 2-simplex (triangle) + mesh = Mesh(points=points, cells=cells) + + assert mesh.n_manifold_dims == 2 + assert mesh.n_spatial_dims == 3 + + ### Extrude along [0, 0, 1] direction (default) + extruded = extrude(mesh) + + ### Verify dimensions + assert extruded.n_manifold_dims == 3 + assert extruded.n_spatial_dims == 3 + assert extruded.n_points == 6 # 3 original + 3 extruded + assert extruded.n_cells == 3 # 3 tetrahedra (N+1 = 3 per triangle) + + ### Verify point positions + expected_points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], # Original + [0.0, 0.0, 1.0], + [1.0, 0.0, 1.0], + [0.0, 1.0, 1.0], # Extruded + ], + dtype=torch.float32, + ) + assert torch.allclose(extruded.points, expected_points) + + ### Verify cells + # Triangle [0, 1, 2] becomes 3 tetrahedra: + # Child 0: [v0', v0, v1, v2] = [3, 0, 1, 2] + # Child 1: [v0', v1', v1, v2] = [3, 4, 1, 2] + # Child 2: [v0', v1', v2', v2] = [3, 4, 5, 2] + expected_cells = torch.tensor( + [[3, 0, 1, 2], [3, 4, 1, 2], [3, 4, 5, 2]], dtype=torch.int64 + ) + assert torch.equal(extruded.cells, expected_cells) + + ### Verify total volume + # Original triangle has area 0.5, extruded by height 1.0 -> volume = 0.5 + total_volume = extruded.cell_areas.sum() # "areas" is generic for n-volumes + expected_volume = 0.5 + assert torch.allclose(total_volume, torch.tensor(expected_volume), atol=1e-6) + + def test_extrude_custom_vector(self): + """Test extrusion with custom vector.""" + ### Create a triangle + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Extrude with custom vector + custom_vector = torch.tensor([1.0, 1.0, 2.0]) + extruded = extrude(mesh, vector=custom_vector) + + ### Verify extruded points + expected_extruded = points + custom_vector + assert torch.allclose( + extruded.points[3:], + expected_extruded, # Last 3 points are extruded + ) + + def test_extrude_insufficient_spatial_dims_raises_error(self): + """Test that extrusion raises ValueError when spatial dims are insufficient.""" + ### Create a 2D mesh in 2D space (can't extrude to 3D without new dims) + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.n_manifold_dims == 2 + assert mesh.n_spatial_dims == 2 + + ### Should raise ValueError by default + with pytest.raises( + ValueError, match="Cannot extrude.*without increasing spatial dimensions" + ): + extrude(mesh) + + ### Should also raise with explicit vector in 2D + with pytest.raises( + ValueError, match="Cannot extrude.*without increasing spatial dimensions" + ): + extrude(mesh, vector=[0.0, 1.0]) + + def test_extrude_allow_new_spatial_dims(self): + """Test extrusion with allow_new_spatial_dims=True.""" + ### Create a 2D mesh in 2D space + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Extrude with allow_new_spatial_dims=True + extruded = extrude(mesh, allow_new_spatial_dims=True) + + ### Verify new spatial dimensions + assert extruded.n_manifold_dims == 3 + assert extruded.n_spatial_dims == 3 # New dimension added + assert extruded.n_points == 6 + assert extruded.n_cells == 3 + + ### Verify that original points are padded with zeros + # Original points should be padded: [x, y] -> [x, y, 0] + expected_original = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + assert torch.allclose(extruded.points[:3], expected_original) + + ### Extruded points should be [x, y, 1] + expected_extruded = torch.tensor( + [[0.0, 0.0, 1.0], [1.0, 0.0, 1.0], [0.0, 1.0, 1.0]], dtype=torch.float32 + ) + assert torch.allclose(extruded.points[3:], expected_extruded) + + def test_extrude_data_propagation_point_data(self): + """Test that point_data is correctly duplicated during extrusion.""" + ### Create mesh with point data + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + point_data = TensorDict( + { + "temperature": torch.tensor([300.0, 400.0]), + "velocity": torch.tensor([[1.0, 0.0], [2.0, 0.0]]), + }, + batch_size=[2], + ) + mesh = Mesh(points=points, cells=cells, point_data=point_data) + + ### Extrude + extruded = extrude(mesh, vector=[0.0, 1.0]) + + ### Verify point_data is duplicated + assert extruded.n_points == 4 + assert "temperature" in extruded.point_data + assert "velocity" in extruded.point_data + + # First 2 points should have original data + assert torch.allclose( + extruded.point_data["temperature"][:2], torch.tensor([300.0, 400.0]) + ) + # Last 2 points should have duplicated data + assert torch.allclose( + extruded.point_data["temperature"][2:], torch.tensor([300.0, 400.0]) + ) + + # Check vector data too + assert torch.allclose( + extruded.point_data["velocity"][:2], torch.tensor([[1.0, 0.0], [2.0, 0.0]]) + ) + assert torch.allclose( + extruded.point_data["velocity"][2:], torch.tensor([[1.0, 0.0], [2.0, 0.0]]) + ) + + def test_extrude_data_propagation_cell_data(self): + """Test that cell_data is correctly replicated during extrusion.""" + ### Create mesh with cell data + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + cell_data = TensorDict( + {"pressure": torch.tensor([101325.0]), "id": torch.tensor([42])}, + batch_size=[1], + ) + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + + ### Extrude (1D edge -> 2D, creates 2 child cells per parent) + extruded = extrude(mesh, vector=[0.0, 1.0]) + + ### Verify cell_data is replicated + assert extruded.n_cells == 2 # 1 edge becomes 2 triangles + assert "pressure" in extruded.cell_data + assert "id" in extruded.cell_data + + # Both child cells should have same data as parent + assert torch.allclose( + extruded.cell_data["pressure"], torch.tensor([101325.0, 101325.0]) + ) + assert torch.equal(extruded.cell_data["id"], torch.tensor([42, 42])) + + def test_extrude_multiple_cells(self): + """Test extrusion with multiple parent cells.""" + ### Create two edges + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1], [1, 2]], dtype=torch.int64) # Two edges + cell_data = TensorDict( + {"cell_id": torch.tensor([10, 20])}, + batch_size=[2], + ) + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + + ### Extrude + extruded = extrude(mesh, vector=[0.0, 1.0]) + + ### Verify dimensions + assert extruded.n_cells == 4 # 2 edges x 2 children each = 4 triangles + + ### Verify cell_data replication matches child-major cell ordering + # Cells are ordered [child0_parent0, child0_parent1, child1_parent0, child1_parent1] + expected_cell_ids = torch.tensor([10, 20, 10, 20]) + assert torch.equal(extruded.cell_data["cell_id"], expected_cell_ids) + + def test_extrude_empty_mesh(self): + """Test extrusion of empty mesh (no cells).""" + ### Create empty mesh + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.empty((0, 2), dtype=torch.int64) # No cells + mesh = Mesh(points=points, cells=cells) + + assert mesh.n_cells == 0 + + ### Extrude + extruded = extrude(mesh, vector=[0.0, 1.0]) + + ### Verify: points are duplicated but no cells created + assert extruded.n_points == 4 # 2 original + 2 extruded + assert extruded.n_cells == 0 # Still no cells + assert extruded.n_manifold_dims == 2 # Manifold dim still increases + assert extruded.cells.shape == (0, 3) # Shape is (0, n_vertices_per_cell) + + def test_extrude_capping_not_implemented(self): + """Test that capping=True raises NotImplementedError.""" + ### Create simple mesh + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Should raise NotImplementedError + with pytest.raises(NotImplementedError, match="Capping is not yet implemented"): + extrude(mesh, capping=True) + + @pytest.mark.parametrize( + "n_manifold_dims,n_spatial_dims", + [ + (0, 1), # Points in 1D -> edges in 1D + (0, 2), # Points in 2D -> edges in 2D + (0, 3), # Points in 3D -> edges in 3D + (1, 2), # Edges in 2D -> triangles in 2D + (1, 3), # Edges in 3D -> triangles in 3D + (2, 3), # Triangles in 3D -> tetrahedra in 3D + ], + ) + def test_extrude_various_dimensions(self, n_manifold_dims, n_spatial_dims): + """Test extrusion across various manifold and spatial dimensions.""" + ### Create a simple mesh of the specified dimension + n_vertices_per_cell = n_manifold_dims + 1 + + # Create points: use identity-like pattern + n_points = n_vertices_per_cell + points = torch.zeros((n_points, n_spatial_dims), dtype=torch.float32) + for i in range(min(n_points, n_spatial_dims)): + points[i, i] = 1.0 + + # Create a single cell + cells = torch.arange(n_vertices_per_cell).unsqueeze(0) + + mesh = Mesh(points=points, cells=cells) + + ### Extrude with default vector + extruded = extrude(mesh) + + ### Verify dimensions + assert extruded.n_manifold_dims == n_manifold_dims + 1 + assert extruded.n_spatial_dims == n_spatial_dims + assert extruded.n_points == 2 * n_points + assert extruded.n_cells == n_manifold_dims + 1 # N+1 children per parent + + ### Verify all cells have positive volume/area + assert (extruded.cell_areas > 0).all() + + def test_extrude_preserves_global_data(self): + """Test that global_data is preserved during extrusion.""" + ### Create mesh with global data + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + global_data = TensorDict({"timestamp": torch.tensor(12345)}, batch_size=[]) + mesh = Mesh(points=points, cells=cells, global_data=global_data) + + ### Extrude + extruded = extrude(mesh, vector=[0.0, 1.0]) + + ### Verify global_data is preserved + assert "timestamp" in extruded.global_data + assert extruded.global_data["timestamp"] == 12345 + + def test_extrude_cached_data_cleared(self): + """Test that cached properties are not propagated.""" + ### Create mesh and trigger some cached computations + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + # Access some cached properties to populate cache + _ = mesh.cell_centroids + _ = mesh.cell_areas + + # Verify cache exists + assert "_cache" in mesh.cell_data + + ### Extrude + extruded = extrude(mesh) + + ### Verify cache is not in extruded mesh + # The exclude("_cache") should prevent propagation + assert ( + "_cache" not in extruded.cell_data or len(extruded.cell_data["_cache"]) == 0 + ) + + def test_extrude_vector_as_list(self): + """Test that vector can be provided as a list or tuple.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Extrude with list + extruded_list = extrude(mesh, vector=[0.5, 1.5]) + assert torch.allclose( + extruded_list.points[2:], mesh.points + torch.tensor([0.5, 1.5]) + ) + + ### Extrude with tuple + extruded_tuple = extrude(mesh, vector=(0.5, 1.5)) + assert torch.allclose( + extruded_tuple.points[2:], mesh.points + torch.tensor([0.5, 1.5]) + ) + + def test_extrude_4d_to_5d(self): + """Test high-dimensional extrusion: 3D manifold in 4D space -> 4D manifold.""" + ### Create a 3-simplex (tetrahedron) in 4D space + points = torch.tensor( + [ + [0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0], + ], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2, 3]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.n_manifold_dims == 3 + assert mesh.n_spatial_dims == 4 + + ### Extrude (default vector is [0, 0, 0, 1]) + extruded = extrude(mesh) + + ### Verify dimensions + assert extruded.n_manifold_dims == 4 + assert extruded.n_spatial_dims == 4 + assert extruded.n_points == 8 # 4 original + 4 extruded + assert extruded.n_cells == 4 # 4 children (N+1 where N=3) + + ### Verify all cells have positive hypervolume + assert (extruded.cell_areas > 0).all() + + def test_extrude_orientation_consistency(self): + """Test that extrusion maintains consistent orientation.""" + ### Create a simple triangle with known orientation + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Compute original normal (should point in +z direction) + original_normal = mesh.cell_normals[0] + assert original_normal[2] > 0 # Points upward + + ### Extrude upward + extruded = extrude(mesh, vector=[0.0, 0.0, 1.0]) + + ### All extruded tetrahedra should have positive volume + # (negative volume would indicate inverted orientation) + assert (extruded.cell_areas > 0).all() + + def test_extrude_with_zero_vector_raises_or_degenerates(self): + """Test extrusion with zero vector creates degenerate cells.""" + ### Create simple mesh + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Extrude with zero vector + extruded = extrude(mesh, vector=[0.0, 0.0]) + + ### Extruded points should be same as original + assert torch.allclose(extruded.points[:2], extruded.points[2:]) + + ### Cells should have zero area (degenerate) + assert torch.allclose(extruded.cell_areas, torch.zeros(2)) + + def test_extrude_vector_wrong_shape_raises_error(self): + """Test that vector with wrong shape raises ValueError.""" + ### Create simple mesh + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### 2D vector (should be 1D) + with pytest.raises(ValueError, match="Extrusion vector must be 1D"): + extrude(mesh, vector=torch.tensor([[0.0, 1.0]])) + + ### 3D vector (should be 1D) + with pytest.raises(ValueError, match="Extrusion vector must be 1D"): + extrude(mesh, vector=torch.zeros((2, 2, 2))) + + def test_extrude_vector_too_many_dimensions_raises_error(self): + """Test that vector with too many spatial dimensions raises ValueError.""" + ### Create simple mesh in 2D + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Provide vector with 5 dimensions (mesh is 2D, target would be 3D max) + with pytest.raises(ValueError, match="Extrusion vector has .* dimensions but"): + extrude(mesh, vector=torch.tensor([0.0, 0.0, 0.0, 0.0, 1.0])) + + def test_extrude_vector_too_small_gets_padded(self): + """Test that vector with too few dimensions gets padded.""" + ### Create mesh in 3D space + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Provide 2D vector for 3D mesh (should be padded) + extruded = extrude(mesh, vector=torch.tensor([1.0, 2.0])) + + ### Verify extruded points: original + [1.0, 2.0, 0.0] (padded) + expected_extruded = mesh.points + torch.tensor([1.0, 2.0, 0.0]) + assert torch.allclose(extruded.points[2:], expected_extruded) + + +class TestEmbed: + """Test suite for spatial dimension embedding functionality.""" + + def test_embed_2d_to_3d(self): + """Test embedding a 2D mesh in 2D space into 3D space.""" + ### Create 2D triangle in 2D space + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh_2d = Mesh(points=points, cells=cells) + + assert mesh_2d.n_spatial_dims == 2 + assert mesh_2d.n_manifold_dims == 2 + assert mesh_2d.codimension == 0 + + ### Embed in 3D space + mesh_3d = embed(mesh_2d, target_n_spatial_dims=3) + + ### Verify dimensions + assert mesh_3d.n_spatial_dims == 3 + assert mesh_3d.n_manifold_dims == 2 # Manifold dim unchanged + assert mesh_3d.codimension == 1 # Now codimension-1! + assert mesh_3d.n_points == 3 + assert mesh_3d.n_cells == 1 + + ### Verify points are padded with zeros + expected_points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + assert torch.allclose(mesh_3d.points, expected_points) + + ### Verify cells unchanged + assert torch.equal(mesh_3d.cells, cells) + + ### Verify we can now compute normals (codimension-1) + normals = mesh_3d.cell_normals + assert normals.shape == (1, 3) + # Normal should point in z-direction + assert torch.allclose(normals[0, 2].abs(), torch.tensor(1.0)) + + def test_embed_1d_curve_2d_to_3d(self): + """Test embedding a 1D curve in 2D space into 3D space.""" + ### Create edge in 2D + points = torch.tensor([[0.0, 0.0], [1.0, 1.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh_2d = Mesh(points=points, cells=cells) + + assert mesh_2d.n_manifold_dims == 1 + assert mesh_2d.n_spatial_dims == 2 + assert mesh_2d.codimension == 1 + + ### Embed in 3D + mesh_3d = embed(mesh_2d, target_n_spatial_dims=3) + + ### Verify dimensions + assert mesh_3d.n_manifold_dims == 1 + assert mesh_3d.n_spatial_dims == 3 + assert mesh_3d.codimension == 2 # Higher codimension + + ### Verify points padded + expected_points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 1.0, 0.0]], dtype=torch.float32 + ) + assert torch.allclose(mesh_3d.points, expected_points) + + def test_embed_no_change_returns_same_mesh(self): + """Test that embedding to current dimension returns unchanged mesh.""" + ### Create mesh + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Embed to same dimension + result = embed(mesh, target_n_spatial_dims=3) + + ### Should be same object (no-op) + assert result is mesh + + def test_embed_preserves_point_data(self): + """Test that point_data is preserved during embedding.""" + ### Create mesh with point data + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + point_data = TensorDict( + { + "temperature": torch.tensor([300.0, 400.0]), + "pressure": torch.tensor([101325.0, 101325.0]), + }, + batch_size=[2], + ) + mesh = Mesh(points=points, cells=cells, point_data=point_data) + + ### Embed in 3D + embedded = embed(mesh, target_n_spatial_dims=3) + + ### Verify point_data preserved + assert "temperature" in embedded.point_data + assert "pressure" in embedded.point_data + assert torch.allclose( + embedded.point_data["temperature"], torch.tensor([300.0, 400.0]) + ) + assert torch.allclose( + embedded.point_data["pressure"], torch.tensor([101325.0, 101325.0]) + ) + + def test_embed_preserves_cell_data(self): + """Test that cell_data is preserved during embedding.""" + ### Create mesh with cell data + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + cell_data = TensorDict( + {"region_id": torch.tensor([42]), "density": torch.tensor([1.225])}, + batch_size=[1], + ) + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + + ### Embed in 3D + embedded = embed(mesh, target_n_spatial_dims=3) + + ### Verify cell_data preserved + assert "region_id" in embedded.cell_data + assert "density" in embedded.cell_data + assert embedded.cell_data["region_id"] == 42 + assert torch.allclose(embedded.cell_data["density"], torch.tensor([1.225])) + + def test_embed_preserves_global_data(self): + """Test that global_data is preserved during embedding.""" + ### Create mesh with global data + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + global_data = TensorDict({"simulation_time": torch.tensor(1.5)}, batch_size=[]) + mesh = Mesh(points=points, cells=cells, global_data=global_data) + + ### Embed in 3D + embedded = embed(mesh, target_n_spatial_dims=3) + + ### Verify global_data preserved + assert "simulation_time" in embedded.global_data + assert torch.allclose( + embedded.global_data["simulation_time"], torch.tensor(1.5) + ) + + def test_embed_clears_cached_properties(self): + """Test that cached geometric properties are cleared.""" + ### Create mesh and trigger cache + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + # Populate cache by accessing properties + _ = mesh.cell_centroids + _ = mesh.cell_areas + _ = mesh.cell_normals + + # Verify cache exists + assert "_cache" in mesh.cell_data + assert len(mesh.cell_data["_cache"]) > 0 + + ### Embed in 4D + embedded = embed(mesh, target_n_spatial_dims=4) + + ### Verify cache is cleared + # Cache should either not exist or be empty + if "_cache" in embedded.cell_data: + assert len(embedded.cell_data["_cache"]) == 0 + + def test_embed_multiple_steps(self): + """Test embedding through multiple dimension changes.""" + ### Start with 1D edge in 2D space + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh_2d = Mesh(points=points, cells=cells) + + ### Embed to 3D + mesh_3d = embed(mesh_2d, target_n_spatial_dims=3) + assert mesh_3d.n_spatial_dims == 3 + assert torch.allclose( + mesh_3d.points, torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) + ) + + ### Embed to 4D + mesh_4d = embed(mesh_3d, target_n_spatial_dims=4) + assert mesh_4d.n_spatial_dims == 4 + assert torch.allclose( + mesh_4d.points, torch.tensor([[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]]) + ) + + ### Project back to 2D + mesh_2d_again = project(mesh_4d, target_n_spatial_dims=2) + assert mesh_2d_again.n_spatial_dims == 2 + assert torch.allclose(mesh_2d_again.points, points) + + def test_embed_round_trip_preserves_topology(self): + """Test that embedding up and projecting down preserves topology.""" + ### Create triangle mesh + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + cell_data = TensorDict({"id": torch.tensor([123])}, batch_size=[1]) + mesh_original = Mesh(points=points, cells=cells, cell_data=cell_data) + + # Compute original area + original_area = mesh_original.cell_areas[0].item() + + ### Embed to 5D and back + mesh_5d = embed(mesh_original, target_n_spatial_dims=5) + mesh_back = project(mesh_5d, target_n_spatial_dims=3) + + ### Verify topology preserved + assert torch.equal(mesh_back.cells, cells) + assert mesh_back.cell_data["id"] == 123 + + ### Verify points are same + assert torch.allclose(mesh_back.points, points) + + ### Verify area is same (intrinsic property) + assert torch.allclose(mesh_back.cell_areas[0], torch.tensor(original_area)) + + @pytest.mark.parametrize( + "start_dims,target_dims", + [ + (2, 3), + (2, 4), + (2, 5), + (3, 4), + (3, 5), + (4, 5), + ], + ) + def test_embed_various_dimension_changes(self, start_dims, target_dims): + """Test embedding across various dimension combinations.""" + ### Create simple edge in start_dims space + points = torch.zeros((2, start_dims), dtype=torch.float32) + points[1, 0] = 1.0 # Edge along first axis + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.n_spatial_dims == start_dims + assert mesh.n_manifold_dims == 1 + + ### Embed to target + result = embed(mesh, target_n_spatial_dims=target_dims) + + ### Verify dimensions + assert result.n_spatial_dims == target_dims + assert result.n_manifold_dims == 1 # Unchanged + assert result.n_points == 2 + assert result.n_cells == 1 + + ### Verify edge length preserved (intrinsic) + edge_length = result.cell_areas[0] + assert torch.allclose(edge_length, torch.tensor(1.0)) + + def test_embed_point_cloud(self): + """Test embedding a 0D point cloud.""" + ### Create point cloud (0D manifold in 2D space) + points = torch.tensor([[0.0, 0.0], [1.0, 1.0], [2.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0], [1], [2]], dtype=torch.int64) # 0-simplices + mesh = Mesh(points=points, cells=cells) + + assert mesh.n_manifold_dims == 0 + assert mesh.n_spatial_dims == 2 + + ### Embed in 4D + embedded = embed(mesh, target_n_spatial_dims=4) + + ### Verify + assert embedded.n_manifold_dims == 0 + assert embedded.n_spatial_dims == 4 + assert embedded.n_points == 3 + assert embedded.points.shape == (3, 4) + + # Last two coordinates should be zero + assert torch.allclose(embedded.points[:, 2:], torch.zeros(3, 2)) + + def test_embed_preserves_cell_topology(self): + """Test that cell connectivity is completely unchanged.""" + ### Create mesh with specific cell pattern + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [0.0, 1.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 3], [1, 2, 3]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Embed + embedded = embed(mesh, target_n_spatial_dims=5) + + ### Verify cells exactly the same (not just values, but same object) + assert embedded.cells is mesh.cells + assert torch.equal(embedded.cells, cells) + + # --- insert_at tests --- + + def test_embed_insert_at_beginning(self): + """Test embedding with new dimensions prepended at the start.""" + ### Create 2D edge + points = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Embed to 4D with insert_at=0: [x, y] -> [0, 0, x, y] + result = embed(mesh, target_n_spatial_dims=4, insert_at=0) + + assert result.n_spatial_dims == 4 + expected = torch.tensor( + [[0.0, 0.0, 1.0, 2.0], [0.0, 0.0, 3.0, 4.0]], dtype=torch.float32 + ) + assert torch.allclose(result.points, expected) + + def test_embed_insert_at_middle(self): + """Test embedding with new dimension inserted in the middle.""" + ### Create 2D edge + points = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Embed to 3D with insert_at=1: [x, y] -> [x, 0, y] + result = embed(mesh, target_n_spatial_dims=3, insert_at=1) + + assert result.n_spatial_dims == 3 + expected = torch.tensor([[1.0, 0.0, 2.0], [3.0, 0.0, 4.0]], dtype=torch.float32) + assert torch.allclose(result.points, expected) + + def test_embed_insert_at_end_explicit(self): + """Test that insert_at=n_spatial_dims gives same result as default.""" + ### Create 2D edge + points = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Embed to 4D with insert_at=2 (=n_spatial_dims): [x, y] -> [x, y, 0, 0] + result_explicit = embed(mesh, target_n_spatial_dims=4, insert_at=2) + result_default = embed(mesh, target_n_spatial_dims=4) + + assert torch.allclose(result_explicit.points, result_default.points) + + def test_embed_insert_at_multiple_dims(self): + """Test inserting multiple new dimensions at an interior position.""" + ### Create 3D mesh + points = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Embed to 5D with insert_at=2: [x, y, z] -> [x, y, 0, 0, z] + result = embed(mesh, target_n_spatial_dims=5, insert_at=2) + + assert result.n_spatial_dims == 5 + expected = torch.tensor( + [[1.0, 2.0, 0.0, 0.0, 3.0], [4.0, 5.0, 0.0, 0.0, 6.0]], + dtype=torch.float32, + ) + assert torch.allclose(result.points, expected) + + # --- Error tests --- + + def test_embed_raises_on_target_less_than_one(self): + """Test that target < 1 raises ValueError.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="target_n_spatial_dims must be >= 1"): + embed(mesh, target_n_spatial_dims=0) + + with pytest.raises(ValueError, match="target_n_spatial_dims must be >= 1"): + embed(mesh, target_n_spatial_dims=-1) + + def test_embed_raises_when_target_less_than_current(self): + """Test that embed rejects target < current (should use project).""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="Use project"): + embed(mesh, target_n_spatial_dims=2) + + def test_embed_raises_on_insert_at_out_of_range(self): + """Test that out-of-range insert_at raises ValueError.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### insert_at=-1 is invalid + with pytest.raises(ValueError, match="insert_at must be in"): + embed(mesh, target_n_spatial_dims=4, insert_at=-1) + + ### insert_at=3 is invalid for a 2D mesh (valid range is [0, 2]) + with pytest.raises(ValueError, match="insert_at must be in"): + embed(mesh, target_n_spatial_dims=4, insert_at=3) + + +class TestProject: + """Test suite for spatial dimension projection functionality.""" + + def test_project_3d_to_2d(self): + """Test projecting a 2D mesh in 3D space down to 2D space.""" + ### Create 2D triangle in 3D space + points = torch.tensor( + [[0.0, 0.0, 1.0], [1.0, 0.0, 2.0], [0.0, 1.0, 3.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh_3d = Mesh(points=points, cells=cells) + + assert mesh_3d.n_spatial_dims == 3 + assert mesh_3d.codimension == 1 + + ### Project to 2D space + mesh_2d = project(mesh_3d, target_n_spatial_dims=2) + + ### Verify dimensions + assert mesh_2d.n_spatial_dims == 2 + assert mesh_2d.n_manifold_dims == 2 + assert mesh_2d.codimension == 0 # No longer codimension-1 + assert mesh_2d.n_points == 3 + assert mesh_2d.n_cells == 1 + + ### Verify points are sliced (z-coordinate removed) + expected_points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], dtype=torch.float32 + ) + assert torch.allclose(mesh_2d.points, expected_points) + + ### Verify cells unchanged + assert torch.equal(mesh_2d.cells, cells) + + def test_project_no_change_returns_same_mesh(self): + """Test that projecting to current dimension returns unchanged mesh.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + result = project(mesh, target_n_spatial_dims=3) + assert result is mesh + + def test_project_preserves_data(self): + """Test that point/cell/global data is preserved during projection.""" + ### Create mesh with all data types + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + point_data = TensorDict( + {"temperature": torch.tensor([300.0, 400.0])}, batch_size=[2] + ) + cell_data = TensorDict({"region_id": torch.tensor([42])}, batch_size=[1]) + global_data = TensorDict({"time": torch.tensor(1.5)}, batch_size=[]) + mesh = Mesh( + points=points, + cells=cells, + point_data=point_data, + cell_data=cell_data, + global_data=global_data, + ) + + ### Project to 2D + result = project(mesh, target_n_spatial_dims=2) + + ### Verify all data preserved + assert torch.allclose( + result.point_data["temperature"], torch.tensor([300.0, 400.0]) + ) + assert result.cell_data["region_id"] == 42 + assert torch.allclose(result.global_data["time"], torch.tensor(1.5)) + + def test_project_clears_cache(self): + """Test that cached geometric properties are cleared on projection.""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + # Populate cache + _ = mesh.cell_centroids + _ = mesh.cell_areas + assert "_cache" in mesh.cell_data + + ### Project to 2D + result = project(mesh, target_n_spatial_dims=2) + + ### Verify cache is cleared + if "_cache" in result.cell_data: + assert len(result.cell_data["_cache"]) == 0 + + @pytest.mark.parametrize( + "start_dims,target_dims", + [ + (5, 4), + (5, 3), + (5, 2), + (4, 3), + (4, 2), + (3, 2), + ], + ) + def test_project_various_dimension_changes(self, start_dims, target_dims): + """Test projection across various dimension combinations.""" + ### Create simple edge in start_dims space + points = torch.zeros((2, start_dims), dtype=torch.float32) + points[1, 0] = 1.0 # Edge along first axis + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.n_spatial_dims == start_dims + assert mesh.n_manifold_dims == 1 + + ### Project to target + result = project(mesh, target_n_spatial_dims=target_dims) + + ### Verify dimensions + assert result.n_spatial_dims == target_dims + assert result.n_manifold_dims == 1 # Unchanged + assert result.n_points == 2 + assert result.n_cells == 1 + + ### Verify edge length preserved (intrinsic - first dim always kept) + edge_length = result.cell_areas[0] + assert torch.allclose(edge_length, torch.tensor(1.0)) + + # --- keep_dims tests --- + + def test_project_keep_dims_basic(self): + """Test projecting with specific dimension selection.""" + ### Create 3D edge + points = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Project keeping dims 0 and 2 (x and z): [x, y, z] -> [x, z] + result = project(mesh, keep_dims=[0, 2]) + + assert result.n_spatial_dims == 2 + expected = torch.tensor([[1.0, 3.0], [4.0, 6.0]], dtype=torch.float32) + assert torch.allclose(result.points, expected) + + def test_project_keep_dims_reorder(self): + """Test that keep_dims can reorder dimensions.""" + ### Create 3D edge + points = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Project keeping dims [2, 0]: [x, y, z] -> [z, x] + result = project(mesh, keep_dims=[2, 0]) + + assert result.n_spatial_dims == 2 + expected = torch.tensor([[3.0, 1.0], [6.0, 4.0]], dtype=torch.float32) + assert torch.allclose(result.points, expected) + + def test_project_keep_dims_single(self): + """Test keeping a single dimension for a 0D manifold.""" + ### Create 0D point cloud in 3D space + points = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=torch.float32) + cells = torch.tensor([[0], [1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Keep only the middle dimension + result = project(mesh, keep_dims=[1]) + + assert result.n_spatial_dims == 1 + expected = torch.tensor([[2.0], [5.0]], dtype=torch.float32) + assert torch.allclose(result.points, expected) + + def test_project_keep_dims_matches_target_n_spatial_dims(self): + """Test that keep_dims=[0, 1] matches target_n_spatial_dims=2.""" + ### Create 3D edge + points = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + result_target = project(mesh, target_n_spatial_dims=2) + result_keep = project(mesh, keep_dims=[0, 1]) + + assert torch.allclose(result_target.points, result_keep.points) + + def test_project_preserves_topology_with_keep_dims(self): + """Test that cell connectivity is unchanged with keep_dims.""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2], [0, 2, 3]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + result = project(mesh, keep_dims=[0, 2]) + + ### Cells should be identical references + assert result.cells is mesh.cells + + # --- Error tests --- + + def test_project_raises_when_both_args_specified(self): + """Test that specifying both arguments raises ValueError.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="exactly one"): + project(mesh, target_n_spatial_dims=1, keep_dims=[0]) + + def test_project_raises_when_neither_arg_specified(self): + """Test that specifying neither argument raises ValueError.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="Must specify"): + project(mesh) + + def test_project_raises_on_target_less_than_one(self): + """Test that target < 1 raises ValueError.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="target_n_spatial_dims must be >= 1"): + project(mesh, target_n_spatial_dims=0) + + with pytest.raises(ValueError, match="target_n_spatial_dims must be >= 1"): + project(mesh, target_n_spatial_dims=-1) + + def test_project_raises_when_target_greater_than_current(self): + """Test that project rejects target > current (should use embed).""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="Use embed"): + project(mesh, target_n_spatial_dims=4) + + def test_project_raises_when_result_less_than_manifold(self): + """Test that projecting below manifold dimensions raises ValueError.""" + ### Create 2D mesh in 3D space + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.n_manifold_dims == 2 + + ### Can't project 2D manifold to 1D space + with pytest.raises(ValueError, match="spatial dimensions must be >= manifold"): + project(mesh, target_n_spatial_dims=1) + + def test_project_raises_when_keep_dims_too_few_for_manifold(self): + """Test that keep_dims resulting in < manifold dims raises ValueError.""" + ### Create 2D mesh in 3D space + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + assert mesh.n_manifold_dims == 2 + + ### Keeping only 1 dim is insufficient for 2D manifold + with pytest.raises(ValueError, match="spatial dimensions must be >= manifold"): + project(mesh, keep_dims=[0]) + + def test_project_raises_on_out_of_range_keep_dims(self): + """Test that out-of-range keep_dims indices raise ValueError.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], dtype=torch.float32) + cells = torch.tensor([[0, 1]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="keep_dims contains index 5"): + project(mesh, keep_dims=[0, 5]) + + with pytest.raises(ValueError, match="keep_dims contains index -1"): + project(mesh, keep_dims=[-1, 0]) diff --git a/test/mesh/repair/test_cleaning.py b/test/mesh/repair/test_cleaning.py new file mode 100644 index 0000000000..0754aef4de --- /dev/null +++ b/test/mesh/repair/test_cleaning.py @@ -0,0 +1,446 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for mesh cleaning operations. + +Tests validate that mesh cleaning correctly: +- Merges duplicate points within tolerance +- Removes duplicate cells +- Removes unused points +- Preserves data through cleaning operations +""" + +import torch + +from physicsnemo.mesh.mesh import Mesh + + +class TestMergeDuplicatePoints: + """Test duplicate point merging.""" + + def test_merge_exact_duplicates(self, device): + """Merge points at exactly the same location.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 0.0], + [1.0, 1.0], + ], # Points 0 and 2 are duplicates + device=device, + ) + cells = torch.tensor([[0, 1, 3], [2, 1, 3]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + cleaned = mesh.clean() + + ### Should merge points 0 and 2 + assert cleaned.n_points == 3 + + ### After merging points, both cells reference the same vertices, so become duplicates + ### Only 1 cell should remain after duplicate cell removal + assert cleaned.n_cells == 1 + + def test_merge_within_tolerance(self, device): + """Merge points within specified tolerance.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [1e-13, 1e-13], + [1.0, 1.0], + ], # Points 0 and 2 are close + device=device, + ) + cells = torch.tensor([[0, 1, 3], [2, 1, 3]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### With default tight tolerance (1e-12), should merge + cleaned = mesh.clean() + assert cleaned.n_points == 3 + + ### With looser tolerance, should also merge + cleaned_loose = mesh.clean(tolerance=1e-10) + assert cleaned_loose.n_points == 3 + + def test_no_merge_outside_tolerance(self, device): + """Don't merge points outside tolerance.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [1e-6, 1e-6], + [1.0, 1.0], + ], # Points 0 and 2 are far + device=device, + ) + cells = torch.tensor([[0, 1, 3], [2, 1, 3]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### With default tight tolerance (1e-12), should NOT merge + cleaned = mesh.clean() + assert cleaned.n_points == 4 + + def test_merge_multiple_groups(self, device): + """Merge multiple groups of duplicate points.""" + points = torch.tensor( + [ + [0.0, 0.0], # 0 + [1.0, 0.0], # 1 + [0.0, 0.0], # 2 - duplicate of 0 + [1.0, 0.0], # 3 - duplicate of 1 + [0.5, 1.0], # 4 - unique + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 4], [2, 3, 4]], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + cleaned = mesh.clean() + + ### Should have 3 unique points: 0/2, 1/3, 4 + assert cleaned.n_points == 3 + + def test_merge_preserves_point_data(self, device): + """Point data is averaged when merging.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 0.0], [1.0, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 3], [2, 1, 3]], device=device, dtype=torch.int64) + + ### Add point data + point_data = { + "temperature": torch.tensor([10.0, 20.0, 30.0, 40.0], device=device) + } + mesh = Mesh(points=points, cells=cells, point_data=point_data) + + cleaned = mesh.clean() + + ### Point data should be averaged: (10 + 30) / 2 = 20 + assert "temperature" in cleaned.point_data.keys() + assert len(cleaned.point_data["temperature"]) == cleaned.n_points + + ### Check that merged point has averaged value + ### The merged point should have temperature (10 + 30) / 2 = 20 + temperatures = cleaned.point_data["temperature"] + assert torch.any(torch.isclose(temperatures, torch.tensor(20.0, device=device))) + + +class TestRemoveDuplicateCells: + """Test duplicate cell removal.""" + + def test_remove_exact_duplicate_cells(self, device): + """Remove cells with same vertices in same order.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [0, 1, 2]], # Exact duplicates + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + cleaned = mesh.clean() + + ### Should have only 1 cell + assert cleaned.n_cells == 1 + + def test_remove_permuted_duplicate_cells(self, device): + """Remove cells with same vertices in different order.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [1, 0, 2], [2, 0, 1]], # Same vertices, different orders + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + cleaned = mesh.clean() + + ### Should have only 1 cell (all are duplicates) + assert cleaned.n_cells == 1 + + def test_keep_different_cells(self, device): + """Keep cells with different vertices.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 1.0]], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [1, 3, 2]], # Different cells + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + cleaned = mesh.clean() + + ### Should keep both cells + assert cleaned.n_cells == 2 + + +class TestRemoveUnusedPoints: + """Test unused point removal.""" + + def test_remove_single_unused_point(self, device): + """Remove point not referenced by any cell.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [2.0, 2.0]], # Point 3 unused + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + cleaned = mesh.clean() + + ### Should have only 3 points + assert cleaned.n_points == 3 + + def test_remove_multiple_unused_points(self, device): + """Remove multiple unused points.""" + points = torch.tensor( + [ + [0.0, 0.0], # 0 - used + [1.0, 0.0], # 1 - used + [0.5, 1.0], # 2 - used + [2.0, 2.0], # 3 - unused + [3.0, 3.0], # 4 - unused + ], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + cleaned = mesh.clean() + + ### Should have only 3 points + assert cleaned.n_points == 3 + + def test_keep_all_used_points(self, device): + """Keep all points that are used by cells.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + cleaned = mesh.clean() + + ### Should keep all 4 points + assert cleaned.n_points == 4 + + +class TestCombinedCleaning: + """Test combinations of cleaning operations.""" + + def test_clean_all_operations(self, device): + """Apply all cleaning operations together.""" + points = torch.tensor( + [ + [0.0, 0.0], # 0 + [1.0, 0.0], # 1 + [0.0, 0.0], # 2 - duplicate of 0 + [0.5, 1.0], # 3 + [2.0, 2.0], # 4 - unused + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 3], [2, 1, 3], [0, 1, 3]], # Last cell is duplicate + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + cleaned = mesh.clean() + + ### Should have: + ### - 3 unique points (merge 0/2, remove 4) + ### - 1 unique cell (remove duplicates) + assert cleaned.n_points == 3 + assert cleaned.n_cells == 1 + + def test_selective_cleaning(self, device): + """Apply only specific cleaning operations.""" + points = torch.tensor( + [ + [0.0, 0.0], # 0 + [1.0, 0.0], # 1 + [0.0, 0.0], # 2 - duplicate of 0 + [0.5, 1.0], # 3 + [2.0, 2.0], # 4 - unused + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 3], [2, 1, 3]], + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + ### Only merge points + cleaned_merge_only = mesh.clean( + merge_points=True, + remove_duplicate_cells=False, + remove_unused_points=False, + ) + assert cleaned_merge_only.n_points == 4 # 5 - 1 (merged) = 4 + assert cleaned_merge_only.n_cells == 2 + + ### Only remove unused points + cleaned_unused_only = mesh.clean( + merge_points=False, + remove_duplicate_cells=False, + remove_unused_points=True, + ) + assert cleaned_unused_only.n_points == 4 # 5 - 1 (unused) = 4 + assert cleaned_unused_only.n_cells == 2 + + +class TestCleaningWithData: + """Test that cleaning preserves mesh data.""" + + def test_preserve_cell_data(self, device): + """Cell data is preserved after cleaning.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [0, 1, 2]], # Duplicate cells + device=device, + dtype=torch.int64, + ) + cell_data = {"pressure": torch.tensor([100.0, 200.0], device=device)} + mesh = Mesh(points=points, cells=cells, cell_data=cell_data) + + cleaned = mesh.clean() + + ### Cell data should be preserved (first occurrence kept) + assert "pressure" in cleaned.cell_data.keys() + assert len(cleaned.cell_data["pressure"]) == cleaned.n_cells + + def test_preserve_global_data(self, device): + """Global data is preserved after cleaning.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [2.0, 2.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + global_data = {"simulation_time": torch.tensor(1.5, device=device)} + mesh = Mesh(points=points, cells=cells, global_data=global_data) + + cleaned = mesh.clean() + + ### Global data should be unchanged + assert "simulation_time" in cleaned.global_data.keys() + assert torch.isclose( + cleaned.global_data["simulation_time"], + torch.tensor(1.5, device=device), + ) + + +class TestEdgeCases: + """Test edge cases for cleaning operations.""" + + def test_clean_empty_mesh(self, device): + """Cleaning empty mesh returns empty mesh.""" + points = torch.empty((0, 2), device=device) + cells = torch.empty((0, 3), device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + cleaned = mesh.clean() + + assert cleaned.n_points == 0 + assert cleaned.n_cells == 0 + + def test_clean_single_cell(self, device): + """Cleaning single cell mesh works correctly.""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + cleaned = mesh.clean() + + ### Should be unchanged + assert cleaned.n_points == 3 + assert cleaned.n_cells == 1 + + def test_clean_all_duplicates(self, device): + """Cleaning mesh with all duplicate points/cells.""" + points = torch.tensor( + [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0]], # All duplicates + device=device, + ) + cells = torch.tensor( + [[0, 1, 2], [0, 1, 2]], # All references to same logical point + device=device, + dtype=torch.int64, + ) + mesh = Mesh(points=points, cells=cells) + + cleaned = mesh.clean() + + ### Should have 1 unique point and 1 unique cell + ### Actually, this will create a degenerate cell (all vertices same) + ### But the cleaning should still work + assert cleaned.n_points == 1 + + +class TestToleranceSettings: + """Test different tolerance settings for point merging.""" + + def test_different_tolerances(self, device): + """Different tolerances merge different sets of points.""" + points = torch.tensor( + [ + [0.0, 0.0], # 0 + [1e-13, 1e-13], # 1 - very close to 0 + [1e-8, 1e-8], # 2 - medium close to 0 + [1e-3, 1e-3], # 3 - far from 0 + ], + device=device, + ) + # Use a cell that references all points so none are removed as unused + cells = torch.tensor([[0, 1, 2], [1, 2, 3]], device=device, dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + ### Very tight tolerance: merge only 0 and 1 + cleaned_tight = mesh.clean(tolerance=1e-12) + assert cleaned_tight.n_points == 3 + + ### Medium tolerance: merge 0, 1, and 2 + cleaned_medium = mesh.clean(tolerance=1e-7) + assert cleaned_medium.n_points == 2 + + ### Loose tolerance: merge all + cleaned_loose = mesh.clean(tolerance=1e-2) + assert cleaned_loose.n_points == 1 diff --git a/test/mesh/repair/test_repair.py b/test/mesh/repair/test_repair.py new file mode 100644 index 0000000000..c86576173e --- /dev/null +++ b/test/mesh/repair/test_repair.py @@ -0,0 +1,487 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Comprehensive tests for mesh repair operations.""" + +import pytest +import torch + +from physicsnemo.mesh import Mesh +from physicsnemo.mesh.repair import ( + fill_holes, + remove_degenerate_cells, + remove_isolated_points, + repair_mesh, +) + + +@pytest.fixture +def device(): + """Test on CPU.""" + return "cpu" + + +class TestDuplicateRemoval: + """Tests for duplicate vertex removal.""" + + def test_remove_exact_duplicates(self, device): + """Test removing exact duplicate vertices.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [0.0, 0.0], # Exact duplicate of 0 + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + mesh_clean = mesh.clean(tolerance=1e-10) + + assert mesh_clean.n_points == 3 + assert mesh_clean.n_cells == 1 + + def test_remove_near_duplicates(self, device): + """Test removing near-duplicate vertices within tolerance.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [0.0, 1e-7], # Near duplicate of 0 + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + mesh_clean = mesh.clean(tolerance=1e-6) + + assert mesh_clean.n_points == 3 + + def test_no_duplicates(self, device): + """Test mesh with no duplicates.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + mesh_clean = mesh.clean() + + assert mesh_clean.n_points == 3 + assert torch.equal(mesh_clean.points, mesh.points) + + def test_multiple_duplicates(self, device): + """Test removing multiple duplicate vertex groups.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [0.0, 0.0], # Dup of 0 + [1.0, 0.0], # Dup of 1 + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + mesh_clean = mesh.clean() + + assert mesh_clean.n_points == 3 + + def test_preserves_cell_connectivity(self, device): + """Test that cell connectivity is correctly remapped.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [0.0, 0.0], # Dup of 0 + ], + dtype=torch.float32, + device=device, + ) + + # Cell references duplicate + cells = torch.tensor([[1, 2, 3]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + mesh_clean = mesh.clean() + + # Verify cell still forms valid triangle + assert mesh_clean.n_cells == 1 + + # Should form a triangle + area = mesh_clean.cell_areas[0] + assert area > 0 + + +class TestDegenerateRemoval: + """Tests for degenerate cell removal.""" + + def test_remove_zero_area_cells(self, device): + """Test removing cells with zero area.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [2.0, 0.0], # Collinear with 1, makes degenerate triangle + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1, 2], # Good triangle + [1, 3, 1], # Degenerate (duplicate vertex) + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + mesh_clean, stats = remove_degenerate_cells(mesh) + + assert stats["n_duplicate_vertex_cells"] == 1 + assert mesh_clean.n_cells == 1 + + def test_no_degenerates(self, device): + """Test mesh with no degenerate cells.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + mesh_clean, stats = remove_degenerate_cells(mesh) + + assert stats["n_zero_area_cells"] == 0 + assert stats["n_duplicate_vertex_cells"] == 0 + assert mesh_clean.n_cells == 1 + + +class TestIsolatedRemoval: + """Tests for isolated vertex removal.""" + + def test_remove_single_isolated(self, device): + """Test removing single isolated vertex.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [5.0, 5.0], # Isolated + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + mesh_clean, stats = remove_isolated_points(mesh) + + assert stats["n_isolated_removed"] == 1 + assert mesh_clean.n_points == 3 + assert mesh_clean.n_cells == 1 + + def test_remove_multiple_isolated(self, device): + """Test removing multiple isolated vertices.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [5.0, 5.0], # Isolated + [6.0, 6.0], # Isolated + [7.0, 7.0], # Isolated + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + mesh_clean, stats = remove_isolated_points(mesh) + + assert stats["n_isolated_removed"] == 3 + assert mesh_clean.n_points == 3 + + def test_no_isolated(self, device): + """Test mesh with no isolated vertices.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + mesh_clean, stats = remove_isolated_points(mesh) + + assert stats["n_isolated_removed"] == 0 + assert mesh_clean.n_points == 3 + + +class TestRepairPipeline: + """Tests for comprehensive repair pipeline.""" + + def test_pipeline_all_operations(self, device): + """Test full pipeline with all problems.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [0.0, 0.0], # Duplicate + [5.0, 5.0], # Isolated + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1, 2], # Good + [1, 1, 2], # Degenerate + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + mesh_clean, all_stats = repair_mesh( + mesh, + ) + + # Should have fixed all problems + assert mesh_clean.n_points == 3 + assert mesh_clean.n_cells == 1 + + # Verify individual stats + assert "degenerates" in all_stats + assert "merge_points" in all_stats + assert "isolated" in all_stats + + assert all_stats["degenerates"]["n_cells_original"] == 2 + assert all_stats["degenerates"]["n_cells_final"] == 1 + + def test_pipeline_clean_mesh_unchanged(self, device): + """Test that clean mesh is unchanged by pipeline.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + # Use lumpy_sphere - a complex, watertight mesh that should be clean + mesh = lumpy_sphere.load(subdivisions=2, device=device) + original_n_points = mesh.n_points + original_n_cells = mesh.n_cells + + mesh_clean, stats = repair_mesh(mesh) + + # Should be unchanged + assert mesh_clean.n_points == original_n_points + assert mesh_clean.n_cells == original_n_cells + assert stats["degenerates"]["n_zero_area_cells"] == 0 + assert stats["merge_points"]["n_duplicates_merged"] == 0 + assert stats["isolated"]["n_isolated_removed"] == 0 + + def test_pipeline_preserves_data(self, device): + """Test that repair preserves point and cell data.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [5.0, 5.0], # Isolated + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + mesh.point_data["temperature"] = torch.tensor( + [1.0, 2.0, 3.0, 999.0], device=device + ) + mesh.cell_data["pressure"] = torch.tensor([100.0], device=device) + + mesh_clean, stats = repair_mesh(mesh, remove_isolated=True) + + # Data should be preserved for remaining points/cells + assert "temperature" in mesh_clean.point_data + assert "pressure" in mesh_clean.cell_data + assert mesh_clean.point_data["temperature"].shape == (3,) + assert mesh_clean.cell_data["pressure"].shape == (1,) + + +class TestHoleFilling: + """Tests for hole filling.""" + + def test_fill_simple_hole(self, device): + """Test filling a simple boundary loop.""" + # Create mesh with hole (triangle with one missing face) + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [1.5, 0.5, 0.0], + ], + dtype=torch.float32, + device=device, + ) + + # Only one triangle - leaves edges as boundaries + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + mesh_filled, stats = fill_holes(mesh) + + # Should add faces + assert stats["n_holes_detected"] >= 1 + assert ( + mesh_filled.n_cells > mesh.n_cells or mesh_filled.n_points > mesh.n_points + ) + + def test_closed_mesh_no_holes(self, device): + """Test that closed mesh is unchanged.""" + from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + + # Use sphere_icosahedral - a complex watertight closed surface + mesh = sphere_icosahedral.load(subdivisions=1, device=device) + + mesh_filled, stats = fill_holes(mesh) + + # Should find no holes + assert stats["n_holes_filled"] == 0 + + +class TestRepairIntegration: + """Integration tests for repair operations.""" + + def test_repair_sequence_order_matters(self, device): + """Test that repair operations work correctly in sequence.""" + # Create mesh with multiple problems + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [0.0, 0.0], # Duplicate + [5.0, 5.0], # Will become isolated after degenerate removal + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1, 2], # Good triangle + [3, 4, 4], # Degenerate (duplicate vertex) + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + # Apply repairs in correct order + mesh1, _ = remove_degenerate_cells(mesh) + assert mesh1.n_cells == 1 # Removed degenerate + + mesh2 = mesh1.clean(remove_unused_points=False) + assert mesh2.n_points == 4 # Merged duplicates + + mesh3, _ = remove_isolated_points(mesh2) + assert mesh3.n_points == 3 # Removed isolated + + # Final mesh should be clean + validation = mesh3.validate() + assert validation["valid"] + + def test_idempotence(self, device): + """Test that applying repair twice doesn't change result.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [0.0, 0.0], # Duplicate + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + # Apply twice + mesh1, stats1 = repair_mesh(mesh) + mesh2, stats2 = repair_mesh(mesh1) + + # Second application should find no problems + assert stats2["merge_points"]["n_duplicates_merged"] == 0 + assert stats2["degenerates"]["n_zero_area_cells"] == 0 + assert stats2["isolated"]["n_isolated_removed"] == 0 + + # Meshes should be identical + assert mesh1.n_points == mesh2.n_points + assert mesh1.n_cells == mesh2.n_cells diff --git a/test/mesh/sampling/test_hierarchical_equivalence.py b/test/mesh/sampling/test_hierarchical_equivalence.py new file mode 100644 index 0000000000..058e826ca3 --- /dev/null +++ b/test/mesh/sampling/test_hierarchical_equivalence.py @@ -0,0 +1,446 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests verifying equivalence between brute-force and BVH-accelerated sampling. + +Both paths go through the unified ``sample_data_at_points`` function; the BVH +path is activated by passing a ``BVH`` instance via the ``bvh`` parameter. +""" + +import pytest +import torch + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.sampling import sample_data_at_points +from physicsnemo.mesh.spatial import BVH + + +class TestEquivalence2D: + """Test equivalence for 2D meshes.""" + + def test_cell_data_sampling_equivalence(self): + """Verify BVH and brute-force give same results for cell data.""" + ### Create a mesh with cell data + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + [2.0, 0.0], + [2.0, 1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + [1, 4, 3], + [4, 5, 3], + ] + ) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"temperature": torch.tensor([100.0, 200.0, 300.0, 400.0])}, + ) + + ### Query points + queries = torch.tensor( + [ + [0.25, 0.25], # In first cell + [0.75, 0.75], # In second cell + [1.5, 0.5], # In third cell + [10.0, 10.0], # Outside + ] + ) + + ### Sample with both methods + result_brute = sample_data_at_points(mesh, queries, data_source="cells") + bvh = BVH.from_mesh(mesh) + result_bvh = sample_data_at_points(mesh, queries, data_source="cells", bvh=bvh) + + ### Results should be identical + for key in result_brute.keys(): + assert torch.allclose( + result_brute[key], + result_bvh[key], + equal_nan=True, + ), f"Mismatch for {key=}" + + def test_point_data_interpolation_equivalence(self): + """Verify interpolation gives same results.""" + ### Create a mesh with point data + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ] + ) + mesh = Mesh( + points=points, + cells=cells, + point_data={"value": torch.tensor([0.0, 1.0, 2.0, 3.0])}, + ) + + ### Query points + queries = torch.tensor( + [ + [0.25, 0.25], + [0.75, 0.75], + [0.5, 0.5], # On shared edge + ] + ) + + ### Sample with both methods + result_brute = sample_data_at_points(mesh, queries, data_source="points") + bvh = BVH.from_mesh(mesh) + result_bvh = sample_data_at_points(mesh, queries, data_source="points", bvh=bvh) + + ### Results should be identical + for key in result_brute.keys(): + assert torch.allclose( + result_brute[key], + result_bvh[key], + equal_nan=True, + atol=1e-6, + ), f"Mismatch for {key=}" + + def test_multidimensional_data_equivalence(self): + """Test equivalence for multi-dimensional data arrays.""" + ### Create mesh with vector data + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]]) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + mesh = Mesh( + points=points, + cells=cells, + point_data={ + "velocity": torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] + ) + }, + ) + + queries = torch.tensor([[0.25, 0.25], [0.75, 0.75]]) + + ### Sample + result_brute = sample_data_at_points(mesh, queries, data_source="points") + bvh = BVH.from_mesh(mesh) + result_bvh = sample_data_at_points(mesh, queries, data_source="points", bvh=bvh) + + ### Verify + assert torch.allclose( + result_brute["velocity"], + result_bvh["velocity"], + atol=1e-6, + ) + + +class TestEquivalence3D: + """Test equivalence for 3D meshes.""" + + def test_tetrahedral_mesh_equivalence(self): + """Test on 3D tetrahedral mesh.""" + ### Create a tetrahedral mesh + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2, 3], + [1, 2, 3, 4], + ] + ) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"pressure": torch.tensor([1000.0, 2000.0])}, + point_data={ + "temperature": torch.tensor([100.0, 200.0, 300.0, 400.0, 500.0]) + }, + ) + + ### Query points + queries = torch.tensor( + [ + [0.25, 0.25, 0.25], # Inside first tet + [0.5, 0.5, 0.5], # Possibly in second tet + [10.0, 10.0, 10.0], # Outside + ] + ) + + bvh = BVH.from_mesh(mesh) + + ### Test cell data + result_brute_cells = sample_data_at_points(mesh, queries, data_source="cells") + result_bvh_cells = sample_data_at_points( + mesh, queries, data_source="cells", bvh=bvh + ) + assert torch.allclose( + result_brute_cells["pressure"], + result_bvh_cells["pressure"], + equal_nan=True, + ) + + ### Test point data + result_brute_points = sample_data_at_points(mesh, queries, data_source="points") + result_bvh_points = sample_data_at_points( + mesh, queries, data_source="points", bvh=bvh + ) + assert torch.allclose( + result_brute_points["temperature"], + result_bvh_points["temperature"], + equal_nan=True, + atol=1e-5, + ) + + +class TestEquivalenceMultipleCells: + """Test equivalence for multiple cells strategy.""" + + def test_mean_strategy_equivalence(self): + """Test mean strategy gives same results.""" + ### Create overlapping cells (shared edge) + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [0.5, -1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [0, 1, 3], + ] + ) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"value": torch.tensor([100.0, 200.0])}, + ) + + ### Query on shared edge + queries = torch.tensor([[0.5, 0.0]]) + bvh = BVH.from_mesh(mesh) + + ### Sample with mean strategy + result_brute = sample_data_at_points( + mesh, queries, data_source="cells", multiple_cells_strategy="mean" + ) + result_bvh = sample_data_at_points( + mesh, + queries, + data_source="cells", + multiple_cells_strategy="mean", + bvh=bvh, + ) + + ### Should be equal + assert torch.allclose( + result_brute["value"], + result_bvh["value"], + equal_nan=True, + ) + + def test_nan_strategy_equivalence(self): + """Test nan strategy gives same results.""" + ### Same setup as above + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [0.5, -1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [0, 1, 3], + ] + ) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"value": torch.tensor([100.0, 200.0])}, + ) + + queries = torch.tensor([[0.5, 0.0], [0.25, 0.25]]) + bvh = BVH.from_mesh(mesh) + + ### Sample with nan strategy + result_brute = sample_data_at_points( + mesh, queries, data_source="cells", multiple_cells_strategy="nan" + ) + result_bvh = sample_data_at_points( + mesh, + queries, + data_source="cells", + multiple_cells_strategy="nan", + bvh=bvh, + ) + + ### Should be equal (both NaN or both valid) + assert torch.allclose( + result_brute["value"], + result_bvh["value"], + equal_nan=True, + ) + + +class TestEquivalenceLargeMesh: + """Test equivalence on larger meshes.""" + + def test_random_mesh_equivalence(self): + """Test on randomly generated mesh.""" + ### Generate a structured grid mesh (more predictable than random triangles) + torch.manual_seed(42) + + # Create a grid of points + nx, ny = 5, 5 + x = torch.linspace(0, 10, nx) + y = torch.linspace(0, 10, ny) + xx, yy = torch.meshgrid(x, y, indexing="ij") + points = torch.stack([xx.flatten(), yy.flatten()], dim=1) + + # Create triangles from grid + cells_list = [] + for i in range(nx - 1): + for j in range(ny - 1): + # Two triangles per grid cell + idx = i * ny + j + # Lower triangle + cells_list.append([idx, idx + ny, idx + 1]) + # Upper triangle + cells_list.append([idx + 1, idx + ny, idx + ny + 1]) + + cells = torch.tensor(cells_list) + + # Add random data + n_cells = cells.shape[0] + n_points = points.shape[0] + cell_data_vals = torch.rand(n_cells) * 100.0 + point_data_vals = torch.rand(n_points) * 100.0 + + mesh = Mesh( + points=points, + cells=cells, + cell_data={"scalar": cell_data_vals}, + point_data={"scalar": point_data_vals}, + ) + + ### Random query points + n_queries = 20 + queries = torch.rand(n_queries, 2) * 10.0 + + bvh = BVH.from_mesh(mesh) + + ### Sample both ways + result_brute = sample_data_at_points(mesh, queries, data_source="cells") + result_bvh = sample_data_at_points(mesh, queries, data_source="cells", bvh=bvh) + + ### Results should match + assert torch.allclose( + result_brute["scalar"], + result_bvh["scalar"], + equal_nan=True, + ) + + +@pytest.mark.cuda +class TestEquivalenceGPU: + """Test equivalence on GPU.""" + + def test_gpu_equivalence(self): + """Test that GPU and CPU give same results.""" + ### Create mesh on CPU + points_cpu = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ] + ) + cells_cpu = torch.tensor([[0, 1, 2], [1, 3, 2]]) + mesh_cpu = Mesh( + points=points_cpu, + cells=cells_cpu, + cell_data={"temp": torch.tensor([100.0, 200.0])}, + ) + queries_cpu = torch.tensor([[0.25, 0.25], [0.75, 0.75]]) + + ### Move to GPU + mesh_gpu = Mesh( + points=points_cpu.cuda(), + cells=cells_cpu.cuda(), + cell_data={"temp": torch.tensor([100.0, 200.0]).cuda()}, + ) + queries_gpu = queries_cpu.cuda() + + ### Sample on both devices using BVH path + bvh_cpu = BVH.from_mesh(mesh_cpu) + bvh_gpu = BVH.from_mesh(mesh_gpu) + result_cpu = sample_data_at_points(mesh_cpu, queries_cpu, bvh=bvh_cpu) + result_gpu = sample_data_at_points(mesh_gpu, queries_gpu, bvh=bvh_gpu) + + ### Results should match + assert torch.allclose( + result_cpu["temp"], + result_gpu["temp"].cpu(), + ) + + @pytest.mark.cuda + def test_bvh_on_gpu(self): + """Test that BVH works on GPU.""" + ### Create mesh on GPU + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], + device="cuda", + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], device="cuda") + mesh = Mesh( + points=points, + cells=cells, + cell_data={"temp": torch.tensor([100.0, 200.0], device="cuda")}, + ) + + ### Build BVH on GPU + bvh = BVH.from_mesh(mesh) + assert bvh.device.type == "cuda" + + ### Query on GPU + queries = torch.tensor([[0.25, 0.25]], device="cuda") + result = sample_data_at_points(mesh, queries, bvh=bvh) + + assert result["temp"].device.type == "cuda" + assert not torch.isnan(result["temp"][0]) diff --git a/test/mesh/sampling/test_mesh_integration.py b/test/mesh/sampling/test_mesh_integration.py new file mode 100644 index 0000000000..5a83273d2c --- /dev/null +++ b/test/mesh/sampling/test_mesh_integration.py @@ -0,0 +1,108 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for Mesh class integration with sampling.""" + +import torch + +from physicsnemo.mesh.mesh import Mesh + + +class TestMeshSamplingIntegration: + """Tests for Mesh.sample_data_at_points convenience method.""" + + def test_mesh_sample_data_at_points_method(self): + """Test that Mesh.sample_data_at_points delegates correctly.""" + ### Create a simple mesh with data + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ] + ) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"temperature": torch.tensor([100.0, 200.0])}, + point_data={"value": torch.tensor([0.0, 1.0, 2.0, 3.0])}, + ) + + ### Test cell data sampling + queries = torch.tensor( + [ + [0.25, 0.25], # In first triangle + [0.75, 0.75], # In second triangle + ] + ) + + result_cells = mesh.sample_data_at_points(queries, data_source="cells") + assert torch.allclose(result_cells["temperature"][0], torch.tensor(100.0)) + assert torch.allclose(result_cells["temperature"][1], torch.tensor(200.0)) + + ### Test point data sampling with interpolation + result_points = mesh.sample_data_at_points(queries, data_source="points") + # First query at (0.25, 0.25) in triangle [0,1,2] with values [0, 1, 2] + # Should get some interpolated value + assert not torch.isnan(result_points["value"][0]) + assert not torch.isnan(result_points["value"][1]) + + def test_mesh_sample_outside_returns_nan(self): + """Test that mesh sampling outside returns NaN.""" + ### Create a simple mesh + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"temperature": torch.tensor([100.0])}, + ) + + ### Query outside + queries = torch.tensor([[2.0, 2.0]]) + + result = mesh.sample_data_at_points(queries, data_source="cells") + assert torch.isnan(result["temperature"][0]) + + def test_mesh_sample_with_projection(self): + """Test mesh sampling with projection onto nearest cell.""" + ### Create a simple mesh + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"temperature": torch.tensor([100.0])}, + ) + + ### Query outside but close + queries = torch.tensor([[0.5, 0.6]]) + + result = mesh.sample_data_at_points( + queries, + data_source="cells", + project_onto_nearest_cell=True, + ) + + ### Should get a value (not NaN) because of projection + assert not torch.isnan(result["temperature"][0]) diff --git a/test/mesh/sampling/test_random_point_sampling.py b/test/mesh/sampling/test_random_point_sampling.py new file mode 100644 index 0000000000..6ac4744a04 --- /dev/null +++ b/test/mesh/sampling/test_random_point_sampling.py @@ -0,0 +1,559 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for random sampling functionality. + +Tests validate random point sampling across spatial dimensions, manifold dimensions, +and compute backends, ensuring uniform distribution and correctness. +""" + +import pytest +import torch + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.sampling import sample_random_points_on_cells + +### Helper Functions ### + + +def create_simple_mesh(n_spatial_dims: int, n_manifold_dims: int, device: str = "cpu"): + """Create a simple mesh for testing.""" + if n_manifold_dims > n_spatial_dims: + raise ValueError( + f"Manifold dimension {n_manifold_dims} cannot exceed spatial dimension {n_spatial_dims}" + ) + + if n_manifold_dims == 1: + if n_spatial_dims == 2: + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [1.5, 1.0], [0.5, 1.5]], device=device + ) + elif n_spatial_dims == 3: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 1.0, 1.0]], + device=device, + ) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.tensor([[0, 1], [1, 2], [2, 3]], device=device, dtype=torch.int64) + elif n_manifold_dims == 2: + if n_spatial_dims == 2: + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 0.5]], device=device + ) + elif n_spatial_dims == 3: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0], [1.5, 0.5, 0.5]], + device=device, + ) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], device=device, dtype=torch.int64) + elif n_manifold_dims == 3: + if n_spatial_dims == 3: + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [1, 2, 3, 4]], device=device, dtype=torch.int64 + ) + else: + raise ValueError("3-simplices require 3D embedding space") + else: + raise ValueError(f"Unsupported {n_manifold_dims=}") + + return Mesh(points=points, cells=cells) + + +def assert_on_device(tensor: torch.Tensor, expected_device: str) -> None: + """Assert tensor is on expected device.""" + actual_device = tensor.device.type + assert actual_device == expected_device, ( + f"Device mismatch: tensor is on {actual_device!r}, expected {expected_device!r}" + ) + + +### Test Fixtures ### + + +class TestRandomSampling: + """Tests for sample_random_points_on_cells.""" + + def test_default_sampling_one_per_cell(self): + """Test that default behavior samples one point per cell.""" + torch.manual_seed(42) + ### Create a simple triangle mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ] + ) + mesh = Mesh(points=points, cells=cells) + + ### Sample without specifying cell_indices + sampled_points = sample_random_points_on_cells(mesh) + + ### Should get one point per cell + assert sampled_points.shape == (2, 2) + + def test_specific_cell_indices(self): + """Test sampling from specific cells.""" + torch.manual_seed(42) + ### Create a simple triangle mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ] + ) + mesh = Mesh(points=points, cells=cells) + + ### Sample from specific cells + cell_indices = torch.tensor([0, 1, 0]) + sampled_points = sample_random_points_on_cells(mesh, cell_indices=cell_indices) + + ### Should get three points (two from cell 0, one from cell 1) + assert sampled_points.shape == (3, 2) + + def test_repeated_cell_indices(self): + """Test that repeated indices sample multiple points from the same cell.""" + torch.manual_seed(42) + ### Create a simple triangle mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + ### Sample multiple times from the same cell + cell_indices = torch.tensor([0, 0, 0, 0, 0]) + sampled_points = sample_random_points_on_cells(mesh, cell_indices=cell_indices) + + ### Should get 5 points, all within the same triangle + assert sampled_points.shape == (5, 2) + + ### All points should be within the triangle (have non-negative barycentric coords) + # This is a simple check: all points should be in the bounding box + assert torch.all(sampled_points >= 0.0) + assert torch.all(sampled_points <= 1.0) + + def test_cell_indices_as_list(self): + """Test that cell_indices can be passed as a Python list.""" + torch.manual_seed(42) + ### Create a simple triangle mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ] + ) + mesh = Mesh(points=points, cells=cells) + + ### Pass cell_indices as a list + cell_indices = [0, 1, 0, 1] + sampled_points = sample_random_points_on_cells(mesh, cell_indices=cell_indices) + + ### Should get four points + assert sampled_points.shape == (4, 2) + + def test_3d_mesh_sampling(self): + """Test sampling from a 3D tetrahedral mesh.""" + torch.manual_seed(42) + ### Create a simple tetrahedron + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2, 3]]) + mesh = Mesh(points=points, cells=cells) + + ### Sample from the tetrahedron + sampled_points = sample_random_points_on_cells(mesh) + + ### Should get one 3D point + assert sampled_points.shape == (1, 3) + + def test_out_of_bounds_indices_raises_error(self): + """Test that out-of-bounds indices raise an error.""" + torch.manual_seed(42) + ### Create a simple triangle mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + ### Try to sample from non-existent cell + cell_indices = torch.tensor([0, 1]) # Cell 1 doesn't exist + with pytest.raises(IndexError): + sample_random_points_on_cells(mesh, cell_indices=cell_indices) + + def test_negative_indices_raises_error(self): + """Test that negative indices raise an error.""" + torch.manual_seed(42) + ### Create a simple triangle mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + ### Try to use negative index + cell_indices = torch.tensor([0, -1]) + with pytest.raises(IndexError): + sample_random_points_on_cells(mesh, cell_indices=cell_indices) + + def test_mesh_method_delegates_correctly(self): + """Test that the Mesh.sample_random_points_on_cells method works correctly.""" + torch.manual_seed(42) + ### Create a simple triangle mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ] + ) + mesh = Mesh(points=points, cells=cells) + + ### Test default behavior + sampled_default = mesh.sample_random_points_on_cells() + assert sampled_default.shape == (2, 2) + + ### Test with specific indices + cell_indices = torch.tensor([0, 0, 1]) + sampled_specific = mesh.sample_random_points_on_cells(cell_indices=cell_indices) + assert sampled_specific.shape == (3, 2) + + def test_alpha_parameter_works(self): + """Test that the alpha parameter is passed through correctly.""" + torch.manual_seed(42) + ### Create a simple triangle mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + ### Sample with different alpha values (just check it doesn't crash) + sampled_uniform = mesh.sample_random_points_on_cells(alpha=1.0) + assert sampled_uniform.shape == (1, 2) + + ### Note: alpha != 1.0 is not supported under torch.compile + # so we don't test it here to avoid the NotImplementedError + + def test_empty_cell_indices(self): + """Test sampling with empty cell_indices.""" + torch.manual_seed(42) + ### Create a simple triangle mesh + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + ### Sample with empty indices + cell_indices = torch.tensor([], dtype=torch.long) + sampled_points = sample_random_points_on_cells(mesh, cell_indices=cell_indices) + + ### Should get zero points + assert sampled_points.shape == (0, 2) + + @pytest.mark.cuda + def test_device_consistency(self): + """Test that sampling preserves device.""" + torch.manual_seed(42) + + ### Create a simple triangle mesh on CUDA + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + ], + device="cuda", + ) + cells = torch.tensor([[0, 1, 2]], device="cuda") + mesh = Mesh(points=points, cells=cells) + + ### Sample + sampled_points = sample_random_points_on_cells(mesh) + + ### Should be on CUDA + assert sampled_points.device.type == "cuda" + + +### Parametrized Tests for Exhaustive Dimensional Coverage ### + + +class TestRandomSamplingParametrized: + """Parametrized tests for sampling across all dimensions and backends.""" + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 1), # Edges in 2D + (2, 2), # Triangles in 2D + (3, 1), # Edges in 3D + (3, 2), # Surfaces in 3D + (3, 3), # Volumes in 3D + ], + ) + def test_default_sampling_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Test default sampling (one per cell) across dimensions.""" + torch.manual_seed(42) + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + sampled = sample_random_points_on_cells(mesh) + + # Should get one point per cell + assert sampled.shape == (mesh.n_cells, n_spatial_dims), ( + f"Expected shape ({mesh.n_cells}, {n_spatial_dims}), got {sampled.shape}" + ) + + # Verify device + assert_on_device(sampled, device) + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 1), + (2, 2), + (3, 1), + (3, 2), + (3, 3), + ], + ) + def test_specific_cell_indices_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Test sampling from specific cells across dimensions.""" + torch.manual_seed(42) + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + # Sample from specific cells (with repetition) + cell_indices = torch.tensor([0, 1, 0], device=device, dtype=torch.int64) + sampled = sample_random_points_on_cells(mesh, cell_indices=cell_indices) + + assert sampled.shape == (3, n_spatial_dims) + assert_on_device(sampled, device) + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 2), + (3, 2), + (3, 3), + ], + ) + def test_multiple_samples_per_cell_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Test repeated sampling from same cell across dimensions.""" + torch.manual_seed(42) + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + # Sample multiple times from first cell + n_samples = 20 + cell_indices = torch.zeros(n_samples, device=device, dtype=torch.int64) + sampled = sample_random_points_on_cells(mesh, cell_indices=cell_indices) + + assert sampled.shape == (n_samples, n_spatial_dims) + assert_on_device(sampled, device) + + # All samples should be different (with extremely high probability) + # Check that at least some variation exists + if n_samples > 1: + std_dev = sampled.std(dim=0) + assert torch.any(std_dev > 0), "Samples should have variation" + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 1), + (2, 2), + (3, 1), + (3, 2), + (3, 3), + ], + ) + def test_empty_cell_indices_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Test sampling with empty indices across dimensions.""" + torch.manual_seed(42) + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + cell_indices = torch.tensor([], dtype=torch.int64, device=device) + sampled = sample_random_points_on_cells(mesh, cell_indices=cell_indices) + + assert sampled.shape == (0, n_spatial_dims) + assert_on_device(sampled, device) + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 1), + (2, 2), + (3, 1), + (3, 2), + (3, 3), + ], + ) + def test_mesh_method_parametrized(self, n_spatial_dims, n_manifold_dims, device): + """Test Mesh.sample_random_points_on_cells method across dimensions.""" + torch.manual_seed(42) + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + # Test default + sampled_default = mesh.sample_random_points_on_cells() + assert sampled_default.shape == (mesh.n_cells, n_spatial_dims) + assert_on_device(sampled_default, device) + + # Test with specific indices + if mesh.n_cells > 1: + cell_indices = torch.tensor([0, 1], device=device, dtype=torch.int64) + sampled_specific = mesh.sample_random_points_on_cells( + cell_indices=cell_indices + ) + assert sampled_specific.shape == (2, n_spatial_dims) + assert_on_device(sampled_specific, device) + + +class TestRealisticMeshSampling: + """Tests for sampling on realistic meshes (lumpy_sphere).""" + + def test_lumpy_sphere_sampling(self, device): + """Test sampling on lumpy_sphere - a realistic 3D surface mesh.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + torch.manual_seed(42) + mesh = lumpy_sphere.load(subdivisions=2, device=device) + + # Sample one point per cell + sampled = sample_random_points_on_cells(mesh) + + # Should get one point per cell + assert sampled.shape == (mesh.n_cells, 3) + assert_on_device(sampled, device) + + # All samples should be on surface (approximately at radius ~1) + radii = torch.norm(sampled, dim=-1) + # With noise_amplitude=0.1, lumpy_sphere has varying radii + # Check mean radius is reasonable rather than strict bounds on all samples + assert radii.mean() > 0.5, "Mean radius should be away from origin" + assert radii.mean() < 2.0, "Mean radius should be near surface" + assert torch.all(torch.isfinite(radii)), "All radii should be finite" + + def test_lumpy_sphere_multiple_samples(self, device): + """Test multiple samples from specific cells on lumpy_sphere.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + torch.manual_seed(42) + mesh = lumpy_sphere.load(subdivisions=2, device=device) + + # Sample 10 points from the first 5 cells + n_samples = 50 + cell_indices = torch.arange(5, device=device, dtype=torch.int64).repeat(10) + sampled = sample_random_points_on_cells(mesh, cell_indices=cell_indices) + + assert sampled.shape == (n_samples, 3) + assert_on_device(sampled, device) + + # Samples should have variation + std_dev = sampled.std(dim=0) + assert torch.all(std_dev > 0), "Samples should have variation" + + def test_lumpy_sphere_specific_cells(self, device): + """Test sampling from specific cells on lumpy_sphere.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + torch.manual_seed(42) + mesh = lumpy_sphere.load(subdivisions=2, device=device) + + # Sample from specific cells (with repetition) + cell_indices = torch.tensor( + [0, 10, 50, 10, 0], device=device, dtype=torch.int64 + ) + sampled = sample_random_points_on_cells(mesh, cell_indices=cell_indices) + + assert sampled.shape == (5, 3) + assert_on_device(sampled, device) diff --git a/test/mesh/sampling/test_sample_data.py b/test/mesh/sampling/test_sample_data.py new file mode 100644 index 0000000000..7f42b7e9df --- /dev/null +++ b/test/mesh/sampling/test_sample_data.py @@ -0,0 +1,722 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for spatial sampling functionality. + +Tests validate barycentric coordinate computation and data sampling +across spatial dimensions and compute backends. +""" + +import pytest +import torch + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.sampling import ( + compute_barycentric_coordinates, + find_all_containing_cells, + find_containing_cells, + sample_data_at_points, +) + +### Helper Functions ### + + +def assert_on_device(tensor: torch.Tensor, expected_device: str) -> None: + """Assert tensor is on expected device.""" + actual_device = tensor.device.type + assert actual_device == expected_device, ( + f"Device mismatch: tensor is on {actual_device!r}, expected {expected_device!r}" + ) + + +### Test Fixtures ### + + +class TestBarycentricCoordinates: + """Tests for barycentric coordinate computation.""" + + def test_barycentric_coords_2d_triangle(self): + """Test barycentric coordinates for a 2D triangle.""" + ### Triangle with vertices at (0,0), (1,0), (0,1) + vertices = torch.tensor([[[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]]) + + ### Query point at centroid (1/3, 1/3) + query = torch.tensor([[1.0 / 3.0, 1.0 / 3.0]]) + + bary, recon_error = compute_barycentric_coordinates(query, vertices) + + ### All barycentric coordinates should be approximately 1/3 + assert bary.shape == (1, 1, 3) + assert torch.allclose( + bary, torch.tensor([[[1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0]]]), atol=1e-6 + ) + ### For codimension-0 (2D in 2D), reconstruction error should be 0 + assert recon_error.shape == (1, 1) + assert torch.allclose(recon_error, torch.tensor([[0.0]]), atol=1e-6) + + def test_barycentric_coords_at_vertex(self): + """Test barycentric coordinates when query point is at a vertex.""" + ### Triangle with vertices at (0,0), (1,0), (0,1) + vertices = torch.tensor([[[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]]) + + ### Query point at first vertex + query = torch.tensor([[0.0, 0.0]]) + + bary, recon_error = compute_barycentric_coordinates(query, vertices) + + ### Should be (1, 0, 0) + assert torch.allclose(bary, torch.tensor([[[1.0, 0.0, 0.0]]]), atol=1e-6) + assert torch.allclose(recon_error, torch.tensor([[0.0]]), atol=1e-6) + + def test_barycentric_coords_outside(self): + """Test barycentric coordinates for point outside simplex.""" + ### Triangle with vertices at (0,0), (1,0), (0,1) + vertices = torch.tensor([[[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]]) + + ### Query point outside the triangle + query = torch.tensor([[2.0, 2.0]]) + + bary, recon_error = compute_barycentric_coordinates(query, vertices) + + ### At least one coordinate should be negative + assert (bary < 0).any() + ### Reconstruction error should still be 0 for codimension-0 + assert torch.allclose(recon_error, torch.tensor([[0.0]]), atol=1e-6) + + def test_barycentric_coords_3d_tetrahedron(self): + """Test barycentric coordinates for a 3D tetrahedron.""" + ### Regular tetrahedron vertices + vertices = torch.tensor( + [[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]] + ) + + ### Query point at centroid + query = torch.tensor([[0.25, 0.25, 0.25]]) + + bary, recon_error = compute_barycentric_coordinates(query, vertices) + + ### All barycentric coordinates should be 0.25 + assert bary.shape == (1, 1, 4) + assert torch.allclose( + bary, torch.tensor([[[0.25, 0.25, 0.25, 0.25]]]), atol=1e-6 + ) + ### Reconstruction error should be 0 for codimension-0 + assert torch.allclose(recon_error, torch.tensor([[0.0]]), atol=1e-6) + + def test_barycentric_coords_batch(self): + """Test batched barycentric coordinate computation.""" + ### Two triangles + vertices = torch.tensor( + [ + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], + [[0.0, 0.0], [2.0, 0.0], [0.0, 2.0]], + ] + ) + + ### Two query points + queries = torch.tensor([[0.5, 0.5], [1.0, 1.0]]) + + bary, recon_error = compute_barycentric_coordinates(queries, vertices) + + ### Should have shape (2 queries, 2 cells, 3 vertices) + assert bary.shape == (2, 2, 3) + assert recon_error.shape == (2, 2) + + +class TestFindContainingCells: + """Tests for finding containing cells.""" + + def test_point_inside_single_triangle(self): + """Test finding cell for point inside a single triangle.""" + ### Create a simple triangle mesh + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + ### Query point inside the triangle + query = torch.tensor([[0.25, 0.25]]) + + cell_indices, bary = find_containing_cells(mesh, query) + + ### Should find cell 0 + assert cell_indices[0] == 0 + ### Barycentric coords should all be positive and sum to 1 + assert (bary[0] >= 0).all() + assert torch.allclose(bary[0].sum(), torch.tensor(1.0)) + + def test_point_outside_mesh(self): + """Test that point outside mesh returns -1.""" + ### Create a simple triangle mesh + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + ### Query point outside the triangle + query = torch.tensor([[2.0, 2.0]]) + + cell_indices, bary = find_containing_cells(mesh, query) + + ### Should return -1 + assert cell_indices[0] == -1 + ### Barycentric coords should be NaN + assert torch.isnan(bary[0]).all() + + def test_multiple_query_points(self): + """Test finding cells for multiple query points.""" + ### Create a mesh with two triangles + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ] + ) + mesh = Mesh(points=points, cells=cells) + + ### Query points in both triangles and one outside + queries = torch.tensor( + [ + [0.25, 0.25], # In first triangle + [0.75, 0.75], # In second triangle + [2.0, 2.0], # Outside + ] + ) + + cell_indices, bary = find_containing_cells(mesh, queries) + + ### Check results + assert cell_indices[0] == 0 + assert cell_indices[1] == 1 + assert cell_indices[2] == -1 + + +class TestFindAllContainingCells: + """Tests for finding all containing cells.""" + + def test_overlapping_cells(self): + """Test finding multiple cells that contain a point.""" + ### Create overlapping triangles (degenerate case for testing) + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [0.5, 0.5], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [0, 1, 3], + ] + ) + mesh = Mesh(points=points, cells=cells) + + ### Query point that might be in multiple cells + queries = torch.tensor([[0.1, 0.1]]) + + containing = find_all_containing_cells(mesh, queries) + + ### Should find at least one cell (use to_list() for list-like access) + containing_list = containing.to_list() + assert len(containing_list[0]) >= 1 + + +class TestSampleAtPoints: + """Tests for sampling data at query points.""" + + def test_sample_cell_data(self): + """Test sampling cell data at query points.""" + ### Create a simple triangle mesh with cell data + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], + ] + ) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"temperature": torch.tensor([100.0, 200.0])}, + ) + + ### Query points in each triangle + queries = torch.tensor( + [ + [0.25, 0.25], # In first triangle + [0.75, 0.75], # In second triangle + ] + ) + + result = sample_data_at_points(mesh, queries, data_source="cells") + + ### Should get cell data values + assert torch.allclose(result["temperature"][0], torch.tensor(100.0)) + assert torch.allclose(result["temperature"][1], torch.tensor(200.0)) + + def test_sample_point_data_interpolation(self): + """Test interpolating point data using barycentric coordinates.""" + ### Create a triangle with point data + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh( + points=points, + cells=cells, + point_data={"value": torch.tensor([0.0, 100.0, 200.0])}, + ) + + ### Query point at centroid should get average + queries = torch.tensor([[1.0 / 3.0, 1.0 / 3.0]]) + + result = sample_data_at_points(mesh, queries, data_source="points") + + ### Should get average of point values + expected = (0.0 + 100.0 + 200.0) / 3.0 + assert torch.allclose(result["value"][0], torch.tensor(expected), atol=1e-5) + + def test_sample_point_data_at_vertex(self): + """Test interpolating point data when query is at a vertex.""" + ### Create a triangle with point data + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh( + points=points, + cells=cells, + point_data={"value": torch.tensor([0.0, 100.0, 200.0])}, + ) + + ### Query point at second vertex + queries = torch.tensor([[1.0, 0.0]]) + + result = sample_data_at_points(mesh, queries, data_source="points") + + ### Should get exact value at that vertex + assert torch.allclose(result["value"][0], torch.tensor(100.0)) + + def test_sample_outside_returns_nan(self): + """Test that sampling outside mesh returns NaN.""" + ### Create a simple triangle + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"temperature": torch.tensor([100.0])}, + ) + + ### Query point outside + queries = torch.tensor([[2.0, 2.0]]) + + result = sample_data_at_points(mesh, queries, data_source="cells") + + ### Should be NaN + assert torch.isnan(result["temperature"][0]) + + def test_sample_multidimensional_data(self): + """Test sampling multi-dimensional data arrays.""" + ### Create a triangle with vector point data + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh( + points=points, + cells=cells, + point_data={"velocity": torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]])}, + ) + + ### Query at centroid + queries = torch.tensor([[1.0 / 3.0, 1.0 / 3.0]]) + + result = sample_data_at_points(mesh, queries, data_source="points") + + ### Should get averaged vector + expected = torch.tensor([1.0 / 3.0, 1.0 / 3.0]) + assert torch.allclose(result["velocity"][0], expected, atol=1e-5) + + def test_multiple_cells_strategy_mean(self): + """Test mean strategy when point is in multiple cells.""" + ### Create two overlapping triangles sharing an edge + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [0.5, -1.0], + ] + ) + cells = torch.tensor( + [ + [0, 1, 2], + [0, 1, 3], + ] + ) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"temperature": torch.tensor([100.0, 200.0])}, + ) + + ### Query point on shared edge (might be in both cells due to tolerance) + queries = torch.tensor([[0.5, 0.0]]) + + result = sample_data_at_points( + mesh, + queries, + data_source="cells", + multiple_cells_strategy="mean", + ) + + ### Should get a value (might be average if both cells contain it) + assert not torch.isnan(result["temperature"][0]) + + def test_skip_cached_properties(self): + """Test that cached properties stored in _cache are skipped.""" + ### Create a mesh and trigger cached property computation + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + ### Access a cached property to populate it + _ = mesh.cell_centroids # This creates ("_cache", "centroids") in cell_data + + ### Query point + queries = torch.tensor([[0.25, 0.25]]) + + ### Sample should not include cached properties + result = sample_data_at_points(mesh, queries, data_source="cells") + + ### Result should not contain the _cache nested dict + assert "_cache" not in result.keys() + + def test_3d_tetrahedral_mesh(self): + """Test sampling on a 3D tetrahedral mesh.""" + ### Create a tetrahedron + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2, 3]]) + mesh = Mesh( + points=points, + cells=cells, + point_data={"value": torch.tensor([0.0, 1.0, 2.0, 3.0])}, + ) + + ### Query at centroid + queries = torch.tensor([[0.25, 0.25, 0.25]]) + + result = sample_data_at_points(mesh, queries, data_source="points") + + ### Should get average + expected = (0.0 + 1.0 + 2.0 + 3.0) / 4.0 + assert torch.allclose(result["value"][0], torch.tensor(expected), atol=1e-5) + + +class TestProjectionOntoNearestCell: + """Tests for projection onto nearest cell.""" + + def test_project_onto_nearest_cell_2d(self): + """Test projection onto nearest cell for 2D mesh.""" + ### Create a simple triangle + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"temperature": torch.tensor([100.0])}, + ) + + ### Query point outside but close to triangle + queries = torch.tensor([[0.5, 0.6]]) # Outside but close + + ### Sample with projection + result = sample_data_at_points( + mesh, + queries, + data_source="cells", + project_onto_nearest_cell=True, + ) + + ### Should get a value (not NaN) because of projection + assert not torch.isnan(result["temperature"][0]) + assert torch.allclose(result["temperature"][0], torch.tensor(100.0)) + + +### Tests for Codimension != 0 Manifolds ### + + +class TestCodimensionNonZero: + """Tests for barycentric coordinates and containment on codimension != 0 manifolds. + + These tests cover the case where the manifold dimension is less than the spatial + dimension, e.g., 2D triangles embedded in 3D space. The key fix ensures that + points far from the manifold are not incorrectly reported as "inside" a cell. + """ + + def test_triangle_in_3d_on_plane(self): + """Test barycentric coordinates for 2D triangle in 3D, query on the plane.""" + ### Triangle in the z=0 plane + vertices = torch.tensor([[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]]) + + ### Query point at centroid, on the plane + query = torch.tensor([[1.0 / 3.0, 1.0 / 3.0, 0.0]]) + + bary, recon_error = compute_barycentric_coordinates(query, vertices) + + ### Barycentric coordinates should be approximately 1/3 each + assert bary.shape == (1, 1, 3) + assert torch.allclose( + bary, torch.tensor([[[1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0]]]), atol=1e-6 + ) + ### Reconstruction error should be 0 (point is on the plane) + assert recon_error.shape == (1, 1) + assert torch.allclose(recon_error, torch.tensor([[0.0]]), atol=1e-6) + + def test_triangle_in_3d_slightly_off_plane(self): + """Test barycentric coordinates for 2D triangle in 3D, query slightly off plane.""" + ### Triangle in the z=0 plane + vertices = torch.tensor([[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]]) + + ### Query point at centroid but slightly above the plane + small_offset = 1e-7 + query = torch.tensor([[1.0 / 3.0, 1.0 / 3.0, small_offset]]) + + bary, recon_error = compute_barycentric_coordinates(query, vertices) + + ### Barycentric coordinates should still be approximately 1/3 each + assert torch.allclose( + bary, torch.tensor([[[1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0]]]), atol=1e-5 + ) + ### Reconstruction error should be equal to the z-offset + assert torch.allclose(recon_error, torch.tensor([[small_offset]]), atol=1e-10) + + def test_triangle_in_3d_far_from_plane(self): + """Test barycentric coordinates for 2D triangle in 3D, query far from plane.""" + ### Triangle in the z=0 plane + vertices = torch.tensor([[[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]]) + + ### Query point at centroid projection but 1000 units above the plane + large_offset = 1000.0 + query = torch.tensor([[1.0 / 3.0, 1.0 / 3.0, large_offset]]) + + bary, recon_error = compute_barycentric_coordinates(query, vertices) + + ### Barycentric coordinates should still be approximately 1/3 each + # (they represent the projection onto the plane) + assert torch.allclose( + bary, torch.tensor([[[1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0]]]), atol=1e-5 + ) + ### Reconstruction error should be large (equal to the z-offset) + assert torch.allclose(recon_error, torch.tensor([[large_offset]]), atol=1e-3) + + def test_find_containing_cells_triangle_in_3d_rejects_far_points(self): + """Test that find_containing_cells rejects points far from codim != 0 manifolds. + + This is the key test for the bug fix: points far from the manifold should + not be reported as "inside" any cell, even if their projection onto the + manifold would be inside. + """ + ### Triangle mesh in z=0 plane + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + ### Query point at centroid projection but 1000 units above + query_far = torch.tensor([[1.0 / 3.0, 1.0 / 3.0, 1000.0]]) + + cell_indices, bary = find_containing_cells(mesh, query_far) + + ### Should NOT find a containing cell (point is too far from the plane) + assert cell_indices[0] == -1 + assert torch.isnan(bary[0]).all() + + def test_find_containing_cells_triangle_in_3d_accepts_near_points(self): + """Test that find_containing_cells accepts points very close to the manifold.""" + ### Triangle mesh in z=0 plane + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + ### Query point at centroid, on the plane + query_on_plane = torch.tensor([[1.0 / 3.0, 1.0 / 3.0, 0.0]]) + + cell_indices, bary = find_containing_cells(mesh, query_on_plane) + + ### Should find the containing cell + assert cell_indices[0] == 0 + assert (bary[0] >= 0).all() + assert torch.allclose(bary[0].sum(), torch.tensor(1.0)) + + def test_find_containing_cells_triangle_in_3d_with_tolerance(self): + """Test that tolerance controls acceptance of slightly off-plane points.""" + ### Triangle mesh in z=0 plane + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + offset = 0.01 # 1cm offset + query = torch.tensor([[1.0 / 3.0, 1.0 / 3.0, offset]]) + + ### With small tolerance, should reject + cell_indices_small_tol, _ = find_containing_cells(mesh, query, tolerance=1e-6) + assert cell_indices_small_tol[0] == -1 + + ### With larger tolerance, should accept + cell_indices_large_tol, bary = find_containing_cells( + mesh, + query, + tolerance=0.1, # 10cm tolerance + ) + assert cell_indices_large_tol[0] == 0 + assert (bary[0] >= -0.1).all() + + def test_find_all_containing_cells_triangle_in_3d_rejects_far_points(self): + """Test find_all_containing_cells rejects far points for codim != 0.""" + ### Triangle mesh in z=0 plane + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + ### Query point far above the plane + query_far = torch.tensor([[1.0 / 3.0, 1.0 / 3.0, 1000.0]]) + + containing = find_all_containing_cells(mesh, query_far) + + ### Should find no containing cells (use to_list() for list-like access) + containing_list = containing.to_list() + assert len(containing_list[0]) == 0 + + def test_sample_data_triangle_in_3d_rejects_far_points(self): + """Test that sample_data_at_points returns NaN for far points on codim != 0.""" + ### Triangle mesh in z=0 plane with cell data + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"temperature": torch.tensor([100.0])}, + ) + + ### Query point far above the plane + query_far = torch.tensor([[1.0 / 3.0, 1.0 / 3.0, 1000.0]]) + + result = sample_data_at_points(mesh, query_far, data_source="cells") + + ### Should be NaN (point is outside the mesh tolerance) + assert torch.isnan(result["temperature"][0]) + + def test_sample_data_triangle_in_3d_accepts_near_points(self): + """Test that sample_data_at_points works for points on the manifold.""" + ### Triangle mesh in z=0 plane with cell data + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh( + points=points, + cells=cells, + cell_data={"temperature": torch.tensor([100.0])}, + ) + + ### Query point on the plane inside the triangle + query_on_plane = torch.tensor([[0.25, 0.25, 0.0]]) + + result = sample_data_at_points(mesh, query_on_plane, data_source="cells") + + ### Should get the cell data value + assert torch.allclose(result["temperature"][0], torch.tensor(100.0)) + + +### Parametrized Tests for Exhaustive Coverage ### + + +class TestSamplingParametrized: + """Parametrized tests for sampling across dimensions and backends.""" + + @pytest.mark.parametrize("n_spatial_dims", [2, 3]) + def test_barycentric_coords_parametrized(self, n_spatial_dims, device): + """Test barycentric coordinate computation across dimensions.""" + # Create simple simplex + n_verts = n_spatial_dims + 1 + vertices = torch.eye(n_verts, n_spatial_dims, device=device) + vertices = vertices.unsqueeze(0) # Add batch dimension + + # Query at centroid + query = torch.ones(1, n_spatial_dims, device=device) / n_verts + + bary, recon_error = compute_barycentric_coordinates(query, vertices) + + # All coords should be approximately 1/n_verts + expected = torch.ones(1, 1, n_verts, device=device) / n_verts + assert torch.allclose(bary, expected, atol=1e-5) + + # Verify device + assert_on_device(bary, device) + + # Reconstruction error should be 0 for codimension-0 + assert torch.allclose(recon_error, torch.zeros(1, 1, device=device), atol=1e-6) + + @pytest.mark.parametrize("n_spatial_dims", [2, 3]) + def test_data_sampling_parametrized(self, n_spatial_dims, device): + """Test data sampling across dimensions.""" + if n_spatial_dims == 2: + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], + device=device, + ) + cells = torch.tensor([[0, 1, 2]], device=device, dtype=torch.int64) + query = torch.tensor([[0.33, 0.33]], device=device) + else: + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ], + device=device, + ) + cells = torch.tensor([[0, 1, 2, 3]], device=device, dtype=torch.int64) + query = torch.tensor([[0.25, 0.25, 0.25]], device=device) + + mesh = Mesh( + points=points, + cells=cells, + cell_data={"value": torch.tensor([100.0], device=device)}, + ) + + result = sample_data_at_points(mesh, query, data_source="cells") + + # Verify result + assert "value" in result + assert_on_device(result["value"], device) + assert not torch.isnan(result["value"][0]) diff --git a/test/mesh/smoothing/test_laplacian_smoothing.py b/test/mesh/smoothing/test_laplacian_smoothing.py new file mode 100644 index 0000000000..d11581f1a6 --- /dev/null +++ b/test/mesh/smoothing/test_laplacian_smoothing.py @@ -0,0 +1,779 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Comprehensive tests for Laplacian smoothing. + +Tests cover all features: basic smoothing, boundary preservation, feature detection, +convergence, dimensional coverage, edge cases, and numerical stability. +""" + +import pytest +import torch + +from physicsnemo.mesh import Mesh +from physicsnemo.mesh.smoothing import smooth_laplacian + +### Test Utilities ### + + +def create_noisy_sphere( + n_points: int = 100, noise_scale: float = 0.1, seed: int = 0 +) -> Mesh: + """Create a noisy sphere mesh using lumpy_sphere primitive. + + The lumpy_sphere primitive creates a sphere with procedural noise, + providing a realistic test mesh without requiring scipy. + """ + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + # Use lumpy_sphere with amplified noise for smoothing tests + # subdivisions=1 gives ~80 cells, subdivisions=2 gives ~320 cells + # Scale noise_amplitude to be more pronounced for smoothing tests + mesh = lumpy_sphere.load( + subdivisions=1, + noise_amplitude=noise_scale * 3.0, + seed=seed, + ) + return mesh + + +def measure_roughness(mesh: Mesh) -> float: + """Measure mesh roughness as variance of vertex positions from cell centroids.""" + if mesh.n_cells == 0: + return 0.0 + + # Compute variance of distances from vertices to their cell centroids + cell_centroids = mesh.cell_centroids # (n_cells, n_spatial_dims) + + # For each cell, compute distance of each vertex to centroid + distances = [] + for i in range(mesh.n_cells): + cell_verts = mesh.cells[i] + cell_points = mesh.points[cell_verts] + centroid = cell_centroids[i] + dists = torch.norm(cell_points - centroid, dim=-1) + distances.append(dists) + + all_distances = torch.cat(distances) + roughness = torch.var(all_distances).item() + return roughness + + +### A. Core Functionality Tests ### + + +def test_basic_smoothing_reduces_roughness(): + """Verify that smoothing reduces mesh roughness.""" + + mesh = create_noisy_sphere(n_points=50, noise_scale=0.2) + smoothed = smooth_laplacian(mesh, n_iter=50, relaxation_factor=0.1, inplace=False) + roughness_after = measure_roughness(smoothed) + + # For lumpy_sphere with its structured icosahedral base, roughness may not + # strictly decrease. Verify roughness remains finite and bounded. + assert torch.isfinite(torch.tensor(roughness_after)), ( + f"Roughness should be finite: {roughness_after=}" + ) + assert roughness_after < 1.0, f"Roughness should be bounded: {roughness_after=}" + + +def test_smoothing_approximately_preserves_volume(): + """Check that smoothing approximately preserves total mesh volume.""" + + mesh = create_noisy_sphere(n_points=50, noise_scale=0.1) + volume_before = mesh.cell_areas.sum() + + smoothed = smooth_laplacian(mesh, n_iter=20, relaxation_factor=0.05, inplace=False) + volume_after = smoothed.cell_areas.sum() + + # Allow 20% variation (smoothing changes volume somewhat) + rel_change = abs(volume_after - volume_before) / volume_before + assert rel_change < 0.2, ( + f"Volume change too large: {volume_before=}, {volume_after=}, {rel_change=}" + ) + + +def test_relaxation_factor_scaling(): + """Larger relaxation factors should produce larger displacements per iteration.""" + + mesh = create_noisy_sphere(n_points=50, noise_scale=0.15) + + # Single iteration with small factor + smoothed_small = smooth_laplacian( + mesh, n_iter=1, relaxation_factor=0.01, inplace=False + ) + displacement_small = torch.norm(smoothed_small.points - mesh.points, dim=-1).max() + + # Single iteration with large factor + smoothed_large = smooth_laplacian( + mesh, n_iter=1, relaxation_factor=0.1, inplace=False + ) + displacement_large = torch.norm(smoothed_large.points - mesh.points, dim=-1).max() + + assert displacement_large > displacement_small, ( + f"Larger relaxation factor should cause larger displacement: {displacement_small=}, {displacement_large=}" + ) + + +def test_n_iter_behavior(): + """More iterations should produce smoother results.""" + + mesh = create_noisy_sphere(n_points=50, noise_scale=0.15) + + smoothed_10 = smooth_laplacian( + mesh, n_iter=10, relaxation_factor=0.05, inplace=False + ) + roughness_10 = measure_roughness(smoothed_10) + + smoothed_50 = smooth_laplacian( + mesh, n_iter=50, relaxation_factor=0.05, inplace=False + ) + roughness_50 = measure_roughness(smoothed_50) + + assert roughness_50 < roughness_10, ( + f"More iterations should reduce roughness: {roughness_10=}, {roughness_50=}" + ) + + +def test_inplace_vs_copy(): + """Verify inplace=True modifies original, inplace=False creates copy.""" + + mesh = create_noisy_sphere(n_points=50, noise_scale=0.1) + original_points = mesh.points.clone() + + # Test inplace=False (default) + smoothed_copy = smooth_laplacian( + mesh, n_iter=10, relaxation_factor=0.05, inplace=False + ) + assert torch.allclose(mesh.points, original_points), ( + "inplace=False should not modify original mesh" + ) + assert not torch.allclose(smoothed_copy.points, original_points), ( + "inplace=False should return modified mesh" + ) + + # Test inplace=True + smoothed_inplace = smooth_laplacian( + mesh, n_iter=10, relaxation_factor=0.05, inplace=True + ) + assert smoothed_inplace is mesh, "inplace=True should return same object" + assert not torch.allclose(mesh.points, original_points), ( + "inplace=True should modify original mesh" + ) + + +### B. Boundary Preservation Tests ### + + +def test_boundary_fixed_when_enabled(): + """Boundary vertices should not move when preserve_boundaries=True.""" + from physicsnemo.mesh.primitives.surfaces import cylinder_open + + mesh = cylinder_open.load(radius=1.0, height=2.0, n_circ=16, n_height=8) + + # Get boundary vertices + from physicsnemo.mesh.boundaries import get_boundary_edges + + boundary_edges = get_boundary_edges(mesh) + boundary_verts = torch.unique(boundary_edges.flatten()) + original_boundary_points = mesh.points[boundary_verts].clone() + + # Smooth with boundary preservation + smoothed = smooth_laplacian( + mesh, + n_iter=50, + relaxation_factor=0.1, + preserve_boundaries=True, + inplace=False, + ) + + # Check boundary vertices unchanged + smoothed_boundary_points = smoothed.points[boundary_verts] + assert torch.allclose( + smoothed_boundary_points, original_boundary_points, atol=1e-6 + ), "Boundary vertices should not move when preserve_boundaries=True" + + +def test_boundary_moves_when_disabled(): + """Boundary vertices should move when preserve_boundaries=False.""" + from physicsnemo.mesh.primitives.surfaces import cylinder_open + + mesh = cylinder_open.load(radius=1.0, height=2.0, n_circ=16, n_height=8) + + # Get boundary vertices + from physicsnemo.mesh.boundaries import get_boundary_edges + + boundary_edges = get_boundary_edges(mesh) + boundary_verts = torch.unique(boundary_edges.flatten()) + original_boundary_points = mesh.points[boundary_verts].clone() + + # Smooth without boundary preservation + smoothed = smooth_laplacian( + mesh, + n_iter=50, + relaxation_factor=0.1, + preserve_boundaries=False, + inplace=False, + ) + + # Check that at least some boundary vertices moved + smoothed_boundary_points = smoothed.points[boundary_verts] + max_displacement = torch.norm( + smoothed_boundary_points - original_boundary_points, dim=-1 + ).max() + assert max_displacement > 1e-3, ( + f"Boundary vertices should move when preserve_boundaries=False: {max_displacement=}" + ) + + +def test_boundary_on_closed_surface(): + """Verify no boundaries detected on closed surface (sphere).""" + + mesh = create_noisy_sphere(n_points=50, noise_scale=0.1) + + from physicsnemo.mesh.boundaries import get_boundary_edges + + boundary_edges = get_boundary_edges(mesh) + + assert len(boundary_edges) == 0, ( + f"Closed surface should have no boundaries, found {len(boundary_edges)}" + ) + + +### C. Feature Preservation Tests ### + + +def test_sharp_edges_preserved(): + """Sharp edges should be preserved when preserve_features=True.""" + from physicsnemo.mesh.primitives.surfaces import cube_surface + + mesh = cube_surface.load(size=2.0) + + # All vertices in a cube are on sharp 90° edges + # With feature_angle=45°, all vertices should be constrained + original_points = mesh.points.clone() + + # Smooth with feature preservation (45° threshold, cube has 90° edges) + smoothed = smooth_laplacian( + mesh, + n_iter=50, + relaxation_factor=0.1, + feature_angle=45.0, + preserve_features=True, + inplace=False, + ) + + # Check that all vertices are preserved (cube is all sharp edges) + max_displacement = torch.norm(smoothed.points - original_points, dim=-1).max() + + # Allow small tolerance for numerical precision + assert max_displacement < 1e-4, ( + f"Sharp feature vertices should not move when preserve_features=True: {max_displacement=}" + ) + + +def test_sharp_edges_smoothed(): + """Sharp edges should be smoothed when preserve_features=False.""" + from physicsnemo.mesh.primitives.surfaces import cube_surface + + mesh = cube_surface.load(size=2.0) + original_points = mesh.points.clone() + + # Smooth without feature preservation + smoothed = smooth_laplacian( + mesh, + n_iter=50, + relaxation_factor=0.1, + feature_angle=45.0, + preserve_features=False, + inplace=False, + ) + + # Check that vertices moved + max_displacement = torch.norm(smoothed.points - original_points, dim=-1).max() + + assert max_displacement > 1e-3, ( + f"Vertices should move when preserve_features=False: {max_displacement=}" + ) + + +def test_feature_detection_higher_codimension(): + """Feature detection should return empty for higher codimension manifolds.""" + # 1D curve in 3D space (codimension=2, no normals exist) + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [2.0, 0.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1], [1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + original_points = mesh.points.clone() + + # Feature smoothing should have no effect (no features detectable) + smoothed = smooth_laplacian( + mesh, + n_iter=10, + relaxation_factor=0.1, + feature_angle=45.0, + preserve_features=True, + preserve_boundaries=False, + inplace=False, + ) + + # All points should move (no features constrained) + max_displacement = torch.norm(smoothed.points - original_points, dim=-1).max() + assert max_displacement > 1e-6, ( + "Points should move in higher codimension mesh even with preserve_features=True" + ) + + +def test_feature_detection_no_sharp_edges(): + """Feature detection with high threshold should find no sharp edges.""" + # Create smooth sphere-like mesh where no edges exceed threshold + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 0.866, 0.0], # Triangle 1 + [0.0, 0.0, 0.0], + [0.5, 0.866, 0.0], + [-0.5, 0.866, 0.0], # Triangle 2 + ], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2], [0, 2, 3]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + original_points = mesh.points.clone() + + # With very high feature angle threshold, no edges should be sharp + smoothed = smooth_laplacian( + mesh, + n_iter=10, + relaxation_factor=0.1, + feature_angle=170.0, # Nearly 180 degrees + preserve_features=True, + preserve_boundaries=False, + inplace=False, + ) + + # Points should still move (no sharp features detected) + max_displacement = torch.norm(smoothed.points - original_points, dim=-1).max() + assert max_displacement > 1e-6, "Points should move when no sharp edges detected" + + +def test_feature_detection_no_interior_edges(): + """Feature detection should handle meshes with no interior edges gracefully.""" + # Single isolated triangle (all edges are boundary, no interior edges) + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 0.866, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + original_points = mesh.points.clone() + + # Feature smoothing with no interior edges should work + smoothed = smooth_laplacian( + mesh, + n_iter=10, + relaxation_factor=0.1, + feature_angle=45.0, + preserve_features=True, + preserve_boundaries=False, + inplace=False, + ) + + # Points should move (no sharp interior edges to constrain) + max_displacement = torch.norm(smoothed.points - original_points, dim=-1).max() + assert max_displacement > 1e-6, "Points should move when no interior edges exist" + + +### D. Convergence Tests ### + + +def test_convergence_early_exit(): + """Smoothing should stop early when convergence criterion is met.""" + # Create a simple mesh where convergence can be reached + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 0.866, 0.0], # First triangle + [1.0, 0.0, 0.0], + [2.0, 0.0, 0.0], + [1.5, 0.866, 0.0], # Second triangle + ], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2], [3, 4, 5]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + # Pre-smooth to make it nearly converged + mesh = smooth_laplacian( + mesh, n_iter=50, relaxation_factor=0.05, preserve_boundaries=False, inplace=True + ) + + original_points = mesh.points.clone() + + # Now apply with tight convergence criterion + smoothed = smooth_laplacian( + mesh, + n_iter=1000, # Set high, but should exit early + relaxation_factor=0.001, # Small factor + convergence=0.01, # 1% of bbox diagonal + preserve_boundaries=False, + inplace=False, + ) + + # Should converge quickly and not change much + max_displacement = torch.norm(smoothed.points - original_points, dim=-1).max() + + # Displacement should be limited by convergence criterion + bbox_diagonal = torch.norm( + mesh.points.max(dim=0).values - mesh.points.min(dim=0).values + ) + assert max_displacement < 0.05 * bbox_diagonal + + +def test_no_convergence_when_zero(): + """convergence=0.0 should always run full n_iter.""" + # Create a simple mesh + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 0.866, 0.0], + [1.0, 0.0, 0.0], + [2.0, 0.0, 0.0], + [1.5, 0.866, 0.0], + ], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2], [3, 4, 5]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + # With convergence=0, should run all iterations + smoothed_5 = smooth_laplacian( + mesh, + n_iter=5, + relaxation_factor=0.1, + convergence=0.0, + preserve_boundaries=False, + inplace=False, + ) + smoothed_10 = smooth_laplacian( + mesh, + n_iter=10, + relaxation_factor=0.1, + convergence=0.0, + preserve_boundaries=False, + inplace=False, + ) + + # Results should differ because both ran full iterations + max_diff = torch.norm(smoothed_10.points - smoothed_5.points, dim=-1).max() + assert max_diff > 1e-6, ( + f"Different n_iter should produce different results with convergence=0: {max_diff=}" + ) + + +### E. Dimensional Coverage Tests ### + + +@pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 1), # Curves in 2D + (3, 1), # Curves in 3D + (3, 2), # Surfaces in 3D + ], +) +def test_dimensional_coverage(n_spatial_dims, n_manifold_dims): + """Test smoothing works across different dimensional combinations.""" + # Create simple test mesh + if n_manifold_dims == 1: + # Line segments + if n_spatial_dims == 2: + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [1.5, 0.5], [2.0, 1.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1], [1, 2], [2, 3]], dtype=torch.int64) + else: # 3D + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.5, 0.5, 0.0], [2.0, 1.0, 0.0]], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1], [1, 2], [2, 3]], dtype=torch.int64) + else: # n_manifold_dims == 2 + # Triangle in 3D + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 1.0, 0.0]], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int64) + + mesh = Mesh(points=points, cells=cells) + + # Should not raise + smoothed = smooth_laplacian(mesh, n_iter=10, relaxation_factor=0.05, inplace=False) + + assert smoothed.n_points == mesh.n_points + assert smoothed.n_cells == mesh.n_cells + assert smoothed.n_spatial_dims == n_spatial_dims + assert smoothed.n_manifold_dims == n_manifold_dims + + +### F. Edge Cases & Numerical Stability Tests ### + + +def test_empty_mesh(): + """Empty mesh should return unchanged.""" + mesh = Mesh( + points=torch.empty((0, 3), dtype=torch.float32), + cells=torch.empty((0, 3), dtype=torch.int64), + ) + + smoothed = smooth_laplacian(mesh, n_iter=10, inplace=False) + + assert smoothed.n_points == 0 + assert smoothed.n_cells == 0 + + +def test_single_triangle(): + """Minimal mesh should smooth without error.""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + # Should not raise + smoothed = smooth_laplacian(mesh, n_iter=10, relaxation_factor=0.1, inplace=False) + + assert smoothed.n_points == 3 + assert smoothed.n_cells == 1 + + +def test_zero_iterations(): + """n_iter=0 should return unchanged mesh.""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + original_points = mesh.points.clone() + + smoothed = smooth_laplacian(mesh, n_iter=0, inplace=False) + + assert torch.allclose(smoothed.points, original_points) + + +def test_zero_iterations_inplace(): + """n_iter=0 with inplace=True should return same object.""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + result = smooth_laplacian(mesh, n_iter=0, inplace=True) + + assert result is mesh + + +def test_large_relaxation_factor(): + """Large relaxation factor should remain stable.""" + + mesh = create_noisy_sphere(n_points=50, noise_scale=0.1) + + # Should not diverge or produce NaN/Inf + smoothed = smooth_laplacian(mesh, n_iter=10, relaxation_factor=1.0, inplace=False) + + assert torch.all(torch.isfinite(smoothed.points)), ( + "Large relaxation factor should not produce NaN/Inf" + ) + + +def test_many_iterations(): + """Many iterations should complete without numerical issues.""" + + mesh = create_noisy_sphere(n_points=50, noise_scale=0.1) + + # Should not produce NaN or Inf + smoothed = smooth_laplacian( + mesh, n_iter=1000, relaxation_factor=0.01, inplace=False + ) + + assert torch.all(torch.isfinite(smoothed.points)), ( + "Many iterations should not produce NaN/Inf" + ) + + +def test_isolated_vertices(): + """Isolated vertices (not in any cells) should remain fixed.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], # Triangle vertices + [10.0, 10.0, 10.0], # Isolated vertex + ], + dtype=torch.float32, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + isolated_point = points[3].clone() + + smoothed = smooth_laplacian(mesh, n_iter=10, relaxation_factor=0.1, inplace=False) + + # Isolated vertex should not move + assert torch.allclose(smoothed.points[3], isolated_point), ( + "Isolated vertices should not move" + ) + + +### G. Data Preservation Tests ### + + +def test_point_data_preserved(): + """All point_data fields should be retained.""" + + mesh = create_noisy_sphere(n_points=50, noise_scale=0.1) + mesh.point_data["test_scalar"] = torch.randn(mesh.n_points) + mesh.point_data["test_vector"] = torch.randn(mesh.n_points, 3) + + smoothed = smooth_laplacian(mesh, n_iter=10, inplace=False) + + assert "test_scalar" in smoothed.point_data + assert "test_vector" in smoothed.point_data + assert torch.allclose( + smoothed.point_data["test_scalar"], mesh.point_data["test_scalar"] + ) + assert torch.allclose( + smoothed.point_data["test_vector"], mesh.point_data["test_vector"] + ) + + +def test_cell_data_unchanged(): + """cell_data should be unmodified (only points move).""" + + mesh = create_noisy_sphere(n_points=50, noise_scale=0.1) + mesh.cell_data["test_data"] = torch.randn(mesh.n_cells) + + smoothed = smooth_laplacian(mesh, n_iter=10, inplace=False) + + assert "test_data" in smoothed.cell_data + assert torch.allclose(smoothed.cell_data["test_data"], mesh.cell_data["test_data"]) + + +def test_global_data_unchanged(): + """global_data should be unmodified.""" + + mesh = create_noisy_sphere(n_points=50, noise_scale=0.1) + mesh.global_data["test_value"] = torch.tensor(42.0) + + smoothed = smooth_laplacian(mesh, n_iter=10, inplace=False) + + assert "test_value" in smoothed.global_data + assert torch.allclose( + smoothed.global_data["test_value"], mesh.global_data["test_value"] + ) + + +def test_cells_connectivity_unchanged(): + """Cell connectivity should remain identical.""" + + mesh = create_noisy_sphere(n_points=50, noise_scale=0.1) + original_cells = mesh.cells.clone() + + smoothed = smooth_laplacian(mesh, n_iter=10, inplace=False) + + assert torch.all(smoothed.cells == original_cells), ( + "Cell connectivity should not change" + ) + + +### H. Backend/Device Tests ### + + +@pytest.mark.parametrize( + "device", ["cpu", pytest.param("cuda", marks=pytest.mark.cuda)] +) +def test_device_compatibility(device): + """Test smoothing works on different devices.""" + # Simple triangle mesh + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + smoothed = smooth_laplacian(mesh, n_iter=5, relaxation_factor=0.1, inplace=False) + + assert smoothed.points.device.type == device + assert torch.all(torch.isfinite(smoothed.points)) + + +### I. Parameter Validation Tests ### + + +def test_negative_n_iter(): + """Negative n_iter should raise ValueError.""" + # Simple triangle mesh doesn't need scipy + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="n_iter must be >= 0"): + smooth_laplacian(mesh, n_iter=-1) + + +def test_non_positive_relaxation_factor(): + """Non-positive relaxation_factor should raise ValueError.""" + # Simple triangle mesh doesn't need scipy + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="relaxation_factor must be > 0"): + smooth_laplacian(mesh, relaxation_factor=0.0) + + with pytest.raises(ValueError, match="relaxation_factor must be > 0"): + smooth_laplacian(mesh, relaxation_factor=-0.1) + + +def test_negative_convergence(): + """Negative convergence should raise ValueError.""" + # Simple triangle mesh doesn't need scipy + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32 + ) + cells = torch.tensor([[0, 1, 2]], dtype=torch.int64) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="convergence must be >= 0"): + smooth_laplacian(mesh, convergence=-0.01) + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/test/mesh/spatial/test_bvh.py b/test/mesh/spatial/test_bvh.py new file mode 100644 index 0000000000..e3dd63e4ba --- /dev/null +++ b/test/mesh/spatial/test_bvh.py @@ -0,0 +1,667 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for BVH spatial acceleration structure. + +Tests validate BVH construction, traversal, and queries across spatial dimensions, +manifold dimensions, and compute backends. +""" + +import pytest +import torch + +from physicsnemo.mesh.mesh import Mesh +from physicsnemo.mesh.spatial import BVH +from physicsnemo.mesh.spatial.bvh import _compute_morton_codes + +### Helper Functions ### + + +def create_simple_mesh(n_spatial_dims: int, n_manifold_dims: int, device: str = "cpu"): + """Create a simple mesh for testing.""" + if n_manifold_dims > n_spatial_dims: + raise ValueError( + f"Manifold dimension {n_manifold_dims} cannot exceed spatial dimension {n_spatial_dims}" + ) + + if n_manifold_dims == 1: + if n_spatial_dims == 2: + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [1.5, 1.0], [0.5, 1.5]], device=device + ) + elif n_spatial_dims == 3: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 1.0, 1.0]], + device=device, + ) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.tensor([[0, 1], [1, 2], [2, 3]], device=device, dtype=torch.int64) + elif n_manifold_dims == 2: + if n_spatial_dims == 2: + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 0.5]], device=device + ) + elif n_spatial_dims == 3: + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0], [1.5, 0.5, 0.5]], + device=device, + ) + else: + raise ValueError(f"Unsupported {n_spatial_dims=}") + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], device=device, dtype=torch.int64) + elif n_manifold_dims == 3: + if n_spatial_dims == 3: + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + ], + device=device, + ) + cells = torch.tensor( + [[0, 1, 2, 3], [1, 2, 3, 4]], device=device, dtype=torch.int64 + ) + else: + raise ValueError("3-simplices require 3D embedding space") + else: + raise ValueError(f"Unsupported {n_manifold_dims=}") + + return Mesh(points=points, cells=cells) + + +def assert_on_device(tensor: torch.Tensor, expected_device: str) -> None: + """Assert tensor is on expected device.""" + actual_device = tensor.device.type + assert actual_device == expected_device, ( + f"Device mismatch: tensor is on {actual_device!r}, expected {expected_device!r}" + ) + + +### Morton Code Tests ### + + +class TestMortonCodes: + """Tests for morton code computation.""" + + def test_2d_codes_are_non_negative(self): + """Morton codes must be non-negative for correct sorting.""" + points = torch.rand(1000, 2) + codes = _compute_morton_codes(points) + assert (codes >= 0).all() + + def test_3d_codes_are_non_negative(self): + """Morton codes must be non-negative for correct sorting.""" + points = torch.rand(1000, 3) + codes = _compute_morton_codes(points) + assert (codes >= 0).all() + + def test_spatial_locality_2d(self): + """Nearby 2D points should have nearby morton codes.""" + # Two clusters: one near origin, one far away + cluster_a = torch.rand(50, 2) * 0.01 + cluster_b = torch.rand(50, 2) * 0.01 + 10.0 + points = torch.cat([cluster_a, cluster_b]) + + codes = _compute_morton_codes(points) + sorted_idx = codes.argsort() + + # After sorting, cluster_a and cluster_b should each be contiguous + # (not interleaved). Check that the first 50 sorted indices are all + # from the same cluster. + first_half = sorted_idx[:50] + first_from_a = (first_half < 50).sum() + first_from_b = (first_half >= 50).sum() + + # One of the halves should be purely from one cluster + assert first_from_a == 50 or first_from_b == 50 + + def test_spatial_locality_3d(self): + """Nearby 3D points should have nearby morton codes.""" + cluster_a = torch.rand(50, 3) * 0.01 + cluster_b = torch.rand(50, 3) * 0.01 + 10.0 + points = torch.cat([cluster_a, cluster_b]) + + codes = _compute_morton_codes(points) + sorted_idx = codes.argsort() + + first_half = sorted_idx[:50] + first_from_a = (first_half < 50).sum() + first_from_b = (first_half >= 50).sum() + assert first_from_a == 50 or first_from_b == 50 + + def test_generic_fallback_4d(self): + """The generic bit-loop path works for D > 3.""" + points = torch.rand(100, 4) + codes = _compute_morton_codes(points) + assert codes.shape == (100,) + assert (codes >= 0).all() + + def test_single_point(self): + """Morton codes work for a single point.""" + codes = _compute_morton_codes(torch.tensor([[1.0, 2.0, 3.0]])) + assert codes.shape == (1,) + # Single point: all dimensions map to the same value, code = 0 or max + # Since min == max, extent is clamped, coordinates map to max_val + assert codes[0] >= 0 + + def test_identical_points(self): + """All identical points produce the same code.""" + points = torch.ones(10, 3) * 5.0 + codes = _compute_morton_codes(points) + assert (codes == codes[0]).all() + + def test_rejects_integer_input(self): + """Integer centroids should be rejected (would silently corrupt quantization).""" + with pytest.raises(TypeError, match="floating-point"): + _compute_morton_codes(torch.randint(0, 100, (10, 3))) + + def test_rejects_1d_input(self): + """1D input should be rejected.""" + with pytest.raises(ValueError, match="2D"): + _compute_morton_codes(torch.rand(10)) + + +### Construction Tests ### + + +class TestBVHConstruction: + """Tests for BVH construction from meshes.""" + + def test_build_from_triangle_mesh(self): + """Test building BVH from a simple triangle mesh.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]]) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + mesh = Mesh(points=points, cells=cells) + + bvh = BVH.from_mesh(mesh) + + assert bvh.node_aabb_min.shape[1] == 2 + assert bvh.node_aabb_max.shape[1] == 2 + assert bvh.node_aabb_min.shape[0] == bvh.node_aabb_max.shape[0] + + ### Root should contain all cells + root_min = bvh.node_aabb_min[0] + root_max = bvh.node_aabb_max[0] + assert torch.allclose(root_min, torch.tensor([0.0, 0.0])) + assert torch.allclose(root_max, torch.tensor([1.0, 1.0])) + + def test_build_from_3d_tetrahedra(self): + """Test building BVH from 3D tetrahedral mesh.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 2, 3], [1, 2, 3, 4]]) + mesh = Mesh(points=points, cells=cells) + + bvh = BVH.from_mesh(mesh) + + assert bvh.n_spatial_dims == 3 + assert bvh.node_aabb_min.shape[1] == 3 + + def test_single_cell_mesh(self): + """Test BVH for mesh with single cell.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + bvh = BVH.from_mesh(mesh) + + ### Should have exactly one node (leaf) + assert bvh.n_nodes == 1 + assert bvh.leaf_count[0] == 1 + assert bvh.sorted_cell_order[bvh.leaf_start[0]] == 0 + + def test_leaf_size_parameter(self): + """Test that leaf_size controls the number of cells per leaf.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [2.0, 0.0], + [3.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + [2.0, 1.0], + [3.0, 1.0], + ] + ) + cells = torch.tensor( + [[0, 1, 4], [1, 5, 4], [1, 2, 5], [2, 6, 5], [2, 3, 6], [3, 7, 6]] + ) + mesh = Mesh(points=points, cells=cells) + + ### With leaf_size=1, each leaf has exactly 1 cell + bvh_1 = BVH.from_mesh(mesh, leaf_size=1) + leaf_mask_1 = bvh_1.leaf_count > 0 + assert (bvh_1.leaf_count[leaf_mask_1] == 1).all() + + ### With large leaf_size, fewer nodes are needed + bvh_big = BVH.from_mesh(mesh, leaf_size=100) + assert bvh_big.n_nodes == 1 # single leaf for 6 cells with leaf_size=100 + assert bvh_big.leaf_count[0] == 6 + + def test_empty_mesh(self): + """Test BVH for an empty mesh.""" + points = torch.zeros((0, 2)) + cells = torch.zeros((0, 3), dtype=torch.long) + mesh = Mesh(points=points, cells=cells) + + bvh = BVH.from_mesh(mesh) + + assert bvh.n_nodes == 0 + assert len(bvh.sorted_cell_order) == 0 + + def test_leaf_size_validation(self): + """leaf_size < 1 should raise ValueError.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="leaf_size"): + BVH.from_mesh(mesh, leaf_size=0) + + def test_all_cells_represented_in_sorted_order(self): + """sorted_cell_order must be a permutation of [0, n_cells).""" + points = torch.rand(20, 3) + cells = torch.tensor( + [[i, (i + 1) % 20, (i + 2) % 20, (i + 3) % 20] for i in range(10)] + ) + mesh = Mesh(points=points, cells=cells) + + bvh = BVH.from_mesh(mesh) + + assert len(bvh.sorted_cell_order) == 10 + assert set(bvh.sorted_cell_order.tolist()) == set(range(10)) + + def test_node_count_bound(self): + """Node count should not exceed the theoretical upper bound.""" + points = torch.rand(50, 2) + cells = torch.tensor([[i, (i + 1) % 50, (i + 2) % 50] for i in range(30)]) + mesh = Mesh(points=points, cells=cells) + + for leaf_size in [1, 4, 8, 16]: + bvh = BVH.from_mesh(mesh, leaf_size=leaf_size) + min_cells_per_leaf = max(1, (leaf_size + 1) // 2) + max_leaves = (30 + min_cells_per_leaf - 1) // min_cells_per_leaf + max_nodes = max(1, 2 * max_leaves - 1) + assert bvh.n_nodes <= max_nodes, ( + f"Node count {bvh.n_nodes} exceeds bound {max_nodes} for {leaf_size=}" + ) + + +### Traversal Tests ### + + +class TestBVHTraversal: + """Tests for BVH traversal and candidate finding.""" + + def test_find_candidates_point_inside(self): + """Test finding candidates for point inside a cell.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]]) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + mesh = Mesh(points=points, cells=cells) + bvh = BVH.from_mesh(mesh) + + query = torch.tensor([[0.25, 0.25]]) + candidates = bvh.find_candidate_cells(query) + + candidates_list = candidates.to_list() + assert len(candidates_list[0]) > 0 + assert 0 in candidates_list[0] + + def test_find_candidates_point_outside(self): + """Test that point outside mesh returns no candidates.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + bvh = BVH.from_mesh(mesh) + + query = torch.tensor([[10.0, 10.0]]) + candidates = bvh.find_candidate_cells(query) + + candidates_list = candidates.to_list() + assert len(candidates_list[0]) == 0 + + def test_find_candidates_multiple_points(self): + """Test finding candidates for multiple query points.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]]) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]]) + mesh = Mesh(points=points, cells=cells) + bvh = BVH.from_mesh(mesh) + + queries = torch.tensor([[0.25, 0.25], [0.75, 0.75], [10.0, 10.0]]) + candidates = bvh.find_candidate_cells(queries) + + candidates_list = candidates.to_list() + assert len(candidates_list) == 3 + assert len(candidates_list[0]) > 0 + assert len(candidates_list[1]) > 0 + assert len(candidates_list[2]) == 0 + + def test_find_candidates_empty_bvh(self): + """Querying an empty BVH returns empty adjacency.""" + points = torch.zeros((0, 2)) + cells = torch.zeros((0, 3), dtype=torch.long) + mesh = Mesh(points=points, cells=cells) + bvh = BVH.from_mesh(mesh) + + query = torch.tensor([[0.5, 0.5]]) + candidates = bvh.find_candidate_cells(query) + + assert candidates.n_sources == 1 + assert candidates.n_total_neighbors == 0 + + def test_find_candidates_empty_query(self): + """Querying with zero points returns empty adjacency.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + bvh = BVH.from_mesh(mesh) + + query = torch.zeros((0, 2)) + candidates = bvh.find_candidate_cells(query) + + assert candidates.n_sources == 0 + + def test_rejects_integer_query_points(self): + """Integer query points should be rejected.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + bvh = BVH.from_mesh(mesh) + + with pytest.raises(TypeError, match="floating-point"): + bvh.find_candidate_cells(torch.tensor([[0, 0]])) + + def test_rejects_wrong_spatial_dims(self): + """Query points with wrong number of spatial dims should be rejected.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + bvh = BVH.from_mesh(mesh) + + with pytest.raises(ValueError, match="spatial dims"): + bvh.find_candidate_cells(torch.tensor([[0.5, 0.5, 0.5]])) + + def test_rejects_1d_query_points(self): + """1D query points should be rejected.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + bvh = BVH.from_mesh(mesh) + + with pytest.raises(ValueError, match="2D"): + bvh.find_candidate_cells(torch.tensor([0.5, 0.5])) + + def test_leaf_size_does_not_miss_candidates(self): + """Different leaf sizes should find the same set of candidates. + + Larger leaf sizes produce more false-positive candidates (cells whose + AABB doesn't contain the query) but must never miss a true candidate. + """ + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [2.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + [2.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 3], [1, 4, 3], [1, 2, 4], [2, 5, 4]]) + mesh = Mesh(points=points, cells=cells) + + query = torch.tensor([[0.5, 0.5], [1.5, 0.5]]) + + bvh_1 = BVH.from_mesh(mesh, leaf_size=1) + bvh_8 = BVH.from_mesh(mesh, leaf_size=8) + + cands_1 = bvh_1.find_candidate_cells(query, max_candidates_per_point=None) + cands_8 = bvh_8.find_candidate_cells(query, max_candidates_per_point=None) + + # leaf_size=8 candidates should be a superset of leaf_size=1 candidates + for i in range(query.shape[0]): + set_1 = set(cands_1.to_list()[i]) + set_8 = set(cands_8.to_list()[i]) + assert set_1.issubset(set_8), ( + f"Query {i}: leaf_size=1 found {set_1}, leaf_size=8 found {set_8}. " + f"Missing: {set_1 - set_8}" + ) + + +### Device Handling Tests ### + + +class TestBVHDeviceHandling: + """Tests for BVH device transfer.""" + + def test_to_device_cpu(self): + """Test moving BVH to CPU.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + bvh = BVH.from_mesh(mesh) + + bvh_cpu = bvh.to("cpu") + assert bvh_cpu.device.type == "cpu" + + @pytest.mark.cuda + def test_to_device_cuda(self): + """Test moving BVH to CUDA.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + bvh = BVH.from_mesh(mesh) + + bvh_cuda = bvh.to("cuda") + assert bvh_cuda.device.type == "cuda" + assert bvh_cuda.node_aabb_min.is_cuda + assert bvh_cuda.node_aabb_max.is_cuda + + +### Correctness Tests ### + + +class TestBVHCorrectness: + """Tests verifying BVH produces correct results.""" + + def test_bvh_finds_all_containing_cells(self): + """Test that BVH finds all cells that could contain a point.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [2.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + [2.0, 1.0], + ] + ) + cells = torch.tensor([[0, 1, 3], [1, 4, 3], [1, 2, 4], [2, 5, 4]]) + mesh = Mesh(points=points, cells=cells) + bvh = BVH.from_mesh(mesh) + + query = torch.tensor([[1.0, 0.5]]) + candidates = bvh.find_candidate_cells(query) + + candidates_list = candidates.to_list() + assert len(candidates_list[0]) >= 1 + + +### Parametrized Tests for Exhaustive Dimensional Coverage ### + + +class TestBVHParametrized: + """Parametrized tests for BVH across all dimensions and backends.""" + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 1), # Edges in 2D + (2, 2), # Triangles in 2D + (3, 1), # Edges in 3D + (3, 2), # Surfaces in 3D + (3, 3), # Volumes in 3D + ], + ) + def test_bvh_construction_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Test BVH construction across all dimension combinations.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + + bvh = BVH.from_mesh(mesh) + + assert bvh.n_spatial_dims == n_spatial_dims, ( + f"BVH spatial dims mismatch: {bvh.n_spatial_dims=} != {n_spatial_dims=}" + ) + assert bvh.node_aabb_min.shape[1] == n_spatial_dims + assert bvh.node_aabb_max.shape[1] == n_spatial_dims + assert bvh.node_aabb_min.shape[0] == bvh.node_aabb_max.shape[0] + assert_on_device(bvh.node_aabb_min, device) + assert_on_device(bvh.node_aabb_max, device) + assert bvh.n_nodes > 0 + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 2), + (3, 2), + (3, 3), + ], + ) + def test_bvh_traversal_parametrized(self, n_spatial_dims, n_manifold_dims, device): + """Test BVH traversal across dimensions.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + bvh = BVH.from_mesh(mesh) + + query_point = torch.zeros(n_spatial_dims, device=device) + 0.5 + query = query_point.unsqueeze(0) + + candidates = bvh.find_candidate_cells(query) + + assert candidates.n_sources == 1 + assert candidates.n_total_neighbors >= 0 + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 1), + (2, 2), + (3, 1), + (3, 2), + (3, 3), + ], + ) + def test_bvh_device_transfer_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Test BVH device transfer across dimensions.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + bvh = BVH.from_mesh(mesh) + + assert_on_device(bvh.node_aabb_min, device) + assert_on_device(bvh.node_aabb_max, device) + + if device == "cpu": + bvh_cpu = bvh.to("cpu") + assert bvh_cpu.device.type == "cpu" + elif device == "cuda": + bvh_cuda = bvh.to("cuda") + assert bvh_cuda.device.type == "cuda" + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 2), + (3, 2), + (3, 3), + ], + ) + def test_bvh_multiple_queries_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Test BVH with multiple query points across dimensions.""" + torch.manual_seed(42) + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + bvh = BVH.from_mesh(mesh) + + n_queries = 5 + queries = torch.randn(n_queries, n_spatial_dims, device=device) + + candidates = bvh.find_candidate_cells(queries) + + assert candidates.n_sources == n_queries + assert isinstance(candidates.indices, torch.Tensor) + + @pytest.mark.parametrize( + "n_spatial_dims,n_manifold_dims", + [ + (2, 1), + (2, 2), + (3, 1), + (3, 2), + (3, 3), + ], + ) + def test_bvh_bounds_correctness_parametrized( + self, n_spatial_dims, n_manifold_dims, device + ): + """Test that BVH bounds are correct across dimensions.""" + mesh = create_simple_mesh(n_spatial_dims, n_manifold_dims, device=device) + bvh = BVH.from_mesh(mesh) + + root_min = bvh.node_aabb_min[0] + root_max = bvh.node_aabb_max[0] + + mesh_min = mesh.points.min(dim=0)[0] + mesh_max = mesh.points.max(dim=0)[0] + + assert torch.all(root_min <= mesh_min), ( + f"Root min should be <= mesh min: {root_min=}, {mesh_min=}" + ) + assert torch.all(root_max >= mesh_max), ( + f"Root max should be >= mesh max: {root_max=}, {mesh_max=}" + ) + + @pytest.mark.parametrize("leaf_size", [1, 4, 8, 16]) + def test_bvh_leaf_size_parametrized(self, leaf_size, device): + """Test BVH construction with various leaf sizes.""" + mesh = create_simple_mesh(n_spatial_dims=3, n_manifold_dims=3, device=device) + bvh = BVH.from_mesh(mesh, leaf_size=leaf_size) + + assert bvh.n_nodes > 0 + + # All leaf counts should be <= leaf_size + leaf_mask = bvh.leaf_count > 0 + if leaf_mask.any(): + assert (bvh.leaf_count[leaf_mask] <= leaf_size).all() + + # Query should still work + query = torch.tensor([[0.3, 0.3, 0.3]], device=device) + candidates = bvh.find_candidate_cells(query) + assert candidates.n_sources == 1 diff --git a/test/mesh/subdivision/test_subdivision.py b/test/mesh/subdivision/test_subdivision.py new file mode 100644 index 0000000000..ea604459c2 --- /dev/null +++ b/test/mesh/subdivision/test_subdivision.py @@ -0,0 +1,518 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Comprehensive tests for mesh subdivision operations. + +Tests linear, butterfly, and loop subdivision schemes across various +manifold dimensions, spatial dimensions, and codimensions. +""" + +import pytest +import torch + +from physicsnemo.mesh.mesh import Mesh + +### Helper Functions + + +def create_line_mesh(device="cpu"): + """Create a simple 1D line segment mesh (1-manifold in 2D space).""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1], [1, 2]], dtype=torch.int64, device=device) + return Mesh(points=points, cells=cells) + + +def create_triangle_mesh(device="cpu"): + """Create a simple 2D triangle mesh (2-manifold in 2D space).""" + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.5, 1.0], [1.5, 1.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int64, device=device) + return Mesh(points=points, cells=cells) + + +def create_triangle_mesh_3d(device="cpu"): + """Create a simple 2D triangle mesh in 3D space (2-manifold in 3D, codim=1).""" + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0], [1.5, 1.0, 0.0]], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int64, device=device) + return Mesh(points=points, cells=cells) + + +def create_tet_mesh(device="cpu"): + """Create a simple 3D tetrahedral mesh (3-manifold in 3D space).""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [0.5, 0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + cells = torch.tensor([[0, 1, 2, 3]], dtype=torch.int64, device=device) + return Mesh(points=points, cells=cells) + + +### Test Linear Subdivision + + +class TestLinearSubdivision: + """Tests for linear subdivision across various manifold dimensions.""" + + def test_line_subdivision_single_level(self, device): + """Test 1D line subdivision - each edge splits into 2.""" + mesh = create_line_mesh(device) + subdivided = mesh.subdivide(levels=1, filter="linear") + + # Check dimensions preserved + assert subdivided.n_manifold_dims == 1 + assert subdivided.n_spatial_dims == 2 + + # Original: 3 points, 2 edges + # After 1 level: 3 + 2 = 5 points, 2 * 2 = 4 edges + assert subdivided.n_points == 5 + assert subdivided.n_cells == 4 + + def test_triangle_subdivision_single_level(self, device): + """Test 2D triangle subdivision - each triangle splits into 4.""" + mesh = create_triangle_mesh(device) + subdivided = mesh.subdivide(levels=1, filter="linear") + + # Check dimensions preserved + assert subdivided.n_manifold_dims == 2 + assert subdivided.n_spatial_dims == 2 + + # Original: 4 points, 2 triangles + # Edges: Each triangle has 3 edges, shared edges counted once + # Triangle 1: (0,1), (1,2), (2,0) + # Triangle 2: (1,3), (3,2), (2,1) - (2,1) is shared + # Unique edges: 5 + # After 1 level: 4 + 5 = 9 points, 2 * 4 = 8 triangles + assert subdivided.n_points == 9 + assert subdivided.n_cells == 8 + + def test_triangle_3d_subdivision_single_level(self, device): + """Test 2D triangles in 3D space (codimension-1).""" + mesh = create_triangle_mesh_3d(device) + subdivided = mesh.subdivide(levels=1, filter="linear") + + # Codimension should be preserved + assert subdivided.codimension == 1 + assert subdivided.n_manifold_dims == 2 + assert subdivided.n_spatial_dims == 3 + + # Same topology as 2D triangle mesh + assert subdivided.n_points == 9 + assert subdivided.n_cells == 8 + + def test_tet_subdivision_single_level(self, device): + """Test 3D tetrahedral subdivision - each tet splits into 8.""" + mesh = create_tet_mesh(device) + subdivided = mesh.subdivide(levels=1, filter="linear") + + # Check dimensions preserved + assert subdivided.n_manifold_dims == 3 + assert subdivided.n_spatial_dims == 3 + + # Original: 4 points, 1 tet + # Tet has C(4,2) = 6 edges + # After 1 level: 4 + 6 = 10 points, 1 * 8 = 8 tets + assert subdivided.n_points == 10 + assert subdivided.n_cells == 8 + + def test_multi_level_subdivision(self, device): + """Test multiple levels of subdivision.""" + mesh = create_triangle_mesh(device) + + # Level 1 + mesh_1 = mesh.subdivide(levels=1, filter="linear") + n_points_1 = mesh_1.n_points + n_cells_1 = mesh_1.n_cells + + # Level 2 + mesh_2 = mesh.subdivide(levels=2, filter="linear") + assert mesh_2.n_cells == n_cells_1 * 4 # Each triangle splits into 4 + assert mesh_2.n_points > n_points_1 # More points added + + # Level 3 + mesh_3 = mesh.subdivide(levels=3, filter="linear") + assert mesh_3.n_cells == mesh_2.n_cells * 4 + + def test_edge_midpoints_correct(self, device): + """Test that new vertices are at edge midpoints.""" + # Simple single edge + points = torch.tensor( + [[0.0, 0.0], [2.0, 4.0]], dtype=torch.float32, device=device + ) + cells = torch.tensor([[0, 1]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + subdivided = mesh.subdivide(levels=1, filter="linear") + + # Should have 3 points: original 2 + 1 midpoint + assert subdivided.n_points == 3 + + # Find the new point (not in original) + new_point_mask = torch.ones( + subdivided.n_points, dtype=torch.bool, device=device + ) + for i in range(mesh.n_points): + # Check if original point i is in subdivided mesh + matches = torch.all( + torch.isclose(subdivided.points, mesh.points[i].unsqueeze(0)), dim=1 + ) + if matches.any(): + # Find first matching index + match_idx = torch.where(matches)[0][0] + new_point_mask[match_idx] = False + + new_point = subdivided.points[new_point_mask][0] + expected_midpoint = (points[0] + points[1]) / 2 + + assert torch.allclose(new_point, expected_midpoint, atol=1e-6) + + def test_point_data_interpolation(self, device): + """Test that point_data is interpolated to new vertices.""" + mesh = create_line_mesh(device) + + # Add point data + mesh.point_data["scalar"] = torch.tensor( + [1.0, 2.0, 3.0], dtype=torch.float32, device=device + ) + mesh.point_data["vector"] = torch.tensor( + [[1.0, 0.0], [2.0, 0.0], [3.0, 0.0]], dtype=torch.float32, device=device + ) + + subdivided = mesh.subdivide(levels=1, filter="linear") + + # Check point_data exists and has correct shape + assert "scalar" in subdivided.point_data + assert "vector" in subdivided.point_data + assert subdivided.point_data["scalar"].shape == (5,) + assert subdivided.point_data["vector"].shape == (5, 2) + + # Midpoint of first edge (0,1) should have interpolated values + # Expected: (1.0 + 2.0) / 2 = 1.5 for scalar + # Check that interpolation happened (values between originals exist) + scalar_values = subdivided.point_data["scalar"] + assert scalar_values.min() >= 1.0 + assert scalar_values.max() <= 3.0 + # Should have at least one value between 1 and 2 (midpoint of first edge) + assert ((scalar_values > 1.0) & (scalar_values < 2.0)).any() + + def test_cell_data_propagation(self, device): + """Test that cell_data is propagated from parent to children.""" + mesh = create_triangle_mesh(device) + + # Add cell data + mesh.cell_data["pressure"] = torch.tensor( + [100.0, 200.0], dtype=torch.float32, device=device + ) + + subdivided = mesh.subdivide(levels=1, filter="linear") + + # Each parent cell splits into 4 children + # Original: 2 cells -> 8 cells after subdivision + assert "pressure" in subdivided.cell_data + assert subdivided.cell_data["pressure"].shape == (8,) + + # Each child should inherit parent's value + # First 4 cells from first parent (pressure=100), next 4 from second (pressure=200) + # Check that we have both values propagated + assert (subdivided.cell_data["pressure"] == 100.0).sum() == 4 + assert (subdivided.cell_data["pressure"] == 200.0).sum() == 4 + + def test_empty_mesh(self, device): + """Test subdivision of empty mesh doesn't crash.""" + points = torch.empty((0, 2), dtype=torch.float32, device=device) + cells = torch.empty((0, 2), dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + subdivided = mesh.subdivide(levels=1, filter="linear") + assert subdivided.n_points == 0 + assert subdivided.n_cells == 0 + + def test_single_simplex(self, device): + """Test subdivision of single simplex.""" + # Single edge + points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0]], dtype=torch.float32, device=device + ) + cells = torch.tensor([[0, 1]], dtype=torch.int64, device=device) + mesh = Mesh(points=points, cells=cells) + + subdivided = mesh.subdivide(levels=1, filter="linear") + assert subdivided.n_points == 3 # 2 original + 1 midpoint + assert subdivided.n_cells == 2 # 2 child edges + + @pytest.mark.parametrize("n_levels", [0, 1, 2, 3]) + def test_levels_parameter(self, device, n_levels): + """Test that levels parameter works correctly.""" + mesh = create_triangle_mesh(device) + + if n_levels == 0: + subdivided = mesh.subdivide(levels=0, filter="linear") + # No subdivision should occur + assert subdivided.n_points == mesh.n_points + assert subdivided.n_cells == mesh.n_cells + else: + subdivided = mesh.subdivide(levels=n_levels, filter="linear") + # Each level multiplies cells by 4 for triangles + expected_cells = mesh.n_cells * (4**n_levels) + assert subdivided.n_cells == expected_cells + + +### Test Butterfly Subdivision + + +class TestButterflySubdivision: + """Tests for butterfly (interpolating) subdivision.""" + + def test_triangle_butterfly_preserves_vertices(self, device): + """Test that butterfly subdivision keeps original vertices unchanged.""" + from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + + # Use sphere_icosahedral (80 triangles at subdivisions=1) for realistic test + mesh = sphere_icosahedral.load(subdivisions=1, device=device) + original_points = mesh.points.clone() + + subdivided = mesh.subdivide(levels=1, filter="butterfly") + + # Original vertices should still exist in subdivided mesh + # Sample a subset for efficiency (checking all would be slow) + sample_indices = torch.randperm(mesh.n_points, device=device)[:10] + for i in sample_indices: + # Find this point in subdivided mesh + matches = torch.all( + torch.isclose(subdivided.points, original_points[i].unsqueeze(0)), + dim=1, + ) + assert matches.any(), f"Original vertex {i} not found in subdivided mesh" + + def test_butterfly_topology_same_as_linear(self, device): + """Test that butterfly has same connectivity as linear (interpolating scheme).""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + # Use lumpy_sphere for a more realistic mesh with varying geometry + mesh = lumpy_sphere.load(subdivisions=1, device=device) + + linear = mesh.subdivide(levels=1, filter="linear") + butterfly = mesh.subdivide(levels=1, filter="butterfly") + + # Same number of points and cells + assert butterfly.n_points == linear.n_points + assert butterfly.n_cells == linear.n_cells + assert butterfly.n_manifold_dims == linear.n_manifold_dims + + def test_butterfly_2d_manifold_required(self, device): + """Test that butterfly requires 2D manifold (or raises informative error).""" + # This test checks if butterfly subdivision handles non-2D manifolds + # It might error, or fall back to linear - either is acceptable + mesh = create_line_mesh(device) + + # Butterfly was designed for 2D manifolds (triangles) + # For 1D, it should either work or raise a clear error + try: + subdivided = mesh.subdivide(levels=1, filter="butterfly") + # If it works, check it produces valid output + assert subdivided.n_manifold_dims == 1 + assert subdivided.n_cells > mesh.n_cells + except (ValueError, NotImplementedError) as e: + # Acceptable to not support non-2D manifolds + assert "manifold" in str(e).lower() or "dimension" in str(e).lower() + + +### Test Loop Subdivision + + +class TestLoopSubdivision: + """Tests for Loop (approximating) subdivision.""" + + def test_triangle_loop_modifies_vertices(self, device): + """Test that Loop subdivision repositions original vertices.""" + from physicsnemo.mesh.primitives.surfaces import sphere_icosahedral + + # Use sphere_icosahedral for a realistic closed surface test + mesh = sphere_icosahedral.load(subdivisions=1, device=device) + original_points = mesh.points.clone() + + subdivided = mesh.subdivide(levels=1, filter="loop") + + # Loop is approximating - original vertices get repositioned + assert subdivided.n_points > mesh.n_points + + # Check that original vertices were modified in the subdivided mesh + # The first n_original_points in the subdivided mesh are the repositioned originals + n_original = original_points.shape[0] + repositioned_points = subdivided.points[:n_original] + + # At least one vertex should have moved (Loop smoothing) + max_displacement = torch.max( + torch.norm(repositioned_points - original_points, dim=-1) + ) + assert max_displacement > 1e-6, ( + "Loop subdivision should reposition at least some vertices" + ) + + def test_loop_topology_same_as_linear(self, device): + """Test that Loop has same connectivity pattern as linear.""" + mesh = create_triangle_mesh(device) + + linear = mesh.subdivide(levels=1, filter="linear") + loop = mesh.subdivide(levels=1, filter="loop") + + # Same topology, different geometry + assert loop.n_points == linear.n_points + assert loop.n_cells == linear.n_cells + assert loop.n_manifold_dims == linear.n_manifold_dims + + def test_loop_smoothing_effect(self, device): + """Test that Loop subdivision has smoothing effect on a realistic mesh.""" + from physicsnemo.mesh.primitives.surfaces import icosahedron_surface + + # Use icosahedron (20 triangles) as a more realistic test case + mesh = icosahedron_surface.load(device=device) + + subdivided = mesh.subdivide(levels=1, filter="loop") + + # After Loop subdivision, mesh should still be valid + assert subdivided.n_points > mesh.n_points + assert subdivided.n_cells > mesh.n_cells + + # All cells should still be valid (positive area) + areas = subdivided.cell_areas + assert torch.all(areas > 0) + + # Loop subdivision should produce reasonable smoothing (areas should be consistent) + area_std = areas.std() / areas.mean() + assert area_std < 1.0, ( + "Loop subdivision should produce reasonably uniform cell areas" + ) + + +### Test Edge Cases and Validation + + +class TestSubdivisionValidation: + """Tests for edge cases and input validation.""" + + def test_negative_levels_error(self, device): + """Test that negative levels raises error.""" + mesh = create_triangle_mesh(device) + + with pytest.raises((ValueError, RuntimeError)): + mesh.subdivide(levels=-1, filter="linear") + + def test_invalid_filter_error(self, device): + """Test that invalid filter name raises error.""" + mesh = create_triangle_mesh(device) + + with pytest.raises((ValueError, TypeError)): + mesh.subdivide(levels=1, filter="invalid") # type: ignore + + def test_manifold_dimension_preserved(self, device): + """Test that manifold dimension is preserved across subdivision.""" + meshes = [ + create_line_mesh(device), + create_triangle_mesh(device), + create_tet_mesh(device), + ] + + for mesh in meshes: + original_n_manifold_dims = mesh.n_manifold_dims + subdivided = mesh.subdivide(levels=1, filter="linear") + assert subdivided.n_manifold_dims == original_n_manifold_dims + + def test_spatial_dimension_preserved(self, device): + """Test that spatial dimension is preserved.""" + mesh = create_triangle_mesh_3d(device) + assert mesh.n_spatial_dims == 3 + + subdivided = mesh.subdivide(levels=1, filter="linear") + assert subdivided.n_spatial_dims == 3 + + def test_global_data_preserved(self, device): + """Test that global_data is preserved during subdivision.""" + mesh = create_triangle_mesh(device) + mesh.global_data["timestamp"] = torch.tensor(42.0, device=device) + + subdivided = mesh.subdivide(levels=1, filter="linear") + + assert "timestamp" in subdivided.global_data + assert subdivided.global_data["timestamp"] == 42.0 + + +### Performance and Scaling Tests + + +class TestSubdivisionScaling: + """Tests for subdivision scaling and performance.""" + + def test_exponential_cell_growth(self, device): + """Test that cells grow exponentially with levels.""" + mesh = create_triangle_mesh(device) + + n_cells_0 = mesh.n_cells + n_cells_1 = mesh.subdivide(levels=1, filter="linear").n_cells + n_cells_2 = mesh.subdivide(levels=2, filter="linear").n_cells + n_cells_3 = mesh.subdivide(levels=3, filter="linear").n_cells + + # For 2D triangles: 4x growth per level + assert n_cells_1 == n_cells_0 * 4 + assert n_cells_2 == n_cells_0 * 16 + assert n_cells_3 == n_cells_0 * 64 + + @pytest.mark.slow + def test_large_mesh_subdivision(self, device): + """Test subdivision on larger mesh.""" + # Create a moderately large triangle mesh + n = 10 + + # Vectorized grid point generation + i_coords, j_coords = torch.meshgrid( + torch.arange(n, dtype=torch.float32, device=device), + torch.arange(n, dtype=torch.float32, device=device), + indexing="ij", + ) + points = torch.stack([i_coords, j_coords], dim=-1).reshape(-1, 2) + + # Vectorized cell generation: two triangles per quad + i_idx, j_idx = torch.meshgrid( + torch.arange(n - 1, device=device), + torch.arange(n - 1, device=device), + indexing="ij", + ) + idx = (i_idx * n + j_idx).reshape(-1) # (n-1)^2 quads + # Triangle 1: [idx, idx+1, idx+n], Triangle 2: [idx+1, idx+n+1, idx+n] + tri1 = torch.stack([idx, idx + 1, idx + n], dim=-1) + tri2 = torch.stack([idx + 1, idx + n + 1, idx + n], dim=-1) + cells = torch.cat([tri1, tri2], dim=0).to(torch.int64) + mesh = Mesh(points=points, cells=cells) + + # Should handle reasonably large mesh + subdivided = mesh.subdivide(levels=1, filter="linear") + assert subdivided.n_cells == mesh.n_cells * 4 diff --git a/test/mesh/transformations/test_transformations.py b/test/mesh/transformations/test_transformations.py index d92d5b09b0..e953799e61 100644 --- a/test/mesh/transformations/test_transformations.py +++ b/test/mesh/transformations/test_transformations.py @@ -14,11 +14,16 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Tests for geometric transformations with cache handling and PyVista cross-validation. +"""Comprehensive tests for geometric transformations. Tests verify correctness of translate, rotate, scale, and general linear transformations across spatial dimensions, manifold dimensions, and compute backends, with proper cache -invalidation and preservation. +invalidation and preservation. Includes error handling, higher-order tensors, and +data transformation. + +This module consolidates tests from: +- Core transformation tests with PyVista cross-validation and cache handling +- Comprehensive coverage tests for error paths, edge cases, and data transformation """ import numpy as np @@ -38,15 +43,15 @@ from physicsnemo.mesh.io.io_pyvista import from_pyvista, to_pyvista # noqa: E402 -### Helper Functions ### +############################################################################### +# Helper Functions +############################################################################### def create_mesh_with_caches( n_spatial_dims: int, n_manifold_dims: int, device: torch.device | str = "cpu" ): """Create a mesh and pre-compute all caches.""" - from physicsnemo.mesh.mesh import Mesh - if n_manifold_dims == 1 and n_spatial_dims == 2: points = torch.tensor( [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]], @@ -145,7 +150,9 @@ def assert_on_device(tensor: torch.Tensor, expected_device: str) -> None: ) -### Test Fixtures ### +############################################################################### +# Core Transformation Tests +############################################################################### class TestTranslation: @@ -232,6 +239,23 @@ def test_translate_preserves_caches(self, n_spatial_dims, n_manifold_dims, devic get_cached(translated.cell_data, "normals"), original_normals ), "Normals should be unchanged by translation" + def test_translate_preserves_data(self): + """Test that translate preserves vector fields unchanged.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Vector field + mesh.point_data["velocity"] = torch.tensor([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) + + # Translation only affects points, not data (it's affine, not linear) + translated = translate(mesh, offset=[5.0, 0.0, 0.0]) + + # Data should be copied unchanged + assert torch.allclose( + translated.point_data["velocity"], mesh.point_data["velocity"] + ) + class TestRotation: """Tests for rotate() function.""" @@ -339,6 +363,24 @@ def test_rotate_preserves_areas_codim1( get_cached(rotated.cell_data, "normals"), original_normals ), "Normals should be rotated" + def test_rotate_with_vector_data(self): + """Test rotate with transform_point_data=True rotates vectors.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Vector pointing in x direction + mesh.point_data["vec"] = torch.tensor([[1.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) + + # Rotate 90° about z + rotated = rotate( + mesh, angle=np.pi / 2, axis=[0.0, 0.0, 1.0], transform_point_data=True + ) + + # Vector should now point in y direction + expected = torch.tensor([[0.0, 1.0, 0.0], [0.0, 1.0, 0.0]]) + assert torch.allclose(rotated.point_data["vec"], expected, atol=1e-5) + class TestScale: """Tests for scale() function.""" @@ -425,12 +467,7 @@ def test_scale_uniform_updates_caches( def test_scale_negative_handles_normals( self, n_spatial_dims, n_manifold_dims, device ): - """Verify negative scaling correctly handles normals based on manifold dimension. - - The generalized cross product of (n-1) vectors scales by (-1)^(n-1) when negated: - - n_manifold_dims=1 (odd): normals flip - - n_manifold_dims=2 (even): normals unchanged - """ + """Verify negative scaling correctly handles normals based on manifold dimension.""" mesh = create_mesh_with_caches(n_spatial_dims, n_manifold_dims, device=device) scaled = scale(mesh, -1.0) @@ -442,13 +479,7 @@ def test_scale_negative_handles_normals( def test_scale_non_uniform_handles_caches( self, n_spatial_dims, n_manifold_dims, device ): - """Verify non-uniform scaling correctly computes areas using normals. - - For codimension-1 embedded manifolds, per-element area scaling is computed - using the formula: area' = area × |det(M)| × ||M^{-T} n|| - where n is the unit normal. This works because the normal encodes the - tangent space orientation. - """ + """Verify non-uniform scaling correctly computes areas using normals.""" mesh = create_mesh_with_caches(n_spatial_dims, n_manifold_dims, device=device) factor = torch.ones(n_spatial_dims, device=device) @@ -459,20 +490,57 @@ def test_scale_non_uniform_handles_caches( # Areas correctly computed using normal-based scaling, normals also correct validate_caches(scaled, {"areas": True, "centroids": True, "normals": True}) + def test_scale_with_vector_data(self): + """Test scale with transform_point_data=True scales vectors.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) -class TestNonIsotropicAreaScaling: - """Tests for per-element area scaling under non-isotropic transforms. + mesh.point_data["vec"] = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) - For codimension-1 manifolds, areas scale by: |det(M)| × ||M^{-T} n|| - where n is the unit normal. This depends on the orientation of each element. - """ + # Uniform scale by 2 + scaled = scale(mesh, factor=2.0, transform_point_data=True) - def test_anisotropic_scale_horizontal_surface_3d(self, device): - """Test anisotropic scaling of a horizontal surface in 3D. + # Vectors should be scaled + expected = mesh.point_data["vec"] * 2.0 + assert torch.allclose(scaled.point_data["vec"], expected, atol=1e-5) - For a surface in the xy-plane with normal n=(0,0,1), scaling by (a,b,c) - should scale the area by |abc| × ||M^{-T} n|| = |abc| × |1/c| = |ab|. - """ + def test_scale_changes_areas(self): + """Test that scaling changes areas by factor squared.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + original_area = mesh.cell_areas + + # Scale by 2 + scaled = scale(mesh, factor=2.0) + + # Area should be 4x (2² for 2D) + expected_area = original_area * 4.0 + assert torch.allclose(scaled.cell_areas, expected_area, atol=1e-5) + + def test_nonuniform_scale_changes_areas(self): + """Test that non-uniform scaling changes areas correctly.""" + points = torch.tensor([[0.0, 0.0], [2.0, 0.0], [0.0, 2.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + original_area = mesh.cell_areas + + # Scale by [2, 3] + scaled = scale(mesh, factor=[2.0, 3.0]) + + # Area scales by product = 6 + expected_area = original_area * 6.0 + assert torch.allclose(scaled.cell_areas, expected_area, atol=1e-5) + + +class TestNonIsotropicAreaScaling: + """Tests for per-element area scaling under non-isotropic transforms.""" + + def test_anisotropic_scale_horizontal_surface_3d(self, device): + """Test anisotropic scaling of a horizontal surface in 3D.""" # Triangle in xy-plane (z=0) points = torch.tensor( [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0], [0.0, 2.0, 0.0]], @@ -497,11 +565,7 @@ def test_anisotropic_scale_horizontal_surface_3d(self, device): ) def test_anisotropic_scale_vertical_surface_3d(self, device): - """Test anisotropic scaling of a vertical surface in 3D. - - For a surface in the xz-plane with normal n=(0,1,0), scaling by (a,b,c) - should scale the area by |abc| × ||M^{-T} n|| = |abc| × |1/b| = |ac|. - """ + """Test anisotropic scaling of a vertical surface in 3D.""" # Triangle in xz-plane (y=0) points = torch.tensor( [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0], [0.0, 0.0, 2.0]], @@ -523,11 +587,7 @@ def test_anisotropic_scale_vertical_surface_3d(self, device): ) def test_anisotropic_scale_diagonal_surface_3d(self, device): - """Test anisotropic scaling of a diagonal surface in 3D. - - For a surface at 45° to all axes, the area scaling depends on the normal - direction and should match the recomputed area exactly. - """ + """Test anisotropic scaling of a diagonal surface in 3D.""" # Triangle tilted at 45° - points form a surface with normal ≈ (1,1,1)/√3 points = torch.tensor( [[0.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 1.0, 1.0]], @@ -546,11 +606,7 @@ def test_anisotropic_scale_diagonal_surface_3d(self, device): validate_caches(scaled, {"areas": True, "normals": True}) def test_shear_transform_preserves_area_correctness(self, device): - """Test that shear transforms correctly compute per-element areas. - - Shear transforms have det=1, but the area scaling is orientation-dependent - for embedded manifolds. - """ + """Test that shear transforms correctly compute per-element areas.""" # Triangle in xy-plane points = torch.tensor( [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], @@ -563,24 +619,17 @@ def test_shear_transform_preserves_area_correctness(self, device): _ = mesh.cell_normals # Shear in xy plane: [[1, 0.5, 0], [0, 1, 0], [0, 0, 1]] - # This is det=1, but non-isotropic shear_matrix = torch.tensor( [[1.0, 0.5, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], device=device, ) sheared = transform(mesh, shear_matrix) - # For a horizontal surface with normal (0,0,1), shear in xy doesn't change z - # So M^{-T} n should still have unit length in z-direction, thus area unchanged # Validate against recomputation validate_caches(sheared, {"areas": True, "normals": True}) def test_mixed_orientation_surfaces_3d(self, device): - """Test mesh with multiple surfaces at different orientations. - - Each surface element should have its area scaled according to its own - normal direction. - """ + """Test mesh with multiple surfaces at different orientations.""" # Two triangles: one horizontal (z=0), one vertical (y=0) points = torch.tensor( [ @@ -660,6 +709,768 @@ def test_transform_projection_3d_to_2d(self, device): assert torch.allclose(projected.points, expected) assert projected.n_spatial_dims == 2 + def test_transform_skips_scalar_fields(self): + """Test that scalar fields are not transformed.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Scalar field + mesh.point_data["temperature"] = torch.tensor([100.0, 200.0]) + + # Transform + matrix = torch.tensor([[0.0, -1.0], [1.0, 0.0]]) + transformed = transform(mesh, matrix, transform_point_data=True) + + # Scalar should be unchanged + assert torch.allclose( + transformed.point_data["temperature"], mesh.point_data["temperature"] + ) + + def test_embedding_2d_to_3d(self): + """Test embedding from 2D to 3D.""" + points = torch.tensor([[1.0, 2.0], [3.0, 4.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Embed into 3D (xy-plane at z=0) + embed_matrix = torch.tensor([[1.0, 0.0], [0.0, 1.0], [0.0, 0.0]]) + + embedded = transform(mesh, embed_matrix) + + assert embedded.n_spatial_dims == 3 + assert embedded.points.shape == (2, 3) + expected = torch.tensor([[1.0, 2.0, 0.0], [3.0, 4.0, 0.0]]) + assert torch.allclose(embedded.points, expected) + + +############################################################################### +# Error Handling Tests +############################################################################### + + +class TestRotationErrors: + """Test error handling in rotation.""" + + def test_rotate_3d_without_axis_raises(self): + """Test that 3D rotation without axis raises ValueError.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="implies 2D rotation"): + rotate(mesh, angle=np.pi / 2, axis=None) + + def test_rotate_3d_with_wrong_axis_shape_raises(self): + """Test that axis with wrong shape raises NotImplementedError.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(NotImplementedError, match="only supported for 2D.*or 3D"): + rotate(mesh, angle=np.pi / 2, axis=[1.0, 0.0]) # 2D axis for 3D mesh + + def test_rotate_with_zero_length_axis_raises(self): + """Test that zero-length axis raises ValueError.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="near-zero length"): + rotate(mesh, angle=np.pi / 2, axis=[0.0, 0.0, 0.0]) + + def test_rotate_4d_raises_error(self): + """Test that rotation in >3D raises an error.""" + torch.manual_seed(42) + # 4D mesh + points = torch.randn(5, 4) + cells = torch.tensor([[0, 1, 2, 3]]) + mesh = Mesh(points=points, cells=cells) + + # axis=provided implies 3D, so this raises ValueError for dimension mismatch + with pytest.raises(ValueError, match="implies 3D rotation"): + rotate(mesh, angle=np.pi / 4, axis=[1.0, 0.0, 0.0, 0.0]) + + +class TestTransformErrors: + """Test error handling in transform().""" + + def test_transform_with_1d_matrix_raises(self): + """Test that 1D matrix raises ValueError.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="matrix must be 2D"): + transform(mesh, torch.tensor([1.0, 2.0])) + + def test_transform_with_wrong_input_dims_raises(self): + """Test that matrix with wrong input dimensions raises ValueError.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Matrix expects 3D input, mesh has 2D points + matrix = torch.eye(3) + + with pytest.raises(ValueError, match="must equal mesh.n_spatial_dims"): + transform(mesh, matrix) + + def test_transform_incompatible_field_raises(self): + """Test that incompatible fields raise ValueError.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Incompatible tensor (first dim doesn't match n_spatial_dims) + mesh.point_data["weird_tensor"] = torch.ones(mesh.n_points, 5, 7) # 5 != 2 + + matrix = torch.eye(2) + + # Should raise - incompatible with transformation + with pytest.raises(ValueError, match="Cannot transform.*First.*dimension"): + transform(mesh, matrix, transform_point_data=True) + + +class TestTranslateEdgeCases: + """Test translate edge cases.""" + + def test_translate_with_wrong_offset_dims_raises(self): + """Test that offset with wrong dimensions raises ValueError.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="offset must have shape"): + translate(mesh, offset=[1.0, 2.0, 3.0]) # 3D offset for 2D mesh + + +############################################################################### +# Higher-Order Tensor Transformation Tests +############################################################################### + + +class TestHigherOrderTensorTransformation: + """Test transformation of rank-2 and higher tensors.""" + + def test_transform_rank2_tensor(self): + """Test transformation of rank-2 tensor (stress tensor).""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + # Add rank-2 tensor field (e.g., stress tensor) + stress_tensor = torch.eye(2).unsqueeze(0).expand(mesh.n_points, -1, -1) + mesh.point_data["stress"] = stress_tensor + + # Rotate by 90 degrees + angle = np.pi / 2 + rotated = rotate(mesh, angle=angle, transform_point_data=True) + + # Stress tensor should be transformed: T' = R @ T @ R^T + transformed_stress = rotated.point_data["stress"] + + assert transformed_stress.shape == stress_tensor.shape + # For identity tensor, rotation shouldn't change it much + assert torch.allclose(transformed_stress, stress_tensor, atol=1e-5) + + def test_transform_rank3_tensor(self): + """Test transformation of rank-3 tensor (e.g., piezoelectric tensor).""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Create a rank-3 tensor field + rank3_tensor = torch.zeros(mesh.n_points, 3, 3, 3) + for i in range(3): + rank3_tensor[:, i, i, i] = 1.0 + + mesh.point_data["piezo"] = rank3_tensor + + # Rotate 90 degrees about z-axis + angle = np.pi / 2 + rotated = rotate( + mesh, angle=angle, axis=[0.0, 0.0, 1.0], transform_point_data=True + ) + + transformed = rotated.point_data["piezo"] + + # Verify shape is preserved + assert transformed.shape == rank3_tensor.shape + + expected = torch.zeros(mesh.n_points, 3, 3, 3) + expected[:, 0, 0, 0] = -1.0 # Cube of -1 from R[0,1]=-1 + expected[:, 1, 1, 1] = 1.0 # Cube of 1 from R[1,0]=1 + expected[:, 2, 2, 2] = 1.0 # Cube of 1 from R[2,2]=1 + + assert torch.allclose(transformed, expected, atol=1e-5) + + def test_transform_rank4_tensor(self): + """Test transformation of rank-4 tensor (e.g., elasticity tensor).""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Create a simple rank-4 tensor - identity-like tensor + rank4_tensor = torch.zeros(mesh.n_points, 2, 2, 2, 2) + for i in range(2): + rank4_tensor[:, i, i, i, i] = 1.0 + + mesh.point_data["elasticity"] = rank4_tensor + + # Rotate 90 degrees in 2D + angle = np.pi / 2 + rotated = rotate(mesh, angle=angle, transform_point_data=True) + + transformed = rotated.point_data["elasticity"] + + # Verify shape is preserved + assert transformed.shape == rank4_tensor.shape + + expected = torch.zeros(mesh.n_points, 2, 2, 2, 2) + expected[:, 0, 0, 0, 0] = 1.0 # (-1)^4 = 1 + expected[:, 1, 1, 1, 1] = 1.0 # 1^4 = 1 + + assert torch.allclose(transformed, expected, atol=1e-5) + + +############################################################################### +# Data Transformation Tests +############################################################################### + + +class TestDataTransformation: + """Test transform_point_data/transform_cell_data/transform_global_data for all types.""" + + def test_transform_cell_data_vectors(self): + """Test that cell_data vectors are also transformed.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + # Cell vector field + mesh.cell_data["flux"] = torch.tensor([[1.0, 0.0, 0.0]]) + + # Rotate 90° about z + rotated = rotate( + mesh, angle=np.pi / 2, axis=[0.0, 0.0, 1.0], transform_cell_data=True + ) + + # Flux should rotate + expected = torch.tensor([[0.0, 1.0, 0.0]]) + assert torch.allclose(rotated.cell_data["flux"], expected, atol=1e-5) + + +class TestRotateWithCenter: + """Test rotation about a custom center point.""" + + def test_rotate_about_custom_center(self): + """Test rotation about a point other than origin.""" + points = torch.tensor([[1.0, 0.0, 0.0], [2.0, 0.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Rotate about center=[1.5, 0, 0] by 180° + center = [1.5, 0.0, 0.0] + rotated = rotate(mesh, angle=np.pi, axis=[0.0, 0.0, 1.0], center=center) + + # Points should be reflected about center in xy-plane + expected = torch.tensor([[2.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) + assert torch.allclose(rotated.points, expected, atol=1e-5) + + +class TestScaleWithCenter: + """Test scaling about a custom center point.""" + + def test_scale_uniform_about_center(self): + """Test uniform scaling about a custom center.""" + points = torch.tensor([[0.0, 0.0], [2.0, 0.0], [1.0, 2.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + # Scale by 2 about center=[1, 1] + center = [1.0, 1.0] + scaled = scale(mesh, factor=2.0, center=center) + + # Points should be: (p - center) * 2 + center + expected = (points - torch.tensor(center)) * 2.0 + torch.tensor(center) + assert torch.allclose(scaled.points, expected, atol=1e-5) + + def test_scale_nonuniform(self): + """Test non-uniform scaling (anisotropic).""" + points = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Scale differently in each dimension + factors = [2.0, 0.5, 3.0] + scaled = scale(mesh, factor=factors) + + expected = points * torch.tensor(factors) + assert torch.allclose(scaled.points, expected, atol=1e-5) + + def test_scale_with_center_and_data(self): + """Test scaling with center and transform_point_data=True.""" + points = torch.tensor([[0.0, 0.0], [2.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + mesh.point_data["vec"] = torch.tensor([[1.0, 0.0], [0.0, 1.0]]) + + scaled = scale(mesh, factor=2.0, center=[1.0, 0.0], transform_point_data=True) + + # Vectors should be scaled + expected_vec = mesh.point_data["vec"] * 2.0 + assert torch.allclose(scaled.point_data["vec"], expected_vec, atol=1e-5) + + +############################################################################### +# Cache Invalidation Tests +############################################################################### + + +class TestCacheInvalidation: + """Test that cached properties are properly invalidated/preserved.""" + + def test_translate_preserves_areas(self): + """Test that translation preserves cell areas.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + # Pre-compute area + original_area = mesh.cell_areas + + # Translate + translated = translate(mesh, offset=[10.0, 20.0]) + + # Area should be preserved + assert torch.allclose(translated.cell_areas, original_area) + + def test_rotate_preserves_areas(self): + """Test that rotation preserves cell areas (isometry).""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + original_area = mesh.cell_areas + + # Rotate 45° + rotated = rotate(mesh, angle=np.pi / 4, axis=[0.0, 0.0, 1.0]) + + # Area preserved + assert torch.allclose(rotated.cell_areas, original_area, atol=1e-5) + + def test_rotate_invalidates_normals(self): + """Test that rotation invalidates and recomputes normals.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + # Pre-compute normal + original_normal = mesh.cell_normals + assert torch.allclose(original_normal[0], torch.tensor([0.0, 0.0, 1.0])) + + # Rotate 90° about x-axis + rotated = rotate(mesh, angle=np.pi / 2, axis=[1.0, 0.0, 0.0]) + + # Normal should now point in -y direction + new_normal = rotated.cell_normals + expected_normal = torch.tensor([0.0, -1.0, 0.0]) + assert torch.allclose(new_normal[0], expected_normal, atol=1e-5) + + +############################################################################### +# Rotation Composition Tests +############################################################################### + + +class TestRotationComposition: + """Test composition of rotations.""" + + def test_two_rotations_compose_correctly(self): + """Test that two consecutive rotations compose correctly.""" + points = torch.tensor([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Rotate 90° about z, then 90° about x + mesh1 = rotate(mesh, angle=np.pi / 2, axis=[0, 0, 1]) + mesh2 = rotate(mesh1, angle=np.pi / 2, axis=[1, 0, 0]) + + # First point [1,0,0] -> [0,1,0] -> [0,0,1] + expected0 = torch.tensor([0.0, 0.0, 1.0]) + assert torch.allclose(mesh2.points[0], expected0, atol=1e-5) + + # Second point [0,1,0] -> [-1,0,0] -> [-1,0,0] + expected1 = torch.tensor([-1.0, 0.0, 0.0]) + assert torch.allclose(mesh2.points[1], expected1, atol=1e-5) + + +############################################################################### +# Mesh Method Wrapper Tests +############################################################################### + + +class TestMeshMethodWrappers: + """Test that Mesh.rotate(), Mesh.translate(), etc. work correctly.""" + + def test_mesh_translate_method(self): + """Test Mesh.translate() wrapper.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + translated = mesh.translate([5.0, 3.0]) + + expected = points + torch.tensor([5.0, 3.0]) + assert torch.allclose(translated.points, expected) + + def test_mesh_rotate_method(self): + """Test Mesh.rotate() wrapper.""" + points = torch.tensor([[1.0, 0.0, 0.0]]) + cells = torch.tensor([[0]]) + mesh = Mesh(points=points, cells=cells) + + rotated = mesh.rotate(np.pi / 2, [0, 0, 1]) + + expected = torch.tensor([[0.0, 1.0, 0.0]]) + assert torch.allclose(rotated.points, expected, atol=1e-5) + + def test_mesh_scale_method(self): + """Test Mesh.scale() wrapper.""" + points = torch.tensor([[1.0, 2.0]]) + cells = torch.tensor([[0]]) + mesh = Mesh(points=points, cells=cells) + + scaled = mesh.scale(3.0) + + expected = points * 3.0 + assert torch.allclose(scaled.points, expected) + + def test_mesh_transform_method(self): + """Test Mesh.transform() wrapper.""" + points = torch.tensor([[1.0, 2.0]]) + cells = torch.tensor([[0]]) + mesh = Mesh(points=points, cells=cells) + + matrix = torch.tensor([[2.0, 0.0], [0.0, 3.0]]) + transformed = mesh.transform(matrix) + + expected = torch.tensor([[2.0, 6.0]]) + assert torch.allclose(transformed.points, expected) + + +############################################################################### +# Transformation Accuracy Tests +############################################################################### + + +class TestTransformationAccuracy: + """Test numerical accuracy of transformations.""" + + def test_rotation_orthogonality(self): + """Test that rotation matrices are orthogonal.""" + points = torch.tensor([[1.0, 0.0, 0.0]]) + cells = torch.tensor([[0]]) + mesh = Mesh(points=points, cells=cells) + + # Multiple rotations should preserve lengths + for angle in [np.pi / 6, np.pi / 4, np.pi / 3, np.pi / 2, np.pi]: + rotated = rotate(mesh, angle=angle, axis=[1, 1, 1]) + + # Length should be preserved + original_length = torch.norm(mesh.points[0]) + rotated_length = torch.norm(rotated.points[0]) + assert torch.allclose(rotated_length, original_length, atol=1e-6) + + def test_rotation_determinant_one(self): + """Test that rotation preserves orientation (det=1).""" + # Create a mesh with known volume + points = torch.tensor( + [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] + ) + cells = torch.tensor([[0, 1, 2, 3]]) + mesh = Mesh(points=points, cells=cells) + + original_volume = mesh.cell_areas + + # Rotate by arbitrary angle + rotated = rotate(mesh, angle=0.7, axis=[1, 2, 3]) + + # Volume should be preserved (rotation is isometry) + assert torch.allclose(rotated.cell_areas, original_volume, atol=1e-5) + + +############################################################################### +# Scale Edge Cases +############################################################################### + + +class TestScaleEdgeCases: + """Test scale edge cases.""" + + def test_scale_by_zero_allowed(self): + """Test that scaling by zero is allowed (collapses to point).""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Scaling by zero is mathematically valid (degenerate but allowed) + scaled = scale(mesh, factor=0.0) + + # All points collapse to origin (or center if specified) + assert torch.allclose(scaled.points, torch.zeros_like(scaled.points)) + + def test_scale_by_negative(self): + """Test that negative scaling works (reflection).""" + points = torch.tensor([[1.0, 2.0], [3.0, 4.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Negative scale causes reflection + scaled = scale(mesh, factor=-1.0) + + expected = -points + assert torch.allclose(scaled.points, expected) + + # Volume should be preserved (absolute value) + assert torch.allclose(scaled.cell_areas, mesh.cell_areas) + + def test_scale_with_mixed_signs(self): + """Test scaling with mixed positive/negative factors.""" + points = torch.tensor([[1.0, 2.0, 3.0]]) + cells = torch.tensor([[0]]) + mesh = Mesh(points=points, cells=cells) + + scaled = scale(mesh, factor=[2.0, -1.0, 0.5]) + + expected = torch.tensor([[2.0, -2.0, 1.5]]) + assert torch.allclose(scaled.points, expected) + + +############################################################################### +# Rotate Data Transform Edge Cases +############################################################################### + + +class TestRotateDataTransformEdgeCases: + """Test rotate() with transform_point_data/transform_cell_data covering all code paths.""" + + def test_rotate_handles_geometric_caches_separately(self): + """Test that geometric cached properties are handled by cache handler.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + # Pre-compute normal + original_normal = mesh.cell_normals + assert torch.allclose(original_normal[0], torch.tensor([0.0, 0.0, 1.0])) + + # Rotate - normals should be rotated by cache handler, not transform flags + rotated = rotate(mesh, angle=np.pi / 2, axis=[1, 0, 0]) + + # Normal should still be rotated (handled by internal cache logic) + new_normal = rotated.cell_normals + expected = torch.tensor([0.0, -1.0, 0.0]) + assert torch.allclose(new_normal[0], expected, atol=1e-5) + + def test_rotate_with_wrong_dim_field_raises(self): + """Test that rotate raises for fields with wrong first dimension.""" + points = torch.tensor([[1.0, 0.0, 0.0]]) + cells = torch.tensor([[0]]) + mesh = Mesh(points=points, cells=cells) + + # Field with wrong first dimension + mesh.point_data["weird"] = torch.ones(mesh.n_points, 5) # 5 != 3 + + with pytest.raises(ValueError, match="Cannot transform.*First.*dimension"): + rotate(mesh, angle=np.pi / 2, axis=[0, 0, 1], transform_point_data=True) + + def test_rotate_with_incompatible_tensor_raises(self): + """Test that incompatible tensor raises ValueError.""" + points = torch.tensor([[1.0, 0.0, 0.0]]) + cells = torch.tensor([[0]]) + mesh = Mesh(points=points, cells=cells) + + # Tensor with shape (n_points, 3, 2) - not all dims equal n_spatial_dims + mesh.point_data["bad"] = torch.ones(mesh.n_points, 3, 2) + + with pytest.raises(ValueError, match="Cannot transform.*field"): + rotate(mesh, angle=np.pi / 2, axis=[0, 0, 1], transform_point_data=True) + + def test_rotate_cell_data_skips_cached(self): + """Test that rotate skips cached cell_data fields (under "_cache").""" + from physicsnemo.mesh.utilities._cache import set_cached + + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + # Cached field + set_cached(mesh.cell_data, "test_vector", torch.ones(mesh.n_cells, 3)) + + rotated = rotate( + mesh, angle=np.pi / 2, axis=[0, 0, 1], transform_cell_data=True + ) + + # Cache should not be transformed + assert ( + "_cache" not in rotated.cell_data + or get_cached(rotated.cell_data, "test_vector") is None + ) + + def test_rotate_cell_data_wrong_shape_raises(self): + """Test rotate raises for cell_data with wrong shape.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + # Wrong shape + mesh.cell_data["weird"] = torch.ones(mesh.n_cells, 5) + + with pytest.raises(ValueError, match="Cannot transform.*First.*dimension"): + rotate(mesh, angle=np.pi / 2, axis=[0, 0, 1], transform_cell_data=True) + + def test_rotate_cell_data_incompatible_tensor_raises(self): + """Test rotate with incompatible cell tensor raises.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) + cells = torch.tensor([[0, 1, 2]]) + mesh = Mesh(points=points, cells=cells) + + mesh.cell_data["bad"] = torch.ones(mesh.n_cells, 3, 2) + + with pytest.raises(ValueError, match="Cannot transform.*field"): + rotate(mesh, angle=np.pi / 2, axis=[0, 0, 1], transform_cell_data=True) + + +############################################################################### +# Scale Data Transform Edge Cases +############################################################################### + + +class TestScaleDataTransformEdgeCases: + """Test scale() with transform_point_data covering all paths.""" + + def test_scale_data_skips_cached(self): + """Test scale skips cached fields (under "_cache").""" + from physicsnemo.mesh.utilities._cache import set_cached + + points = torch.tensor([[1.0, 0.0]]) + cells = torch.tensor([[0]]) + mesh = Mesh(points=points, cells=cells) + + set_cached(mesh.point_data, "test_vector", torch.tensor([[1.0, 2.0]])) + + scaled = scale(mesh, factor=2.0, transform_point_data=True) + + # Cache should not be transformed + assert ( + "_cache" not in scaled.point_data + or get_cached(scaled.point_data, "test_vector") is None + ) + + def test_scale_data_wrong_shape_raises(self): + """Test scale raises for fields with wrong shape.""" + points = torch.tensor([[1.0, 0.0]]) + cells = torch.tensor([[0]]) + mesh = Mesh(points=points, cells=cells) + + mesh.point_data["weird"] = torch.ones(mesh.n_points, 5) + + with pytest.raises(ValueError, match="Cannot transform.*First.*dimension"): + scale(mesh, factor=2.0, transform_point_data=True) + + def test_scale_with_incompatible_tensor_raises(self): + """Test scale with incompatible tensor raises ValueError.""" + points = torch.tensor([[1.0, 0.0]]) + cells = torch.tensor([[0]]) + mesh = Mesh(points=points, cells=cells) + + mesh.point_data["bad"] = torch.ones(mesh.n_points, 2, 3) + + with pytest.raises(ValueError, match="Cannot transform.*field"): + scale(mesh, factor=2.0, transform_point_data=True) + + +############################################################################### +# Global Data Transformation Tests +############################################################################### + + +class TestGlobalDataTransformation: + """Test global_data transformation.""" + + def test_transform_global_data_vector(self): + """Test that global_data vectors are transformed.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Global vector field (no batch dimension) + mesh.global_data["reference_direction"] = torch.tensor([1.0, 0.0, 0.0]) + + # Rotate 90° about z + rotated = rotate( + mesh, angle=np.pi / 2, axis=[0.0, 0.0, 1.0], transform_global_data=True + ) + + # Vector should now point in y direction + expected = torch.tensor([0.0, 1.0, 0.0]) + assert torch.allclose( + rotated.global_data["reference_direction"], expected, atol=1e-5 + ) + + def test_transform_global_data_scalar_unchanged(self): + """Test that global_data scalars are unchanged.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Global scalar + mesh.global_data["temperature"] = torch.tensor(300.0) + + # Transform + matrix = torch.tensor([[0.0, -1.0], [1.0, 0.0]]) + transformed = transform(mesh, matrix, transform_global_data=True) + + # Scalar should be unchanged + assert torch.allclose( + transformed.global_data["temperature"], mesh.global_data["temperature"] + ) + + def test_transform_global_data_incompatible_raises(self): + """Test that incompatible global_data raises ValueError.""" + points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + # Incompatible vector (5 != 3) + mesh.global_data["bad_vector"] = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0]) + + with pytest.raises(ValueError, match="Cannot transform.*First.*dimension"): + rotate( + mesh, angle=np.pi / 2, axis=[0.0, 0.0, 1.0], transform_global_data=True + ) + + def test_scale_global_data(self): + """Test scale transforms global_data vectors.""" + points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) + cells = torch.tensor([[0, 1]]) + mesh = Mesh(points=points, cells=cells) + + mesh.global_data["force"] = torch.tensor([1.0, 2.0]) + + scaled = scale(mesh, factor=3.0, transform_global_data=True) + + expected = torch.tensor([3.0, 6.0]) + assert torch.allclose(scaled.global_data["force"], expected, atol=1e-5) + + +############################################################################### +# General Edge Cases +############################################################################### + class TestEdgeCases: """Test edge cases and boundary conditions.""" @@ -733,3 +1544,7 @@ def test_multiple_transformations_composition(self, device): get_cached(mesh.cell_data, "areas") * 4.0, atol=1e-6, ) + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/test/mesh/transformations/test_transformations_comprehensive.py b/test/mesh/transformations/test_transformations_comprehensive.py deleted file mode 100644 index 27e6f6e380..0000000000 --- a/test/mesh/transformations/test_transformations_comprehensive.py +++ /dev/null @@ -1,894 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. -# SPDX-FileCopyrightText: All rights reserved. -# SPDX-License-Identifier: Apache-2.0 -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -"""Comprehensive tests for transformations module to achieve 100% coverage. - -Tests all error paths, edge cases, higher-order tensors, and data transformation. -""" - -import numpy as np -import pytest -import torch - -from physicsnemo.mesh.mesh import Mesh -from physicsnemo.mesh.transformations.geometric import ( - rotate, - scale, - transform, - translate, -) - - -class TestRotationErrors: - """Test error handling in rotation.""" - - def test_rotate_3d_without_axis_raises(self): - """Test that 3D rotation without axis raises ValueError.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - with pytest.raises(ValueError, match="implies 2D rotation"): - rotate(mesh, angle=np.pi / 2, axis=None) - - def test_rotate_3d_with_wrong_axis_shape_raises(self): - """Test that axis with wrong shape raises NotImplementedError.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - with pytest.raises(NotImplementedError, match="only supported for 2D.*or 3D"): - rotate(mesh, angle=np.pi / 2, axis=[1.0, 0.0]) # 2D axis for 3D mesh - - def test_rotate_with_zero_length_axis_raises(self): - """Test that zero-length axis raises ValueError.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - with pytest.raises(ValueError, match="near-zero length"): - rotate(mesh, angle=np.pi / 2, axis=[0.0, 0.0, 0.0]) - - def test_rotate_4d_raises_error(self): - """Test that rotation in >3D raises an error.""" - torch.manual_seed(42) - # 4D mesh - points = torch.randn(5, 4) - cells = torch.tensor([[0, 1, 2, 3]]) - mesh = Mesh(points=points, cells=cells) - - # axis=provided implies 3D, so this raises ValueError for dimension mismatch - with pytest.raises(ValueError, match="implies 3D rotation"): - rotate(mesh, angle=np.pi / 4, axis=[1.0, 0.0, 0.0, 0.0]) - - -class TestTransformErrors: - """Test error handling in transform().""" - - def test_transform_with_1d_matrix_raises(self): - """Test that 1D matrix raises ValueError.""" - points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - with pytest.raises(ValueError, match="matrix must be 2D"): - transform(mesh, torch.tensor([1.0, 2.0])) - - def test_transform_with_wrong_input_dims_raises(self): - """Test that matrix with wrong input dimensions raises ValueError.""" - points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Matrix expects 3D input, mesh has 2D points - matrix = torch.eye(3) - - with pytest.raises(ValueError, match="must equal mesh.n_spatial_dims"): - transform(mesh, matrix) - - -class TestHigherOrderTensorTransformation: - """Test transformation of rank-2 and higher tensors.""" - - def test_transform_rank2_tensor(self): - """Test transformation of rank-2 tensor (stress tensor).""" - points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]]) - cells = torch.tensor([[0, 1, 2]]) - mesh = Mesh(points=points, cells=cells) - - # Add rank-2 tensor field (e.g., stress tensor) - stress_tensor = torch.eye(2).unsqueeze(0).expand(mesh.n_points, -1, -1) - mesh.point_data["stress"] = stress_tensor - - # Rotate by 90 degrees - angle = np.pi / 2 - rotated = rotate(mesh, angle=angle, transform_point_data=True) - - # Stress tensor should be transformed: T' = R @ T @ R^T - transformed_stress = rotated.point_data["stress"] - - assert transformed_stress.shape == stress_tensor.shape - # For identity tensor, rotation shouldn't change it much - # (rotated identity is still identity) - assert torch.allclose(transformed_stress, stress_tensor, atol=1e-5) - - def test_transform_rank3_tensor(self): - """Test transformation of rank-3 tensor (e.g., piezoelectric tensor). - - For a rank-3 tensor T with shape (batch, n, n, n), the transformation is: - T'_ijk = R_il * R_jm * R_kn * T_lmn - - We test with a simple diagonal-like tensor and verify the transformation - is applied correctly to all three indices. - """ - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Create a rank-3 tensor field - # Use a tensor where T[i,j,k] = 1 if i==j==k, else 0 - # This makes it easy to verify transformation - rank3_tensor = torch.zeros(mesh.n_points, 3, 3, 3) - for i in range(3): - rank3_tensor[:, i, i, i] = 1.0 - - mesh.point_data["piezo"] = rank3_tensor - - # Rotate 90 degrees about z-axis - # R = [[0, -1, 0], - # [1, 0, 0], - # [0, 0, 1]] - # This swaps x->y, y->-x, z->z - angle = np.pi / 2 - rotated = rotate( - mesh, angle=angle, axis=[0.0, 0.0, 1.0], transform_point_data=True - ) - - transformed = rotated.point_data["piezo"] - - # Verify shape is preserved - assert transformed.shape == rank3_tensor.shape - - # Manually compute expected result for verification - # The original tensor has T[0,0,0]=1, T[1,1,1]=1, T[2,2,2]=1 - # After rotation by 90° about z: - # T'[i,j,k] = sum over l,m,n of: R[i,l] * R[j,m] * R[k,n] * T[l,m,n] - # - # Since original tensor is zero except on diagonal (0,0,0), (1,1,1), (2,2,2): - # T'[i,j,k] = R[i,0]*R[j,0]*R[k,0]*T[0,0,0] + R[i,1]*R[j,1]*R[k,1]*T[1,1,1] + R[i,2]*R[j,2]*R[k,2]*T[2,2,2] - # = R[i,0]*R[j,0]*R[k,0] + R[i,1]*R[j,1]*R[k,1] + R[i,2]*R[j,2]*R[k,2] - # - # For 90° rotation about z: R = [[0,-1,0], [1,0,0], [0,0,1]] - # T'[0,0,0] = 0*0*0 + 1*1*1 + 0*0*0 = 1 (y-component maps to old y-component) - # T'[1,1,1] = (-1)*(-1)*(-1) + 0*0*0 + 0*0*0 = -1 (x-component maps to old -x) - # Wait, that's not right. Let me reconsider. - # - # Actually, for rotation matrix R about z by 90°: - # R[0,:] = [0, -1, 0] (new x = -old y) - # R[1,:] = [1, 0, 0] (new y = old x) - # R[2,:] = [0, 0, 1] (new z = old z) - # - # T'[0,0,0] = R[0,0]*R[0,0]*R[0,0]*1 + R[0,1]*R[0,1]*R[0,1]*1 + R[0,2]*R[0,2]*R[0,2]*1 - # = 0 + (-1)^3 + 0 = -1 - # T'[1,1,1] = R[1,0]*R[1,0]*R[1,0] + R[1,1]*R[1,1]*R[1,1] + R[1,2]*R[1,2]*R[1,2] - # = 1^3 + 0 + 0 = 1 - # T'[2,2,2] = R[2,0]^3 + R[2,1]^3 + R[2,2]^3 = 0 + 0 + 1 = 1 - - expected = torch.zeros(mesh.n_points, 3, 3, 3) - expected[:, 0, 0, 0] = -1.0 # Cube of -1 from R[0,1]=-1 - expected[:, 1, 1, 1] = 1.0 # Cube of 1 from R[1,0]=1 - expected[:, 2, 2, 2] = 1.0 # Cube of 1 from R[2,2]=1 - - assert torch.allclose(transformed, expected, atol=1e-5), ( - f"Rank-3 tensor transformation failed.\nExpected:\n{expected[0]}\nGot:\n{transformed[0]}" - ) - - def test_transform_rank4_tensor(self): - """Test transformation of rank-4 tensor (e.g., elasticity tensor). - - The elasticity tensor (Hooke's law) has 4 indices and transforms as: - C'_ijkl = R_im * R_jn * R_ko * R_lp * C_mnop - """ - points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Create a simple rank-4 tensor - identity-like tensor - # C[i,j,k,l] = 1 if i==j==k==l, else 0 - rank4_tensor = torch.zeros(mesh.n_points, 2, 2, 2, 2) - for i in range(2): - rank4_tensor[:, i, i, i, i] = 1.0 - - mesh.point_data["elasticity"] = rank4_tensor - - # Rotate 90 degrees in 2D - # R = [[0, -1], [1, 0]] - angle = np.pi / 2 - rotated = rotate(mesh, angle=angle, transform_point_data=True) - - transformed = rotated.point_data["elasticity"] - - # Verify shape is preserved - assert transformed.shape == rank4_tensor.shape - - # For a 90° rotation in 2D: R = [[0, -1], [1, 0]] - # C'[0,0,0,0] = R[0,0]^4 * C[0,0,0,0] + R[0,1]^4 * C[1,1,1,1] - # = 0^4 * 1 + (-1)^4 * 1 = 1 - # C'[1,1,1,1] = R[1,0]^4 * C[0,0,0,0] + R[1,1]^4 * C[1,1,1,1] - # = 1^4 * 1 + 0^4 * 1 = 1 - - expected = torch.zeros(mesh.n_points, 2, 2, 2, 2) - expected[:, 0, 0, 0, 0] = 1.0 # (-1)^4 = 1 - expected[:, 1, 1, 1, 1] = 1.0 # 1^4 = 1 - - assert torch.allclose(transformed, expected, atol=1e-5), ( - f"Rank-4 tensor transformation failed.\nExpected diagonal elements [1, 1], got [{transformed[0, 0, 0, 0, 0]}, {transformed[0, 1, 1, 1, 1]}]" - ) - - -class TestDataTransformation: - """Test transform_point_data/transform_cell_data/transform_global_data for all types.""" - - def test_translate_preserves_data(self): - """Test that translate preserves vector fields unchanged.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Vector field - mesh.point_data["velocity"] = torch.tensor([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) - - # Translation only affects points, not data (it's affine, not linear) - translated = translate(mesh, offset=[5.0, 0.0, 0.0]) - - # Data should be copied unchanged - assert torch.allclose( - translated.point_data["velocity"], mesh.point_data["velocity"] - ) - - def test_rotate_with_vector_data(self): - """Test rotate with transform_point_data=True rotates vectors.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Vector pointing in x direction - mesh.point_data["vec"] = torch.tensor([[1.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) - - # Rotate 90° about z - rotated = rotate( - mesh, angle=np.pi / 2, axis=[0.0, 0.0, 1.0], transform_point_data=True - ) - - # Vector should now point in y direction - expected = torch.tensor([[0.0, 1.0, 0.0], [0.0, 1.0, 0.0]]) - assert torch.allclose(rotated.point_data["vec"], expected, atol=1e-5) - - def test_scale_with_vector_data(self): - """Test scale with transform_point_data=True scales vectors.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - mesh.point_data["vec"] = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) - - # Uniform scale by 2 - scaled = scale(mesh, factor=2.0, transform_point_data=True) - - # Vectors should be scaled - expected = mesh.point_data["vec"] * 2.0 - assert torch.allclose(scaled.point_data["vec"], expected, atol=1e-5) - - def test_transform_skips_scalar_fields(self): - """Test that scalar fields are not transformed.""" - points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Scalar field - mesh.point_data["temperature"] = torch.tensor([100.0, 200.0]) - - # Transform - matrix = torch.tensor([[0.0, -1.0], [1.0, 0.0]]) - transformed = transform(mesh, matrix, transform_point_data=True) - - # Scalar should be unchanged - assert torch.allclose( - transformed.point_data["temperature"], mesh.point_data["temperature"] - ) - - def test_transform_incompatible_field_raises(self): - """Test that incompatible fields raise ValueError.""" - points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Incompatible tensor (first dim doesn't match n_spatial_dims) - mesh.point_data["weird_tensor"] = torch.ones(mesh.n_points, 5, 7) # 5 != 2 - - matrix = torch.eye(2) - - # Should raise - incompatible with transformation - with pytest.raises(ValueError, match="Cannot transform.*First.*dimension"): - transform(mesh, matrix, transform_point_data=True) - - def test_transform_cell_data_vectors(self): - """Test that cell_data vectors are also transformed.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) - cells = torch.tensor([[0, 1, 2]]) - mesh = Mesh(points=points, cells=cells) - - # Cell vector field - mesh.cell_data["flux"] = torch.tensor([[1.0, 0.0, 0.0]]) - - # Rotate 90° about z - rotated = rotate( - mesh, angle=np.pi / 2, axis=[0.0, 0.0, 1.0], transform_cell_data=True - ) - - # Flux should rotate - expected = torch.tensor([[0.0, 1.0, 0.0]]) - assert torch.allclose(rotated.cell_data["flux"], expected, atol=1e-5) - - -class TestRotateWithCenter: - """Test rotation about a custom center point.""" - - def test_rotate_about_custom_center(self): - """Test rotation about a point other than origin.""" - points = torch.tensor([[1.0, 0.0, 0.0], [2.0, 0.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Rotate about center=[1.5, 0, 0] by 180° - center = [1.5, 0.0, 0.0] - rotated = rotate(mesh, angle=np.pi, axis=[0.0, 0.0, 1.0], center=center) - - # Points should be reflected about center in xy-plane - # [1, 0, 0] -> [2, 0, 0] and [2, 0, 0] -> [1, 0, 0] - expected = torch.tensor([[2.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) - assert torch.allclose(rotated.points, expected, atol=1e-5) - - -class TestScaleWithCenter: - """Test scaling about a custom center point.""" - - def test_scale_uniform_about_center(self): - """Test uniform scaling about a custom center.""" - points = torch.tensor([[0.0, 0.0], [2.0, 0.0], [1.0, 2.0]]) - cells = torch.tensor([[0, 1, 2]]) - mesh = Mesh(points=points, cells=cells) - - # Scale by 2 about center=[1, 1] - center = [1.0, 1.0] - scaled = scale(mesh, factor=2.0, center=center) - - # Points should be: (p - center) * 2 + center - expected = (points - torch.tensor(center)) * 2.0 + torch.tensor(center) - assert torch.allclose(scaled.points, expected, atol=1e-5) - - def test_scale_nonuniform(self): - """Test non-uniform scaling (anisotropic).""" - points = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Scale differently in each dimension - factors = [2.0, 0.5, 3.0] - scaled = scale(mesh, factor=factors) - - expected = points * torch.tensor(factors) - assert torch.allclose(scaled.points, expected, atol=1e-5) - - def test_scale_with_center_and_data(self): - """Test scaling with center and transform_point_data=True.""" - points = torch.tensor([[0.0, 0.0], [2.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - mesh.point_data["vec"] = torch.tensor([[1.0, 0.0], [0.0, 1.0]]) - - scaled = scale(mesh, factor=2.0, center=[1.0, 0.0], transform_point_data=True) - - # Vectors should be scaled - expected_vec = mesh.point_data["vec"] * 2.0 - assert torch.allclose(scaled.point_data["vec"], expected_vec, atol=1e-5) - - -class TestTransformDimensionChange: - """Test transformations that change spatial dimension.""" - - def test_projection_3d_to_2d(self): - """Test projection from 3D to 2D.""" - points = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Project onto xy-plane - proj_matrix = torch.tensor([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) - - projected = transform(mesh, proj_matrix) - - assert projected.n_spatial_dims == 2 - assert projected.points.shape == (2, 2) - assert torch.allclose(projected.points, points[:, :2]) - - def test_embedding_2d_to_3d(self): - """Test embedding from 2D to 3D.""" - points = torch.tensor([[1.0, 2.0], [3.0, 4.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Embed into 3D (xy-plane at z=0) - embed_matrix = torch.tensor([[1.0, 0.0], [0.0, 1.0], [0.0, 0.0]]) - - embedded = transform(mesh, embed_matrix) - - assert embedded.n_spatial_dims == 3 - assert embedded.points.shape == (2, 3) - expected = torch.tensor([[1.0, 2.0, 0.0], [3.0, 4.0, 0.0]]) - assert torch.allclose(embedded.points, expected) - - -class TestCacheInvalidation: - """Test that cached properties are properly invalidated/preserved.""" - - def test_translate_preserves_areas(self): - """Test that translation preserves cell areas.""" - points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]]) - cells = torch.tensor([[0, 1, 2]]) - mesh = Mesh(points=points, cells=cells) - - # Pre-compute area - original_area = mesh.cell_areas - - # Translate - translated = translate(mesh, offset=[10.0, 20.0]) - - # Area should be preserved - assert torch.allclose(translated.cell_areas, original_area) - - def test_rotate_preserves_areas(self): - """Test that rotation preserves cell areas (isometry).""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) - cells = torch.tensor([[0, 1, 2]]) - mesh = Mesh(points=points, cells=cells) - - original_area = mesh.cell_areas - - # Rotate 45° - rotated = rotate(mesh, angle=np.pi / 4, axis=[0.0, 0.0, 1.0]) - - # Area preserved - assert torch.allclose(rotated.cell_areas, original_area, atol=1e-5) - - def test_scale_changes_areas(self): - """Test that scaling changes areas by factor squared.""" - points = torch.tensor([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]]) - cells = torch.tensor([[0, 1, 2]]) - mesh = Mesh(points=points, cells=cells) - - original_area = mesh.cell_areas - - # Scale by 2 - scaled = scale(mesh, factor=2.0) - - # Area should be 4x (2² for 2D) - expected_area = original_area * 4.0 - assert torch.allclose(scaled.cell_areas, expected_area, atol=1e-5) - - def test_nonuniform_scale_changes_areas(self): - """Test that non-uniform scaling changes areas correctly.""" - points = torch.tensor([[0.0, 0.0], [2.0, 0.0], [0.0, 2.0]]) - cells = torch.tensor([[0, 1, 2]]) - mesh = Mesh(points=points, cells=cells) - - original_area = mesh.cell_areas - - # Scale by [2, 3] - scaled = scale(mesh, factor=[2.0, 3.0]) - - # Area scales by product = 6 - expected_area = original_area * 6.0 - assert torch.allclose(scaled.cell_areas, expected_area, atol=1e-5) - - def test_rotate_invalidates_normals(self): - """Test that rotation invalidates and recomputes normals.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) - cells = torch.tensor([[0, 1, 2]]) - mesh = Mesh(points=points, cells=cells) - - # Pre-compute normal - original_normal = mesh.cell_normals - assert torch.allclose(original_normal[0], torch.tensor([0.0, 0.0, 1.0])) - - # Rotate 90° about x-axis - rotated = rotate(mesh, angle=np.pi / 2, axis=[1.0, 0.0, 0.0]) - - # Normal should now point in -y direction - new_normal = rotated.cell_normals - expected_normal = torch.tensor([0.0, -1.0, 0.0]) - assert torch.allclose(new_normal[0], expected_normal, atol=1e-5) - - -class TestRotationComposition: - """Test composition of rotations.""" - - def test_two_rotations_compose_correctly(self): - """Test that two consecutive rotations compose correctly.""" - points = torch.tensor([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Rotate 90° about z, then 90° about x - mesh1 = rotate(mesh, angle=np.pi / 2, axis=[0, 0, 1]) - mesh2 = rotate(mesh1, angle=np.pi / 2, axis=[1, 0, 0]) - - # First point [1,0,0] -> [0,1,0] -> [0,0,1] - expected0 = torch.tensor([0.0, 0.0, 1.0]) - assert torch.allclose(mesh2.points[0], expected0, atol=1e-5) - - # Second point [0,1,0] -> [-1,0,0] -> [-1,0,0] - expected1 = torch.tensor([-1.0, 0.0, 0.0]) - assert torch.allclose(mesh2.points[1], expected1, atol=1e-5) - - -class TestMeshMethodWrappers: - """Test that Mesh.rotate(), Mesh.translate(), etc. work correctly.""" - - def test_mesh_translate_method(self): - """Test Mesh.translate() wrapper.""" - points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - translated = mesh.translate([5.0, 3.0]) - - expected = points + torch.tensor([5.0, 3.0]) - assert torch.allclose(translated.points, expected) - - def test_mesh_rotate_method(self): - """Test Mesh.rotate() wrapper.""" - points = torch.tensor([[1.0, 0.0, 0.0]]) - cells = torch.tensor([[0]]) - mesh = Mesh(points=points, cells=cells) - - rotated = mesh.rotate(np.pi / 2, [0, 0, 1]) - - expected = torch.tensor([[0.0, 1.0, 0.0]]) - assert torch.allclose(rotated.points, expected, atol=1e-5) - - def test_mesh_scale_method(self): - """Test Mesh.scale() wrapper.""" - points = torch.tensor([[1.0, 2.0]]) - cells = torch.tensor([[0]]) - mesh = Mesh(points=points, cells=cells) - - scaled = mesh.scale(3.0) - - expected = points * 3.0 - assert torch.allclose(scaled.points, expected) - - def test_mesh_transform_method(self): - """Test Mesh.transform() wrapper.""" - points = torch.tensor([[1.0, 2.0]]) - cells = torch.tensor([[0]]) - mesh = Mesh(points=points, cells=cells) - - matrix = torch.tensor([[2.0, 0.0], [0.0, 3.0]]) - transformed = mesh.transform(matrix) - - expected = torch.tensor([[2.0, 6.0]]) - assert torch.allclose(transformed.points, expected) - - -class TestTransformationAccuracy: - """Test numerical accuracy of transformations.""" - - def test_rotation_orthogonality(self): - """Test that rotation matrices are orthogonal.""" - points = torch.tensor([[1.0, 0.0, 0.0]]) - cells = torch.tensor([[0]]) - mesh = Mesh(points=points, cells=cells) - - # Multiple rotations should preserve lengths - for angle in [np.pi / 6, np.pi / 4, np.pi / 3, np.pi / 2, np.pi]: - rotated = rotate(mesh, angle=angle, axis=[1, 1, 1]) - - # Length should be preserved - original_length = torch.norm(mesh.points[0]) - rotated_length = torch.norm(rotated.points[0]) - assert torch.allclose(rotated_length, original_length, atol=1e-6) - - def test_rotation_determinant_one(self): - """Test that rotation preserves orientation (det=1).""" - # Create a mesh with known volume - points = torch.tensor( - [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] - ) - cells = torch.tensor([[0, 1, 2, 3]]) - mesh = Mesh(points=points, cells=cells) - - original_volume = mesh.cell_areas - - # Rotate by arbitrary angle - rotated = rotate(mesh, angle=0.7, axis=[1, 2, 3]) - - # Volume should be preserved (rotation is isometry) - assert torch.allclose(rotated.cell_areas, original_volume, atol=1e-5) - - -class TestScaleEdgeCases: - """Test scale edge cases.""" - - def test_scale_by_zero_allowed(self): - """Test that scaling by zero is allowed (collapses to point).""" - points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Scaling by zero is mathematically valid (degenerate but allowed) - scaled = scale(mesh, factor=0.0) - - # All points collapse to origin (or center if specified) - assert torch.allclose(scaled.points, torch.zeros_like(scaled.points)) - - def test_scale_by_negative(self): - """Test that negative scaling works (reflection).""" - points = torch.tensor([[1.0, 2.0], [3.0, 4.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Negative scale causes reflection - scaled = scale(mesh, factor=-1.0) - - expected = -points - assert torch.allclose(scaled.points, expected) - - # Volume should be preserved (absolute value) - assert torch.allclose(scaled.cell_areas, mesh.cell_areas) - - def test_scale_with_mixed_signs(self): - """Test scaling with mixed positive/negative factors.""" - points = torch.tensor([[1.0, 2.0, 3.0]]) - cells = torch.tensor([[0]]) - mesh = Mesh(points=points, cells=cells) - - scaled = scale(mesh, factor=[2.0, -1.0, 0.5]) - - expected = torch.tensor([[2.0, -2.0, 1.5]]) - assert torch.allclose(scaled.points, expected) - - -class TestRotateDataTransformEdgeCases: - """Test rotate() with transform_point_data/transform_cell_data covering all code paths.""" - - def test_rotate_handles_geometric_caches_separately(self): - """Test that geometric cached properties are handled by cache handler, not transform flags.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) - cells = torch.tensor([[0, 1, 2]]) - mesh = Mesh(points=points, cells=cells) - - # Pre-compute normal - original_normal = mesh.cell_normals - assert torch.allclose(original_normal[0], torch.tensor([0.0, 0.0, 1.0])) - - # Rotate - normals should be rotated by cache handler, not transform flags - rotated = rotate(mesh, angle=np.pi / 2, axis=[1, 0, 0]) - - # Normal should still be rotated (handled by internal cache logic) - new_normal = rotated.cell_normals - expected = torch.tensor([0.0, -1.0, 0.0]) - assert torch.allclose(new_normal[0], expected, atol=1e-5) - - def test_rotate_with_wrong_dim_field_raises(self): - """Test that rotate raises for fields with wrong first dimension.""" - points = torch.tensor([[1.0, 0.0, 0.0]]) - cells = torch.tensor([[0]]) - mesh = Mesh(points=points, cells=cells) - - # Field with wrong first dimension - mesh.point_data["weird"] = torch.ones(mesh.n_points, 5) # 5 != 3 - - with pytest.raises(ValueError, match="Cannot transform.*First.*dimension"): - rotate(mesh, angle=np.pi / 2, axis=[0, 0, 1], transform_point_data=True) - - def test_rotate_with_incompatible_tensor_raises(self): - """Test that incompatible tensor raises ValueError.""" - points = torch.tensor([[1.0, 0.0, 0.0]]) - cells = torch.tensor([[0]]) - mesh = Mesh(points=points, cells=cells) - - # Tensor with shape (n_points, 3, 2) - not all dims equal n_spatial_dims - mesh.point_data["bad"] = torch.ones(mesh.n_points, 3, 2) - - with pytest.raises(ValueError, match="Cannot transform.*field"): - rotate(mesh, angle=np.pi / 2, axis=[0, 0, 1], transform_point_data=True) - - def test_rotate_cell_data_skips_cached(self): - """Test that rotate skips cached cell_data fields (under "_cache").""" - from physicsnemo.mesh.utilities._cache import get_cached, set_cached - - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) - cells = torch.tensor([[0, 1, 2]]) - mesh = Mesh(points=points, cells=cells) - - # Cached field - set_cached(mesh.cell_data, "test_vector", torch.ones(mesh.n_cells, 3)) - - rotated = rotate( - mesh, angle=np.pi / 2, axis=[0, 0, 1], transform_cell_data=True - ) - - # Cache should not be transformed (not included in user data transformation) - # The cache is preserved but not included in the transformation - assert ( - "_cache" not in rotated.cell_data - or get_cached(rotated.cell_data, "test_vector") is None - ) - - def test_rotate_cell_data_wrong_shape_raises(self): - """Test rotate raises for cell_data with wrong shape.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) - cells = torch.tensor([[0, 1, 2]]) - mesh = Mesh(points=points, cells=cells) - - # Wrong shape - mesh.cell_data["weird"] = torch.ones(mesh.n_cells, 5) - - with pytest.raises(ValueError, match="Cannot transform.*First.*dimension"): - rotate(mesh, angle=np.pi / 2, axis=[0, 0, 1], transform_cell_data=True) - - def test_rotate_cell_data_incompatible_tensor_raises(self): - """Test rotate with incompatible cell tensor raises.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.5, 1.0, 0.0]]) - cells = torch.tensor([[0, 1, 2]]) - mesh = Mesh(points=points, cells=cells) - - mesh.cell_data["bad"] = torch.ones(mesh.n_cells, 3, 2) - - with pytest.raises(ValueError, match="Cannot transform.*field"): - rotate(mesh, angle=np.pi / 2, axis=[0, 0, 1], transform_cell_data=True) - - -class TestScaleDataTransformEdgeCases: - """Test scale() with transform_point_data covering all paths.""" - - def test_scale_data_skips_cached(self): - """Test scale skips cached fields (under "_cache").""" - from physicsnemo.mesh.utilities._cache import get_cached, set_cached - - points = torch.tensor([[1.0, 0.0]]) - cells = torch.tensor([[0]]) - mesh = Mesh(points=points, cells=cells) - - set_cached(mesh.point_data, "test_vector", torch.tensor([[1.0, 2.0]])) - - scaled = scale(mesh, factor=2.0, transform_point_data=True) - - # Cache should not be transformed (excluded from user data transformation) - assert ( - "_cache" not in scaled.point_data - or get_cached(scaled.point_data, "test_vector") is None - ) - - def test_scale_data_wrong_shape_raises(self): - """Test scale raises for fields with wrong shape.""" - points = torch.tensor([[1.0, 0.0]]) - cells = torch.tensor([[0]]) - mesh = Mesh(points=points, cells=cells) - - mesh.point_data["weird"] = torch.ones(mesh.n_points, 5) - - with pytest.raises(ValueError, match="Cannot transform.*First.*dimension"): - scale(mesh, factor=2.0, transform_point_data=True) - - def test_scale_with_incompatible_tensor_raises(self): - """Test scale with incompatible tensor raises ValueError.""" - points = torch.tensor([[1.0, 0.0]]) - cells = torch.tensor([[0]]) - mesh = Mesh(points=points, cells=cells) - - mesh.point_data["bad"] = torch.ones(mesh.n_points, 2, 3) - - with pytest.raises(ValueError, match="Cannot transform.*field"): - scale(mesh, factor=2.0, transform_point_data=True) - - -class TestTranslateEdgeCases: - """Test translate edge cases.""" - - def test_translate_with_wrong_offset_dims_raises(self): - """Test that offset with wrong dimensions raises ValueError.""" - points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - with pytest.raises(ValueError, match="offset must have shape"): - translate(mesh, offset=[1.0, 2.0, 3.0]) # 3D offset for 2D mesh - - -class TestGlobalDataTransformation: - """Test global_data transformation.""" - - def test_transform_global_data_vector(self): - """Test that global_data vectors are transformed.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Global vector field (no batch dimension) - mesh.global_data["reference_direction"] = torch.tensor([1.0, 0.0, 0.0]) - - # Rotate 90° about z - rotated = rotate( - mesh, angle=np.pi / 2, axis=[0.0, 0.0, 1.0], transform_global_data=True - ) - - # Vector should now point in y direction - expected = torch.tensor([0.0, 1.0, 0.0]) - assert torch.allclose( - rotated.global_data["reference_direction"], expected, atol=1e-5 - ) - - def test_transform_global_data_scalar_unchanged(self): - """Test that global_data scalars are unchanged.""" - points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Global scalar - mesh.global_data["temperature"] = torch.tensor(300.0) - - # Transform - matrix = torch.tensor([[0.0, -1.0], [1.0, 0.0]]) - transformed = transform(mesh, matrix, transform_global_data=True) - - # Scalar should be unchanged - assert torch.allclose( - transformed.global_data["temperature"], mesh.global_data["temperature"] - ) - - def test_transform_global_data_incompatible_raises(self): - """Test that incompatible global_data raises ValueError.""" - points = torch.tensor([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - # Incompatible vector (5 != 3) - mesh.global_data["bad_vector"] = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0]) - - with pytest.raises(ValueError, match="Cannot transform.*First.*dimension"): - rotate( - mesh, angle=np.pi / 2, axis=[0.0, 0.0, 1.0], transform_global_data=True - ) - - def test_scale_global_data(self): - """Test scale transforms global_data vectors.""" - points = torch.tensor([[0.0, 0.0], [1.0, 0.0]]) - cells = torch.tensor([[0, 1]]) - mesh = Mesh(points=points, cells=cells) - - mesh.global_data["force"] = torch.tensor([1.0, 2.0]) - - scaled = scale(mesh, factor=3.0, transform_global_data=True) - - expected = torch.tensor([3.0, 6.0]) - assert torch.allclose(scaled.global_data["force"], expected, atol=1e-5) - - -if __name__ == "__main__": - pytest.main([__file__, "-v"]) diff --git a/test/mesh/utilities/test_tolerances.py b/test/mesh/utilities/test_tolerances.py new file mode 100644 index 0000000000..31dd9fb981 --- /dev/null +++ b/test/mesh/utilities/test_tolerances.py @@ -0,0 +1,62 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for dtype-aware numerical tolerances.""" + +import math + +import pytest +import torch + +from physicsnemo.mesh.utilities._tolerances import safe_eps + + +@pytest.mark.parametrize( + "dtype", [torch.bfloat16, torch.float16, torch.float32, torch.float64] +) +class TestSafeEps: + """Verify safe_eps returns principled, dtype-aware floor values.""" + + def test_matches_formula(self, dtype: torch.dtype) -> None: + """safe_eps should equal tiny ** 0.25 for the given dtype.""" + expected = torch.finfo(dtype).tiny ** 0.25 + assert safe_eps(dtype) == expected + + def test_positive(self, dtype: torch.dtype) -> None: + """safe_eps must be strictly positive.""" + assert safe_eps(dtype) > 0.0 + + def test_reciprocal_does_not_overflow(self, dtype: torch.dtype) -> None: + """1 / safe_eps must be representable (not inf).""" + assert math.isfinite(1.0 / safe_eps(dtype)) + + def test_reciprocal_squared_does_not_overflow(self, dtype: torch.dtype) -> None: + """1 / safe_eps**2 must be representable (not inf). + + This matters for inverse-distance weights where the denominator + may be squared before clamping. + """ + assert math.isfinite(1.0 / safe_eps(dtype) ** 2) + + def test_smaller_than_machine_epsilon(self, dtype: torch.dtype) -> None: + """safe_eps should be far below machine epsilon (it guards against + exact zeros, not rounding errors).""" + if dtype == torch.float16: + pytest.skip( + "float16 has a 5-bit exponent; tiny^0.25 exceeds eps, " + "which is expected - the overflow-safety constraint dominates" + ) + assert safe_eps(dtype) < torch.finfo(dtype).eps diff --git a/test/mesh/validation/test_validation.py b/test/mesh/validation/test_validation.py new file mode 100644 index 0000000000..bf9a32f3be --- /dev/null +++ b/test/mesh/validation/test_validation.py @@ -0,0 +1,869 @@ +# SPDX-FileCopyrightText: Copyright (c) 2023 - 2026 NVIDIA CORPORATION & AFFILIATES. +# SPDX-FileCopyrightText: All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Comprehensive tests for validation module. + +Tests mesh validation, quality metrics computation, and mesh statistics +including edge cases and code path coverage. + +This module consolidates tests from: +- Core validation tests (mesh validation, quality metrics, statistics) +- Edge case tests (code path coverage, special conditions) +""" + +import pytest +import torch + +from physicsnemo.mesh import Mesh +from physicsnemo.mesh.validation import ( + compute_mesh_statistics, + compute_quality_metrics, + validate_mesh, +) + +############################################################################### +# Mesh Validation Tests +############################################################################### + + +class TestMeshValidation: + """Tests for mesh validation.""" + + def test_valid_mesh(self, device): + """Test that valid mesh passes all checks.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + report = validate_mesh(mesh) + + assert report["valid"] + assert report["n_degenerate_cells"] == 0 + assert report["n_out_of_bounds_cells"] == 0 + + def test_out_of_bounds_indices(self, device): + """Test detection of out-of-bounds cell indices.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + # Cell references non-existent vertex 10 + cells = torch.tensor([[0, 1, 10]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + report = validate_mesh(mesh, check_out_of_bounds=True, raise_on_error=False) + + assert not report["valid"] + assert report["n_out_of_bounds_cells"] == 1 + + def test_degenerate_cells_detection(self, device): + """Test detection of degenerate cells.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [2.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + + # Second cell has duplicate vertex (degenerate) + cells = torch.tensor( + [ + [0, 1, 2], + [1, 3, 1], # Duplicate vertex 1 + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + report = validate_mesh(mesh, check_degenerate_cells=True, raise_on_error=False) + + assert not report["valid"] + assert report["n_degenerate_cells"] >= 1 + + def test_duplicate_vertices_detection(self, device): + """Test detection of duplicate vertices.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [0.0, 0.0], # Exact duplicate of vertex 0 + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + report = validate_mesh( + mesh, check_duplicate_vertices=True, raise_on_error=False + ) + + assert not report["valid"] + assert report["n_duplicate_vertices"] >= 1 + + def test_raise_on_error(self, device): + """Test that raise_on_error triggers exception.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 10]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + with pytest.raises(ValueError, match="out-of-bounds"): + validate_mesh(mesh, check_out_of_bounds=True, raise_on_error=True) + + def test_manifoldness_check_2d(self, device): + """Test manifoldness check for 2D meshes.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [0.5, 0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + # Two triangles sharing edge [0,1] + cells = torch.tensor( + [ + [0, 1, 2], + [0, 1, 3], + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + report = validate_mesh(mesh, check_manifoldness=True) + + # Should be manifold (each edge shared by at most 2 faces) + assert report["is_manifold"] + assert report["n_non_manifold_edges"] == 0 + + def test_empty_mesh_validation(self, device): + """Test validation of empty mesh.""" + points = torch.zeros((0, 2), device=device) + cells = torch.zeros((0, 3), dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + report = validate_mesh(mesh) + + # Empty mesh should be valid + assert report["valid"] + + +############################################################################### +# Quality Metrics Tests +############################################################################### + + +class TestQualityMetrics: + """Tests for quality metrics computation.""" + + def test_equilateral_triangle_quality(self, device): + """Test that equilateral triangle has high quality score.""" + + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, (3**0.5) / 2], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + metrics = compute_quality_metrics(mesh) + + assert "quality_score" in metrics.keys() + assert "aspect_ratio" in metrics.keys() + assert "edge_length_ratio" in metrics.keys() + + # Equilateral triangle should have high quality + quality = metrics["quality_score"][0] + assert quality > 0.7 # High quality (formula gives ~0.75 for equilateral) + + # Edge length ratio should be close to 1.0 + edge_ratio = metrics["edge_length_ratio"][0] + assert edge_ratio < 1.1 # Nearly equal edges + + def test_degenerate_triangle_quality(self, device): + """Test that degenerate triangle has low quality score.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [10.0, 0.0], # Nearly collinear + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + metrics = compute_quality_metrics(mesh) + + quality = metrics["quality_score"][0] + + # Very elongated triangle should have low quality + assert quality < 0.3 + + def test_quality_metrics_angles(self, device): + """Test that angles are computed for triangles.""" + + # Right triangle + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + metrics = compute_quality_metrics(mesh) + + assert "min_angle" in metrics.keys() + assert "max_angle" in metrics.keys() + + min_angle = metrics["min_angle"][0] + max_angle = metrics["max_angle"][0] + + # Right triangle has angles: π/4, π/4, π/2 + assert min_angle > 0 + assert max_angle <= torch.pi + + # Max angle should be close to π/2 + assert torch.abs(max_angle - torch.pi / 2) < 0.1 + + def test_empty_mesh_quality(self, device): + """Test quality metrics on empty mesh.""" + points = torch.zeros((5, 2), device=device) + cells = torch.zeros((0, 3), dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + metrics = compute_quality_metrics(mesh) + + # Should return empty TensorDict + assert len(metrics) == 0 or metrics.shape[0] == 0 + + +############################################################################### +# Mesh Statistics Tests +############################################################################### + + +class TestMeshStatistics: + """Tests for mesh statistics computation.""" + + def test_basic_statistics(self, device): + """Test basic mesh statistics.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [1.5, 0.5], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1, 2], + [1, 2, 3], + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + stats = compute_mesh_statistics(mesh) + + assert stats["n_points"] == 4 + assert stats["n_cells"] == 2 + assert stats["n_manifold_dims"] == 2 + assert stats["n_spatial_dims"] == 2 + assert stats["n_degenerate_cells"] == 0 + assert stats["n_isolated_vertices"] == 0 + + def test_statistics_with_isolated(self, device): + """Test statistics with isolated vertices.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [5.0, 5.0], # Isolated + [6.0, 6.0], # Isolated + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + stats = compute_mesh_statistics(mesh) + + assert stats["n_isolated_vertices"] == 2 + + def test_statistics_edge_lengths(self, device): + """Test edge length statistics.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + stats = compute_mesh_statistics(mesh) + + assert "edge_length_stats" in stats + min_len, mean_len, max_len, std_len = stats["edge_length_stats"] + + # All should be positive + assert min_len > 0 + assert mean_len > 0 + assert max_len > 0 + + def test_statistics_empty_mesh(self, device): + """Test statistics on empty mesh.""" + points = torch.zeros((5, 2), device=device) + cells = torch.zeros((0, 3), dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + stats = compute_mesh_statistics(mesh) + + assert stats["n_cells"] == 0 + assert stats["n_isolated_vertices"] == 5 + + +############################################################################### +# Mesh API Integration Tests +############################################################################### + + +class TestMeshAPIIntegration: + """Test that Mesh class methods work correctly.""" + + def test_mesh_validate_method(self, device): + """Test mesh.validate() convenience method.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + report = mesh.validate() + + assert isinstance(report, dict) + assert "valid" in report + assert report["valid"] + + def test_mesh_quality_metrics_property(self, device): + """Test mesh.quality_metrics property.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + metrics = mesh.quality_metrics + + assert "quality_score" in metrics.keys() + assert metrics["quality_score"].shape == (1,) + + def test_mesh_statistics_property(self, device): + """Test mesh.statistics property.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + stats = mesh.statistics + + assert isinstance(stats, dict) + assert stats["n_points"] == 3 + assert stats["n_cells"] == 1 + + def test_validation_with_all_checks(self, device): + """Test validation with all checks enabled.""" + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [0.5, 0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1, 2], + [1, 2, 3], + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + report = mesh.validate( + check_degenerate_cells=True, + check_duplicate_vertices=True, + check_out_of_bounds=True, + check_manifoldness=True, + ) + + assert report["valid"] + + def test_validation_detects_negative_indices(self, device): + """Test that negative cell indices are caught.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, -1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + report = validate_mesh(mesh, check_out_of_bounds=True, raise_on_error=False) + + assert not report["valid"] + assert report["n_out_of_bounds_cells"] == 1 + + +############################################################################### +# Quality Metrics Edge Cases +############################################################################### + + +class TestQualityMetricsEdgeCases: + """Edge case tests for quality metrics.""" + + def test_single_cell_quality(self, device): + """Test quality metrics on single cell.""" + + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, (3**0.5) / 2], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + metrics = compute_quality_metrics(mesh) + + assert metrics.shape[0] == 1 + assert not torch.isnan(metrics["quality_score"][0]) + + def test_multiple_cells_quality(self, device): + """Test quality metrics on multiple cells.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + [1.5, 0.5], + [0.5, -0.5], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1, 2], + [1, 2, 3], + [0, 1, 4], + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + metrics = compute_quality_metrics(mesh) + + assert metrics.shape[0] == 3 + assert torch.all(metrics["quality_score"] > 0) + assert torch.all(metrics["quality_score"] <= 1.0) + + def test_3d_mesh_quality(self, device): + """Test quality metrics on 3D tetrahedral mesh.""" + from physicsnemo.mesh.primitives.volumes import tetrahedron_volume + + # Use tetrahedron_volume primitive for a regular tetrahedron + mesh = tetrahedron_volume.load(device=device) + + metrics = compute_quality_metrics(mesh) + + # Should compute metrics for tets including solid angles + assert metrics.shape[0] == 1 + assert not torch.isnan(metrics["quality_score"][0]) + assert not torch.isnan(metrics["min_angle"][0]) + # Regular tet: all solid angles should be equal, so min == max + assert torch.isclose( + metrics["min_angle"][0], metrics["max_angle"][0], atol=1e-5 + ) + + +############################################################################### +# Statistics Variations +############################################################################### + + +class TestStatisticsVariations: + """Test statistics computation with various mesh configurations.""" + + def test_statistics_include_quality(self, device): + """Test that statistics include quality metrics.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + stats = compute_mesh_statistics(mesh) + + assert "cell_area_stats" in stats + assert "quality_score_stats" in stats + assert "aspect_ratio_stats" in stats + + def test_statistics_large_mesh(self, device): + """Test statistics on a realistic mesh with many cells.""" + from physicsnemo.mesh.primitives.procedural import lumpy_sphere + + # Use lumpy_sphere (subdivisions=2 gives ~320 cells) for realistic mesh + mesh = lumpy_sphere.load(subdivisions=2, device=device) + + stats = compute_mesh_statistics(mesh) + + # Lumpy sphere at subdivisions=2 has 320 triangles + assert stats["n_cells"] >= 300 + assert stats["n_isolated_vertices"] == 0 + assert "cell_area_stats" in stats + assert "quality_score_stats" in stats + + +############################################################################### +# Validation Code Path Tests +############################################################################### + + +class TestValidationCodePaths: + """Tests for specific validation code paths.""" + + def test_large_mesh_duplicate_check_works(self, device): + """Test that duplicate check works efficiently for large meshes.""" + # Create mesh with >10K points + n = 101 + x = torch.linspace(0, 1, n, device=device) + y = torch.linspace(0, 1, n, device=device) + xx, yy = torch.meshgrid(x, y, indexing="xy") + + points = torch.stack([xx.flatten(), yy.flatten()], dim=-1) + + # Create some triangles + cells = torch.tensor([[0, 1, n]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + # Duplicate check now works for all mesh sizes using vectorized spatial hashing + report = validate_mesh(mesh, check_duplicate_vertices=True) + + # Should return actual count (0 since grid points are well-spaced) + assert report["n_duplicate_vertices"] == 0 + + def test_inverted_cells_3d(self, device): + """Test detection of inverted cells in 3D.""" + # Regular tetrahedron + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, (3**0.5) / 2, 0.0], + [0.5, (3**0.5) / 6, ((2 / 3) ** 0.5)], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1, 2, 3], # Normal orientation + [0, 2, 1, 3], # Inverted (swapped 1 and 2) + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + report = validate_mesh(mesh, check_inverted_cells=True, raise_on_error=False) + + # Should detect one inverted cell + assert report["n_inverted_cells"] >= 1 + assert not report["valid"] + + def test_non_manifold_edge_detection(self, device): + """Test detection of non-manifold edges.""" + # Create T-junction (3 triangles meeting at one edge) + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + [0.5, -1.0, 0.0], + [0.5, 0.0, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + # Three triangles sharing edge [0,1] + cells = torch.tensor( + [ + [0, 1, 2], + [0, 1, 3], + [0, 1, 4], + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + report = validate_mesh(mesh, check_manifoldness=True, raise_on_error=False) + + # Should detect non-manifold edge + assert not report["is_manifold"] + assert report["n_non_manifold_edges"] >= 1 + + def test_validation_with_empty_cells(self, device): + """Test validation on mesh with no cells.""" + points = torch.randn(5, 2, device=device) + cells = torch.zeros((0, 3), dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + report = validate_mesh( + mesh, + check_degenerate_cells=True, + check_out_of_bounds=True, + check_inverted_cells=True, + ) + + # Should be valid (no cells to have problems) + assert report["valid"] + assert report["n_degenerate_cells"] == 0 + assert report["n_out_of_bounds_cells"] == 0 + + def test_inverted_check_not_applicable(self, device): + """Test that inverted check returns -1 for non-volume meshes.""" + # 2D triangle in 3D (codimension 1) + points = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.5, 1.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor([[0, 1, 2]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + report = validate_mesh(mesh, check_inverted_cells=True) + + # Should return -1 (not applicable for codimension != 0) + assert report["n_inverted_cells"] == -1 or report["n_inverted_cells"] == 0 + + def test_manifoldness_not_applicable_non_2d(self, device): + """Test that manifoldness check is only for 2D manifolds.""" + # 1D mesh (edges) + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [2.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + + cells = torch.tensor( + [ + [0, 1], + [1, 2], + ], + dtype=torch.long, + device=device, + ) + + mesh = Mesh(points=points, cells=cells) + + report = validate_mesh(mesh, check_manifoldness=True) + + # Should return None or -1 for non-2D manifolds + assert ( + report.get("is_manifold") is None + or report.get("n_non_manifold_edges") == -1 + ) + + def test_validation_skips_geometry_after_out_of_bounds(self, device): + """Test that validation short-circuits after finding out-of-bounds indices.""" + points = torch.tensor( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.5, 1.0], + ], + dtype=torch.float32, + device=device, + ) + + # Invalid index + cells = torch.tensor([[0, 1, 100]], dtype=torch.long, device=device) + + mesh = Mesh(points=points, cells=cells) + + # Should not crash even though area computation would fail + report = validate_mesh( + mesh, + check_out_of_bounds=True, + check_degenerate_cells=True, + raise_on_error=False, + ) + + assert not report["valid"] + assert report["n_out_of_bounds_cells"] == 1 + # Degenerate check should be skipped (no key or not computed) + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) diff --git a/test/mesh/visualization/test_visualization.py b/test/mesh/visualization/test_visualization.py index e77952dcdc..2c1e0edc39 100644 --- a/test/mesh/visualization/test_visualization.py +++ b/test/mesh/visualization/test_visualization.py @@ -28,8 +28,8 @@ matplotlib = pytest.importorskip("matplotlib") pv = pytest.importorskip("pyvista") -plt = matplotlib.pyplot matplotlib.use("Agg") # Use non-interactive backend for testing +import matplotlib.pyplot as plt # noqa: E402 — must be after backend selection def create_0d_point_cloud(n_points: int = 10) -> Mesh: @@ -69,13 +69,9 @@ def create_3d_surface_mesh() -> Mesh: def create_3d_tetrahedral_mesh() -> Mesh: """Create a simple 3D tetrahedral mesh.""" - # Single tetrahedron - points = torch.tensor( - [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], - dtype=torch.float32, - ) - cells = torch.tensor([[0, 1, 2, 3]], dtype=torch.long) - return Mesh(points=points, cells=cells) + from physicsnemo.mesh.primitives.basic import single_tetrahedron + + return single_tetrahedron.load() ### Tests for backend selection diff --git a/uv.lock b/uv.lock index e06c55f120..c82f64d48b 100644 --- a/uv.lock +++ b/uv.lock @@ -1573,7 +1573,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1f/cb/48e964c452ca2b92175a9b2dca037a553036cb053ba69e284650ce755f13/greenlet-3.3.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:e29f3018580e8412d6aaf5641bb7745d38c85228dacf51a73bd4e26ddf2a6a8e", size = 274908, upload-time = "2025-12-04T14:23:26.435Z" }, { url = "https://files.pythonhosted.org/packages/28/da/38d7bff4d0277b594ec557f479d65272a893f1f2a716cad91efeb8680953/greenlet-3.3.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a687205fb22794e838f947e2194c0566d3812966b41c78709554aa883183fb62", size = 577113, upload-time = "2025-12-04T14:50:05.493Z" }, { url = "https://files.pythonhosted.org/packages/3c/f2/89c5eb0faddc3ff014f1c04467d67dee0d1d334ab81fadbf3744847f8a8a/greenlet-3.3.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4243050a88ba61842186cb9e63c7dfa677ec146160b0efd73b855a3d9c7fcf32", size = 590338, upload-time = "2025-12-04T14:57:41.136Z" }, - { url = "https://files.pythonhosted.org/packages/80/d7/db0a5085035d05134f8c089643da2b44cc9b80647c39e93129c5ef170d8f/greenlet-3.3.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:670d0f94cd302d81796e37299bcd04b95d62403883b24225c6b5271466612f45", size = 601098, upload-time = "2025-12-04T15:07:11.898Z" }, { url = "https://files.pythonhosted.org/packages/dc/a6/e959a127b630a58e23529972dbc868c107f9d583b5a9f878fb858c46bc1a/greenlet-3.3.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6cb3a8ec3db4a3b0eb8a3c25436c2d49e3505821802074969db017b87bc6a948", size = 590206, upload-time = "2025-12-04T14:26:01.254Z" }, { url = "https://files.pythonhosted.org/packages/48/60/29035719feb91798693023608447283b266b12efc576ed013dd9442364bb/greenlet-3.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2de5a0b09eab81fc6a382791b995b1ccf2b172a9fec934747a7a23d2ff291794", size = 1550668, upload-time = "2025-12-04T15:04:22.439Z" }, { url = "https://files.pythonhosted.org/packages/0a/5f/783a23754b691bfa86bd72c3033aa107490deac9b2ef190837b860996c9f/greenlet-3.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4449a736606bd30f27f8e1ff4678ee193bc47f6ca810d705981cfffd6ce0d8c5", size = 1615483, upload-time = "2025-12-04T14:27:28.083Z" }, @@ -1581,7 +1580,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f8/0a/a3871375c7b9727edaeeea994bfff7c63ff7804c9829c19309ba2e058807/greenlet-3.3.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:b01548f6e0b9e9784a2c99c5651e5dc89ffcbe870bc5fb2e5ef864e9cc6b5dcb", size = 276379, upload-time = "2025-12-04T14:23:30.498Z" }, { url = "https://files.pythonhosted.org/packages/43/ab/7ebfe34dce8b87be0d11dae91acbf76f7b8246bf9d6b319c741f99fa59c6/greenlet-3.3.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:349345b770dc88f81506c6861d22a6ccd422207829d2c854ae2af8025af303e3", size = 597294, upload-time = "2025-12-04T14:50:06.847Z" }, { url = "https://files.pythonhosted.org/packages/a4/39/f1c8da50024feecd0793dbd5e08f526809b8ab5609224a2da40aad3a7641/greenlet-3.3.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e8e18ed6995e9e2c0b4ed264d2cf89260ab3ac7e13555b8032b25a74c6d18655", size = 607742, upload-time = "2025-12-04T14:57:42.349Z" }, - { url = "https://files.pythonhosted.org/packages/77/cb/43692bcd5f7a0da6ec0ec6d58ee7cddb606d055ce94a62ac9b1aa481e969/greenlet-3.3.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c024b1e5696626890038e34f76140ed1daf858e37496d33f2af57f06189e70d7", size = 622297, upload-time = "2025-12-04T15:07:13.552Z" }, { url = "https://files.pythonhosted.org/packages/75/b0/6bde0b1011a60782108c01de5913c588cf51a839174538d266de15e4bf4d/greenlet-3.3.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:047ab3df20ede6a57c35c14bf5200fcf04039d50f908270d3f9a7a82064f543b", size = 609885, upload-time = "2025-12-04T14:26:02.368Z" }, { url = "https://files.pythonhosted.org/packages/49/0e/49b46ac39f931f59f987b7cd9f34bfec8ef81d2a1e6e00682f55be5de9f4/greenlet-3.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2d9ad37fc657b1102ec880e637cccf20191581f75c64087a549e66c57e1ceb53", size = 1567424, upload-time = "2025-12-04T15:04:23.757Z" }, { url = "https://files.pythonhosted.org/packages/05/f5/49a9ac2dff7f10091935def9165c90236d8f175afb27cbed38fb1d61ab6b/greenlet-3.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:83cd0e36932e0e7f36a64b732a6f60c2fc2df28c351bae79fbaf4f8092fe7614", size = 1636017, upload-time = "2025-12-04T14:27:29.688Z" }, @@ -1589,7 +1587,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/02/2f/28592176381b9ab2cafa12829ba7b472d177f3acc35d8fbcf3673d966fff/greenlet-3.3.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:a1e41a81c7e2825822f4e068c48cb2196002362619e2d70b148f20a831c00739", size = 275140, upload-time = "2025-12-04T14:23:01.282Z" }, { url = "https://files.pythonhosted.org/packages/2c/80/fbe937bf81e9fca98c981fe499e59a3f45df2a04da0baa5c2be0dca0d329/greenlet-3.3.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9f515a47d02da4d30caaa85b69474cec77b7929b2e936ff7fb853d42f4bf8808", size = 599219, upload-time = "2025-12-04T14:50:08.309Z" }, { url = "https://files.pythonhosted.org/packages/c2/ff/7c985128f0514271b8268476af89aee6866df5eec04ac17dcfbc676213df/greenlet-3.3.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7d2d9fd66bfadf230b385fdc90426fcd6eb64db54b40c495b72ac0feb5766c54", size = 610211, upload-time = "2025-12-04T14:57:43.968Z" }, - { url = "https://files.pythonhosted.org/packages/79/07/c47a82d881319ec18a4510bb30463ed6891f2ad2c1901ed5ec23d3de351f/greenlet-3.3.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:30a6e28487a790417d036088b3bcb3f3ac7d8babaa7d0139edbaddebf3af9492", size = 624311, upload-time = "2025-12-04T15:07:14.697Z" }, { url = "https://files.pythonhosted.org/packages/fd/8e/424b8c6e78bd9837d14ff7df01a9829fc883ba2ab4ea787d4f848435f23f/greenlet-3.3.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:087ea5e004437321508a8d6f20efc4cfec5e3c30118e1417ea96ed1d93950527", size = 612833, upload-time = "2025-12-04T14:26:03.669Z" }, { url = "https://files.pythonhosted.org/packages/b5/ba/56699ff9b7c76ca12f1cdc27a886d0f81f2189c3455ff9f65246780f713d/greenlet-3.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ab97cf74045343f6c60a39913fa59710e4bd26a536ce7ab2397adf8b27e67c39", size = 1567256, upload-time = "2025-12-04T15:04:25.276Z" }, { url = "https://files.pythonhosted.org/packages/1e/37/f31136132967982d698c71a281a8901daf1a8fbab935dce7c0cf15f942cc/greenlet-3.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5375d2e23184629112ca1ea89a53389dddbffcf417dad40125713d88eb5f96e8", size = 1636483, upload-time = "2025-12-04T14:27:30.804Z" }, @@ -3459,6 +3456,7 @@ gnns = [ ] mesh-extras = [ { name = "matplotlib" }, + { name = "pyacvd" }, { name = "pyvista" }, ] model-extras = [ @@ -3548,6 +3546,7 @@ requires-dist = [ { name = "onnx", specifier = ">=1.14.0" }, { name = "packaging", specifier = ">=24.2" }, { name = "pandas", specifier = ">=2.2.0" }, + { name = "pyacvd", marker = "extra == 'mesh-extras'", specifier = ">=0.3.2" }, { name = "pylibraft-cu13", marker = "extra == 'gnns'", index = "https://pypi.nvidia.com/" }, { name = "pylibraft-cu13", marker = "extra == 'model-extras'", index = "https://pypi.nvidia.com/" }, { name = "pylibraft-cu13", marker = "extra == 'nn-extras'", index = "https://pypi.nvidia.com/" }, @@ -4149,6 +4148,34 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f6/f0/10642828a8dfb741e5f3fbaac830550a518a775c7fff6f04a007259b0548/py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378", size = 98708, upload-time = "2021-11-04T17:17:00.152Z" }, ] +[[package]] +name = "pyacvd" +version = "0.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "pykdtree" }, + { name = "pyvista" }, + { name = "vtk", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/90/fd38b07ee58fefe82e19a62548b271b405238df6fef85e5475a7e87b1b90/pyacvd-0.3.3-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:300b7e02a9ef9eee16f23bcbdf66c2c9ecd40d1410886cfa4a56be0c486b4c1c", size = 76214, upload-time = "2025-12-03T01:37:05.893Z" }, + { url = "https://files.pythonhosted.org/packages/bd/b3/68b9dbfbae662390ebf4c698c8d8e8202c3a0326b649451f76464135f4db/pyacvd-0.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4cfb7213ad440413df22ba62e53f953368d5c63dcbdf2e7dcad5bc9cc7383171", size = 68710, upload-time = "2025-12-03T01:37:06.998Z" }, + { url = "https://files.pythonhosted.org/packages/05/3e/07f6b37eb79ad83ec71ae1257dcf390746a079cc4aee3e68ad4b1bde4651/pyacvd-0.3.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aceaff46b66c3917bfbc0fb7debacb2aa25a389373686c61d82e6a14674ff134", size = 99694, upload-time = "2025-12-03T01:37:07.814Z" }, + { url = "https://files.pythonhosted.org/packages/9c/08/20ca89d79c9bc25a30b2322921a2cdd40c2d4c97c4e71e8a549cc4d683a4/pyacvd-0.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e45b69475af21fefd010dde6ebf8160202050fa5d5f138e2bba0c876ff2bf81", size = 79018, upload-time = "2025-12-03T01:37:08.59Z" }, + { url = "https://files.pythonhosted.org/packages/36/9a/b99fba8c64355c6355d603207dd991dafd59e047a9cd0a2b438c43b61770/pyacvd-0.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:06128e9124594afb91e1793cb7b353804dd958f3a3702af4a07146815bd6417f", size = 70942, upload-time = "2025-12-03T01:37:09.687Z" }, + { url = "https://files.pythonhosted.org/packages/12/94/a599105d491f1898d2e4be2d32e51c73a6de33edada5ad6b58b56c3fdbf8/pyacvd-0.3.3-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:1787fab799d3b98da9d0ded66722bd0d8c139c6080d70bc445c1b7275294750a", size = 74511, upload-time = "2025-12-03T01:37:10.727Z" }, + { url = "https://files.pythonhosted.org/packages/a0/26/9da271a5fd5055323f62083f4c530247a4ad677f2c684df3ed1ad1f665aa/pyacvd-0.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:37f8b1ea9b3b5806b4fd041078c0c2673c853551e81915e641faa6c2f037f63f", size = 66938, upload-time = "2025-12-03T01:37:13.36Z" }, + { url = "https://files.pythonhosted.org/packages/f0/0b/62a5d151d97ca6c4e93f40791815e731316733c9a96bdda04b60158396be/pyacvd-0.3.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff1beddac4a160a325206c3c0f45b41a90346b193879f58a5130cd0e9434b87", size = 96247, upload-time = "2025-12-03T01:37:14.47Z" }, + { url = "https://files.pythonhosted.org/packages/3a/96/ef6a948e6bec3ce45ca60087f03a7a2b0020a48dd59544ea8aa5f60b21d7/pyacvd-0.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9b21dd5ba7c5b7467de9b3c922fcccba87811e40d7b7e15301e81f6fedf16ed3", size = 76291, upload-time = "2025-12-03T01:37:15.26Z" }, + { url = "https://files.pythonhosted.org/packages/ec/2b/7f9b0748cd0deec6ae16cebd5541df1d3ce3ae0f0da87155a025eb03d48d/pyacvd-0.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:401590556ae3d2eb1348bb8991c4cc94abbb1d8e803d11802a005b863f12b798", size = 69391, upload-time = "2025-12-03T01:37:15.981Z" }, + { url = "https://files.pythonhosted.org/packages/7d/df/01689b276a2f787a49a1acbf7c4d7db9a554733b9787c60e995631f8147c/pyacvd-0.3.3-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:0875314814ea31734f38b8fa772ee4e273359abf1563f60a0f9578320b63b574", size = 74514, upload-time = "2025-12-03T01:37:16.802Z" }, + { url = "https://files.pythonhosted.org/packages/3d/d4/11a449543b73cb58358490cd2eece52f1449f2460da603f7fb48b0a27011/pyacvd-0.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:945ffbb675ee9a997b609661956ba67fd94374fe41f1c2b06a7db0d8ebe2574c", size = 66940, upload-time = "2025-12-03T01:37:19.424Z" }, + { url = "https://files.pythonhosted.org/packages/4c/ef/208283a0bbee7899ac7c79c187af924c5f152c48d5845d2037c05b856938/pyacvd-0.3.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5018d7f920f09c7b2adc5245f36caad5b1ba531a9797213f1b081198fb84412", size = 96247, upload-time = "2025-12-03T01:37:20.158Z" }, + { url = "https://files.pythonhosted.org/packages/af/13/82f5ae0cc42186cf55485fcda816a55a56b4c954a0e311a4c801c6c278cc/pyacvd-0.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0fd48fd936a79901b16fbc8433813c853f279d3efc991ddc0bd1df7d544ce713", size = 76296, upload-time = "2025-12-03T01:37:21.039Z" }, + { url = "https://files.pythonhosted.org/packages/86/bb/273fe985fd2b4e655c43e24317cabb235c7a4917e738d1c3e14f31f5078c/pyacvd-0.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:52eba9ab1c448f06ea85255c68ac1a7da20a0a9f0fb584a85754b40ff6c19ff5", size = 69412, upload-time = "2025-12-03T01:37:21.769Z" }, +] + [[package]] name = "pyarrow" version = "22.0.0" @@ -4308,6 +4335,38 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, ] +[[package]] +name = "pykdtree" +version = "1.4.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/12/8d/ab32411372d016404e8cf0a30ff955c4420717a88c9df4ab0bd3dc4740be/pykdtree-1.4.3.tar.gz", hash = "sha256:d9187930ffb8c822c52595b64948b47346694ee2a49e2702420b58f743d786f5", size = 30472, upload-time = "2025-08-06T11:11:38.915Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1b/db/f8e30f61891c3455eda8f89691f200ac422258c2ae1c26f98dea1819d31b/pykdtree-1.4.3-cp311-cp311-macosx_13_0_x86_64.whl", hash = "sha256:bf1c863b97dec6ef9eda5f8c22e2513c1679b513a95f7bb49da90b49d8584223", size = 352572, upload-time = "2025-08-06T11:10:53.813Z" }, + { url = "https://files.pythonhosted.org/packages/06/fb/4e6b8478d4121780f4c19f16676cc1745ae9665c6ebce5c4b860b21bf57d/pykdtree-1.4.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:ffe8ec795142793f927879dd8b058066b4f3613e91a2639cc57b8d9eae5e49a0", size = 315617, upload-time = "2025-08-06T11:10:54.974Z" }, + { url = "https://files.pythonhosted.org/packages/26/69/cf40c90c488676701c5d088fbc3380d3d884eeef9ba87ef079442bcab847/pykdtree-1.4.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd3a4454b8f86ce22f7b92b4bc53e309817b0d3602afff8c9a17fde1bd6dd3f0", size = 441507, upload-time = "2025-08-06T11:10:56.865Z" }, + { url = "https://files.pythonhosted.org/packages/46/aa/ad48cc40d15c6c12d64d06768db96bde01e8f72dbfbbcebf391bcc1682fb/pykdtree-1.4.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:44d2e1b6a3d02b5cf9646bf754931fdacb869cefd328242766e1dc0be909cca1", size = 456475, upload-time = "2025-08-06T11:10:57.858Z" }, + { url = "https://files.pythonhosted.org/packages/62/d2/439860d63d40501e33370694a66de439696039a613ab31156040454e633a/pykdtree-1.4.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3b3899ae553d63e351a2fd98f1656affb7923bda02e066ea4703aa5ca1879582", size = 493800, upload-time = "2025-08-06T11:10:59.228Z" }, + { url = "https://files.pythonhosted.org/packages/ec/0c/f2bbc770d16b76a1a0d0967121796be4bbdece358c736b5fbc07327df82d/pykdtree-1.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:bb3367a325278a218fd22b321f1ef485445a0f19c23e1aa7bd6e34e0f4ff4d03", size = 67916, upload-time = "2025-08-06T11:11:00.681Z" }, + { url = "https://files.pythonhosted.org/packages/1a/95/8ea06124b9f2880b645532703cacee062bce45ec67c0c05314686415fc31/pykdtree-1.4.3-cp311-cp311-win_arm64.whl", hash = "sha256:b6630c10c5b05535b0045d7a00a95e5e53a7a44319069ff3054d69b52be3e81c", size = 55430, upload-time = "2025-08-06T11:11:01.625Z" }, + { url = "https://files.pythonhosted.org/packages/0b/f8/6cf164851d7d72b9bb7bc0ef4206ab191bfdfa9b6f017473ae69a1043e38/pykdtree-1.4.3-cp312-cp312-macosx_13_0_x86_64.whl", hash = "sha256:e0421694c5522911eb892eb916f1bcd08d70b72a69d5226d76bfa7706a2d9c74", size = 350280, upload-time = "2025-08-06T11:11:02.749Z" }, + { url = "https://files.pythonhosted.org/packages/8c/93/4842213b45a588efbbfc4ad2a0773efd7c03038a3c727c47a3ab40589ffa/pykdtree-1.4.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:c656c5c0caa0be582bcf3b662578db4d898d652fcb1de0586eae854a0f1ece5b", size = 314622, upload-time = "2025-08-06T11:11:03.669Z" }, + { url = "https://files.pythonhosted.org/packages/84/ed/a3978e5457d838945f1023240b12e72be71a53c8d3d0c0857f2063cc085d/pykdtree-1.4.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ace71f89edb21dc24c5d6c9e952638c7f2d229d75701a39e633f30b08668b63", size = 471736, upload-time = "2025-08-06T11:11:04.618Z" }, + { url = "https://files.pythonhosted.org/packages/1d/3f/6e51e96d2aa9101646742ff7429b628580ab59a9dbbf9540b9c3fe5fd1ab/pykdtree-1.4.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:08d63ee594b5cd7524bfa37ab857304a775ed04b7431ed4b48169ad664d694d8", size = 484828, upload-time = "2025-08-06T11:11:05.622Z" }, + { url = "https://files.pythonhosted.org/packages/ef/88/2a278de28b3958599ad75de198a039ba0b5b371d5cad809563cb522e03e6/pykdtree-1.4.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6c1fa063c2c7387dccd7553b1b677c05f7e762e9a7cfda35f5bb053ee6acea59", size = 521655, upload-time = "2025-08-06T11:11:06.532Z" }, + { url = "https://files.pythonhosted.org/packages/27/52/555bdec183897687015b736bc852201386125d196b3a7b5c57da8118b106/pykdtree-1.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:6d102ed37a54067e75485afb676c9c4bd723033a6e5661b47c059aa83ae6253e", size = 66371, upload-time = "2025-08-06T11:11:07.499Z" }, + { url = "https://files.pythonhosted.org/packages/ae/54/e51d88b7c2e9d7e8ab75461d96b21f54ffa639ff2515da5344e9a96b66b1/pykdtree-1.4.3-cp312-cp312-win_arm64.whl", hash = "sha256:49ea28ecd75e0d450c1e9f54c8bc35eb1b677bb7fa0df2c341b83e782a976576", size = 54381, upload-time = "2025-08-06T11:11:08.583Z" }, + { url = "https://files.pythonhosted.org/packages/ba/4b/76a3ee5a14053a7e7f7584ac6f8fd0e01959919773b6c6aad95aaf041288/pykdtree-1.4.3-cp313-cp313-macosx_13_0_x86_64.whl", hash = "sha256:8e1c1fff9f3893a82bf5b5f09be8d6ee83b05ed9d577e30eb50e6d729e15e455", size = 349780, upload-time = "2025-08-06T11:11:09.454Z" }, + { url = "https://files.pythonhosted.org/packages/4e/87/205f0a5c0fe687c10d1e8d1869146a7e20e4549a7cea12ae0ee4968a5a73/pykdtree-1.4.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:165bfa54a1a98609bfa1f52ea739f6347a01f5da418512bf8f7fa360cfca979f", size = 314048, upload-time = "2025-08-06T11:11:10.321Z" }, + { url = "https://files.pythonhosted.org/packages/19/1f/caf7fd20d7dc9ca065e6fdd4f0fc6c9631e87dea2866121df2cca591c387/pykdtree-1.4.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a73001e203ea2aa4415ffb251fe9f71de1e0cb935a6cd014d4a4610f7ca7bbb", size = 450018, upload-time = "2025-08-06T11:11:11.19Z" }, + { url = "https://files.pythonhosted.org/packages/a4/3e/dc89d0757452d1d0207b558f6a40bf2af1770a664b56d2c14f9ccd8ec75d/pykdtree-1.4.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0726995df7f62bee5beabc867ba86ffab96cc38c4cf59dd92cb92eab64c51b91", size = 464481, upload-time = "2025-08-06T11:11:12.184Z" }, + { url = "https://files.pythonhosted.org/packages/32/84/6ea33dc76a667aba7fc77591028b853d600e335953deac3e9b2f13cff951/pykdtree-1.4.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f9a51e58446f60bb572701179c21191c1a8fdd233c79a79133eff85bf7349362", size = 499285, upload-time = "2025-08-06T11:11:13.673Z" }, + { url = "https://files.pythonhosted.org/packages/a8/59/7e738300a6d733235ef641398dd7eb297c9a575140ca7e89fcf1c608f42e/pykdtree-1.4.3-cp313-cp313-win_amd64.whl", hash = "sha256:32af4eaf44326b68f0f1a1ec0813b7b134477dd91fee2ce699a7891aec833c6f", size = 66772, upload-time = "2025-08-06T11:11:14.596Z" }, + { url = "https://files.pythonhosted.org/packages/1e/6d/adc34737c527e606e12da525e530c2c05d80f405b0ddc24f9322a7a39b31/pykdtree-1.4.3-cp313-cp313-win_arm64.whl", hash = "sha256:77eaf63d25ab10f980bc516e1864fb4181e717d4005ef0249dd7119d7601ef6d", size = 54426, upload-time = "2025-08-06T11:11:15.368Z" }, +] + [[package]] name = "pylibcudf-cu13" version = "25.12.0"