From aaf5612bec14134a652b795e218c7d4dbe05f792 Mon Sep 17 00:00:00 2001 From: x25tang Date: Tue, 2 Dec 2025 07:30:33 +0100 Subject: [PATCH 01/32] ENH: Add contextily as a dependency for Monte Carlo simulations in pyproject.toml and requirements-optional.txt --- pyproject.toml | 1 + requirements-optional.txt | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 306299b2b..1479ecd11 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -65,6 +65,7 @@ monte-carlo = [ "multiprocess>=0.70", "statsmodels", "prettytable", + "contextily>=1.0.0", ] all = ["rocketpy[env-analysis]", "rocketpy[monte-carlo]"] diff --git a/requirements-optional.txt b/requirements-optional.txt index 58ed1030b..7f7f91d17 100644 --- a/requirements-optional.txt +++ b/requirements-optional.txt @@ -6,4 +6,5 @@ timezonefinder imageio multiprocess>=0.70 statsmodels -prettytable \ No newline at end of file +prettytable +contextily>=1.0.0 \ No newline at end of file From 14cdb4ad916fd8a7c6ea4b7febb007fff6d84cf3 Mon Sep 17 00:00:00 2001 From: x25tang Date: Tue, 2 Dec 2025 07:32:08 +0100 Subject: [PATCH 02/32] ENH: Add background map functionality to Monte Carlo plots - Introduced a new method `_get_background_map` to fetch and display background maps using contextily. - Added support for various map types: "satellite", "street", "terrain", and custom contextily providers. - Updated `ellipses` and comparison methods to integrate background maps, enhancing visualization capabilities. - Included error handling and warnings for missing dependencies and attributes. - See issue #890 --- rocketpy/plots/monte_carlo_plots.py | 173 +++++++++++++++++++++++++++- 1 file changed, 171 insertions(+), 2 deletions(-) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index 933bf9301..a4cb3e981 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -1,10 +1,12 @@ +import math from pathlib import Path +import warnings import matplotlib.pyplot as plt import numpy as np from matplotlib.transforms import offset_copy -from ..tools import generate_monte_carlo_ellipses, import_optional_dependency +from ..tools import generate_monte_carlo_ellipses, import_optional_dependency, inverted_haversine, haversine from .plot_helpers import show_or_save_plot @@ -14,10 +16,135 @@ class _MonteCarloPlots: def __init__(self, monte_carlo): self.monte_carlo = monte_carlo + def _get_background_map(self, background, xlim, ylim): + if background is None: + return None, None + else: + try: + contextily = import_optional_dependency("contextily") + except ImportError: + warnings.warn( + "contextily library is required for automatic map background. " + "Install it via 'pip install contextily' or 'pip install rocketpy[monte-carlo]'. " + "Plotting without background.", + UserWarning + ) + return None, None + + if not hasattr(self.monte_carlo, "environment"): + raise ValueError( + "MonteCarlo object must have an 'environment' attribute " + "to use automatic map background." + ) + env = self.monte_carlo.environment + if not hasattr(env, "latitude") or not hasattr(env, "longitude"): + raise ValueError( + "Environment must have 'latitude' and 'longitude' attributes." + ) + + try: + + # Handle both StochasticEnvironment (which stores as lists) and Environment (which stores as scalars) + origin_lat = env.latitude + origin_lon = env.longitude + if isinstance(origin_lat, (list, tuple)): + origin_lat = origin_lat[0] + if isinstance(origin_lon, (list, tuple)): + origin_lon = origin_lon[0] + # Get earth_radius from the underlying Environment object if available + if hasattr(env, "obj") and hasattr(env.obj, "earth_radius"): + earth_radius = env.obj.earth_radius + else: + earth_radius = getattr(env, "earth_radius", 6.3781e6) + + if background == "satellite": + map_provider = "Esri.WorldImagery" + elif background == "street": + map_provider = "OpenStreetMap.Mapnik" + elif background == "terrain": + map_provider = "Esri.WorldTopoMap" + else: + map_provider = background + + # Helper to resolve provider string (e.g., "Esri.WorldImagery") to object + source_provider = map_provider + if isinstance(map_provider, str): + try: + # Attempt to traverse contextily.providers + p = contextily.providers + for key in map_provider.split("."): + p = p[key] + source_provider = p + except (KeyError, AttributeError): + pass + + corners_xy = [ + (xlim[0], ylim[0]), # Bottom-Left + (xlim[0], ylim[1]), # Top-Left + (xlim[1], ylim[0]), # Bottom-Right + (xlim[1], ylim[1]), # Top-Right + ] + req_lats, req_lons = [], [] + + for x, y in corners_xy: + dist = (x**2 + y**2) ** 0.5 + # Calculate bearing: 0 is North (Y), 90 is East (X) + bearing = np.degrees(np.arctan2(x, y)) + lat, lon = inverted_haversine(origin_lat, origin_lon, dist, bearing, earth_radius) + req_lats.append(lat) + req_lons.append(lon) + + west, south, east, north = min(req_lons), min(req_lats), max(req_lons), max(req_lats) + + bg, mercator_extent = contextily.bounds2img( + west, south, east, north, source=source_provider, ll=True + ) + + # Helper: Web Mercator (3857) to WGS84 (4326) without pyproj dependency + def mercator_to_wgs84(x, y): + r_major = 6378137.0 + lon = x / r_major * 180.0 / math.pi + lat = (2 * math.atan(math.exp(y / r_major)) - math.pi / 2.0) * 180.0 / math.pi + return lat, lon + + # Convert corners of the fetched image + bg_lat_min, bg_lon_min = mercator_to_wgs84(mercator_extent[0], mercator_extent[2]) # Bottom-Left + bg_lat_max, bg_lon_max = mercator_to_wgs84(mercator_extent[1], mercator_extent[3]) # Top-Right + + # Calculate X/Y meters relative to origin (lat0, lon0) using haversine + # X = Distance along longitude (East-West) + # Y = Distance along latitude (North-South) + + # Calculate X min (Left) + x_min = haversine(origin_lat, origin_lon, origin_lat, bg_lon_min, earth_radius) + if bg_lon_min < origin_lon: x_min = -x_min + + # Calculate X max (Right) + x_max = haversine(origin_lat, origin_lon, origin_lat, bg_lon_max, earth_radius) + if bg_lon_max < origin_lon: x_max = -x_max + + # Calculate Y min (Bottom) + y_min = haversine(origin_lat, origin_lon, bg_lat_min, origin_lon, earth_radius) + if bg_lat_min < origin_lat: y_min = -y_min + + # Calculate Y max (Top) + y_max = haversine(origin_lat, origin_lon, bg_lat_max, origin_lon, earth_radius) + if bg_lat_max < origin_lat: y_max = -y_max + + return bg, [x_min, x_max, y_min, y_max] + + except Exception as e: + warnings.warn( + f"Unable to fetch background map '{background}'. " + f"Error: {e}. Plotting without background." + ) + return None, None + # pylint: disable=too-many-statements def ellipses( self, image=None, + background=None, actual_landing_point=None, perimeter_size=3000, xlim=(-3000, 3000), @@ -31,6 +158,14 @@ def ellipses( ---------- image : str, optional Path to the background image, usually a map of the launch site. + If both `image` and `background` are provided, `image` takes precedence. + background : str, optional + Type of background map to automatically download and display. + Options: "satellite" (uses Esri.WorldImagery) + "street" (uses OpenStreetMap.Mapnik) + "terrain" (uses Esri.WorldTopoMap) + or any contextily provider name (e.g., "CartoDB.Positron"). + If both `image` and `background` are provided, `image` takes precedence. actual_landing_point : tuple, optional Actual landing point of the rocket in (x, y) meters. perimeter_size : int, optional @@ -59,6 +194,10 @@ def ellipses( "The image file was not found. Please check the path." ) from e + bg ,local_extent = None, None + if image is None and background is not None: + bg, local_extent = self._get_background_map(background, xlim, ylim) + try: apogee_x = np.array(self.monte_carlo.results["apogee_x"]) apogee_y = np.array(self.monte_carlo.results["apogee_y"]) @@ -132,7 +271,6 @@ def ellipses( ax.text(0, 1, "North", va="top", ha="left", transform=north_south_offset) ax.set_ylabel("Y (m)") ax.set_xlabel("X (m)") - # Add background image to plot # TODO: In the future, integrate with other libraries to plot the map (e.g. cartopy, ee, etc.) # You can translate the basemap by changing dx and dy (in meters) @@ -150,10 +288,20 @@ def ellipses( ], ) + elif bg is not None and local_extent is not None: + plt.imshow( + bg, + extent=local_extent, + zorder=0, + interpolation="bilinear" + ) + plt.axhline(0, color="black", linewidth=0.5) plt.axvline(0, color="black", linewidth=0.5) plt.xlim(*xlim) plt.ylim(*ylim) + # Set equal aspect ratio to ensure consistent display regardless of background + ax.set_aspect('equal') if save: plt.savefig( @@ -294,6 +442,7 @@ def ellipses_comparison( self, other_monte_carlo, image=None, + background=None, perimeter_size=3000, xlim=(-3000, 3000), ylim=(-3000, 3000), @@ -308,6 +457,13 @@ def ellipses_comparison( MonteCarlo object which the current one will be compared to. image : str, optional Path to the background image, usually a map of the launch site. + background : str, optional + Type of background map to automatically download and display. + Options: "satellite" (uses Esri.WorldImagery) + "street" (uses OpenStreetMap.Mapnik) + "terrain" (uses Esri.WorldTopoMap) + or any contextily provider name (e.g., "CartoDB.Positron"). + If both `image` and `background` are provided, `image` takes precedence. perimeter_size : int, optional Size of the perimeter to be plotted. Default is 3000. xlim : tuple, optional @@ -333,6 +489,11 @@ def ellipses_comparison( "The image file was not found. Please check the path." ) from e + + bg ,local_extent = None, None + if image is None and background is not None: + bg, local_extent = self._get_background_map(background, xlim, ylim) + try: original_apogee_x = np.array(self.monte_carlo.results["apogee_x"]) original_apogee_y = np.array(self.monte_carlo.results["apogee_y"]) @@ -453,11 +614,19 @@ def ellipses_comparison( perimeter_size - dy, ], ) + elif bg is not None and local_extent is not None: + plt.imshow( + bg, + extent=local_extent, + zorder=0, + interpolation="bilinear" + ) plt.axhline(0, color="black", linewidth=0.5) plt.axvline(0, color="black", linewidth=0.5) plt.xlim(*xlim) plt.ylim(*ylim) + plt.aspect('equal') if save: plt.savefig( From 14f924c938fe2c32eb3ccd3b279ba7465882b19f Mon Sep 17 00:00:00 2001 From: x25tang Date: Tue, 2 Dec 2025 07:33:20 +0100 Subject: [PATCH 03/32] DOC: Enhance documentation for _get_background_map method in Monte Carlo plots - Added detailed docstring for the _get_background_map method, outlining parameters, return values, and background map options. - Clarified usage of background types including "satellite", "street", "terrain", and contextily providers. --- rocketpy/plots/monte_carlo_plots.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index a4cb3e981..ee491cc16 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -17,6 +17,29 @@ def __init__(self, monte_carlo): self.monte_carlo = monte_carlo def _get_background_map(self, background, xlim, ylim): + """ + Helper method to get the background map for the Monte Carlo analysis. + + Parameters + ---------- + background : str, optional + Type of background map to automatically download and display. + Options: "satellite" (uses Esri.WorldImagery) + "street" (uses OpenStreetMap.Mapnik) + "terrain" (uses Esri.WorldTopoMap) + or any contextily provider name (e.g., "CartoDB.Positron"). + xlim : tuple + Limits of the x-axis. Default is (-3000, 3000). Values in meters. + ylim : tuple + Limits of the y-axis. Default is (-3000, 3000). Values in meters. + + Returns + ------- + bg : ndarray + Image as a 3D array of RGB values + extent : tuple + Bounding box [minX, maxX, minY, maxY] of the returned image + """ if background is None: return None, None else: From e7e8bfcd09e7bb56acbc925508c23225e99501db Mon Sep 17 00:00:00 2001 From: x25tang Date: Tue, 2 Dec 2025 07:35:36 +0100 Subject: [PATCH 04/32] MNT: Move imageio import to conditional block in _MonteCarloPlots class - Moved the import of imageio to be conditional upon the presence of an image, improving dependency management. - This change ensures that imageio is only imported when necessary, optimizing performance and reducing unnecessary imports. --- rocketpy/plots/monte_carlo_plots.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index ee491cc16..35627a917 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -206,10 +206,9 @@ def ellipses( None """ - imageio = import_optional_dependency("imageio") - # Import background map if image is not None: + imageio = import_optional_dependency("imageio") try: img = imageio.imread(image) except FileNotFoundError as e: @@ -501,10 +500,10 @@ def ellipses_comparison( ------- None """ - imageio = import_optional_dependency("imageio") # Import background map if image is not None: + imageio = import_optional_dependency("imageio") try: img = imageio.imread(image) except FileNotFoundError as e: # pragma no cover From 3ca9159801c66a7cfb511e0fd1a916a04aadb777 Mon Sep 17 00:00:00 2001 From: x25tang Date: Tue, 2 Dec 2025 07:39:47 +0100 Subject: [PATCH 05/32] TST: Add unit tests for ellipses background functionality in Monte Carlo plots - Introduced a new test file to validate the behavior of the `ellipses` method with various background options including None, satellite, street, terrain, and custom providers. - Implemented tests to ensure proper error handling when the MonteCarlo object lacks necessary attributes. - Added checks for warnings when contextily is not installed and verified that images take precedence over backgrounds. --- .../test_monte_carlo_plots_background.py | 273 ++++++++++++++++++ 1 file changed, 273 insertions(+) create mode 100644 tests/unit/simulation/test_monte_carlo_plots_background.py diff --git a/tests/unit/simulation/test_monte_carlo_plots_background.py b/tests/unit/simulation/test_monte_carlo_plots_background.py new file mode 100644 index 000000000..584f9dd70 --- /dev/null +++ b/tests/unit/simulation/test_monte_carlo_plots_background.py @@ -0,0 +1,273 @@ +# pylint: disable=unused-argument +import os +import warnings +from unittest.mock import MagicMock, patch + +import matplotlib.pyplot as plt +import pytest + +plt.rcParams.update({"figure.max_open_warning": 0}) + + +def _post_test_file_cleanup(): + """Clean monte carlo files after test session if they exist.""" + files_to_cleanup = [ + "monte_carlo_test.png", + ] + for filepath in files_to_cleanup: + if os.path.exists(filepath): + os.remove(filepath) + + +@patch("matplotlib.pyplot.show") +def test_ellipses_background_none(mock_show, monte_carlo_calisto_pre_loaded): + """Test default behavior when background=None (no background map displayed). + + Parameters + ---------- + mock_show : + Mocks the matplotlib.pyplot.show() function to avoid showing the plots. + monte_carlo_calisto_pre_loaded : MonteCarlo + The MonteCarlo object, this is a pytest fixture. + """ + try: + # Test that background=None does not raise an error + result = monte_carlo_calisto_pre_loaded.plots.ellipses(background=None) + assert result is None + finally: + _post_test_file_cleanup() + + +@patch("matplotlib.pyplot.show") +def test_ellipses_background_satellite(mock_show, monte_carlo_calisto_pre_loaded): + """Test using satellite map when background="satellite". + + Parameters + ---------- + mock_show : + Mocks the matplotlib.pyplot.show() function to avoid showing the plots. + monte_carlo_calisto_pre_loaded : MonteCarlo + The MonteCarlo object, this is a pytest fixture. + """ + try: + # Test that background="satellite" does not raise an error + result = monte_carlo_calisto_pre_loaded.plots.ellipses(background="satellite") + assert result is None + finally: + _post_test_file_cleanup() + + +@patch("matplotlib.pyplot.show") +def test_ellipses_background_street(mock_show, monte_carlo_calisto_pre_loaded): + """Test using street map when background="street". + + Parameters + ---------- + mock_show : + Mocks the matplotlib.pyplot.show() function to avoid showing the plots. + monte_carlo_calisto_pre_loaded : MonteCarlo + The MonteCarlo object, this is a pytest fixture. + """ + try: + # Test that background="street" does not raise an error + result = monte_carlo_calisto_pre_loaded.plots.ellipses(background="street") + assert result is None + finally: + _post_test_file_cleanup() + + +@patch("matplotlib.pyplot.show") +def test_ellipses_background_terrain(mock_show, monte_carlo_calisto_pre_loaded): + """Test using terrain map when background="terrain". + + Parameters + ---------- + mock_show : + Mocks the matplotlib.pyplot.show() function to avoid showing the plots. + monte_carlo_calisto_pre_loaded : MonteCarlo + The MonteCarlo object, this is a pytest fixture. + """ + try: + # Test that background="terrain" does not raise an error + result = monte_carlo_calisto_pre_loaded.plots.ellipses(background="terrain") + assert result is None + finally: + _post_test_file_cleanup() + + +@patch("matplotlib.pyplot.show") +def test_ellipses_background_custom_provider(mock_show, monte_carlo_calisto_pre_loaded): + """Test using custom contextily provider for background. + + Parameters + ---------- + mock_show : + Mocks the matplotlib.pyplot.show() function to avoid showing the plots. + monte_carlo_calisto_pre_loaded : MonteCarlo + The MonteCarlo object, this is a pytest fixture. + """ + try: + # Test that custom provider does not raise an error + result = monte_carlo_calisto_pre_loaded.plots.ellipses( + background="CartoDB.Positron" + ) + assert result is None + finally: + _post_test_file_cleanup() + + +@patch("matplotlib.pyplot.show") +def test_ellipses_image_takes_precedence_over_background( + mock_show, monte_carlo_calisto_pre_loaded, tmp_path +): + """Test that image takes precedence when both image and background are provided. + + Parameters + ---------- + mock_show : + Mocks the matplotlib.pyplot.show() function to avoid showing the plots. + monte_carlo_calisto_pre_loaded : MonteCarlo + The MonteCarlo object, this is a pytest fixture. + tmp_path : + pytest fixture providing a temporary directory. + """ + try: + dummy_image_path = tmp_path / "dummy_image.png" + dummy_image_path.write_bytes(b"dummy") + + # Test that when both image and background are provided, image takes precedence + # This should not attempt to download background map + import numpy as np + mock_image = np.zeros((100, 100, 3), dtype=np.uint8) # RGB image + + with patch("imageio.imread") as mock_imread: + mock_imread.return_value = mock_image + result = monte_carlo_calisto_pre_loaded.plots.ellipses( + image=str(dummy_image_path), background="satellite" + ) + assert result is None + mock_imread.assert_called_once() + finally: + _post_test_file_cleanup() + + +def test_ellipses_background_no_environment(): + """Test that ValueError is raised when MonteCarlo object has no environment attribute. + + This test creates a MonteCarlo object without an environment attribute. + """ + from rocketpy.plots.monte_carlo_plots import _MonteCarloPlots + + class MockMonteCarlo: + def __init__(self): + self.results = { + "apogee_x": [100, 200, 300], + "apogee_y": [100, 200, 300], + "x_impact": [1000, 2000, 3000], + "y_impact": [1000, 2000, 3000], + } + self.filename = "test" + + mock_monte_carlo = MockMonteCarlo() + plots = _MonteCarloPlots(mock_monte_carlo) + + with pytest.raises(ValueError, match="MonteCarlo object must have an 'environment' attribute"): + plots.ellipses(background="satellite") + + +def test_ellipses_background_no_latitude_longitude(): + """Test that ValueError is raised when environment has no latitude or longitude attributes. + + This test creates a mock environment without latitude and longitude attributes. + """ + from rocketpy.plots.monte_carlo_plots import _MonteCarloPlots + + mock_environment = MagicMock() + delattr(mock_environment, "latitude") + delattr(mock_environment, "longitude") + + mock_monte_carlo = MagicMock() + mock_monte_carlo.environment = mock_environment + + plots = _MonteCarloPlots(mock_monte_carlo) + + with pytest.raises(ValueError, match="Environment must have 'latitude' and 'longitude' attributes"): + plots.ellipses(background="satellite") + + +@patch("matplotlib.pyplot.show") +def test_ellipses_background_contextily_not_installed(mock_show, monte_carlo_calisto_pre_loaded): + """Test that a warning is issued when contextily is not installed. + + Parameters + ---------- + mock_show : + Mocks the matplotlib.pyplot.show() function to avoid showing the plots. + monte_carlo_calisto_pre_loaded : MonteCarlo + The MonteCarlo object, this is a pytest fixture. + """ + try: + from rocketpy.tools import import_optional_dependency as original_import + + # Create a mock function that only raises exception when importing contextily + def mock_import_optional_dependency(name): + if name == "contextily": + raise ImportError("No module named 'contextily'") + return original_import(name) + + with patch("rocketpy.plots.monte_carlo_plots.import_optional_dependency", side_effect=mock_import_optional_dependency): + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + result = monte_carlo_calisto_pre_loaded.plots.ellipses(background="satellite") + assert result is None + assert len(w) > 0 + assert any("contextily" in str(warning.message).lower() for warning in w) + finally: + _post_test_file_cleanup() + + +@patch("matplotlib.pyplot.show") +def test_ellipses_background_with_custom_xlim_ylim(mock_show, monte_carlo_calisto_pre_loaded): + """Test using background with custom xlim and ylim. + + Parameters + ---------- + mock_show : + Mocks the matplotlib.pyplot.show() function to avoid showing the plots. + monte_carlo_calisto_pre_loaded : MonteCarlo + The MonteCarlo object, this is a pytest fixture. + """ + try: + # Test using custom xlim and ylim + result = monte_carlo_calisto_pre_loaded.plots.ellipses( + background="satellite", + xlim=(-5000, 5000), + ylim=(-5000, 5000), + ) + assert result is None + finally: + _post_test_file_cleanup() + + +@patch("matplotlib.pyplot.show") +def test_ellipses_background_save(mock_show, monte_carlo_calisto_pre_loaded): + """Test using background with save=True. + + Parameters + ---------- + mock_show : + Mocks the matplotlib.pyplot.show() function to avoid showing the plots. + monte_carlo_calisto_pre_loaded : MonteCarlo + The MonteCarlo object, this is a pytest fixture. + """ + try: + # Test save functionality + result = monte_carlo_calisto_pre_loaded.plots.ellipses( + background="satellite", save=True + ) + assert result is None + # Verify file was created + assert os.path.exists("monte_carlo_test.png") + finally: + _post_test_file_cleanup() + From 30ddaa0f72c84a8e2d7a941b9e218b7c61b4407d Mon Sep 17 00:00:00 2001 From: x25tang Date: Tue, 2 Dec 2025 07:40:23 +0100 Subject: [PATCH 06/32] TST: Add integration test for Monte Carlo background map options at Kennedy Space Center - Introduced a new test script to visualize and validate various background map options for Monte Carlo simulations at Kennedy Space Center. - The script generates simulated data and tests background options including None, satellite, street, terrain, and custom providers, saving the results as images. --- ...st_monte_carlo_plots_background_kennedy.py | 160 ++++++++++++++++++ 1 file changed, 160 insertions(+) create mode 100644 tests/integration/simulation/test_monte_carlo_plots_background_kennedy.py diff --git a/tests/integration/simulation/test_monte_carlo_plots_background_kennedy.py b/tests/integration/simulation/test_monte_carlo_plots_background_kennedy.py new file mode 100644 index 000000000..71dd99ac9 --- /dev/null +++ b/tests/integration/simulation/test_monte_carlo_plots_background_kennedy.py @@ -0,0 +1,160 @@ +"""Test script to visualize different background map options at Kennedy Space Center. + +This script creates simulated Monte Carlo data for Kennedy Space Center +and tests all background map options, saving the results as images. +""" + +import os +import numpy as np +import matplotlib.pyplot as plt +from datetime import datetime, timedelta + +from rocketpy import Environment +from rocketpy.simulation import MonteCarlo +from rocketpy.stochastic import StochasticEnvironment + +plt.rcParams.update({"figure.max_open_warning": 0}) + + +def create_kennedy_environment(): + """Create an Environment object for Kennedy Space Center. + + Kennedy Space Center coordinates: + - Latitude: 28.5721° N + - Longitude: -80.6480° W + - Elevation: ~3 meters + + Returns + ------- + Environment + Environment object configured for Kennedy Space Center. + """ + env = Environment( + latitude=28.5721, + longitude=-80.6480, + elevation=3.0, + datum="WGS84", + ) + # Set a date for the environment (tomorrow at noon UTC) + tomorrow = datetime.now() + timedelta(days=1) + # Use tuple format: (year, month, day, hour) + env.set_date((tomorrow.year, tomorrow.month, tomorrow.day, 12), timezone="UTC") + return env + + +def create_simulated_monte_carlo_data(): + """Create a MonteCarlo object with simulated results data. + + Returns + ------- + MonteCarlo + MonteCarlo object with simulated apogee and impact data. + """ + # Create environment for Kennedy Space Center + env = create_kennedy_environment() + + # Create stochastic environment (no randomization for simplicity) + stochastic_env = StochasticEnvironment( + environment=env, + elevation=None, + gravity=None, + latitude=None, + longitude=None, + ) + + + from unittest.mock import MagicMock + + stochastic_rocket = MagicMock() + stochastic_flight = MagicMock() + + monte_carlo = MonteCarlo( + filename="kennedy_space_center_test", + environment=stochastic_env, + rocket=stochastic_rocket, + flight=stochastic_flight, + ) + + # Generate simulated Monte Carlo results + # Simulate 50 data points with realistic dispersion + np.random.seed(42) # For reproducibility + + # Simulate apogee points (scattered around origin with some dispersion) + n_points = 50 + apogee_x = np.random.normal(0, 500, n_points) # meters, std dev 500m + apogee_y = np.random.normal(0, 500, n_points) # meters, std dev 500m + + # Simulate impact points (further from origin, more dispersion) + impact_x = np.random.normal(2000, 1000, n_points) # meters, mean 2km, std dev 1km + impact_y = np.random.normal(1500, 1000, n_points) # meters, mean 1.5km, std dev 1km + + monte_carlo.results = { + "apogee_x": apogee_x.tolist(), + "apogee_y": apogee_y.tolist(), + "x_impact": impact_x.tolist(), + "y_impact": impact_y.tolist(), + } + + return monte_carlo + + +def test_all_background_options(): + """Test all background map options and save images. + + This function tests: + - None (no background) + - satellite + - street + - terrain + - custom provider (CartoDB.Positron) + """ + output_dir = "kennedy_background_tests" + os.makedirs(output_dir, exist_ok=True) + + monte_carlo = create_simulated_monte_carlo_data() + + background_options = [ + (None, "no_background"), + ("satellite", "satellite"), + ("street", "street"), + ("terrain", "terrain"), + ("CartoDB.Positron", "cartodb_positron"), + ] + + print(f"Testing {len(background_options)} background options...") + print(f"Output directory: {output_dir}/") + + for background, name in background_options: + try: + print(f" Testing {name}...", end=" ") + + # Temporarily change filename to save with desired name + original_filename = monte_carlo.filename + monte_carlo.filename = os.path.join(output_dir, f"kennedy_{name}") + + try: + monte_carlo.plots.ellipses( + background=background, + xlim=(-5000, 5000), + ylim=(-5000, 5000), + save=True, + ) + + # Check if file was created + expected_file = f"{monte_carlo.filename}.png" + if os.path.exists(expected_file): + print(f"✓ Saved to {expected_file}") + else: + print("✗ Failed to save") + finally: + # Restore original filename + monte_carlo.filename = original_filename + + except (ValueError, ImportError, OSError) as e: + print(f"✗ Error: {str(e)}") + + print(f"\nAll tests completed! Check the '{output_dir}/' directory for results.") + + +if __name__ == "__main__": + test_all_background_options() \ No newline at end of file From f026acc334d0f8f94c8791596a06d908fb6a0b98 Mon Sep 17 00:00:00 2001 From: x25tang Date: Tue, 2 Dec 2025 08:11:02 +0100 Subject: [PATCH 07/32] DOC: Updated CHANGELOG.md --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index abca56e18..9bcbb8196 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -31,7 +31,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/). Attention: The newest changes should be on top --> ### Added - +- ENH: Add background map auto download functionality to Monte Carlo plots [#896](https://github.com/RocketPy-Team/RocketPy/pull/896) - MNT: net thrust addition to 3 dof in flight class [#907] (https://github.com/RocketPy-Team/RocketPy/pull/907) - ENH: 3-dof lateral motion improvement [#883](https://github.com/RocketPy-Team/RocketPy/pull/883) - ENH: Add multi-dimensional drag coefficient support (Cd as function of M, Re, α) [#875](https://github.com/RocketPy-Team/RocketPy/pull/875) From 8ccdfb79439be05fa857c3f0297af4949d3f51bd Mon Sep 17 00:00:00 2001 From: x25tang Date: Tue, 2 Dec 2025 08:15:14 +0100 Subject: [PATCH 08/32] STY: Reformat with black --- rocketpy/plots/monte_carlo_plots.py | 85 ++++++++++++------- ...st_monte_carlo_plots_background_kennedy.py | 11 ++- .../test_monte_carlo_plots_background.py | 33 +++++-- 3 files changed, 82 insertions(+), 47 deletions(-) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index 35627a917..d5def427e 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -6,7 +6,12 @@ import numpy as np from matplotlib.transforms import offset_copy -from ..tools import generate_monte_carlo_ellipses, import_optional_dependency, inverted_haversine, haversine +from ..tools import ( + generate_monte_carlo_ellipses, + import_optional_dependency, + inverted_haversine, + haversine, +) from .plot_helpers import show_or_save_plot @@ -50,7 +55,7 @@ def _get_background_map(self, background, xlim, ylim): "contextily library is required for automatic map background. " "Install it via 'pip install contextily' or 'pip install rocketpy[monte-carlo]'. " "Plotting without background.", - UserWarning + UserWarning, ) return None, None @@ -113,11 +118,18 @@ def _get_background_map(self, background, xlim, ylim): dist = (x**2 + y**2) ** 0.5 # Calculate bearing: 0 is North (Y), 90 is East (X) bearing = np.degrees(np.arctan2(x, y)) - lat, lon = inverted_haversine(origin_lat, origin_lon, dist, bearing, earth_radius) + lat, lon = inverted_haversine( + origin_lat, origin_lon, dist, bearing, earth_radius + ) req_lats.append(lat) req_lons.append(lon) - west, south, east, north = min(req_lons), min(req_lats), max(req_lons), max(req_lats) + west, south, east, north = ( + min(req_lons), + min(req_lats), + max(req_lons), + max(req_lats), + ) bg, mercator_extent = contextily.bounds2img( west, south, east, north, source=source_provider, ll=True @@ -127,32 +139,52 @@ def _get_background_map(self, background, xlim, ylim): def mercator_to_wgs84(x, y): r_major = 6378137.0 lon = x / r_major * 180.0 / math.pi - lat = (2 * math.atan(math.exp(y / r_major)) - math.pi / 2.0) * 180.0 / math.pi + lat = ( + (2 * math.atan(math.exp(y / r_major)) - math.pi / 2.0) + * 180.0 + / math.pi + ) return lat, lon # Convert corners of the fetched image - bg_lat_min, bg_lon_min = mercator_to_wgs84(mercator_extent[0], mercator_extent[2]) # Bottom-Left - bg_lat_max, bg_lon_max = mercator_to_wgs84(mercator_extent[1], mercator_extent[3]) # Top-Right + bg_lat_min, bg_lon_min = mercator_to_wgs84( + mercator_extent[0], mercator_extent[2] + ) # Bottom-Left + bg_lat_max, bg_lon_max = mercator_to_wgs84( + mercator_extent[1], mercator_extent[3] + ) # Top-Right # Calculate X/Y meters relative to origin (lat0, lon0) using haversine # X = Distance along longitude (East-West) # Y = Distance along latitude (North-South) # Calculate X min (Left) - x_min = haversine(origin_lat, origin_lon, origin_lat, bg_lon_min, earth_radius) - if bg_lon_min < origin_lon: x_min = -x_min + x_min = haversine( + origin_lat, origin_lon, origin_lat, bg_lon_min, earth_radius + ) + if bg_lon_min < origin_lon: + x_min = -x_min # Calculate X max (Right) - x_max = haversine(origin_lat, origin_lon, origin_lat, bg_lon_max, earth_radius) - if bg_lon_max < origin_lon: x_max = -x_max + x_max = haversine( + origin_lat, origin_lon, origin_lat, bg_lon_max, earth_radius + ) + if bg_lon_max < origin_lon: + x_max = -x_max # Calculate Y min (Bottom) - y_min = haversine(origin_lat, origin_lon, bg_lat_min, origin_lon, earth_radius) - if bg_lat_min < origin_lat: y_min = -y_min + y_min = haversine( + origin_lat, origin_lon, bg_lat_min, origin_lon, earth_radius + ) + if bg_lat_min < origin_lat: + y_min = -y_min # Calculate Y max (Top) - y_max = haversine(origin_lat, origin_lon, bg_lat_max, origin_lon, earth_radius) - if bg_lat_max < origin_lat: y_max = -y_max + y_max = haversine( + origin_lat, origin_lon, bg_lat_max, origin_lon, earth_radius + ) + if bg_lat_max < origin_lat: + y_max = -y_max return bg, [x_min, x_max, y_min, y_max] @@ -216,7 +248,7 @@ def ellipses( "The image file was not found. Please check the path." ) from e - bg ,local_extent = None, None + bg, local_extent = None, None if image is None and background is not None: bg, local_extent = self._get_background_map(background, xlim, ylim) @@ -311,19 +343,14 @@ def ellipses( ) elif bg is not None and local_extent is not None: - plt.imshow( - bg, - extent=local_extent, - zorder=0, - interpolation="bilinear" - ) + plt.imshow(bg, extent=local_extent, zorder=0, interpolation="bilinear") plt.axhline(0, color="black", linewidth=0.5) plt.axvline(0, color="black", linewidth=0.5) plt.xlim(*xlim) plt.ylim(*ylim) # Set equal aspect ratio to ensure consistent display regardless of background - ax.set_aspect('equal') + ax.set_aspect("equal") if save: plt.savefig( @@ -511,8 +538,7 @@ def ellipses_comparison( "The image file was not found. Please check the path." ) from e - - bg ,local_extent = None, None + bg, local_extent = None, None if image is None and background is not None: bg, local_extent = self._get_background_map(background, xlim, ylim) @@ -637,18 +663,13 @@ def ellipses_comparison( ], ) elif bg is not None and local_extent is not None: - plt.imshow( - bg, - extent=local_extent, - zorder=0, - interpolation="bilinear" - ) + plt.imshow(bg, extent=local_extent, zorder=0, interpolation="bilinear") plt.axhline(0, color="black", linewidth=0.5) plt.axvline(0, color="black", linewidth=0.5) plt.xlim(*xlim) plt.ylim(*ylim) - plt.aspect('equal') + plt.aspect("equal") if save: plt.savefig( diff --git a/tests/integration/simulation/test_monte_carlo_plots_background_kennedy.py b/tests/integration/simulation/test_monte_carlo_plots_background_kennedy.py index 71dd99ac9..d24f29680 100644 --- a/tests/integration/simulation/test_monte_carlo_plots_background_kennedy.py +++ b/tests/integration/simulation/test_monte_carlo_plots_background_kennedy.py @@ -18,12 +18,12 @@ def create_kennedy_environment(): """Create an Environment object for Kennedy Space Center. - + Kennedy Space Center coordinates: - Latitude: 28.5721° N - Longitude: -80.6480° W - Elevation: ~3 meters - + Returns ------- Environment @@ -44,7 +44,7 @@ def create_kennedy_environment(): def create_simulated_monte_carlo_data(): """Create a MonteCarlo object with simulated results data. - + Returns ------- MonteCarlo @@ -62,7 +62,6 @@ def create_simulated_monte_carlo_data(): longitude=None, ) - from unittest.mock import MagicMock stochastic_rocket = MagicMock() @@ -100,7 +99,7 @@ def create_simulated_monte_carlo_data(): def test_all_background_options(): """Test all background map options and save images. - + This function tests: - None (no background) - satellite @@ -157,4 +156,4 @@ def test_all_background_options(): if __name__ == "__main__": - test_all_background_options() \ No newline at end of file + test_all_background_options() diff --git a/tests/unit/simulation/test_monte_carlo_plots_background.py b/tests/unit/simulation/test_monte_carlo_plots_background.py index 584f9dd70..1c670b630 100644 --- a/tests/unit/simulation/test_monte_carlo_plots_background.py +++ b/tests/unit/simulation/test_monte_carlo_plots_background.py @@ -138,8 +138,9 @@ def test_ellipses_image_takes_precedence_over_background( # Test that when both image and background are provided, image takes precedence # This should not attempt to download background map import numpy as np + mock_image = np.zeros((100, 100, 3), dtype=np.uint8) # RGB image - + with patch("imageio.imread") as mock_imread: mock_imread.return_value = mock_image result = monte_carlo_calisto_pre_loaded.plots.ellipses( @@ -171,7 +172,9 @@ def __init__(self): mock_monte_carlo = MockMonteCarlo() plots = _MonteCarloPlots(mock_monte_carlo) - with pytest.raises(ValueError, match="MonteCarlo object must have an 'environment' attribute"): + with pytest.raises( + ValueError, match="MonteCarlo object must have an 'environment' attribute" + ): plots.ellipses(background="satellite") @@ -191,12 +194,16 @@ def test_ellipses_background_no_latitude_longitude(): plots = _MonteCarloPlots(mock_monte_carlo) - with pytest.raises(ValueError, match="Environment must have 'latitude' and 'longitude' attributes"): + with pytest.raises( + ValueError, match="Environment must have 'latitude' and 'longitude' attributes" + ): plots.ellipses(background="satellite") @patch("matplotlib.pyplot.show") -def test_ellipses_background_contextily_not_installed(mock_show, monte_carlo_calisto_pre_loaded): +def test_ellipses_background_contextily_not_installed( + mock_show, monte_carlo_calisto_pre_loaded +): """Test that a warning is issued when contextily is not installed. Parameters @@ -215,19 +222,28 @@ def mock_import_optional_dependency(name): raise ImportError("No module named 'contextily'") return original_import(name) - with patch("rocketpy.plots.monte_carlo_plots.import_optional_dependency", side_effect=mock_import_optional_dependency): + with patch( + "rocketpy.plots.monte_carlo_plots.import_optional_dependency", + side_effect=mock_import_optional_dependency, + ): with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") - result = monte_carlo_calisto_pre_loaded.plots.ellipses(background="satellite") + result = monte_carlo_calisto_pre_loaded.plots.ellipses( + background="satellite" + ) assert result is None assert len(w) > 0 - assert any("contextily" in str(warning.message).lower() for warning in w) + assert any( + "contextily" in str(warning.message).lower() for warning in w + ) finally: _post_test_file_cleanup() @patch("matplotlib.pyplot.show") -def test_ellipses_background_with_custom_xlim_ylim(mock_show, monte_carlo_calisto_pre_loaded): +def test_ellipses_background_with_custom_xlim_ylim( + mock_show, monte_carlo_calisto_pre_loaded +): """Test using background with custom xlim and ylim. Parameters @@ -270,4 +286,3 @@ def test_ellipses_background_save(mock_show, monte_carlo_calisto_pre_loaded): assert os.path.exists("monte_carlo_test.png") finally: _post_test_file_cleanup() - From 7036aec6090e4830baf925bca6f166a81f57b6ae Mon Sep 17 00:00:00 2001 From: x25tang Date: Tue, 2 Dec 2025 08:40:51 +0100 Subject: [PATCH 09/32] MNT: Fix wrong usage for set_aspect in _MonteCarloPlots.ellipses_comparison --- rocketpy/plots/monte_carlo_plots.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index d5def427e..a04768829 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -669,7 +669,7 @@ def ellipses_comparison( plt.axvline(0, color="black", linewidth=0.5) plt.xlim(*xlim) plt.ylim(*ylim) - plt.aspect("equal") + ax.set_aspect("equal") if save: plt.savefig( From 408af47e89ea576a06b886b1efd5a548541c039e Mon Sep 17 00:00:00 2001 From: x25tang Date: Wed, 3 Dec 2025 20:26:12 +0100 Subject: [PATCH 10/32] MNT: Refactor _get_background_map in _MonteCarloPlots class - Removed unnecessary else statements and improved indentation issues. --- rocketpy/plots/monte_carlo_plots.py | 273 ++++++++++++++-------------- 1 file changed, 136 insertions(+), 137 deletions(-) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index a04768829..9cbd1c76b 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -1,6 +1,6 @@ import math -from pathlib import Path import warnings +from pathlib import Path import matplotlib.pyplot as plt import numpy as np @@ -8,9 +8,9 @@ from ..tools import ( generate_monte_carlo_ellipses, + haversine, import_optional_dependency, inverted_haversine, - haversine, ) from .plot_helpers import show_or_save_plot @@ -47,153 +47,152 @@ def _get_background_map(self, background, xlim, ylim): """ if background is None: return None, None - else: - try: - contextily = import_optional_dependency("contextily") - except ImportError: - warnings.warn( - "contextily library is required for automatic map background. " - "Install it via 'pip install contextily' or 'pip install rocketpy[monte-carlo]'. " - "Plotting without background.", - UserWarning, - ) - return None, None - if not hasattr(self.monte_carlo, "environment"): - raise ValueError( - "MonteCarlo object must have an 'environment' attribute " - "to use automatic map background." - ) - env = self.monte_carlo.environment - if not hasattr(env, "latitude") or not hasattr(env, "longitude"): - raise ValueError( - "Environment must have 'latitude' and 'longitude' attributes." - ) + try: + contextily = import_optional_dependency("contextily") + except ImportError: + warnings.warn( + "contextily library is required for automatic map background. " + "Install it via 'pip install contextily' or 'pip install rocketpy[monte-carlo]'. " + "Plotting without background.", + UserWarning, + ) + return None, None - try: + if not hasattr(self.monte_carlo, "environment"): + raise ValueError( + "MonteCarlo object must have an 'environment' attribute " + "to use automatic map background." + ) + env = self.monte_carlo.environment + if not hasattr(env, "latitude") or not hasattr(env, "longitude"): + raise ValueError( + "Environment must have 'latitude' and 'longitude' attributes." + ) - # Handle both StochasticEnvironment (which stores as lists) and Environment (which stores as scalars) - origin_lat = env.latitude - origin_lon = env.longitude - if isinstance(origin_lat, (list, tuple)): - origin_lat = origin_lat[0] - if isinstance(origin_lon, (list, tuple)): - origin_lon = origin_lon[0] - # Get earth_radius from the underlying Environment object if available - if hasattr(env, "obj") and hasattr(env.obj, "earth_radius"): - earth_radius = env.obj.earth_radius - else: - earth_radius = getattr(env, "earth_radius", 6.3781e6) - - if background == "satellite": - map_provider = "Esri.WorldImagery" - elif background == "street": - map_provider = "OpenStreetMap.Mapnik" - elif background == "terrain": - map_provider = "Esri.WorldTopoMap" - else: - map_provider = background - - # Helper to resolve provider string (e.g., "Esri.WorldImagery") to object - source_provider = map_provider - if isinstance(map_provider, str): - try: - # Attempt to traverse contextily.providers - p = contextily.providers - for key in map_provider.split("."): - p = p[key] - source_provider = p - except (KeyError, AttributeError): - pass - - corners_xy = [ - (xlim[0], ylim[0]), # Bottom-Left - (xlim[0], ylim[1]), # Top-Left - (xlim[1], ylim[0]), # Bottom-Right - (xlim[1], ylim[1]), # Top-Right - ] - req_lats, req_lons = [], [] - - for x, y in corners_xy: - dist = (x**2 + y**2) ** 0.5 - # Calculate bearing: 0 is North (Y), 90 is East (X) - bearing = np.degrees(np.arctan2(x, y)) - lat, lon = inverted_haversine( - origin_lat, origin_lon, dist, bearing, earth_radius - ) - req_lats.append(lat) - req_lons.append(lon) - - west, south, east, north = ( - min(req_lons), - min(req_lats), - max(req_lons), - max(req_lats), + try: + # Handle both StochasticEnvironment (which stores as lists) and Environment (which stores as scalars) + origin_lat = env.latitude + origin_lon = env.longitude + if isinstance(origin_lat, (list, tuple)): + origin_lat = origin_lat[0] + if isinstance(origin_lon, (list, tuple)): + origin_lon = origin_lon[0] + # Get earth_radius from the underlying Environment object if available + if hasattr(env, "obj") and hasattr(env.obj, "earth_radius"): + earth_radius = env.obj.earth_radius + else: + earth_radius = getattr(env, "earth_radius", 6.3781e6) + + if background == "satellite": + map_provider = "Esri.WorldImagery" + elif background == "street": + map_provider = "OpenStreetMap.Mapnik" + elif background == "terrain": + map_provider = "Esri.WorldTopoMap" + else: + map_provider = background + + # Helper to resolve provider string (e.g., "Esri.WorldImagery") to object + source_provider = map_provider + if isinstance(map_provider, str): + try: + # Attempt to traverse contextily.providers + p = contextily.providers + for key in map_provider.split("."): + p = p[key] + source_provider = p + except (KeyError, AttributeError): + pass + + corners_xy = [ + (xlim[0], ylim[0]), # Bottom-Left + (xlim[0], ylim[1]), # Top-Left + (xlim[1], ylim[0]), # Bottom-Right + (xlim[1], ylim[1]), # Top-Right + ] + req_lats, req_lons = [], [] + + for x, y in corners_xy: + dist = (x**2 + y**2) ** 0.5 + # Calculate bearing: 0 is North (Y), 90 is East (X) + bearing = np.degrees(np.arctan2(x, y)) + lat, lon = inverted_haversine( + origin_lat, origin_lon, dist, bearing, earth_radius ) + req_lats.append(lat) + req_lons.append(lon) + + west, south, east, north = ( + min(req_lons), + min(req_lats), + max(req_lons), + max(req_lats), + ) - bg, mercator_extent = contextily.bounds2img( - west, south, east, north, source=source_provider, ll=True - ) + bg, mercator_extent = contextily.bounds2img( + west, south, east, north, source=source_provider, ll=True + ) - # Helper: Web Mercator (3857) to WGS84 (4326) without pyproj dependency - def mercator_to_wgs84(x, y): - r_major = 6378137.0 - lon = x / r_major * 180.0 / math.pi - lat = ( - (2 * math.atan(math.exp(y / r_major)) - math.pi / 2.0) - * 180.0 - / math.pi - ) - return lat, lon - - # Convert corners of the fetched image - bg_lat_min, bg_lon_min = mercator_to_wgs84( - mercator_extent[0], mercator_extent[2] - ) # Bottom-Left - bg_lat_max, bg_lon_max = mercator_to_wgs84( - mercator_extent[1], mercator_extent[3] - ) # Top-Right - - # Calculate X/Y meters relative to origin (lat0, lon0) using haversine - # X = Distance along longitude (East-West) - # Y = Distance along latitude (North-South) - - # Calculate X min (Left) - x_min = haversine( - origin_lat, origin_lon, origin_lat, bg_lon_min, earth_radius + # Helper: Web Mercator (3857) to WGS84 (4326) without pyproj dependency + def mercator_to_wgs84(x, y): + r_major = 6378137.0 + lon = x / r_major * 180.0 / math.pi + lat = ( + (2 * math.atan(math.exp(y / r_major)) - math.pi / 2.0) + * 180.0 + / math.pi ) - if bg_lon_min < origin_lon: - x_min = -x_min + return lat, lon + + # Convert corners of the fetched image + bg_lat_min, bg_lon_min = mercator_to_wgs84( + mercator_extent[0], mercator_extent[2] + ) # Bottom-Left + bg_lat_max, bg_lon_max = mercator_to_wgs84( + mercator_extent[1], mercator_extent[3] + ) # Top-Right + + # Calculate X/Y meters relative to origin (lat0, lon0) using haversine + # X = Distance along longitude (East-West) + # Y = Distance along latitude (North-South) + + # Calculate X min (Left) + x_min = haversine( + origin_lat, origin_lon, origin_lat, bg_lon_min, earth_radius + ) + if bg_lon_min < origin_lon: + x_min = -x_min - # Calculate X max (Right) - x_max = haversine( - origin_lat, origin_lon, origin_lat, bg_lon_max, earth_radius - ) - if bg_lon_max < origin_lon: - x_max = -x_max + # Calculate X max (Right) + x_max = haversine( + origin_lat, origin_lon, origin_lat, bg_lon_max, earth_radius + ) + if bg_lon_max < origin_lon: + x_max = -x_max - # Calculate Y min (Bottom) - y_min = haversine( - origin_lat, origin_lon, bg_lat_min, origin_lon, earth_radius - ) - if bg_lat_min < origin_lat: - y_min = -y_min + # Calculate Y min (Bottom) + y_min = haversine( + origin_lat, origin_lon, bg_lat_min, origin_lon, earth_radius + ) + if bg_lat_min < origin_lat: + y_min = -y_min - # Calculate Y max (Top) - y_max = haversine( - origin_lat, origin_lon, bg_lat_max, origin_lon, earth_radius - ) - if bg_lat_max < origin_lat: - y_max = -y_max + # Calculate Y max (Top) + y_max = haversine( + origin_lat, origin_lon, bg_lat_max, origin_lon, earth_radius + ) + if bg_lat_max < origin_lat: + y_max = -y_max - return bg, [x_min, x_max, y_min, y_max] + return bg, [x_min, x_max, y_min, y_max] - except Exception as e: - warnings.warn( - f"Unable to fetch background map '{background}'. " - f"Error: {e}. Plotting without background." - ) - return None, None + except Exception as e: + warnings.warn( + f"Unable to fetch background map '{background}'. " + f"Error: {e}. Plotting without background." + ) + return None, None # pylint: disable=too-many-statements def ellipses( From 2efc13422a90c60b73d06fef00644c667315759d Mon Sep 17 00:00:00 2001 From: x25tang Date: Wed, 3 Dec 2025 20:28:13 +0100 Subject: [PATCH 11/32] MNT: Move mercator_to_wgs84 from_MonteCarloPlots class to tools - Removed the local definition of mercator_to_wgs84 and replaced it with an import from tools. - Updated calls to mercator_to_wgs84 to include the earth_radius parameter for improved accuracy. --- rocketpy/plots/monte_carlo_plots.py | 17 +++------------- rocketpy/tools.py | 30 +++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 14 deletions(-) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index 9cbd1c76b..0e4276a6e 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -1,4 +1,3 @@ -import math import warnings from pathlib import Path @@ -11,6 +10,7 @@ haversine, import_optional_dependency, inverted_haversine, + mercator_to_wgs84, ) from .plot_helpers import show_or_save_plot @@ -134,23 +134,12 @@ def _get_background_map(self, background, xlim, ylim): west, south, east, north, source=source_provider, ll=True ) - # Helper: Web Mercator (3857) to WGS84 (4326) without pyproj dependency - def mercator_to_wgs84(x, y): - r_major = 6378137.0 - lon = x / r_major * 180.0 / math.pi - lat = ( - (2 * math.atan(math.exp(y / r_major)) - math.pi / 2.0) - * 180.0 - / math.pi - ) - return lat, lon - # Convert corners of the fetched image bg_lat_min, bg_lon_min = mercator_to_wgs84( - mercator_extent[0], mercator_extent[2] + mercator_extent[0], mercator_extent[2], earth_radius ) # Bottom-Left bg_lat_max, bg_lon_max = mercator_to_wgs84( - mercator_extent[1], mercator_extent[3] + mercator_extent[1], mercator_extent[3], earth_radius ) # Top-Right # Calculate X/Y meters relative to origin (lat0, lon0) using haversine diff --git a/rocketpy/tools.py b/rocketpy/tools.py index bc80b469c..cf01b2dfc 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -443,6 +443,36 @@ def inverted_haversine(lat0, lon0, distance, bearing, earth_radius=6.3781e6): return lat1_deg, lon1_deg +def mercator_to_wgs84(x, y, earth_radius=6.3781e6): + """Convert Web Mercator (EPSG:3857) coordinates to WGS84 (EPSG:4326) coordinates. + + This function converts coordinates from Web Mercator projection to WGS84 + latitude/longitude without requiring the pyproj dependency. + + Parameters + ---------- + x : float + X coordinate in Web Mercator projection (meters). + y : float + Y coordinate in Web Mercator projection (meters). + earth_radius : float, optional + Earth's radius in meters. Default value is 6.3781e6. + + Returns + ------- + tuple[float, float] + A tuple containing (latitude, longitude) in degrees. + + """ + lon = x / earth_radius * 180.0 / math.pi + lat = ( + (2 * math.atan(math.exp(y / earth_radius)) - math.pi / 2.0) + * 180.0 + / math.pi + ) + return lat, lon + + # Functions for monte carlo analysis def sort_eigenvalues(cov): # Calculate eigenvalues and eigenvectors From 37d49aa2bc38b04c87980fea567abc7aa7a544c7 Mon Sep 17 00:00:00 2001 From: x25tang Date: Wed, 3 Dec 2025 22:12:37 +0100 Subject: [PATCH 12/32] MNT: Decompose _get_background_map and move utilities to tools.py - Refactors `_get_background_map` into modular functions and extracts shared utility logic into `tools.py`. This significantly improves maintainability and separation of concerns. --- rocketpy/plots/monte_carlo_plots.py | 200 +++++++++++++--------------- rocketpy/tools.py | 111 ++++++++++++++- 2 files changed, 196 insertions(+), 115 deletions(-) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index 0e4276a6e..81e78fb94 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -6,11 +6,10 @@ from matplotlib.transforms import offset_copy from ..tools import ( + convert_local_extent_to_wgs84, + convert_mercator_extent_to_local, generate_monte_carlo_ellipses, - haversine, import_optional_dependency, - inverted_haversine, - mercator_to_wgs84, ) from .plot_helpers import show_or_save_plot @@ -21,6 +20,86 @@ class _MonteCarloPlots: def __init__(self, monte_carlo): self.monte_carlo = monte_carlo + def _get_environment_coordinates(self): + """Get origin coordinates and earth radius from the environment. + + Returns + ------- + tuple[float, float, float] + A tuple containing (origin_lat, origin_lon, earth_radius). + + Raises + ------ + ValueError + If MonteCarlo object doesn't have an environment attribute, or if + environment doesn't have latitude and longitude attributes. + """ + if not hasattr(self.monte_carlo, "environment"): + raise ValueError( + "MonteCarlo object must have an 'environment' attribute " + "to use automatic map background." + ) + env = self.monte_carlo.environment + if not hasattr(env, "latitude") or not hasattr(env, "longitude"): + raise ValueError( + "Environment must have 'latitude' and 'longitude' attributes." + ) + + # Handle both StochasticEnvironment (which stores as lists) and + # Environment (which stores as scalars) + origin_lat = env.latitude + origin_lon = env.longitude + if isinstance(origin_lat, (list, tuple)): + origin_lat = origin_lat[0] + if isinstance(origin_lon, (list, tuple)): + origin_lon = origin_lon[0] + + # Get earth_radius from the underlying Environment object if available + if hasattr(env, "obj") and hasattr(env.obj, "earth_radius"): + earth_radius = env.obj.earth_radius + else: + earth_radius = getattr(env, "earth_radius", 6.3781e6) + + return origin_lat, origin_lon, earth_radius + + def _resolve_map_provider(self, background, contextily): + """Resolve the map provider string to a contextily provider object. + + Parameters + ---------- + background : str + Type of background map. Options: "satellite", "street", "terrain", + or any contextily provider name (e.g., "CartoDB.Positron"). + contextily : module + The contextily module. + + Returns + ------- + object + The resolved contextily provider object. + """ + if background == "satellite": + map_provider = "Esri.WorldImagery" + elif background == "street": + map_provider = "OpenStreetMap.Mapnik" + elif background == "terrain": + map_provider = "Esri.WorldTopoMap" + else: + map_provider = background + + # Attempt to resolve provider string (e.g., "Esri.WorldImagery") to object + source_provider = map_provider + if isinstance(map_provider, str): + try: + p = contextily.providers + for key in map_provider.split("."): + p = p[key] + source_provider = p + except (KeyError, AttributeError): + pass + + return source_provider + def _get_background_map(self, background, xlim, ylim): """ Helper method to get the background map for the Monte Carlo analysis. @@ -59,122 +138,23 @@ def _get_background_map(self, background, xlim, ylim): ) return None, None - if not hasattr(self.monte_carlo, "environment"): - raise ValueError( - "MonteCarlo object must have an 'environment' attribute " - "to use automatic map background." - ) - env = self.monte_carlo.environment - if not hasattr(env, "latitude") or not hasattr(env, "longitude"): - raise ValueError( - "Environment must have 'latitude' and 'longitude' attributes." - ) - try: - # Handle both StochasticEnvironment (which stores as lists) and Environment (which stores as scalars) - origin_lat = env.latitude - origin_lon = env.longitude - if isinstance(origin_lat, (list, tuple)): - origin_lat = origin_lat[0] - if isinstance(origin_lon, (list, tuple)): - origin_lon = origin_lon[0] - # Get earth_radius from the underlying Environment object if available - if hasattr(env, "obj") and hasattr(env.obj, "earth_radius"): - earth_radius = env.obj.earth_radius - else: - earth_radius = getattr(env, "earth_radius", 6.3781e6) - - if background == "satellite": - map_provider = "Esri.WorldImagery" - elif background == "street": - map_provider = "OpenStreetMap.Mapnik" - elif background == "terrain": - map_provider = "Esri.WorldTopoMap" - else: - map_provider = background - - # Helper to resolve provider string (e.g., "Esri.WorldImagery") to object - source_provider = map_provider - if isinstance(map_provider, str): - try: - # Attempt to traverse contextily.providers - p = contextily.providers - for key in map_provider.split("."): - p = p[key] - source_provider = p - except (KeyError, AttributeError): - pass - - corners_xy = [ - (xlim[0], ylim[0]), # Bottom-Left - (xlim[0], ylim[1]), # Top-Left - (xlim[1], ylim[0]), # Bottom-Right - (xlim[1], ylim[1]), # Top-Right - ] - req_lats, req_lons = [], [] - - for x, y in corners_xy: - dist = (x**2 + y**2) ** 0.5 - # Calculate bearing: 0 is North (Y), 90 is East (X) - bearing = np.degrees(np.arctan2(x, y)) - lat, lon = inverted_haversine( - origin_lat, origin_lon, dist, bearing, earth_radius - ) - req_lats.append(lat) - req_lons.append(lon) - - west, south, east, north = ( - min(req_lons), - min(req_lats), - max(req_lons), - max(req_lats), + origin_lat, origin_lon, earth_radius = self._get_environment_coordinates() + source_provider = self._resolve_map_provider(background, contextily) + local_extent = [xlim[0], xlim[1], ylim[0], ylim[1]] + west, south, east, north = convert_local_extent_to_wgs84( + local_extent, origin_lat, origin_lon, earth_radius ) bg, mercator_extent = contextily.bounds2img( west, south, east, north, source=source_provider, ll=True ) - # Convert corners of the fetched image - bg_lat_min, bg_lon_min = mercator_to_wgs84( - mercator_extent[0], mercator_extent[2], earth_radius - ) # Bottom-Left - bg_lat_max, bg_lon_max = mercator_to_wgs84( - mercator_extent[1], mercator_extent[3], earth_radius - ) # Top-Right - - # Calculate X/Y meters relative to origin (lat0, lon0) using haversine - # X = Distance along longitude (East-West) - # Y = Distance along latitude (North-South) - - # Calculate X min (Left) - x_min = haversine( - origin_lat, origin_lon, origin_lat, bg_lon_min, earth_radius - ) - if bg_lon_min < origin_lon: - x_min = -x_min - - # Calculate X max (Right) - x_max = haversine( - origin_lat, origin_lon, origin_lat, bg_lon_max, earth_radius - ) - if bg_lon_max < origin_lon: - x_max = -x_max - - # Calculate Y min (Bottom) - y_min = haversine( - origin_lat, origin_lon, bg_lat_min, origin_lon, earth_radius - ) - if bg_lat_min < origin_lat: - y_min = -y_min - - # Calculate Y max (Top) - y_max = haversine( - origin_lat, origin_lon, bg_lat_max, origin_lon, earth_radius + local_extent = convert_mercator_extent_to_local( + mercator_extent, origin_lat, origin_lon, earth_radius ) - if bg_lat_max < origin_lat: - y_max = -y_max - return bg, [x_min, x_max, y_min, y_max] + return bg, local_extent except Exception as e: warnings.warn( diff --git a/rocketpy/tools.py b/rocketpy/tools.py index cf01b2dfc..68ab3404a 100644 --- a/rocketpy/tools.py +++ b/rocketpy/tools.py @@ -465,14 +465,115 @@ def mercator_to_wgs84(x, y, earth_radius=6.3781e6): """ lon = x / earth_radius * 180.0 / math.pi - lat = ( - (2 * math.atan(math.exp(y / earth_radius)) - math.pi / 2.0) - * 180.0 - / math.pi - ) + lat = (2 * math.atan(math.exp(y / earth_radius)) - math.pi / 2.0) * 180.0 / math.pi return lat, lon +def convert_local_extent_to_wgs84( + local_extent, origin_lat, origin_lon, earth_radius=6.3781e6 +): + """Convert local extent to geographic extent (latitude/longitude bounding box). + + This function converts a local extent (bounding box in meters relative to an + origin point) to a geographic extent (bounding box in latitude/longitude degrees). + + Parameters + ---------- + local_extent : list[float] + Local extent [x_min, x_max, y_min, y_max] in meters relative to the origin. + origin_lat : float + Origin latitude in degrees. + origin_lon : float + Origin longitude in degrees. + earth_radius : float, optional + Earth's radius in meters. Default value is 6.3781e6. + + Returns + ------- + tuple[float, float, float, float] + Geographic extent (west, south, east, north) in degrees. + """ + x_min, x_max, y_min, y_max = local_extent + corners_xy = [ + (x_min, y_min), # Bottom-Left + (x_min, y_max), # Top-Left + (x_max, y_min), # Bottom-Right + (x_max, y_max), # Top-Right + ] + req_lats, req_lons = [], [] + + for x, y in corners_xy: + dist = (x**2 + y**2) ** 0.5 + # Calculate bearing: 0 is North (Y), 90 is East (X) + bearing = np.degrees(np.arctan2(x, y)) + lat, lon = inverted_haversine( + origin_lat, origin_lon, dist, bearing, earth_radius + ) + req_lats.append(lat) + req_lons.append(lon) + + return min(req_lons), min(req_lats), max(req_lons), max(req_lats) + + +def convert_mercator_extent_to_local( + mercator_extent, origin_lat, origin_lon, earth_radius=6.3781e6 +): + """Convert Mercator extent to local extent (coordinates relative to origin). + + This function converts a geographic extent from Web Mercator coordinates to a + local extent (bounding box in meters relative to an origin point). + + Parameters + ---------- + mercator_extent : list[float] + Mercator extent [minX, maxX, minY, maxY] in meters. + origin_lat : float + Origin latitude in degrees. + origin_lon : float + Origin longitude in degrees. + earth_radius : float, optional + Earth's radius in meters. Default value is 6.3781e6. + + Returns + ------- + list[float] + Local extent [x_min, x_max, y_min, y_max] in meters relative to the origin. + """ + # Convert corners of the fetched image from Mercator to WGS84 + bg_lat_min, bg_lon_min = mercator_to_wgs84( + mercator_extent[0], mercator_extent[2], earth_radius + ) # Bottom-Left + bg_lat_max, bg_lon_max = mercator_to_wgs84( + mercator_extent[1], mercator_extent[3], earth_radius + ) # Top-Right + + # Calculate X/Y meters relative to origin (lat0, lon0) using haversine + # X = Distance along longitude (East-West) + # Y = Distance along latitude (North-South) + + # Calculate X min (Left) + x_min = haversine(origin_lat, origin_lon, origin_lat, bg_lon_min, earth_radius) + if bg_lon_min < origin_lon: + x_min = -x_min + + # Calculate X max (Right) + x_max = haversine(origin_lat, origin_lon, origin_lat, bg_lon_max, earth_radius) + if bg_lon_max < origin_lon: + x_max = -x_max + + # Calculate Y min (Bottom) + y_min = haversine(origin_lat, origin_lon, bg_lat_min, origin_lon, earth_radius) + if bg_lat_min < origin_lat: + y_min = -y_min + + # Calculate Y max (Top) + y_max = haversine(origin_lat, origin_lon, bg_lat_max, origin_lon, earth_radius) + if bg_lat_max < origin_lat: + y_max = -y_max + + return [x_min, x_max, y_min, y_max] + + # Functions for monte carlo analysis def sort_eigenvalues(cov): # Calculate eigenvalues and eigenvectors From 89f9bcf8ed67d5b9606a754c306b52ff0dc3861c Mon Sep 17 00:00:00 2001 From: x25tang Date: Wed, 3 Dec 2025 22:17:39 +0100 Subject: [PATCH 13/32] BUG: Fix map alignment by enforcing standard Earth radius in plots - Previously, `_get_environment_coordinates` retrieved the Earth radius directly from the environment object. When simulations utilized a custom or local Earth radius for high-precision physics, this value was incorrectly applied to the map projection calculations. - Since background map providers (like Contextily) rely on the standard Web Mercator projection (based on ~6,378,137m), using a non-standard radius caused the background map to be shifted or scaled incorrectly relative to the scatter plot data. - This change forces the plotting module to use the standard WGS84 radius. This ensures visual accuracy for map overlays without affecting the physical integrity of the simulation data itself. --- rocketpy/plots/monte_carlo_plots.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index 81e78fb94..67cdf673f 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -54,11 +54,13 @@ def _get_environment_coordinates(self): if isinstance(origin_lon, (list, tuple)): origin_lon = origin_lon[0] - # Get earth_radius from the underlying Environment object if available - if hasattr(env, "obj") and hasattr(env.obj, "earth_radius"): - earth_radius = env.obj.earth_radius - else: - earth_radius = getattr(env, "earth_radius", 6.3781e6) + # We enforce the standard WGS84 Earth radius (approx. 6,378,137 m) for + # visualization purposes. Background map providers (e.g., via Contextily) + # typically use Web Mercator (EPSG:3857), which assumes this standard radius. + # Using a custom local radius here—even if used in the physics simulation—would + # cause projection mismatches, resulting in the map being offset or scaled + # incorrectly relative to the data points. + earth_radius = 6378137.0 return origin_lat, origin_lon, earth_radius From c39f297fd93382a326dfec91bebd5b3be6187ee7 Mon Sep 17 00:00:00 2001 From: x25tang Date: Wed, 3 Dec 2025 23:40:41 +0100 Subject: [PATCH 14/32] TST: Add Kennedy Space Center environment fixture - Add example_kennedy_env fixture to replace create_kennedy_environment helper function in tests. This follows the same pattern as other environment fixtures and improves test consistency. - Make test_all_background_options() a a parametrized test. - Remove main from test --- .../environment/environment_fixtures.py | 28 ++++++++++ ...y => test_monte_carlo_plots_background.py} | 53 +++++-------------- 2 files changed, 42 insertions(+), 39 deletions(-) rename tests/integration/simulation/{test_monte_carlo_plots_background_kennedy.py => test_monte_carlo_plots_background.py} (76%) diff --git a/tests/fixtures/environment/environment_fixtures.py b/tests/fixtures/environment/environment_fixtures.py index a662d90e0..818f434c7 100644 --- a/tests/fixtures/environment/environment_fixtures.py +++ b/tests/fixtures/environment/environment_fixtures.py @@ -115,3 +115,31 @@ def environment_spaceport_america_2023(): env.max_expected_height = 6000 return env + + +@pytest.fixture +def example_kennedy_env(example_date_naive): + """Environment class with location set to Kennedy Space Center launch site. + + Kennedy Space Center coordinates: + - Latitude: 28.5721° N + - Longitude: -80.6480° W + - Elevation: ~3 meters + + Returns + ------- + rocketpy.Environment + Environment object configured for Kennedy Space Center. + """ + kennedy_env = Environment( + latitude=28.5721, + longitude=-80.6480, + elevation=3.0, + datum="WGS84", + ) + # Set date to tomorrow at noon UTC + tomorrow = example_date_naive + kennedy_env.set_date( + (tomorrow.year, tomorrow.month, tomorrow.day, 12), timezone="UTC" + ) + return kennedy_env diff --git a/tests/integration/simulation/test_monte_carlo_plots_background_kennedy.py b/tests/integration/simulation/test_monte_carlo_plots_background.py similarity index 76% rename from tests/integration/simulation/test_monte_carlo_plots_background_kennedy.py rename to tests/integration/simulation/test_monte_carlo_plots_background.py index d24f29680..6ad687ae4 100644 --- a/tests/integration/simulation/test_monte_carlo_plots_background_kennedy.py +++ b/tests/integration/simulation/test_monte_carlo_plots_background.py @@ -7,51 +7,27 @@ import os import numpy as np import matplotlib.pyplot as plt -from datetime import datetime, timedelta +from unittest.mock import MagicMock -from rocketpy import Environment from rocketpy.simulation import MonteCarlo from rocketpy.stochastic import StochasticEnvironment plt.rcParams.update({"figure.max_open_warning": 0}) -def create_kennedy_environment(): - """Create an Environment object for Kennedy Space Center. - - Kennedy Space Center coordinates: - - Latitude: 28.5721° N - - Longitude: -80.6480° W - - Elevation: ~3 meters - - Returns - ------- - Environment - Environment object configured for Kennedy Space Center. - """ - env = Environment( - latitude=28.5721, - longitude=-80.6480, - elevation=3.0, - datum="WGS84", - ) - # Set a date for the environment (tomorrow at noon UTC) - tomorrow = datetime.now() + timedelta(days=1) - # Use tuple format: (year, month, day, hour) - env.set_date((tomorrow.year, tomorrow.month, tomorrow.day, 12), timezone="UTC") - return env - - -def create_simulated_monte_carlo_data(): +def create_simulated_monte_carlo_data(env): """Create a MonteCarlo object with simulated results data. + Parameters + ---------- + env : rocketpy.Environment + Environment object to use for the Monte Carlo simulation. + Returns ------- MonteCarlo MonteCarlo object with simulated apogee and impact data. """ - # Create environment for Kennedy Space Center - env = create_kennedy_environment() # Create stochastic environment (no randomization for simplicity) stochastic_env = StochasticEnvironment( @@ -62,8 +38,6 @@ def create_simulated_monte_carlo_data(): longitude=None, ) - from unittest.mock import MagicMock - stochastic_rocket = MagicMock() stochastic_flight = MagicMock() @@ -97,7 +71,7 @@ def create_simulated_monte_carlo_data(): return monte_carlo -def test_all_background_options(): +def test_all_background_options(example_kennedy_env): """Test all background map options and save images. This function tests: @@ -106,11 +80,16 @@ def test_all_background_options(): - street - terrain - custom provider (CartoDB.Positron) + + Parameters + ---------- + example_kennedy_env : rocketpy.Environment + Environment fixture for Kennedy Space Center. """ output_dir = "kennedy_background_tests" os.makedirs(output_dir, exist_ok=True) - monte_carlo = create_simulated_monte_carlo_data() + monte_carlo = create_simulated_monte_carlo_data(example_kennedy_env) background_options = [ (None, "no_background"), @@ -153,7 +132,3 @@ def test_all_background_options(): print(f"✗ Error: {str(e)}") print(f"\nAll tests completed! Check the '{output_dir}/' directory for results.") - - -if __name__ == "__main__": - test_all_background_options() From 02eb829f8644a1dd0ed663cb09e600aaefbc3d2b Mon Sep 17 00:00:00 2001 From: x25tang Date: Thu, 4 Dec 2025 00:24:41 +0100 Subject: [PATCH 15/32] ENH: Improve error handling and documentation for automatically download background - Enhanced error messages for missing or invalid map providers, providing clearer guidance on potential issues. - Removed warnings for missing contextily library and replaced them with exceptions to enforce required dependencies. - Updated docstring to include raised exceptions and clarify the function's behavior when fetching background maps. --- rocketpy/plots/monte_carlo_plots.py | 74 ++++++++++++++++------------- 1 file changed, 40 insertions(+), 34 deletions(-) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index 67cdf673f..8422a6cb2 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -1,4 +1,3 @@ -import warnings from pathlib import Path import matplotlib.pyplot as plt @@ -37,12 +36,13 @@ def _get_environment_coordinates(self): if not hasattr(self.monte_carlo, "environment"): raise ValueError( "MonteCarlo object must have an 'environment' attribute " - "to use automatic map background." + "for automatically fetching the background map." ) env = self.monte_carlo.environment if not hasattr(env, "latitude") or not hasattr(env, "longitude"): raise ValueError( - "Environment must have 'latitude' and 'longitude' attributes." + "Environment must have 'latitude' and 'longitude' attributes " + "for automatically fetching the background map." ) # Handle both StochasticEnvironment (which stores as lists) and @@ -97,8 +97,13 @@ def _resolve_map_provider(self, background, contextily): for key in map_provider.split("."): p = p[key] source_provider = p - except (KeyError, AttributeError): - pass + except (KeyError, AttributeError) as e: + raise ValueError( + f"Invalid map provider '{background}'. " + f"The provider '{map_provider}' could not be found in contextily.providers. " + f"Please check the provider name or use one of the built-in options: " + f"'satellite', 'street', or 'terrain'." + ) from e return source_provider @@ -125,45 +130,46 @@ def _get_background_map(self, background, xlim, ylim): Image as a 3D array of RGB values extent : tuple Bounding box [minX, maxX, minY, maxY] of the returned image + + Raises + ------ + ImportError + If the contextily library is not installed. + RuntimeError + If unable to fetch the background map from the provider. """ if background is None: return None, None - try: - contextily = import_optional_dependency("contextily") - except ImportError: - warnings.warn( - "contextily library is required for automatic map background. " - "Install it via 'pip install contextily' or 'pip install rocketpy[monte-carlo]'. " - "Plotting without background.", - UserWarning, - ) - return None, None + contextily = import_optional_dependency("contextily") - try: - origin_lat, origin_lon, earth_radius = self._get_environment_coordinates() - source_provider = self._resolve_map_provider(background, contextily) - local_extent = [xlim[0], xlim[1], ylim[0], ylim[1]] - west, south, east, north = convert_local_extent_to_wgs84( - local_extent, origin_lat, origin_lon, earth_radius - ) + origin_lat, origin_lon, earth_radius = self._get_environment_coordinates() + source_provider = self._resolve_map_provider(background, contextily) + local_extent = [xlim[0], xlim[1], ylim[0], ylim[1]] + west, south, east, north = convert_local_extent_to_wgs84( + local_extent, origin_lat, origin_lon, earth_radius + ) + try: bg, mercator_extent = contextily.bounds2img( west, south, east, north, source=source_provider, ll=True ) - - local_extent = convert_mercator_extent_to_local( - mercator_extent, origin_lat, origin_lon, earth_radius - ) - - return bg, local_extent - except Exception as e: - warnings.warn( - f"Unable to fetch background map '{background}'. " - f"Error: {e}. Plotting without background." - ) - return None, None + raise RuntimeError( + f"Failed to fetch background map tiles from provider '{background}'. " + f"This could be due to:\n" + f" - Network connectivity issues\n" + f" - Invalid coordinate bounds (west={west:.6f}, south={south:.6f}, " + f"east={east:.6f}, north={north:.6f})\n" + f" - Service unavailability\n" + f" - Invalid map provider configuration\n\n" + ) from e + + local_extent = convert_mercator_extent_to_local( + mercator_extent, origin_lat, origin_lon, earth_radius + ) + + return bg, local_extent # pylint: disable=too-many-statements def ellipses( From f26be7c5908600a31d2f9272b47dcc1d38c510e7 Mon Sep 17 00:00:00 2001 From: x25tang Date: Thu, 4 Dec 2025 00:33:46 +0100 Subject: [PATCH 16/32] TST: Enhance Monte Carlo background map unit tests - Refactored tests to improve error handling for missing environment attributes and invalid map providers. - Replaced warnings with exceptions for missing dependencies, ensuring stricter validation. - Added assertions to verify error messages for better clarity on issues encountered during background map fetching. - Introduced new tests for handling network errors and invalid map provider scenarios. --- .../test_monte_carlo_plots_background.py | 124 +++++++++++++++--- 1 file changed, 103 insertions(+), 21 deletions(-) diff --git a/tests/unit/simulation/test_monte_carlo_plots_background.py b/tests/unit/simulation/test_monte_carlo_plots_background.py index 1c670b630..c043ee156 100644 --- a/tests/unit/simulation/test_monte_carlo_plots_background.py +++ b/tests/unit/simulation/test_monte_carlo_plots_background.py @@ -1,10 +1,9 @@ # pylint: disable=unused-argument import os -import warnings +import pytest from unittest.mock import MagicMock, patch import matplotlib.pyplot as plt -import pytest plt.rcParams.update({"figure.max_open_warning": 0}) @@ -13,6 +12,9 @@ def _post_test_file_cleanup(): """Clean monte carlo files after test session if they exist.""" files_to_cleanup = [ "monte_carlo_test.png", + "monte_carlo_test.errors.txt", + "monte_carlo_test.inputs.txt", + "monte_carlo_test.outputs.txt", ] for filepath in files_to_cleanup: if os.path.exists(filepath): @@ -152,10 +154,12 @@ def test_ellipses_image_takes_precedence_over_background( _post_test_file_cleanup() -def test_ellipses_background_no_environment(): +@patch("matplotlib.pyplot.show") +def test_ellipses_background_no_environment(mock_show): """Test that ValueError is raised when MonteCarlo object has no environment attribute. This test creates a MonteCarlo object without an environment attribute. + The function should raise ValueError when trying to fetch background map. """ from rocketpy.plots.monte_carlo_plots import _MonteCarloPlots @@ -172,16 +176,18 @@ def __init__(self): mock_monte_carlo = MockMonteCarlo() plots = _MonteCarloPlots(mock_monte_carlo) - with pytest.raises( - ValueError, match="MonteCarlo object must have an 'environment' attribute" - ): + with pytest.raises(ValueError) as exc_info: plots.ellipses(background="satellite") + assert "environment" in str(exc_info.value).lower() + assert "automatically fetching the background map" in str(exc_info.value) -def test_ellipses_background_no_latitude_longitude(): +@patch("matplotlib.pyplot.show") +def test_ellipses_background_no_latitude_longitude(mock_show): """Test that ValueError is raised when environment has no latitude or longitude attributes. This test creates a mock environment without latitude and longitude attributes. + The function should raise ValueError when trying to fetch background map. """ from rocketpy.plots.monte_carlo_plots import _MonteCarloPlots @@ -191,20 +197,28 @@ def test_ellipses_background_no_latitude_longitude(): mock_monte_carlo = MagicMock() mock_monte_carlo.environment = mock_environment + mock_monte_carlo.results = { + "apogee_x": [100, 200, 300], + "apogee_y": [100, 200, 300], + "x_impact": [1000, 2000, 3000], + "y_impact": [1000, 2000, 3000], + } + mock_monte_carlo.filename = "test" plots = _MonteCarloPlots(mock_monte_carlo) - with pytest.raises( - ValueError, match="Environment must have 'latitude' and 'longitude' attributes" - ): + with pytest.raises(ValueError) as exc_info: plots.ellipses(background="satellite") + assert "latitude" in str(exc_info.value).lower() + assert "longitude" in str(exc_info.value).lower() + assert "automatically fetching the background map" in str(exc_info.value) @patch("matplotlib.pyplot.show") def test_ellipses_background_contextily_not_installed( mock_show, monte_carlo_calisto_pre_loaded ): - """Test that a warning is issued when contextily is not installed. + """Test that ImportError is raised when contextily is not installed. Parameters ---------- @@ -226,16 +240,9 @@ def mock_import_optional_dependency(name): "rocketpy.plots.monte_carlo_plots.import_optional_dependency", side_effect=mock_import_optional_dependency, ): - with warnings.catch_warnings(record=True) as w: - warnings.simplefilter("always") - result = monte_carlo_calisto_pre_loaded.plots.ellipses( - background="satellite" - ) - assert result is None - assert len(w) > 0 - assert any( - "contextily" in str(warning.message).lower() for warning in w - ) + with pytest.raises(ImportError) as exc_info: + monte_carlo_calisto_pre_loaded.plots.ellipses(background="satellite") + assert "contextily" in str(exc_info.value).lower() finally: _post_test_file_cleanup() @@ -286,3 +293,78 @@ def test_ellipses_background_save(mock_show, monte_carlo_calisto_pre_loaded): assert os.path.exists("monte_carlo_test.png") finally: _post_test_file_cleanup() + + +@patch("matplotlib.pyplot.show") +def test_ellipses_background_invalid_provider( + mock_show, monte_carlo_calisto_pre_loaded +): + """Test that ValueError is raised when an invalid map provider is specified. + + Parameters + ---------- + mock_show : + Mocks the matplotlib.pyplot.show() function to avoid showing the plots. + monte_carlo_calisto_pre_loaded : MonteCarlo + The MonteCarlo object, this is a pytest fixture. + """ + try: + with pytest.raises(ValueError) as exc_info: + monte_carlo_calisto_pre_loaded.plots.ellipses( + background="Invalid.Provider.Name" + ) + assert "Invalid map provider" in str(exc_info.value) + assert "Invalid.Provider.Name" in str(exc_info.value) + assert ( + "satellite" in str(exc_info.value) + or "street" in str(exc_info.value) + or "terrain" in str(exc_info.value) + ) + finally: + _post_test_file_cleanup() + + +@patch("matplotlib.pyplot.show") +def test_ellipses_background_bounds2img_failure( + mock_show, monte_carlo_calisto_pre_loaded +): + """Test that RuntimeError is raised when bounds2img fails to fetch map tiles. + + Parameters + ---------- + mock_show : + Mocks the matplotlib.pyplot.show() function to avoid showing the plots. + monte_carlo_calisto_pre_loaded : MonteCarlo + The MonteCarlo object, this is a pytest fixture. + """ + try: + from rocketpy.tools import import_optional_dependency as original_import + import contextily + + # Create a mock contextily module with a failing bounds2img + mock_contextily = MagicMock() + mock_contextily.providers = contextily.providers + + def mock_bounds2img(*args, **kwargs): + raise ConnectionError("Network error: Unable to fetch tiles") + + mock_contextily.bounds2img = mock_bounds2img + + def mock_import_optional_dependency(name): + if name == "contextily": + return mock_contextily + return original_import(name) + + with patch( + "rocketpy.plots.monte_carlo_plots.import_optional_dependency", + side_effect=mock_import_optional_dependency, + ): + with pytest.raises(RuntimeError) as exc_info: + monte_carlo_calisto_pre_loaded.plots.ellipses(background="satellite") + assert "Failed to fetch background map tiles" in str(exc_info.value) + assert "satellite" in str(exc_info.value) + assert "Network connectivity" in str( + exc_info.value + ) or "Service unavailability" in str(exc_info.value) + finally: + _post_test_file_cleanup() From bc309b4837fbc73603eeeb47d307a9e4132a7dec Mon Sep 17 00:00:00 2001 From: x25tang Date: Fri, 5 Dec 2025 00:27:41 +0800 Subject: [PATCH 17/32] TST: Refactor Monte Carlo plot tests with mock class - Introduced a MockMonteCarlo class to simulate Monte Carlo data for testing background map options without real simulations. - Updated tests to utilize the MockMonteCarlo, improving clarity and maintainability. - Simplified environment handling in tests by creating a SimpleEnvironment class for latitude and longitude attributes. - Enhanced error handling and assertions in tests for various background map scenarios. --- .../test_monte_carlo_plots_background.py | 158 +++++++-------- .../test_monte_carlo_plots_background.py | 189 +++++++++--------- 2 files changed, 177 insertions(+), 170 deletions(-) diff --git a/tests/integration/simulation/test_monte_carlo_plots_background.py b/tests/integration/simulation/test_monte_carlo_plots_background.py index 6ad687ae4..3c54305a8 100644 --- a/tests/integration/simulation/test_monte_carlo_plots_background.py +++ b/tests/integration/simulation/test_monte_carlo_plots_background.py @@ -7,68 +7,71 @@ import os import numpy as np import matplotlib.pyplot as plt -from unittest.mock import MagicMock from rocketpy.simulation import MonteCarlo -from rocketpy.stochastic import StochasticEnvironment +from rocketpy.plots.monte_carlo_plots import _MonteCarloPlots plt.rcParams.update({"figure.max_open_warning": 0}) -def create_simulated_monte_carlo_data(env): - """Create a MonteCarlo object with simulated results data. +class MockMonteCarlo(MonteCarlo): + """Create a mock class to test the method without running a real simulation. - Parameters - ---------- - env : rocketpy.Environment - Environment object to use for the Monte Carlo simulation. - - Returns - ------- - MonteCarlo - MonteCarlo object with simulated apogee and impact data. + This class creates a MonteCarlo object with simulated results data for testing + background map options. Only includes the minimal attributes needed for plotting. """ - # Create stochastic environment (no randomization for simplicity) - stochastic_env = StochasticEnvironment( - environment=env, - elevation=None, - gravity=None, - latitude=None, - longitude=None, - ) - - stochastic_rocket = MagicMock() - stochastic_flight = MagicMock() - - monte_carlo = MonteCarlo( - filename="kennedy_space_center_test", - environment=stochastic_env, - rocket=stochastic_rocket, - flight=stochastic_flight, - ) - - # Generate simulated Monte Carlo results - # Simulate 50 data points with realistic dispersion - np.random.seed(42) # For reproducibility - - # Simulate apogee points (scattered around origin with some dispersion) - n_points = 50 - apogee_x = np.random.normal(0, 500, n_points) # meters, std dev 500m - apogee_y = np.random.normal(0, 500, n_points) # meters, std dev 500m - - # Simulate impact points (further from origin, more dispersion) - impact_x = np.random.normal(2000, 1000, n_points) # meters, mean 2km, std dev 1km - impact_y = np.random.normal(1500, 1000, n_points) # meters, mean 1.5km, std dev 1km - - monte_carlo.results = { - "apogee_x": apogee_x.tolist(), - "apogee_y": apogee_y.tolist(), - "x_impact": impact_x.tolist(), - "y_impact": impact_y.tolist(), - } - - return monte_carlo + def __init__(self, env, filename="kennedy_space_center_test"): + """Initialize MockMonteCarlo with simulated data. + + Parameters + ---------- + env : rocketpy.Environment + Environment object to use for the Monte Carlo simulation. + Must have latitude and longitude attributes. + filename : str, optional + Filename for the MonteCarlo object. Defaults to "kennedy_space_center_test". + """ + + # pylint: disable=super-init-not-called + # Create a simple environment object with only latitude and longitude + # needed for background map fetching + class SimpleEnvironment: + """Simple environment object with only latitude and longitude.""" + + def __init__(self, env): + self.latitude = env.latitude + self.longitude = env.longitude + + # Set attributes needed for plotting background maps + self.filename = filename + self.environment = SimpleEnvironment(env) + self.plots = _MonteCarloPlots(self) + + # Generate simulated Monte Carlo results + # Simulate 50 data points with realistic dispersion + np.random.seed(42) # For reproducibility + + # Simulate apogee points (scattered around origin with some dispersion) + n_points = 50 + apogee_x = np.random.normal(0, 500, n_points) # meters, std dev 500m + apogee_y = np.random.normal(0, 500, n_points) # meters, std dev 500m + + # Simulate impact points (further from origin, more dispersion) + impact_x = np.random.normal( + 2000, 1000, n_points + ) # meters, mean 2km, std dev 1km + impact_y = np.random.normal( + 1500, 1000, n_points + ) # meters, mean 1.5km, std dev 1km + + # Set simulated results (only what's needed for ellipses plot) + self.results = { + "apogee_x": apogee_x.tolist(), + "apogee_y": apogee_y.tolist(), + "x_impact": impact_x.tolist(), + "y_impact": impact_y.tolist(), + } def test_all_background_options(example_kennedy_env): @@ -89,7 +92,7 @@ def test_all_background_options(example_kennedy_env): output_dir = "kennedy_background_tests" os.makedirs(output_dir, exist_ok=True) - monte_carlo = create_simulated_monte_carlo_data(example_kennedy_env) + monte_carlo = MockMonteCarlo(env=example_kennedy_env) background_options = [ (None, "no_background"), @@ -103,32 +106,29 @@ def test_all_background_options(example_kennedy_env): print(f"Output directory: {output_dir}/") for background, name in background_options: + print(f" Testing {name}...", end=" ") + + # Temporarily change filename to save with desired name + original_filename = monte_carlo.filename + monte_carlo.filename = os.path.join(output_dir, f"kennedy_{name}") + try: - print(f" Testing {name}...", end=" ") - - # Temporarily change filename to save with desired name - original_filename = monte_carlo.filename - monte_carlo.filename = os.path.join(output_dir, f"kennedy_{name}") - - try: - monte_carlo.plots.ellipses( - background=background, - xlim=(-5000, 5000), - ylim=(-5000, 5000), - save=True, + monte_carlo.plots.ellipses( + background=background, + xlim=(-5000, 5000), + ylim=(-5000, 5000), + save=True, + ) + + # Check if file was created + expected_file = f"{monte_carlo.filename}.png" + if not os.path.exists(expected_file): + raise FileNotFoundError( + f"Expected file {expected_file} was not created after plotting." ) - - # Check if file was created - expected_file = f"{monte_carlo.filename}.png" - if os.path.exists(expected_file): - print(f"✓ Saved to {expected_file}") - else: - print("✗ Failed to save") - finally: - # Restore original filename - monte_carlo.filename = original_filename - - except (ValueError, ImportError, OSError) as e: - print(f"✗ Error: {str(e)}") + print(f"✓ Saved to {expected_file}") + finally: + # Restore original filename + monte_carlo.filename = original_filename print(f"\nAll tests completed! Check the '{output_dir}/' directory for results.") diff --git a/tests/unit/simulation/test_monte_carlo_plots_background.py b/tests/unit/simulation/test_monte_carlo_plots_background.py index c043ee156..7a2ab4429 100644 --- a/tests/unit/simulation/test_monte_carlo_plots_background.py +++ b/tests/unit/simulation/test_monte_carlo_plots_background.py @@ -1,13 +1,65 @@ -# pylint: disable=unused-argument +# pylint: disable=unused-argument,assignment-from-no-return import os import pytest from unittest.mock import MagicMock, patch import matplotlib.pyplot as plt +from rocketpy.plots.monte_carlo_plots import _MonteCarloPlots +from rocketpy.simulation import MonteCarlo + plt.rcParams.update({"figure.max_open_warning": 0}) +class MockMonteCarlo(MonteCarlo): + """Create a mock class to test the method without running a real simulation. + + This class creates a MonteCarlo object with simulated results data for testing + background map options. Only includes the minimal attributes needed for plotting. + """ + + def __init__(self, environment=None, filename="test"): + """Initialize MockMonteCarlo with simulated data. + + Parameters + ---------- + environment : object, optional + Environment object with latitude and longitude attributes. + If None, no environment attribute will be set. + filename : str, optional + Filename for the MonteCarlo object. Defaults to "test". + """ + # pylint: disable=super-init-not-called + # Set attributes needed for plotting background maps + self.filename = filename + self.results = { + "apogee_x": [100, 200, 300], + "apogee_y": [100, 200, 300], + "x_impact": [1000, 2000, 3000], + "y_impact": [1000, 2000, 3000], + } + if environment is not None: + self.environment = environment + self.plots = _MonteCarloPlots(self) + + +class SimpleEnvironment: + """Simple environment object with latitude and longitude attributes.""" + + def __init__(self, latitude=32.990254, longitude=-106.974998): + """Initialize SimpleEnvironment with latitude and longitude. + + Parameters + ---------- + latitude : float, optional + Latitude in degrees. Defaults to Spaceport America coordinates. + longitude : float, optional + Longitude in degrees. Defaults to Spaceport America coordinates. + """ + self.latitude = latitude + self.longitude = longitude + + def _post_test_file_cleanup(): """Clean monte carlo files after test session if they exist.""" files_to_cleanup = [ @@ -22,118 +74,108 @@ def _post_test_file_cleanup(): @patch("matplotlib.pyplot.show") -def test_ellipses_background_none(mock_show, monte_carlo_calisto_pre_loaded): +def test_ellipses_background_none(mock_show): """Test default behavior when background=None (no background map displayed). Parameters ---------- mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. - monte_carlo_calisto_pre_loaded : MonteCarlo - The MonteCarlo object, this is a pytest fixture. """ try: + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) # Test that background=None does not raise an error - result = monte_carlo_calisto_pre_loaded.plots.ellipses(background=None) + result = mock_monte_carlo.plots.ellipses(background=None) assert result is None finally: _post_test_file_cleanup() @patch("matplotlib.pyplot.show") -def test_ellipses_background_satellite(mock_show, monte_carlo_calisto_pre_loaded): +def test_ellipses_background_satellite(mock_show): """Test using satellite map when background="satellite". Parameters ---------- mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. - monte_carlo_calisto_pre_loaded : MonteCarlo - The MonteCarlo object, this is a pytest fixture. """ try: + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) # Test that background="satellite" does not raise an error - result = monte_carlo_calisto_pre_loaded.plots.ellipses(background="satellite") + result = mock_monte_carlo.plots.ellipses(background="satellite") assert result is None finally: _post_test_file_cleanup() @patch("matplotlib.pyplot.show") -def test_ellipses_background_street(mock_show, monte_carlo_calisto_pre_loaded): +def test_ellipses_background_street(mock_show): """Test using street map when background="street". Parameters ---------- mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. - monte_carlo_calisto_pre_loaded : MonteCarlo - The MonteCarlo object, this is a pytest fixture. """ try: + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) # Test that background="street" does not raise an error - result = monte_carlo_calisto_pre_loaded.plots.ellipses(background="street") + result = mock_monte_carlo.plots.ellipses(background="street") assert result is None finally: _post_test_file_cleanup() @patch("matplotlib.pyplot.show") -def test_ellipses_background_terrain(mock_show, monte_carlo_calisto_pre_loaded): +def test_ellipses_background_terrain(mock_show): """Test using terrain map when background="terrain". Parameters ---------- mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. - monte_carlo_calisto_pre_loaded : MonteCarlo - The MonteCarlo object, this is a pytest fixture. """ try: + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) # Test that background="terrain" does not raise an error - result = monte_carlo_calisto_pre_loaded.plots.ellipses(background="terrain") + result = mock_monte_carlo.plots.ellipses(background="terrain") assert result is None finally: _post_test_file_cleanup() @patch("matplotlib.pyplot.show") -def test_ellipses_background_custom_provider(mock_show, monte_carlo_calisto_pre_loaded): +def test_ellipses_background_custom_provider(mock_show): """Test using custom contextily provider for background. Parameters ---------- mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. - monte_carlo_calisto_pre_loaded : MonteCarlo - The MonteCarlo object, this is a pytest fixture. """ try: + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) # Test that custom provider does not raise an error - result = monte_carlo_calisto_pre_loaded.plots.ellipses( - background="CartoDB.Positron" - ) + result = mock_monte_carlo.plots.ellipses(background="CartoDB.Positron") assert result is None finally: _post_test_file_cleanup() @patch("matplotlib.pyplot.show") -def test_ellipses_image_takes_precedence_over_background( - mock_show, monte_carlo_calisto_pre_loaded, tmp_path -): +def test_ellipses_image_takes_precedence_over_background(mock_show, tmp_path): """Test that image takes precedence when both image and background are provided. Parameters ---------- mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. - monte_carlo_calisto_pre_loaded : MonteCarlo - The MonteCarlo object, this is a pytest fixture. tmp_path : pytest fixture providing a temporary directory. """ try: + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) dummy_image_path = tmp_path / "dummy_image.png" dummy_image_path.write_bytes(b"dummy") @@ -145,7 +187,7 @@ def test_ellipses_image_takes_precedence_over_background( with patch("imageio.imread") as mock_imread: mock_imread.return_value = mock_image - result = monte_carlo_calisto_pre_loaded.plots.ellipses( + result = mock_monte_carlo.plots.ellipses( image=str(dummy_image_path), background="satellite" ) assert result is None @@ -161,23 +203,10 @@ def test_ellipses_background_no_environment(mock_show): This test creates a MonteCarlo object without an environment attribute. The function should raise ValueError when trying to fetch background map. """ - from rocketpy.plots.monte_carlo_plots import _MonteCarloPlots - - class MockMonteCarlo: - def __init__(self): - self.results = { - "apogee_x": [100, 200, 300], - "apogee_y": [100, 200, 300], - "x_impact": [1000, 2000, 3000], - "y_impact": [1000, 2000, 3000], - } - self.filename = "test" - - mock_monte_carlo = MockMonteCarlo() - plots = _MonteCarloPlots(mock_monte_carlo) + mock_monte_carlo = MockMonteCarlo(environment=None) with pytest.raises(ValueError) as exc_info: - plots.ellipses(background="satellite") + mock_monte_carlo.plots.ellipses(background="satellite") assert "environment" in str(exc_info.value).lower() assert "automatically fetching the background map" in str(exc_info.value) @@ -189,45 +218,35 @@ def test_ellipses_background_no_latitude_longitude(mock_show): This test creates a mock environment without latitude and longitude attributes. The function should raise ValueError when trying to fetch background map. """ - from rocketpy.plots.monte_carlo_plots import _MonteCarloPlots - mock_environment = MagicMock() - delattr(mock_environment, "latitude") - delattr(mock_environment, "longitude") + # Create a simple environment object without latitude and longitude + class EmptyEnvironment: + """Empty environment object without latitude and longitude attributes.""" - mock_monte_carlo = MagicMock() - mock_monte_carlo.environment = mock_environment - mock_monte_carlo.results = { - "apogee_x": [100, 200, 300], - "apogee_y": [100, 200, 300], - "x_impact": [1000, 2000, 3000], - "y_impact": [1000, 2000, 3000], - } - mock_monte_carlo.filename = "test" + def __init__(self): + pass - plots = _MonteCarloPlots(mock_monte_carlo) + mock_environment = EmptyEnvironment() + mock_monte_carlo = MockMonteCarlo(environment=mock_environment) with pytest.raises(ValueError) as exc_info: - plots.ellipses(background="satellite") + mock_monte_carlo.plots.ellipses(background="satellite") assert "latitude" in str(exc_info.value).lower() assert "longitude" in str(exc_info.value).lower() assert "automatically fetching the background map" in str(exc_info.value) @patch("matplotlib.pyplot.show") -def test_ellipses_background_contextily_not_installed( - mock_show, monte_carlo_calisto_pre_loaded -): +def test_ellipses_background_contextily_not_installed(mock_show): """Test that ImportError is raised when contextily is not installed. Parameters ---------- mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. - monte_carlo_calisto_pre_loaded : MonteCarlo - The MonteCarlo object, this is a pytest fixture. """ try: + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) from rocketpy.tools import import_optional_dependency as original_import # Create a mock function that only raises exception when importing contextily @@ -241,28 +260,25 @@ def mock_import_optional_dependency(name): side_effect=mock_import_optional_dependency, ): with pytest.raises(ImportError) as exc_info: - monte_carlo_calisto_pre_loaded.plots.ellipses(background="satellite") + mock_monte_carlo.plots.ellipses(background="satellite") assert "contextily" in str(exc_info.value).lower() finally: _post_test_file_cleanup() @patch("matplotlib.pyplot.show") -def test_ellipses_background_with_custom_xlim_ylim( - mock_show, monte_carlo_calisto_pre_loaded -): +def test_ellipses_background_with_custom_xlim_ylim(mock_show): """Test using background with custom xlim and ylim. Parameters ---------- mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. - monte_carlo_calisto_pre_loaded : MonteCarlo - The MonteCarlo object, this is a pytest fixture. """ try: + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) # Test using custom xlim and ylim - result = monte_carlo_calisto_pre_loaded.plots.ellipses( + result = mock_monte_carlo.plots.ellipses( background="satellite", xlim=(-5000, 5000), ylim=(-5000, 5000), @@ -273,21 +289,20 @@ def test_ellipses_background_with_custom_xlim_ylim( @patch("matplotlib.pyplot.show") -def test_ellipses_background_save(mock_show, monte_carlo_calisto_pre_loaded): +def test_ellipses_background_save(mock_show): """Test using background with save=True. Parameters ---------- mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. - monte_carlo_calisto_pre_loaded : MonteCarlo - The MonteCarlo object, this is a pytest fixture. """ try: - # Test save functionality - result = monte_carlo_calisto_pre_loaded.plots.ellipses( - background="satellite", save=True + mock_monte_carlo = MockMonteCarlo( + environment=SimpleEnvironment(), filename="monte_carlo_test" ) + # Test save functionality + result = mock_monte_carlo.plots.ellipses(background="satellite", save=True) assert result is None # Verify file was created assert os.path.exists("monte_carlo_test.png") @@ -296,23 +311,18 @@ def test_ellipses_background_save(mock_show, monte_carlo_calisto_pre_loaded): @patch("matplotlib.pyplot.show") -def test_ellipses_background_invalid_provider( - mock_show, monte_carlo_calisto_pre_loaded -): +def test_ellipses_background_invalid_provider(mock_show): """Test that ValueError is raised when an invalid map provider is specified. Parameters ---------- mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. - monte_carlo_calisto_pre_loaded : MonteCarlo - The MonteCarlo object, this is a pytest fixture. """ try: + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) with pytest.raises(ValueError) as exc_info: - monte_carlo_calisto_pre_loaded.plots.ellipses( - background="Invalid.Provider.Name" - ) + mock_monte_carlo.plots.ellipses(background="Invalid.Provider.Name") assert "Invalid map provider" in str(exc_info.value) assert "Invalid.Provider.Name" in str(exc_info.value) assert ( @@ -325,19 +335,16 @@ def test_ellipses_background_invalid_provider( @patch("matplotlib.pyplot.show") -def test_ellipses_background_bounds2img_failure( - mock_show, monte_carlo_calisto_pre_loaded -): +def test_ellipses_background_bounds2img_failure(mock_show): """Test that RuntimeError is raised when bounds2img fails to fetch map tiles. Parameters ---------- mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. - monte_carlo_calisto_pre_loaded : MonteCarlo - The MonteCarlo object, this is a pytest fixture. """ try: + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) from rocketpy.tools import import_optional_dependency as original_import import contextily @@ -360,7 +367,7 @@ def mock_import_optional_dependency(name): side_effect=mock_import_optional_dependency, ): with pytest.raises(RuntimeError) as exc_info: - monte_carlo_calisto_pre_loaded.plots.ellipses(background="satellite") + mock_monte_carlo.plots.ellipses(background="satellite") assert "Failed to fetch background map tiles" in str(exc_info.value) assert "satellite" in str(exc_info.value) assert "Network connectivity" in str( From 0caa835659db3cffec69db59f9be5d6cd7c722de Mon Sep 17 00:00:00 2001 From: x25tang Date: Fri, 5 Dec 2025 00:40:34 +0800 Subject: [PATCH 18/32] DOC: Add background map options to documentation - Updated the user documentation for the Monte Carlo simulations to include details on the new ``background`` parameter for displaying various map types. - Provided examples for using satellite, street, and terrain maps, along with instructions for listing available providers. --- docs/user/mrs.rst | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/docs/user/mrs.rst b/docs/user/mrs.rst index e58f7a784..ff8ce84a5 100644 --- a/docs/user/mrs.rst +++ b/docs/user/mrs.rst @@ -204,6 +204,31 @@ Finally, we can compare the ellipses for the apogees and landing points using th Note we can pass along parameters used in the usual `ellipses` method of the `MonteCarlo` class, in this case the `ylim` argument to expand the y-axis limits. +You can also use the ``background`` parameter to automatically download and display +a background map. The ``background`` parameter accepts: +- ``"satellite"`` - uses Esri.WorldImagery for satellite imagery +- ``"street"`` - uses OpenStreetMap.Mapnik for street maps +- ``"terrain"`` - uses Esri.WorldTopoMap for terrain maps +- Any contextily provider name (e.g., ``"CartoDB.Positron"``) + +To view all available providers, you can use ``contextily.providers``: + +.. jupyter-execute:: + + import contextily + # List all available providers + print(list(contextily.providers.keys())) + +For example, to display a satellite background map: + +.. jupyter-execute:: + + original_results.compare_ellipses(mrs_results, background="satellite") + +Note that if both ``image`` and ``background`` parameters are provided, the ``image`` +parameter takes precedence. The background map is automatically downloaded based on the +environment's latitude and longitude coordinates. + Calculating Confidence Intervals -------------------------------- From 5d9af922e5e1b330b471f3ae0ec889fa78995801 Mon Sep 17 00:00:00 2001 From: x25tang Date: Fri, 5 Dec 2025 01:33:42 +0800 Subject: [PATCH 19/32] DOC: Update Monte Carlo analysis notebook with background parameter --- .../monte_carlo_class_usage.ipynb | 601 +++++++++++++++--- 1 file changed, 514 insertions(+), 87 deletions(-) diff --git a/docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb b/docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb index dc0f4e8b5..78b84cb50 100644 --- a/docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb +++ b/docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb @@ -332,7 +332,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[3.717859855893523, 4.439778613233867, 2.2538981612637707, 0.8915877554321416, 2.1553975254175404]\n" + "[np.float64(5.6160475545638056), np.float64(4.980393173814939), np.float64(5.385767484040212), np.float64(7.4369921935345875), np.float64(7.816424882152167)]\n" ] } ], @@ -373,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -461,14 +461,14 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[5355.9143244739935, 6320.4738883261325, 7394.177114563075, 5358.212881446587, 6619.455732940446]\n" + "[np.float64(3897.2472513392745), np.float64(7638.837490686001), np.float64(6424.245649353455), np.float64(7380.054043426244), np.float64(4962.403470127441)]\n" ] } ], @@ -498,7 +498,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -551,7 +551,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -601,7 +601,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -635,7 +635,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -686,7 +686,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -733,25 +733,25 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "C:\\Mateus\\GitHub\\RocketPy\\rocketpy\\simulation\\monte_carlo.py:137: UserWarning: This class is still under testing and some attributes may be changed in next versions\n", - " warnings.warn(\n" + "The following input file was imported: monte_carlo_analysis_outputs\\monte_carlo_class_example.inputs.txt\n", + "A total of 1000 simulations results were loaded from the following output file: monte_carlo_analysis_outputs\\monte_carlo_class_example.outputs.txt\n", + "\n", + "The following error file was imported: monte_carlo_analysis_outputs\\monte_carlo_class_example.errors.txt \n" ] }, { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "The following input file was imported: monte_carlo_analysis_outputs\\monte_carlo_class_example.inputs.txt\n", - "A total of 20 simulations results were loaded from the following output file: monte_carlo_analysis_outputs\\monte_carlo_class_example.outputs.txt\n", - "\n", - "The following error file was imported: monte_carlo_analysis_outputs\\monte_carlo_class_example.errors.txt \n" + "C:\\Users\\admin\\Desktop\\RocketPy\\rocketpy\\simulation\\monte_carlo.py:138: UserWarning: This class is still under testing and some attributes may be changed in next versions\n", + " warnings.warn(\n" ] } ], @@ -777,7 +777,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -792,7 +792,7 @@ ], "source": [ "test_dispersion.simulate(\n", - " number_of_simulations=10,\n", + " number_of_simulations=1000,\n", " append=False,\n", " include_function_data=False,\n", " parallel=True,\n", @@ -827,7 +827,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -837,7 +837,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -846,7 +846,7 @@ "1000" ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -857,7 +857,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -865,27 +865,28 @@ "output_type": "stream", "text": [ "Monte Carlo Simulation by RocketPy\n", - "Data Source: monte_carlo_analysis_outputs/monte_carlo_class_example\n", + "Data Source: monte_carlo_analysis_outputs\\monte_carlo_class_example\n", "Number of simulations: 1000\n", "Results: \n", "\n", - " Parameter Mean Std. Dev.\n", - "------------------------------------------------------------\n", - " apogee 3221.616 594.740\n", - " frontal_surface_wind -3.839 0.481\n", - " apogee_y 876.923 123.791\n", - " lateral_surface_wind -5.259 0.621\n", - " t_final 299.027 34.327\n", - " out_of_rail_velocity 25.690 2.194\n", - " initial_stability_margin 2.596 0.085\n", - " out_of_rail_time 0.361 0.027\n", - " y_impact -1839.493 486.133\n", - " apogee_x 446.565 124.777\n", - " impact_velocity -5.259 0.378\n", - " max_mach_number 0.859 0.131\n", - " x_impact 312.319 195.323\n", - "out_of_rail_stability_margin 2.669 0.084\n", - " apogee_time 24.782 2.015\n" + " Parameter Mean Median Std. Dev. 95% PI Lower 95% PI Upper\n", + "--------------------------------------------------------------------------------------------------------------\n", + " apogee_y 134.982 130.025 100.615 -47.049 356.129\n", + " frontal_surface_wind 3.702 3.754 0.805 2.245 5.442\n", + " apogee 3388.888 3448.481 612.972 2017.330 4401.488\n", + " x_impact 2031.702 2034.583 463.765 1102.537 2895.557\n", + " out_of_rail_velocity 25.755 25.877 2.201 20.955 29.861\n", + " apogee_time 25.492 25.814 2.042 20.554 28.399\n", + " t_final 305.905 309.231 34.430 227.323 362.786\n", + "out_of_rail_stability_margin 2.673 2.669 0.079 2.524 2.830\n", + " out_of_rail_time 0.360 0.356 0.027 0.318 0.424\n", + " lateral_surface_wind 0.362 0.405 0.591 -0.874 1.387\n", + " apogee_x 248.848 244.031 135.160 12.068 528.276\n", + " y_impact 614.070 622.436 189.047 214.816 976.160\n", + " impact_velocity -5.292 -5.292 0.084 -5.448 -5.133\n", + " max_mach_number 0.853 0.860 0.131 0.573 1.098\n", + " initial_stability_margin 2.600 2.598 0.080 2.450 2.758\n", + " index 499.500 499.500 288.675 24.975 974.025\n" ] } ], @@ -903,14 +904,29 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "3ccc7b772234415cb5b0650e98f3e0c5", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAABLAAAAOECAYAAACxbcj6AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAXEgAAFxIBZ5/SUgABAABJREFUeJzs3Qd8U/X6x/Gne5eWlrL3UnCiIIiAeMHFUkRQ/yqCuFBBRUW9bvE6uYrzqqiIel0MEdwIspShqAiCyJC9R0vpbvN/Pb/eE9KMNt0n7ef9eh0STnKSk5O0Tb55fs8vyOFwOAQAAAAAAACwqeDq3gEAAAAAAACgOARYAAAAAAAAsDUCLAAAAAAAANgaARYAAAAAAABsjQALAAAAAAAAtkaABQAAAAAAAFsjwAIAAAAAAICtEWABAAAAAADA1giwAAAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsDUCLAAAAAAAANgaARYAAAAAAABsjQALAAAAAAAAtkaABQAAAAAAAFsjwAIAAAAAAICtEWABAAAAAADA1giwAAAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsDUCLAAAAAAAANgaARYAAAAAAABsjQALAAAAAAAAtkaABQAAAAAAAFsjwAIAAAAAAICtEWABAAAAAADA1giwAAAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsDUCLAAAAAAAANgaARYAACiVa665RoKCgswpUJME6mu7uP0u62UAANgNARYAoEwyMjLkyy+/lAkTJsjgwYOlefPm5oOQLg8//LCtj+qBAwfk7bffliuvvFI6dOggMTExEhERIU2aNJGLLrpIZs6cWd27WGOtXLlSHnnkERk4cKAcd9xxkpSUJGFhYea0e/fu8vjjj8vBgwerbf/0tWu9jnX58MMPS9ymX79+Rbb5+++/xS6mTJliHtP3338vdpCfny8ff/yxXH311dKuXTtJSEiQ8PBwSUlJkbPOOkvuvfdeWb16tdRG7q+9khYAAGqb0OreAQBAYFq+fLlceOGFEogaNGggeXl5zv9HRkaaEGXHjh1mmTVrllxwwQUybdo0iY6OrtZ9rWneeustefnll4sc+6ioKBNa/fDDD2Z5/vnn5bPPPpNu3bpJddOg87LLLvN5+c6dO+Xrr78Wu9IAa8GCBeb82WefXa37snTpUhk+fLisX7/euU5/7uLi4kyovGTJErM8+eSTJhT/4IMPTLhVG9WvX79K7qdhw4bSvn17cwoAgN1RgQUAKLPExET5xz/+IXfddZf5sKnBUCDQ8KpLly7yyiuvyMaNGyUzM1PS09Nl8+bNcu2115rraHXZDTfcUN27WuPocX/mmWfkxx9/lEOHDpljn5aWJkeOHJF33nlH6tWrJ/v37zeVcKmpqdW2n8nJyaYyb+7cubJ9+3af15s6daqpKmrRokWV7l+gmT17tgnQNLzSarsnnnjCnM/JyTHhlZ6uWLFC7rnnHomPj5cZM2aYKs/aavfu3SUuFUGfh3Xr1plTAADsjgALAFAmPXr0MFUz+gH/6aefNlUqOgwvEMybN0+WLVsmN910k7Rq1cq5XkOIyZMnO4Or9957T7Zt21aNe1rz6NCxO++8U7p27WqGj1liY2PNZXrM1d69e2XOnDnVtp8aXg0ZMkQKCgpMFVNxFVqKHkK+/fXXX2a4bnZ2thmy++uvv5qgqm3bts7rhISEyOmnn26CFA2SBw0aVKHPJwAACHwEWACAMtEPnBVBQ4pLL73UhEc6XK+4ni8aLlWE3r17F3u5VYWlfvrppyrff61MevPNN2Xo0KFy4oknSt26dc1QO+0zdsUVV5ihWL5olYvVh8zhcMgbb7whZ5xxhqlq0aFaOizPComK8/7775ueVLpNnTp1zG28/vrr5jYrkwZbluIqn6ritTNixAhz6ivAWrx4saki0hC0Z8+eJd6e9qHS/W3cuLEJe7XKSysYNQTTKq6KfD51n3U7a/ig9h1zPybeenXputtuu006duxoQkU9rtqrbOzYsbJ161Ypi/vvv99U2elrWPvLaa+54ujr/dNPPzWvu8r4ucjNzZWJEyeawExDVF1fmh5hZXke7aq4Ju6ux0wr5HRo50knnWTCXa2+7du3r6lULc5HH31khmPrkEgdLqrHW4NL7YGnQ4mzsrK8blee12FZ7xMAEAAcAABUkObNm2u64XjooYdKvG5GRoZj4MCB5vq6BAUFORISEhyhoaHOde7LihUrquS5WrVqlfM+P/nkkyrffz1+1jYhISGOxMRER0RERJH7mjRpktdte/XqZa5z//33OwYNGmTO6z7Fx8cX2ZcHH3zQ6/YFBQWOESNGFLkvvf/g4GDz/8suu8wxfPhwc15PK9qcOXNscez1tazHonXr1ub/CxYs8LjuyJEjzWWPPvqoY/78+c772rx5s8d1b7/9do/91efWWnfOOec40tLSKuz5/PDDDx3169d3hIWFmctjYmLM/12XrVu3FtnmvffeK/I60/NRUVHO/8fFxTm+/vprR2ns3r3b+dq59tprHeVRET8X48ePd5x55pnO46i3odvp86dKem2X9Xks7eMrreL2u6yXWcfs3nvvdfTo0cN5zPQxu772fP2+d/09oktsbKwjOjq6yDpvPyvleR2W9T4BAIGBAAsAUC0B1kUXXeT8IPrAAw849uzZY9ZnZmY6nnvuOeeHjTPOOMPx9ttvmyUrK6tKnq0XXnjBef/r1q2r8v1/7bXXzDH86aefHNnZ2WadhimbNm1yjB071nxw1vtduXKlzw+d+sG8Tp06jilTppjAR23bts0xYMAAc7mGCuvXr/fYXgMAa99vueUWx759+8z6w4cPOx5++GHnh/aKDLD0uOiHyhdffNHst952mzZtfB6vyjz2rgGWeuyxx7w+1vT0dPPhWI+jBkHFBVj6uKzLrr/+eseuXbuct6H7awVvw4YNq/Dn09q+pJ/Jb775xtyG7svdd99tHoO+5nTRn4FLL73U3I4GZ1u2bHH464MPPnA+dg0ny6Mifi70OdNFXxPWcdy/f7/jwIEDJQY65XkeAznA0tedhkj/+c9/zM+Y0tf8kCFDnPs7a9asItsuWrTI+bp86qmnnMfXOt4aQOl97tixo8Jeh2W9TwBA4CDAAgBUeYA1depU5wefyZMne72OfgjUy5OSkqr0GTp06JCjYcOG5r616sCO+3/zzTf7rGixPnTqMm/ePI/LNchp1KiRuXzChAlFLtMPp3Xr1jWXXXXVVV7v+5577nHefnkDLNcqC9ele/fuPkOSyj727gGWflDXD8RawXTkyBHn9d566y1zvb59+5r/+wqwNCSxjunll19eYmCq4UxFPZ+u2xf3M5mfn+9o27atuZ6GRL5YVW8aFvlLK8es/a/s4MDfn4vPPvvM5234CnTK+zyWNsByr5ZzX8aMGePXfpfnMtdj9uabb3p93fTs2dNc3rFjxyKXaYCk688991y/H395X4dluU8AQGChBxYAoKqHrstjjz1mzutMc679plwNGDDAnOoMZbt27aqSfdOG3VdddZW5P+2t89JLL9ly//v16+fsweSL9q/y1utLe/acd9555vyqVauKXPbNN9+YxvzqwQcf9Hq72nxbj01F0FkrtU+N9tSx6D4///zz0qxZM1sc+6ZNm0qfPn3k6NGj8vHHH3s0bx85cmSx23/77bfOY6q9hLwZPXq0NGzY0Jz/73//W2HPp78WLlxoGq1rL6dRo0b5vJ422Vdff/2137etz4FFe1ZVJn9+LrSnkvX6KI2Keh79tWfPnmKXqpyhU38GrH5wroKDg01/M7VmzRr5/fffnZdZEzTs27fP775g5X0dluU+AQCBhQALAFClfvzxR/MhRelsdL4kJSU5z2vT5aqgDYKtme+02a82LK6u/d+0aZO5/dNOO818MNOm+Vbz7QsvvLDEJufa6NuXRo0amVPrA7l7w3r9wNqmTRuv22pjbd2niqCNmnfv3i3p6enmQ/mzzz5rZqjr0qWL1wCtul471of3t956y5xu2LBBFi1aZBpZa5BWHNdj2q5dO6/X0ef2nHPOKXL9ing+/bVkyRJzqqGI3pYGi96W6667zlxvy5YtUl3K+3OhQWBZVNTz6K//jZLwuRQ3M2ZFs5q5+5qNNjQ01OMxa1N7Dbp/+eUXcx1tvq+zS1bm67As9wkACCyFf3EAAKgi3333nTnVDyI6g5ove/fudX7Lr9etbPqh2Kq4eu6553xW1lTF/utMbZdffrlkZ2c71+msc/rhTD9I6oxgOiObVgX5ojPU+WJ94HQPd6x91tnVilPSLHJlkZKSIuPGjTMfPPW4aqWVBln9+/ev9tfOxRdfbMIq/YCtAZoVHuhzVFI1WmmPqXX9ing+/bVz507n9hokliQzM9Pv23YNEzVgs8K2sqiInwt9nZVFRT2Pgai4x6zHXp9jfd24PubWrVubmT9vvPFGEzzrourVq2cqCXXWSJ0V0DUYK+/rsCz3CQAILFRgAQCqlDXMRMMJDRh8WbBggTnVKqjw8PBK3ae7775bJk6caM5rFZBO315d+69DrnRKe/2QrtUc33//vWRkZJiqBP1QpxVLn3zyidRUelzPOussc/7111+3xWtHh+lpcKL0A/LUqVPNeW/DqgKRNdxKq7xKqvyxFn/pkD2LVsaUVUX9XGiVFKrG//3f/5kqqf/85z8ybNgwU72mw/t0KK5WLvbq1UvS0tIq9HVY2vsEAAQWAiwAQJXasWOHOdU+J77oB5nPPvvMnLeGBVWWu+66S5555hlz/umnnzZVQNW5/1988YX5gKUVP7NnzzYfuKKioopcRz+sVwarOsV6jL6UdHlFVXzoUD27vHassEr7c+kQtRNOOEFOP/10v49pccPaXC8va4VQeVhVapUxNFArX6ywUSuoyqo6fy4C5XmsLMX9vGugaPU58/aYte/ZDTfcIB9++KFs3brV/ExrHz2tgtJhuK79xCrqdVia+wQABBYCLABAlbKGO7k2d3b32muvyf79+021hNXvpLKGDWrFlRVeaZhV3fu/bds2c9q+fXuJjo72ep25c+dKZbACGd2HjRs3er2Ohgg///yzVHafI2/D5qrztaPH5sQTTzTD1Pxp3u66nRVsrF+/3mfoNn/+fHO+c+fOUpGs8Ki4qimrL5QGQOXt3eROm/Rfcsklzsbmvo6BN677XJ0/F3Z4HquTVjT6ev1oIJSXl2fO+xPo6jC/J554wgzns5rjV/brsLj7BAAEFgIsAECVOu6448ypftA7fPiwx+Xr1q0zQ/rUmDFjpEWLFpUWXrkOG/QnvKqK/dcm6Uo/JGdlZXlcrk3OyzvDmS99+/Y1FS7Kmu3PnQZ9pemB5P4Bv6ThZ9rnavny5c7m0XZ67Tz11FOmQk+XK6+80u9javWB8lX5oaGb1f/HGqpYUbRHlPJ2vFyrpKym/bfffrszpPOltM3iJ0yYILGxseZ1M3jw4BIr+LSPlYZerjPtVefPhR2ex+qkVUzvvPOO11lb//Wvf5nzHTp0MAGvxbVPmTdW9ZzrUODyvg7Lcp8AgMDCb3AAQJnpB02tdrEW/UCjtDeN63qdZc61R4lVyXPppZeaD0dKP5S+++67pom3NmHWb+Mff/xxn7PXWTOPlWU4iGvPq3//+98lDht0VRH7X5xzzz3XfMDSD2d6X9aHff0wp31c9PLiGnqXh37Ae+CBB8x5/cCqvcCsaid9vBpq6QdWa7r60tIqmlNPPdV80NcqK/cKmyeffFIGDRpk1uswIP0QW5XHviQXXHCBCTt10cbQ/h5T6zX6wQcfmAbTVoNq/Tl54YUXnD3XtGdPRc3waNGhjtYQPF/BkVa2ac8gPV28eLH07NnTBImuTeH1+dLraGXRK6+8Uqp90Fn79PnRfmRr1qyRU045xYSBrkNENdzUHlk6+2SrVq1kxowZtvm5sMPzWJ00PLzpppvkjTfecIaH+vOqIZ1VcaYhpatbbrlFhg4dKtOnTy/S3F3/FujryOoj169fvwp7HZblPgEAAcYBAEAZNW/eXBOIEpfhw4cX2e6WW24pcnlCQoIjNDTU+f+LL77YkZqa6vN+N2/e7LzuQw89VKp93rJli3Pb4OBgR/369YtdnnnmGY/bKO/+l2T8+PFFbr9OnTqOsLAwc75ly5aO999/33mZu169epV4XPQyvY5e111+fr7jqquuKnKMEhMTHSEhIeb/l112mXk+vT2vJXF93nQJDw93JCcnO2JiYoqs18e4cuVKr7dR2cfeOjb62i6N+fPnO/dBH6e722+/3Xl5UFCQOaau+927d29HWlpahT+f69evd0RGRhZ5vetj02Xbtm1Frjtz5kxHXFycc5/0NZeUlOSIiIgocswnTJjgKIvFixc72rRp4/EaqFu3rtk31+Nz+eWXO3Jycqr050KV9Nou6/PoD+t51KWk30u6LFmyxK/9Lutl1jG79957HWeddZbzNaGP2fV5uP/++33errXExsaan1XXdXqb6enpHtuW9XVYnvsEAASGwmYSAABUoRdffFG6detmZpn77bffTAWDNvA988wz5dprrzXVFMVxrSTp2rVrqe7bqhKzzpc0Xbtr9VhF7X9JtBJJZ2976aWXzMx7WoGgQ2suvvhiUz1WntncSqJVLlqpoEOmtMJB71973HTq1Mk8tuuvv77Ms+81atTIzBSnM8gtW7bMDLey+lU1a9ZMTj75ZFOBpb1q3Bt0V9Wxryxa6TdgwAB5+eWXZcmSJaayTSuGtBrpqquukquvvrpSZshr27atqZLRHkB6zPV+rZ5F1qlFZ2nTqih93r/88kv566+/zNDDmJgYM3xTq160eqWszfG1Mk6HeeprYM6cOWZ/tFLmyJEjpuJO70Obs+vx0F5Xdvq5qOrnsaTfS6qkIXYVRSvntBJKq1Z1mKZWQWlVlva8uuOOO7y+HrSSU6vQ9LW3du1a09dKf5dqo3f9OdfqLV/Hqqyvw/LcJwAgMARpilXdOwEAQGnocBX9sHLWWWeZJsIAgIqlPei0gftDDz3EzH0AAFugBxYAIODMmzfPnFoNhAEAAADUbARYAICAojNN/fjjj3L++eebpt0AAAAAaj56YAEAAkpERIRkZmZW924AAAAAqEJUYAEAAAAAAMDWCLCAUs4+NHjwYDOrk87Ao5UgzZs3N7Pa6IxI7h5++GEJCgryudxzzz0+70tnN9IZdnRmptjYWOnSpYuZGaw427dvN7OD6UxfkZGR0q5dO9N8NSsri+cZAAD4TWcL1bme9L0MAAB2wCyEQCkkJyfL0aNH5aSTTpLGjRubdWvWrJH169dLWFiYzJgxQ/r37++8vr7pe+SRR8zU4TrVtzudBvrSSy/1WD99+nQZNmyYFBQUSM+ePc396hTWOo30uHHj5Nlnn/XYRqec1qnldUr6E044QTp06CA//fSTme5a71+318ANAAAAAIBAQw8soBRmzZolp512mqlucvXKK6/IzTffLKNGjTJVUKGhRX+0dP0111zj130cPHhQRo4cKfn5+SbI0oovtWfPHjnrrLNk4sSJJiTT6a1d6e1reDVmzBiZNGmSWZeXlydDhw6VmTNnyhNPPMG3qAAAAACAgMQQQqAUtJLJPbxSo0ePltatW5uQ6Y8//ijXMZ08ebKkpaXJoEGDnOGVql+/vjz99NPmvIZYrpYvX26GHKakpDivozRIe/XVV0112AsvvGACLQAAAAAAAg0BFlBBNCRS4eHh5bqdzz//3JwOGTLE65BDDdDmzp1bpK+Vtc2AAQM8hglq8NWjRw85dOiQLF68uFz7BgAAAABAdSDAAirAu+++K3/++adp7q6Lu3nz5sltt90mN954o0yYMEF+/vlnn7f122+/mdNOnTp5XKbhmPa30vBK+275s43r+lWrVpXh0QEAAAAAUL3ogQWUwTPPPGOat2tD97Vr15rzOvPfBx98ICEhIV4DLlcPPPCAXHLJJTJlyhQzw6BFhw6mpqaa802aNPF637pem7Nv2bLFNJNXW7duLXEbpdsAAAAAABBoCLCAMvj666/NrH6W5s2by9SpU02Dd1c686DOGHjBBReY6+gwvoULF8rdd99tGrRro3ZtsG5JT093no+OjvZ63zExMeb0yJEjHtuVZpvidOzY0et6rTKLioqSZs2a+XU7AAAAgN3ol7/6/nj37t3VvSsASoEhhDVcUFCQWRISEuTw4cNer/Pkk0+a6zz88MNS3f7++2+zL+4z7NmN9qByOBzOQEqHDfbq1Usef/zxIte78sorZdy4cdKhQwfzR1Iroa644gpZsWKFJCUlyaeffipLly6VQKGPOTc3V+y2T9o4X08BAACAkuj7WR1JASCwUIFVS+iwtH//+9/y6KOPVut+fP/999K7d28ZPny4GT4X6DQY1AbpX3zxhXTr1s0MDTz33HOlc+fOxW7XsGFDGTFihKnO+uqrr6Rr165mvetwwoyMDImPj/fY1vpjGxcX51xnbafbeONtm+LokMjiKrN8XV5db0C0N5j2AbMa6QMAAAClHW0AwN6owKoFtKJJZ66bNGmSqRhCxdPgZNiwYaYKaPbs2X5tYzV737Vrl3OdBlZ16tQx57dv3+51O2u9Dkm0WEP6SrMNAAAAAACBggCrFggODpbrr7/eNAjXih9UjuTkZHO6b98+v65vhYlWfyrLySefbE5Xrlzptdpo9erVJpBs166dX9u4rreavgMAAAAAEEgIsGqJe+65xzTffvHFF+XAgQN+b6dD0h577DE54YQTzPZaHdSzZ0/58MMPvV6/RYsWpuJLK5H0vjRY0cbip5xyilxzzTVm+KB65513nP25fPXfyszMNPutVUMRERGmIfpTTz1l215HCxYsMKetW7cu8br6GKzm7Z06dSpyWb9+/czptGnTPLabM2eOZGVlSZ8+fUyI5b6NVn9lZ2cX2WbPnj2yaNEiSUxMlO7du5fpsQEAAAAAUJ0IsGoJ7bl04403mlnonnnmGb+20etqWPXggw/K3r17pX///iYAWb58uVx++eUyduxYn9vqfWnz8pSUFBk4cKC0atVKzjrrLDnvvPOcIY/2wbIWDbhc5eTkmF5Sb7zxhpx++ukm+NqxY4cJtLTPVHVYsmSJ6VdVUFDgURWlYd27775rQj4dSmhVYr388sseM//pjIE33XSTLFu2TBo0aCCDBw8ucvmoUaPMUMJZs2bJjBkznOv1OdDZC5UeW1ddunQxz41eZ/z48c71eXl5Mnr0aLOPY8aMoUcUAAAAACAwOVCj6VMcEhJizu/evdsRHR3tiImJcezdu9d5nSeeeMJc76GHHiqy7S233GLW9+7d25GWluZcv3btWkdKSoq5bPbs2UW2ad68uVmfnJzsWL16tcf+zJ8/31w+fPhwr/u7efNmc7kuvXr1cqSmpjovW7FihXks+hiOHDniqGpvv/2287Gdd955jiuuuMJx7rnnOho2bGjWR0ZGOj766COPxxIbG2uOoV6/b9++jqSkJLM+ISHBsXjxYq/3NW3aNEdwcLAjKCjIbDtkyBBzfd3ujjvu8LrN+vXrnbd94oknOoYNG+Zo1aqV+f+ZZ57pyMrKKvcx6NChg1nsJCcnxzxGPQUAAAAC8T0tgJJRgVWL1K9f31T+6Ix0OhSvOHqdN9980/TPeuWVV4rMXnfcccfJ/fffb85rY3hvtAqoPLN76P2+9tprRWbh00qsCy64wAxr/Omnn6Sq9erVS+677z5p3769rFq1Sj755BNTlVW3bl259dZb5ffff5ehQ4c6r5+UlGSOw2mnnSbr16+X6dOnm+tr1ZVWUGkvK19D+i655BJZuHChqVj75ZdfzCyHOoRSZ26cOHGiz6bwel0dqqnVXzpEUY+jVqx99913ZhgmAAAAAACBKLS6dwBVSwOV//znP/Lqq6/KXXfdZUItb37++WfTg0pDIw2s3F111VVmSJoGMjqkToMSVzpssDy075UGRe6sxuWuM/dVlZYtW8rjjz/u9/U19HvyySfLfH8abn355Zel2qZp06by9ttvl/k+AQCBRYut7dobEgAqm9VPF0DtQIBVy9SrV09uvvlmefrpp0248txzz3m93s6dO51N2b1JSEgwDd1TU1PNbHpabeSqWbNm5drPJk2aeF1vVYK5NyoHAKC20C+OrL+//D0EUNvpKAOdrEg/m7h/qQ6gZuEnvBbSyqvY2FhTiVWeSqbivu1wnSGvLPjjAwCAJ6222r17t1kIrwCg8Itt/Z2oM29TkQrUbFRg1ULJycmmZ9MTTzxhlkaNGnlcx1q3ZcsWr7eh3/wePnzYzLqn33gAAIDKpzPb6t9gpTP9aq/IkJAQDj2AWik/P1/S0tLMTNz62SQmJqZID10ANQsBVi2lTcRfeuklef311+W6667zuFwbj2s4pb2w/vrrL9Mg3NV7773n7NNUmmqp8PBwc5qXl1fuxwAAQG2jH9SUTiDiPnwfAGob/Ryivwv1s8XBgwdNyE+ABdRcDCGspfQXvTZh15JbnW3QnX57MXLkSNNnQ3tm6ayEFp1Rb8KECea83kZpWJVdf/75Z7kfAwAAtY3OxKtcZwcGgNrO+p3o+pkFQM1DBVYtr8J68cUXnd/mutPhhUuXLpVvv/1WWrVqJb169TJ/FObNmydZWVkmvBowYECp7lObwp900kny008/SZcuXaRjx45m6IPOWljemQsBAKjJtLeLDpexmhYDAKTI70T9Ham/K5mZEKiZqMCqxbR31W233VbsNxkLFiyQRx55xPTN+uyzz2TRokVy+umny3//+1+ZNGlSme53+vTpctFFF8mmTZtk6tSppgJs5cqV5XgkAADUfK7NiflwBgDi9XcijdyBmivIwU84AD9pxZxas2aNbY5Zbm6u6a2Wk5MjYWFh1b07AFBpdFi/NQS/ffv2zNgLAGX8/WjH97QASkYFFgAAAAAAAGyNAAsAAAAAAAC2RoAFAACAgO9/Uxv7gulj1glyKsLff//tPI7WohPtaB/Uc8891/QwLa9rrrnG3O73339fIfsMAKhdCLAAAAAAGDExMTJ8+HCzXHbZZdKsWTMzI/WQIUPknnvusc1ROvvss00YpsEbAKB2IMACAAAAYGjF1ZQpU8zy/vvvm5mi3377bXPZ008/Lb///nuZj9QTTzwha9eulS5dunC0AQClRoAFAAAAn3TCap3di4mray8d+te7d2/zGpg1a1aZb6dhw4Zy3HHHSXR0dIXuHwCgdiDAAgAAgE+TJk0yoYOe1gSHDx+WF198Uc477zxp3ry5RERESFJSkpx//vlmqJw32mfKV48t7eekl2nI46vf08KFC+Wcc86RuLg4iY+Pl379+skff/zhcx+/+uorGThwoNSvX9/sX9OmTaV///4++1Dl5+fLU089Je3atXNef/z48ZKdnS0V5dRTTzWn27Ztc67Ly8szx/K0006T2NhYs2h11auvvmr2yd8eWK7Hd/LkyXLSSSdJVFSUNGjQQG644QbznLn36lqwYIH5f8uWLYv07QIA1FwEWAAAAPBJAwX15ptv1oijtHTpUhkzZoysX79e2rdvLxdffLE5/eabb0yo9dZbb1Xo/c2ePduEVxkZGXLhhReaKqQvvvhCevbsKbt37/a4/rhx4+SCCy6Qzz//XNq2bSuXXHKJtG7dWpYsWSKPPfaY1/u44oorZMKECeZxaMP1I0eOmOF+1157bYU9Dr1NpQGZ0oBq0KBB5lhu2LBB+vbtK3369JF169bJ6NGj5dJLL5WCgoJS3cfdd98tN998szlGegy04uv11183YZ5VAaghmfbn0nBP6fGxenbpAgCouUKrewcAAABgTxpGrFmzxpxfvXq1GUqoIUkg0/3/8ccfpWvXrkXW//LLLyZouv3222Xo0KEmKKkIzz//vKmcuuiii5zBz7Bhw8y6V155RR599FHndd977z3597//LY0aNTIB1imnnOK8LDMzUxYvXuxx+1u2bDFD8v766y9TsaQ2b94snTp1Mj2sHnnkEROAlUdWVpazOk2ro6zHpUFcx44d5bvvvnMGSrt27TLDDWfOnGke3y233OL3/bz77ruyatUq52ts//790q1bN1m0aJHMnz/fPD9Wjy5t4r5nzx559tlnK2wmRgCAvVGBBQAAAGPv3r3y2WefOZeJEycWOTL6f9fL9fqBRoecuYdX1hA5rf5JS0szYUlFufzyy53hlQoJCZF7773XnNehha7+9a9/mVMNsVzDK6VD6rTKyZsXXnjBGV5Zj/HKK6805zX8Kavc3FzTtF1nINShezrUUiurrPu09tUKr5RWTz3zzDPmfGmHnWqFmWtAqmHVjTfe6PVYAQBqHyqwAAAAYPTq1ctUXfnyxhtvmMWivbF0VrlAo1VQWjX0ww8/mIohq1eUVjG5nlYEHdLnTntVKb1vy86dO82xTEhIMBVg/goLCzMVT/7chz+0ostbLykNqbRqrE6dOrJ161az1KtXz+vj035d+jh0aKEOk3QN1yriWAEAaicCLAAAADj7CT3++OOlun6g2b59uwlYfvvttxL7PVWEJk2aeKzTZu7Ktcm61Ry9VatWpWpGruGQVnX5cx/+iImJMRVXSm9Xgygdjqi9wqzZAzVsU9oE3xvdf71Mm6/v2LHD7wDL32MFAKidCLAAAABgaCNw7XF0/fXXS2pqqs+jolU4WollDScLJKNGjTLhlYZv2jRch6xpSBIcHGwahuusd1bDcH+U1Khcb7cyVfTtWz2myqssMwJW9rECAAQ2AiwAAAA46fC1Ll26mKqbQ4cOeRyZxMREWblyZUA2zj569KhpRq7D4T766COPyqVNmzZ53S48PNycpqenezR3tyqnyqtp06bOfdAArSwBUFXRJvPWcENfrMsaN25cZfsFAKjZ+JoDAAAARYSGhnoNr5Su175LgUiryrRiShuNu4dX2rBcZ87zRq+v1q9f73GZNTtfRYRCxx9/vBl298knn4idNWvWzCz79u0zvcTc6QyK+jpp06aN38MHS8sKFfPy8irl9gEA9kOABQAAgCJ8BTn+Xm5XKSkpZvjj6tWrZcmSJUWauo8fP95rQGU1t1dPPPGEua7lgw8+MEtFueeee8zpHXfcIatWrSpyWVZWVoWFZRXh1ltvde6rBlkWbdp+1113mfNjx46t9CqwP//8s9LuAwBgLwRYAAAA8BlQDRw40MxMqKeWGTNm2PKIde3a1ecyefJkU1mmfa+0akdDKZ317rLLLjOVQv/5z3/k5ptv9nq7ul5n3Js2bZp06NDB9P465ZRT5KqrrqrQkObqq682wZA2PtchnD169JArrrjCzDKoVWBWMGQHt99+u1xwwQUmaGvbtq0MHjzYNHrXWQN1NsWLLrpIRo8eXWn3b70e9fjo86G9zXQBANRc9MACAABAEfHx8RIZGSkTJ06Um266yfRj+vTTT+WVV16RO++801Qx2dGyZct8Xnb++eeb0/vuu8/Mdvf888+bKqyoqCg566yz5NFHHzW9vbzRnlkLFy40AdKCBQtMwHTaaaeZiig9Ns8991yFPYYXXnhB+vTpY471ihUrZPny5aZyTPdx5MiRYhc6BPOzzz4z+6lN37/++muzXgO+ESNGmGb4ldmUXQMzPe46mcDs2bOdsxRqUAkAqJmCHKWZZgVArdaxY0dzumbNGrEL7VmifTBycnICticLAPhDezdZw6V05rzKDAf0d6oOldNwx11mZqYJL6weRAAQaL8f7fieFkDJqMACAABAEcWFU95CLQAAgMpGDywAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAQMCbP3++XHLJJdK4cWMJDw+XxMREad++vVx66aXy0ksvSWpqapHrn3322RIUFCR///232M3DDz9s9m3KlCkSaHSfdd/1MZTF8uXLzfa6PProoxW+fwCAwEWABQAAgICmQcc555wjM2bMkDp16kj//v3l3HPPlaioKLPu1ltvlbVr10ptpEFQixYtJFC8++67zvPvv/9+te4LAMBeQqt7BwAAAICy+vnnn021T1hYmHz88cdy0UUXFbl89+7d8t5770lCQkKR9VOnTpWMjAxTsQV7yM3NlQ8//NCcb9Cggaxfv16WLVsmZ5xxRnXvGgDABqjAAgAAQMDSCiuHwyFDhw71CK+sIOTOO++U4447rsj6Zs2amXUafMEevvrqK9m/f790795dRo8e7VGRBQCo3QiwAAAAELD27dtnTuvVq1eq7Xz1wLKG3OXl5cljjz0mbdq0MUMRjz/+eHn77bed15s3b5707t1b4uPjTb+tq6++Wg4cOOBxP3pbepvefP/99+aya665xq993rBhg6k269atmwnmtNdXkyZNzH1rtZK3XlRqy5Ytzr5Suuhjd6WVaE888YSceuqpEhsba5auXbvKO++843NflixZIn369JG4uDhT3XbeeeeZaqny0Eo5deWVV5pFffTRR6Yyyxvr2GqAOWnSJOnQoYNERkaaqroxY8bI4cOHvW6nj1ef2xNOOME8tzrstGfPns7qL29WrVolAwYMMI9VH7Ne/9tvvy32OdT9+uCDD8zwVn2N6L7p60ifQ90Hb/R19+qrr5rnWF9bun+nnHKKPP/88+YyAKjNCLAAAAAQsJo2bWpOp0+fLnv37q2w29WKrokTJ8qJJ55oworNmzfLyJEjTYg1bdo0E9hooKCnMTExplJIK8A0tKgskydPNv2+jh49Kp07d5aBAweakEPvW/+vIYtFg7fhw4eb87p/et5azj//fOf19JhpWHLfffeZ4Za9evUyj3fdunUmlNH+Ye7mzJljQrDvvvvOhEYXXHCBbNu2zWz3448/lumxaZP9zz77zIRyeuxbtmwpZ555pqnI0sqs4ug+3nXXXSbMGzRokOTn58uLL75oHktaWlqR6x45csTs54MPPmgeu/ZL04ovbR5/+eWXy9ixYz1uXx+THiN93M2bNzfbZGVlmeOoFYDeFBQUyP/93//JFVdcIStWrDAh1IUXXmieu0ceecSEn5mZmUW20f9r7zatPtNAUkPEvn37yq5du+T22283kxTo7QJAreUAAD916NDBLHaSk5OjnxTMKQDUZPn5+Y4//vjDLHoehTZu3OiIiooyfwvi4uIcw4cPd7zxxhuOlStXOvLy8nwepl69epltNm/eXGS9rtPlhBNOcOzdu9e5ft68eWZ9w4YNHUlJSY45c+Y4L0tNTXV07NjRXK7Xc9W8eXOz3pv58+eby3SfXT300ENm/dtvv11k/Y8//ujYtGmTx+289dZb5vq9e/f2uEzX6z74cuGFF5rrjB071pGVleVcv3v3bsfpp59uLvvyyy+d69PS0hz16tUz6/V+LQUFBY7x48c7j58+htKYPHmy2W7QoEHOda+88opZd+mll3rdxjq28fHxjp9++sm5/siRI45zzjnH+bhc3XLLLc5jpY/FsnbtWkdKSoq5bPbs2c71+rPWrl07s/7xxx/3us/ensOnn37arD/77LMdu3btcq7Pzs52XHvtteYyPV6uRo8ebdYPGzbMcfjwYed63U/reXr11Vf9Op61TWl/P9rxPS2AkhFgAfCbHf/YE2ABqC0IsHybO3euo2nTps4wwVoSEhIcN910k2Pnzp2lDrD0Nt2deuqp5rIrr7zS47JJkyZ5DW4qMsAqTvfu3R1BQUFFgo+SAqxffvnFXN65c2evH/o1BNTLBw4c6BGW9ezZ0+vf5CZNmpQpwLKej08++cS5bv/+/Y6wsDBHZGSkx+NyPbb33Xefx2Vr1qwxxyM2NtaRmZlp1qWnp5uwMzg42ARW7l544QVze3369HGu+/bbb826tm3bej1Getzdn8Pc3FxHcnKyIyYmxgSB7jIyMhwNGjRwJCYmOm9zz5495rHq61gvd6chWHh4uOOkk07yeQxrMwIsoHZgCCEAAAB8WrRlkXR5o4s5tat//OMfpj+UDue68cYbpVOnThIaGmp6IGk/IR2+9eeff/p9e9rY3b1PlGrVqpU51WFevi7T4V6VKT093fRVGj9+vFx33XVmmJ8uer+aV23cuNHv2/rmm2/MqQ59DA72/Fhg9cTS4XWWRYsKXweXXXaZ1+M2ZMiQUj+mrVu3ysKFC01/Ke0zZUlKSjLD7nS43ieffOJze2/7okMbTz75ZHO8fvnlF+eMlTpMT18f7k391VVXXeXs72UN1dPzSofveTtGw4YN81i3cuVKM/RRh0DWr1/f43Lta3XaaafJoUOH5K+//jLrtJeW9vrSYYl6uTvteda2bVv5/fffPYYeAkBtQYAFAAAArwocBXLT5zfJip0rZPQXo83/7Up7J1188cUmsNKgQpu763ltnq29jm655Ra/b0vDgpCQEI/1GuYobRLu67Ls7GypLNo4XoMy7av09NNPm55Y2mhdl02bNjl7PPnLamD/z3/+s0iTd9dFAyANYyw7d+40p9oLyldj9dJ6//33Tfim4VdERESRy6xm7laDd29K2hdrn61TX/uoAZo2dNeASMMl10DS6rXmTmez9HVctcm7r+P6+eefm+tYx9ba5o033vC5zZo1a8xxOnjwoM9jAQA1WWh17wAAAADsafof02XNvjXm/Oq9q2XG2hkypEPpK2yqg4YRWo3VqFEj09h7/vz5Zua36OjoErf1VmlTmsv9VZqG3BokaXNzDS+0AblWHWlwo9U6Gm5oqKWVWaVpIm/d/1lnnSWtW7eW6qJN6K0qJN0XVzk5OeZUK7R0NkVfYVVF8TVjZGlYx1Ub6WuD+OJolZnrNlotqJVjxXEP+QCgtiDAAgAAgAettnpkwSNF1un/Bx8/WIKDAqeI/5xzzjGnOjOdDin0J8Cq6MowK4CyqrQsOnOfv3To3oEDB0yVks5i586qwCoNnbXPGkI4btw4v7Zp2LChOdUwyRtf633Rarm1a9ea8zoMVBdvNJjTSi2dLdHbfepskb72RUNM11Nf+6gzIeprRENBrdxzfby+nitv663jqsMUp0yZ4nU7X9togKczKAIAPAXOuw8AAABUS/WVxarCspOSKo6sQESDpOTkZKlqVgCyfv16j8t0iJm/rCFtVtDh/hi175I32pcqLy/P62V9+/Y1pzNnzvR7P3r06GFOP/74Y4/L9H6mT58upWENDbzzzjvNc+lt0cos1+u687Yv69atk19//dWEhlrVpLTvlIZTGppZvae87YtWTVlVdlYFlR4jb681b/fduXNnMxRxwYIFfg/36927txm2OmfOHNMLCwDgiQALAAAAHl5c/mKp1leXBx54QO666y6vzct37NghN9xwgzk/cOBAZzVUVerVq5c5feKJJ0wVmEWH++nir3bt2plTbVSv/b0sWjF07bXX+gw9tOpoz5495nruzjjjDBNiaaPym2++WdLS0jyu89tvv8lXX33l/P+ll15qhr1pqKS9tywa7jz00EOmIbu/9HhYx+Dyyy8vNjTTvmNaqaXhkzutWLIatSsdKnrrrbeafRoxYoSzKXpMTIyMHDnSDNfTx3v06FHnNhowTpgwwZwfM2ZMkQo+bZ6ukwBo3zFXWl1lNbV3H+J39913m35kgwcP9lodp69Na+ik0sen+6a9sPRY6HPmLagsbUAIADUJQwgBAADg4fw258v2tO3ikGNVJ0ESJOe1Ps9WR0uH5k2aNEmeffZZE/Lo7HORkZGyfft2WbZsmQl2tBfR888/Xy37p0HJf/7zH5k2bZrZt5NOOslU/6xevVrGjh0rzz33nF+3c/rpp5uwSau29HFasyRqkKSVZdrna9asWR7baXCnAY/OvKez4umxad++vQn9rKojnfnulVdekf/+97+mWklDLx1Ot2rVKjNETvdTr6Pi4uLkzTffNLPy6eyH2ihfG8tr0KWPS2dG1Ebk/s6CqEGNPh7dP1+0Gkpn+/v3v/9tQh+tpHJv9K5hnIZNWvmk/bJ2794tHTt2lMcee6zIdTVIXLp0qTmOut8aMGqQpQ3ydbZDDa9cZ0LU+9agrk+fPnLPPfeYwE2fRw1MV6xYYZ7fl19+2SMc1etqFZju7/HHH29mdGzZsqXp6aVh2B9//GFeC9bMh0pfxxpgaUiloaE+F9okXvdPr68Blj7PeuwBoDaiAgsAAAAe7utxn2wau0k2j93sXPT/ut5O7r//fhMSaIihlS9aEaNhkX7g79Kli6ma0aFk3mYOrAr169c3gUr//v3NjHZffvmlCVk0QNFwqTQ0oNIZA+vVq2duR6uRtJm7BjLatN4bDWx0BkYd3vfRRx+Z8MmaAU+lpKTIDz/8IC+88IIJZrSSSY+fhlca8DzzzDNmeJ8rqym+DnvTIE5vT4dK6pA5Dcn8ZVUgFVd9ZbGuowGS+5BI3Xd9nNrbSo+RNmLXYElfC3qsXWkAp/upfcQ0+Pvss8/M9TQg1ABPQyR33bp1M8dIn8PNmzebbXRo5hdffGEuc23G7hp8TZ061eyPBo+6nQZTixcvNiGiBohvvfVWkW20UkyfVw3MNJDTijN9Ln766SfznOs+u1eBAUBtEuQozVQlAGo1/SZT6TTOdqHfrOu3nvqNpr6ZBICaSoc9aeWG0gqaipoJDwhULVq0MKFVdX6c0ZkuX3vtNfnwww9NlRgC4/ejHd/TAigZ73wAAAAAwAdtxK5D+9xpRdvkyZNN9ZtWZwEAKhc9sAAAAADAB23wrkMFtWeVDqtUOrxPK3505kCtwNIG8QCAykUFFgAAAAD4oKGV9tTStgXa+2vOnDmmyb3OMKj9s4YOHcqxA4AqQAUWAAAAgIDjbVhfZdBG9y+99FKV3BcAwDcqsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsDUCLAAAAAS8+fPnyyWXXCKNGzeW8PBwSUxMlPbt28ull14qL730kqSmpha5/tlnny1BQUHy999/i908/PDDZt+mTJkigUb3WfddH4O/9Pq6BBLd3xYtWhRZ9/3335v111xzjdj1eXFdwsLCpEmTJnL55ZfLypUry30fejwC7XkEEFgIsAAAABDQHn30UTnnnHNkxowZUqdOHenfv7+ce+65EhUVZdbdeuutsnbtWqmNvAUtqL1at24tw4cPN8ugQYMkNDRUPvzwQ+natat89tlnYhe8bgF4E+p1LQAAABAAfv75Z1Pto9UkH3/8sVx00UVFLt+9e7e89957kpCQUGT91KlTJSMjw1RsARWhS5cuJijVENWuzjrrrCKVfbm5uTJ69GiZPHmy3HjjjXL++eebCsay+O6778ztAUBlIcACAABAwNIKK4fDIUOHDvUIr1SDBg3kzjvv9FjfrFmzKtpD1BbR0dFy3HHHSSDR4Pf55583VVi7du2S5cuXm5CrrNVdAFCZGEIIAACAgLVv3z5zWq9evVJt56sHljV0KS8vTx577DFp06aNGYp4/PHHy9tvv+283rx586R3794SHx9v+m1dffXVcuDAgVL1BSptz6QNGzaYarNu3bqZYE4rZbSHkd73+vXrvfY8Ulu2bCnS+0gfuyutRHviiSfk1FNPldjYWLPokLJ33nnH574sWbJE+vTpI3Fxcaa67bzzzpNly5ZJZTt8+LC8+OKL5v6aN28uERERkpSUZCqHvv322xKf608//dQ8tpiYGKlbt67p/7R9+3av2x08eFBuueUWadSokURGRkqHDh1k0qRJJjAtzfPp2tPs999/l4EDB5rXjO5Dr1695IcffvB6e1rN9NRTT5lebnr/Grrecccdkp6eXqE93HQ/2rVrZ85v27bNuV5fz3fddZe0bdvW3L8eLz3O33zzjdfb8fZa1/2zXnOZmZlyzz33OJ83/dnSx+d6PEvzugVQ+1CBBQAAgIDVtGlTczp9+nS59957JSUlpUJuVyu6rJBKK0sWLFggI0eONJdpaKPBhwYhGqT8+OOP8u6778rmzZtl4cKFldbIWod5Pf3003LCCSdI586dTQjwxx9/mPueNWuWLFq0SE466SRzXQ0HtM+RhlAaUAwZMsR5O65VQnv37pW+ffvKqlWrTCimgYoGChqqaBDz008/mcDI1Zw5c+Tiiy82IZ8Om2vVqpX89ttv0rNnz0pvYL506VIZM2aMCUs02NEwb+vWrSZU0UWPkfU8uXvllVfk3//+t/To0UMuvPBCE7hp5ZEOQ9X916DScujQIVOJpEMC9bhovygNtLSaT4PEstBjefPNN5vXk75u1q1bZ14v//jHP2TFihXmebXoczBs2DCZOXOmef60p5tWS2mIunjxYtO7qiIdOXLEnOprSu3YscM8n5s2bTLBmVY3alg8d+5c+frrr81xvP322/2+/ZycHPMY9PWqQdTRo0fNz5QGWnrfEyZMKNXrFkAt5QDgt4kTJzouvvhiR5s2bRzx8fGO8PBwR7NmzRxXXXWVY9WqVT63e/vttx2dO3d2xMTEOBITEx0XXHCBY8mSJcXe1+LFi8319Pq6nW7/zjvvFLvNtm3bHNdcc42jYcOGjoiICEfbtm0dDz74oCMzM7NCnuUOHTqYxU5ycnL0aztzCgA1WX5+vuOPP/4wi55HoY0bNzqioqLM34K4uDjH8OHDHW+88YZj5cqVjry8PJ+HqVevXmabzZs3F1mv63Q54YQTHHv37nWunzdvnlmvf2OTkpIcc+bMcV6Wmprq6Nixo7lcr+eqefPmZr038+fPN5fpPrt66KGHzHp9/+Dqxx9/dGzatMnjdt566y1z/d69e3tcput1H3y58MILzXXGjh3ryMrKcq7fvXu34/TTTzeXffnll871aWlpjnr16pn1er+WgoICx/jx453HTx+Dv6xt/KGPX4+DO32+ExISzPuzI0eOeH2uo6OjHT/88INz/dGjRx1nnnmmuezNN98sss2NN95o1p9//vnmepZly5Y5YmNjvR7Xkp5PXSZNmlTksttuu82s1/eSrt59912zvmXLlub9nWX//v2OU045xXl77q9fX/S15G3f1Jo1axwhISHm8r/++sus69+/v/n/FVdc4cjOznZed9GiReY46vV/+eWXEl/run/WvurzoD8rlhUrVpjb0dtzf85Ket2W9/ejHd/TAigZARZQCvqGNTIy0tGlSxcTZOnSrl0780c2LCzMMXv2bI9t9A2hXq5vrgcNGuQ477zzHKGhoeYP9syZM73ez7Rp08zlQUFB5o/9JZdcYt6U6e2MGzfO6zb6hiM5Odn5pnvo0KGOVq1amf937969yJvSsrLjH3sCLAC1RVUHWBMmOBwtWzocLVocW/T/ut5u5s6d62jatKnzg7K16N/Om266ybFz585SB1h6m+5OPfVUc9mVV17pcZkGE96Cm4oMsIqjf+v1fcPhw4f9DgI0gNDL9Usyb68pDYX08oEDB3qEZT179vT6N7lJkyaVGmAV55///Ke5nc8++8zrc62Xe3vP5f4cpKenm/dtwcHBjg0bNnhsYwV1pQ2w9Dlyp4GUt9vS6+p6DbLcffvttxUSYOnj1Nd5+/btzWV9+vRxhsL6fw3qDhw44HFbd9xxh7l81KhRfgdYeizXrVvncVtWUKbHzhUBFgBvGEIIlIKW55922mmmD4B7SbqWhI8aNcr0UbDKurXMWnslaG8GHV6gPQSUntfy6REjRphT15mRtDxdS9/z8/PNcIjBgweb9Xv27DGl7BMnTjTTg7v3AdCS/f3795uyer1PpaX9OgRCy8+1t4X2YAAAwB9ffy2yebPnem1/889/2usY6hAsHdb1+eefm2Fk2ohah8Rpv6RXX33V/D3VoVo65MwfOlTLW78dHSr3yy+/mKFQ3i5T2gi7Mmn/o9mzZ8uvv/5q3jNYs77p/ern/o0bN0qnTp38ui2rl5EODwsO9myNa/XE0uNp0WGK6rLLLvN63HTIlzYFr0z6HklnvNNhjvq4s7Ozzfq//vqryKk7b8+b1fvJ9XnTIYXar0mHR3prTK7DR7V3U2l5u399j6i9pVzvX59THVKoQ1Fdh9BZtPeYbqPPf2np0Dxvvc1OP/10MxRV6RBFpf2u9H7cXXXVVWYIofVa8If2vfL28+ft+AOALwRYQCl0797d63qdflj/kOubRh3bb/Wf0HXq/vvvd4ZXSvs16FTFL7zwgrz55psybtw452XauyEtLc30WrDCK1W/fn3T90LXaYjl+sZa31hqM1Xt+6HXcf6Ah4aaN+7aq0LvS/ejonsmAABqpltv1bDC+3o70obm2pdJF6XhlfY3uu+++0yfJ23G7avJtzvteRQSEuKxXsMc1bhxY5+XWWFKZdCeXBocWY3ri+tl5A+rAfg///lPs/iSlZXlPL9z505nIOGN9qaqTPpFoX6Rpz2rSnsMtOG9O+1n5v68VdZj9Hb/1j64hlHaPF17RunEBO5fmlq0L1VZAiwN5KxZBjVw1PeX2hNM+6BZIab1+H09Tmu99smqiMde2T83AGoOPskCFUTfBFhvoJV+c6dvNJW3b890nYZK+i2qa4Cl3x772qZfv37mjYxWdumbSetNjbXNgAEDnM03LdYbE90X/UaNGVwAAP645BKRjh1F1qw5tk57TLt8t2JrWt2sXxbpDHL6pdD8+fPNbHvR0dElbuutGqk0l/uroKCgVJVXWlWtocWDDz5ogiwNWLTxuFbqXHHFFfLBBx/4nCGvuPvXQMNbpZEdabW7hleXXHKJ3H333aaqR0MQfU5ef/11ueGGG3weg4p63sqquu/feq51pr/yKMskBXZ47AACHwEWUAG05PrPP/80VVZWpZX+X79N0m/PvH3rZJX36xAHV9Y3it7K/zUc0xlqdBYbnS7bqvQqbhtrvQZYel8EWAAAf+jnzYce0tn4jq3T/wfa59BzzjnHOexMq7L8CbAqkvXFlgZQVpWWZdu2bX7fjg7X0soc/YLrkUce8bhcZ4srLev9iQ4hdP0yrTgNGzY0p1u2bPF6ua/1FUFnrtMqOv1y7qOPPvKokivLMbDbY7SGFeoXo9oawvULy7K+dkpLQ9/iHqdVueetEhEAKlOAvQUB7OGZZ54xPacuvfRSEyhdffXV5s2OfvNpvZnSKZ2LK5nWqYH122Gdptkqddehg6mpqcVuZ613fVNR0n152wYAAH+rsOxcfVVSxZH2xrKCpOTkZKlqVhiiXzy583dIo9L3C77+1utjXLlypdftNAjRnpje6LAxpb0y/aVV3erjjz/2uEzvR/uNVRZ9j6RVY3pM3cMr7RtVmsdRHO13qpVt2gvLWyimQ1Mrkz5n2n9LX9szZszwuFy/lNQws7JYQwy/+uorE/q6e++994q8FipDca9bALUXARZQBl9//bVpgDlt2jRZs2aNKeHX8Erf8Fj0m1ZV3De9GmIpK8CytiluO/dt/Lkvb9sUp2PHjl4X7fEFAKg9tNrq1VdFOnfWCUvsWX31wAMPyF133eX1b5T26NEhZWrgwIHOaqiq1KtXL3Oqk6loFZhF3zfo4i+r2bUGGq49sDRguPbaa53N3L1V0+hEMN6CiDPOOMOEWNpHUyej0S/S3GmVtwYZFv3yTiuEvv/++yLNwDVseeihh5xfqlUG7fVZp04dWb16tdlnix7X8ePHew0Jy0Ir5bRRud7urbfeatpCWLQK/qWXXpLKpsNflQ4Xde01pUNI9fVemXRCAm1boe8bx44dW+S1pRMRaX9VDRD1NVNZinvdAqi9bPg2BLA/7UGlb9T021Cd1UiHDeob1Mcff7y6dw0AgAqlRRY6CV0lFluUi36J8+yzz0qbNm1MPyRt4q6zxGl1SMuWLc1EJ3pZZc+M54t+yNd2AvqlV4cOHUwAdMopp5iARMMBf+kscRo2aUCkYZbVsF4fozbd1j5f3mhwp5Us2k7gyiuvND2ktJLctZpGZxvUGZX1C7nevXvL//3f/5lG6dooXPfVNcDSflM6AY0GGFqN3rVrV9N/SyvS9Xavu+66Mh8rvS1fi05yoxPRaN8rfTz6vktn9dNeYPr8/uc//6nQQEUDR309ffHFF6Y/mN7PeeedZybi0cr7yqbPgT6/Gswed9xxZpin9v3Sx6r9pPSYqMoKZV977TXz2po6dap5n6s/Uzr7of5c6VBOnTRIXxuVpaTXLYDaiQALKAcdAqh/yPXNjVZf6bfAOu2xsvpcaMNYX/QNgOsMLK69MXxt576NP/flbZviaFWZtyVQGrwCAGoPnWFXe1Hqh1ydyER7RWlYpLMC6zAs/aD966+/Vlu/Hu3XpF92aSC0a9cu+fLLL00VkQ4f1A/ppTFr1iwzW6AGYno7OsRNg5WlS5ea9yS+ghidgVHDAO0bpeGTNfmLVdX0ww8/mIllNGD75ZdfzPHTvplaiaOhwZ133lnkNq2m+Bp2aTWU3p4O61uwYIGceeaZZTxSIsuWLfO56OyDSmeV1Mov7QOqVVj6peLJJ59sjoGGfBWlbt265vZvuukm86Xlp59+asLDJ598Ul588UWpbNooXZ8vff702OrzrcdBX+c6hFD7Y+l1EhMTK+X+9edF39NqbzQNDrXyT19v//jHP8xIhDvuuEMqU0mvWwC1U5CjNFOVAPBJ3+Dpt4IaYj366KPmzbJ+o6lvMnX6bm+hkgZP+sbDdRpkfQOqPR40MNI3ku46d+5syte1pN9q4q7fyumb2pdffllGjx7tsY2Wmuu305MmTZIxY8aU+VnUYYRK980utKxdv33U6aatmSABoCbS3j86QYjSyhBm9QJqJw3ztDpKq7HWrl1b3bsTkL8f7fieFkDJqMACKojVGNbqS6F/PPWbYP2/a+8Ci9Vs1QqhLPotouvl7mGNftOps9FYvTBK2qa4+wIAAIA9aRWce28z7QulQze1MkmrsQCgNiHAAiqIls0ra5idzl5jTd39ySefeFxfy/PVgAEDiqzXppmul7uaM2eOmU5ZexC4TqlsbTN79mzJzs72eKOjwym00qt79+7lfpwAAACofFrZr0NQ9f2k9qA6++yzTdXVd999ZyrydXgfANQmBFiAn7QPgjYx1RJlV/rNmPZC0P4bGloNGzbMeZnVH2DChAny119/FZnBRZtj6nBBnTnIlTapjI+PN0MCXadO1mGI+kZGub9h0R4fGk7pdXQWHot+O6dDCnUfdeggQ+wAAAACg1ZaaVC1bt06mTlzpulJpQGWvq/UWSBdv8wEgNqAHliAn6ZMmSIjRowwQwW1YbtOIa0NNH///XfTlFXfRGhT0aFDhxbZ7rbbbjO9p6Kjo83sQdqrSRu3avs5rbLS/lXupk+fbm5Hr6Pftul9aZNSnUpYQ7GJEyd6bKMBmc6Mc+DAATnxxBNN/yx9o7Np0ybTUFUbfuqQxvKwY78AemABqC3ogQUAFfP70Y7vaQGUjAoswE86XbPOfKN/FLUngQ4L1KosnaXm1ltvNUGWe3ildNrut99+W44//ngTXGn1lQ4B1BmJvIVXSqdJ1st1umadDUhnOdRv3DRE8xZeKZ3iWK+r39Zp3y39pk7/eGtTeS01L294BQAAAABAdaECC4Df7PhtFRVYAGoLKrAAoGJ+P9rxPS2AklGBBQAAAAAAAFsjwAIAAAgAQUFBzvPuE4oAQG3m+jvR9XclgJqFAAsAACAA6Iey8PBwc/7o0aPVvTsAYBvW70T9HUmABdRcodW9AwAAAPBPXFycmW12z5495v8xMTEl9noBgJpceaXhlfU7UX9HAqi5CLAAAAACRFJSkvmwlpWVJTt37qzu3QEA24iMjDS/IwHUXARYAAAAASIkJESaNWtmqrCOHDkiOTk51b1LAFCtdNigVl5peKW/IwHUXARYAAAAAUQ/oKWkpJjF4XCYBQBqI+13Rc8roPYgwAIAAAhQfHgDAAC1BV0/AQAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsDUCLAAAAAAAANgaARYAAAAAAABsjQALAAAAAAAAtkaABQAAAAAAAFsjwAIAAAAAAICtEWABAAAAAADA1giwAAAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsDUCLAAAAAAAANgaARYAAAAAAABsjQALAAAAAAAAtkaABQAAAAAAAFsjwAIAAAAAAICtEWABAAAAAADA1giwAAAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsDUCLAAAAAAAANgaARYAAAAAAABsjQAL8ENGRoZ8+umncu2110r79u0lMjJSYmJi5OSTT5ZHH31U0tPTPbZ5+OGHJSgoyOdyzz33+Ly/JUuWyIUXXih169aV2NhY6dKli0ydOrXYfdy+fbuMGDFCGjVqZPavXbt28tBDD0lWVhbPMQAAAAAgoIVW9w4AgeC///2vXHfddeb88ccfLwMHDpS0tDT54YcfTEj0wQcfyIIFCyQlJcVj2+7du0ubNm081p922mle72v69OkybNgwKSgokJ49e0pycrJ89913Mnz4cFm1apU8++yzHtts2LBBunXrJvv375cTTjhBevToIT/99JMJ13RbXSIiIirkWAAAAAAAUNUIsAA/hIWFyfXXXy+33XabCbAsu3btkn79+skvv/xiLtOgy92oUaPkmmuu8es4Hzx4UEaOHCn5+fkmyBo8eLBZv2fPHjnrrLNk4sSJ0r9/fzn77LOLbKe3r+HVmDFjZNKkSWZdXl6eDB06VGbOnClPPPGEqQgDAAAAACAQMYQQ8INWP7322mtFwivVsGFDefnll835GTNmSE5OTrmO5+TJk01l16BBg5zhlapfv748/fTT5ryGWK6WL19uhhxq9Zd1HRUaGiqvvvqqCd9eeOEFE2gBAAAAABCICLCActI+WCo7O1sOHDhQrtv6/PPPzemQIUM8LtNKL+1tNXfu3CJ9raxtBgwY4DFMUIMvHU546NAhWbx4cbn2DQAAAACA6kKABZTTpk2bzKlWOmnTdXfz5s0zwwtvvPFGmTBhgvz8888+b+u3334zp506dfK4LDw83PS30vBq/fr1fm3jul77ZwEAAAAAEIjogQWUk9Vz6vzzz/faKP3dd98t8v8HHnhALrnkEpkyZYqZYdCiQwdTU1PN+SZNmni9L12vzdm3bNkiJ510klm3devWErdRug0AAAAAAIGIAAsohy+++ELefPNNU3312GOPFblMZx7UGQMvuOACad68uRnGt3DhQrn77rtNg3Zt1K4N1i3p6enO89HR0V7vLyYmxpweOXLEY7vSbFOSjh07el2/ceNGad26td+3AwAAAABARSDAAspo3bp1cuWVV4rD4ZBnnnnG2QvLope5B0lXXHGF9O7dW0488UT59NNPZenSpdK1a1eeAwAAAAAAikGABZTBjh07zJBBraq64447ZOzYsX5vqzMXjhgxwlRnffXVV84Ay3U4YUZGhsTHx3tse/ToUXMaFxfnXGdtp9t4422bkqxZs6ZUlVkAAAAAAFQmmrgDpXTw4EE599xzTU8pK4gqrbZt25rTXbt2OddpYFWnTh1zfvv27V63s9brkERLs2bNSr0NAAAAAACBhAALKAXtN6U9rf744w8ZPHiwvPHGGxIUFFTqY6iVW679qSzWMMSVK1d6bJObmyurV6+WyMhIadeunV/buK63mr4DAAAAABBoCLAAP2VnZ8ugQYNk+fLlct5558kHH3wgISEhpT5+2jPLat7eqVOnIpf169fPnE6bNs1juzlz5khWVpb06dPHhFju28yePdvso6s9e/bIokWLJDExUbp3717qfQUAAAAAwA4IsAA/6IyBl19+ucybN0969OghM2bMkPDwcJ/X37dvn7z88sseM/9pBddNN90ky5YtkwYNGpgqLlejRo0yQwlnzZpl7sOyd+9eM3uhGjduXJFtunTpYsIpvc748eOd6/Py8mT06NGmcmvMmDFmpkQAAAAAAAJRkEPLQQAUa9KkSXLbbbeZ8xdffLHXButK+2ElJyfL33//LS1btjQN1jt37mwat2uopcP5Dhw4IAkJCaaiyltV1PTp02Xo0KGmUuvss8+WpKQkmTt3rhw+fNg0jJ84caLHNn/99Zd069bN3LbOcNihQwdZsWKFbNq0Sc4880wTvEVERJT7WbaauPtq8l4dNKDTMDEnJ4eQDgAAAAH5nhZAyQiwAD88/PDD8sgjj5R4vc2bN0uLFi1M5dXjjz8uS5culQ0bNsj+/fvNcEMNtXT2wttvv10aN27s83aWLFkiEyZMMNtrMKOB1C233CLDhw/3uc22bdvkwQcfNDMbaqN5be6uVWP33XdfkSGHNe2PPQEWAAAAAv09LYCSEWABCOg/9gRYAAAACPT3tABKRg8sAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsDUCLAAAAAAAANgaARYAAAAAAABsjQALAAAAAAAAtkaABQAAAAAAAFsjwAIAAAAAAICtEWABAAAAAADA1giwAAAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsDUCLAAAAAAAANgaARYAAAAAAABsjQALAAAAAAAAtkaABQAAAAAAAFsjwAIAAAAAAICtEWABAAAAAADA1giwAAAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsDUCLAAAAAAAANgaARYAAAAAAABsjQALAAAAAAAAtkaABQAAAAAAAFsjwAIAAAAAAICtEWABAAAAAADA1giwAAAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAF+yMjIkE8//VSuvfZaad++vURGRkpMTIycfPLJ8uijj0p6errPbadMmSJdunSR2NhYqVu3rlx44YXyww8/FHt/S5YsMdfT6+t2uv3UqVOL3Wb79u0yYsQIadSokdm/du3ayUMPPSRZWVk8xwAAAACAgBbkcDgc1b0TgN1NnjxZrrvuOnP++OOPlxNOOEHS0tJMEHXkyBE57rjjZMGCBZKSklJku9tuu00mTZokUVFRcu6555ow6bvvvhP9sZs2bZpcdNFFHvc1ffp0GTZsmBQUFEjPnj0lOTnZbHP48GEZN26cPPvssx7bbNiwQbp16yb79+83+9ahQwf56aefZNOmTdK9e3ezfURERLmPQ8eOHc3pmjVrxC5yc3MlPDxccnJyJCwsrLp3BwAAADZnx/e0AEpGBRbgBw1Grr/+evnjjz/M8vHHH8tXX30lf/75p5x66qmybt06E1a5mjt3rgmvkpKS5LfffjMVXLrNwoULJSQkxFRLaSjl6uDBgzJy5EjJz883Adf3339vTvX227RpIxMnTjTr3F1zzTUmvBozZoz8/vvv8tFHH5l9u/jii0011xNPPMHzDAAAAAAIWARYgB+GDx8ur732mqm+ctWwYUN5+eWXzfkZM2aYKiDLv//9b3N6//33S9u2bZ3rtVLqxhtvNOHVm2++6VHppZVdgwYNksGDBzvX169fX55++mlzXkMsV8uXLzchlVZ/WddRoaGh8uqrr5rw7YUXXpC8vDyeawAAAABAQCLAAspJ+2Cp7OxsOXDggDmfmZkp8+bNM+eHDBnisY21bvbs2UXWf/755z636devn+ltpZVdrn2trG0GDBjgMUxQg68ePXrIoUOHZPHixTzXAAAAAICARIAFlJP2mVJa6aRN15UO39NAq169etKkSROPbTp16mROV61aVWS9DjV0vdyV9nnS/lYaXq1fv96vbYq7LwAAAAAAAgUBFlBO2udKnX/++c4KqK1bt5pTb+GV0hkMExISTGWUNoFXOnQwNTW12O2s9Vu2bHGuK+m+vG0DAAAAAEAgCa3uHQAC2RdffGH6WGn11WOPPeZcn56ebk6jo6N9bqshlvbB0gArLi7OuU1x2+k2ygq9/Lkvb9v4OzOLu40bN0rr1q39vh0AAAAAACoCFVhAGenMgFdeeaU4HA555plnnL2wAAAAAABAxaICCyiDHTt2mCGDOgTwjjvukLFjxxa5PDY21pxmZGT4vI2jR4+aU62+ct3G2i4+Pr7Ebfy5L2/blGTNmjWlqswCAAAAAKAyUYEFlNLBgwfl3HPPNT2lRowYIc8++6zHdZo1a2ZOt2/f7jNU0uGDiYmJzmBJA6s6deoUu521vnnz5n7fl7dtAAAAAAAIJARYQClov6kLLrhA/vjjDxk8eLC88cYbEhQU5HG99u3bm4bu+/btM9Va7lauXGlOTzrppCLrrWGI1uWucnNzZfXq1RIZGSnt2rXza5vi7gsAAAAAgEBBgAX4KTs7WwYNGiTLly+X8847Tz744AMJCQnxet2oqCg555xzzPlPPvnE4/Jp06aZ0wEDBhRZ369fvyKXu5ozZ45kZWVJnz59TIjlvs3s2bPNPrras2ePLFq0yFR6de/enecaAAAAABCQCLAAP+Tn58vll18u8+bNkx49esiMGTMkPDy82G20N5aaMGGC/PXXX871P/74o7z22muSkJAg1157bZFtRo0aZYYSzpo1y9yHZe/evXL33Xeb8+PGjSuyTZcuXUw4pdcZP368c31eXp6MHj3aVG6NGTPGzJQIAAAAAEAgCnLoFGoAijVp0iS57bbbzPmLL77Ya4N1pf2wkpOTnf/XbXTb6Oho6du3r+Tk5Mi3335rZi7UKquLLrrI4zamT58uQ4cONdc5++yzJSkpSebOnWt6ZmkoNnHiRI9tNCDr1q2bHDhwQE488UTp0KGDrFixQjZt2iRnnnmmCd50SGN5WU3cfTV5rw4a0GmYqMeWkA4AAACB+J4WQMkIsAA/PPzww/LII4+UeL3NmzdLixYtiqybMmWKvPTSS7J27VoTtHTt2lUeeOABEyz5smTJElO5tXTpUhPMaCB1yy23yPDhw31us23bNnnwwQflq6++Mo3mtbm7Vo3dd999RYYc1rQ/9gRYAAAACPT3tABKRoAFIKD/2BNgAQAAINDf0wIoGT2wAAAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsDUCLAAAAAAAANgaARYAAAAAAABsjQALAAAAAAAAtkaABQAAAAAAAFsjwAIAAAAAAICtEWABAAAAAADA1giwAAAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbC63uHQAqSmpqquzbt08OHz4sCQkJUq9ePalTpw4HGAAAAACAAEeAhYCVl5cnM2fOlM8//1wWLFggW7du9bhOs2bNpFevXtK/f3+56KKLJDSUlzwAAAAAAIGGT/MIOFph9dRTT8lbb70l+/fvF4fDIcHBwdKoUSOpW7euxMfHm2qsQ4cOmVBr6tSp8u6770pycrJce+21cvfdd5sKLQAAAAAAEBjogYWA8uyzz0rr1q1NgKXDA++//3757rvvTFi1bds2+e2332TRokWyatUq838Nu+bOnSv33XefCbaefPJJs/3EiROr+6EAAAAAAAA/BTm0fAUIEFppNXDgQLn33nvljDPOKPX2P/74owmx5syZI/n5+ZWyjzVZx44dzemaNWvELnJzcyU8PFxycnIkLCysuncHAAAANmfH97QASsYQQgSUlStXyimnnFLm7bt16yazZs2SX3/9tUL3CwAAAAAAVB6GECKglCe8qozbAQAAAAAAlY8ACwAAAAAAALbGEELUGNrTSmclzM7O9nmdZs2aVek+AQAAAACA8iPAQsD79ttv5V//+pdp0K4NvX0JCgqSvLy8Kt03AAAAAABQfgRYCGjTp0+XYcOGSUFBgSQnJ0vz5s0lNja2uncLAAAAAABUIAIsBLSHH37YnE6ePFmuueYaCQ6mrRsAAAAAADUNARYC2oYNG6RXr14ycuTI6t4VAAAAAABQSShXQUBr0KCBGToIAAAAAABqLgIsBLRLL71UFi5cKFlZWdW9KwAAAAAAoJIQYCHge2A1bdpUBgwYIBs3bqzu3QEAAAAAAJWAHlgIaNHR0TJ37lw588wz5bjjjpMWLVpI48aNvTZzDwoKku+++65a9hMAAAAAAJQdARYC2o4dO6RPnz6yfv16cTgcpgrLVyWWBlgAAAAAACDwEGAhoN1xxx3y559/mhDr1ltvlVatWklsbGx17xYAAAAAAKhABFgIaDp8sG3btvLll19KSEhIde8OAAAAAACoBDRxR0ArKCiQTp06EV4BAAAAAFCDEWAhoHXt2pXZBwEAAAAAqOEIsBDQHn/8cfn999/ljTfeqO5dAQAAAAAAlYQeWAhoq1evlhEjRsiNN94o77//vvTt21caN24swcHes9mrr766yvcRAAAAAACUT5DD4XCU8zaAaqNBVVBQkFgvYz3vjV6ul+Xn51fxHtYsHTt2NKdr1qwRu8jNzZXw8HDJycmRsLCw6t4dAAAA2Jwd39MCKBkVWAhoDz74oM/QCgAAAAAA1AwEWAhoDz/8cHXvAgAAAAAAqGQ0cQcAAAAAAICtEWABAAAAAADA1giwEFCGDRsma9euLddtaLPGoUOHVtg+AQAAAACAykWAhYAyd+5cOfHEE2Xw4MHy6aefmpnn/KHXmz59ugwaNEhOPvlkmT9/fqXvKwAAAAAAqBg0cUdA2bRpk0yYMEFeeuklmTVrlsTFxUnXrl2lc+fO0r59e0lMTDTrjhw5IgcPHpQ///xTVqxYIcuWLTPrIiIiZNy4cXLfffdV90MBAAAAAAB+CnI4HA5/rwzYxe7du+XNN980y99//23WBQUFeVzPenm3bNlSRo0aJSNHjpT69etX+f7WFB07dnQOw7SL3NxcCQ8PN1V2YWFh1b07AAAAsDk7vqcFUDICLAS8P/74QxYtWiSrVq2SvXv3SmpqqtSpU0dSUlLMcMEePXrI8ccfX927WSPY8Y89ARYAAAAC/T0tgJIxhBABr0OHDmYBAAAAAAA1E03cAQAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8BCQLn99tslIyOjuncDAAAAAABUIQIsBJRJkybJiSeeKHPnzq3uXQEAAAAAAFWEAAsB5bLLLpPNmzfLeeedJyNGjJBDhw5V9y4BAAAAAIBKRoCFgPLf//5XZs+eLY0bN5Z33nlHOnToIB9//HF17xYAAAAAAKhEBFgIOP369ZO1a9fKzTffLPv27ZPLL79cBg0aJDt27KjuXQMAAAAAAJUgyOFwOCrjhoGqsHTpUrn22mtNoBUfHy833HCDxMTE+Lz+gw8+yBNTDh07djSna9assc1xzM3NlfDwcMnJyZGwsLDq3h0AAADYnB3f0wIoGQEWAp4GFz179pTly5dLUFCQ1+toTquX5efnl/l+fv75Z/n222/N/ehiVXz5yoAffvhheeSRR3ze3vjx4+XJJ5/0etmSJUvk8ccfNwGdPj4dKnnLLbfI1Vdf7fP2tm/fLg888IB8/fXXcvDgQWnWrJmpTrv33nslMjJSauofewIsAAAABPp7WgAlC/XjOoBtbdq0Sa677jpZsWKFhISEyMUXX1xsBVZ5PPbYYzJr1qxSb9e9e3dp06aNx/rTTjvN6/WnT58uw4YNk4KCAhPMJScny3fffSfDhw+XVatWybPPPuuxzYYNG6Rbt26yf/9+OeGEE6RHjx7y008/yaOPPmq21SUiIqLU+w4AAAAAgB0QYCEgadXTxIkTTZVTRkaGnHzyyTJ58mSfoVBF0IDopJNOks6dO5ulRYsWkp2dXeJ2o0aNkmuuucav+9DKqZEjR5pKMQ2yBg8ebNbv2bNHzjrrLPOY+/fvL2effXaR7fT2NbwaM2aMTJo0yazLy8uToUOHysyZM+WJJ54wxwoAAAAAgEBEE3cEnN9//13OOOMMMwRPgx4daqfVRpUZXim9P61oGjBggDRo0KBS7kNDuLS0NNOU3gqvVP369eXpp5825zXEcqXDGXXIYUpKivM6KjQ0VF599VXTF+qFF14wgRYAAAAAAIGIAAsB5f7775fTTz/dBFZakfTbb7+ZHk86fLAm+Pzzz83pkCFDvM6+qL2s5s6dK1lZWR7baLDmPkxQgy8dTnjo0CFZvHhxpe8/AAAAAACVgQALAeVf//qXREVFmcqiBQsWSLt27cTu5s2bJ7fddpvceOONMmHCBNMM3hcN5FSnTp08LtOZ9rS/lYZX69ev92sb1/XaPwsAAAAAgEBEDywEFK0y0vCqUaNGEijefffdIv/XmQIvueQSmTJlisTGxjrX69DB1NRUc75JkyZeb0vXa/XZli1bTD8utXXr1hK3UboNAAAAAACBiAALAaUsswBWF515UGcMvOCCC6R58+ZmGN/ChQvl7rvvNg3atX+XNli3pKenO89HR0d7vU1rhsUjR454bFeabfydWtjdxo0bpXXr1n7fDgAAAAAAFYEAC6gkV155pUeQdMUVV0jv3r3lxBNPlE8//VSWLl0qXbt25TkAAAAAAKAYBFhAFWvYsKGMGDHCVGd99dVXzgDLdThhRkaGxMfHe2x79OhRcxoXF+dcZ22n23jjbZuSrFmzplSVWQAAAAAAVCaauAPVoG3btuZ0165dznUaWNWpU8ec3759u9ftrPU6JNHSrFmzUm8DAAAAAEAgIcACqoH2w3LtT2U5+eSTzenKlSs9tsnNzZXVq1dLZGRkkdkXi9vGdb3V9B0AAAAAgEBDgAVUMYfD4Wze3qlTpyKX9evXz5xOmzbNY7s5c+ZIVlaW9OnTx4RY7tvMnj1bsrOzi2yzZ88eWbRokSQmJkr37t0r5fEAAAAAAFDZCLCASrBv3z55+eWXPWb+0xkDb7rpJlm2bJk0aNBABg8eXOTyUaNGmaGEOtvijBkznOv37t1rZi9U48aNK7JNly5dTDil1xk/frxzfV5enowePdpUbo0ZM0bCwsJ4rgEAAAAAASnIoeUgAEr0+eefy2OPPeb8//Lly0011RlnnOFc98ADD5iKqL///ltatmxpGqx37tzZNG7XUEuH8x04cEASEhJMRZW3qqjp06fL0KFDzW2fffbZkpSUJHPnzpXDhw/LHXfcIRMnTvTY5q+//pJu3bqZ29YZDjt06CArVqyQTZs2yZlnninz5s2TiIiIcj/LVhN3X03eq4MGdOHh4ZKTk0NIBwAAgIB8TwugZMxCCPhJAyitnHLnuk6vozR00mqopUuXyvr16+WHH36QkJAQE2pdc801cvvtt0vjxo293s8ll1wiCxculAkTJpjtNZjRQOqWW26R4cOH+2wK/8svv8iDDz5oZjbUIYra3F0Dtfvuu69CwisAAAAAAKoLFVgAAvrbKiqwAAAAEOjvaQGUjB5YAAAAAAAAsDUCLAAAAAAAANgaARYAAAAAAABsjQALAAAAAAAAtkaABQAAAAAAAFsjwAIAAAAAAICtEWABAAAAAADA1giwAAAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsDUCLAAAAAAAANgaARYAAAAAAABsjQALAAAAAAAAtkaABQAAAAAAAFsjwAIAAAAAAICtEWABAAAAAADA1giwAAAAAAAAYGsEWAAAAAAAALA1AiwAAAAAAADYGgEWAAAAAAAAbI0ACwAAAAAAALZGgAUAAAAAAABbI8ACAAAAAACArRFgAQAAAAAAwNYIsAAAAAAAAGBrBFgAAAAAAACwNQIsAAAAAAAA2BoBFgAAAAAAAGyNAAsAAAAAAAC2RoAFAAAAAAAAWyPAAgAAAAAAgK0RYAEAAAAAAMDWCLAAAAAAAABgawRYAAAAAAAAsLXQ6t4BAAAAAFWvoKDALPn5+WYp7rzD4TCLKs2pP9cJCgoyS3BwcJHF2zpf632t0wUAUDMQYAEAAAABRkOl3NxcycvLM6clBVDu561QqqBAiiz5+RoqFZ66rtd1/8ucnKcW9/WlvZ4KDhbRrEkX67ye6mJd7rre23Vd11nbhYaGmiUsLKzIqbd1ISEhFfskAQAqFAEWAAAAYKNQyjWYsk7dz+t18/LELFbY5B46+QqmXE91CQoKNuFNcHDI/6qXjp3qer28sKJJXCqaCk+t//s61euVfJ1j1WAOh3Wq1Vsatnmuc71uYQjnep3CdYW3rwFWnllCQrIkNFREMypdrPN6ap0PDg4qMejSJTw8nLALAKoBARYAAABQBaFUScGUayhlBVPu511PtZ1tYcgS9r/QqWjwFBpaGEx5C6hc19dEhSFXvjm2+fl5kpenVWqF53NyciUzs3CdXq6nGnyFhDgkJCRHQkNzPMIt19OwMF1CJSIiwrloqOV6HgBQ8QiwAAAAgDLSap/s7GzJycnxeloYkIhfwdSxUMqq/gmTkJDC0/DwY+et9TU1fKoIVh8sPVb+KBxaeSzosoItPZ+dba3TwEuDxsKqrrCwPAkPP2oCLc2sdNHzoaFBJsiKjIz0WHjOAKDsCLAAAACAYgIqDaN8BVSFFVQiubkiOTmFp67n9bJjoVTRYCo6+lgYZV2uoQuqK/AKl7CwkquntIdYbm6O5Obq60BfA9mSkVF4Pi8vR4KDHRIenvW/RSQi4ljApUGka6AVFRUl0dHRBFsA4AcCLAAAANRqJQVUubkOE0R5C6h00YAqPDzChB9hYYVDyGJjj/2fqpuaRZ/PkJAoiYyMkjffFPnsM9eG9IVnLrggW4YNS5OcnCw5ejTLnObn50poaK5ERORKePgRE2xFRhYGXNHRURITE+NcNNxiBkUAKIoACwAAADWeDhHLysqSzMxMc2othcP8HM4wygqnXAMrh0ObexcGUhpUhYaGS3T0sYBKq6pQOy1dKrJjh+uawsb0v/wSKTfdFOmlcitbsrMLA6309EzZvz/DVG1FRmZKVJQu+yUqSkOt4CKBli7aQB4AajP+2gIAAKDG0JDACqessEpPC6usRLKzjy1WQFVQEGRCKSug0tOoKNfAiuAA3g0bpmGV5/qhQ31VbkVLZGR0kfXaVysz86hZDh06Krt2ZUhwcL5ERR2RyMgjJtDSJTIyvEigpUMPGXIKoDYhwAIAAEDA0Sbb7kFVYUXVsaDKNbDS88HBOnNclEREaO+hSElIiHIGVAzXqjk8h/WJBAWJDBwocu21FXtf55wj0qqVyKZNx9a1bl243l/6+ouLSzDLsYkB9PVcGGqlpR2VnJxMCQ/PkagoXQ6ZoYdRUUFmqGFsbKzExcVJfHw8w1UB1GgEWAAAALB1UOVaSWUFVTk5uUXCKeu8VlSFhISZoCo8PFKioyMlMbHwPEP9auuwvkLLllV8gKU996+/XuSee46tu+66wvVlpWGq9tfSJSEh2TkE1qrSSk8/Kvv2HZWCglzn0MPY2H0SHR0kcXGxUqdOHbNouAUANQkBFgAAAKqdVp1oQJWRkWEWK6zKycnzqKTKyirsUaXD/jSY0rAqNjZSkpIKgyqaptdupRnWV9FVWKWtvvKXDhWMiYkzi0VnQtRAKyMjXXbtSpO8vCyJjT1ilpiY7RITE+EMs7RCiypDAIGOAAsAAABVSqtJrKDKWgqH/zlMOKWLa0WVNkrXYX/HgqpIgipU6rC+0tBqq3vvFXnuOZHbby9f9VVpFE4iEC7x8Ynm/zk52ZKeniqpqamya5f2z8qW2Ni9ZomODjZDDK1Ai4bwAAIRARYAAAAqtam6e1iVmalh1bGgygqtgoJCTYNrXeLjC3tVaUUVjapR3cP6SnLqqSJTp0q10n5udeummKXw5+6ICbS2bUuVoKBciYk5LLGxhyUmRiQ+Plbq1q0riYmJDK0FEDAIsAAAAFChlVVHjx51nmZlZRcJqaxF+1RZYVXduoWnWk0CBMqwPjvTYbSujeGzsjJMmHXgQKrs2HFUYmPTpU6ddImL2yZ16sSbMCshIYGwGICtEWABAACgzD2rXMOqwr5VnmGV9qqKjIwxTamTkwvDKp15Dags1TWsz66ssDg5uaHpnZWWdkj27z8ou3ZlSFxcqtSpkyqxscEmxEpKSjLDDQHAbgiwAAAAUKLsbO2vk+4MrHSxelZlZhYuVmVVVFTM/z4sF54y+x8q2ptvinz2mQapx9YFBYkMHHhspkE7DOuzI610TEqqb5bs7CxJSzsoO3ce1J9yiY8/KAkJByUuLkLq1atnwix+fgHYBQEWAAAAPGg1lQZWuhw5ckSysnKdQZUVVjkcIc6wKikpxpynsgpVYelSkR07PNcvW3YswKrqwCwQaZ+5evUamUVnNExNPSCbNx+UqKhs2b9/u8TH75S6dRPl7bcbybvvhns8fn3s//xndT4CALUJARYAAEAtp8MBtbLKCqx0yc7Ol6NHC8OqjAyd4SzIBFVRUbFSp060NGgQY5pGA9Vh2DCRX37xXD90aM0IzKqDBtC6pKQ0MVVZ+/fvkz17MiQh4YB89lmSbN7s2aPum28IsABUHQIsAACAWkZnKLMCK62uKpwZsMAZVumSlxcs0dGxZqlfP9Z8sGU2QNixSbulMpu1V3VgVp305zwhIdksWpV16NA+6dFjn/z6a5zG3Vp75Ty99dbq3lsAtQkBFgAAQA2Xm5tbpLrq6FHtXyVFKqz0baGGVVphlZgYa6qtgnSMECD2G5KnTdmvv17knnuOrbvuuspr1l7VgZndqrIuvzxPPvssV7ZssSZfCJI2bbLkrLPSpKAgmXAbQJUgwAIAAKihDdetCqvMzGxn7yqrwio0NMIEVrGxsVKvXqzphQNUlYoYkucaKlV2mOQtMDt4UOSii2pOP6zihIeHyk03FX38F120Q/7887Ds2bNLGjRoICkpKYTeACoVARYAAECAy8rSmcTSnKFVZmauabJuVVjp+fDwKBNY1akTK40axdFsHdWqIobkaah0770izz0ncvvtlVd95asK69ChwqUm9sPyViGnEhMLH3Pr1g7p2zdedu/OkP37cyQ1dbvs27dPmjRpIgkJCdW12wBqOAIsAACAAOxhpYGVtWRk5Dgrq441XI8xgVVycuGwwJCQkOrebdhQdc2uV1FD8k49VWTqVKkSVmD2yCMi27fX7H5Yvirk2rUTadhQA8MgSUqqJ3XrJpuZC3fu3CmHDmXLkSMbpW7dWGnatKlER0dXx64DqMEIsAAAAAJglkBttJ6amvq/SqujprIqPb2wyio7O8iEVDExcdKgQZzpX0XDddh5dr2q7mFVUTQwmzFD5LLL7NEPq7ICSF8VciNHivTp43pfQabZe1xcohw8uEc2b94jBw+mS2rqWklJSZLGjRtLWJjVNwsAyocACwAAwIZycnKKVFllZurMgeJcQkMjJSYmXurVi5fo6DgCK1RoULF5c2EIUpkVWVXZw6qmhm+VFUCWtkJOKzzr1Wtkwqy9e3fIxo0HJS3tgAndtRqrbt26Zd8ZAPgfAiwAAAAbKCgoMA3XrcDq6NEsMxxQwyqttMrPDzGBVWxsvNSvHy9hYeHVvcuoAbwFFVXV36mqe1hVpL//1hBZJC+v8HTSJJEXX6z6Ru4V0UusIkM6/b3UuHFLycxMkd27t0pqaoZkZGyWevUOSvPmzanGAlAuAfRnAqheP//8szz55JMyePBg06BSS6b9mV58ypQp0qVLFzPLk377dOGFF8oPP/xQ7DZLliwx19Pr63a6/dQSGjxs375dRowYIY0aNZLIyEhp166dPPTQQ6axLwDAnnRY4O7du2X9+vXy66+/yu+/b5A//tgr69ZlyV9/BcmBA7ESGtpIGjc+Ttq1O1maNGllKhwIr1BRrKCiJJXV38nqYaWngUQDPQ2vlJ7u2lVYCaXrqyOAdFVR1Wyut13a24yKipEWLY6T2NhGsnlzkGzalCpr1qyRAwcOlH/HANRaVGABfnrsscdk1qxZpTpet912m0yaNEmioqLk3HPPNWHSt99+K998841MmzZNLrLmXnYxffp0GTZsmPkmvmfPnpKcnCzfffedDB8+XFatWiXPPvusxzYbNmyQbt26yf79++WEE06QHj16yE8//SSPPvqo2VaXiIgInmsAqGa5ubluwwLznBVWWm0VHBwusbF1JCmpcFggjddR1VVYVmBhh/5Odm5EX1mVT3YazljeCjn9ojc5uaHExibIrl1/y5EjWo31tzRokGqqsfj9BqC0ghzaFRRAiZ566ik5evSodO7c2SwtWrSQ7Oxs01jXm7lz50rfvn0lKSlJfvzxR2nbtq1Zr+fPPvtsMzPL5s2bi0w1fPDgQWnZsqX5UKNBllZ7qT179shZZ51lgqr58+eb7V3pZVq1NWbMGBOYqby8PBk6dKjMnDnTVGI9/PDD5X6WO3bsaE71GzQ7fRgMDw83vWJoEgrAjvRvx+HDh00vmKNHM01QZTVfz80NNo3XC4cG1pHwcL5sQPXQMMYKKrRIxjUQefLJoo277UYDG29hUqdOIq+/Xjn3WVDgvZH7Bx9U/VBI132prn0oib5fPnBgjxw4sFMaNnRISkqktG7d2owaqA52fE8LoGQEWEAZ6R/c4gIsHQL45ZdfynPPPWcqsVyNHTtWXnjhBVNNNW7cOOf6p59+WsaPHy+DBg2STz/9tMg2GkRpoNW/f3+ZPXu2c/3y5cvljDPOkJSUFNm6dWuRSisNvrRxpg5D3Lt3r4Rqk4Ya9seeAAuA3ejfBe1lpaGVLhkZuXLkyLEqq4iIaBNY6RIdHevXcHSgpgci5amimju3aOBWVcGb+/1WZ9DnGkDaeThmZuZR2b59o8TH50rDhiHSsmWLIl/mVhU7vqcFUDKbZfNAzZCZmSnz5s0z54cMGeJxubXONYhSn3/+uc9t+vXrZ0Izrexy7WtlbTNgwACPYYL169c3wwkPHTokixcvrpDHBgDwpMO+NazSytrffvtNfv/9L1m7dp+sX58rGzcGS0ZGotSp01LatDlZWrY8XlJSGpvKK8Ir2JE1dKxDh8KApiqqeazZ9HbuPLb421OqMvtA+Xu/1T3MMlB6iWlvLP0dmJUVJ5s358uff26UHd6mUQQAL+iBBVSCP//801Rn1atXzzR8d9dJa9pFTE8rV/qhx/VyVzpMTvtbaW8rbfZ70kknlbiNtV7DNL0v96GHAICy06HaOixQg6vCWQMLJC1NTLVVQUGoxMUlSL16CaaXVbDdxvOg1vZuKm0gUlXK01PKVx+ot9+u3OMbyLMoVqfQ0DBp1qyt7N27QzZv3iN5ebtNRb32xSLUB1AcAiygEuhQPuUtvFIxMTGmXForo3SYSVxcnPnwox+EittO12uAtWXLFmeAVdJ9Wet1GwBA+Wi/PWto4JEj6ZKe7jBDAzW0CgoKl7i4RGnUKMFUGfBBDP5WHbnTqqPqDrCqs5G8RTsfaGvPF18sOXRy3d6qhrrhhso/vlUd9NUU+vuxfv0mEhERJVu3bpGCggOmklV7wfK7E4AvBFhAJUjXTzMiplG7LxpiFX4AKgywrG2K2063UbqNv/flbRt/+wK427hxo2m4CQC1iQ7b1i8c9Hd2enqGM7DS07CwKFNp1bRpokRGRlX3riLA2GUmOztUgnmrosrLE9m1y7/QyVs1lF2OL3xLSEgysxFu27ZJCgoOSX5+vnmvSdUqAG8IsAAAAHzMHFgYWmU5QyudOTAyMtY5PJBZA1HRVUd164q88IIuDpdAySH9++fLVVflFv7vfxccm0jG+r94vVxPtapFQwENpoKCgv93vnDdjz+Gyo4dwdVeCabHo359nYSm9KGTawj30EPH1icmihw6dOz/1d2rCp7092njxm1kx46N4nCkicOxQdq0aUOIBcADARZQCXTWP5Wh000V8+FIafWV6zbWdvHx8SVu4899edumJL5mZPFVmQUANXXmQO1plZUVZGYM1A9ZDRvWMf1bgJJoJYku2iut8LyeFphhUtai6wcPjpRnn012bhcZmS07d+qkLK6zUwbJggWZcsYZW728dl2DK8/LXGl4pZVJ1sSXel6XM8+Mk19/1ZYDukGQ87Rnz12yYcNRCQ0NkZCQUDObsVbLWKfWeetyDcTKU82l+/LooyJjxohkZ5cudPI1HNN9AmbtjVXaXlX+Pib36+nvEH17pkXy1tswu/Q4s5vY2Hhp2rStbN++QY+chIb+La3cO/MDqPUIsIBK0KxZM3O6ffv2Yr/ZT0xMdAZLGljVqVPH9MHS7Tro1D9urNvTJpeu9/XLL7/4vC9v2wAAjv0+PnjwoFnS0/OclVY5OSEmtKpbN9Gc6gd1wDWQcj0tPF94WrjkS0GBQwoKCofB5edrY//CRcMN1/MpKUekfv1Y2bMnUurXz5KePffLhx96hkmnnZYme/eGyfffJ8qKFUW/5NJQpHPnI3LOOdpLszCdsvoIWaca0h5bCsyi+6in9esfkZSULNm7N9K6RQkOLpApU5LknXeSnPfRtethueCCA6I/DhoCaThkhWC6Tn9O5s9vKjt2eA6n/fHHAhk5MqjE/kannSbyyCOeDdlLCp18DRfU42+JjCwahPkbTPnbq8zX9fR3imsnh9rY48wf0dGx0qRJG9m2bb2EhR2SiIgd0rhx4+reLQA2QoAFVIL27dtLRESE7Nu3z0wN7P7Hd+XKlebUasRuOfnkk2XhwoXmcvcAS2dnWb16tURGRkq7du2KbDNr1iznbbrzdV8AUFvpLLEHDhz4X2iVLTp/hlZa5eUdmzlQQysaCdc+eXm5kpOTa/7m5ubmuJzPNcGUeyjlvuhleqqX63l9DWllUmG1klYoBUtIiA7d0/9rmBMiERFBcuWV+TJ9er5ceqlI27bJsmiRQ3bssIKeINH5WM4/v6EJcXROFtchcZa//64rjRrVLfNjHzrUIS+9dOz/BQXBcvhweJHrrF+fKOeeWyA5OYUVZQUFhQGenmrwExKSL6eddkDWrfMM4Lp33ynr1h2RsLBQCQsLl4iIcDMEV2dZ1vdMYWHHKhv//rswHNPj6G8jd2/DMd2deGLRIMzfYMrfXlq+rlfSdoHQo6wqQ6wGDVrItm2bJSRkt3ltJCcfq1AEULsRYAGVICoqSs455xz58ssv5ZNPPpHbbrutyOXTpk0zpwMGDCiyvl+/fibA0suvvPLKIpfNmTPHNBLu37+/CbFct3n00Udl9uzZ5kOZ/qG37NmzRxYtWmQqvbp3785zDaDW0g/ZVqVVWtpRUw2hwVVmZrAJrVJSkiQmJo7Qqha8DqxASmeUdD2v4ZUGJsUtRUMp1+F0GsocW2dd7m8j6lNOKVxECiv9Lr5YioRJ+n/rpvr2FfnzT8/bOPfc8h2bzp2DRL9v00BH+3AdPOh5Ha0AW7y4gQwaVHS9VnVZYVbduvkyf36+7NxpVS3qbHM5kpKSboKpsLA8CQ3Nk7CwDNHMKjy8MKQKDQ0y72H0Pc6SJcmSlxdWqkbu3prAF1eNVZpgyls45m1Yo7fr6WPMzfXcrjShVG2brbJOnbqSk5Ml27btkpCQreZ1UZpWGABqLgIsoJLccccdJsCaMGGCCZnatm1r1v/444/y2muvSUJCglzr9q5j1KhR8vjjj5uKqhkzZsjgwYPN+r1798rdd99tzo8bN67INl26dDHh1JIlS2T8+PHy/PPPm/X6JnL06NHmjfmYMWOKfLMJALWB9hjS4doaWqWmpsmRIw4TWukwwejoeDP7VdOmCTQKroHPe05OtmRlZZtgSr/cscKq/HxHkUBKgwXX/2uYUNjrKdz0OtO/neHhehouX3wRLosXh4jDEVQkcOjVSzwCnfLq3FmcYZJWX51+uvfLLO7XKQsNgEaMEPnvf0Uuu0zk2Wd1KG3R62il4u+/ez5e11BPv0fTty+uAdzQoeHSqtVxkp9/rLpNl4wMrYDU8DBHgoMdEhaWJeHhWdK1a778/rtnFdeQIXnFfnwpqQpLA6uyBFPewjFvwxq9XU/DsPff99yuNKFUbZxNsV69RubneOfOgxIZ+bcZmcBQbgAEWICfPv/8c3nsscec/9c3w6pr167OdQ888IAJq1SfPn1k7NixMmnSJDnllFOkb9++Zptvv/3WfFP59ttvmxDLVd26deWtt96SoUOHypAhQ+Tss8+WpKQkmTt3rvkQpqGYrnOnt9WtWzdzX/PmzTN/5FesWCGbNm2SM888U+7VeaUBoBY1Y9fQ6tChQ5KeXuAcIhgeHi116iRJgwaJNGKvAbT/VGFAlSXZ2TnO8zk5WmUlHos17K8woAr7X0AVLtHRx85//nmoLFgQ5FEVoyHVH3+I7NvnuR/eAp3ycg2TrriiaFCi54ur0CqP9u0L+08pDXG++qpslV6+AriQkDCzREZGe/zcWqFWdnamtG6dKSkp2bJ3r1VVrgFZgUycWCDPPZf7v9kTg8zMjDfcEOasnNRjoG95nnuucJilVblV3mDKPewqrqm8+/VuvVW/vPTcrjShlL9BW03TsGFz2bTpqOzbly3btm2TFi1aVPcuAahmBFiAn7Sf1TL9WsyN6zq9jiuthtLw6qWXXjLBlfZ50GBLgy4Nlry55JJLzDBCrdxaunSpeUOugdQtt9wiw4cP97qNVndpI/cHH3xQvvrqK5k5c6Zp7q73c9999xUZVggANZHOxHqsGXuuM7QSiTDDUVq0qCsREceGXyNwaEWx/i10r6rKzS0MqmbNSpIlSxLN8D6l4ZPmGV26HJULLsgyz3tMTGFApUFVcb3NNIzyFVJV1tC9ksKkWbNEXnvNc6iZTlasr/GKqL7yRgOWuXOLDrvz976KC+C80eeksB9WhBnK660nV35+sBw4ULQn18KFWdK792aJiYkxszLrcuqpoTJ1auG+V2Qw5RqO3X570dtyHw6oMyhq4bv23NLhkd62K00oVZqgrSbRIbiNGmk/rD8lJuaAaYmhEx4BqL2CHPqVBwD4oWPHjuZ0zZo1tjleOhRBg0H9QMMwSaB20Z/7Y83Ys5yhVW5uqMTHJ0p8fF3TEBiBwwqntOejtWhQpUXPViWVdV6DleDgUJk8uals3hzpNQDSAGHBAs/wx9ewP/1OyjU0sWgVjQY3993nOXTv8cfLFyRoQFXcPk6Y4D040wmPNRzRgEgfa2WYOVNkxoyix6FLF6kSGkhaxzsqSvvViceQwpNOOiKXXbZdoqMLr6NLdHSUCbI0CBs4MMJUYulxqlev8Lh66zOllVBWwHTqqaXfVw2TvFVTdeok8vrrvrdzD9mefFIr+H0fDx3aaQVtH3xQ8wMsy5492yUnZ4+0ahVmvtTVvnM18T0tgJJRgQUAAAKqGkeHBhb2tUo3zdg1tMrICJbY2DpSr542Y2cGwUDgHlQVhlXav6owpNIqFj3VoKqwSbrOVBch0dE6e12k6VOlPXF05L630Ekro775pnTD/orrL1VZQ/eKq/rSffRV+aWXVXaYpPehoZ63XlxlDeWUP6GiaxWXvg62bzfXtLYw/2Znx0lKSgvJyEiXQ4eOmKFmkZGZEh2tyz6Ji2slhw5FFGkE763PlIZWWrVVVmXtUeVv9VdJFWA1nfbD2rw5VfbvzzITFLnP7g2g9iDAAgAAtqd9rfbv3y8HD2pfq8Jm7BpeRUXFmb5WjRsn0ODXxrRaNjMz04RU1qmGVVZIZZ1qj6qwsEgz7E9no6tT51hQ5UtxoZOGJKUZ9ldSSFVcc/WyVliVNDSxspq2+6O0QwH9CeWUv6GiNYzSV2WcHqOIiCizJCbWMzNJaph19OgROXDgqPTosU/ef9+zGXxFNz8va4+q0oZS5Q3aAnkoYf36TWT37g2SkLBXUlJSqLoHaikCLAAAYNsm3TpEUPsLpqVlyeHDYpbQ0CgTWqWkJJq+RrDfLIDakywrK1MyMwsDq5ycfGdQdSysKux7pGFVdHSkJCREmsqq4npU+QqF9DZdWaFTWcKf4kKqsgQ6JVVYlbSPs2cXhrWutOpQ11d08/iSGrv7q7hQrqRQ0Vvgp6yeX8U9j9rjrHD4cKL5/ZGUlCHffZcru3dbMzEHSZMmWdK27T5JT0+QmJhYv15vJSlPj6raGkqVllbYhobGyKFDR00VVhN9AQCodQiwAACArRw9qrNO7TPVVmlpBaaHjQ4R1GbszZrV85jBDNU/rFNDKg2tdNGZALOyxCyuwwCtyqrCsCrKhFeu4UFJlUr+hELuwYY/w/683a/22EpMFLnmGs8QorSBTkkVViXtoz5W1+BG6f8rY/bDilJSKFfcZb6e20aNih6HkoZvatVeXFycDBlS9NieddZ+2bYtXQ4fTjfN/XVGaF2svkruDdmVt75Z5RkOiLJJTm4ku3f/JYmJ+6R+/fpUYQG1EAEWAACodlotoX2tNLg6ciTThFY6TDA4uHBoUOPGdRkiaKNG6xpUWaFVVpbOEChFQittrh4REW2GdtWpE2V6V+kwoPJUKvkTCqWkeIZOJQ3783W/GlSVtjl6WauHXPdRr6sNujVI0ePpa7qlypr9sCKUFMq5X6Y/6+PGFZ7X15I3gwcXNpUvbT8u9+f/H/+oJ0ePhsmuXYclPDxXDh/eJzEx+yQ+Pl7q1q0rS5dGFQnXfPXNKutwwLIGZNAqrHgJDY2VQ4fSZe/evfTCAmohAiwAAFBtNADR3lY6VFCrrXSI4NGjwRIXlyiNG9eTqKgYnp1qZvWt0so4Pc3OzjMhlRVYaeCgAVVkpM7+Fi3JydFmKFdplVSp5B4SaVss7Zll0eDnmWc8g4OShv35e7/+KGv1kOs+avXXtm3F309V9cAqj+KCQ/cKLR0i6TpM0v251e11m4SE0vfjcn/+IyP1tVrfBONHj6ZJauohOXAgS+Li0uTQoTTp0ydFfvklyeN2/Omb5c9wwKVLi1af+RuQoVDduily8GC6+cKDZu5A7UOABQAAqrxHks4kqNVWqalHnb2tgoIizYfKBg3qVsg06Sgb7V2Vnl4YVmnAqM3WMzMLK6s0sNKARXtVaYVVQkJhlZXOElhe/var8hUSxcb6DjWKG/ZXkU3SfYVh/lQPldSw3JUGYNoDy98hl9XBNThq1kzkzjuL7qsOK9XrFBR4bqthpFZhugd+ZenHpbxtpxWBcXEJZsnOzpS0tEOyfXuqNGmilT0xsmNHpPO6FTkksKwzFuJYL6ydO4Pl6NEcSU9Pl1j9wQdQa/DuEAAAVFklj4ZWhdVW+eYDanp6kMTGJkjDhvUkJiaOZ6Ia6MxtGlhphZUu2dn5JrCyKqy02br2HdMKq7p1CwOrkoYDloU//apKCokq83794S0M0zDmww8Lgz/NZbXSSMMcX0GTt9twpZdpAPavf/k/5LK6WMHRhAm+K9N27vRcf/nlIu+9V1i1ptVYOqRSl8oK6PQ1Xa9elGRn15WDB/dIz5775YMPjjUJv+46hwQHl7/Ze0kzFjK8sGT6u0eb9KemHjBVWARYQO1CgAUAACqNw+Ew1VY6TPDw4SOm140GVw5HuCQkaLVVUpmGm6H8swRagVVmZrYJqjS00iUvL8gM3dTQKj4+2u+ZAb0pTWN2f/pVuV/HUq9e4fqycr1NDUy0akgDk5L219vjc+/hpAUiriGN/gwUFzR5C9Rce3xpVZNWX+3a5f2x6H3dcYd9KrFKCh31WB88eGxdUpLIGWcUPkYNsHQo4f79xy7X46Yqo/pMJxlo2LC5xMUdkXnzcmTPnnBp3DhLmjffIenpKRIbG1epMxYyvNA/GmDt3XvA/G1p2rRphcwkCSAwEGABAIAKl52dbUIrXY4cyTOhlX4Y1Wqr+vXrmWa8qNrnQ4fbaGBV2Hjd4QysdGigzhCooVVycqypRinr7IDlaczuT78qXwGPPgarCXhp9s/18VnBkwYmBw74t7++Hl94eOHtaQin2738cul6bLkGalq1pcPt9LYef7zw8X/yiefMhBarn1RFVGKV57l33V6HCfrqa6W37Xp8tPpKH6PevrcQT4/bN99UbvWZBlWjRjnkvffypG/ffbJzZ45kZW2XunXjpWHDhuWuQPQ1YyHDC/0TExMvubkhkplZOANqdDQz0wK1BQEWAACoMBqQ7NmzRw4cOGQqTbS3VV6eTlWfLK1bJ0tYWDhHuwrk5eW5VFmlS1aWftA7VmWlbwE1sIqLi5GUlJhie1iVNoQqb4N0f/ocuQY8GhZ5C3P8DTN8PT5XiYmle3z9+4v8+mthCNe2rcinn/rfY8s1UNPwKjKycChnmzbHAj1f9+vvMfY3mCrPc1/c9q7DNLt0Efn448LruVbSFdebTPe7ohrv+3LccUEyYUKo5Oc3ksOH98uOHQclOzvNhMFNmjSRcH3hlZGvGQuLG16IYzRg199fGRlp5nccARZQexBgAQCAcktNTTXB1aFDR0y1lS6RkfGSnKzVVnUY4lEFcnJy5MiRI2bJyMgsMiwwN7ewj5V+6IuPjzFDpfzlKyzRIWz64bu4AKQiG6T7qtQ65RSRGTPKHmb4Ewa5NhR35e3x6XHQwEr9+98iWhziPqywuB5b7qFPenrhqeuQQb1f7a3lqwqrpGPsbzDlK7jztd49INPXoDc6TNDaPz0ON9zgWXVXXG+yynpdeRMSEiJJSfVNj769e3dIVla25ORsliZNGpVrSKG3GQuLG16IovR3WWZmYYBVT5NPALUCARYAAChzfyttoqvBVWpqpuljk5oaJHFxdaVZs/qm6Tcqf8bAI0fS/xdaZUtGhphFQ6uwsAiJjIyRxMTCflZlHfbkLSzwt+qpIhuk+6rU0uFpOnNfWcOMkpqmF9dXytvj0+ogq7LJej7chxUWV33lq7eVayCn96u9tXwFWCUdY38r41x7U/mz3p/Kq7CwwsDKdf98Vd2590Szngc9vjps1FVFva580Z+hxo1byJ49O2TnzkzJy9su9esnS3JycoUG9L6GF1alQGgmr8+Hvg51CCGA2oM8HwAAlEp+fr4JrVavXi1r1/4tf/2VKZs2BUtQUH1p1eoEadSoBeFVJYaGWnGwe/du2bDhL9mw4W/ZtGm/bNmSLdu26RDOGImKaiBNmrSRxo1bmcqR6OjYcvXssUIaV74+VHurerJCiMqqkvG2f6UJM7xt7057SmkgYzUQd398deuWfD8DBhQGE9dcU3z1lbdQSsMv9+Pma59dq5t8cX1OLN6eG19VbOedV/zta0Dmy403ihx/vJSq0s46bqtXFz4P2tRdn5Pijk9lCAkJM03ew8MTTZi2Y8d+2bZtmxmyW1Gs4YUdOhRWYlVH9ZXVTF4fo7Xo/zUotgvt1achps5uC6D2oAILAAD4JTc3V/bu3Sv79u2T1NR88yEyNzdMEhNTpGHDemaoDSpr1sCjzkqrzMx8Z2VPTk5hLxgd3lSvXlylPQfulTDabFrDFteqJb1rnblPF903/Vyp/Zt0CF1ubmE/J9c+ThXZQNyf2Qv9fXwaRvmqMNKhc1o95P6ZWauK9HFpNZg3uk9avXLRRWUbcqfH9s47iz52195RxVU3eeOtckx71lmN8K3jrKFbo0ZFZ1HU4+RvQOZe1VaW58a1OstX5ZjuZ1UFPVptlZTUwAQou3fvkpyco5Kfv02aNWtWYT9/3oYXVqVAaCavs9fqpAD6+1GX8jbWBxAYCLAAAECx9Bturbjav/+AHD6swwY1VIg01T3x8XX54FBJVW46a6AGVnqqswYePVoYDOXnh5iqqjp14kx4VdYPbqUJiNxnB9Qwyj0A0Q+TGmq6ch1Cp3wNj/OmNA3E/Zm9sDiu2+sseFOmeA9f9LXv+ngsWgniHvSUpiKspEbyVi8z18c+e7bnMLqoKJH16/2rcHIPmazZC11fH99/73kfep2bbioatmlQGRNz7LXjLSBLSSm++swfvnpfaThY1bS3nw7T3b17qwQFZUlIyA5p2rRpjej3FwjN5PX3nh7r/HyH+X1JgAXUDgRYAADAKw1OCmcUPGxmE9QP72FhMVKvXgOJi0uolqMWCL1ZykqrCPSYa0N8PdXA4lgAFCrR0XGSlBRner9UxIfk0s4wt25dYXjxn/8U/l+fAy040eCquKol9womq4dRSaFZcc3jNVxxv74/sxcWx3V7DbNef11k795jl2sgo/utAZE3gweLzJxZGK5Yw/P8rQjzp5G8+5A+b8MN9f9W8OTruLqHdu6P06JVc+6BpK/eZ9br1PW1414V9/jj5a+SqsyeamWhkyE0aNBUdu/eIiEhRyU0dJc00iQzwAVKM/ng4BApKMgzAVaYlh8CqPEIsAAAQBGHDx82wdXhw+ly4ID+X6srEqRx48J+StXJ6s3iTnuzBGKAZfW0SktL+18j9gJTaaUzz4WEhJvQKiUlzgxXqmj+NvIuKfDS6hutyPFWteStgsmf0MyqDvNGAxRfIZs/VWX+XEfDrGeeEbnvPs8QylullV6ugU1CwrEqMOVaEVbc/bqGgcUdP9cgzNfz5xo8WcepuPt2fZzF0ceglXfuMyoW12i+PFVxvpR3uGhF05/NevUay9692yU4OFVCQ0MlRcvNApwdmsn7E2Dl5xcGWABqBwIsAABggpQDBw78b0bBLBNcpaUFSZ06SdKiRX1TaWAHgdCbxd/ZA1NT00xwlZGR5wyt9K1ZTEwdadiwjoSHR/g9zK80wwFLGo7lKxDwFZicckphFU9JvZSLq2ByD81KGlJX2pDNNfDyt/LMVwCjlVauFUDWY9PL3avAXM8Xd7+qpM/g7pVG/syeaB2nkh6ze1WTt4o67e/lbfhkca+d8lbFeVNZwVh5aNBct27D/2fvTeAjK8vs/5NKVVLZ9z3pdDrdDTQ7OAgKqNACIggDqDjOAMOMiozguPzH+eE27sw4grgLgo4zDiAIuLAIyDoIgmwKjUCnO/u+p5Kq1Jb/57zVb3Lr5t6qW0klqSTPV++nUtu9712q6PfUec6DgYE+3HMP8OSTUWRluda1S1SHyV97LfCxj2XGcTZDJyq/U+heFQRhcyACliAIgiBscuFqeHgYfX19mJgIKeFqZiYbZWVV2L69WgXlZhLrIZslUQg+ywNjotWsEqy4hMMuFBYWo6qqRJUHGnEqtqRaDriUciw7wcvOVWVEB7xTUHMimiUqqVuKyGYUvFJxnlkJMDwORheWUxdQou1yEm71nBaSrLZhdf6MGN/D0k0r9ONmVxOvme9+FymhQ+CTCadLxUqk/eEPV2ZbS4Fl1aFQEM8/X4i+PteGcImudZh8MqJRZl/x+0UaiAjCZkEELEEQBEHYpMLV6Ogoent7MT4eVBk47ChYXl6D+vrKjJ0QrEQ2y0rmarG0ZWpqEuPjE5ie9iunFRe6lfLyilBaWqLKMu0yrZyKLamWA2oxgMYFXbrGW7sQ8kSCV6JcKHPA+0svORPNErmLEgklTlxlVq/RAtsttyQXRDjWSy+NXTccg9Ng8mRjs3qOYu3vfx/LHjN3COQYE3VPZKmlfg/LgK344x8X8sSMrqYdO4C77rJ3d+XmxsLdORb9uTGGwCcSTpfKUkTa1YbC/wknDGL/fgrRPDBZ69Yluh5g+SA/uyzbFARhc5CBZlBBEARBEFaSsbEx7NmzB3/5Szv27g2ip8eDkpIt2L79cNVZMFPFK7MLK13uK52rRfFGL7xPx8RSxUHmWXV3d+G1115DW1s/Ojr86Oyk4yofBQW1aGraiZqaRhQUFCUMZNcChRErN47T15nFADrudOkabykwJcK4Hb1+q23bCToU1KzWYSeWWUGRhGIYx6/L7xK9zyyQWb1GC2xW67SCzqw3vzmWN8VQe5ZYcbnsMuBDH1q4z4Wh9RSJEo3N7rmBATr0YqIdx6fHyPXpdVJ4opNKi5FGAUu/h+uwgo/r/dVuM97q9SbqFcDP4EknWT9nJ5wuB4q0q7WtpcLP8lvfWozqatbTZq07l+h6gmWD/K6ldiUCliBsHkTAEgRBEIRNAkvXXnnlFbzyyj7s3RtAR0c28vMb0Np6mHIOrJf27zqbZdeumBNrudkszNWyIlXHRDgcwvDwENra9qKtrRvt7T50dFAwzEVOThUaG7ejrq4ZRUVljkVCJ4JMKq9LRQygQELxxSjGfPKTMXcOxQvtPLLaNh0x5qZgWqzS4ohxHVYYha6iouTjtXqfnUDG19CxZIXucpgMdvqjmKRFIi501zEnyviYURRLNDZuV18WvKUbqr3detsUzozCE19Pl9VSsqztBCCu9/TTrZ+jGEOxiw7FVITT5ZCqSLtW5OXl4cwz/XGPZWIHv43ivuJ/t1xycAVh0yB+S0EQBEHY4Ph8PvT09GBszKcm01NTLlUqWFeX+W6r1chmWW6uFo/v+PgYJid9KtOKDqFQKBuFhSWorS1ZdgC+sUysuDhW5sZyN40uKTv7bOfd2ZyU2tmVbFFoscqFMm773HNj9+1KBZ2EexvDui+8EPiv/3IWOO8k5JuPsXPiV78aXzpq7HJIEgXj5+QgZZEo0djofjO64eiOSwTPAwVGjsfJWOjSGhuLfyzZdUJx98EH4x1cdLxocTfVHLXlsJrbWi4nnVSIe+4JYHDQi5aWKE45JQMHuc4JBmfVtegxK+WCIGxo5NtUEARBEDYoMzMz2Lt3L15++VXs3etDW1sWsrNr0Np6OKqq6teteLVSuVqpOCbC4bAKv+fxbWvrUm4rlghOTeWhuLgeW7bsUOWY6ejeaHQslZQsdv1oh49TZ5NTx1YqJVtW23bihEqGFroOOWTxeHXGky7R0/BvhnvzeV3eZ34NOfhge4cRxR6+3upY83GuU+c9Wb3XiHnfjaV6RuyOtx3cP33u7cotjbz//YtdZzpPzOr4kLvvXuyk430+rknHeXbKam5rOeTkePDe9/qwZYsf//iPwxkpsq13AoEZ5OWxA2R84wtBEDY24sASBEEQhA1GIBBQ4ezDw2PKxTE2loXi4gq0ttbB40nBNrKJMLqwErmvKAoyQ4zlmCwXo4gQDLoOuK1KLQUrq+5pqXZq06IHc7msus5pUcmJs8nONWWXq+U07Ny8bSdOqFTgeOg0CgZj93nsrYK8Uwn7tnIY6c6KLNOzgo9TzLKCAtH73hffwS+RS4jXxj33xEL9rdBijV2Yuj73PHc8L8YQd07uGbSus7H4PK9ZI8bgdY6FZZHGa5PHzB9fDafu87WvvALV/IHXNY8J3TBc169/nd5QdfPnR29r+/bMdF9pjjyyALW17WhuzkIkUiE/GKyAgEXtqqCgIN2rFgQhgxEBSxAEQRA2CMFgUAlXQ0MjaiJL8aqwsBwtLfXIycld6+Gti1yta6+NuWuME2N2EpyYmFDC1cxMUAknLBV0u70oKipFQUFJwgyW5XZP0xN43b3QDMsKEzlREgloiQQmq5ItHXbudPypCGpOxk3hQgtYdq4wu46MDOfXJXd63Fwfu03eccfC67jPzzyztDEzH+y44xY6+CVzCfEYMjPLjvPOi+2/lWhpzhUzC2elpbEyQ6cliUZhjkIWj5HdseRrKfaaxS06urSTK10iVqJS1kwmNzcPLleO+s5gU4dSnhAhbfj900owFgeWIGwuRMASBEEQhHVOKBRCf38/BgeHMDIypyaq+fmlaG6uh9ebt9bDW7e5WnSyUbSieOXzzSnRyu/PUm6rmhq6rZwdWzsRwGn3NLsJvKawMLETJZmAlkhg0mHnRmfPanV/o4hi5XSim8gYVm4WiaycY0a3EcWlRx+dw4knRvHOd4Zw2mlzeOqpXPT2ulBfH8GOHVO4+266OhZn62RnzyESsW920N9P9+MQzjorF3ffXYqzzprE4GBIBU1nZbmQnc0lWy0uVzbe9jYPXn3V2hXJ4673S++Ped+N7i4KZ7feGjtmVVUx8csoaKWCztRKdP4pBN53n7W4pd1cGop0FE3pCkvVhbjcz89aUlBQjJmZYUxPT4uAlUb4o0I4PAuvVwQsQdhsiIAlCIIgCOv4H/EUrgYGBjE2FlUTV4+nCE1NDcjLk7KKpcLJ5ujoKCYmfPOih8uVq7oHVlYWp1wK5CQwfSkTeA2FipUSAHTY+X/8R3xJnXH86SiRtMIumJyOM2MYublEL+Ycm8N3vmMtNLFccGgoC889F8Rhh/WrcZ96ai4efLACb3vbCHp6ZnHYYbPYt69m0XsPP3wCL7xgdNJwp7Pmbw85ZAI9PWHk5IRx3nnTaiz6vOuOjXrhZVRRAVRWNmB4OH5nPZ45XHJJAOFwtgqp/vu/z1oUZq/LAnWgP485xUx2I6RLjWKWWfBiN0cKsebgertriuWAxvJK4zlg+eXTT1uLW3ZlluYSRicuvuV+ftYSity8Vv1mq5qwLHy+CSVe5eV54aaNUhCETYN84gVBEARhnTE3N6cCxFkuODISVu4at7sAdXUNKCgoWuvhrTtuvJEizByiUS4RRKMezM3V4KijcvGOdwRRVVUOrzd/zbqn2TmKCJ02fH4lBQCGnX/oQ/bjt3N43X77QmkeJ5tnnrkgVjgRvbgNKwcRS+X4fu5PQ0MUBx88jfHxMO69N0c5qbjOmRmKShyglYgVE5t27pzEyAidUFkoLZ3Du989qkpBg8FCla9UXh7G6OjCP5VLSiI444wc9PREMTTkMrmxslBVFcWxx5ZQ3lGfUS7clr594gkP/vSnnAP7vLDjVVX+RQLWmWcOwuudQVdXTIQqKsrFlVfmwuvNxUUXeXHttW5VTmoWiShOUXBiKZ8VdEIlE6/ouNLXFM+tMWtMQ6GMuoG5bDFVnIqo66X7oBlm4lHMCwZD6gcHaZyRHqamxpWIKmWZgrD5EAFLEARBENYRPh+73XVibMyP/n4GNOehpqZeZTEJSxOuKL6EQhQitOgRo6urEjU16ZklJwtMT3UCr2FIN7vIJXI8pUMASDT+RA4xBohr4cRJ0Lq59IwlZ0bzSmlpBE1NA3jHO7Jwzz3lOPXUmGOKos2LL9bFCU72ZKGgYA7PPFMTl3XFY3jMMbHjSHbvBn7+84XnzzgjW+XtnH028NvfAjt3ZuHhhxeeP+UUV1yIPwW6J55YyOzSx8JMaWkRKispSsfEsMrKCFpaXJiaykEoFFTnKSdnFh7PrHKl5eYC555biFtuqTI4wBKX9WmMbiw7jHlodudWO7RYtsiOj1YurWRh9Kl8Dpbz+VlLsrPdyMrKRjgcUecyO1tKupdLNBpVDqyaGnb8NLX8FARhwyMCliAIgiCsk4D2np4eDA6Oqs5fU1PZqK5uQGlppcrXEVIjHA7j8cej6O21qlOLiQL9/S4V6J6OsrjlduSzc2HZdeJLtwCQaPyJHGKpBq2bS8+qqkLw+xeyqAKBOXzta1XzLqJXX81HSQndQB4cc0z4wBjiRR0r8vOzLAU0imfPPhs718xEq66Oddrj/lK04kL4PBf9PG8POSR+XXv32ncXNMLx796dhV/9Knb/Xe/KRnl51bzbksIH836CwVlMTFCsC6GiwoeKihKMjCxcv8zvuuCCOfz5z+6k58KMLjU0O/qszq3xNTwuFPTuvDPx+puagD17Fl+7TjsWpruj5WpC1xWdnZGIjYIppMT09CS83igKCnIkwF0QNiFZczFfsyAIQlIOPfRQdfvyyy9nVHh1Tk6OmtwzJ0QQNuKvzQMDA+jr68fwcCznqqSkCpWV9Rs++4MOKU7qzWVm7Br3D/+w9O+MkZERjI+P49FHC3HDDY2WggedLlbd7thV7zOfwZpAwYcTeApQjz22+Pkrrog5YpK9nwIA9yOd/OEP9p3yCMt96BwynsuxMatA9PhMqe3bfRgYyMXUlPX3e3PzwrVAh9P3vhcTlBLBsZx+OnDbbclFHe0As3IucdunnhoTtbi+rVvjn3/ppXgHlx3GfTBDF9dzz5nL/uZw5JEhFBUF8JvfFM8/+td/PYCjj57B3r3l+OlPWcronPPPB55/3vraMJ9b5mjxXGpBlwLWJz9p32iA12t+PvDaa5n1eVotenv3o6wsgB07GlHEgycsi56e/fB6R7FrVw0aeXFtoH/TCoKQnI39L19BEARBWMdQZOnu7sbIyCwGBjihLkRzc9Oy8pgyWVwy89RT1q4eTqhT3QY7ClK4mpiYVKHszAhqaQmhri6Cvr7FoeynnGJdirWWnc842WfHQAo1bW2pl2Pp968ERqeOuexPh3cvzlKyckktZEqRwcF8zM1lKceNVQne8ccv/M3XvPWtiUUjar4UaygaURxKJHZRtGKmlJ3bh9umaMV8MCt27Yq5lRJ1kDTvgxm6uIyB9TGy8MQTOTj55Jx5BxjLDuvrw6qsuKpqFFVVeRgasknBN8Frh5/bc8+1P7dGQVc3NjC6/hjobhYwue/Mynr/+2PB8lYC1nroJLhc2H2S35P8MUJYHnQfTk2NSfmgIGxiRMASBEEQhAxjdnZW5VwND0+qySlLqKqrG1FSUo5MIZ3ikh2cFNMVYuY973G+Drozh4aGMDa2IFzl5hagoqIc+fmFSswwT7w5oee2OTnPxM5naxVqnSx4XZd4Uejo7o5/74KDKd5hVVAQwvS0B0VFEVUWayYnx2XZzY5Yle3xtXZilw6kb2mJ/Z1M7NJYrctq22Y4jre9LfE2kq3njW8EOjoWP87MKTqzmEUVc4Blo6amAcFgADMzU3jTm4bxyCNVmJjwxIWzmzsGcowU6RKV8vE1Z521EMhvJUAZBUyjcKXdXDyGy+0kmI5ulyvVMTMRFK5iXSfXUd1jhjI2NoSiojmUlBSgoEA67QrCZkQELEEQBEHIEFjV39/fr8oFh4aiGBnJQllZDerr61R3tEwiHeJSMuiC2rYN2Ldv4bHW1tjjTn6pZ6fG0dFxJVpx8XqLUFtboVrba+wm3nTqpEskWolJczpDrZ2Ozy54Xbtw/vIXOnPm4PdzRa5FYlV2dhSRiD6Ascenp92qHO2CC7KV0EOnlobHmuHvdlAcMp8POtMSGV2MLjA6pLSDifubSqiG1baduLBYvmgcQ7L12Il3hEKh2QGWk+NVy9FHR7Bzpw833piH0VE6tYLYvduH//3feBGcx4ruKH0O7a6Fk09OLECZM6rMZYjpEF2TXX/pWMdKfFaj0fABAUumXcsVAilgbdkC1DDBXRCETYl8kwqCIAhCBjA1NXXAdRVQ5YIeTzG2bm2K62qWSSxHXHIKJ30f/CDwr/+68NgHPpB40stwdpYKjo6OKqGAk/Pc3ELU1lbGCVfGbdhNvNMlEqVj4p1o3AzIZgbRUifdTsdn1/CruDiMsbEpPPtsPoaGcheVAfLW5bLKu8qa76TIEHBz2SHFFTsBi/vHEk8KDhRyWOKm15WIkZGYQMFjo51F//M/1nlnVtvkMbYKdDd2LzSiQ851QDv/vvvuheB3Hvdrr1187rg+YpV1pmGulB0uVzaKikpwzjlR3HtvGG984zBqa2eRm1uC2dnFTrf9+6EaFvDzYtVRkHleZgGKny9zB8xEJarGzxPzxXjt3nzzwj5rMdHuOrYL/jeWISYToJKtYyU+q5FIRO0vw9wzhdUoAU83k5OjyM0No7g4B6Wl0nVXEDYrImAJgiAIwhrCUHHmXLG7IIWrmZnMKxdMl7i0XKEskUDGSSJFK4pXk5NzaiLOlvXV1dVJM8PssqHS1fnMbtJMQejjH1+68KTH/eUvW0+677prQaxJtD4nwgAxl59pBgZ4DY/jkEOC2L+/xjIUPxpN3BWQ5ysVeMzoqtM46fZH6PBirpQWm+hgYvaTk1JCdgukoEaxyzxerpMiUHv74vdxG1deuXCfopkOfv/d76wyrmLrI1ZiksaJWNzS4sLll7sQiVThgQfYydD6PHCfErm9eC1QwDVmYTntgGn+PP3nf8bOF8VEI9y+lQtOr9uqI6JZWE4mQCVbh9PPglPYOZLirdudlVGNZlajBDzd7uSRkQElcvI7XTrvCsLmRQQsQRAEQVijf5CzxK2npwdDQxE16Sopqca2bfUZ9Ut9OsSl5cBJ7//7fzGXCh0iZhEpVlYydkC4iigxICvLi4qKKpVxtVzSEXxuN2mmIJQOt4edM4riB9efaH3ascJLzthpj6VuRmEgEgnhxBODeO21xbkzBx/sQzCYj8MPz8Mzz8xhaCixWLXWmEPTjaWEiaBwQw3Cyq3FdVIwtCpfNAsFuuyPx91ONOL6KOZY5V8RNrPjuJ2Sne1BT48npTJJs8DDnCyW1lrtv50LioKfFhe93phrjCKYleBoNza9bidliMkEqGTrcCKSpQIzyVgi6/V6M0p0WY0S8HQ6wCYmRuByBVBamo3KysrVGaQgCBmJCFiCIAiCsAYh7fv378fIyDT6+vhIPpqbmzOiu2A6xaV0cfTRwE9/ulgAZJdGioCTkyxh42M5KCurQkFBMTIJu0kzJ2/p6Mxm54xysj47xwqdSh/+8ByCwbkD7ik3olH3IndVVVUUJ5xQiezs2GPm0PJUs6WcvN6cI5UKVqHpVt0LjU4jjV05o15nZyfw5JPWr7nmmvhSQwo8XKwcVhTJ9BjthDWKjd/8ZvISRutA+PhzWFY2h7y8LPT2Wr9PCzy8VqyOAY+VExcU36vfb3V8rTCLR8nKep0IUInWke4GCbOzfrWvFLA2Wwl4uhxg/JFiaKgX9fVAXV3duvmBRxCElUEELEEQBEFYRdgRr6urGwMDUYyPZ6OqqgGlpZUZ9ev8csWl1cgLGxgYwNRUSIk3kYgbpaVVKCwswa9+lbXqXcacYDdpTofbgwKVlRDmZH12jhUKJDMzvCYTX5ennOJS7i0rNxNvGf59++2OdyWpeMVzycyvl192tj46howikTE0ndcJO/npberuhWxu9o53OB+3XqedRsFcLp3NpcsXeWtXHsgxXH11bH2hkPVrjGKQcb2JWDg38ef0rLMmUVJSEifa6I6FTsrrTj3VmQvKSHMz8PrrSIpZPEpW1utEgEq2jnQ2SGBHSB5zdszLpNyp1SoBT4cDbGSkH15vCOXluap8UBCEzY0IWIIgCIKwSllXHR0dGBycUE4Hl6sILS1b4fEcSJ8WHDnXKFyNj0+ryfXsLIWrShQVlc4LgMsNYV6JLmSJJs1LdXsYx6mDxa3K15Ktz8qxEmNxjpXVPpmPtQ5G1xlP7BjG0HJzQDtpaYnlRqUC95VjpUvJTtwxYhSJzO4rij5W+VMszzvsMODBB2NZV+Zjy/VwHNx34zqNbpZk5YsLbihr8ZCLVZkdu2T6fPbrTYSV06ywMITm5lHU1rrQ0FA0L9pcdBFwyy3x16rVtUKB0Cw62F9TMbj+ZOPk8bYTj5KV9ToRoBKtI13Zd4EAFcYw8vJcSsDKtNyp1SgBd7JtjdUY2E12dHRAld02NDSs2x96BEFIHyJgCYIgCMIKw1K3mHgVVvlAVVWNKC9P3y/JmfTL/krAgHaWCo6MjCpBgeVjRUUVqKqqhMs0u1xuCPNKdCFLNGlONNlOJKbZjdNIMvdIMBjE9PQ0Tj45gptvNufK8DqNIhBwYWrK+v0UGdraYqKIVcaThgLHf/1X/Gt42ige2QlviaB4deKJwMMPO38PHUUU1oyXi52IpDsUnndeTIjbuTN+W3Rc0aWlRTq9zkSiFDGKXXRDORXhjNvl2L7+9ViJp0Z3RWSeltGFZXaYaTh2vp/i01lnBdT5zc8fxyWXFOLmm7Pmu3Gar1UrdxPL4/6//2/x9Wl+nRFdPmvnwOL1QPfZJZfYi0fJhOblClDpyL6bnp5Ux7qoqEh9T6117tRalYAvxwE2ONiDkpIoKioKUWYX9icIwqZCBCxBEARBWEHhpaurC/39I8p1FY0y62orvN68tG4n037ZT7f4Nzg4iImJWEB7Tk4h6utrbJ1rywlh5qQ4lkm2GD7OSV66SxITuT0SiWmJyrSqqmJOnfe/3zr03ufzweebgt8fxO9+V4IXXihRndLMnQJZHkgx4bbb7MfvxPlDZwXFF6MIxPWm2nlQQ8Hs0EOBZ5+1zsKig8ooulFE4PbuuGPhMZ5Dlr+aM6aMIpMW4vhelizqskg+z+NqFOmchMHzOb5PC0upCAYcL99DAcTsZtPH0lxGaOcwY8knlyOOYAB/AQYHxzAzE0ZDwxS+8IXE+XHGzxfFK3Mpo74+zz574XW8JcnKZ41QzKCItFShOR0C1HJgRp/PN4naWma2FWVE7lSmlIA7dYDx+E1PjyinZmMy254gCJsGEbAEQRAEYQWgSMCg9qGhIPr7GZRci6qq+hUpgci0X/bT4RoLBALo7+/H+LgfIyOcpOegoqImaWfB5YQwc/JrFw5uftzKkbXU8kO7yXYiNxlFALMAYBSuuE6O54c/1OOhQBVV4sfcXAFycvIOdIlzIxLJsg0Sf+wx+2B1q0B0O3gM7ASnRJgdWhzL/fcDDzxgnSFVWho7bkbRLS/Putsf3WNmwYnledddF+vsGGsMEHuc26Low3m01bWkRalEweR63+2EpURwHBMTiV9jFhPtHGG62yQ/V3QGMTvO5xvFxMQEioqKHQuuRx0VLwoar0+zMEuSlc+mIjgv12m50vj9PmRnR5Cfn42CgsKMyJ3KNBI5wPjjT19fuxIA6+urVQmmIAgCEQFLEARBENL8y3tvby96evqVcOX356CpqSWp8LIcMvGX/aW6xp56ag5nnz2E4eERlXPl82WpgPbi4nLH4t9SQ5idhE8nmiinu/zQyk1GEeXmm2OLWSy58ELguOPsxsNjt5C2Hggk7uR10kmxCSVFHrtgdWMgeiK0uKOFk1SgCGPs7JdMyGFJH0U1blM7piieWbnIKPiYuwZqRxEXHbxuhPvBRaMvSSedFk84wVmpoRPy8+OdT1ZiYjJHmBa8/vjHQjzzTL66ttzuWPZZIuFVC64UFunytHM7moXZROWzRpwIzst1Wt5772InG8sWzzxz+c5K/jdgbGxIiakMxzd+b61l7lQmlprbOcAGBrqQnx9CZWWuyr4SBEHQiIAlCIIgCGnC7/cfcF35VclZYWElWloaV7zt93r8Zd/ONdbWFsHf/V0potFS7hnc7my85S1ZKU0qlxrCbCcY0QXgZKKcbleIlZuMIpDRTcQyLgpZ5jHxWjzuuABefbXMEMiePJhdb/f3vwceecRemCkpce6+SsVxxG3rYHqKLzymr7wSK5HT2U1W76GYYizvMwfJa0FLo1/L7XR2Ll7nMccsFrescCJcGbfnRFgywpwq7rdRtLMS5azERKvQdqvxtLVlY2pq8XcUBVCSyFVo53Z04kbUn9Of/SxW8snr2ngdJ1vHcpyWVtcRBcF0ZN35fKyNnUVxsQuVlZUZkzu12qXmSxXMfL4JVTpIoe+223bgv//btWgdfP+nP53+MQuCkPlk8D9tBUEQBGH9wO54L7/8Cvbv96O3143a2lbU1TWvuHhl/mV/PbivzONdYA6Tk26MjORgbIyLW4Xe64l0Kmj3R6IcHTvByMi55y5+zG6irAUwI6k4wKywWqcRhoBzLBQAPvnJOdx22yx6enqUA7CqahxlZUGDaJWlhAuWGprFKCMUg9gBj7dWAg1FFQacO51803HkFL1NCnMUofS2eAxYEsvxG+H9iy+OPW8Madf5VbzVQo4RLfhoMckIBaM9e9IrLhgFJqvxMGT+He+I7S+he6e+PtYNkCKceV3MANPjTlTKabV/5vEsnJ+5RcKrdvFRXNIL7+vPpPH6NF7ryd6n4efzi18ELrss9n1gDG5f6raTQVHUjuWWILL0bWxsGBUV/JxVWX7/a9cRb1f7RwMrVqrUXAtmzH/UC+9TMLMjHA6jr68DdXW8/mvw8MO5qlNpe/vCwvssIxYEYXMiDixBEARBWAbs5Nbe3o6hoakDwcYl2LatGW63Z1WP61r+sp8u15idO8hqUrnUvKlUyw/pFiBOShKXk79lh9Gl0t29uGuddivFHDpZeOGFKLZtC6ryN5atnnqqC7ffHi9c8PVGV44WwZx2Azz/fKhgZTNWXe/swtKTweNG8cnc1dDsKOL+cCzmQHUzRteTUfCxcinZZWalis4O4/YovPCzaTw2RufY5ZfH7nPizvPFzC06gpgxxfckc5nZXWP6dffdF1sfnWzG/ec5YzaZOcSfY6eD0S7TS38m7dyOqboRrXLgkq1Db/u7341ll33iE86+C+xKF/nYcsRmMjk5itzcMIqKPBnXNW+1S81TzWaMld/vR1ERSwe9qK+vxxVXAI8/vvi1fFwQhM2JCFiCIAiCsETGxsbQ3t6BwcEIRkZcqKlpQmlpfMlIpneUWqtcFAaK79o1iIaGUvT0eFFSEsLExGLRj84Uq0lluvOmNHYTcqcliUvN30omytGlQhGLQoQ1sfLAQw7xweMpRWlpEVwuNw47LBbEbhZuGNKuxTBjlhIdQFbh6JpEbh+7UkHmaNmVsqW6DTshKhlWgo8W3CgMaYGItzU16RGwmpuBrq7Y8eW27DLA+Dwn6TzPFOuoe1hlZNGVxmuKIfPGa+TOO2Mlj8YOhEa4Tjqc6F4xC148Z7FukPHiMdfPkHcr9HVtvl5/8IOF65WP0Xxk3GfepwvHKU5yrih88TqwEro4PpbBOik/JKm4Cq0Ih0OYnBxRzrmampoVadixnkrNUxXMhof7EI1Ooq7OhW3btqkGAxTL6TZkF1ANv9N4rgRB2JyIgCUIgiAISwxq7+7uV64YoAAtLS3Iycldd8dytXNRSCDgR09PL8bHgzjzzAB++9t6vP/9biW+mcdiJxgtJ28qmXvLyg1i1ykwmQD26187d4olE+XoaHjwQTuBKQuVlRG88Y0VcLtdlsINhRktfthlN3HybZUJpddl14UvUTh5cXGs5MfO5cUSRmPGk7G8zcrVxf3nOo0lg04wOrnsBDeOj26eVBxpVnCf+H4KOFxfIvg8x6IFKLvjSNGFn1crkdD4fjPmY0hXF69Bil4L23KWj6bHweuanyOzI5DoEj+zYMf7L70UK8t1+nl04mi0+y7g2MxCpP4smcWxdLivGNxeWDiH4uI8FBUVIRNZzRD5VAQz5l6NjfUpN+XWrc3Iow3ywDo+//l41xbvZ7rDWBCElUMELEEQBEFIMeOEQe39/RNKvCourkF1dUPG/dq+UmUeyxX+RkZGMDg4pNwdMzNuvOENFTj55Bz1vHmySvcVJ5rp7kK2Uu4to9hFceCHP4y5WKyEEDpDzNtKJsrRHXXmmSH86lfW5amnnpo9n6FkJdzQbeckTN2u3I/78ac/xTsqtBBCYqVo8furA8hjLh9ruH/GroFGV5Wdq4vuJgovdB+ZhY9EbiQjdkIRu/OxAyZzxeygS4rPm8VEbp8LuwTaOZgSdQS0C3k3hs5bjZlCzTXXxP5mfhlL/+jYYmc9jtPK/cVjy26TVVVzKmtOw9zx3Nz4z5Z25unP2Fe/ai1e6fPJcVpdy2xuQcHKeO3bfR75OjpBEzkatfhldntR/zB3GdRjMwrNN90UGyv/dho+b8XMzBRmZibUGOm+ylRWu9TciWAWDDK3b786z/X1VSjnF78BowtL3FeCIIiAJQiCIAgOCQQCaGtrQ39/AAMDLtTWNqOkJP4f2+uN1cpFYVYYXWvj4341Mc/JKURDQx2ys92WohRL3D784cTZPkvNm0p3t0Ar7CblGooLTkU5ll19/ONziESiapKu84ry86PIz8/C8HCWZTmd2XljJzgYoehCAY5iBUUcM3zcLEZRuKLjyEqkopBAcSaRq4vuLO4XRQizwyuRyLQUN5IRK6GIghvdanblfhruK69Rs2Cn3W0UapxiPndWuVzm0HnjmDkOq656FLK42MFjyHWecMIMfvWrgvnH3/e+2D4YP1sUkl54YcERafcZYni5Fpl0h0wjk5OLheJEDio6thKV79p9zigwUgdJVn747/++fHE7FApiaKhXnZfKytJ591CmspRS85USzFhK3t3dhoqKCGpqCtDU1GS5ju9/P5Zx9o1viPtKEDY7ImAJgiAIggMmJiawb99+9PZG4PPloLm5FV5v/ro7dlaZV+ZJbrpzUcbHx9DfP4DRUXYZdKG8vAZFRaVJy++SdRBcat7UctxbTrGblGvoiuGELlnJ1LnnzuHeeyMYGuI/2djRbKGrWVGRC+98p32Qt517KREUQihiXXkl8L3vxQslZpeL0Z1jJzRRCKXoQmHISmSh+GMsH9SuJS2+WblouJ8UGRKJW05YToA7Pz8UZ+hWSiUvy5g9pqHwYc61IvqYJQud53X75JPOx6C3qde5Zcs4Kis9GB7OifscGD9bOjcqWRA6xS99HfLcW2W2mYVirotik5VgytcmKt+1+5zpjKRUBe5UxW0KMIOD3SgpiaK83IuamlqsFGuVV7hSghkduT09+5CT40dtrVvlXtk5mekUfPrplR+rIAiZjwhYgiAIgpCE/v5+dHT0qMna3Fwhtm5thduqVmsdZ16x1IhCViL3VaoTKE5Q+vr6MDw8oYSQrKw8NDQ0JOzQ6DRrKlHgupP3pbtboBm7CT7hpUMBy1yiRpfH2WcvvK+hIYr6+j4ceaQbbW01i3KKKGRQwKHo85OfxGdb8bws9RLVzhyzUHLccdZCiRapzM6g0tLY41wXhSErActq29rVZVd2SNHroYesn0sl2N0qFJ4i4m23OX8/BTazC4v5XHQaWUFnEM+LsSMgX2slNNbWxo6hWZw0j5miC4PyE4mN5jFxe2wMwM8oUK8eo7OvtTXLUeMCq88Q3VfGkl+rzDYroZjrovDFboJGnIjKdLqZ95Xr4+PJyg/TIW6PjPTD7Z5FRUU2GhoaV7SUfC3yCleS/v5ORCITaGlxobW1FTlWtlRBEAQTEoEnCIIgCLD/dX3fvn1oa+tRHbxyc6vQ3Lxz3YpXelJpxcUXxybGDNy1E3L0BIolbXrhfU6grDpydXR0oK9vQr2uoKAKdXXNCcWrpaAFr2RuLbuJ6nLdV8zM+fjHY24qvfA+Q66NjhUjdl3+6PLgsd++fQ7Z2XOYmIji6qur8cAD5UpcMIpXWqihy4rCIwUUo7DIv61KBvm+qqrEDiEtAGmhRL+PQgmFEDMUfCiGmEuvjMILS+CSwdfSscMsJzsBKBnGAHgn6JB7Xgu8ZdaO3mcnUJQzZ5ydcYb1cdLj4/HlNUDhhUKWXbkhzxOzy5hhlmjM/Dqi2GiE7jTzmPR+aRdY7JrJml9Yltrf7/yzZfwMcZ0cK697/Xn4p39afK3zvPI1ZiiOmqKPHInKLDE0uwK5X3xcC9wskb7kEmfXhRbmnIxjcnIMgcCEOk8U5j08CGvw3b0SeYUrDTsOzswMgxWD27a1oLCwcK2HJAjCOmH9/gtcEARBEFYQZjbt3bsXAwN+9PUxY6gJZWUJZv7rPPOKv+CzdDAdge/sMtjd3Y3h4TDGx12oqmpAfn5mTVCW4t6yCnhm+ZtdJzajmyoZWkTjddfRwbyrXPh89v9Mo1gUc9AgJShiUIy167JHUUIfCy2U3H57TGj51res99Wqq6FRCCMUhph1ZSwXTFZOmCqpuq/suhOanWdOoPFGHwO6FK2uJz2+H/94oTNhog6FiUQ885iNZZrcthZweEz5OJ+nRsBy0507gYcftl6vMWQ9WaC5VcnvL36ROPvNKgOLcF3MvPuP/4hdY05F5WQlf0ZHp9OAdielybOzfoyN9SuXXG1tNQp4kDdIXuFKMz4+jLGxXnUNt7RsQSlthoIgCA4RAUsQBEEQTExPTyvxqq8vjLExN5qaWjNOgFmN1uZLmUBNTk6qsPbBwTnMzuagrq4ROTm5yERSKVd0Esxu5abiBP/66627+pldHj7fJEZHR3DYYflob19cMphMNLJDO250uVoi0YTCx5498d38WPZmlTVlJ4KRE0+Mv6b4Nx1ZqQhDdp3kzDBAnvoBXUaploGag+41dplddiTKlNNwfY8/bp/dtdQsL8L9pkClHWFG8YuP83ktesUcSvGdB60EJieB5ubPULLst0R5UgcfDHzqU7FSQpbXMrQ7WSfAVEr+nAa0JxO3I5EQBga6VclkZWUhKvhHhn93Zwo+H8vJO7FlC7PX6lCVyA4qCIJggQhYgiAIgmAKa29r24eurihCoXy0tLTC49lY2Rx2rc2TZVwlm0ANDQ1hYGAYAwN8rAB1dQ3Izs6Ocz7QyaMn+Mzdys+3npwutZ39SuJkcm6eQHOC//WvA1ddZe/EamiYQ1PTAPr6/CoXadu2KKqqrAWGpcAA5CeecCa+GYUP3c3PTnA5+eRYa3vzenWWlBm6gDhfdSoCJuqgZx4zBQ8KDrymjOJbInh9cbEq6aSzJjfXOlh8qVBcYnaXE+FRu7WsBDa9f8RJl0lzeSEQxbHHjuG++ypsXVgsATR3EHTSrTNR9htJ5qzi54X7bvU5s3NuOc2zSyWg3U7cjkTC6O/vQkFBGOXlFOhj+WFr/d29HqBA39u7T33fNTRUoL5+dY+dIAgbAxGwBEEQBOEAIyMj2LevA11dc3C5StDcvA2u9fTztgO0SEVxgM4cCiac8FGkchISbDWBYlZYb28Phod9ymmUn1+O8vLq+UBjO+cDxSwuVpPTpbSzX2nxK9nk3CioaPeIXXdBTXV1FO985xBGR/2qfK6oqBzPPlsyf1zSwe9/z5Kn1N+nHUBWAe38WLCc1Eo0oVDzzW/GrjGKIMZgef5tLLczuqjM5YNWQo+V60u70bg9LXpp8S0RfI1dHhkFMX4+rMaaCLtOjcaxOoFZWXRr2QlsHDtJ1mXSqqxycnIEBx3kw7PPFmFoKCehiGneH96/+eaYyGX1WbISlIysRCdAp91IrT6/3B8Kn9ynZN8TMfGqE17vLGpq6MxtUgL9SmP+YYGfZV6bhx22ftxXMfGqDfX1UTQ0lKK5uXmthyQIwjpFBCxBEARBMHQa7Oyki6NCBY6no6NUprU+N4tU7GCnRSonGVecMP2//wdce23MpcFymq6uLoyOzmJ4mEHMdSgqis80WUpZUaqTWCPLEb+SiWAU7ZwIWInysBi6TVGCk7kPfagTk5NzmJrKRkVFNZ580msrWiyVZE4mjodlZsauf0bhw6ojYaK8KrvSu0TiDc8r85mShbfblSwupfzOzllGTSKV8kHzOikYLgcGwOusLLvrgPvH45msFNEcau/zjWN21qeccBdfHFXfT4lEMI7F+DzFLH7OE32WjEKRDnk3i0uJRGar7LhEwpTTPDsrcY37o78DNVb7ZhavtmzZsmpd8+x+WOjqwroTrxobS7Ft27YV7dYoCMLGZp3o9oIgCIKwclCA2b8/1mmwsLAW9fVb0/YP7FQ6960GiTpZaXeVEasylaOPBn76UwZzM3C8Hf39sxgZcaO2dusi8crcrcwKq8mp1XuSlR/pjoA8xlY4Eb/MIhgn63rh/T/+MSZwEPNE2a7zHMdDRxazpygWMdC8uTmM00/vx+joHILBHFRV1SEnx5vQFbRSnHfe4mNjFj6MHQnplkoH+nhxvTwm558fOz7LxWmYu3GfzB3xlrrd3btj7hgrnJh1uP88Djz25k6CGh5/7p/V+I1dJs3HgflDPt+Y6vZXUVGKI4/0Kqec/pyZjz0/b+97X+qfJWP3P95adQK0+3zx8VQ6AabajdT4vWLuemi3b1biVS7rS1eJ9dx9UMQrQRDSjTiwBEEQhE3L3Nwc2tvb0dMzqn7NrqxsUqVv6cRp577VIlEQeyohweyW19nZgf7+MPz+HNTXb4HbbT1zX0pZUaJsGzv3Bu9zImyFlfiVyAVi5wAziktGNxDX/6UvAZ/5zGK3BMvRuGimp0O4+OJula/kchWivLwSjz2WpfKM7HKHUhGFkrmYjLABGIUQossErQQgHnfuI90qdK2YS/lS3S638c53xjoT1tQA110XOw80tSxXwDOLb3ZYOct4/l95JXFAvRUUQ9ixkSIQA+ytuvxRGHvyycTroXjV0hK7Lp991nocukEAMY+f+84AerrZGJqvXxcTr0ZV8HhVVSlKS8sWuZeOOgq44474zxs/M1y/8XPlpEOgOUOKf/Pz9sMfxs6zXUmrFo+clgWminF/L7wQ+K//Suz0Wmvxaj13H4wvGywR55UgCGlBBCxBEARhU0Lxav/+/ejuHkN3d5ZyD5WU2Pwkv4ySQd7qkjHj5INuL5aprHZpoZVIxRKhc89dPF67SZJZvKqr24LsbGvxSotEnITrPB3dMY2Ch9PMGuPr7EoEE2UCm0UyjouLVYaTueTPKFJYhXpTjKG7hMctkVCnOeqoUSUEvfhiLV5+OU8dcwpcibKT7OAxZZdACgw6PP2225y/3yhyUIAxCx9GtHhl1cWQHQAfeSR5t0Wj0EKhhl3xkpWxOUELaE7dVxpzvhfPhbGU0gl8/+WXLxwzngOG2xuPBc8RRdG2NvtjROeWHjudeFbj4PmmW80Y7q5FLt7yc8HneVw1RvGqsrIEZRyMSWxiKDzPn/6MGrOuKPQYr2ljxlsq+XLJungaP+NOywKXglFcSxQAnwni1XrtPjg1NW4IbC9Ba2urlA0KgpAWRMASBEEQsNnFq4aGVhQWlqxoXokRTj5uvTV5YPpq/KLPrm1Wogy7A3LCZJ4kafFqYCC5eGU3aeVkm2VQlZXJM2usJrF27iiWwt155+LjSiHKLJJxXHZd27TDxTy55RjM6+ek+ytfWRibWXRjTpTRfeVyzeH++8txxBHF6OrKcyTc6GpWc4YUt0mxiR3ztPDE9vT33BPLcEoWQG7X6Y4uHKtOfnaZUXwtnVRWx5Pb4Hp5DWhxxCwy2a03FRcZzxXHYCe+2cGgdAbmc2wUkKzywoqKYs44O9cQ90c7yDTmY8FrigInRcK77rL+zLFbpB673THRr6HAZb52+Ll67LHYuYwxB7+fgypEXl6+akjhcmVbCk78PBhdVsasK6OYS4ecldOO+0QBLJGYlSwLzywy23UCTGejBjuRnNl+7Da41uLVeuw+ODY2hMHBTjQ18UcFybwSBCG9iIAlCIIgbCpWUrxKVDKoXR7GycdalRYag9g5IWZZj5nPfS6WdWUnXs3MJBevEk1a6fhykjVkNYm16ibGyScfJ0bRicedIphZ1LAbF11WehJr3A4dPhQdzQIHt2tc969/vZB1RdHGLHpEo1mYnPTgySc9Sjx0gpUIRcHls59d2LbRcUN3GwUsq/cZS/e02GMlhlh18rPqRqjHZ3YLUVSiCEpnFqHAduSRwP/9X0wwYvaSEZa9GYPTE5UkmoU57od2c6UK91E7yqwccDyPF1wA3H23tXOKohfHaXX8+ByFLKNgt3UrcOWVwPe+F78+vubkkxMfaxqnWDKYSOCic3LhXFD5jKmfs7PZCYPKEzVNSFRmaNyuFsDsAt6tPrfaPaYdX1ycCFHpaNSgt799OzAwEBOaY86yqLoW3vSmQvzt30bWXLyyap6Rqe6roaFeTEz0gU0GGxsr1bGTwHZBENJJhn79CYIgCML6E6+IXRA685E4KdWuJqeB6SuFDmKn28vJOJYiXi01jD0ZiUKejdvjdr7+detgZ7tgeaPTi2IURRWKGLzlhNnopiLMKaIbxDiBpuuKE3o7xw7hBDlZp7u8vJhDzgqKI3QPWWEUncxQrKGLjCKSFkDswsKNnfzodqHLyIljjCIg3XCXXRYTbLgcfHAs/4n7zDFQZDEufn/8Onj8KGpZYRSvUi0Z5H5QBLjmmthil5lmzqTSwpEZ5l3ZdTykOMxrjK4ro+Cgs7cS5XZZvcaYfWUV4L4Qrq8PkL39zhxUnuxzqoVkikOJGjJYrTvR51ZXM2rHlzHMPREU3FLZdiL6+2PXGz+3sTG4MDbmwb59RWhubl5z8cr8nW3+YSFT/tva19eBycmYeNXSUqeOnYhXgiCkGxGwBEEQhE3BaohXxrwSc8ngscfGTz7sXrfav6w7GcdSxSu9/lQ7iiXqMEj3AZdbblno6maVnUNRjkLcJz+58B4uXAfXZTUuCi/axUU4iaa4wsmtXT4VHTbGybbdxHopnflYrmVV0kb4ON1DqXTXIxSuuE8UovT7+XqzWMTjQ9cUBR+iXVp2ZZcabpcOI4pWRvT77Y6jOaic46SAlwiOka+jsKbHmQw9Di2cWYmI+royimN2x4guSp0/ZkQ7qugKMx8LvT79HjsRLtFrKF6ax85zk5/PA6k7qGYdCNBevH90Uxk/ExRrnXxOrT43dg5GK8wCM/O1UhWi+PmlG9Lc1ZGfnaUI4wuf2Xjh7+/+Lgc5/BAKCYlGo+jp2YfZ2WElXrW2bkF9okBCQRCEZSAlhIIgCMKmoLOzEz09KytepZpXkim5JonGwclJd3c3BgdTF680S+0oZsy5oTvCSjyhQ4kB6lbZOV/+cuIyI+O46Gj68Ifj15Mss8dqsm1VJpUMYzaUsbyPzQASYeX80XlWidxf5vdznykWGQURCkoUeHQZIXOgltMB0On7jfA61MHw+hgZ4Rh1+Z8WsBK5z5zmbfFaILrUUeeB2R0jBrNbdQNMJNLyuWSh+cbXGDs1EqvQf463rCz2OdVMTS1eMd/HQH4j5qyrZM0VqE/09i5+LlngujnXbseOWH6W8fNCIUqXE2qMZYV25YMsnV3KDwDHHBNBTU0UAwP6ey0Lra1z2L3bpJAJiwiHQ+jubkN29jSam3ncWhY1CRAEQUgn4sASBEEQNjx9fX3o6RlGVxcnXttWVLwy5pUYSwaX87qVJtE4ent7MTo6i6kp95LEK+OklfMaCg7MmTE7oqycVpzYcqJKh4ud84duMasSQSdlRka31qc+FStzM26fE2izy8OMeaKfzKFiBZ06utRMZznRtUMRxA471452GFHMsBJl7N5vty0tctnlURnhvt93X6xEz+yIcvJ+8/h4PfKY8NgY86GsoEvO7EgzlwtyoThodlLxvvGap7tNd1s0utXsjhGvT65Xr0N3A0wGz7GdQ8v8GgpORufYYidbTNnavXsMHs9C6SCFrvgmAtbbMWZd8fNgFoWN8PFLL13sOjM7GO3QAjNvrT4vFKJ0OaFVWaHd55rny/hd4oRQKIjBwQ6cfvpA3OMf+EBWxuZMZQp+/zT2738FeXkUr7Jx0EE7RLwSBGHFEQeWIAiCsKEZHh5GZ2evEq+qq7egqKh0VfNK0vW6lcZqHKOjoxgZmVITyJqahiWJVxpOVjnhtXI0GYOX7dwVViRzc9mFvRvfYw6JT7Z9Tq6168euzCq23Tn09GShvDyIrKxsjIxYK2EUlugssRJHDj005r6xEn/oBNJB6MaOgXYOI3OJHveBjh79Pm6LZWTGkkXuF0VEigLJhDy9DTrlCJ1TzAfT40uWm2RGO5i0gMN1v/xyzI2lg7+TOdLswumrquKdVAybT5ZHxnXzurDq7Gh+L8emXVnpIrlzLAs1NSG8/e2liESyLIPW9dhYFceuiomyrpLB1zFf7qqr7B2MS3Vo8rvgu9+1F575evM+EH5OUglxpwAzONiDkpIITj89gscfj2L/flfGd/nLBMbHRzAw0IHa2jnU1Hixffv2jMkKEwRhYyMCliAIgrBhmZiYwP79nejsZFlKLcrKqtK6/htvjJV5mVu5v+tdsXD09czMzAz6+gaUYFBaWgOvN3/ZrewTdTpL9horkmVpaXeHsSthovdwf/r67NdHEcf4XrvMHb7mvPMmcPvteTjhhAmUllap4HQrMYVB38Z16hJAfUzpLLLCLJr87nfAE0+wc5p1p0CrcjMuukSQY6A4ZxSwKHYkK0W0EnT09oydCXmsKBw5EScZRm52l+lyuttvj43JPC66qMzvsRN9KCzxOPMY8VhxSTQu7VZ76inrfbXCLth9qVh1JSwsDMHnWxCV3/1uN/LystRn7w9/sC9jpThDp9xyMumsygHtnJCprseqrNCcc2feh1RD3CcmRjE+PoDKSqCiwovGxkZcdZUr47v8ZUKW5MBAN3y+QZV3VVNTgpaWFmQ7UbgFQRDSgAhYgiAIwoZkenoabW370NU1B6+3AtXVKVpAHMAJrdUkkZPH9SBg2QlwZ50VwVvf2oObb67A00+Xw+Vyp5RFY+eCcOKISpYhxTKl0VHnWVrJ8rec5GwZRRmjG4pCi9VENxIJobJyDOedN4aSEop/WfjoR2OOKaOoo4O+nbiGCF0n3F6iYHerPKZkQosWzezWm4hUBB2+Ntm4OA9mB0Or40o3FstQrUQpuqjM76Fz0OzW4n2W4xnzp37xi8Rj4nni+5zkZ9mJactFdyU0Hr/TThvFE0+Uq+wmXtt/9VdZtsKthq9773tjn9FUM+mscOrYSnU9yYRn7sODD8YLvE72hZ/NoaE+RCLTqK2lqFqMuro6uFyujHHDZirhcFiFtc/NTanPYlNTnYS1C4Kw6oiAJQiCIGw4QqEQ2tra0N0dRVYWJyjNK7IdTqLYhczMe96DdYGdAPf44yEcfngYf/lLEUZH3bYClRNHVaqOKKvXGEWriy+OZVMlC4u2c3eY3+OkZPGoo4AXXlj8OAUvujXM4t5b3zqjxCCXK0c517RAZBbHKFTpMkAnpXYUsHgs6Ci0g2HpOo/JqszOKrOKbi47pxfFG+5LqhlW5nVQ0HnssYVx2Tm3GMpPtxrhayhY8Tjp19oJjFblehTzzMfAWN7H0kSrfDAzet/pguJrk3VitBLTlks0GkZj4xjKykowNpaD6uog3vKWHBxyiNvy82AnBPOz5XYn/kxkAsmEZ+4Dna7GUslkTrLp6UkMD/ehsDCKurosVFdXo5wfKCEpgYBfhbUXFMyivt6FlpatknclCMKaIAKWIAiCsOFKHPbt24f+/hBmZ/PQ3LwNWZwJr3D3Ps16yk+xE+BOOmkY4+MunHGGGz/4QeIsmmSOqqV0JDS/5qKLgFtuWShTStXxkeg9TkoW6boxd8GjmGQl6jD76aGHChAO5yMry6VEGOZNWQlEFEKMjiwtQFl13CPsgkcnk52AxRI9jsm8TieZVYmyqPi6225ztk67dVBYMApKds4tc2kkyxyTlTFS5GKGlxk7x5S5vI/jS7R/J5wQu+U+8Hp98snE4+E+ULRM1hHRCdFoRAkvPt8EvN45nHtuCA8+WIW//VsXysvLlKBpdW1r4fZnP4uFuNONxs8SOweySYE+/vx8m8t+Uy0NXgmSCc/EWCqZ6HsnEolgZKQfs7OTSkwtK/Mq59BaZzatlxL0qalx9PbuR3V1FLW1uWhtbUUev4wEQRDWABGwBEEQhA1FT08PBgZ8KjSb4tVKZnNwUvXBD8Y69xm74qXL0bDSExwrAa6xMYDGxilUVjaiqcmjgr0TZdGkkjHldGJqla2TjjIlq4m5zmdK5DCyKumzy+BhB7i+vqX/84piCUUXuuPM0DVEF5BdlhTHxH1L5NCyw+oY8DywzI5B78mOkdlRpe8bux3aCUoUAynwJXOM2aE76DnJjdLjMWaNcbFzhJm7NVLwfPppa4FRY8wWWyrRaBQzM5OYmppAbm4UFRXMvKLjqgynnOKsmQI/N1/8Ykyg1Z8lCnXJyn5TLQ1eKZJ97p18lzCofXi4F15vGPX1zGyqRGVlZco/aqzEd/F6KEEfGurF2Fgfmpp47Iqwbds2uGl/EwRBWCPkG0gQBEHYMIyNjaGnZ0BNCurqtiI317vi2zSKQOl2X630BMdKgNu9exj5+cUoKChS95MJVE4cVWacCFL6NRSdfvjD9LhB7CbmnNhaiTN2TiiKCcYcIQ33/4wzgvjRj+js4IAXJsnJBCCjWMJ9p0hiFHSYt0WXEY99Tc3i/eAx4XsotjkpHzRnNlntJ9dBNxedU+efD/z3f9uXGprFH96nMMWsKX29WAlKxNxNTsNyPTv3lZVA5iQ3SrvB2CHRiVONr3/88fhgfY4rkYBlF+JuDujX+6E7QWoH6czMlHK9eDwRda0VFLhVuVZBQSGWgvHzZuc4ZPMCXQ5rdz6cBqSvJnbfJRQAx8aG4PONqqD20lIPGhoaluwcWonv4kwuQQ+FgujtbUc0OoWWFn7HV6ug+5VyMwuCIDhFBCxBWGHe+ta34lH+q9WGe++9F2ecccaix3/yk5/ge9/7Hvbs2YOcnBwcf/zx+MxnPoM3scWUDU888QS+8pWv4KmnnkIwGMSuXbvwkY98BBex/kYQNjh+vx/797eju5uTlVoUFZWuynY5Gf5//w8r0r1qNSY4RgGuoSGAbdt8KC9vdSxQOXFBLKckyU50Yqlequu0m7wzNJy5S+YJKiuMKKAYxQqKF8xOognBLO5RoLrjDg9crjlEowsTPYosHFeyMjyWnl13XUzQYLg799HKZWQlhPE4sDzMSvDRQpydIMfMpkQ5YBTfOInlf0rYHY55ZE7g8WHYcyJBKRG89n7/e+vnrAQyK4yimVHscmIi0RlhLAG1E6wojlA0ND5vJ6rZBfTz8ZNOiijhiuWCLldElUUWFGSjtLQMhYWFaRMO7LKxzNcUj61RyEokTq9UyeFS1zs7G1Cuq+zsWTXuiopS1NTUqKD2TPouztQS9PHxEQwOdqG0NIKaGheam7eggkqqIAhCBiACliCsEueff776R6gZ/iJo5p//+Z9x3XXXqV8KTzvtNAQCATzwwAO4//77cfvtt+Pcc89d9J5f/OIXeO9736t+dTz55JOVRf53v/sdLr74YvzpT3/Cf/7nf67YvgnCWsPrnrlXfX0MbS9CVVX9qm5/pbpXrcYEh3O6f/3XOfz7v8/i9NP7UVJSDrfbk5JAlcxRZSdCUQzRIo3dxNROdOIEm4KN1aTXKPwY12uX2cXHS0vj84J0KZgZGjheey0mUBjXt5CJ5bJ08fD1LMdL5MKigMWFggaPOYPj6RIyZzzZ5WAde6y14HPSScDrrwM7dwIPPxz/nBNxbc+emEBLYe3KK4FvfCN2nBJhJ+JQUKLji/upryWjW0yLbHz/7t2xY2F2bGm4P0aBzApuw9hxUG/TLveKx5pQaEqWEcb8KZaQ7d8ff1y1y8uMXQnlEUdMYWBgBLm5c+o6zM/PRklJCYqLi9PueEnUoTBRiWyi0uCVKjlMdb10r01MDKuF57GsLBv19XUoLIy5STPtu3ilS9CX0mWwv78TgcCY+l6sqipAS0vLmmeFCYIgGBEBSxBWCQpIW5P9SxtsC/2gEq/4a9eTTz6JHTt2qMf5N91cf//3f69uS/mv3AOMjo7i0ksvVUGlFLLOo50AwMDAAE488UR84xvfwFlnnaXeJwgbkb6+PgwPBzA15UFLy8qFtq82KzXBMee5RCJRRCIuvPZaIY477sAMPolAZeWOoODDQ2+s0uF9TvSsYDmaFovsJqZ2ohNf993vWgejG9dpXG+izC5jXtD119uLJhSg9PqYD0Z3Dt08C1FrunQwdsv9pxBAAcVpWR8FKo6JX+Vm4SVRtpOV4MP36Q6KdJBo8YgTfJ4nGoC3bImdS7t9pqBEQUfnOvE9ZvHHXCJpJ+LwMf6WwzFYHQ86zygQcp95XBM5tpx2RuR/enXHQc3IiHVuF4/LwEDydfJ4X355bH94/F5+ebHLy4zVeSsvD2L79mF1TPLz3Uq4YqlgIrfQch1Pxs+Uvm6NDjKeS2OJbLLS4FS7kTpFi4lOHmfWFYPas7ODqiS4vLwQtbV1actrWqnv4pUsQU8Fn28SfX3tKCwMobU1Cw0Ndaitrd0w/y0VBGHjIAKWIGQY11xzjbpluaAWr8gJJ5yAyy67DN/61rdw44034hOf+MT8cz/60Y8wOTmJc845Z168IrTM/8d//Id6jCKWCFjCRmR6eho9Pf0qw6W2dsuGC5hdiQnO4jwXzmKz0d5e4jj03s4dYdVJjk4Vq7IlJxNeO9GJE2o6uIzr5Hasytt4bXDSz8k9/zaW1NFZxg6HevJPIevrXweuusp+vMZObtqhs5ANpSd8MfHK+BonGAUQLbxQrGCJo1GwoFBnhIKRleCjc6w0zM/i7x8UiIy/qTgp7dO5TnSDmd1kFLXofDOLOFa5T+axa2j00GVad9wR/7hVaSRFqAP/yVyUJZUM5npZ5XbxnCcqw7QS6OxcXmb4+JvfHMCddy5k85166hjq6rwoKSlGfn6Bo7Ev1/GkXZU0ZgcCi5+nmMZrKZnzUrOUbqROsCtVNZZhRiIhjIwMIhCYVJ//0lI3qqurlRC4Hr6LV7IE3al7eXCwG5OTQ0r4q6z0KtdVPuuKBUEQMpCN9a98QdgAGT4PPfSQ+vuCCy5Y9Dwfo4D161//Ok7Auvvuu23f8853vhNer1c5u1iKyL8FYaPAf3y3t7crx0RBQcWq5V6tJisxwVmc5xJzC51xhjuh24MOKz3hTUUnpDDF9xtFKLPYlGjCa5XDZSVscaJN95Q5hNromnrppQUhgrcUQcyT/2RlViyf48IJXyLe+MYonnpq8QkrKloowdOOqESh4XytVQYT87goBhkFI7ugdKNQZSxH1CR7n3EbPD7GUHc+x/dT+DCLOHa5T2b4emoOVtun6MbzZA6QNwulqXT+4zmwgtuyKs+kgMXzQUGQ58zssrJyeWmi0QgCgWn4fBOorw+jsrIBw8M5qK0N4+1vL0FeXmr/XV6q48ns3OL1YyVg6d/BnHb/XEo3Uidwf+jGs3qc5YIMuh8bG0RhYVR9P1RWlqGqqmrFOs8m+y5eaqfClSpBTwZdawxqz81l9iG/z6pVrMVyssIEQRBWGhGwBGGVoGtqZGRE/cNg586dKsdqC+sODLz66quYnZ1V/wBjtxczx/DnZUBlWhl58cUX4543wgD4ww47DH/84x/x2muv4YgjjkjzngnCyvOVr8QmB+aJwQUXTOGd7wxgetqDbduaUlrn8yOP49o9n8DHdn0DR1echEwm3ROcxXkuWaivj+Cv/irbsdvDrlOZGaMwZRShzCWAiSa8djlcFLZ06RrnrDffbL8OPbl3Ovm3C7tOFv5OYY9CS0VFECefHMC+fcWLSvooguhx8jrWIhZvKQDZCVZmuM9cF4XFq6+OPcbfKKyyu/S2uH6WWJqFHu0iYrkj32/u0GcuCdSh7kbBykrEsct9ssIsSBlFN372nTrEnHT+S1TOmaxTot8PfPObiV1fFFgCgRn4/T7Mzs6ojDSKZgUFWXjf+/z4zW/ceP/73cjLS/2f4sbr3ngt0ElIh6HZhaWFKwqJdl0kNVVVsfUnw6qMUbvU0uG+SuTsOuywGfT29jOuHbW1FD69qKurhde7tA6D6fouXumusemC1ybLLUdG+lBTM4eqKo+KuGDmmiAIQqYjErsgrBJf/vKX8f3vfx/f/e538dGPfhTbt2/Hl770pbjXdB742ddKvCIFBQUq+2psbAxTB36+Z+ngxIH6FLv36cc7nM4iBCHD4CSZQcnt7QsL7z/4oEtN2OrqmlP61T06F8XXXvow9kw8g6tfulzdTycU2ziJ5C/veuF9Pp4J6DwXI+ed57IUfyj4LActTGkRisLZJZcAxx0Xm5wSJxNe7QbhrXE/dKWQdlNZOUqM69eTYrvnjevmeCnUsNOc1Tq5Lu6fEZ7r5uYw3vGOYUxPj+Otb42vU6NwovOfuDBDi84ljom3FI6ciFeE+8rXch38mwvfbycuUmzg83QqWUEB6rLLYsIc3WU6atEu10kLVoniHbWzKxn6uJjR26boZhT9zNdqss5/3G+98L5dCP0JJ8QEs2Rj1esxH8tg0I+JiSEVhj01NYicnBnl6qqtdaOhoQyNjU047rgSfPGLrrhrORV0jpgRXgcUmik424nQycQrcuGFzpxTep08L3rhGCig8vOdDhOPdnYZOeWUEQwNdaC4eBZNTeyQV6vEl9UQr5w4W61IZ9fY5RIMzqKj41X4fL1oaZlDS0uZ6lgt4pUgCOsFcWAJwgrDjoD/+I//iDe96U2oq6tDV1eX6iRIQetzn/uc+kcDBS3i4yxEtTS3zx6giDU+Pq4ErKKiovn3JHof30O06JWMQ63qS1RmSBta7dKYBWEFueKKWFmVmdNPH0R+fjkKC1PLO3mo7xfYN/Wy+rtt6iU81HcHdtcvLsFdKuvhl3i6sLZsCaGz04O6uhD+6q8WOg+m6kQyo8sDzcLQX/4SEw5+8IPYfZa/0bG0fbv1hNdJWDVvk3VUo1OFVdf6vU7LnRIFu+v3mMsbOZ5zznGhu5sdvSJobp6Ex1Nim/tkLOtjeaOdy8jsuFkOZqeSnUuJYiMFGjqy6DgyPpcsb8q4zkT7ngyKRNw2rxvtmuI6zflVqXb+s3JgsaROi2CJyinNxzIUCqpyLLqtgLAKx6fo6fVmq//+FhYWIDfXm7YQdn39WTUxYMC5zmdz4pbkPnNfnYS1G7FzMjLYfKnCnBWxz9ccenqyUFMTwFFHDarvl8rKUlRWVmVU5uFqdI1dDmNjQyrvqqIiiurqbDQ3b0E5D6YgCMI6InO+9QVhg/JFzn4MsHzwqquuwhve8Aacfvrp+Ld/+zd88IMfRJ6xbZcgCHEwb4cTfHb60mzb5sehh06ipuawlI4W3VbXvx4f7HLD61/AKXXnwZWVHmPy4oypzPslHoji4ov78OMfV+F978uCy2UtYCXLg7ISWujiYTmTOfzZrhyRLrqlhlVbCWy8z/fpibtR+OF7zz57cabWUkukrMsbXSpE2u8fxcjIKE44IQ+PPZZjuY/aOcRtPfvsQomhGXNIOsdlPDZ8jL9n2JUPmrdnxC6nKlF2VbK8KafZV8mg+GUuZ0x0DM1CnFXOGF17VsH6vJb09cpyyp/8JHGpocs1h7vvjuCeexjYz86BhTj2WJY1R5Rw9cADeXj00axFQhXvmztl6muO59iJqEUHI8VO4zXA65LCsdVnRpe2mmHnymOPdRbWvhrB7eZSN7oYzzzTh/vuq8Tf/M0AtmzJQ21tTUY4rlarU+FyCYdD6OvrQDA4geZmlokWKdcaIyYEQRDWGyJgCcIacdpppykRi9lUf/jDH1SHwMIDNQEzCWYg7LhG6L4i+j36fVY2cPN7kvGyUSVw4MwShJWGE4DPfz5eALrggl5UVtbA7bYWXpy4rzTpdmFZ/RLPH7q/9a3YkkrA70rB74Xm5mlcfjlLcRY6ni7XhcWyM4oJVuHPqYZPO3n9r3+9uByM9+nq2rPH+r12mVpOxDOrEimrsGt+FwcCfkQifuza1YdXXtmCoaHFLem1c4iCj51QYw5JZ0ma+bjY5UeZocil85vo1qHI5DTPLFnelBPnE43CyUQ2p/Ba4/oo7uljaCWamc8vrwGKXUaHFcVJijkalkXyM2slNGmi0Sz4fPH/lH7ssTK8+GLsPFMks3Kf2YX/87Xm7dl1FuQ+USg3OwkpjlkFn596auzaMfPMMzGBz0lY+2oEt2umpyeVYygrK6hEsVNOCSypu+BSg9UzqVPhchgfH1Guq+LiMBobs7BlS6M6joIgCOsVycAShDVkx47YpLHvgP1Ah7p3d3fbTjhZPlhWVjYvRnGSpP9BZ/c+/Xgzf3oThHXuwiItLX4ceeQ0KipqU17Pre3ftnz85zaPpytjitpyb2/8QkGIZYVrAb9PKCTk5ycXto15UAx5TkSiEiin+VOpvJ4TfHNpHe/TbZLovVaZWk6yv1hy9cMfxtwyGv7Nsi12JtPLJz6RhSef5IQ7B8XFURxzzHBCNxQFHysoMtENZAxJZ9aXWbDi/QTV5/PogHYKPbz+eOtU/NLosPlrrllY2JmNolCi7Cvep+iyVMOxOeaO4fF0++kMLrtjaHRRcQz8HjHnXJ18cnxnTe7LUoS2UChrPhPKrnSSGWPma9OukitRZ0Hj50Nf23afGWZbWVXbcZxWuVlOsNr+cpmZmUJPz36MjfWgrCyILVuysXVrtYovSFW8MpZzr9b3ru5UyOufTqy1cl9RPG9vfxWjo+1obAyjpSUPhx56iIhXgiCse0TAEoQ1hGHsxoyqgw46CLm5uRgaGkKPhdXhOdZGAIs6CR555JFxzxsJhUJ46aWX4PV6VfmiIKxXOBH4znciOPTQafz933eipqZ+Se2+T6g6Aw35LajP2zq/8P7xVaevyC/xhL/EH9CrF2EVEL5aE5zZWSA315maoPOg7IKKnUxirUKZk3UfTPZ6O6GJ4ob5vXTEMAuLYpNRgLKCvytY9QWgu8sclm0VaM37L73kQm1tNUpL3TjqKJ+akGtRii4cLUzZCT58HSMSzSHpdkIN3Vw6eF1D0aKuzvr1dHItBXbhM4aiWwWac7/MIhHH50QEtYNlc/oYWZVCJguMp0ikj7kxFJ63LPmlCPfIIxGVZfWXvwQtBaysLG3lMdUpJtimk/B/OgFTEXf1uI2NEXSzBKvPDK8Duo5SFckSYbX9ZFiJvbz/i18E0dvbjpERuoUC2LLFha1bK5VwVVFRsaTv+rUKVtedCnm72kSjUQwO9qCj4xUUFvrQ2srO14045JBDJKpCEIQNgZQQCsIaQZHq8QOp1McwDRf8VToPp5xyCu69917cdttt+Od//ue49zD8nZzNABcD73znO/HYY4+p5//2b/827rnf/OY3CAQCOOuss5SIJQjrmUMOGcZ3v9uNgQEvSkoqlrSOS3dcpZaVRv8Sz0kxJ2lWgcvEqkxtpWG2TCAwqwSsiorEApY5C4q3OgtKh7UbJ9yf/GTicGpz6Hky10ay1yfL4mHMiy6Ro/ikyw3tSrM0DFRP1A3QOOlPVOqYne1BfX0dcnKGcfbZw7jvvgq89a0sK2RmknuR4GMMcdfljma0UGMsgdPOIh5v4zroXHzySfv9cBpWrkPk6UCzcxaZywo5Tp0/xf24776Yc2spoe685nicKVpxHRQozcfG6hga9/Pyyxfe09a24MzSXQXJK68EcdhhQzj22Hz09FDh48W8UPp52mlZ6tpgqLgZc36ZDvU3fvbtwv95n6RakmdVvmr3meFY+M8Oc25Wqs4pq3w4uhKdhNDbleb+5jduPP44f5TgPmcjO9uFc87JWnaZX6YHq6eTqalxDAx0wesNqn2uqipFU1OTZF0JgrChEAeWIKwgv//973HXXXchYpoFtbe346//+q9VCc+73vUuNPJfkAf4OH+KBFSXwtdff33+8SeffBI//OEPUVpain8w/YuOXQ5ZSvjLX/4Sd9xxx/zjg4OD+Jd/+Rf19ydoOxCEdQxFF17TLJ+qqKhBFmfqGY7xl3iW8FiRyNG0UgSDQYTDc5iby4LHk2PriuDjZncRjz+/0nj4Dz88voRIB0ibnUhGtxInqHSj0RFCMYlfTcbtEeN4+Dxzm+y6FSZyaXGh42YprhM7Z5fVpD9ZqWN2ths1NbV4wxvycPnlvWhoGMPAQDd8vnF1XVs5iKwcRsncTXzcah12eVUnnLB4PVawcotCGPfxxBPtX2MeL8ejP6YUduiAo1BkVbJIoSuRM4sV9rwGdBml2ZWWzIWls79iJY8MB9eJ5vGOquHhXPzlL+V461vdqK+nGhX/PfPHP9p3gzQHvvM6pGvMqszOyr2UrpI8O2eUzs0yjzFVc5Od49BJKeLC5yr+uIfDLoyM5GBoKAcDA9no7c1KS5mfVTl3JgSrpxN2wezubsPAQBtqayle5eCQQ7Yr95oEtQuCsNHYQF/fgpB5vPbaa0qookBFl9T73/9+nHjiicrK/cQTT6hQ9BtuuCHuPbt378ZHP/pRjIyM4KijjsK5556LM888EyeffDLC4TB+/OMfKxHLCNsg33TTTcpif8EFFygX17vf/W5Vkrh3714lijEkXhBWi8c7HsdxNxynbtMF898mJ4OYnXWjuHj9tf7mL/4snzLCCeZaOAEoqjMjisJKsgmpnZBD3aW/P36ibCcKmR9neR63T0HDagJsHg9fx9dbdSuk2HXrrQvlfrxlB0QthtERkmpplp0oZTfpd1oayfzC+vpa1NTkoKKCLrgxFbDM3B+W/mjBjds1lheaofvl/vvjhQm6kvi41Too6pjFIS1uJSu7o2jEzCZeuxSO6LKxer3ZLcax0H3oNEeKuVgU4exI1A3QiN5/lmga/1Ops79iSxYmJrQwFX8bCrnQ0VGCqqoKnHfe4hNAAdfcNMCqZFBfY4nK7Mw5bEspybPDLuMtHSKZ3XeCk1LEI4+cRW1tKO64V1aGV7TMz1zOvVHcV/zOGB7ux759LyMnZxytrVnYvr1W/dtyKXlhgiAI6wEpIRSEFeSNb3wjPvzhD6sug88884zKvGLeFYUpCkx8jmWDZr75zW+q13znO9/BAw88oH5Bo7D12c9+Fm9605sst3X++eerMkI6t5566inlsNi1axc+8pGP4OKLL5bzLKwa0bkoPnz3h/Hy0Mu4/J7L8eJlL8KVtfzfS+i+osOnrKxqyXkoa9WlSm/DPJm3chStFMb9jEa9CIValQOLk7lEJXCc4JpLBY3PG0uYKDKYy/lYenbzzbFFY9f1Tk+AU+lWaC5JojtMi2EUr+y6pbF7obkMyljuaPU+86TfWEplLK3kPtsJA/zOr6+vh8/nQ17emHICTU0NY2JiFPn5hWhsLMaHPpS4s6a5Y6EugePjHL92KRGOj/GILBc1wswqOpJITMyMlQcGAvGvo/OqsxO4666FY2U+f5wrm5vU2nUEtIPXIcU0XaqYatdDTTQaQW3tLN7//lm0t0fx298WY3LSYygFjN2+8Y0z+L//s25goK+zZN039fk2XhsXXRQTUI3dLa3K/Ozga5kqwJK8RKW4Synz0+tI1oEzGcnKdq0IBGYwMTGCQMCHM84owk9+YnSeu/GjH61cmZ+5nHsjuK9i5YLdyMmZVZ/3ysoi1QhIoiIEQdjoiIAlCCsInVbf+973lvTeSy65RC2p8OY3v1nlZwnCWvKLPb9Q4hV5afAl3PHKHbhg1wXLWmesA6cPk5P8hXmJCdBJulSZYflKugQsu22sZv5V/Bg4g8tRf1HoYaye3YSUk733vW9xhpfVhNVK9CksjHX+MmPMpjKvL5UJshOxyyoT6KtftT7+xmws4/voYOK+vP/9CxNguzwfCjqJJsksf2UnWf6gMTk5gcLCKczMMDx8EkNDk/B4vMjLK4DXm6cytMwwxL2jw5nI8+yz8WKXhjlU5sfZUIBipXYraZfWj39sL0Zph5Z5fw80yrXEnBVFpxTFKz5Owey//zsmqmnsyimj0bBqVBIKzR4oi51VTmUKcby+KIJceeUkrr++AYODseud4lVj4xz+4R+KVA6W2dVnVeb3s5/FShDN2VFW+VYcp1Oxyg6768oqt81OqOJ9uhfNUIhkcwAKWXYdOBOtV4toVqKw1TU/PT2lhKtw2K/ESV5ju3bN4dFHo9i/36XO0e7dsfeya99Klfnpcu71zuxsQOVcBYOTqglDeblHufzpxBcEQdgMiIAlCIIgpNV99YVH42dvvH/eIecty4VF9yIn1EVFZXC7E7tTUoWZMOxAtpJdquy2sdT8q6W4xhaPIeZE0aVfiSakzPGhg8rowrKbsJrFIvMkX0N3BUO9rdaXbDx227MTu7QQYXSdOBG+zO8zT/jt1nHuuU6FABdKS8tQUlIKv38GU1NT8Pn8qvEGF5ZO8nr3emNilseTq8QvuxB3K5GHApNTWGlOJ1V7e3xQup1gxjkz99Uqj8ouJ4pwfcZgeWMgO0sVKYgZg9hZWjg3F4LfH1R5PxSqeMtSWO4fxSouFBgpXnk8btXRl4vXm4t3v9ttEpqy1PsolpkddubrTHffpKBtvh55jVEQctKQIJkgZGQ5DkQNSyitoDBodCguVURL1FyBuW7Md6OrEAgqQZeCJuMPKLTwvFx1Vbwjyhi2vpHK/NIFr/Xh4T6Mjw+q8uOmpizU1dWgrq4urY5kQRCETEcELEEQBCFt/8C+5U+3zLuvNHRh/fcf/xvnH3K+Kof1eDwpB7BTwKIDoqKiLO1nazW6VFltg5P/b30rtqRaurgU19jiMWShpiaIN7wh5kxJNCHl/Oiyy4Cvfz3m3Ek0WTeLPgxs15N8Dd9PQY2TYT7OUiy+XpcZ8jicfPJCOZnxefOk36nYZS7jshK+uB1d7mjcjp2jJpl4RtGCi1XXPaOAwM9Dfn6BWsrLQ5ie9mFmxn+gU2QIs7PjGBsbV+VqFLGee64UPh+7yi7sJIPR2WGOYzZC8ee22xZvn4KCMcvJKIAZSxAJnTxm1xTvH3WUfZg63WAsPbQKa6dAQ/cTBTi9Xbqp6J6KRMJobg6joqIQIyNulJcHUVrao14bE6cANtQ1ilU5OR4livD7hbc6201DAdZKaOL5o9CjHYKJrmurz4eVMGonWFGAN7rKNFZCUjociBQB77zTvvzRSRODRCKa1b7zvwFTU2OYnByD2x1W33GFhS6V/VZeHv/jg9kRtRHL/NLF+PiIysrLzw/Pdxek64rXuiAIwmZDBCxBEATBMZyg+P1+zMzMqFu6RGIlPCFEohH85+//0/J91z51Lba7tsMDD9xZbiViMQuI3TO5JMrt4Lamp4MIBFwoKChO+9nSXapWsnzFahsUZ+h0SSRC2TmtzHlDTlxjVmM45ZQRuFx1888nysahyPCpTznLzjGLRVYCEx0w3N5//mcsd4nh2EZeeilWikcBi8KN8flHHlnsZtF5RE6Dqa2EL77fWHalQ+VTKaXi9j/5ydjr6aCyEq8SCQj8bNCVxYViDoUsfgYCAb/qHDk7O4uODhdmZuJPAAWsV18N441vnFVlhxQLKIzxWqGbyuiI4vhNzXHnuxhaQbHJHKLO+3zcrj+IDo43unjc7jmcey7dZUG87W1zeOSRfLz5zczymVGuHZ5DXhdcTjttBo88UoG3v30EdXU6oytHiVQxoYpieA6ydXp/Auyubd5eemnsc8Zjkig43W4ddvlWdg4mJ9cB89nMQfE8f3zcqdjFx4nZYUYSCcLJ1mv8bOl9D4dDGBkZVeJVXt6cKm0rLHSjrKxcua6cnKONVOaXLlh+SeFqbm5GHfvyci+amprUfzMFQRA2KyJgCYIgbGLYJfAT938C3zjtGzip+aS45zih5MSZZU3MoFKC1WwAswf+F0AAQQQRQghhhBFBBDtrdqJ3dnHg0a6GXejO6UY4FEbWXBY8QQ+8QS8KJgrA/+Xn5KvSkpqaGrhNNU90X3EyV1hYghfHnsC1ez6Bj+36Bo6uiB/vcliN8hXzNihSsYwmkQhl57Sia2UprjHjGBobAzj44HFEozXzJSjJwqZTCaM2Yufu4vr+8R+tJ9mc2FMEsnqO5WJWuVrUQVPp3pYspJtjYLe/VEqpWGaZTLioqHAmstFJxKwsLoQ5TxSwdu+exU9+4l0UTH7kkSOYmppR4hQFJpcrW53bN7+5APfeu+Be5HE1NhQoKJjDffdx4b0sJWqQY46JKiccHUwdHdmLtnf00X74fEHMzUXV98XcXASRCJ+LIhqdw7HH5uC++yrmt3PqqSx/mlGi3pYtFITG5gUrnjMKHW43Fw+2bHHjpJMoxpUqUY/fC6k6N51cu3z8P/5jeetIxcFkxE5s5bVlLsHkfSu3ViIHot31bRaEU12vMY9pcnIUMzMTylnHbRUW5qrvcnbBW8752sz4/dMYHOxBKDR1IJcuG/X1daiurpZjKgjCpkcELEEQhE2KVbfA2cAsJicn1cIuaYFoADOYgR9+JVhRuHLnuJGblwtvvhfF3mJ4cjxwe9xqOeTYQ/Av+Bc83/E8rr3/WnzstI/h6Oaj57f5XPtz6vHLT74cO8t2YmJyAn1TfcgN5qKsvwwDgwOoqa6JE7LGx8fV5CES/3UAAH1vSURBVK20rAQff+Fd2Df1Mq5+6XLcfHJ6uhuuVvmKeRtHHomknbcSZWc99FD8eymccIKZqATROIaamgCuu65ViRV6nplqpzOnJHJ3JXJ60H1m7vTG+01N1gIWnXOJgqmN6BIvBsnr0Gsj3A63kUopFUUZdvxLBkPxl3KNafcR3VIPPMBjpgUC5uGE8Za3zCEa9cQckUrEiqjlyCPH8eijRZiZcS8SobKy+J4IJiYW/5PwlVeC2LmzX5WClZU1YGxsIQi9oiKI5uZ+VRanryHuEz+2+v4xxwTw7LNFGBrKQXV1EG9+c0CNn59tLjFhKiZY8f5SsnxSyZZaTayua3M3T7tct0TXnN3+6nJbuxB6/ghgFequ12sFA+7150+7tm65ZQ7HHx/AiSf2IxQKqFJUbrOoKB8VFeUoLEyQ3r8KrEZX2ZWCLsuhoR74/RMHhKssVFdXoba2Vn1WBEEQBHFgCYIgbFrM3QKvve9anFh9InzwYRrTSriKZkdRUFSAvMI8FOcXK+HK7JCyEsa+dvfXsG9oH66+52rcfNnNSmji47zPx7/58DfV4xU1FYhGo5ienMZw3zBGZkYw3j+O4eFhtLa2qtLCmRmWHAFPTz2oxCvSNvUSHuq7A7vrl9fdcLXLV8zbSFa6mCif65Zb4tfNLnFcknVP1GO46CIvRke1ILFAsnDnpWLnXknk9GAZobnUjfeZJ+Q0I8iOZCVe3A63z4mv01KqL385cXi5dl/p8q6lYnXMLrjAjbq6WsP4QwiH6YiiGyqCD3zAj299qxBzcwuiF+H9oqI5+P1YJG6dfPLkfBj4aaeN4dZba+bXf8YZPjQ15anXZWe7lDMk5viiKOZStxSkLrlkDrfdFsX73peNlpZmpJtUOvatBEZBia42fldpN6C5co7iLT97yXLdEom6dt0zdfnl9u3WIfQUxKyErESfG+Pnb8G1lYWXXorizDMDKoeM7sCKigpVEp4JrEZX2XQTDM5iaKgXPt+o+n5obMxCVVWFCmin4CsIgiAsIA4sQRCEDV4KaIaC0fjEOD7z4GfiHr/uletQXVONouIi5PPX9OIKePPss6nseGjPQ0qkIm2DbXjolYewe9du28c5yS0qLVLL1PgUhnqHMOWfQui1ECrLKzE7C2S7c/Cjti/FbeeG17+AU+qW191wrZ0AyUoXE+VzXXgh8MILS++eeN55YezZYxQtnIU7rwR2JYaJnCjm8kI7N8tySrycdGh0sk5O9NmEgCYKhqOnw+GXKHSfMAeLi1FkoagSE6riec97PAcCvxfELa4zHK7Bt7/N0sDYY9qNQ7fPaaeVO9qPI46ILcvFznnEz40Vq3Ud2wloxhJNYy4V98Mq180ouCW65uyuMS000TVlRaJuinbn8e1vn8Orry4Imvq2ri6CL3xhpxIqdZlgpricVqOrbLpgJ012FpycHEFZ2ZwSHysry1BfX58wF1IQBGEzIwKWIAjCBiwFtBJ1WBY4MjKiSvJ+0/0bvDb+WtzzXVNd6M3txe7tu5c1lusfvT7usRsevQFvPfitlo+fcsgpcWOliFVQXIDe/b3oGO/AwKsD8E958XzgL/PuK81KuLBW2wmQrHSRIhgnvHRWsFSLt+xa2NERKw1aTvfEM8/04sc/DqCnx7tkF1O6SrvsSgyTBUknEnCSuWPy8xeXJxpZKJmKdURMti278fKcXXllbD3cN6cljslIFrrv1G3G/eTYOHk2jpvCRiz/a3GOUWlp6iLcUkr9jO+x6+LHsrzluvGWM3YnQigz63Q2G/fVLvPNiUDpJLdtOcKnFlampsZRXT2OmpotGBjQ3xFZaGmJYGamCP39WRnpclqNrrLLhd02KVyNjw+htHROja+iokQJV/n8YhIEQRBsycyfrQVBEIQllwLe8codypF13A3H4aG2h9DX14c///nPeOn1l/CX0b/gtehr+N+O/7Vc18+f+fmyjrzRZaWh2+pbD3zL8vHzvn2eyssyQkdWY2sjvNVe7A/vR3d3P34z/F+W27vp9S/josePw/MjjyPToBPACrMTQJf08dZKBGMOk56485b3OVHU7iwjqXRPzMlx433v88U9lqqLKRFaNGG5kl54X3f2M6PL8IwCj3aiWI1RCzicrNoFtxvHQAGLweZc+DcfsxOviHbI8P0spUq2LbvxUrBgB0fzvqUDq2NmBUUWO3TnRZafUtggWtiwe99SSvMSXQ8UiD7+8ZiIqxfeZ7dJ/R4r8YqUldl37EsXicauc6Ls4LH8+tcXzpEWkMyvMQtJdte31TWWaD1m7NbLEH52vevv70RPTxui0RHU10dw4YVjce//0IeyceGF1uHsmeByWu734kp38WWpYFvbnxGNDqK1dQ47dhTh0EMPwvbt20W8EgRBcIA4sARBENYxdDx94dH4YKEvPPIFhMIhvDr2Kj74yw/i+yd/H5NZk5jNnkVJeQkaKhpwyswpmHpuCnOqJCRGFrJwfOvxtgHsTrj16VstH//V87+yfLx7rHs+J+vFzhfjtlvbVIu9r+7FAIZxaM5xmMgfVpMsI8OzfRgNDqY91H2lnQBOg4aTlcMst3vimWfm4uabYy6sxsY5vOEN6esaliz83CmJHCPJusI5ccfoYG1ug+V1xpBt45iddqAzj5fndLmk4l6yei3RId92cB9LSuIdXckccOm6Huw6PSYTHXTXR6cd+5ZKsrEnEkLNonAqJal215ydC8upAG1cL91WPt+EclxlZ4dVKHtVFa+XApSVleHwwwuVGGj+jqFwSNFTY3SHZpILKxPcVyzbHx0dxMhIPwoKIti6lccvHw0NDSjmB1MQBEFwjAhYgiAI6xij+0rz0tBL83+3TbXh/vH78Y5j3oG9k3vxld9+RQlEl550qVqsBLELv3/hogB2jVncMt8/YfsJGJwcXCSMNZY3onu0G4FwAJP+SeS6c+Gb9c07sR7c8yB+9OiPFm23pKoEr7l78Pai9+CfjvgKCgtL5tf7YO9t+Nfn3pOx5YSJ8qucBg0nK4dZbvfE4uIifOhDvbjhhjKce64fLlc50kW6xI9USuWcjMEIx3PxxbEgba6b7iy6ZUKhpY95OeNNtQTw9tuBO+5YuE+nF51KdiHfduiOi8cdFy+YpCK22GEU1Mwlm/rY8jkrgYjnIxEcC9/7Wnw1dNozsBJdy3ZjN74m0frMr3EiVlp1F0zlOo1Ewspt5fONq06CBQXsSsqy2myUlpaqxRgebvUdQ7HTKGAZ3aFrLWCtRldZJ/AHl/HxYVUu6PWG0NzM8luvEq54jAVBEITUEQFLEARhHfPtp7+d9DV3vn4nLjjlAvz7Lf9uK0xp7ILWrboL/uxDP5u///m7Po/S/NJ5ccwKvv+c685BKBJSfxu57v7rMDA5ELfd9l/8DX5x/fmYDURxS5YH7iyPCsGmo+XvL43i+te/kPGh7nZOAKdBw4lEsHR1Tzz55CI0NraryXQwWICcnFykg3SIH5pE7ierCT+dVLzPOBk2AbCD4zn44Ph1M2R9uWN26tZySiInmVHkYSg/A+OtSFYuyTLJc89dWmZSIhLlb+ljm0xotHLMWWWhrVQGVqJr2WrsdDDxPLz//dbXTiKR02lXRWN3QSdiKV1AMzNTmJ6ehN/vA5sGUoTibVFRAUpKSpQbSIeyG7H6juH30lVXZWYZ4Wp1lU0kXE1MjGJ4uBdud1BdH2VluaqrYHl5ueUxFgRBEJyROf/KFwRBEFL6B/Lw8DCOLjoadfl1qM6rRlVeFQo8BYtea86g4v2bHrvJcQC7FpvM4ta3H/j2/P3e8V7s6d2jhC2jOEWH1kU3XKRuH3z5QfRNxFpkRaLxs2ktXhm3++RvizHUXYTJ4RKMDuVjcNCjJon8hf+hvl/YhrpnEtoJsGtXTITSE0wtbBmxK3UxvnYlymEKC4tQWlqggrk54TKXaS4HY95PukWFRPlE09MLOVfGfCQKoMnGsxpjThWr3CQreOrMeVBmKFpYYedYcpI1lgi7HC0KUfrYJsp1MsLzcdll8WNJlJOWLiiSMuheu9h4S9ceH7faPjuEUlxKlE1ml19md7zszs9f/hI75z/4QXx+GMfGz/LMjE/lLnV2vobJyV7k5fnQ1AQ0N3uxbVsNDjpoO7Zs2aIErFSEld27gbq6+McyoVxvLaFIODY2hLa2lzE21o7a2iB27PDg4IO34NBDD0VFRYWIV4IgCMtEHFiCIAjr7B/IFK4GBgbwWN9juKf7HnzgmA/gTbvehOLKYpzydevZwx3Pxgs7Nz1+Ey456RK4Xe6kAex0Q7FboFncsgp8N7q2zI4tlg46het5zzkP4MUnLljUwp2/8N/abu08+3n7tzOqjNDOCeDEWbWa5TB0BszM7MPMTAATEyMoLa1My3pXopxuKTlXmrPPjomJicZjHjPzf1LtnpdOtMNMd1A0jsE4Jo47WckdBaAvfQn4zGdScywtx1Fm5VCikPjhDy8cf72PibpCspMfOyXecENsvynY6OPgtEukcVupnE+KpBRDzcH3XBeD5oke+3JFz2Slt+bxT0zEl7xqnn8+iKOP7oDLFVZuMK4zP9+NkpJS5bTKzY05LZ3m8ZnhufvoR519h60FS92vpXYVZEdB5lzl5oZRW8tSQTdqa2tRVVWlGpMIgiAI6UEELEEQhHVArHvREAYHBzEeGsfgHIPLr0b3VDd+9urP0NDagC99/0sIhBZmuWX5ZcjLyUMgGMDoTHwydTASxLcf/LYq+UsWwP7zp3+utCOzuMVSQCvonqLgZXZsWVGaV4qZ4Iwaj5m/lH4F9a270dums0KysHVrGKec4kZn2xkYDHTHuYXoHji+6nSsF1IJGtYiGCdl//Zv6Z+UeTwe1NbWIBjsQ2/vEDyeXBQUFKVFBEh3OZ3TCT/FHGbyGB/j2DiXtBqP1T798Iex+0bxQuMkJHwpYonVdqxKyuikGh+Pd+jwtYnK8OgUYth2uko7l1p+RxcVSzedlBnqc/eVrwBf/ar163SXSCdCqdMSPSciKYUj47Xh9S7NpZZK6a39sYoX+k86aRA1NWHk5blQUlKM4uISyy53TvP41kNYerr2yykMwB8ZGcDExDAKCqLYsoW5gjmoqalBZWWlCFeCIAgrgAhYgiAIGQx/2aVoxWUiMoFhDCOcE8ZLvpeUeEXahtrwLz//F0z4J+LeW15YrrKuPvSTD2G0c3Frtduevg3PtT+Hj5/+8UUB7LPhWeWYKskrUZ0J7cQtK4yh7MkoKyjD35zwN/jlc79cFPx+3LY3YPBv7sOvvnTh/OPvf/8UXK4yXLrjKrWsZ5birFrJSRlDhQMBPyKRcQwMdCM7uxle7+IJ71JFgJXCbsJP0SgVkcZun+rrrV/vJCQ8HcfJTjxhvhIFNoZnU5RirhodSsZ9pmuJx4FjMLp4KPrproR0DlH4YUnccpxlicQ6Ot8SOaSSueh47uiE64tVIC+Cj2tHFm8T7Yfdtih28nNo9V6nGV10ICUqG3SK+fzw3OjzQ6HIWrjS5X9ZaGwMKFG7rKwRhYWFCcvWnObxZXJYerr3KxmBwIwSrny+MZSUzKGlhd+f+Uq4YudGybgSBEFYOUTAEgRByEBCoZAqE6Trajw6roSrOe8cKmorUFRWhKt+EC/emMUrYzkfhamOkQ6MTi92Yb3S98p8qLvuTKg7EY74RlCSX4JLTrxEvV6LW/xf/3h/nOBk5oZHbsD+4f1J95NCmV1HxJmZGVz4/N8AVYcBQ4ehrmkKb3wjOxeW4fmRx3Htnk/gY7u+gaMrTsJ6JdWg4ZWclJGamlolmkYiPgwMdKGubqtlqLudCJDOzm+pYBc0nkr4uN0+nXcecOedSwsJT8dxsnOYsWMgs49uvTV2XVDEMh8HupZef32xM4m3dHBRIGHZ28jI8kXIZGJdorJMqw6F3B+Kc1rAsSuVozbD/bDbrhk7MYrHUueHmd9rJZLqMHlNOvPSzOfH6PIqLY2gtnYO/f36n/BZKCsLYWzMM/+ayy/3YMuWRkfbStbpNJPD0ldyv6zw+SYxOjqAQGBSnX92biwvL1bCFcsyBUEQhJUng34rEQRBEILBIDo7O/Hnl/6MVwdexevR1zGcN4zKbZXYtmsbSitK8fArDy8q57OD5X8Uh5ormm1fo4WuRJ0IuY5ffvSX+NVHf4WP7v6orXiVk52DhtKGuFJG8/P1pfVq4evOPcai7dkBHnv9MfROdwNnfRiofxpHXXgzXK65WLbWSx/GnolncPVLly/qaLiRSSX8fSnQOVBf34DKSi/KyqIYGOhUZTJOQsXXMvDcKmg81fBxu33i40sNCU/HcUoUUk6B7Ec/Wgj+ttpnu7BwO5FqqSJksvBx4zjMwfsU0MzZVxwfS/K0gGMlXpEjj0xtP5wExlu91xzu/773xT+f7jLMhfMzF3f7hjf04Ywz+uNe+0//NItt2+bmvw927z6QNu8AncdnJJOyrJZKuvZLdxTcv/8V9Pe/jqKiSezYkYWdO8tx+OGHYMeOHSJeCYIgrCLiwBIEQcgQx1Vvby/uf+1+fOPlb+DCXRfi8C2Ho6auBoUlhXGvdVrOR5GI5X+Et3/u/jPC0bBtbhUzs755/zcXubl0ppUry2XZqZCUF5Qjz5OHc445R4ldDIm3KgvUzyeD27npiQOdEpv/D/jgG/FCzla4st8Z14FQdx7MtOD2lSKV8PelBhkzcLixsQnhcDvm5nhd7kdVVT3y84sc5/SsBRRGjjlmIbfKuL/s1JastCvRPtk5vJKRruPkZPvmEr5kpXTJwsJTJZX12TnTtKuJ7+M1yi53xmNnhi6tK64APve51PbDOFbt9Er2XnO4/44dwF13pX5NOG3WsWvXNGprvejv186qLDQ0BPCOd/hUWeAjj0TQ3p6tBKt3vasQzc1LL+VbjSyr1QxVT8d+8RyMjw8rx1V2dhAVFXTFuVBVVakcVzk5OSszaEEQBCEhImAJgiCsIfxHMvOtevt6MRwZxhf//EWVbfXT136KW99+qxKNzKiSwOGORcHsZt52yNvmxSI6sOzEK+20+uydn1Vlgok6C1p1KiSebA/uvPLO+fHalQU6xWo7fcF2PDl+H37We23c4ze8/gWcUnee5bHaiKQyKVtqZpbb7cbWrc1wu3uQk+PH4GA3iosrUVZWNf+apYo6K8lyM6fs9mk53RSXepzMghQdSBRbeM6tOiPaldjZ7Xu6RchU1mcndl10EXDLLQvHOFn2FMUP6gip7ofxfB51FHDHHc7ea25IkM4Om5FIGDMzPszMTMHvn0ZOzhzOPLMIN920UAr4gQ/M4eCDdyqR+dOfjhesllPKtxpZVqsRqp6O/WIJ9djYIMbGhuD1hpWIWlLiRnV1teooyO9GQRAEYe2Qb2FBEIQ1Ynx8HN3d3RidHcUABvDU2FPzwez7R/bPi0ZmKAw9ufdJy2B2I7f+4VZcsfsKuF1uR64tK/FKc+NjN6qx2K1nYHLAdrxLwW47P+36Ojpm4q0bm9GF5XRStpzMLLfbg+ZmBrn3w+MZx+DgMILBACor6/Cb37iVgBIMxkQVZgd98pNLDwBPF8vNnEokVCXqppis2+BShA47Ma6/P7Yk6tpnDjjndWI1LitxLdm+LCesPZnYdcgh8cc4UfaU7iq5VJFQn092q6SIshQhdjkdNlmaNjvrV2KV3+9Tny2WTLJRYGUlyyc92LXLg4cfjmL/fpcSLs88M2/++kl39tRKZ1mtdH7fcvcrGJxVbquJiREUFsY6CpaU5Cq3VUVFhXQUFARByBBEwBIEQVhl/H4/urq6MDI1gkEMwu/xo6K+Anf94S7Lsr7rHrgOHzvtY6pToMbYMZCw7G96djru/XRcfeuBb6kugye0noD+iX5EIhEMTQ+pyZMu6yvOLYYv6ENkbiGERpcLarpHu9He0Y6j6o9SYhW3y+1HohHLUsPlwv0bmBjAwNSA2oYL2SjPrsZs1Dpb6+ft394QApbTMhunk7LlBhkzE6u2tg5ebx48nn4MDfnQ29uOF1/chqEhV5z7h7Ck6pFHFsa92oJWOsriliJKJHN+OV2nURyanbV+DcU4Pp+oBE9Dd1KigHMrwS7ZvqQS1p5IrEsmOuljQYFJB7zz9vDDga6uxaH0S3VDLee9qRIOh5TLioIVO9llZ0eRl8dg9ljeV15eLoqKitTi5QMArroqM7v8ZUKoejpgMPv4+BB8vnF1HjjG0tICJVyxM6t0FBQEQcgs1vF/CgVBENYXLE1gQPtLe15C21Qb9mXtQ25dLloPa8VzA88tKplj6d7n7vwc9vTuUZ0CjYLS0VuOVh0Cv3DuF1Swuh2/+OMv0NHRgTdVvwlfPv3LeNfh75oXr4gSwDg5NIhXxByM7g/5cdH/XoT/fvq/8fZtb8fFx10cJ15ZhcEvB7rMrnz7lfPbiCKCv635JM5r/iAa8ltQn7d1fuH946tOx0ZAl9n09i4svE+HyFoGGXMix5LCujoPSktDOPbYvgPPxIf5M0tIB3NT5KCosZokCjxfSZIFmDvFGG6uO+IZ0UKPXTi8OVjcThwwjssYrk7RiI6tRO9JJaw9EclC9vWxMAa885buM6v1O92uFct5b7IScZYEjoz0o6trL3p69sLv70deng8NDVE0N2dj69YitLbWYufO7di2bZsqU9PilVGs5u16JpPC4vnf4pGRAezd+5IKZs/LG1eZZgcdVIJDD92Jgw8+GGVlZSJeCYIgZCDiwBIEQVhhKBgNDQ2pkPaRyAiGMIS8sjxsa9iGnNxYEGyi0jxzDhXFpc/f9Xn0jvfi3+76N5U9dVjDYXhm/zOLO/LNAW3TbQhmBRF1RXHHnw1hLweYmIkPbbdjJjijbv/nhf9BZX6l5Wu++MsvoqKgIs4tthSswuLvHLsetx29B5fuuAoblZUos0lXQDNdWFu3bkVubh9OPXUSDz9cgYGBhYl2OjvaLYe1yOZKVyC6XQmklRhnVYLH7RmDxXk9UQhyOi6+1sqxRSeXfk+ifU1WfmgmkTNtueWga8VCWeA0Zmdn1LGjy6qqSrus8lBYWICCgkIlVCVy+KQSfL4WIempshph8Ymg+43ZVlNTYygsnFP5VsXF2SgvL1fCIc+NIAiCkNmIA0sQBGEFmZycxJ49e/Ba12toi7RhNG8U9Tvr0bitcV680iVzDaUNqnMgl7qSOpVdZYQles+2P4vzvn2eEq9Iz3gP7nvxPnz+9M/jI2/6yKLtz0Zm8arvVdRtq8NAeACjPuvcrGxXNipKKlBZWgl3duLfNuiKGvGPxL8/K3te5DK7xZzyfMfzuOiGi9StVYh7h/9VlXW1kdETPCPLnejpzKxdu2LdC5fjeGCAcVNTE7Ztq8f73jcW91xZWfw5X6tg92TOnkx2flk5q3RmtPl4Gl+rnzPvO9+byrjs3FWnnhpfrmdeJ0WvT3wiJmBpB9lynXh2LrNMaBZgzk6iIDI42IOOjtcwONiOcHgIxcUzaGoCmps92LatFNu3N2Lnzp1KBK6sjIklycrTUnFkptu9uRKk87vIKSybHx0dRFvby+jtfRW5uaPYvn0OO3fmY9euZhxxxBHYsmWLiFeCIAjrhKw5Yy2JIAhCAg499FB1+/LLL2fMcQqFQqqddTAYhMej242vPbOzsyqgfXh8WAW0T7unUVVfhdJKZ5kaD778IP719n9d9HhNcc28K8soPl1x8hX42bM/w9DU4nCag5oPwmcu+Qw+9d1PoXc4JnxZccW7r8Bxu47Djb++EY8+9+h8vtZSuPrdV6cU6E7B69xvnauEOQp5VcVVeKHzhUWvO6b8ZFz/pkexkXnwwdjkTnP11cDu9GTjp5VwOIr3vjeKjg436usDOOmkYdx660LHtCuuAI47DpsGZjUxr0i7n77ylaVN0Ck4GJ1V558fc+Uxn8lc4kaHks5usit/S2VcxtdqKILdcMOCkGZ+HR1GDPNPxFKvBfOxWOtriv9kZtg686tii58SiXJWxdxVQG5u1rzDqqCgQP33KV3fBYm+E1J5bSaTLicZHXDj48OYmBhFQUEUZWV0W7nm3Vb5TMsXNjWZ+G9aQRCSIyWEgiAIaf61t7+/H30DfRiZG8FI1ghKqkrQWt+KbCYQJ4Huo2vvvxahSMjyebN4pbYZjeDHT/94keuJwlZ5cTmOaD1CPeeb8SXc9v1P3483HPIGvN71uhKv+P48b17S91mRaqD7g3sejHOVHdpwqBKymFUSDUeBCEU/D46vyvD6oQ1QZuMUt9uFz3zGhWuvjeKii3yorp7Co48G0N/vRV1dCEccwesxF5uFdIWBm0sgCfOwfvAD67I8qxI8cylfKBQToLZvTzwuq65/FA6M4pV5X486CrgjgTFyOa6ptSgHNWdYsSSQpYAUq2LB63Pz3QIpiuTmxsprKVZxceKsWongc6vXMtT/W9+KLZlaVmjnJLMSM5ONmedrcnJUlQmGwzMqlJ3Hq7g4T4lWFK+c/HdYEARByFxEwBIEQUgTExMTKjB9JBTrLphTnIOtTVuR63U2iafI9LW7v6ZK58oLylUpITv9sZugLtEzh60nyrGisHXh2y9Urqo/vPwHTM4sDrfR3QYpVh2+7XA8s+cZ9Az1zL+/OL84oYDlcrkwF51b5NYyZnY52e/r7r8u7rEXu17EL6/8Jdr+3Iat4a1AkCUxuaiq2o6Nji6zWQ+dx2IB0xxgJQKBQnzkIxO48cY5nHXWAAYG/MjJyUdxcTny8wtXLBA51dyllWQp3QatxmwUwm67LXHXPyvsOgXaBbQnEo3M2zCP/bHHFroEWrGcEP3V7BBIIpHwvFBF0YpuKxp7KVgVFcVyrDwel3LvUKi6/fZi3HMPnb9ZKyIQ6eBzo7PKLvjc6rXFxUB7+9LEoPWUA8hzxk6CdFvl5UVQWcnzlYXy8jIlXBUWFq7omAVBEITVQwQsQRCEZUKXUFdXFwZGB9CPfszmzqK2qRaFJan9o9mY+zQ6PYq/eePf4H//8L8Jhatk0FVFAeuBpx+wfF67tihW1VbU4s5H74x73uf3weP2IBQO2f7ibcdNj92Enz7xU3zstI8tCnXXTjM+N+QbWuQs4/3fPPMbHO05GsXeYpTUlGB6elBlmRQWlmCjozuPrScYSH3GGV6ceCKDkrNVLtL09AzGx2cwMuJGUVEpiotLkZ2d3lJfO7EmkcCz1iQbs1EIW0qY+XIC0JOJRnZjN0Lnz+hoelxTTkXBpZUDziqRKhikaOVHKDSrSiIpWNG9Q3dVbq5bCVZatDJ2CHz22VjW1EoKRKk4Ms2v5RhY6pnOphArjVPXWcxtNaaEq2BwGiUlQEsLhSv+0FGFiooKldknCIIgbCwy+HddQRCEzGdsbEzlJ+wb3Qf+L7c2F9t2bVPilTGUXGN+TN9nOLu5697Pn/l5yuMpyi9SbiqiXVXk8NbD4x5naaG+r/npvT+dd19pJqcncdlfX4aPXLA4ID4RHpcHw75h7OndsyjUXTvN9HPXPxK/35of//7HKEPsF/Tq6mqUlWVhdnZSdZISMhe6HRj0vnPndmzdWoEtW7JRUxNGODyM7u69GBjoUvk06cIueDyTu9WlMualhJkvNwBdi0ZWuVp2Y9cN3LQbi9qBzwf8+tfICEKhIHy+CYyMDKC3tx0dHa9iYGA/Zmb6kJ09joqKWWzZAmzdmqNC11tb67BzZyt27NiBhoYGlJWVxYlX2i1kRToFolSCz82vZfZVuptCrDTaSWbE6DqbnQ1gYKAbr7/+J4yPt6OsbBo7d2bh4IPLcNhhO3HYYYehpqZGxCtBEIQNivw0IQiCsETXVWdnJwbHBtGHPoS8IWzZugV5BXmLygEp0tx82c3qceNjP/vQz+bvf+7Ozy1yIbF0cCkC1tTM1Lyrqq6yTv1NdxXv68fpyrrvqfsWiVVW/PYPv8V0CoIDuye+7ZC34f6X77csJzQ6zfhcaX6p5XqC4SBKXCXzv6RXVVVgbGwYQ0O9aG7e6Xg8wtrApgoUHilAshsnxV6fzw+fz4fhYYqQdLYUIS+vEHl5BfjVr7KWVApoLHnL5G51Sx2zVS5VsrK8pbxnuWPnuerqiolXEwcqmsfH18YJR7GKziqKHfqWYesxRxWUW4dalNudpUQpOqu0wyoV104qGVWr5cg0v9ZpCWImYXaSnXxyWH1/sERwdtanzt/WrXRb5cy7rTKpiYsgCIKwcoiAJQiCkCKjo6OqZHAoPITBrEGU15ajqa4pLuPHLNJQwGFMlPGxbz3wrfn7VuHsqcI8qqnpmHilueWBW3DMwccsKg186NmHrNeR5VLrKcgrUKWDWchSbq3XOl9zPA4Kb8ywsgp1J2anGbdZX1JvjJFBOBTG2Y1no7amdn5CWVdXh+HhEYyMTGF6egoFBUWOxySsHfxclJSUqCUQCGB8nBPRSfj9YUxPj6mJ6dCQC88+uxVDQ4vz4pIJICsp1qwUqY55KWHmKxGArvOvAtSDDLCk0K7Z3ko64eLLAGNCFcsAgagSqjgmZldVVMT+plgVW/KUWMUOgcvJZkslo2qtWC9NIYzw+H3qU1Fccw0bRPRj375BFBTMqdJUxlmVlZUo4aq4uHjFsvUEQRCEzEQELEEQhBRdVwNjA8p1FcmLoHlrM7z58WUldF+ZRRqrMrnbnrkt6TbzvflqmQnMqCURzASZ8scLWEPjQ7j1gVsXlQYGQ/Z978ORsHJyXfSOi5QAZn6vE8yCnJWIp2He19XvvhoVBRUqF+sDx38AjcFGbM/erkpBNJxsVlVVqg5Tg4Pd2Lr1YJm8rDMoHtTW1qG6ugbT09PKjTU1NYXZ2Qje9rYh7N/Ptnu0YGXN3zoRQNa6W91SMI6ZZXfMnLr5Zmvn2VLCzFciAN0u/2p2NraYSde50EJVOBw8IFjNKqGK97lfWqyiM4d/ezx0VuUaBCsvcnO9K/J9kekCUaY1hbjxRuBXv1rstGTw/aWXzqkS8YmJERQWjuMrX4moc0oRsrg4X3UR5CJuK0EQhM1L1hz/VSAIguCAQw89VN0y8ylTCIVCStgIBoMr+o9alkC1t7djKDSEgawB5bqqrKu0nBA9+PKD+NfbDT/JL4Mr3n2FKvf7n/v+R5XyLYUcd44qx0sVOq9GJ0dRXFCMSCSCmdkZNZEk3G/+z5htlQy+p6G0Ad1j3YueO3rL0ZjwTyhxq6m4Cf910n/hkMZDUFtbu+h88/pra4ugsLAelQdKJIX1jd/vx+SkD5ddVoKurgUrT01NAFdc0a3Ku3Jz85QIkZNjLUQwtFyLNVbZTZkIx/yf/7nY0US4D5/5DDIKhpMbXWPJYBc8ozMrWUkoRXgKU7ESwNn5vylUUeTjVzwXrlP/za6AublmsSo3JbEqkajiJIydXfO0QMQSvo3Oco4XHWpWXQYPO2wWn/70q3C5Qkq04rVTWJgzL1rRMScIG/3ftIIgJEccWIIgCAnghKq7uxt9Q/Rc9SHoDaK5ZbHrysjNTx2wUaQBBqv/+v9+jc6BziWvQ4tMLNUrKiiKObUO5GQlguKVzsZiiDvLELUbi5PDAm8BXHBhOjDtKK+L4lffeB/qS+vjHqcQVl1Ujec7Y7OarskuPDf0HN5yzFsWrYMi5ZYtW+D378f+/X2qI6HXm+/wSAiZCienXP7pn+LLsd7znmHU1oYQCEzA759Q2UqRSJYSsShosRSMt263Z8W61a0kHPM//qO1KJSJIfRW+VdGdHA8n6fIxE6UVi6us84KKUdrTKQKKqEq5rAKqfB3vpe3+fkLf8eEqpwDImYOfv7zQtx7L9WxrCWJTkaeesp6n5J1EzQLOZ///NLHsJ5Y6vHSwfcxASveaXnWWd1obAyhsDBbBeYz14oNIQRBEATBiAhYgiAINrDESbmuAkNKvCquLlbdqJgRZQU7CrIEbjYcX0tTkFOg3kMBx+v2IhgJYjIwOS/ezKl/wFsz4ZtQy3JgSaAWsgrzClW+1VRncgHLLKQZQ961CFZeWI7Td52OP3b8Edm0SAAYnhpW+2hFZC6iAt4/dtrHFtY1F8WF378w7nU37r0RHztj4TVG+Gt8dfUYpqfHVTexlpZDpJRwg2Aux/qbv6nD7GwJ/P6AcmlxCYWiCAT8mJ2lawsIBikauJWwEXNpxbKNsrPXR6jzegqht8ruMnLeebEyvp/9bA65uRH85S/uRUJFTs4Eurp6lXsqJkwBBQVAaal2VGWr88cSwJyc3Pm/KVIaee45oLfXWlQiqQhIC6JKat0ElyPkrGeWerzo5D3mmDE0NRWhq0vn3WWhtdWPf/iHLFRWtqqsPMm1EgRBEOwQAUsQBMHKKdTXh57+HvTP9WPaM436rfUoLC6ME6oowhzdfPSiroNmKObcdN5NmI5OY3huGF+/++sL20ogXq0EdFDlehYHZSfDrkPhqG8UT+9/Gp89+7N400FvUo/d9PhN+OVzv1T7xuPSP9Ef957bnr4NV+y+QnUrNAfea14ZfQV3vHIHLth1geV2m5ubD+Qn+TEw0IXa2i0p75OQeZjzeihmeDxFKCxcCOyfnZ1VQhZFLApbDO4OBOjm8akOZdPTLDWlqOWCx5MDjyd3/pYiCP+2E6Gdhpin2ikx2fvWUwh9THCbQ09PFurrI4hG59Df70ZtbRB1dd2IRIIqy+jGG5sP/DNTO6Rit7OzbtVBzuNxq3NhdFWx9M9pF0A7EYWCphaQnJa6tbfHxLSwwUjK+3x8JYSc9U4q3Rf531Mff4iZGIXPN478/Dn8/d+X4otfbJ1/zVe/moPt27et0ugFQRCE9YwIWIIgCKaMpX379mHQN4he9CKvPA/btmybdxcZhaqr77kaN192syrNsxJh5tcZCeHDd34Y7zv5fZjLmcPEzPIcVctlVnXpSh9D00O4+r6rUfJoCT5++sdx6UmXqoVc89tr8L9P/e8iQe/bD3573oV169O3Wq73209/21bA4iSXIlYg0Ib29iGMjnpRXl6d1v0S1gZmCP30p/bPU+TgApTOuwHZ3VA7tPg3P8fhcFR1pguFAkqY8PtjAkUkQhGDwpgHbjeFrRwlbPEznp3tVovLlW0pctmFmCfrlJjsfWsdQk+RIRqNqLK+SCSs/uYt7+u/6Z6JPRfGGWfk4be/rcHZZw+obKpf/aoGF1wwgKqqWeWi4mPnnDOB665bXN47OJiPT30q1oBhOaV2FEvY42FgwF5AcuqQ4n2jeEV4/+mnYyWeicbgVMjZSDjpvqjD2Ccnx5CTEwtjZ6RhUVEe3vjGAtx+exR79rhw2GHABRfE/vsqCIIgCMkQAUsQBOEAdPRQvOoP9WMkewQ1W2pQUl4Sd3yMQpXurHfKIacs6jpoxjfrw70v3KvyolYSTgrXojdH73ivWoyiHvnl87+0fD0dWlrAOn7b8egZ7oFrzgVPtgfZ7mxVWnl66+kJt1laWoqtWxsRiXSjo6NLCRFFRTFRQ1h7lhuM7RQKTQx55xLftY5B4EHl2Ir9zVsKWxRqIgiFeEuBi5PtmLAVjS7ccr0UsmKiVuz2TW/Kx6uvliwqi9u9mwJPzPVlJXy9/e2xwHa7nKvldgzUAhRvKTTNzUWVsBe7jbmk5uYWbiOR6CJhiueGwpN50YKUXji2rVv9OPXULuTkUAT04Mwzp+DxlMDjqVTCIJeDDnLh17+OF3fI+HgWxseXX2rHcXz0o8BVV8U/bhSQnDqk7F5HBxavY7sxOhFyNku579vexg6C00qwotMKCCrRim67wkKPKv1mrpUOY//BD4BPfAL4xjc2x/ESBEEQ0oMIWIIgCHQRDQ2ho6sDPXM9mPXOorm1GbnehVI7XTY4Nj0Wd7xuePQG5cqyc18Z6R5a3H0v3ax1Y1mKejc+diMef+1xJVAd1nAY/tj+x0WvO7Qh1v2HnLn1TJxReAZava3YtWtXSvknNTU1ynETDg+ju3s/mpsPklD3DGEt84F4DWmnVlHRQvkhoWAT63IXUsIW3VpctJATcx3FnF10cUUioXlh64gjxlFbm4v+ft3EIUt1Sqyp2Y+urgWxTnXpVItL3dbXu1BT04iBgYWWfAynb2rqn3cQMQPqwx+OraCvbw6/+10xnnmmcJEA+IY3TOGUU8bV+GIiFQWr2HNcKAZw0YIU4a1+zkqU0sIUhTq6G/Vt/N/Gx9yOPqdmcSfdpXa7dwPXXRfvwtICEoUnlm6aSwPLyxc7pHjf613cDXJ0NPn1ahZyNrr7SsNj/KlPRXHttVFccskw2toG4HKFVfdAugkZxs4fGXQYu/l6OemkmMNNEARBEFJBBCxBEDY1nAB2dnaib6QP3ehGTlkOWra2xLkoEuVbUbD51gPfWuVRZzbMwGLZpNmNZcXk2CSmh6fRghZVEriU8F52JYwJEZPo7HwdW7bsEBErA0hHPtBKuLhibqpYB0M7KGbFyukoai2U1vH27/5uGl//+kIX0ve+d0QJGHqMFLsoJMdcUdH5x885ZxDXX984/76zzhpAYaFP7Y/eLyNtbVUYHV0cRN/enovKytlFwlRMwMo64Bxzqf3kfeOtfk4/bxSmnIpSqWAUdyia0e2mSYfYw/3+4heBK69ktlb8OimgWoW80xVkdPzoa0yLfaler+bcto3uJuLngZlWU1PjKCiYwJe+FAU1Yi75+THRiktxcfGSs+YEQRAEwQ4RsARB2LSwtIglgwMzA+jL6kNFQwUqaioWvS5RvpXuuleRV4ER/8gKj3h9QPFKi3vnffs8fP6cz8+H3ce9LhhCX0cfGtGIhtqGJbdM56R727ZtCIdfY/IKOjtfQ1PTDuTlFSx7XzYKq1XOl+58oLVyccVELmtF493vBn7xiwXHzd/+LTuTNhgEK6N4RZdU7P62bVHcf38E7e3Z2Lo1gne/m91JCwzCVewPLSKxlJDijLlcsbExB5/97EGGEdHpFcvSYie3TMIo7tBx88Mfpr/U7thjYwH4ZgHJTkDldp1cY6lcr8ly29Y74XBICVZcZmamkJc3pwQrZpAVFOTMi1ZWTitBEARBSCciYAmCsCmZnJyM5V1F+jHmHkPDtgYUFC0WPOi+SpZvFY6GkZebB/ix6WBWVaJOit1j3ZZOLE7oe/b3oCxShuqCatTX1y9rHBQbdu7cCZdrL1wunxKxGhu3o6Agvnxss7IWQlA68oEyscubneNGu5wS8elP6/dlo6KiLOFrzzoL+J//oVC20MWPggpdWX19a1OauRS0uENn2gMPrEypnZWAZCWg8muGZYdOrrHNlGdlBTPjYqLVGAKBafD3BZYH8hgWFnrnRauCAvmhQBAEQVg9RMASBGHT0dfXh87eTtVlMFoQRcu2FnhyFpfqOHFfabrHuzM+aH0loHhVXlAOr8cLf9CPsZn4jDBj2P3uXQszx6HeIcAH1GbXoqWlJS2/2lM82LFjB1yuNrhck+jufh319dsk2H0NhaBE+UBOXGGZ2uVtqY6bVN5nJwCSF17ILFHPCatdamd1/FhqaN6u1TVG+NhaX2erTSAwg+uvD+O++7wHctVK4XJxofNwEv/6rxElWnkZGCYIgiAIa8Am/V1JEITNCLM72trasK93H9rRjpyqHDQf1GwrXpFbn7417ePYKOKVZmvlVvzqo79St3bosHvim/RhvH8cDWjA1uatKmg7XTBzZfv27WhsLEVT0xz6+towPGxhV9lk6Em6kdUQgrRosWtXTEgwigfaFcacIr3wPp1EZhFis7pijOdNn6+1OpfpQAt4vF2r42fG6hprbIxdtyt9nVHEZeknRVu98D4fXw3436Lp6Sn093dh794/o6vrFTz7bBYGB3MwNJSLwUE2LMhFb28unn++CrW1tSJeCYIgCGuKOLAEQdgU+P1+JV4NzA5gIGsANVtqUFpZmvR9J2w/AYOTg8ppNBWYUosAeFweVBVXqRLC41uPjztWM8GZRU4s7cI6adtJ6N3Xi3r+r6oeZWWJy6iWk4nl8XTB4xlCd3cv/P5p1Ne3JC3x2qiko5xvqdi5jpy6wuxcXGuR65UprqVE53IzHBcr7Pb7r/4q1mEwkevLfI3dfPPqfDbSVdpr3PepKWBmJvZ4fn4sXN14/vlDDnOsdBB7dnZYvYadAwsKXPjQh6Zx5ZVFhuy1GFdckY49FgRBEITlIQKWIAgbnrGxMexv34++aB98OT40tzbDm++sBOLSky5VC7uP/fz/fo5rHr1m0Wso4vD/G81ZlYhTdp2Cr5z/Fctj9YEffwBjnYtLCW/9w61omWtBRaQCNQU1aGpqWrHxUcRid0Lms7jdHejrm8D+/a+gsbE1Yfe5jUyicr61Ho/Galx2Is5aBbyvNsnynczHbLMcFzN2+82g8WRlm2vVSTBdpb12+04xiwv5v/8L4tRT96s8K693TmVaNTdTtHKjpKRkvnPgkUe6VNj+yy8viFeHHQacd17KuycIgiAIaUcELEEQNiwqKLynBz0DPehGN1zFLmxt2apaxjvl+Y7ncc191+Ddh74bNz19k+Vrjtt1HE59w6n46k+/is3C0NSQI9eakUPKDkFeIA91OXVobW1dlW5VFRUVyMvLQ25uGwYGZtHR8RdUVzeirKwKm421mqSnwxVmJeJkYsB7JpzLjX5c7JxWhx5q/Xqn+70WnQTTlfGWKIheO6ne+c4ulJf7wMz1/PzcedHKqnPg5z8ff9x4f62/LwRBEASBZM1tJsuAIAjL4tADM4SXX345Y45kKBRCTk4OgsEgPJ6FLCt+te3fvx+9Y71KvCqpLUFVfVVKogkzm97znfegfbQdpXmlGPeP2762wFuA6cA0NgN0nF32tsvwDyc7t3MMdA/AP+BHi6sFBx90MPJZ27KK0EHH62FwcFJlLWVnF6Gurhk5OenL3xJSh53pLrxwaaVbxvdqVrP8K1NJx3HJ5DJEipxWYg0FqImJ9Xc9PPhgvIh79dWLOyUmIxyO4sIL59Debl0ivX27H/fc04vS0mLlskqWO8hr6Igj+N/6mPvqxRcz+xgKwkb5N60gCMmR/xwJgrDhiEaj2Lt3L7rGutCZ1YnqlmpUN1Q7Eq/ouLrohovwbPuz+MXvf6HEK5JIvCKbRbwidFY1VzY7fv348DimBqbQiEa0bG1ZdfGK0HXHcPcdO5rQ2upCfv4U9u/fg7ExeyeZsPIkCnl38t6VDnhf65DtpZCO4+IkYH+toNvI7vGl7Pdan2MnQfNWBAJ+jIwMoLPzdezd+yLOOy/23yorvvpVL3bsaEVVVZWjphk8Zt//fiw/7HvfE/FKEARByBykhFAQhA0FnTYUr3qne9Hv6kdDawMKiwsdO66+dvfXsG9oH75015cQmYus+HjXK+wqeMohp8CVlXh2yI6DA50DaEYzttRvWZHQdqdQwKyurlalMwUF7Sgq8qG3txOTk2Oord2C3FxpDb8WLKd0a6VzvdZrntRyj0smlyEmK7tLdb/X+hw7Le3lf9umpyfnFyCkygFLSoD6erpJpvGb3wTx2ms5OPTQOczNZWHPnpiD6vzzUy/XPukk4Omnl79/giAIgpBORMASBGHDwDLC119/HX2BPgy5h7Bl+xbkFTgP7H5oz0NKvCLdE90rONL1j+4quHuXfa2Lf9qPnrYeNMw1oL68HnV1dcgE6EA46KCDUFY2iLy8HgwNTaG9fQ9KSqpQWVmXUkaasLFzvVZLyEl3yd5yj0u6spnWIjst1f1ejXOc7Pxaibgsg2f3VC1YMXw9L4+h60B5OXOsXCq/ioI8ywK9Xi9+9CPgE58AvvGNmGAV+1scVIIgCMLGQTKwBEHYEBlYk5OTaG9vR0+wBxM5E2ja0YRcb25qeVfffQ/aR+zLMIR4jmk+Btdfcr3lYQn4A+h8tRO1kVo0Fjeq8r3VCG1PldnZWXR3d2N4eByDg+zYla1ErPJyZyWnwsZmtXK27HKdjjkGuN76I7bq2UynnRbLRMqEXKzlZKclWtdKnWMn55eC1eysHzMzPszMTGF6egpud0QJVuwYyMrrgoI8JVZxoXjlkmAqQdhQ/6YVBCE58jOzIAgbgldffRUDWQOY9k6jeUczPDkLge5O+O7937UUr4rzi5VANu2fhn/Wj82KO9utwtuL84qR685Vfx/ferzla4OzQXS93oXqSDXqC+tXrePgUt1YHF919RSKi7sxOjqDgYFulY1VXd2A4uK1K3kU1p5UOiUuh0ws2TOXIVLgXetySqOTaXYWYN8OBrf/+MdLH8NqnGO783vOOX4lnlO0otsqOzuiXFYUrGpqgLw897xgxcXYqEQQBEEQNiMiYAmCsK6h84p0RjoxVzKH5u3NKZeAjYyO4H+f/l/L54LhIK58z5UY843hu7d/F5uNbFc28j35bD2IqcCUEq/uuvIu2+yrcCiMztc6UR4qR11enXJerQeXQFFREQ4++GCMjo6iqKgHo6OzGBzch+HhPFRU1CohK1NFuPVKJne6W82cLfM2MqVkz1yGODICvPDC2opsVnlVw8PLF9FW+hzH1j+HffsWvkMaG/046KA9CIdjOVassPZ6s5WzigsFq7VoeCEIgiAImYwIWIIgrFvGxsbw+t7X1d+Rogi27tyaslgyNDSEXz//a4SiobjH6TBit71AMIB//59/V06szchXzv+K6up41S+uUvd7x3vx4J4Hcdqhp1mGDHe81oHiYDHqc+uxY8cOZGdbt3XPRChQVVRUqKD5/v5+lJYOYmyMnb72Y2ioF5WVtSgpqRAhK00C1FqHZ2dKztZqOr1SxZjNxFK7tRbZVsqpthLnOBQKHnBWsSTQh3e+Mxff/nbr/POXX96LQw7xzAtWFNGZYyVCuSAIgiDYIwKWIAjrEgpP+zr3oQMd6n7T9ibH4tXzHc/j2vuvxUXHXoQKbwVue+m2Ra+heKUJhUMYnRrFZuT6R66Hb9YX99h191+nwtuNLiyKXN17u1EQKECDpwE7d+5ct+UuvI7q6+tRU1ODwcFBtYyPz2J4uAPDw30oL69BaWnlunCWrSTLFaBWs2xuuWLbcjolZpLTa72LbCvpVFvuOZ6dDcyLVcywikSCqhyQJiqWA77//X7ce28Ae/d6ccghYfzzPzciL895TqMgCIIgCCJgCYKwDunr60NHbwc60QlvpVc95vRXa4a1f+3ur6lug9+e/jbefMibMTQ1lPR9DNjdiOR4cpRAZ7d/uiujkYHJgTgXFt/btbcLnmkPGt2NSrxibth6h+4xdk6kkEXBdGBgAOPjQYyMdClHFt1YZWVVyM2NXYObjeUKUKtZNrce3F6r4fRarvDHW1Zos+xtLUS2TBDR9HdeIDAT57ACwkqs4sIugbm5DF3Pn3dXFRQU4KabPAc6A7pVvpUgCIIgCKkh//UUBGFd0dXVha7BLvB/JXUlKKtKLWT7wZcfnBdleiZ6cO+L92IzU+gthCfLo0SpVLjhkRuUgEXnVc++HrimXGh0xboNsgxmI0GnFUWsqqoqjIyMKCFramoWY2OD6OgYRE5OoepaWFRUuqnKf5YrQK2mGJGJIelr5fRKh/BHkYbnbS1EtrVwqoXDISVYMWhdB6673VF1HBi4XlXFwHWXEql0SSD/NpdQn3QS8PTTKz9eQRAEQdioiIAlCMK6obu7G52D9F11orKpEuXV5So03GnJ4JVvvxLf/933456b8k9hs1KYV4im0ia82PXi/GMsCzSKMBSojOWUmtnwLCKRiHJeZfuy0ZjViB3bd6hJ20aFQhZFLC5sHkBX1ujoOCYnfRgd9WFgwKNcWVw2gysrHQLUaokRmRiSvh6wE/4+97mY2JYpTrV0NgTg9xoFKgpWgUDsNhwOgro8l7IyoKGBDquFwHU6rBi4vloC9le+Ettn8/5yXz/96VUZgiAIgiCsCSJgCYKwLmCodtdAzHlV3VyN0srShGLVx077GI5uPjquZPAzt38Gw9PDqz72TKXAU4Ch8fjyyZaqFtx82c3z+VY3PX4TfvncL+NELAbcn33k2arbYO5MLhqzG7G9dbuaxG0WdFv7pqYghoeH1TI1FcL4eD86Ovrh8eSjuLhcdS/0eNZ/OeVKCVCrVTaXKaVn641MFf7MTrWllohSoI8JVTF3FZdweFaV/zG/iu6qyspYOWBenlcJ9NpllccXrBG//S2wf//ix++/XwQsQRAEYWMjApYgCBkPnS4dPbHMq/LGclvxyihWXX3P1UqIeWjPQ/MlgyJexWNVNtg22IaHXnlIhbSTS0+6VC1GgrNBdL7eifyZfDS4G1S3wc3a7p1ZXwx8Z1bW+Pi4KjGcmJiEzzeD8fEZDA11Iy+vCCUl5SgqKltXXRlXS4BarbK5TA9Jz0TWi/DnpESUzqrZWf+8YMUlGAzA45lTYhUXZlfFnFa56juNYhVvuWTSZ/eKK4DHH7d+XBAEQRA2MiJgCYKQ0YyOjs53G2TmVWegEx+74WPzDisjRrGKQszv9vwONzx6wxqNfP3y86d/Pi9gmQn4A+h6vQtloTI05MbEq1zaEzY5LB0qKytTSzgcxtjYmLp2WV44NTWFiYkp9Pd3Ij+/CIWFJWrJydkYxy3TcpvWU0j6emA9CH9WTrGWlgiOOGII3d0zSrgKhQJgbwldClhaGnNWeb0eJVD96Ec1uOWWggNlgFkZXZZ3/vnAoYcCL7+88NhhhwHnnbeWoxIEQRCElUcELEEQMpaJiQnsa9+HbnSjoKoAFXUV+Kfv/1Ocw8rovrr+0evj3v/1e7+O0enRNRj5+oBlggW5BSjyFsWVBx7ferzl62d8M+je243qSDXq8uqUeOXxeFZxxOsDt9s9n5UVDAaVkMVlasqP6elJTE0xP6sLbrd3XszKzy/cVAHwK02iTKT1ILZlEpks/LEbYCgUVALVhRfO4atfXWjq8dd/3Y5IZByM5auo0GJVzryjiiWAvNUdU3//e6CjY32U5fEcfP7z8Q4z3s+kcyMIgiAIK4EIWIIgZCQ+nw9t+9rQOdcJT7kHtVtq4zoI6lK3t+54q7r/8J6H55/TiHiVGIp+nz7707Zuq7jzMeFD775e1EXrUFdYp7oNZlJJTabCyXFtba1aAoGAEmW5TE35MDMTgM8XUF0NQ6FsFBQUHxC0iuF2izC4HJaaiSRkpsuOQlUwOKuEKpb9zc4G5v92ueaUOHX88cDWrbvQ3p6H1lY/Lr7Yj8LCsnnBigvF5Y1Slmd0YYn7ShAEQdgsiIAlCELGMTMzg9f3vo6uaBdcJS7Ub623dFixPPDk7Serv2975rY1Gu365tY/3JpUwBofGcdgxyAa5hpQX1KPbdu2qY58Qmp4vV611NTUqDwedjLUgpbfH4bPN4apqTH099Mtkq/ErLw8hkUXpFUsTGfHtkzFSSaSkHlQqKI4FROp/PNCVSg0i+zsOVUCSLGKkXvsBsj7OTmu+c/WN7/pxxe/mINvfCMHRxxx2IYuy+NX8Pe/D3ziE8A3viHuK0EQBGFzIAKWIAgZxezsLF5//XV0R7oRLgxjy7YtqrTqdy//bpHDii6sh195WP39xu1vxODMIAYnBxGOhtdo9OuP6uLqhM+PDIxgpHsEW7AFDRUNaG5ullK3NEBBSmdmkenp6XkxiwHwFHF5OzTEzwTg8XiVkKWX3Ny8JZ+HzeBOytTuecJC9z+zk0oLV6xK1kIVuwAyWJ1/ezwuVfanxSr9N12O+rPQ0gKcc87mKcs76STg6afXehSCIAiCsHqIgCUIQsbA8GuKVz3hHszmz2LL9i3zTp9bn77V8j23P3O7uv37E/8eLdUt+NfbDe2yhKQMTQ3ZPjfYM4jJ/klsxVY01TShsbFRjugKwW5nXNjRMBQKHSgznFLClt8/q8oP/f4ApqdHMDLCzwpdJ/lxopbHE8vyScZmcCetl+55m+E7ne4ps6uKj1GoojClhSqdU+XxZMcJVEahaqWRsjxBEARByGxEwBIEIWNKR/bt24f+2X5M5U5h646tcWVTJ2w/Qbmr5jCH2fAsJv2TKMkrwXGtx+F5PG9ZYrjZyHZlI9+bj6mZKUevL88vtwxs57no7+yHf9ivxKvmhmaV4SSsDgzGr6ysVIsWAShkGZfZ2Qj8fp9axsaAvj6KMx4lZHm9C6KWVannZnEnrYfueesdlsIyRJ2CFG+ZUxUOx255f24uMi9UUX8qLl74OyfHbSlUrWVjCCnLEwRBEITMRgQsQRAygq6uLvRP9WPQNYjm1uZFYbuXnnSpWihUXfj9CzHiG0FJfgkufvPF+CF+aBnivtnIz81HeUG5YwFra9VWdUzNE9Le/b2ITETQjGZsa942L6QIawM/CyUlJWrR0JFlFLT8fj/8/hACgXH4/eOYnASCQYoEFAXYac2L3Fy6WLjk4oMfzNrw7qRM7p63nkr9zAKV8X40Gga/qnXZH2/z8hbux57zxAlU+u9EgepriZTlCYIgCELmkpn/ehAEYVMxNDSEnqEe8H8N2xrgzfPavvahPQ/FdSLUGVg/f/rn2OxM+adwcOXB8Bf6Me4fRzASXPSanOwcVBZVIgtZi9xXAX8A3W3dyJ/NR2NWI7Zv247S0tJV3APBKVoIqGDd1QGhgblZRlErEAgiEPCrhWLW9HRM1IpEstDcnIstW3agszMHW7eGccIJdM7kZqyosF6752U6dFtaOae0QBUOhxYJVCz3ixeo3Kq8Lzc31/JWGj4IgiAIgpAuNta/VAVBWHcw56e9qx1d6EJ5QzkKSwptX2tVJnjj4zeqWwo33ZPdCEQCmA5MY7PiD/tx98fvxo//78f45XO/VCWXGopW5xxzziLXFZkcm0Rfex+qo9WoyalBa2urajsvrA8oEhQWFqpFwywt7c6iY0svoVAsQPtjH9uP73+/ERdf3I3+fh9CIXYjzFYOLY+H4kPu/N/M1+Ky1OB4YXVFqUgkrEpPKUBxid2P/1vfslJbi1G8LShY+JtCldudnVCgSmeHTEEQBEEQhESIgCUIwpp2HGxra0PPXA+85V5U1iYuVTO6rzT7BmP337b9bSioLMB/P/7f2KyU5pXi5ENOViKDLrl0MtlVYe0Dk6rTYE1xDVpaWjacE2czwtItOujMLrpgkM6sAHbuDOC880YQCGQhEPAowSsUiiAYnEEoNDPv2qKwxb+j0Sy43Tlwuz0HFjeys93qb+Nt7G+5flZGlAo5EqaoM/IUGBfqTNSkeRv/nCuhQCXnUhAEQRCETEH+hSkIwtqGtkf6ESmIoKG5Iel77DoRksG5Qdz5zJ0IhUPYrGyr3qZEq+c7nse191+Lj532MRzdfLTt68OhMHr292Buag4taEFjbaPqgicum40NRQkuxUzUNsAyRIrKFLh4a17CYZab8ZYLSxEZMA/4/Yi7z1v6/RbErHiBy0r82uhlZsyWi0a5RONu+fjcXNTi+dhzRlGKh2ix+LTgnjI+x9fyGFPE1LeJ/hYEQRAEQVgPiIAlCMKa0N3djcGZQYy5x9CyrcXRBFZ3IowiiqHJIYSjYbiyXOr+Y3sfw5hvDJuR0vxSFOQUqEwrlll+7e6vKafa1fdcjZsvu1kdIzP+ab/KuyoKFaHOVYdtLdsk72qTw88gw7W5WEFhiwudWnQBmW/13zHhZe6A8MLFHydwBQILQpdeSFaWS40h9l2QNf+3fpzC6sLfix+zepy3FMtJ7Nb4t/2ts9fN2QpQxsd5S0cUF4pM+pa7aV60EKVfY3RP8Xk7Ecr8GBcRogVBEARB2GiIgCUIwqozPj6O3sFe8H/1W+vhyXHmANBlcQ++/CD+9fZYCzUKNuShPz/EOW8czHwyZkBtVCoKK+aFKh4bY8j9Q688hN27dse9fmxoDINdg6idq0WNN5Z3xUBwQXDi3HIWDB4valkJXfo2Gp1DNMr3RdUS+5uOsNhC9N/6cd4a/zY/pu8Tc2yXvm936/R1vNXCEz8+iYQpLhSUKK4xM4qLk7+NwhTviyglCIIgCMJmRgQsQRBWFU5YOzo6lHhVUlOSMLTdaZC7epwzVlOW8HoQr5SD7IAIp/HmeBFki3rT43ZooeqUQ05ZdGxuePQG9bjaTjSK/s5+zIzMoBnNqCurQ3Nzs4QwC2mFIotTsYvE3EvR+YUCmPG+3WNOXmscU6q3Tl6TSIAyP7bRyyQFQRAEQRBWGhGwBGEDwW5jX/va13DLLbegs7MT5eXlOOOMM/ClL30JDQ3JM6ZWg/b2dgyEBxDJj6C6oTrl91sFua9nrESqQDCQ8np+/vTPVdWT+dhocest29+iSgbdM26Vd7WlYQtqa2uXNXZBSAda5BEEQRAEQRCERIiAJQgbBHYVO+WUU/DUU0+hrq4O55xzjhKLfvzjH+M3v/mNenzbtm1rOsahoSGVYTXsGsbWlq1LKodJFOS+2XC73KgqroILLpV/ZXdsbv79zdgS2oLycDlq3bXqOigqKlr18QqCIAiCIAiCICwVEbAEYYPw5S9/WYlUJ5xwAu6//34UFsZK86655hp84hOfwKWXXopHHnlkTUsHu3u60Yc+VDVUIdebu6T1MMi9f6IffRN92OwwxP5dR70LH3jLB+Yfo0BoLJ2MRqI4qPAg1IfrUZ1frfKunJZ2CYIgCIIgCIIgZApZcwstdwRBWKewM1h1dTUmJibw3HPP4eijj457/sgjj8Sf/vQn/PGPf8Sxxx675O0ceuih6vbll19O+b379u3D3rG9mCqYQvNBzSm7r57veB7X3n8tPnbax/Bax2v4+sNfjz3BDmZfAvBZ1iJh0+H1ePHY/3tsUafBUDCE3vZeRKeiaEAD6ivr0dTUJDk8giAIgiBsepbzb1pBENYOcWAJwgbgiSeeUOIV3TVm8YpccMEFSsD69a9/vSwBazldBwfHBjGcNaxCw1MVr5gT9bW7v6byna6++2pVLrkZKPIWqYXdFBvLG9E92q3cVf6gH2MzY+o1gVBgUafBidEJFdZeFilDjasGW5q2oLKycg33RBAEQRAEQRAEYXmIgCUIG4AXX3xR3R5zzDGWz+vHKWKtNuww1tXVhX70o6ymDN48b8rruPHRG+fDyduG2uKf3MAe0k+f/ek4YUqLeRd+/8J5AcvYaZDlghSuAmMBNKEJVQVV2Lp1K7ze1I+5IAiCIAiCIAhCJiE9nQVhA8COg6SxsdHyef14R0cHVpv+/n4MB4cxmzuLyrrKJeU83fR/N9m/IPUc+HWD6izooAsjOw3e8+w92L9nP7LHsrEtaxu212/HQQcdJOKVIAiCIAiCIAgbAnFgCcIGwOfzqdv8/HzL5wsKCtTt1NRUSrkAZtra2lQHOwaypxLc3jvXi9rmWuUQ4pIK37z/myrPKc5xRdGKu8yH87CQhbUO8Lg9CEfCyHHnoCCnQHUQDIQDqqyy0BsL3icsG/yr5r9COBSOe/8tv7/Fcl9v/r+b8Z0TvoPK3ErluuI5D4fj3ysIgiAIgiAAjIFeSjdsQRDWFhGwBEFIiVdeeSUzu9h9FeuCkFLdgNkD/zMyhXiB8YcH/ueEV/Eq3o63p3GkgiAIgiAIG5ddu3at9RAEQUgREbAEYQNQWBhz7szMzFg+Pz09rW6Lioocrc+uIwudWfzFSmduJWJ2dhYvvfwS9mIv6nfUo6Ao5gJLhd+9/Dt8+o5PWz6X/WQ2Iq0RoOKAeHXVgS6E2qGVYeTn5sPr9uKtW9+Ki064CJVVlXC7l/YVHI1GMdgziMmhSdSgBpWeShWOX1xcnPZxC4IgCIIgbDTYoVsQhPWHCFiCsAHYsmWLuu3u7rZ8Xj9OkWO50G7t8XiSvq6npweT7kkUFBegpLxkSdu6/fnbY6KUBRFXBKgzlA7ydTavzQRK80tx/YXXo6KywtHxs2N6ahp9HX3wznqx070TtZW1KuMsOzuDd14QBEEQBCGDkPJBQVifiIAlCBvoV6TnnnvO8nn9+BFHHLEq4wkGgxgaGcIIRrClISauLYUTtp+AwclB1XlvaGpIBbrPcxwyinxvPkLhkFqsCEQCqK6thivLteRujkM9Q8p1VYtaVOaI60oQBEEQBEEQhM2DdCEUhA3Am9/8ZpSUlKiQ9RdeeGHR87fffru6Pfvss1dlPMPDw5jEJHKLcuHN9y55PZeedCl++dFf4qNv/2i8eDV3QH7n7TLIdmXj0xd/Gu8+5d2oKq1CZWklCvMWgtRTYSYwYytekdHpUdz02E246IaL8HzH8ymt2zfhUx0Gw0NhbMM2tFa1qtwGKRkUBEEQBEEQBGGzIAKWIGwAGKr+kY98RP39T//0T/OZV+Saa67Bn/70J7zlLW/Bscceu+JjYUYWBawxjKGsqiwt67z16VvjH9AZV8vMuopEI/j+nd/HWSeehWs+eg2+ceU3kONZuYD6nzzxE+zp3YOr77laucqSMRuYRdfeLvTv7UdNsAatua3YtXOXKhmVkkFBEARBEARBEDYTUkIoCBuEz3zmM3jwwQfx+9//Hjt27MBJJ52Ejo4O/OEPf0BVVRVuuummVRnH+Pg4pkJTCHvCKCp1FhrvpJRwYHJAlRManVhZyMLcMm1Yo5Oj+P++/f/hg+d8EOO+cXU/FUrzSjEVmEJkTodxLcBywYLcAhR5ixAIBZQLi7QNtuGhVx7C7l27bcsFh/uGMT44jvK5cjRmNaK2uhb19fVwueR3B0EQBEEQBEEQNh8yExKEDYLX68XDDz+Mz372s8jPz8ddd92lBKxLLrlEZWBt27ZtVcah3VclFSVpC8hkKeGVu6+MLyNUFYTLrCE8wODYIH5yz09w/x/uT/m9b2l9i6V4RVqqWvC7f/kd7rryLhXibuSGR29Y5MKie218eBxtL7UhNBDCtrlt2F6yHYftOkwFtYt4JQiCIAiCIAjCZkUcWIKwgcjLy8MXv/hFtawFdA5NTE6o/KuWypZlr49ZUdfef63KwLr+0euxknQPdqPAW4DSwlJMzUyp8kI6qJKV+t33l/tsn9NOK+ps+4b2WT6nXVgzvhkMdA0AM0AjGlHuLVeiFbPNBEEQBEEQBEEQNjsiYAmCkDampqbghx9urxs5ucvLkqJw9LW7v6aEn8/d+TlVQrjSTAemUZJfosQrPQYz2VnZcY4rilz1pfUYnhpGMBJc9PqfP/1z5ayygs+9ZftbMNA9gJmxGVSjGhXZFapUkGWf0uJZEARBEARBEAQhhghYgiCkjcnJSUxjGgXFBcte10N7Hpp3La2GeKWZmJlI+Ly5XNAf8uPzb/88Okc68cvnfhlX1siMruNbj1d/M7/LXPJ4eNXh2PfyPpRGS9GKVtRWxXKu3G75ahYEQRAEQRAEQTAisyRBENIuYFUUVSxrPXQ+mUsGs13ZyM/JV4HpmQadVNdfcr3K6rLD+NzE6ASGeoaQG8xFTbRGHS+WCzK7TBAEQRAEQRAEQViMCFiCIKSFcDiMwGwA/F9+UX7a3FcalvWdddRZuPmpmx2tQ5XfzR24PUCeJw/vOvRdeO/R78Udf74D9796v+oOOO4fT2l8LCOsLqlWDiujyyoZgZkA+rv6EfFFUItalOfEcq7KyspS2r4gCIIgCIIgCMJmQwQsQRDSQjAYRAghuNwuZGdnL2tdtz59q+Xjtz9zu+N1MHeqsawRnz/n8ziy6UglZBnFrCubrsSVZ16JD/z4A3i+83nLdZTmlaqMq9GZ0UVlhAyW1wHsyZgNzGK4bxi+UR+qUIUKVwXqautQU1MjnQUFQRAEQRAEQRAc4HLyIkEQhGSEQpSvQvDkeJbdebBnrAcVBRVwu+I19lAklNK6use6cfU9VzOMyjYQ/YTtJ6ChtAF1JXVKrDKS68lFU0WT5ftu/YO1yGZ2XHW3daP95XbkjOaonKvt5dtx+GGHo66uTsQrQRAEQRAEQRAEh4iAJQhC2hxYYYSXJWDpzoODU4NwZ7sRjoYdv9flcqmcLC5ej3f+8bbBNjz0ykO27zt6y9Gq8yDLE81dBxkeb9dBsLq42nadM74ZdL7eic5XOuEd92I7tmNH6Q4cfsjhaGlpgcezPJFPEARBEARBEARhsyElhIIgpIVIJIIoonBlu1a082BOdg4KcgswNjMW9/jvP/17uD1uJUJd+P0L4zK0bnj0BpxyyCmLHFZaMONrXx943XJ7r/a/avn40NTQosd8kz5VKhjyhVCBCjRlNaGirEK5rbzeBVFNEARBEARBEARBSA0RsDYJDz/8ML7zne/gqaeewtDQEAoKClBdXY0jjjgCb3nLW/B3f/d3KCkpQSaxdetWdHR02DpghMzC7XYjG9mIhCNp7TxIpxOD0glv33X0u/Dbl/7/9u4DPqoqe+D4CamUkABJBKLEhQgCIlKkSEcBgaUjfsRC8SMoovgHrAgBREUFFcuq6yJgWQvBoKiLyorSFFCUoCgovXdIAkkI+P6fc903ZjKThmTmZfL7+hknvDKZ3Nx5ee+8c8/91COAZWdPeSsAb2dh5a1ZlXvb/IYnhoWESUylGLG0Ivz/5C3cnn483QSuzp46KzESI9FB0RJTLUaqV68u4eHh59QeAAAAAIA/EcAqA6ZOnSpJSUnm6/r160vLli3NEKZNmzbJ+++/L8nJydK8eXNp1apoM6mdL1qTKCEhQbZv3+7T74uSoX3qrwSw8pt58O5r7pYuDbu4li35aYnHdmrpz0ulW+NuMnvZbK+v/96a99wCWN4CZlpzKzYy1lUvSwNVfZr2keHthnu8ngZWTxw9IUf2HxEr0/ojcFUuWmJjYk3gimGCAAAAAHD+EMAKcN99951MnjzZXEy/99570rdvX7f1+/fvlzfffFOio6P99h4ROBlY+l/O6eIVWi9s5sF/fvlPtwBWQTMUdrm8ixw5ecQjGJU3Yyq/gJnW3BrTteDZBU3g6sgJObz/sARnB5tZBaODoyU2NtbMKqjtAAAAAAA4v7jSCnCaYaUX3IMGDfIIXinNFBk/frxf3hsCi9Z4Kl+uvEjOH7PvRVQoXs0nnQ1Q614dTDvoVrz9ROYJky1l16/S7XQbe0ifddaSfbJPWtRpYYJSR08eLVIwKr9AWN5MLZsG5jRwdezQMQnNCZXqUl2iQ6JN0EqDV8HBwcX6eQEAAAAARccshAFO610pvcAujl27dsnIkSPNED+t4aP1svr37y9r16712PbLL780WS5Dhw71+lq6XNfrdmru3LmuIVpa48pkyPzv0bFjR6+v8a9//cvU6ypfvrwJuul7O378eLF+JpQsDeBUrlxZIiVS0o6lFXt/HaanwwXzzjyoAancswjqdh+M+UA+HPOheaTclWKWD2kzxGNIoBZvzzuzoE0DYfHR8VIzuqbrof/OnamlwV/9WXRGwS0btsjpvaclPideLgm9ROpfVF8aNWpk+iPBKwAAAAAoWWRgBbiLLrrIPC9YsEAefPBBE4gqzIYNG6Rz585y+PBhqVevnglc7dy5U1JSUmTRokXy73//W6677rpzfk+JiYkyZMgQmTdvnikmP3DgQNe6Sy+91GP7++67T2bNmmWCW7rvypUr5Z///Kf8/PPP8tVXX7mCYfC/qlWrSuXjlWXv0b0SW/PPWlJFVdysqNyWblxa5OLtdiDMW20rlZWZJccPH5e0o2kSdiZMoiVa4iVeoiOjJSYmRqpUqUK/AwAAAAAfIoAV4G688UZ5/PHHTUaVBn80GNW2bVtp1qyZyWjKmzmiGSe6jwavNHA0ffp014W6BsF0KOLw4cPNa9SoUeOc3pPuqw8NYGkwQDOyCvLGG29IamqqCaYpfW+tW7eW5cuXm9kVNdgGZ9CZLKNCo+Tw6cOmuHlMjZhi7Z93eKDyVr/Km/lr53tdPvWDqVKtYjVpktCkwP3Pnj1rAlY6TPD0ydMSJVFSS2pJZGik6afVqlVjRkEAAAAA8BMCWAGudu3aJmtq2LBhJoilQSN9KC3cfsMNN8jEiRNdwSgd5qcZWLVq1ZJp06a5ZZkMGDDA1NHSulqvvfaaTJgwwSc/wyOPPOIKXikNJtx+++2mdteyZcsIYDlIuXLl5MILL5ST207K9n3bpUJkBalQqUKR9y8oK6owLRNbyqFTh/6sjSWWHEo7JKdOn5Lpn0yXt29/21VHy/b7779LxokMST+ebh4Vf68oVaWqVA6qLFWiq5iglQ6LJMsPAAAAAPyLAFYZcPXVV8tvv/0mH3/8sXz22WeyZs0ak9GkNaReeuklk1mlgSANEmlWk9JMK525MK+bb77ZBLDs7Xyha9euHsvq1q1rnvft2+ez94GiDyOsfqK6ZB/Nll2/7pL42vFSKapSiTffsLbD5LZOt7n+veSnJfJA8gMeQwk100qDVRnHMyQjLUMifo8wdbviJE4iI/7MtmI2QQAAAABwDgJYZURYWJj069fPPJQGr9555x156KGH5ODBgzJ69Gj5/PPPZe/evWb9xRdf7PV17OV79uzx2XvXjJ68IiMjzXN2drbP3geKTjP4zpw5I+XSysme3/ZItQurSdW4qj7LZNLC7XkLur/835clMSRRsjKypIJVwQStdCbBiuEVTTai1rXSmmwAAAAAAOchgFVG6QW7DsOrWbOm9OnTx9SSOnXqVKH7nUsAQodp/dVhaShdtLaa1lwL2xkmIYdDZO/uvaYoutbEqlyl5IfkfZb6mUdB9+1Ht0vqplTpWbOnVCpfyXwG9FGhQtGHOAIAAAAA/IMAVhlnF0DXYVWalaUBLbVjxw6v22/fvt08x8fHu2V3qYyMDK/7aO0tlD0apEpISDABoop7K8qxrGNyeNthObzvsERGR0rFyhVNfay/EszSSQeys/7Iwju456CcyTkj2ZnZ8uayN71u/9m+z+TBLg9KRETEOX9PAAAAAIDvEcAKcHqBX1CAQGtj2UEorf3Trl078+/58+eb2QvzzlL45pt/BAbs7ZRdAH7z5s0er3/06FFZt26d1++tNbZ0mBkCW2xsrKmLpUNVow9ES1pWmmTsz5D9+/dLTrkcKV+xvISFh0loWKiEhIVISGiI6bPad10sMcGpnNM55tn++nT2abFO/2+7AyLRIdESLuFyddzVkpGdYV4nqFyQyeLT2Qx71e9F8AoAAAAASiECWAFOZxjUOlE6XLBOnTpu67SO1ciRI83XvXv3NkGsjh07SqNGjcxMhJMmTXKbiTAlJcUUcK9UqZIMH/7nTHF/+9vfTM0j3eeDDz4wQxLVyZMnZcSIEZKWlub1vWm2l74HzfzSoVwIXBoI1UBnXFycnDhxwvQJfc48kylZ6VmSk54j+l+WZMkZ8QxqavAp5H//hUmYVJAKEiqh5mu7fzaIaWBmDNSMr1ZNWskL5V7ww08KAAAAACgJBLACnA7rmzVrlsyYMcPM3NegQQOTgbJ7925ZvXq15OTkmFpFzz77rNlegwFvvfWWdOrUSR577DETtLriiitk586dsnLlSjMz2+zZs11ZV7akpCS59dZbZcCAAdK+fXsT5NLZDjWgoAEtDWzlpUGz559/Xpo2bSpXXXWVeV86E+K9997rs/aB7wNZmo2lD6V11zIzM+X06dOuh/bJvLRfasaeBln12X5on7FrpGkQ1dvMmQAAAACA0o8AVoB7+OGHpXnz5vLpp5/K+vXrZfny5SbzRQNLLVq0MMGlUaNGuc2+phlYOuxPs68WL14sycnJEhUVJX379pUHH3zQ7JeXZmRpIGHmzJkm0KUzuvXq1UumT58u48aN8/redIiiDhPT4Na7775rhhN26NCBAFYZotlSf7WIureAFwAAAAAgsARZboVmACB/DRs2NM8//fSTY5pJA1iamaXZW2RgAQAAoDSe0wIo3B9jbwAAAAAAAACHIoAFAAAAAAAAR6MGFoAi02L+OmTPTrt2AnsUdOPGjV0zEgIAAAD52bJlC6UngFKIDCwARabF/p1WZ2rr1q0SHh5O8MoPJ376AG0e6OjrtHtZQV+n3csSvSGrM2EDKF3IwAJQZPv373dca1GEk3YvK+jrtHtZQn+nzcsK+rp/2x1A6UIGFgAAAAAAAByNABYAAAAAAAAcjQAWAAAAAAAAHI0AFgAAAAAAAByNABYAAAAAAAAcLciyLMvfbwIAAAAAAADIDxlYAAAAAAAAcDQCWAAAAAAAAHA0AlgAAAAAAABwNAJYAAAAAAAAcDQCWAAAAAAAAHA0AlgAAAAAAABwNAJYAAAAAAAAcDQCWABKpczMTJk0aZLUrVtXIiIipGbNmjJ8+HDZs2ePv9+a43Xs2FGCgoLyfSxevNjrfnPnzpUWLVpIpUqVpGrVqtKjRw9ZtWpVgd9r5cqVZjvdXvfT/V9//XUJVN99951Mnz5d+vfvLxdeeKGrTQvjq7bdvXu3DBs2zHxe9HOjn5+kpCTJysqSstTukydPLvAz8MADD+S7L+3+h1OnTsnChQvl1ltvlXr16pn+VLFiRWncuLFMnTpVMjIy8m1D+rvv2py+fn48/fTT5vhyySWXSFRUlISHh0tCQoLccsstsmHDhnz3o6/7tt3p70AZYAFAKZOZmWm1atXK0kNYjRo1rEGDBlktWrQw/46NjbW2bNni77foaB06dDBtNWDAAGvIkCEej9TUVI99xowZY/YpX7681adPH6tbt25WSEiIFRwcbKWkpHj9PsnJyWZ9UFCQ+Z76/aKjo83rjBs3zgpE2jb68+V9FMRXbfvrr79aMTExZpvLLrvMfG5q165t/t2mTRsrKyvLKivtnpSU5Pq5vX0G3nvvPa/70e5/evXVV13tXL9+feu6664zfTcyMtIsu/TSS60DBw54tCH93bdtTl8/P6pVq2ZFRESYc41+/fqZR926dU27h4aGWosWLfLYh77u+3anvwOBjwAWgFJnwoQJ5uSldevWVnp6umv5zJkzzXK9oEfhAaxt27YVqZk+//xzs72eSG7evNm1fNWqVVZYWJgJnBw7dsxtnyNHjliVK1c2+y1YsMC1fP/+/VZiYqJZvnTp0oD7NU2fPt2aOHGi9eGHH1r79u2zwsPDCwyk+LJtNVij6+6++27XspycHHNBoMv1xL+stLt9kTNnzpwifw/a3d3cuXOtESNGWBs3bnRbvnfvXqtJkyamfW+44Qa3dfR337c5ff38WLFihbl5lteLL75o2v2CCy4wx1Mbfd0/7U5/BwIfASwApUp2drYVFRVlTlzWrVvnsf7yyy8367799lu/vL9ADGB1797dbP/MM894rNNgiK6bMWOG2/InnnjCLNfMmLzef/99s+7vf/+7FegKC6T4qm1Xr15tlsfFxXlkWmngS+9kV6lSxe1CoDQriQAW7V50GoDV9tXfgx6zbfR337c5fb3k1alTx7T9+vXrXcvo6/5pd/o7EPiogQWgVNH6MydOnJA6depIkyZNPNYPHDjQPC9atMgP7y4wa4198cUXbm1blPb++OOP892nZ8+epnbLkiVLSn3tpdLStvY+vXr1MjVEcrvgggukXbt2cuzYMVmxYsV5+dkCEe1edFqTSWVnZ8uRI0fM1/R337f5uaKvF09oaKh5DgsLM8/0df+0+7mivwOlCwEsAKXK+vXrzXPTpk29rreXp6am+vR9lUazZ8+WUaNGyejRo+W5556TnTt3emyzadMmc0EUGxtrimMXtb0L+j3pyeZll11mAiybN2+WssqXbcvnxjsNIN5zzz1y++23y7Rp00wx+PzQ7kW3detW1wWmTjKg6O++b/Pc6Osl44033jB9W4uM60PR1/3T7rnR34HAFeLvNwAAxWEHWbxd8OdevmPHDhq2EHrBntv48eNl4sSJ5lHU9tYZsKKjo032Tnp6ukRGRkpaWprJkivs9/Ttt9+a39Pll19eJn9XvmxbPjf5XwTlpn1/wIABZuYwndnRRrsXz6xZs8zztdde68r4o7/7vs1zo6+fH0899ZT89NNPcvLkSfn555/N1zqr69tvvy3BwcFmG/q6f9o9N/o7ELjIwAJQqtjThFeoUCHfi36lF/zwrn379ubkbsuWLWZadr2L+eijj0pISIhMmjTJdSFUlPb21ua5p3Ln93Tuffl8ti2fG3eJiYkyY8YMcxGkbbNr1y556623JD4+XhYsWCA333yz198V7V64Tz75xGR3aibQI488Qn/3Y5sr+vr59emnn8q8efMkOTnZHD8SEhJMEKVZs2aubTi2+6fdFf0dCHwEsACgjJk6darcdNNNUrt2bSlfvrzUrVtXHnroIVm4cKFZP3nyZFPDAwhU2v/HjRsnDRo0MAE/zVobPHiwrF27VqpVq2Y+C998842/32ap88svv5i21UmCNGPCrssE/7U5ff380vqC2taaGbts2TIzfK1Dhw7mJhD83+70dyDwEcACUKrYw3o0c8gbTS9XOtwKxdO1a1dp3ry5HD9+XFavXl2k9vbW5rmHXvF7Ove+fD7bls9N0dSoUUOGDRtmvl68eLFH+9Hu+duzZ48ZvqYXmGPHjpUxY8a4rae/+77NC0Jf/2t0eLdOfqHZb5oFpMOPNQCu6Ov+afeC0N+BwEEAC0CpUqtWLfO8e/dur+vt5ZpejuKzi6Hu27evSO2twRINeFWpUsUVMKlcubJERUXxe/qLffl8ti2fm3P/DNDuhTt69KgJgGvdNQ0A6vDMvOjvvm/zwtDX/zodtnn99deb7CB7xlj6un/avTD0dyAwEMACUKrYwyPWrVvndb29vKwWBv+r9E5+7jpK9erVMwWBDx06ZO72F7W9C/o95eTkyI8//igRERFm+GJZ5cu25XNz7p8B2r1gWu+ne/fusnHjRunfv7+8+uqrEhQU5LEd/d33bV4Y+vr5ERMTY571WK7o6/5p98LQ34HAQAALQKnSpk0bk4GiBch/+OEHj/Va4FP16tXLD++udNOTwOXLl5uvmzZtap61Rlbnzp3N1/Pnzy9ye/fs2dNtfW4fffSRZGVlyTXXXGMCLWWVL9vW3kfvVGdnZ7vtc+DAAfN710wv/XyVZXo3PyUlxe0zYKPdPWlf6tOnj6xZs0a6deuW74xgiv7u+zYvCH39/Pnqq6/Mc506dcwzfd0/7V4Q+jsQQCwAKGUmTJhg6eHrqquusjIyMlzLZ86caZZ36NDBr+/PyVauXGmlpKRYZ86ccVu+bds2q02bNqb9evfu7bbu888/N8urVatmbd682bV81apVVnh4uBUdHW0dO3bMbZ8jR45YlStXNvstWLDAtfzAgQNWYmKiWb506VIr0Gn7FPSn1pdta/9+x4wZ41qWk5Nj9e/f3yxPSkqyykK7Hzx40HrhhRestLQ0t+Xp6enWyJEjzX7Vq1e3Tp486baednenx5B+/fqZ9mrXrp1He3lDf/dtm9PXz48VK1ZY//nPf6yzZ8+6LT99+rT13HPPWeXKlbPKly9v7dy507WOvu77dqe/A2UDASwApU5mZqbVsmVLcxJfo0YNa9CgQa5/x8bGWlu2bPH3W3SsOXPmuC7Qe/ToYQ0ePNgENiIiIszyhg0bmkBIXhr00PUVKlSw+vTpY3Xv3t0KCQmxgoODTUDMm+TkZHOCGRQUZHXq1MkaOHCgCcjo64wdO9YKRB999JHpi/ZDf3b9eXMv02380bYaINNAmW7TqFEj6/rrr7dq167tCgZnZWVZZaHdNVir6ypVqmTaTj8DXbp0cbWNtqNeOHlDu//p2WefNe2lDw2qDBkyxOvj0KFDbm1If/ddm9PXz+/fzZiYGKtbt27mmNG1a1dz/qHL9e/nu+++67Effd237U5/B8oGAlgASqVTp05ZEydOtOrUqWOFhYWZgMzQoUOtXbt2+futOdrGjRutO+64w2ratKkJ9mmgJCoqymrVqpXJYNN2LehkslmzZibQohf51157rcnoKogGAnQ73V73a968uTV37lwrUNkn3AU9dBt/ta3eqdbPiX5e9HOjGVv6OdKgcFlpd828uv/++02mZnx8vMnW0vbT4O24ceOs3bt3F/i9aPc/aMZeYW2uD72o9Pb7or+XfJvT18+PrVu3Wg899JC52aPBk9DQUKtixYrmmHHXXXdZv/76a7770td91+70d6BsCNL/+XsYIwAAAAAAAJAfirgDAAAAAADA0QhgAQAAAAAAwNEIYAEAAAAAAMDRCGABAAAAAADA0QhgAQAAAAAAwNEIYAEAAAAAAMDRCGABAAAAAADA0QhgAQAAAAAAwNEIYAEAAAAAAMDRCGABAAAAAADA0QhgAQAAAAAAwNEIYAEB5Pvvv5egoCCJj4/3uv7333+X6Ohos82IESO8brNs2TKzvmHDhiX8bgGgdHj99dfNcbFRo0aSk5PjdZtvvvlGgoODJSYmRg4dOlSs1x8+fLhUrFhRDh48KCXFsixp0qSJ+Rn0bwEAlCZ6DC7sMXToUH+/TQAljAAWEEAaN24slStXlr1798rWrVs91m/YsEFOnDhhvl6xYoXX11i+fLl5bteunU9ORi6++OIS/z4A8Ffccsstcs0118iPP/4oTz75pMd6DWrddtttJjA0c+ZMiY2NLfJr63F53rx5cuedd0pcXFyJHm8nTZpkfoa5c+eW2PcBgJI0ZMiQfB9t27b1WePrcVSPq5MnT/bZ9wQgEkIjAIGjXLlyctVVV8nixYtNgKp27dpeg1Ma6EpNTZUjR45ItWrV/BbAAoDS4pVXXpHLLrtMpk2bJoMGDZJLLrnEte6JJ54wgSENculFVHE8/PDDJnNr/PjxUtL69u0rl156qQlkaVAuJITTQAClCwF4oGwjAwsIMHbgyVuGlS4LDQ2Ve+65xwwnWblypdt6zR74+uuv3V4HACDmhsCUKVMkKyvLbQj2pk2bTFCrfPny8vLLLxerqXbt2iUfffSRdOvWrUSzr2yaLXDjjTfKnj175MMPPyzx7wcAAHA+EcACAowdeLIzqXLTZU2bNpUuXbp43Wb9+vWSlpYmtWrVMg915swZeemll6R169ZmeKJepF1xxRXy7LPPmnV5ae2XBx54QBo0aCCVKlWSqKgoqVu3rrnbv2bNGre0a7Vjxw63+gUdO3YsgVYBgL/u//7v/0wdqS+//FJmz55tbgRoMCs7O9sMI6lTp06xXu+1114zNw5uuOEGj3Xbt293HRNPnjwpY8eOlYsuusgcg/U4vmjRIte28+fPl5YtW5o6WhdccIHcfffdkpmZ6fV7Dh482Dy/+uqrxf75AaA00fPc0aNHy+WXXy5VqlQxx0/NQtXz1OPHj3vdZ9WqVSZbNSEhQcLDw6V69erSokULs09GRobZRo/Lw4YNM1/rjY3c57FkiAEli9xxIMDoH1n9g6tZAYcPHzYFhZXWxNLaWHqhpEXe9Q9z3iytvMMH9QKoZ8+esnTpUqlataq0atVKIiIiZPXq1eZCTpenpKSYoYsqPT3dXERt27bNXGhpoEyHqOzcuVPeeecdk8Gg7y8xMdEMs9G6L3rBNXDgQNd70BMLAHAiPZ5p4EePc/fee685purEFxrU1wBTcWn2lSoocH/69Gm5+uqrzXG1ffv25riu37Nfv35muLjW0LrvvvukQ4cOJpNL1z3//PNmiPhbb73l8Xp6HNbj8xdffGGO8XpBBwCBSI/TenNWA1h6HNUM2nXr1plh33r81ck39GarTW8MaPBKb07o+aqW5dBA16+//mr2uf3228321157rbmJqyMZtCyH/g2w6TkugBJkAQg4bdu2tfTjvXDhQteyefPmmWUpKSnm34MHD7bCwsKsU6dOuba57rrrzDYvv/yy+feoUaPMv6+//nrr+PHjru3S0tKsHj16mHUvvfSSa/lrr71mlvXu3ds6e/as23s6ePCgtWHDBrdlum1CQkIJtAAAlJxx48aZ45c+goODrbVr1xb7NdLT082+NWvW9Lp+27Ztru/RuXNnKyMjw7Vuzpw5ZnliYqJVpUoVt++/Z88eKy4uzqzfsmWL19ceMGCAWf/FF18U+30DgD/Yx8Pi+OSTT9zOX1VWVpY1YsQI81pTpkxxW9e+fXuzPDk52eO11qxZY85/8x6Hk5KSiv2zADh3DCEEysgwQvvrNm3auJ71zr5mU9nsjCzdX6dz10wDvVM/Z84cMxTQFhkZaYbPhIWFmeGFNnvq+M6dO7uysmw6K5cWQAaA0k6zrexh0JpN2rx582K/xsaNG+Xs2bNSr169ArfTY6keZzVb1aZDsjW79rfffjOzF+b+/jVr1jR1rpRmY3ljZ7r+8MMPxX7fAOBPuYfr5X0sXLjQbdvu3bu7nb8qHaWgZTA0o/aDDz5wW2efx+qEHHldeeWV5vwXgH8xhBAIQBqAevzxx92GCOrXWovKnt7dDmTpch2+smXLFtm3b5+ZlbB+/fqmpopODa9p0t6GmGhNAJ2FS4ev2MNQmjVrZtY99dRTpg6LDj/kjz2AQJOUlGSGmKhPP/3UDJ8u7rFObxIorctSkIsvvtgcu/MGtXQYuA4n7Nq1q8c+9gy0ekz3RoeE575YA4DSoqCZXu36rbnppBU6NPCXX34xdV617qDSm7A6NDA3PY/9+eef5eabb5aJEyeaf+e9IQvAvwhgAQFIx+zrH1wd56/BJS06qX+4hw8f7tqmUaNGpii7HeSyM7Tatm1r7mJpAWGlWViFFfs9evSoqaul9QW0Npbe2dJaW3p3yy4ar9/bvqgCgNJKs5o0A7VGjRqmFpbe8Z8wYYI899xzxXqdEydOmOfCAl96bPXGrtvibb29TovLe6PHfpVfEWMAcKriFEl/+umnTfF1vSFbFI899pi5MasBL33oDQY9L+7du7fcdNNNpg4sAP8igAUEIE2X1oKVOjxEC1TaFyn6R9imAS4tyv7111+bYSx5C7jbd6i0MKUWqCyIpmPnPlkYOXKkSctesmSJKXCpsw8++eST8vbbb8uAAQNK5GcGgJKmASGddVCzr7RQuh5Tv/rqK3nxxRfNHXsdYlJU9rAWzd4qSGF3/88lO8AOnkVHRxd7XwAoDfT8d9y4ceZYO2vWLDPaQEcP2OesOtw6b5aqls349ttvzSQXWuRdj+92MEvPY/WcWUcqAPAfAlhAgNJAlAawNMPKWwDLHkb42WefSWpqqlv9K3XhhRe69tELteLQmi46K5Y+dMaXF154wcwEc8cddxDAAlBqTZs2zczwqnfj7WC8XtTcdttt5qEXPpp5WhRxcXGuDFZfO3bsmHm2h5QDQKDRWbLVo48+6jHsUEcn7N+/3+t+egzXodn28OwdO3aYUQQa1NKZCPWYD8B/GNQLBCg7EKWBKc2u0ppUWrMqN7sO1vvvvy+bN282RYJ1yJ/q1KmTBAcHmztQRU299kbTrcePH2+G22i9FbvuiwoNDTXTEAOA0/3444/m4kWH/GnGle3WW281x1udqv2ZZ54p8us1bNjQXChpQMzXtMaLyj31OwAEEjtQb9+QzU3rvNp1DAuj9Qbvv/9+198Bm9bQUpzHAr5FAAsI8ADWqlWr5Pvvv3cFq3LT+i0apLIvxnRIoZ09oHVV9I6T1sLSelYHDhzw2F9nwFqwYIHr31oLRlO28/ruu+/M/lqXJfeQFU3f1uXUYQHgZDqkWjOsNJivd/NzXxBpzcBXXnnFXMxMnjzZVT+wMHrDoEmTJmYIixYZ9iUd1q3vV4/5ABCI7MkvtGZh7huxOgOsHZDKS29CeMvM+uSTT1xDDHOfwyp/3IQAyjKGEAIBSsf5JyYmmiCTt+GDSgNKWt9Ki73nDnrZtGaAXoxpkGrx4sXmbr3O8HLy5ElzAqCv3adPH9dQmi+//NLso8EvvTDTQsF79+41GWB6AThlyhTXHSulw3B0eKJmfWnhec3W0uGHOtwQAJziH//4hwnOa9D/zjvv9FivM7dqoeCpU6fKqFGjXBc7hdGZWteuXWuOnTfeeKP4gs44u3v37nxnmAUAJxs6dGi+6/QcVY/DatiwYTJz5kxTv0rPLbVGoQ7Z1rpWffv2NYF8HR6Ym56n6qgBPTfWUQuapaXZtTpKQWdv1XU2vQGgQ8GTk5NNfS2dqEhrEurNXz2nBVBCLAABa9iwYZofbR5r1qzxus1dd93l2ua///2vx/ozZ85Y8+bNszp37mxVrVrVCg0NtWrWrGm1bt3amjJlirVp0ybXtt9//701btw468orr7Ti4uKs8PBwKyEhwerVq5e1ZMkSj9fOyMiwRo8ebV100UVWSEiIeQ8dOnQ4z60AAOdu165dVmRkpDlGpaam5rtdVlaWVbduXXMce+edd4r02jt37rSCg4OtHj16eKzbtm1bgcdEXa7rdbu85syZY9YlJSV5rJs6dapZt2DBgiK9RwBwAvtctaBH48aNPY7fgwcPtuLj462IiAirfv361vTp0825rZ6f5r0Ufv3118329erVM8d9fTRo0MAaO3astXv3bo/3tHbtWqtLly5WVFSUFRQUZF5Pj78ASk6Q/q+kgmMAAADIX79+/UytwV27dpnM2ZKkp3yaLZaRkWGya4tacB4AAMAJqIEFAADgJ4888ogZYj1jxowS/15ap1DrtegQG4JXAACgtCEDCwAAwI+0Zsq7774r27ZtMzVVSir7SusN6oxZWtNFa7UAAACUJgSwAAAAAAAA4GjcfgMAAAAAAICjEcACAAAAAACAoxHAAgAAAAAAgKMRwAIAAAAAAICjEcACAAAAAACAoxHAAgAAAAAAgKMRwAIAAAAAAICjEcACAAAAAACAoxHAAgAAAAAAgKMRwAIAAAAAAICjEcACAAAAAACAoxHAAgAAAAAAgKMRwAIAAAAAAICjEcACAAAAAACAoxHAAgAAAAAAgKMRwAIAAAAAAICjEcACAAAAAACAoxHAAgAAAAAAgKMRwAIAAAAAAICjEcACAAAAAACAoxHAAgAAAAAAgKMRwAIAAAAAAICjEcACAAAAAACAoxHAAgAAAAAAgKMRwAIAAAAAAICjEcACAAAAAACAoxHAAgAAAAAAgKMRwAIAAAAAAICjEcACAAAAAACAoxHAAgAAAAAAgKMRwAIAAAAAAICjEcACAAAAAACAoxHAAgAAAAAAgKMRwAIAAAAAAICjEcACAAAAAACAoxHAAgAAAAAAgDjZ/wMpKw4PkEH7zAAAAABJRU5ErkJggg==", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -921,16 +937,151 @@ "test_dispersion.plots.ellipses(xlim=(-200, 3500), ylim=(-200, 3500))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using Background Maps\n", + "\n", + "You can also use the `background` parameter to automatically download and display a background map. The `background` parameter accepts:\n", + "- `\"satellite\"` - uses Esri.WorldImagery for satellite imagery\n", + "- `\"street\"` - uses OpenStreetMap.Mapnik for street maps\n", + "- `\"terrain\"` - uses Esri.WorldTopoMap for terrain maps\n", + "- Any contextily provider name (e.g., `\"CartoDB.Positron\"`)\n", + "\n", + "Note that if both `image` and `background` parameters are provided, the `image` parameter takes precedence. The background map is automatically downloaded based on the environment's latitude and longitude coordinates." + ] + }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "eea219a59ac2464fbcea97b6d6c38c46", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example: Plot ellipses with satellite background map\n", + "test_dispersion.plots.ellipses(\n", + " background=\"satellite\",\n", + " xlim=(-200, 3500),\n", + " ylim=(-200, 3500)\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "325fe1b9d06c4c76bf4f04a11e468b52", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example: Plot ellipses with street map background\n", + "test_dispersion.plots.ellipses(\n", + " background=\"street\",\n", + " xlim=(-200, 3500),\n", + " ylim=(-200, 3500)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a88c3da8e4ab4152a5d30dd79fef67a4", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9f658125a5dc4cbc967b8ef383f21dc5", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -938,9 +1089,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "e6b69845c59a412386529f6474f3f993", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyAAAAMgCAYAAADbcAZoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAUgpJREFUeJzt3QeYVNXBP/5DF5Qi0kQRUFFUsHfsEFGJkaiJGlQsgcTYsaKxoCZgNxpL8kbFGE2xv2o0QTRWNIoVxYJK1AiiIkVR6vyfc97/7G+XpsBwdnf283meYXbuvXPLmbvL/c4pt16hUCgEAACADOrn2AgAAIAAAgAAZKUGBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBIDvbOLEiaFevXph5MiRNarUHn744bD55puHVVZZJe3ftGnTqnuXAFgCAQSgGsQL+HihXPnRrl27sPvuu4eHHnoo+/7861//qrIvjRo1Cuuuu244/PDDw3vvvVeSbTzzzDPh/PPPL3k4+Pzzz8OPf/zj0LRp03DttdeGW2+9Nay66qol3QYApdOwhOsCYBldcMEFoWvXrqFQKIRPPvkkBZN99tkn3H///eH73/9+9vI84YQTwjbbbBPmzp0bXnzxxfD73/8+PPjgg+G1114LHTt2XOEAMmzYsHDEEUeEVq1alWyfn3/++TBz5sxw4YUXhj59+pRsvQCsHAIIQDXae++9w9Zbb13x+uijjw7t27cPf/7zn6slgOy8887hwAMPTD8feeSRYYMNNkih5JZbbglDhw4NNdGUKVPScylDDQArjyZYADVIvIiOTYkaNqz6/dBXX30VTjnllNCpU6fQpEmTsOGGG4bLLrss1ZxEX3/9dejevXt6xJ+Lpk6dGtZcc82w4447hvnz5y/z/uyxxx7p+f3331/qco8++mgKL7HpUzyG/fbbL4wfP75ifmx6ddppp6WfY41PsalX7FOyNHfccUfYaqutUpm0adMmHHrooeG///1vxfzddtstDBw4MP0ca27iOmMNy5L85z//Cb/4xS9S+cV1rrHGGuFHP/rRIvtRbCL3xBNPhJ/97GdpuRYtWqQmaV988cUi673uuuvCJptskj6bWFN07LHHLrapWWwiFpu2xW1vu+224cknn0zHEB+VzZ49O5x33nlh/fXXT+uMn/vpp5+epi/sT3/6U0UZtW7dOhx88MHhww8/XGq5AlQnNSAA1Wj69Onhs88+S0EifpN/zTXXhC+//DJdaBfFeT/4wQ/CY489lmpIYmfrf/zjH+mCPl6MX3nlleniM9ZS9OrVK5x99tnhiiuuSO+NF8JxG/GCukGDBsu8f++++256jhfgS/LII4+kmpx4YR2DRgxA8TjivsRmXF26dAn7779/ePvtt1PNTtzfGCaitm3bLnG9cZ9jLUwMFsOHD09N1H7zm9+Ep59+Orz00ksp6MRjjWEiNhUrNmdbb731ltpcKzYFixfpa6+9dgoe119/fQoAb7zxRmjWrFmV5Y877ri0nXhcb731Vlo2hphin5kozotNy2Lzr2OOOaZiubituK+xP00Up8X1xaB28sknp233798/rL766mlfihYsWJA+76eeeioMHjw4bLTRRqkJXCy3WIb33ntvxbK/+tWvwjnnnJP6wPz0pz8Nn376aSr7XXbZpaKMAGqcAgDZ3XzzzbHqYpFHkyZNCiNHjqyy7L333pvmXXTRRVWmH3jggYV69eoVJkyYUDFt6NChhfr16xeeeOKJwh133JHed9VVV33r/jz22GNp2Ztuuqnw6aefFj7++OPCgw8+WOjSpUvaxvPPP5+We//999Nycf+LNt9880K7du0Kn3/+ecW0V155Je3H4YcfXjHt0ksvTe+N6/g2c+bMSevs0aNH4euvv66Y/sADD6R1nHvuuYuUZXEfl2bWrFmLTBszZkx6/x//+MdF1rnVVlulfSm65JJL0vT77rsvvZ4yZUqhcePGhT333LMwf/78iuV++9vfVpRnNHv27MIaa6xR2GabbQpz586tWC5+1nG5XXfdtWLarbfemsruySefrLKfN9xwQ1r26aefTq8nTpxYaNCgQeFXv/pVleVee+21QsOGDReZDlBTaIIFUI1ik5xRo0alR2xKE0fBit9k33333RXL/P3vf0+1F7EvRmWxSVasHak8alb8Nj42BYrNkmJTo1133XWR9y3NUUcdlWolYjOifv36paZfsWalcj+VyiZNmhRefvnl1OwpNv8p2nTTTcP3vve9tO/L44UXXkg1QvEY4tC6RXGfYjOz2DF+ecSaoqLY0T6OoBWbOcWaglhbs7BYA1GswYhiDUdsHlc8rlj7M2fOnHDSSSeF+vX/33+pgwYNSk22ivsZjyduK06v3LxuwIABqQZk4WZnsdYjHmesHSs+is3hYk1YFM+RWFsSaz8qL9ehQ4fQrVu3iuUAahpNsACqUewHUPni/pBDDglbbLFFaqoTO6E3btw4NfmJgaB58+ZV3hsvUqM4vyguf9NNN6VmS/HC/eabb65oKvRdnHvuuamJUAw8sZlU3MbC/VEqK247NoNaWHxvbCoWQ8yyDou7tPXGC/PYPGl5xOZhsTlXLJfYfK3YhyaKTdUWFi/kK1tttdVSn5pin5El7Wf8HGKTtOL84nMMO5XFso1N1Cp75513Uv+ZJTVPK3a6j8vF/V94H4sqByeAmkQAAahB4rfosRYk9nWIF5ixNmNZxYv+6JtvvknriP0ivquePXuW9VC2xx9/fAofscZihx12CC1btkwBLfYJibUJNUHcj/g5FPvxLCx2SC8uF/c91oAtrn9PDEsANZEAAlDDzJs3Lz3HzuhR586dU1OfeK+LyrUgb775ZsX8oldffTV1xo6dt2PTqNicK3ZgjhfaK0Nx27Hj9cLi/sValGLtx7LUxFReb7HpUVGcVvmYl8Wdd96ZmqddfvnlFdNiUFvSzRFjgIuBsCh+JrHZWbxXy8L7GWs8imKzrDhyWDHMFZebMGFClfXFzzrWpsQma0WxE/0rr7wSevfuvdQyi8vFGpAYMONwyQC1hT4gADVI7Jfwz3/+MzXhKTaxihe7cQjd3/72t1WWjaMixQvUOAJV8b2xL0ZsrhVrUOIoUnHkqDji0soSmyPFUbliP5HKF/Hjxo1Lx1G8UI+KQeS73Ak9NkuLd4a/4YYbqgw9G7/tj82TYl+Q5RFrCio3u4riqFFLGqI4jq4Vy7UojmQVQ0OxzGPAiJ/V1VdfXWW9N954Y2rSVdzPeDxxJLH/+Z//qQiY0W233bbIsL6xT0dsHhaXXVwTstikLYoji8XjiSNwLXxM8XXscwJQE6kBAahG8YK6WJMR2/bffvvt6Vv3M888M3Vijvbdd9/0rXkccjZ+W77ZZpuli/v77rsvNSUqDjt70UUXpVqP0aNHp5qS+K167NPxy1/+Mt1csHIYKKVLL700XZDHJk1xmODiMLyx1iV2ii+K96qI4nHEJk+xj0I8tsX1D4nzLr744lSTEzvSx74xxWF4Y5+J5Q1VsV/NrbfemvZt4403DmPGjEm1S0saZjjWZMSaiBgKYi1HvN/HTjvtlIbJjWI/jXiDxhgC9tprrzS9uFzsh1McTjmGlFgWsQlYrNGJ64ufZQyJ8fOrXNNx2GGHhb/97W/h5z//eepIHoczjgEpnidxemxiFwNNfF/8zOP2i0P6xs891rzcc889qQP9qaeeulzlBLBSVfcwXAB10eKG4V1llVXSkLbXX399YcGCBVWWnzlzZuHkk08udOzYsdCoUaNCt27d0rC2xeXGjh2bhl49/vjjq7xv3rx5aejX+L4vvvjiW4fhjUP3Ls3ihuGNHnnkkUKvXr0KTZs2LbRo0aKw7777Ft54441F3n/hhRcW1lprrTTM7HcZkvevf/1rYYsttkjDE7du3bowYMCAwkcffVRlmWUZhjeWwZFHHllo06ZNYbXVViv07du38OabbxY6d+5cGDhw4CLrfPzxxwuDBw8urL766mn5uP3Kww1XHna3e/fu6bNp37594ZhjjllseV999dVpW/F4tt122zSkbhzqd6+99qqyXBz69+KLLy5ssskmadm4/bjcsGHDCtOnT6+y7F133VXYaaedCquuump6xP049thjC2+99da3lgdAdagX/1m5EQcAapfiTRDjzQSXNARxKcSO5LEWJTanWlyTK4BypA8IAGQQO7sv/J3fH//4xzB16tR0J3aAukIfEADI4Nlnn019V370ox+lPifxxoexs3qPHj3SNIC6QgABgAxi5/l4D484Ylas9Yh3jj/88MPDiBEjUid1gLpCHxAAACAbfUAAAIBsBBAAACAbfUCWMjTixx9/nG7qVPkGUQAAUJcVCoUwc+bM0LFjx1C//rLXZwggSxDDR+wsCAAALOrDDz8Ma6+9dlhWAsgSxJqPYsG2aNFimQsWAADK0YwZM9IX9cXr5WUlgCxBsdlVDB8CCAAAVLW83RR0QgcAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyaZhvUwCw4t55550wc+ZMRckimjdvHrp166ZkoIYTQACoVeFjgw02qO7dqLE6rFYv/GyrxuF3Y+eEyV8WQl309ttvCyFQwwkgANQaxZqPP/3pT2GjjTaq7t2pcZpOezts9MTPwkHnjgxft6pbQW38+PHh0EMPVTsGtYAAAkCtE8PHlltuWd27UfN8XD+EJ0LYqHv3EDpuXt17A7BYOqEDAADZCCAAAEA2AggAAJCNAAI13KxZs8KLL76YngEAZtXyawMBBGq4N998M2y11VbpGQDgzVp+bWAUrBpo/vz54cknnwyTJk0Ka665Zth5551DgwYNatw6c6t8DO3atUvTpkyZUnE80YocY1z/v/71r/SIdtttt/QoRTmVQ/kDAJSCAFLD3H333eGUU04JEydOrJjWpUuXcPnll4f999+/xqwzt8UdQ2Vt27YN9erVS4FkeY4xrv+YY46p8v6LLroorfeGG25YoXIqh/IHACgVTbBqkHiheuCBB4aePXuGMWPGpJspxef4Ok6P82vCOnOrfAzDhw9PQWOnnXZKj2jAgAHh008/TeEhzl/WYyyuP74/rnP06NHpEX+O6z3ggAOWu5zKofwBAEqqwGJNnz69EIsnPucwb968QpcuXQr77rtvYf78+VXmxddxeteuXdNy1bnO3Cofw5w5c6ocT3x8//vfLzRs2LDQr1+/9HPl4/kux1hcf9OmTdP7K5dTcf3NmjVLyyxrOZWq/MeOHZvOxfgMdZ3fh2/x35cKhfNa/N9zHePcoC4ZW83XBit6nawJVg0R+wfEJjp//vOfQ/36VSum4uuhQ4eGHXfcMS0X+yVU1zpzq3wMTz/99CLHs9dee4UHHngg7LPPPmGLLbaocjzf5RiL64/OPvvsKuUUfz7rrLPS+uMyy1pOpSr/r7/+Oj2PHz/+O28bylXx96D4ewFF/lZSl4yv5X8LBZAaInZOjnr06LHY+cXpxeWqa525VT6G+++/v+LnoqZNm1Y8L+54vu0YF7dsZZWnLWs5lar8iwHp0EMPXabtQzmLvxe9evWq7t2gBvG3krpoYi39WyiA1BBxZKRo3LhxYfvtt19kfpxeebnqWmdulY9hccdTTP7xeXHH823HuPCyC5dT8f1LW8fKLv/YYT3605/+FDbaaKNl2gcox2/9Yhgv/l5Akb+V1CXja/vfwpI3CisT+oDUDPqAVH87T6hJ/D58C31A/K2kThhby/uAGAWrhoj3hIjDssb+Bv37968yYlJ8Hadfdtlly3TviJWxztwqH0McjWrw4MHp51133TXssssu6ecf//jH4cEHH0w/Dxo0KN0V9LseY3H933zzTVo2rvORRx5Jj7iNOC2uLy6zrOVUDuUPAFByJY9EZSJ3DUjRXXfdlUZOitsuPuJISXF6TVpnbos7hsqPdu3apcfyHmNcbuH3F9e7ouW0ouVf3d9yQE3i9+FbqAHxt5I6YWwtrwHRB6SGiTem22+//Up61+yVsc7cFj6GUt8Jvbj+lXEn9HIofwCAUhFAaqB4YVrqYXFXxjpz+y7HsCLHGNffu3fv9Ci1cih/AIBS0AcEAADIRgCBGq579+5h7Nix6RkAoHstvzbQBAtquGbNmoUtt9yyuncDAKghmtXyawM1IAAAQDYCCAAAkI0mWADUGvHGoNGLL75Y3btSIzWd9nbYKIQw/s03w9eTF4S6ZPz48dW9C8B3JIAAUGu8+eab6XnQoEHVvSs1UofV6oWfbdU4/O7yn4TJX8b7hNU9zZs3r+5dAL6FAAJArdG/f//0HEd+iZ0wWbwf1NGCieGjW7du1b0bwLeoF2+H/m0L1UUzZswILVu2DNOnTw8tWrSo7t0BAICyuE7WCR0AAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAAABBAAAKD9qQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsGubbVO1SKBTS84wZM6p7VwAAoMYoXh8Xr5eXlQCyBDNnzkzPnTp1Wt7PBgAAyvp6uWXLlsv8vnqF5Y0uZW7BggXh448/Ds2bNw/16tWr7t0BAIAaIcaHGD46duwY6tdf9h4dAggAAJCNTugAAEA2AggAAJCNAAIAAAggAABA+VEDAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAJQA3Tp0iUcccQR1b0bZe/SSy8N6667bmjQoEHYfPPNq3t3AOokAQSgxEaOHBnq1asXXnjhhcXO32233UKPHj1WeDt///vfw/nnn7/C66kr/vnPf4bTTz899OrVK9x8883h17/+dXXvEkCd1LC6dwCAEN56661Qv379ZQ4g1157rRDyHT366KOpjG+88cbQuHFjpx1ANVEDAlADNGnSJDRq1CjUJl999VWoTaZMmRKaNm0qfABUMwEEoAb2AZk7d24YNmxY6NatW1hllVXCGmusEXbaaacwatSoND8uG2s/otjcq/ioHA5OOeWU0KlTpxRuNtxww3DZZZeFQqFQZbtff/11OOGEE0KbNm1C8+bNww9+8IPw3//+N62rcvOu+HOc9sYbb4Sf/OQnYfXVV0/7E7366qtpf2LfirivHTp0CEcddVT4/PPPq2yruI633347HHrooaFly5ahbdu24Zxzzkn79eGHH4b99tsvtGjRIq3j8ssv/05lN2/evHDhhReG9dZbLx1rLMuzzjorzJ49u2KZuN3Y7CqWS7GsYlO5JXnyySfDj370o7DOOuukdcZyPPnkk1N5VRaPe7XVVgvvvfde6Nu3b1h11VVDx44dwwUXXLBIWZf6M4ni9FjW7du3T+vcZJNNwk033bTI8cSyOO+888L6669fcTyxOVrlMgLIRRMsgJVk+vTp4bPPPltkegwX3yZeaA4fPjz89Kc/Ddtuu22YMWNG6lPy4osvhu9973vhZz/7Wfj4449TILn11lurvDde0MaL1sceeywcffTRqbP1P/7xj3DaaaelC9Yrr7yyygX03/72t3DYYYeF7bffPjz++OOhX79+S9yveFEeQ1HsP1G8cI77EC/AjzzyyBQcXn/99fD73/8+PT/77LNVglF00EEHhY022iiMGDEiPPjgg+Giiy4KrVu3Dr/73e/CHnvsES6++OJw2223hVNPPTVss802YZdddllqWcUyuuWWW8KBBx6YLvCfe+65VHbjx48P99xzT1omllHcp3//+9/hD3/4Q5q24447LnGdd9xxR5g1a1Y45phjUviL77vmmmvCRx99lOZVNn/+/LDXXnul8rvkkkvCww8/nC72YzCKQWRlfSaffPJJmh/L97jjjkth7qGHHkrrj+fLSSedlJZbsGBB2vZTTz0VBg8enMr+tddeS9uMYfDee+9davkClFwBgJK6+eab45X5Uh+bbLJJlfd07ty5MHDgwIrXm222WaFfv35L3c6xxx6b1rWwe++9N02/6KKLqkw/8MADC/Xq1StMmDAhvR47dmxa7qSTTqqy3BFHHJGmn3feeRXT4s9x2iGHHLLI9mbNmrXItD//+c9p+SeeeGKRdQwePLhi2rx58wprr7122q8RI0ZUTP/iiy8KTZs2rVImi/Pyyy+ndf70pz+tMv3UU09N0x999NGKaXFdq6666lLXt7RjGj58eNrP//znP1XWGbdz/PHHV0xbsGBB+uwaN25c+PTTT1faZ3L00UcX1lxzzcJnn31WZdmDDz640LJly4pjuPXWWwv169cvPPnkk1WWu+GGG9I6n3766e9UJgClogkWwEoSm0jF2oGFH5tuuum3vrdVq1apBuGdd95Z5u3GzulxmNnYjKeyWDsQv4mP35JH8Zv66Be/+EWV5Y4//vglrvvnP//5ItNiv4qib775JtX6xG/mo1hjs7gai6K4n1tvvXXar/jNfeXjj02UYs3Ktx1rNGTIkEWONYo1LMuj8jHFplPxmGKNSdzPl156aZHlYw1EUbFGYs6cOeGRRx5ZKZ9JfM9dd90V9t133/Rz3L/iIzYFi7VvxbKPNTax1qN79+5Vlou1TVGslQHISRMsgJUkNp2KF9cLi/0nFtc0q7LYdCf2h9hggw3SkL2xiU9skvNdwst//vOf1A8h9h+oLF6EFucXn+OoUF27dq2yXOwnsCQLLxtNnTo19Vf5y1/+kjp6VxYvhBcW+1VUFvuCxL4jsc/DwtMX7keysOIxLLzPsSlYDDHFY11WH3zwQTj33HPD//7v/4YvvvhiqccUtx/7v1QWP7do4sSJK+Uz+fTTT8O0adNSs7L4WJziZxFDbGyOFptoLW05gFwEEIAaKPZ7ePfdd8N9992X7l8R+y3ENvs33HBDlRqE3CrXDBT9+Mc/Ds8880zqzxD7NsRO2bHfQQxN8XlhsSbgu0yLFu6gvSQL9zNZEbFPR+xnE4PVGWeckWoOYufy2Fcj9s9Y3DHlVtyH2Jl/4MCBi12mGFbjsj179gxXXHHFYpeLHdIBchJAAGqo2DE7duyOjy+//DKFktg5vRhAlnTR3blz59T0Z+bMmVW+cX/zzTcr5hef48Xp+++/nzqWF02YMOE772OsHRg9enSqAYk1BkXL03RseRSPIW6vWJtQ7KAdawiKx7osYgft2Dk7dmw//PDDK6YXRyBbWNx+bCpWrPWI4vujOCLXyvhMYm1GXE8MS3369Fnq8cTRwV555ZXQu3fvkgY1gOWlDwhADbRw06NYqxCb4VQeNjV+Kx/FC+3K9tlnn3Rh+tvf/rbK9FiDEi9A99577/Q69hWIrrvuuirLxdGevqtizcXCNRVXXXVVyCEe6+K2V/y2f2kjei3LMcWff/Ob3yzxPZXLOi4bX8f7usSL/pXxmcR9POCAA1I/kHHjxi2yP7GJVuUaqlh78z//8z+LLBeH/K1t93MBaj81IAA10MYbbxx22223sNVWW6WakDgE75133lmls3OcF8WOzfHCNV6UHnzwwalj8u677x7OPvvs1Adhs802S824YnOuODRr/Ea8+P54ERsv3mPgKQ75Wvz2/rt8Wx7v2RFrZuLws3F44bXWWittK36Dn0M8ttgEKfaDiEFs1113TUPmxtqL/v37p3JYVrHJVSyjOAxwvHCPxxgv9BfuC1IU+6/EzuNxP7bbbrvUoTx2fo/3Iin2u1gZn0kcxjh2II/bHDRoUDpnYrOx2Pk81rbEn6PYdygO6xsHEIjL9+rVK4WhWPsSp8fhgBfXVwlgpSnZeFoAVBmG9/nnn19siey6667fOgxvHK512223LbRq1SoNR9u9e/fCr371q8KcOXOqDGEbh39t27ZtGsq18p/0mTNnFk4++eRCx44dC40aNSp069atcOmll6YhYiv76quv0nC+rVu3Lqy22mqF/v37F9566620rsrD4haH0C0OK1vZRx99VPjhD3+Y9jUO//qjH/2o8PHHHy9xKN+F17Gk4XEXV06LM3fu3MKwYcMKXbt2TcfaqVOnwtChQwvffPPNd9rO4rzxxhuFPn36pDJp06ZNYdCgQYVXXnkl7X/8fBde57vvvlvYc889C82aNSu0b98+Hev8+fOrrLPUn0n0ySefpGXjMcd1dujQodC7d+/C73//+yrLxfPm4osvTuXZpEmTwuqrr17YaqutUrlNnz79O5UJQKnUi/+svHgDQG3z8ssvhy222CL86U9/CgMGDKju3anRYqf0WDMV++isTD4ToJzoAwJQh8U+AAuLzX/iULDfdgdyfCYAy0MfEIA6LPbdGDt2bOqf0LBhw9R/IT4GDx5seFafCcBKIYAA1GHx7t5xeNkLL7wwNSOKNwmMQ/3GztL4TABWBn1AAACAbPQBAQAAshFAAACAbPQBWYIFCxaEjz/+ODRv3vw73YwLAADqgkKhEGbOnBk6duyYRk1cVgLIEsTw0alTpxX9fAAAoCx9+OGHYe21117m9wkgSxBrPooF26JFixX7dAAAoEzMmDEjfVFfvF5eVgLIEhSbXcXwIYAAAEBVy9tNQSd0AAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyKZhvk0BACuiy5kP1vkCnDiiX50vA6jt1IAAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAA1N0AMnz48LDNNtuE5s2bh3bt2oX+/fuHt956q8oyu+22W6hXr16Vx89//vMqy3zwwQehX79+oVmzZmk9p512Wpg3b17mowEAAGr0ndAff/zxcOyxx6YQEgPDWWedFfbcc8/wxhtvhFVXXbViuUGDBoULLrig4nUMGkXz589P4aNDhw7hmWeeCZMmTQqHH354aNSoUfj1r3+d/ZgAAIAaGkAefvjhKq9HjhyZajDGjh0bdtlllyqBIwaMxfnnP/+ZAssjjzwS2rdvHzbffPNw4YUXhjPOOCOcf/75oXHjxiv9OAAAgFrQBGth06dPT8+tW7euMv22224Lbdq0CT169AhDhw4Ns2bNqpg3ZsyY0LNnzxQ+ivr27RtmzJgRXn/99cVuZ/bs2Wl+5QcAAFDmNSCVLViwIJx00kmhV69eKWgU/eQnPwmdO3cOHTt2DK+++mqq2Yj9RO6+++40f/LkyVXCR1R8Hectqe/JsGHDVurxAABAXVejA0jsCzJu3Ljw1FNPVZk+ePDgip9jTceaa64ZevfuHd59992w3nrrLde2Yi3KkCFDKl7HGpBOnTqtwN4DAAC1pgnWcccdFx544IHw2GOPhbXXXnupy2633XbpecKECek59g355JNPqixTfL2kfiNNmjQJLVq0qPIAAADKPIAUCoUUPu65557w6KOPhq5du37re15++eX0HGtCoh122CG89tprYcqUKRXLjBo1KoWKjTfeeCXuPQAAUKuaYMVmV7fffnu477770r1Ain02WrZsGZo2bZqaWcX5++yzT1hjjTVSH5CTTz45jZC16aabpmXjsL0xaBx22GHhkksuSev45S9/mdYdazoAAIDqUeNqQK6//vo08lW82WCs0Sg+/vrXv6b5cQjdOLxuDBndu3cPp5xySjjggAPC/fffX7GOBg0apOZb8TnWhhx66KHpPiCV7xsCAADk17AmNsFamtgxPN6s8NvEUbL+/ve/l3DPAACAsqsBAQAAypcAAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZNMw36YAYPl1OfNBxQdQBtSAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkE3DfJsCAFgxXc58sM4X4cQR/ep8GVC7qQEBAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAA6m4AGT58eNhmm21C8+bNQ7t27UL//v3DW2+9VWWZb775Jhx77LFhjTXWCKuttlo44IADwieffFJlmQ8++CD069cvNGvWLK3ntNNOC/Pmzct8NAAAQI0OII8//ngKF88++2wYNWpUmDt3bthzzz3DV199VbHMySefHO6///5wxx13pOU//vjjsP/++1fMnz9/fgofc+bMCc8880y45ZZbwsiRI8O5555bTUcFAABE9QqFQqEmF8Wnn36aajBi0Nhll13C9OnTQ9u2bcPtt98eDjzwwLTMm2++GTbaaKMwZsyYsP3224eHHnoofP/730/BpH379mmZG264IZxxxhlpfY0bN/7W7c6YMSO0bNkyba9FixYr/TgBWLouZz6oiCCEMHFEP+VAtVrR6+QaVwOysHhgUevWrdPz2LFjU61Inz59Kpbp3r17WGeddVIAieJzz549K8JH1Ldv31RYr7/+evZjAAAA/k/DUIMtWLAgnHTSSaFXr16hR48eadrkyZNTDUarVq2qLBvDRpxXXKZy+CjOL85bnNmzZ6dHUQwrAABAadXoGpDYF2TcuHHhL3/5S5bO77Eqqfjo1KnTSt8mAADUNTU2gBx33HHhgQceCI899lhYe+21K6Z36NAhdS6fNm1aleXjKFhxXnGZhUfFKr4uLrOwoUOHpuZexceHH364Eo4KAADqthoXQGKf+Bg+7rnnnvDoo4+Grl27Vpm/1VZbhUaNGoXRo0dXTIvD9MZhd3fYYYf0Oj6/9tprYcqUKRXLxBG1YieZjTfeeLHbbdKkSZpf+QEAAJR5H5DY7CqOcHXfffele4EU+2zEZlFNmzZNz0cffXQYMmRI6pgeg8Lxxx+fQkccASuKw/bGoHHYYYeFSy65JK3jl7/8ZVp3DBoAAED1qHEB5Prrr0/Pu+22W5XpN998czjiiCPSz1deeWWoX79+ugFh7DgeR7i67rrrKpZt0KBBar51zDHHpGCy6qqrhoEDB4YLLrgg89EAAAC16j4g1cV9QABqFvcBgf/jPiBUt7K/DwgAAFA+BBAAACAbAQQAABBAAACA8qMGBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAKhdAeTFF18Mr732WsXr++67L/Tv3z+cddZZYc6cOaXYBAAAUAZKEkB+9rOfhbfffjv9/N5774WDDz44NGvWLNxxxx3h9NNPL8UmAACAMlCSABLDx+abb55+jqFjl112CbfffnsYOXJkuOuuu0qxCQAAoAyUJIAUCoWwYMGC9PMjjzwS9tlnn/Rzp06dwmeffVaKTQAAAGWgJAFk6623DhdddFG49dZbw+OPPx769euXpr///vuhffv2pdgEAABQBkoSQK666qrUEf24444LZ599dlh//fXT9DvvvDPsuOOOpdgEAABQBhqWYiWbbrpplVGwii699NLQoEGDUmwCAAAoAyW7D8i0adPCH/7whzB06NAwderUNO2NN94IU6ZMKdUmAACAWq4kNSCvvvpq6N27d2jVqlWYOHFiGDRoUGjdunW4++67wwcffBD++Mc/lmIzAABALVeSGpAhQ4aEI488MrzzzjthlVVWqZgeR8N64oknSrEJAACgDJQkgDz//PPpZoQLW2uttcLkyZNLsQkAAKAMlCSANGnSJMyYMWOxNyhs27ZtKTYBAACUgZIEkB/84AfhggsuCHPnzk2v69Wrl/p+nHHGGeGAAw4oxSYAAIAyUJIAcvnll4cvv/wytGvXLnz99ddh1113TfcCad68efjVr35Vik0AAABloCSjYLVs2TKMGjUqPP300+GVV15JYWTLLbcMffr0KcXqAQCAMlGSAFLUq1ev9AAAAFhpTbBOOOGEcPXVVy8y/be//W046aSTSrEJAACgDJQkgNx1112LrfnYcccdw5133lmKTQAAAGWgJAHk888/T/1AFtaiRYvw2WeflWITAABAGShJAIkjXj388MOLTH/ooYfCuuuuW4pNAAAAZaAkndCHDBkSjjvuuPDpp5+GPfbYI00bPXp0Gp73qquuKsUmAACAMlCSAHLUUUeF2bNnp3t+XHjhhWlaly5dwvXXXx8OP/zwUmwCAAAoAyUbhveYY45Jj1gL0rRp07DaaquVatUAAECZKOl9QKK2bduWepUAAECZKEkn9E8++SQcdthhoWPHjqFhw4ahQYMGVR4AAAAlqwE54ogjwgcffBDOOeecsOaaa4Z69eopXQAAYOUEkKeeeio8+eSTYfPNNy/F6gAAgDJVkiZYnTp1CoVCoRSrAgAAylhJAki818eZZ54ZJk6cWIrVAQAAZaokTbAOOuigMGvWrLDeeuuFZs2ahUaNGlWZP3Xq1FJsBgAAqOVKEkDc7RwAAMgWQAYOHFiK1QAAAGWuJH1AonfffTf88pe/DIccckiYMmVKmvbQQw+F119/vVSbAAAAarmSBJDHH3889OzZMzz33HPh7rvvDl9++WWa/sorr4TzzjuvFJsAAADKQEkCSBwB66KLLgqjRo0KjRs3rpi+xx57hGeffbYUmwAAAMpASQLIa6+9Fn74wx8uMr1du3bhs88+K8UmAACAMlCSANKqVaswadKkRaa/9NJLYa211irFJgAAgDJQkgBy8MEHhzPOOCNMnjw51KtXLyxYsCA8/fTT4dRTTw2HH354KTYBAACUgZIEkF//+tehe/fuoVOnTqkD+sYbbxx22WWXsOOOO6aRsQAAAEpyH5BCoZBqPq6++upw7rnnpv4gMYRsscUWoVu3bkoZAAAobQBZf/310/0+YuCItSAAAAArpQlW/fr1U/D4/PPPV3RVAABAmStJH5ARI0aE0047LYwbN64UqwMAAMrUCjfBiuJIV7NmzQqbbbZZuhFh06ZNq8yfOnVqKTYDAADUciUJIFdddVUpVgMAAJS5FQ4gc+fODY8//ng455xzQteuXUuzVwAAQFla4T4gjRo1CnfddVdp9gYAAChrJemE3r9//3DvvfeWYlUAAEAZK0kAicPwXnDBBeHAAw8Mw4cPTzclrPxYFk888UTYd999Q8eOHUO9evUWCTZHHHFEml75sddeey3S6X3AgAGhRYsWoVWrVuHoo49ON0cEAADKoBP6jTfemC70x44dmx6VxYBwwgknfOd1ffXVV2k0raOOOirsv//+i10mBo6bb7654nWTJk2qzI/hY9KkSWHUqFGpj8qRRx4ZBg8eHG6//fZlPjYAAKCGBZD3338/lMree++dHksTA0eHDh0WO2/8+PHh4YcfDs8//3zYeuut07Rrrrkm7LPPPuGyyy5LNSsAtU2XMx+s7l0AgJrTBCu3f/3rX6Fdu3Zhww03DMccc0yVu7CPGTMm1cYUw0fUp0+fdMf25557bonrnD17dpgxY0aVBwAAUANrQGJzqaW56aabQqnE5lexaVYc8vfdd98NZ511VqoxicGjQYMGYfLkySmcVNawYcPQunXrNG9JYt+VYcOGlWw/AQCAlRRAvvjiiyqvY7+LcePGhWnTpoU99tgjlNLBBx9c8XPPnj3DpptuGtZbb71UK9K7d+/lXu/QoUPDkCFDKl7HGpBOnTqt8P4CAAAlDiD33HPPItMWLFiQmkfFcLAyrbvuuqFNmzZhwoQJKYDEviFTpkypssy8efPSyFhL6jdS7FeycGd2AACglvQBiX0uYo3ClVdeGVamjz76KPUBWXPNNdPrHXbYIdW8VB6N69FHH02BaLvttlup+wIAAGSoAVmS2Ecj1j4si3i/jlibUXmErZdffjn14YiP2E/jgAMOSLUZcf2nn356WH/99UPfvn3T8htttFHqJzJo0KBwww03pOZgxx13XGq6ZQQsAAAogwBSue9EVCgU0n04HnzwwTBw4MBlWtcLL7wQdt9990XWHddz/fXXh1dffTXccsstqZYjBoo999wzXHjhhVWaT912220pdMQmWbEmJgaWZb0hIgAAUHr1CjEtrKDKgSGKF/1t27ZNHdDjCFlxFKraJnZCb9myZZg+fXq6ozpAdXIfEKBo4oh+CoNafZ1ckmTw2GOPlWI1AABAmStJJ/TYT+Odd95ZZHqcNnHixFJsAgAAKAMlCSBHHHFEeOaZZxaZHu88HucBAACULIC89NJLoVevXotM33777dMIVgAAACULIPXq1QszZ85cZHrsmDJ//nwlDQAAlC6A7LLLLmH48OFVwkb8OU7baaedSrEJAACgDJRkFKyLL744hZANN9ww7Lzzzmnak08+mYboinchBwAAKFkNyMYbb5xuEPjjH/84TJkyJTXHOvzww8Obb74ZevTooaQBAICkZHcIjHcl//Wvf12q1QEAAGWoJDUgN998c7jjjjsWmR6n3XLLLaXYBAAAUAZKEkBiZ/M2bdosMr1du3ZqRQAAgNIGkA8++CB07dp1kemdO3dO8wAAAEoWQGJNR+yEvrBXXnklrLHGGkoaAAAoXQA55JBDwgknnBAee+yxdP+P+IjD75544onh4IMPLsUmAACAMlCSUbAuvPDCMHHixNC7d+/QsOH/rXLBggVpKF4jYwEAACUNII0bNw5//etfUxCJza6aNm0aevbsmfqAAAAAlPw+IFHr1q3D7rvvvtgRsQAAAFa4D8i0adPCsccem0JH+/bt0yP+fNxxx6V5AAAAJakBmTp1athhhx3Cf//73zBgwICw0UYbpelvvPFGGDlyZBg9enR45plnwuqrr74imwEAAMrECgWQCy64IPX/ePfdd1PNx8Lz9txzz/R85ZVXruh+AgAAdb0J1r333hsuu+yyRcJH1KFDh3DJJZeEe+65Z0U2AQAAlJEVCiCTJk0Km2yyyRLn9+jRI0yePHlFNgEAAJSRFQogsbN5vP/Hkrz//vtpZCwAAIAVDiB9+/YNZ599dpgzZ84i82bPnh3OOeecsNdeeylpAACgNJ3Qt95669CtW7c0FG/37t1DoVAI48ePD9ddd10KIbfeeuuKbAIAACgjKxRA1l577TBmzJjwi1/8IgwdOjSFj6hevXrhe9/7Xvjtb38bOnXqVKp9BQAA6vqd0Lt27Roeeuih8MUXX4R33nknTVt//fX1/QAAAEofQIrizQa33XbbUq0OAAAoQyvUCR0AAGBZCCAAAEA2AggAAFDzA8iWW26ZOp4Xh+OdNWtWKfcLAAAoQ8sdQOK9Pr766qv087Bhw8KXX35Zyv0CAADK0HKPgrX55puHI488Muy0007p/h+XXXZZWG211Ra77Lnnnrsi+wgAANT1ADJy5Mhw3nnnhQceeCDdeDDeC6Rhw0VXF+cJIAAAwAoFkA033DD85S9/ST/Xr18/jB49OrRr106pAgAAK/dGhAsWLCjFagAAgDJXsjuhv/vuu+Gqq65KndOjjTfeOJx44olhvfXWK9UmAACAWq4k9wH5xz/+kQLHv//977Dpppumx3PPPRc22WSTMGrUqFJsAgAAKAMlqQE588wzw8knnxxGjBixyPQzzjgjfO973yvFZgAAgFquJDUgsdnV0Ucfvcj0o446Krzxxhul2AQAAFAGShJA2rZtG15++eVFpsdpRsYCAABK2gRr0KBBYfDgweG9994LO+64Y5r29NNPh4svvjgMGTKkFJsAAADKQEkCyDnnnBOaN28eLr/88jB06NA0rWPHjuH8888PJ5xwQik2AQAAlIGSBJB4t/PYCT0+Zs6cmabFQAIAALBS7gNSJHgAAAArtRM6AADAdyGAAAAA2QggAABA7Qkgc+fODb179w7vvPNOafYIAAAoWyscQBo1ahReffXV0uwNAABQ1krSBOvQQw8NN954YylWBQAAlLGSDMM7b968cNNNN4VHHnkkbLXVVmHVVVetMv+KK64oxWYAAIBariQBZNy4cWHLLbdMP7/99tuL3KQQAACgZAHkscceU5oAAEDeYXgnTJgQ/vGPf4Svv/46vS4UCqVcPQAAUMuVJIB8/vnnaSjeDTbYIOyzzz5h0qRJafrRRx8dTjnllFJsAgAAKAMlCSAnn3xyGo73gw8+CM2aNauYftBBB4WHH364FJsAAADKQEn6gPzzn/9MTa/WXnvtKtO7desW/vOf/5RiEwAAQBkoSQ3IV199VaXmo2jq1KmhSZMmpdgEAABQBkoSQHbeeefwxz/+scrQuwsWLAiXXHJJ2H333UuxCQAAoAyUpAlWDBqxE/oLL7wQ5syZE04//fTw+uuvpxqQp59+uhSbAAAAykBJakB69OiRbkC40047hf322y81ydp///3DSy+9FNZbb71SbAIAACgDJakBiVq2bBnOPvvsUq0OAAAoQyULIF988UW48cYbw/jx49PrjTfeOBx55JGhdevWpdoEAABQy5WkCdYTTzwRunTpEq6++uoUROIj/ty1a9c0DwAAoGQ1IMcee2y66eD1118fGjRokKbNnz8//OIXv0jzXnvtNaUNAACUpgZkwoQJ4ZRTTqkIH1H8eciQIWkeAABAyQLIlltuWdH3o7I4bbPNNlPSAADAijXBevXVVyt+PuGEE8KJJ56Yaju23377NO3ZZ58N1157bRgxYsTybgIAACgz9QqFQmF53li/fv10x/Nve3tcJvYHqW1mzJiRhhaePn16aNGiRXXvDlDHdTnzwereBaCGmDiiX3XvAnXcjBW8Tl7uGpD3339/ed8KAADUUcsdQDp37lzaPQEAAMpeyW5E+PHHH4ennnoqTJkyJSxYsKDKvNhHBAAAoCQBZOTIkeFnP/tZaNy4cVhjjTVSv4+i+LMAAgAAlCyAnHPOOeHcc88NQ4cOTZ3TAQAAFqckaWHWrFnh4IMPFj4AAICVH0COPvrocMcdd5RiVQAAQBkrSROs4cOHh+9///vh4YcfDj179gyNGjWqMv+KK64oxWYAAIBarmQB5B//+EfYcMMN0+uFO6EDAACULIBcfvnl4aabbgpHHHGEUgUAAFZuH5AmTZqEXr16KWYAAGDlB5ATTzwxXHPNNaVYFQAAUMZK0gTr3//+d3j00UfDAw88EDbZZJNFOqHffffdpdgMAABQy5WkBqRVq1Zh//33D7vuumto06ZNaNmyZZXHsnjiiSfCvvvuGzp27Jg6sN97771V5hcKhXTTwzXXXDM0bdo09OnTJ7zzzjtVlpk6dWoYMGBAaNGiRdq3OEzwl19+WYpDBQAAqrsG5Oabbw6l8tVXX4XNNtssHHXUUSnULOySSy4JV199dbjllltC165d013Y+/btG954442wyiqrpGVi+Jg0aVIYNWpUmDt3bjjyyCPD4MGDw+23316y/QQAAKopgJTS3nvvnR6LE2s/rrrqqvDLX/4y7LfffmnaH//4x9C+fftUUxLvxj5+/Ph0P5Lnn38+bL311mmZ2D9ln332CZdddlmqWQEAAGpxAIk1EUu738d7771Xis2E999/P0yePDk1uyqKTby22267MGbMmBRA4nNsdlUMH1Fcvn79+uG5554LP/zhDxe77tmzZ6dH0YwZM0qyzwAAQIkDyEknnVTldWz29NJLL6WaiNNOOy2USgwfUazxqCy+Ls6Lz+3atasyv2HDhqF169YVyyzpZorDhg0r2b4CAAArKYDEYXgX59prrw0vvPBCqA2GDh0ahgwZUqUGpFOnTtW6TwAAUG5KMgrWksS+HHfddVfJ1tehQ4f0/Mknn1SZHl8X58XnKVOmVJk/b968NDJWcZkl3UwxjppV+QEAANSiAHLnnXempk+lEvuaxBAxevToKjUVsW/HDjvskF7H52nTpoWxY8dWLBPvUbJgwYLUVwQAAKjlTbC22GKLKp3Q42hVsb/Fp59+Gq677rplWle8X8eECROqdDx/+eWXU5BZZ511Un+Tiy66KHTr1q1iGN44slX//v3T8htttFHYa6+9wqBBg8INN9yQ+qMcd9xxqYO6EbAAAKAMAkjx4r8ojjjVtm3bsNtuu4Xu3bsv07pin5Hdd9+94nWxX8bAgQPDyJEjw+mnn57uFRLv6xFrOnbaaafU2b14D5DotttuS6Gjd+/eaV8OOOCAdO8QAACgetUrxOoKFhGbdsUhfqdPn64/CFDtupz5YHXvAlBDTBzRr7p3gTpuxgpeJ6/UPiAAAAAla4IVmzct7QaEUZwfR6ECAABYoQByzz33LHFevCN57HcRR58CAABY4QCy3377LTLtrbfeCmeeeWa4//77w4ABA8IFF1ygpAEAgNL2Afn444/T0Lc9e/ZMTa7i0Lm33HJL6Ny5c6k2AQAA1PUAEnu/n3HGGWH99dcPr7/+erpJYKz96NGjR2n2EAAAKBsr1ATrkksuCRdffHG6O/mf//znxTbJAgAAKMl9QOIoWE2bNg19+vQJDRo0WOJyd999d6ht3AcEqEncBwQoch8Qavt18grVgBx++OHfOgwvAABASQLIyJEjV+TtAABAHeNO6AAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAACAAAIAAJQfNSAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZNMy3KQAAVlSXMx+s84U4cUS/Ol8GtZkaEAAAIBsBBAAAyEYAAQAAshFAAACAbHRCB2o8HS4BoHyoAQEAALIRQAAAgGxqXQA5//zzQ7169ao8unfvXjH/m2++Cccee2xYY401wmqrrRYOOOCA8Mknn1TrPgMAALU0gESbbLJJmDRpUsXjqaeeqph38sknh/vvvz/ccccd4fHHHw8ff/xx2H///at1fwEAgFrcCb1hw4ahQ4cOi0yfPn16uPHGG8Ptt98e9thjjzTt5ptvDhtttFF49tlnw/bbb18NewsAANTqGpB33nkndOzYMay77rphwIAB4YMPPkjTx44dG+bOnRv69OlTsWxsnrXOOuuEMWPGVOMeAwAAtbIGZLvttgsjR44MG264YWp+NWzYsLDzzjuHcePGhcmTJ4fGjRuHVq1aVXlP+/bt07ylmT17dnoUzZgxY6UdAwAA1FW1LoDsvffeFT9vuummKZB07tw5/O1vfwtNmzZd7vUOHz48hRkAAGDlqZVNsCqLtR0bbLBBmDBhQuoXMmfOnDBt2rQqy8RRsBbXZ6SyoUOHpj4kxceHH364kvccAADqnlofQL788svw7rvvhjXXXDNstdVWoVGjRmH06NEV8996663UR2SHHXZY6nqaNGkSWrRoUeUBAADU8SZYp556ath3331Ts6s4xO55550XGjRoEA455JDQsmXLcPTRR4chQ4aE1q1bpxBx/PHHp/BhBCwAAKh+tS6AfPTRRylsfP7556Ft27Zhp512SkPsxp+jK6+8MtSvXz/dgDB2Ku/bt2+47rrrqnu3AQCAEEK9QqFQUBKLiqNgxRqV2B9EcyyoXl3OfNBHAECFiSP6KY1afJ1c6/uAAAAAtYcAAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYN820KWB5dznxQwQEAZUMNCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQTcN8m4Jl1+XMBxUbAEAZUQMCAABkowYEAIBaRQuJECaO6BdqKzUgAABANgIIAACQjQACAABkI4AAAADZlHUn9GuvvTZceumlYfLkyWGzzTYL11xzTdh2221DbaGDFQAA5aZsa0D++te/hiFDhoTzzjsvvPjiiymA9O3bN0yZMqW6dw0AAOqssg0gV1xxRRg0aFA48sgjw8YbbxxuuOGG0KxZs3DTTTdV964BAECdVZZNsObMmRPGjh0bhg4dWjGtfv36oU+fPmHMmDGLfc/s2bPTo2j69OnpecaMGaG6LJg9q9q2DQBAzTWjGq9Ri9suFArL9f6yDCCfffZZmD9/fmjfvn2V6fH1m2++udj3DB8+PAwbNmyR6Z06dVpp+wkAAMuj5VWh2s2cOTO0bNlymd9XlgFkecTakthnpGjBggVh6tSpYY011gj16tULNU1MnjEcffjhh6FFixbVvTu1jvJTfs692snvrvJz7tVOfnfLq/wKhUIKHx07dlyu95dlAGnTpk1o0KBB+OSTT6pMj687dOiw2Pc0adIkPSpr1apVqOniSVgTTsTaSvkpP+de7eR3V/k592onv7vlU37LU/NR1p3QGzduHLbaaqswevToKjUa8fUOO+xQrfsGAAB1WVnWgESxOdXAgQPD1ltvne79cdVVV4WvvvoqjYoFAABUj7INIAcddFD49NNPw7nnnptuRLj55puHhx9+eJGO6bVVbC4W73GycLMxlJ/zr2bzu6v8nH+1k99d5ef8K516heUdPwsAAGAZlWUfEAAAoGYSQAAAgGwEEAAAIBsBBAAAyEYAqUZPPPFE2HfffdNdJOPd1u+9994q8+P4AHEUrzXXXDM0bdo09OnTJ7zzzjtVlol3ax8wYEC6KU28ceLRRx8dvvzyyyrLvPrqq2HnnXcOq6yySrqL5iWXXBLqQvkdccQRaXrlx1577VVlmbpafsOHDw/bbLNNaN68eWjXrl3o379/eOutt6os880334Rjjz02rLHGGmG11VYLBxxwwCI39/zggw9Cv379QrNmzdJ6TjvttDBv3rwqy/zrX/8KW265ZRpBZv311w8jR44MdaH8dtttt0XOv5///OdVlqmr5Xf99deHTTfdtOKGWvH+TA899FDFfOfe8ped827ZjBgxIv1unnTSSc6/EpSd82/Jzj///EX+T+jevXvdPe/iKFhUj7///e+Fs88+u3D33XfHkcgK99xzT5X5I0aMKLRs2bJw7733Fl555ZXCD37wg0LXrl0LX3/9dcUye+21V2GzzTYrPPvss4Unn3yysP766xcOOeSQivnTp08vtG/fvjBgwIDCuHHjCn/+858LTZs2Lfzud78rlHv5DRw4MJXPpEmTKh5Tp06tskxdLb++ffsWbr755nRML7/8cmGfffYprLPOOoUvv/yyYpmf//znhU6dOhVGjx5deOGFFwrbb799Yccdd6yYP2/evEKPHj0Kffr0Kbz00kvp82jTpk1h6NChFcu89957hWbNmhWGDBlSeOONNwrXXHNNoUGDBoWHH364UO7lt+uuuxYGDRpU5fyL51NRXS6///3f/y08+OCDhbfffrvw1ltvFc4666xCo0aNUnlGzr3lLzvn3Xf373//u9ClS5fCpptuWjjxxBMrpjv/lr/snH9Ldt555xU22WSTKv8nfPrpp3X2vBNAaoiFL6AXLFhQ6NChQ+HSSy+tmDZt2rRCkyZN0kVwFE+u+L7nn3++YpmHHnqoUK9evcJ///vf9Pq6664rrL766oXZs2dXLHPGGWcUNtxww0I5WVIA2W+//Zb4HuX3/0yZMiWV4eOPP15xrsWLmjvuuKNimfHjx6dlxowZk17HP37169cvTJ48uWKZ66+/vtCiRYuK8+30009Pf3ArO+igg9IFfDmXX/E/4sr/MS9M+VUV/0794Q9/cO6tQNk57767mTNnFrp161YYNWpUld9Vf/uWv+ycf98eQOIXnoszrQ7+n6sJVg31/vvvpxsoxmZXRS1btgzbbbddGDNmTHodn2OzoXi396K4fP369cNzzz1Xscwuu+wSGjduXLFM3759U3ORL774IpS7WBUZqyk33HDDcMwxx4TPP/+8Yp7y+3+mT5+enlu3bp2ex44dG+bOnVvl/ItVxeuss06V869nz55Vbu4Zz60ZM2aE119/vWKZyusoLlNcR7mWX9Ftt90W2rRpE3r06BGGDh0aZs2aVTFP+f2f+fPnh7/85S/hq6++Ss2JnHvLX3bOu+8uNnWJTVkW/vvk/Fv+snP+fbvYjD42G1933XVT8+/YpKqunndleyf02i6Gj2jhO7fH18V58TleXFfWsGHDdBFUeZmuXbsuso7ivNVXXz2Uq9jfY//990/H/+6774azzjor7L333ukXsUGDBsrv/7dgwYLUhrdXr17pQrl4bsTQGgPu0s6/xZ2fxXlLWyb+wfz6669T36ZyLL/oJz/5SejcuXP6zyb2IzrjjDNS8L/77rvT/Lpefq+99lq6aI7tnmN753vuuSdsvPHG4eWXX3buLWfZRc67bxdD24svvhief/75Reb527f8Zef8W7r4BXLsjxG/EJ00aVIYNmxY6l86bty4OnneCSCUrYMPPrji5/itQey4ud5666Vakd69e1frvtW0b7PiH8CnnnqqunelrMpv8ODBVc6/OJhEPO9iGI7nYV0X/xOOYSPWHt15551h4MCB4fHHH6/u3arVZRdDiPNu6T788MNw4oknhlGjRqWBRSht2Tn/lix+AVq06aabpkASv6T629/+VqOCQS6aYNVQHTp0SM8Lj4AQXxfnxecpU6ZUmR9HQ4gjO1VeZnHrqLyNuiJWecbmMBMmTEivlV8Ixx13XHjggQfCY489FtZee+2KsoplM2fOnDBt2rSlnn/fdm4taZk4ek85/MFdUvktTvzPJqp8/tXl8ovf9sURWrbaaqs0qthmm20WfvOb3zj3VqDsFsd5V1Vs6hL/34yjBMUWA/ERw9vVV1+dfo7fFvvbt3xlF5sEOv++u1atWoUNNtgg/Z9QF//PFUBqqNhsKJ5Io0ePrpgWq9Bi345iW9/4HE/W+Eeh6NFHH01NQor/6cRl4nC1sW1hUfz2In6DVs7Nrxbno48+Sn1A4jfRdb38Yr/9ePEcm27EY164mV68sGnUqFGV8y82H4rtVSuff7EpSOUQHMsm/qErNgeJy1ReR3GZyu3Vy7H8Fid+Yx1VPv/qavktTvy9mz17tnNvBcpucZx3VcVayPh7F8ul+Ij9KGN7/OLP/vYtX9nFps3Ov+/uyy+/TDXi8f+EOvl/bnX3gq/L4kgScSi1+IgfxRVXXJF+/s9//lMxDG+rVq0K9913X+HVV19NIzotbhjeLbbYovDcc88VnnrqqTQyReVhZOPICnEY2cMOOywN0/iXv/wlDdFW24eR/bbyi/NOPfXUNHrE+++/X3jkkUcKW265ZSqfb775plDXy++YY45JQzz/61//qjIk4KxZs6oMCRiHln300UfTkIA77LBDeiw8JOCee+6ZhqKNw/y1bdt2sUMCnnbaaWlEj2uvvbbGDglYyvKbMGFC4YILLkjlFs+/+Du87rrrFnbZZZeKddTl8jvzzDPTiGGxbOLftvg6jt73z3/+M8137i1f2Tnvls/CIzk5/5av7Jx/S3fKKaek/zPi7+7TTz+dhtONw+jGURTr4nkngFSjxx57LF04L/yIw8cWh+I955xz0gVwHH63d+/eadz3yj7//PN0wbzaaqulodiOPPLIdPFdWbyHyE477ZTWsdZaa6VgU+7lFy8E4y9p/OWMQ9t17tw53ZOh8vB1dbn8Fldu8RHvbVEUg+4vfvGLNMRn/IP2wx/+MF1kVzZx4sTC3nvvne6NEv+Qxj+wc+fOXeRz2nzzzQuNGzdOF+GVt1Gu5ffBBx+ksNG6det03sT7y8T/ECrfB6Qul99RRx2VfifjMcXf0fi3rRg+Iufe8pWd8640AcT5t3xl5/xbujgc7pprrpl+d9daa630Ooa2unre1Yv/VHctDAAAUDfoAwIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAhFz+PzZ9lwR7+8zbAAAAAElFTkSuQmCC", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -948,9 +1114,24 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGzCAYAAADJ3dZzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA7iklEQVR4nO3deVyU5f7/8feAgLgAogJSqKTmvpSWomYW5HoqT7boMQGzPBXmgplauZeYLXoss9M5pZ2ObWbZSRPD5atlpLngnrtRKm4IiBoCc/3+6MH8nFBjZEbw7vV8POYRc93X3PO55zJ5e93XfY/NGGMEAABgUV5lXQAAAIAnEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXaAcqpu3bqKj48v6zIs7+WXX9YNN9wgb29vtWrVqqzLAeABhB3gKpg7d65sNpvWr19/0e2dO3dWs2bNSv0+X331lSZMmFDq/fxZfP3113rmmWfUoUMHzZkzR1OmTCnrkgB4QIWyLgDAxe3atUteXq79e+Srr77SrFmzCDwltGLFCnl5eemdd96Rr69vWZcDwEOY2QHKKT8/P/n4+JR1GS45c+ZMWZfgkmPHjsnf35+gA1gcYQcop36/Zic/P18TJ05UgwYNVLFiRVWvXl0dO3ZUSkqKJCk+Pl6zZs2SJNlsNsejyJkzZzRixAhFRETIz89PDRs21CuvvCJjjNP7njt3TkOGDFGNGjVUtWpV3XPPPTp06JBsNpvTjNGECRNks9m0Y8cO/e1vf1O1atXUsWNHSdKWLVsUHx+vG264QRUrVlRYWJgeeeQRnTx50um9ivaxe/duPfzwwwoMDFTNmjU1duxYGWP0888/695771VAQIDCwsL06quvluizKygo0OTJk1WvXj35+fmpbt26evbZZ5WXl+foY7PZNGfOHJ05c8bxWc2dO/eS+/zmm2/0wAMPqHbt2vLz81NERISGDx+uc+fOOfWLj49XlSpVtH//fnXt2lWVK1dWeHi4Jk2aVOyzdveYSNKhQ4f0yCOPKDQ0VH5+fmratKnefffdYseTl5en8ePHq379+o7jeeaZZ5w+oz8yZ84c2Ww2bdq0qdi2KVOmyNvbW4cOHSrx/gBP4TQWcBVlZ2frxIkTxdrz8/P/8LUTJkxQUlKSHn30Ud16663KycnR+vXrtXHjRt111136+9//rsOHDyslJUXvv/++02uNMbrnnnu0cuVKDRw4UK1atdLSpUs1cuRIHTp0SNOnT3f0jY+P1yeffKL+/furXbt2WrVqlXr27HnJuh544AE1aNBAU6ZMcfySTklJ0f79+zVgwACFhYVp+/btevvtt7V9+3Z9//33TiFMkh566CE1btxYU6dO1eLFi/XCCy8oODhY//znP3XnnXfqpZde0rx58/T000/rlltuUadOnS77WT366KN67733dP/992vEiBFau3atkpKStHPnTn3++eeSpPfff19vv/221q1bp3//+9+SpPbt219yn/Pnz9fZs2f1xBNPqHr16lq3bp1ef/11/fLLL5o/f75T38LCQnXr1k3t2rXTtGnTlJycrPHjx6ugoECTJk3y2JgcPXpU7dq1k81m0+DBg1WzZk0tWbJEAwcOVE5OjoYNGyZJstvtuueee/Ttt99q0KBBaty4sbZu3arp06dr9+7dWrhw4WU/3yL333+/EhISNG/ePN10001O2+bNm6fOnTvruuuuK9G+AI8yADxuzpw5RtJlH02bNnV6TZ06dUxcXJzjecuWLU3Pnj0v+z4JCQnmYv9bL1y40EgyL7zwglP7/fffb2w2m9m7d68xxpgNGzYYSWbYsGFO/eLj440kM378eEfb+PHjjSTTt2/fYu939uzZYm0ffvihkWRWr15dbB+DBg1ytBUUFJjrr7/e2Gw2M3XqVEf7qVOnjL+/v9NncjFpaWlGknn00Ued2p9++mkjyaxYscLRFhcXZypXrnzZ/V3umJKSkozNZjM//fST0z4lmaeeesrRZrfbTc+ePY2vr685fvy4McYzYzJw4EBTq1Ytc+LECae+ffr0MYGBgY5jeP/9942Xl5f55ptvnPq99dZbRpJZs2ZNiT4TY4zp27evCQ8PN4WFhY62jRs3Gklmzpw5Jd4P4EmcxgKuolmzZiklJaXYo0WLFn/42qCgIG3fvl179uxx+X2/+uoreXt7a8iQIU7tI0aMkDFGS5YskSQlJydLkp588kmnfk899dQl9/34448Xa/P393f8/Ouvv+rEiRNq166dJGnjxo3F+j/66KOOn729vdWmTRsZYzRw4EBHe1BQkBo2bKj9+/dfshbpt2OVpMTERKf2ESNGSJIWL1582ddfyoXHdObMGZ04cULt27eXMeaip3EGDx7s+LlopuX8+fNatmyZo053jokxRgsWLNDdd98tY4xOnDjheHTt2lXZ2dmOz37+/Plq3LixGjVq5NTvzjvvlCStXLmyxJ9LbGysDh8+7PSaefPmyd/fX7179y7xfgBP4jQWcBXdeuutatOmTbH2atWqXfT01oUmTZqke++9VzfeeKOaNWumbt26qX///iUKSj/99JPCw8NVtWpVp/bGjRs7thf918vLS5GRkU796tevf8l9/76vJGVmZmrixIn66KOPdOzYMadt2dnZxfrXrl3b6XlgYKAqVqyoGjVqFGv//bqf3ys6ht/XHBYWpqCgIMexuio9PV3jxo3T//73P506dcpp2++PycvLSzfccINT24033ihJOnjwoKNOd47J8ePHlZWVpbfffltvv/32RY+haCz27NmjnTt3qmbNmpftVxJ33XWXatWqpXnz5ik6Olp2u10ffvih7r333mLHBpQVwg5wjejUqZP27dunL774Ql9//bX+/e9/a/r06XrrrbecZkautgtnPIo8+OCD+u677zRy5Ei1atVKVapUkd1uV7du3WS324v19/b2LlGbpGKLdy/l9+uCSqOwsFB33XWXMjMzNWrUKDVq1EiVK1fWoUOHFB8ff9FjutqKanj44YcVFxd30T5Fwdhut6t58+Z67bXXLtovIiKixO/r7e2tv/3tb/rXv/6lN998U2vWrNHhw4f18MMPu3gEgOcQdoBrSHBwsAYMGKABAwYoNzdXnTp10oQJExxh51K/4OvUqaNly5bp9OnTTv/a/vHHHx3bi/5rt9t14MABNWjQwNFv7969Ja7x1KlTWr58uSZOnKhx48Y52q/k9NuVKDqGPXv2OGZJpN8W72ZlZTmO1RVbt27V7t279d577yk2NtbRXnQl3O/Z7Xbt37/fMZsjSbt375b021V2RXW6c0xq1qypqlWrqrCwUDExMZc9nnr16mnz5s2Kjo52SyiMjY3Vq6++qi+//FJLlixRzZo11bVr11LvF3AX1uwA14jfn76pUqWK6tev73SpcOXKlSVJWVlZTn179OihwsJCvfHGG07t06dPl81mU/fu3SXJ8QvqzTffdOr3+uuvl7jOohmZ38/AzJgxo8T7KI0ePXpc9P2KZjEud2XZpVzsmIwx+sc//nHJ11z4WRtj9MYbb8jHx0fR0dGOOt05Jt7e3urdu7cWLFigbdu2Favn+PHjjp8ffPBBHTp0SP/617+K9Tt37pzL90tq0aKFWrRooX//+99asGCB+vTpowoV+Lc0yg/+NALXiCZNmqhz585q3bq1goODtX79en366adOC2Fbt24tSRoyZIi6du0qb29v9enTR3fffbfuuOMOPffcczp48KBatmypr7/+Wl988YWGDRumevXqOV7fu3dvzZgxQydPnnRc5lw0K1GSWYCAgAB16tRJ06ZNU35+vq677jp9/fXXOnDggAc+leJatmypuLg4vf3228rKytLtt9+udevW6b333lOvXr10xx13uLzPRo0aqV69enr66ad16NAhBQQEaMGCBcXW7hSpWLGikpOTFRcXp7Zt22rJkiVavHixnn32Wcc6GU+MydSpU7Vy5Uq1bdtWjz32mJo0aaLMzExt3LhRy5YtU2ZmpiSpf//++uSTT/T4449r5cqV6tChgwoLC/Xjjz/qk08+0dKlSy+6tuxyYmNj9fTTT0sSp7BQ/pTRVWDAn0rRpec//PDDRbfffvvtf3jp+QsvvGBuvfVWExQUZPz9/U2jRo3Miy++aM6fP+/oU1BQYJ566ilTs2ZNY7PZnC5DP336tBk+fLgJDw83Pj4+pkGDBubll182drvd6X3PnDljEhISTHBwsKlSpYrp1auX2bVrl5HkdCl40WXjRZdSX+iXX34xf/3rX01QUJAJDAw0DzzwgDl8+PAlL1///T4udUn4xT6ni8nPzzcTJ040kZGRxsfHx0RERJgxY8aYX3/9tUTvczE7duwwMTExpkqVKqZGjRrmscceM5s3by52iXXRPvft22e6dOliKlWqZEJDQ8348eOdLs82xv1jYowxR48eNQkJCSYiIsL4+PiYsLAwEx0dbd5++22nfufPnzcvvfSSadq0qfHz8zPVqlUzrVu3NhMnTjTZ2dkl+kwudOTIEePt7W1uvPFGl18LeJrNmBKu9gPwp5WWlqabbrpJ//3vf9WvX7+yLqdci4+P16effqrc3FyPvk95G5MTJ06oVq1aGjdunMaOHVvW5QBOWLMDwMnvv/5A+m39i5eX1x/euRiecS2Mydy5c1VYWKj+/fuXdSlAMazZAeBk2rRp2rBhg+644w5VqFBBS5Ys0ZIlSzRo0CCXLkmG+5TFmGRnZ180ZF0oLCxMK1as0I4dO/Tiiy+qV69ejqvNgPKEsAPASfv27ZWSkqLJkycrNzdXtWvX1oQJE/Tcc8+VdWl/WmUxJkOHDtV777132T7GGE2aNEnfffedOnTo4NJVe8DVxJodAEAxO3bs0OHDhy/b54/u5wOUF4QdAABgaSxQBgAAlsaaHf12a/fDhw+ratWqbv0+HQAA4DnGGJ0+fVrh4eHy8rr0/A1hR9Lhw4e5ygQAgGvUzz//rOuvv/6S2wk7kuNL+H7++WcFBASUcTUAAKAkcnJyFBER4fRluhdD2NH//26ZgIAAwg4AANeYP1qCwgJlAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaYQdAABgaRXKugAAQHF1Ry8u6xJcdnBqz7IuAbgoZnYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAIClEXYAAICllWnYSUpK0i233KKqVasqJCREvXr10q5du5z6dO7cWTabzenx+OOPO/VJT09Xz549ValSJYWEhGjkyJEqKCi4mocCAADKqQpl+earVq1SQkKCbrnlFhUUFOjZZ59Vly5dtGPHDlWuXNnR77HHHtOkSZMczytVquT4ubCwUD179lRYWJi+++47HTlyRLGxsfLx8dGUKVOu6vEAAIDyp0zDTnJystPzuXPnKiQkRBs2bFCnTp0c7ZUqVVJYWNhF9/H1119rx44dWrZsmUJDQ9WqVStNnjxZo0aN0oQJE+Tr6+vRYwBQ/tUdvbisSwBQhsrVmp3s7GxJUnBwsFP7vHnzVKNGDTVr1kxjxozR2bNnHdtSU1PVvHlzhYaGOtq6du2qnJwcbd++/aLvk5eXp5ycHKcHAACwpjKd2bmQ3W7XsGHD1KFDBzVr1szR/re//U116tRReHi4tmzZolGjRmnXrl367LPPJEkZGRlOQUeS43lGRsZF3yspKUkTJ0700JEAAIDypNyEnYSEBG3btk3ffvutU/ugQYMcPzdv3ly1atVSdHS09u3bp3r16l3Re40ZM0aJiYmO5zk5OYqIiLiywgEAQLlWLk5jDR48WIsWLdLKlSt1/fXXX7Zv27ZtJUl79+6VJIWFheno0aNOfYqeX2qdj5+fnwICApweAADAmso07BhjNHjwYH3++edasWKFIiMj//A1aWlpkqRatWpJkqKiorR161YdO3bM0SclJUUBAQFq0qSJR+oGAADXjjI9jZWQkKAPPvhAX3zxhapWrepYYxMYGCh/f3/t27dPH3zwgXr06KHq1atry5YtGj58uDp16qQWLVpIkrp06aImTZqof//+mjZtmjIyMvT8888rISFBfn5+ZXl4AACgHCjTmZ3Zs2crOztbnTt3Vq1atRyPjz/+WJLk6+urZcuWqUuXLmrUqJFGjBih3r1768svv3Tsw9vbW4sWLZK3t7eioqL08MMPKzY21um+PAAA4M+rTGd2jDGX3R4REaFVq1b94X7q1Kmjr776yl1lAQAACykXC5QBAAA8hbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAszeWws3HjRm3dutXx/IsvvlCvXr307LPP6vz5824tDgAAoLRcDjt///vftXv3bknS/v371adPH1WqVEnz58/XM8884/YCAQAASsPlsLN79261atVKkjR//nx16tRJH3zwgebOnasFCxa4uz4AAIBScTnsGGNkt9slScuWLVOPHj0kSRERETpx4oR7qwMAACgll8NOmzZt9MILL+j999/XqlWr1LNnT0nSgQMHFBoa6vYCAQAASsPlsDNjxgxt3LhRgwcP1nPPPaf69etLkj799FO1b9/epX0lJSXplltuUdWqVRUSEqJevXpp165dTn1+/fVXJSQkqHr16qpSpYp69+6to0ePOvVJT09Xz549ValSJYWEhGjkyJEqKChw9dAAAIAFVXD1BS1atHC6GqvIyy+/LG9vb5f2tWrVKiUkJOiWW25RQUGBnn32WXXp0kU7duxQ5cqVJUnDhw/X4sWLNX/+fAUGBmrw4MG67777tGbNGklSYWGhevbsqbCwMH333Xc6cuSIYmNj5ePjoylTprh6eAAAwGJsxhjj6ouysrL06aefat++fRo5cqSCg4O1ceNGhYaG6rrrrrviYo4fP66QkBCtWrVKnTp1UnZ2tmrWrKkPPvhA999/vyTpxx9/VOPGjZWamqp27dppyZIl+stf/qLDhw87TqO99dZbGjVqlI4fPy5fX98/fN+cnBwFBgYqOztbAQEBV1w/gPKp7ujFZV3Cn8LBqT3LugT8yZT097fLp7G2bNmiBg0a6KWXXtIrr7yirKwsSdJnn32mMWPGXHHBkpSdnS1JCg4OliRt2LBB+fn5iomJcfRp1KiRateurdTUVElSamqqmjdv7rReqGvXrsrJydH27dsv+j55eXnKyclxegAAAGtyOewkJiZqwIAB2rNnjypWrOho79Gjh1avXn3Fhdjtdg0bNkwdOnRQs2bNJEkZGRny9fVVUFCQU9/Q0FBlZGQ4+vx+YXTR86I+v5eUlKTAwEDHIyIi4orrBgAA5ZvLYeeHH37Q3//+92Lt11133SXDRUkkJCRo27Zt+uijj654HyU1ZswYZWdnOx4///yzx98TAACUDZcXKPv5+V30tM/u3btVs2bNKypi8ODBWrRokVavXq3rr7/e0R4WFqbz588rKyvLaXbn6NGjCgsLc/RZt26d0/6KrtYq6nOxY/Dz87uiWgEAwLXF5Zmde+65R5MmTVJ+fr4kyWazKT09XaNGjVLv3r1d2pcxRoMHD9bnn3+uFStWKDIy0ml769at5ePjo+XLlzvadu3apfT0dEVFRUmSoqKitHXrVh07dszRJyUlRQEBAWrSpImrhwcAACzG5bDz6quvKjc3VyEhITp37pxuv/121a9fX1WrVtWLL77o0r4SEhL03//+Vx988IGqVq2qjIwMZWRk6Ny5c5KkwMBADRw4UImJiVq5cqU2bNigAQMGKCoqSu3atZMkdenSRU2aNFH//v21efNmLV26VM8//7wSEhKYvQEAAK6fxgoMDFRKSorWrFmjzZs3Kzc3VzfffLPTFVMlNXv2bElS586dndrnzJmj+Ph4SdL06dPl5eWl3r17Ky8vT127dtWbb77p6Ovt7a1FixbpiSeeUFRUlCpXrqy4uDhNmjTJ5XoAAID1XNF9dqyG++wA1sZ9dq4O7rODq81j99kZMmSIZs6cWaz9jTfe0LBhw1zdHQAAgEe5HHYWLFigDh06FGtv3769Pv30U7cUBQAA4C4uh52TJ08qMDCwWHtAQIBOnDjhlqIAAADcxeWwU79+fSUnJxdrX7JkiW644Qa3FAUAAOAuLl+NlZiYqMGDB+v48eO68847JUnLly/Xq6++qhkzZri7PgAAgFJxOew88sgjysvL04svvqjJkydLkurWravZs2crNjbW7QUCAACUhsthR5KeeOIJPfHEEzp+/Lj8/f1VpUoVd9cFAADgFlcUdopc6XdhAQAAXC0uL1A+evSo+vfvr/DwcFWoUEHe3t5ODwAAgPLE5Zmd+Ph4paena+zYsapVq5ZsNpsn6gIAAHALl8POt99+q2+++UatWrXyQDkAAADu5fJprIiICPF1WgAA4FrhctiZMWOGRo8erYMHD3qgHAAAAPdy+TTWQw89pLNnz6pevXqqVKmSfHx8nLZnZma6rTgAAIDScjnscJdkAABwLXE57MTFxXmiDgAAAI9wec2OJO3bt0/PP/+8+vbtq2PHjkn67YtAt2/f7tbiAAAASsvlsLNq1So1b95ca9eu1Weffabc3FxJ0ubNmzV+/Hi3FwgAAFAaLoed0aNH64UXXlBKSop8fX0d7Xfeeae+//57txYHAABQWi6Hna1bt+qvf/1rsfaQkBCdOHHCLUUBAAC4i8thJygoSEeOHCnWvmnTJl133XVuKQoAAMBdXA47ffr00ahRo5SRkSGbzSa73a41a9bo6aefVmxsrCdqBAAAuGIuh50pU6aoUaNGioiIUG5urpo0aaJOnTqpffv2ev755z1RIwAAwBVz6T47xhhlZGRo5syZGjdunLZu3arc3FzddNNNatCggadqBAAAuGIuh5369etr+/btatCggSIiIjxVFwAAgFu4dBrLy8tLDRo00MmTJz1VDwAAgFu5vGZn6tSpGjlypLZt2+aJegAAANzK5e/Gio2N1dmzZ9WyZUv5+vrK39/faTvfeg4AAMoTvvUcAABYmkthJz8/X6tWrdLYsWMVGRnpqZoAAADcxqU1Oz4+PlqwYIGnagEAAHA7lxco9+rVSwsXLvRAKQAAAO7n8pqdBg0aaNKkSVqzZo1at26typUrO20fMmSI24oDAAAoLZfDzjvvvKOgoCBt2LBBGzZscNpms9kIOwAAoFxxOewcOHDAE3UAAAB4hMtrdgAAAK4lLs/sPPLII5fd/u67715xMQAAAO7mctg5deqU0/P8/Hxt27ZNWVlZuvPOO91WGAAAgDu4HHY+//zzYm12u11PPPGE6tWr55aiAAAA3MVmjDHu2NGuXbvUuXNnHTlyxB27u6pycnIUGBio7OxsBQQElHU5ANys7ujFZV0CyqmDU3uWdQkohZL+/nbbAuV9+/apoKDAXbsDAABwC5dPYyUmJjo9N8boyJEjWrx4seLi4txWGAAAgDu4HHY2bdrk9NzLy0s1a9bUq6+++odXagEAAFxtLoedlStXeqIOAAAAj3B5zc6BAwe0Z8+eYu179uzRwYMH3VETAACA27gcduLj4/Xdd98Va1+7dq3i4+PdURMAAIDbuBx2Nm3apA4dOhRrb9eundLS0txREwAAgNu4vGbHZrPp9OnTxdqzs7NVWFjolqIAlF/cswbAtcblmZ1OnTopKSnJKdgUFhYqKSlJHTt2dGtxAAAApeXyzM5LL72kTp06qWHDhrrtttskSd98841ycnK0YsUKtxcIAABQGi7P7DRp0kRbtmzRgw8+qGPHjun06dOKjY3Vjz/+qGbNmnmiRgAAgCvm8syOJIWHh2vKlCnurgUAAMDtXJ7ZmTNnjubPn1+sff78+XrvvffcUhQAAIC7uBx2kpKSVKNGjWLtISEhLs/2rF69WnfffbfCw8Nls9m0cOFCp+3x8fGy2WxOj27dujn1yczMVL9+/RQQEKCgoCANHDhQubm5rh4WAACwKJfDTnp6uiIjI4u116lTR+np6S7t68yZM2rZsqVmzZp1yT7dunXTkSNHHI8PP/zQaXu/fv20fft2paSkaNGiRVq9erUGDRrkUh0AAMC6XF6zExISoi1btqhu3bpO7Zs3b1b16tVd2lf37t3VvXv3y/bx8/NTWFjYRbft3LlTycnJ+uGHH9SmTRtJ0uuvv64ePXrolVdeUXh4uEv1AAAA63F5Zqdv374aMmSIVq5cqcLCQhUWFmrFihUaOnSo+vTp4/YC/+///k8hISFq2LChnnjiCZ08edKxLTU1VUFBQY6gI0kxMTHy8vLS2rVrL7nPvLw85eTkOD0AAIA1uTyzM3nyZB08eFDR0dGqUOG3l9vtdsXGxrr9Cq1u3brpvvvuU2RkpPbt26dnn31W3bt3V2pqqry9vZWRkaGQkBCn11SoUEHBwcHKyMi45H6TkpI0ceJEt9YKAADKJ5fDjq+vrz7++GNNnjxZmzdvlr+/v5o3b646deq4vbgLZ4qaN2+uFi1aqF69evq///s/RUdHX/F+x4wZo8TERMfznJwcRURElKpWAABQPl3RfXYkKTg4WHfcccdFr8zylBtuuEE1atTQ3r17FR0drbCwMB07dsypT0FBgTIzMy+5zkf6bR2Qn5+fp8sFAADlgEtrdrKyspSQkKAaNWooNDRUoaGhqlGjhgYPHqysrCwPlfj//fLLLzp58qRq1aolSYqKilJWVpY2bNjg6LNixQrZ7Xa1bdvW4/UAAIDyr8QzO5mZmYqKitKhQ4fUr18/NW7cWJK0Y8cOzZ07V8uXL9d3332natWqlfjNc3NztXfvXsfzAwcOKC0tTcHBwQoODtbEiRPVu3dvhYWFad++fXrmmWdUv359de3aVZLUuHFjdevWTY899pjeeust5efna/DgwerTpw9XYgEAAEkuhJ1JkybJ19dX+/btU2hoaLFtXbp00aRJkzR9+vQSv/n69et1xx13OJ4XraOJi4vT7NmztWXLFr333nvKyspSeHi4unTposmTJzudgpo3b54GDx6s6OhoeXl5qXfv3po5c2aJawAAANZmM8aYknSsW7eu/vnPfzpmVX4vOTlZjz/+uA4ePOjO+q6KnJwcBQYGKjs7WwEBAWVdDlCu1R29uKxLANzm4NSeZV0CSqGkv79LvGbnyJEjatq06SW3N2vW7LKXewMAAJSFEoedGjVqXHbW5sCBAwoODnZHTQAAAG5T4rDTtWtXPffcczp//nyxbXl5eRo7dmyxL+kEAAAoay4tUG7Tpo0aNGighIQENWrUSMYY7dy5U2+++aby8vL0/vvve7JWAAAAl5U47Fx//fVKTU3Vk08+qTFjxqhoXbPNZtNdd92lN954g7sQAwCAcselOyhHRkZqyZIlOnXqlPbs2SNJql+/Pmt1AABAuXVFXxdRrVo13Xrrre6uBQAAwO1c+roIAACAaw1hBwAAWBphBwAAWFqJws7NN9+sU6dOSfrtEvSzZ896tCgAAAB3KVHY2blzp86cOSNJmjhxonJzcz1aFAAAgLuU6GqsVq1aacCAAerYsaOMMXrllVdUpUqVi/YdN26cWwsEAAAojRKFnblz52r8+PFatGiRbDablixZogoVir/UZrMRdgAAQLlSorDTsGFDffTRR5IkLy8vLV++XCEhIR4tDAAAwB1cvqmg3W73RB0AAAAecUV3UN63b59mzJihnTt3SpKaNGmioUOHql69em4tDgAAoLRcvs/O0qVL1aRJE61bt04tWrRQixYttHbtWjVt2lQpKSmeqBEAAOCKuTyzM3r0aA0fPlxTp04t1j5q1CjdddddbisOAACgtFye2dm5c6cGDhxYrP2RRx7Rjh073FIUAACAu7gcdmrWrKm0tLRi7WlpaVyhBQAAyh2XT2M99thjGjRokPbv36/27dtLktasWaOXXnpJiYmJbi8QAACgNFwOO2PHjlXVqlX16quvasyYMZKk8PBwTZgwQUOGDHF7gQAAAKXhctix2WwaPny4hg8frtOnT0uSqlat6vbCAAAA3OGK7rNThJADAADKO5cXKAMAAFxLCDsAAMDSCDsAAMDSXAo7+fn5io6O1p49ezxVDwAAgFu5FHZ8fHy0ZcsWT9UCAADgdi6fxnr44Yf1zjvveKIWAAAAt3P50vOCggK9++67WrZsmVq3bq3KlSs7bX/ttdfcVhwAAEBpuRx2tm3bpptvvlmStHv3bqdtNpvNPVUBAAC4icthZ+XKlZ6oAwAAwCOu+NLzvXv3aunSpTp37pwkyRjjtqIAAADcxeWwc/LkSUVHR+vGG29Ujx49dOTIEUnSwIEDNWLECLcXCAAAUBouh53hw4fLx8dH6enpqlSpkqP9oYceUnJysluLAwAAKC2X1+x8/fXXWrp0qa6//nqn9gYNGuinn35yW2EAAADu4PLMzpkzZ5xmdIpkZmbKz8/PLUUBAAC4i8th57bbbtN//vMfx3ObzSa73a5p06bpjjvucGtxAAAApeXyaaxp06YpOjpa69ev1/nz5/XMM89o+/btyszM1Jo1azxRIwAAwBVzeWanWbNm2r17tzp27Kh7771XZ86c0X333adNmzapXr16nqgRAADgirk8syNJgYGBeu6559xdCwAAgNtdUdg5deqU3nnnHe3cuVOS1KRJEw0YMEDBwcFuLQ4AAKC0XD6NtXr1atWtW1czZ87UqVOndOrUKc2cOVORkZFavXq1J2oEAAC4Yi7P7CQkJOihhx7S7Nmz5e3tLUkqLCzUk08+qYSEBG3dutXtRQIAAFwpl2d29u7dqxEjRjiCjiR5e3srMTFRe/fudWtxAAAApeVy2Ln55psda3UutHPnTrVs2dItRQEAALhLiU5jbdmyxfHzkCFDNHToUO3du1ft2rWTJH3//feaNWuWpk6d6pkqAQAArpDNGGP+qJOXl5dsNpv+qKvNZlNhYaHbirtacnJyFBgYqOzsbAUEBJR1OUC5Vnf04rIuAXCbg1N7lnUJKIWS/v4u0czOgQMH3FYYAADA1VSisFOnTh1P1wEAAOARV3RTwcOHD+vbb7/VsWPHZLfbnbYNGTLELYUBAAC4g8tXY82dO1eRkZEaOHCgXnnlFU2fPt3xmDFjhkv7Wr16te6++26Fh4fLZrNp4cKFTtuNMRo3bpxq1aolf39/xcTEaM+ePU59MjMz1a9fPwUEBCgoKEgDBw5Ubm6uq4cFAAAsyuWwM3bsWI0bN07Z2dk6ePCgDhw44Hjs37/fpX2dOXNGLVu21KxZsy66fdq0aZo5c6beeustrV27VpUrV1bXrl3166+/Ovr069dP27dvV0pKihYtWqTVq1dr0KBBrh4WAACwKJdPY509e1Z9+vSRl5fLOamY7t27q3v37hfdZozRjBkz9Pzzz+vee++VJP3nP/9RaGioFi5cqD59+mjnzp1KTk7WDz/8oDZt2kiSXn/9dfXo0UOvvPKKwsPDS10jAAC4trmcWAYOHKj58+d7ohYnBw4cUEZGhmJiYhxtgYGBatu2rVJTUyVJqampCgoKcgQdSYqJiZGXl5fWrl17yX3n5eUpJyfH6QEAAKzJ5ZmdpKQk/eUvf1FycrKaN28uHx8fp+2vvfaaWwrLyMiQJIWGhjq1h4aGOrZlZGQoJCTEaXuFChUUHBzs6HMxSUlJmjhxolvqBAAA5dsVhZ2lS5eqYcOGkn67kWCRC38uz8aMGaPExETH85ycHEVERJRhRQAAwFNcDjuvvvqq3n33XcXHx3ugnP8vLCxMknT06FHVqlXL0X706FG1atXK0efYsWNOrysoKFBmZqbj9Rfj5+cnPz8/9xcNAADKHZfX7Pj5+alDhw6eqMVJZGSkwsLCtHz5ckdbTk6O1q5dq6ioKElSVFSUsrKytGHDBkefFStWyG63q23bth6vEQAAlH8uh52hQ4fq9ddfd8ub5+bmKi0tTWlpaZJ+W5Sclpam9PR02Ww2DRs2TC+88IL+97//aevWrYqNjVV4eLh69eolSWrcuLG6deumxx57TOvWrdOaNWs0ePBg9enThyuxAACApCs4jbVu3TqtWLFCixYtUtOmTYstUP7ss89KvK/169frjjvucDwvWkcTFxenuXPn6plnntGZM2c0aNAgZWVlqWPHjkpOTlbFihUdr5k3b54GDx6s6OhoeXl5qXfv3po5c6arhwUAACyqRN96fqEBAwZcdvucOXNKVVBZ4FvPgZLjW89hJXzr+bXNrd96fqFrMcwAAIA/r9LfBhkAAKAcc3lmJzIy8rL303H1+7EAAAA8yeWwM2zYMKfn+fn52rRpk5KTkzVy5Eh31QUAAOAWLoedoUOHXrR91qxZWr9+fakLAgAAcCe3rdnp3r27FixY4K7dAQAAuIXbws6nn36q4OBgd+0OAADALVw+jXXTTTc5LVA2xigjI0PHjx/Xm2++6dbiAAAASsvlsFP0VQ1FvLy8VLNmTXXu3FmNGjVyV10AAABu4XLYGT9+vCfqAAAA8AhuKggAACytxDM7Xl5el72ZoCTZbDYVFBSUuigAAAB3KXHY+fzzzy+5LTU1VTNnzpTdbndLUQAAAO5S4rBz7733FmvbtWuXRo8erS+//FL9+vXTpEmT3FocAABAaV3Rmp3Dhw/rscceU/PmzVVQUKC0tDS99957qlOnjrvrAwAAKBWXwk52drZGjRql+vXra/v27Vq+fLm+/PJLNWvWzFP1AQAAlEqJT2NNmzZNL730ksLCwvThhx9e9LQWAABAeWMzxpiSdPTy8pK/v79iYmLk7e19yX6fffaZ24q7WnJychQYGKjs7GwFBASUdTlAuVZ39OKyLgFwm4NTe5Z1CSiFkv7+LvHMTmxs7B9eeg4AAFDelDjszJ0714NlAAAAeAZ3UAYAAJZG2AEAAJZG2AEAAJZG2AEAAJZW4gXKANyLS7gB4OpgZgcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFgaYQcAAFhauQ47EyZMkM1mc3o0atTIsf3XX39VQkKCqlevripVqqh37946evRoGVYMAADKm3IddiSpadOmOnLkiOPx7bffOrYNHz5cX375pebPn69Vq1bp8OHDuu+++8qwWgAAUN5UKOsC/kiFChUUFhZWrD07O1vvvPOOPvjgA915552SpDlz5qhx48b6/vvv1a5du6tdKgAAKIfK/czOnj17FB4erhtuuEH9+vVTenq6JGnDhg3Kz89XTEyMo2+jRo1Uu3ZtpaamXnafeXl5ysnJcXoAAABrKtdhp23btpo7d66Sk5M1e/ZsHThwQLfddptOnz6tjIwM+fr6KigoyOk1oaGhysjIuOx+k5KSFBgY6HhERER48CgAAEBZKtensbp37+74uUWLFmrbtq3q1KmjTz75RP7+/le83zFjxigxMdHxPCcnh8ADAIBFleuZnd8LCgrSjTfeqL179yosLEznz59XVlaWU5+jR49edI3Phfz8/BQQEOD0AAAA1nRNhZ3c3Fzt27dPtWrVUuvWreXj46Ply5c7tu/atUvp6emKiooqwyoBAEB5Uq5PYz399NO6++67VadOHR0+fFjjx4+Xt7e3+vbtq8DAQA0cOFCJiYkKDg5WQECAnnrqKUVFRXElFgAAcCjXYeeXX35R3759dfLkSdWsWVMdO3bU999/r5o1a0qSpk+fLi8vL/Xu3Vt5eXnq2rWr3nzzzTKuGgAAlCc2Y4wp6yLKWk5OjgIDA5Wdnc36HVw1dUcvLusSgD+9g1N7lnUJKIWS/v6+ptbsAAAAuIqwAwAALI2wAwAALI2wAwAALI2wAwAALK1cX3oOAIAnXYtXRXIFmeuY2QEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZG2AEAAJZWoawLANyh7ujFZV0CAKCcYmYHAABYGmEHAABYGmEHAABYGmEHAABYGmEHAABYGldjAQBwDbkWrz49OLVnmb4/MzsAAMDSCDsAAMDSCDsAAMDSWLODYq7F88EAAFwKMzsAAMDSCDsAAMDSCDsAAMDSCDsAAMDSLBN2Zs2apbp166pixYpq27at1q1bV9YlAQCAcsASYefjjz9WYmKixo8fr40bN6ply5bq2rWrjh07VtalAQCAMmYzxpiyLqK02rZtq1tuuUVvvPGGJMlutysiIkJPPfWURo8e/Yevz8nJUWBgoLKzsxUQEODW2riMGwDwZ+epr4so6e/va/4+O+fPn9eGDRs0ZswYR5uXl5diYmKUmpp60dfk5eUpLy/P8Tw7O1vSbx+au9nzzrp9nwAAXEs88fv1wv3+0bzNNR92Tpw4ocLCQoWGhjq1h4aG6scff7zoa5KSkjRx4sRi7RERER6pEQCAP7PAGZ7d/+nTpxUYGHjJ7dd82LkSY8aMUWJiouO53W5XZmamqlevLpvNVoaVXV5OTo4iIiL0888/u/10G0qHsSmfGJfyi7Epv66lsTHG6PTp0woPD79sv2s+7NSoUUPe3t46evSoU/vRo0cVFhZ20df4+fnJz8/PqS0oKMhTJbpdQEBAuf8D+GfF2JRPjEv5xdiUX9fK2FxuRqfINX81lq+vr1q3bq3ly5c72ux2u5YvX66oqKgyrAwAAJQH1/zMjiQlJiYqLi5Obdq00a233qoZM2bozJkzGjBgQFmXBgAAypglws5DDz2k48ePa9y4ccrIyFCrVq2UnJxcbNHytc7Pz0/jx48vdgoOZY+xKZ8Yl/KLsSm/rDg2lrjPDgAAwKVc82t2AAAALoewAwAALI2wAwAALI2wAwAALI2wAwAALI2wU85MnTpVNptNw4YNc7T9+uuvSkhIUPXq1VWlShX17t272B2j09PT1bNnT1WqVEkhISEaOXKkCgoKrnL11nPo0CE9/PDDql69uvz9/dW8eXOtX7/esd0Yo3HjxqlWrVry9/dXTEyM9uzZ47SPzMxM9evXTwEBAQoKCtLAgQOVm5t7tQ/FMgoLCzV27FhFRkbK399f9erV0+TJk52+CJBxuTpWr16tu+++W+Hh4bLZbFq4cKHTdneNw5YtW3TbbbepYsWKioiI0LRp0zx9aNe8y41Nfn6+Ro0apebNm6ty5coKDw9XbGysDh8+7LQPS42NQbmxbt06U7duXdOiRQszdOhQR/vjjz9uIiIizPLly8369etNu3btTPv27R3bCwoKTLNmzUxMTIzZtGmT+eqrr0yNGjXMmDFjyuAorCMzM9PUqVPHxMfHm7Vr15r9+/ebpUuXmr179zr6TJ061QQGBpqFCxeazZs3m3vuucdERkaac+fOOfp069bNtGzZ0nz//ffmm2++MfXr1zd9+/Yti0OyhBdffNFUr17dLFq0yBw4cMDMnz/fVKlSxfzjH/9w9GFcro6vvvrKPPfcc+azzz4zksznn3/utN0d45CdnW1CQ0NNv379zLZt28yHH35o/P39zT//+c+rdZjXpMuNTVZWlomJiTEff/yx+fHHH01qaqq59dZbTevWrZ32YaWxIeyUE6dPnzYNGjQwKSkp5vbbb3eEnaysLOPj42Pmz5/v6Ltz504jyaSmphpjfvtD7eXlZTIyMhx9Zs+ebQICAkxeXt5VPQ4rGTVqlOnYseMlt9vtdhMWFmZefvllR1tWVpbx8/MzH374oTHGmB07dhhJ5ocffnD0WbJkibHZbObQoUOeK97CevbsaR555BGntvvuu8/069fPGMO4lJXf/0J11zi8+eabplq1ak5/l40aNco0bNjQw0dkHRcLor+3bt06I8n89NNPxhjrjQ2nscqJhIQE9ezZUzExMU7tGzZsUH5+vlN7o0aNVLt2baWmpkqSUlNT1bx5c6c7Rnft2lU5OTnavn371TkAC/rf//6nNm3a6IEHHlBISIhuuukm/etf/3JsP3DggDIyMpzGJjAwUG3btnUam6CgILVp08bRJyYmRl5eXlq7du3VOxgLad++vZYvX67du3dLkjZv3qxvv/1W3bt3l8S4lBfuGofU1FR16tRJvr6+jj5du3bVrl27dOrUqat0NNaXnZ0tm83m+FJsq42NJb4u4lr30UcfaePGjfrhhx+KbcvIyJCvr2+xb2UPDQ1VRkaGo8/vvxqj6HlRH7hu//79mj17thITE/Xss8/qhx9+0JAhQ+Tr66u4uDjHZ3uxz/7CsQkJCXHaXqFCBQUHBzM2V2j06NHKyclRo0aN5O3trcLCQr344ovq16+fJDEu5YS7xiEjI0ORkZHF9lG0rVq1ah6p/8/k119/1ahRo9S3b1/Ht5xbbWwIO2Xs559/1tChQ5WSkqKKFSuWdTm4gN1uV5s2bTRlyhRJ0k033aRt27bprbfeUlxcXBlX9+f1ySefaN68efrggw/UtGlTpaWladiwYQoPD2dcABfl5+frwQcflDFGs2fPLutyPIbTWGVsw4YNOnbsmG6++WZVqFBBFSpU0KpVqzRz5kxVqFBBoaGhOn/+vLKyspxed/ToUYWFhUmSwsLCil2dVfS8qA9cV6tWLTVp0sSprXHjxkpPT5f0/z/bi332F47NsWPHnLYXFBQoMzOTsblCI0eO1OjRo9WnTx81b95c/fv31/Dhw5WUlCSJcSkv3DUO/P3mOUVB56efflJKSopjVkey3tgQdspYdHS0tm7dqrS0NMejTZs26tevn+NnHx8fLV++3PGaXbt2KT09XVFRUZKkqKgobd261ekPZtEf3N//skbJdejQQbt27XJq2717t+rUqSNJioyMVFhYmNPY5OTkaO3atU5jk5WVpQ0bNjj6rFixQna7XW3btr0KR2E9Z8+elZeX819d3t7estvtkhiX8sJd4xAVFaXVq1crPz/f0SclJUUNGzYsV6dJrjVFQWfPnj1atmyZqlev7rTdcmNT1iukUdyFV2MZ89ul57Vr1zYrVqww69evN1FRUSYqKsqxvejS8y5dupi0tDSTnJxsatasyaXnpbRu3TpToUIF8+KLL5o9e/aYefPmmUqVKpn//ve/jj5Tp041QUFB5osvvjBbtmwx995770Uvrb3pppvM2rVrzbfffmsaNGjAJc6lEBcXZ6677jrHpeefffaZqVGjhnnmmWccfRiXq+P06dNm06ZNZtOmTUaSee2118ymTZscV/S4YxyysrJMaGio6d+/v9m2bZv56KOPTKVKlcrl5c3lyeXG5vz58+aee+4x119/vUlLSzNHjhxxPC68sspKY0PYKYd+H3bOnTtnnnzySVOtWjVTqVIl89e//tUcOXLE6TUHDx403bt3N/7+/qZGjRpmxIgRJj8//ypXbj1ffvmladasmfHz8zONGjUyb7/9ttN2u91uxo4da0JDQ42fn5+Jjo42u3btcupz8uRJ07dvX1OlShUTEBBgBgwYYE6fPn01D8NScnJyzNChQ03t2rVNxYoVzQ033GCee+45p7+kGZerY+XKlUZSsUdcXJwxxn3jsHnzZtOxY0fj5+dnrrvuOjN16tSrdYjXrMuNzYEDBy66TZJZuXKlYx9WGhubMRfcdhQAAMBiWLMDAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAsjbADAAAs7f8BdFN3wNn9blMAAAAASUVORK5CYII=", + "application/vnd.jupyter.widget-view+json": { + "model_id": "ab7b081d9b05440aad079e917878a337", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -958,9 +1139,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "18b4585a154a44938bb524fda741ca10", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -968,9 +1164,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "a0cab169117a4a99a3364cad99559469", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyAAAAMgCAYAAADbcAZoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAWFpJREFUeJzt3QWcHdXdP/4TJ0gSEiIEQhI0uAR3K06hQAsUh+JSpEgoDm1wKBR5SoEghVL8AYq7BAvuGixAsAgWvf/X9zz/u7/dzSYk2ZtZe79fr8vdOzM7c+6ZS3Y+98i0KpVKpQQAAFCA1kUcBAAAQAABAAAKpQUEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQACameHDh6dWrVqlIUOGpMbknnvuScstt1yabbbZcvlGjRrV0EVqNtZdd938AGgKBBCAqYgL+LhQrv7o0aNHWm+99dLdd99deL098sgjNcrSrl27tOCCC6Zdd901ffDBBxU5xlNPPZVOOumkioeDb775Jv3ud79LHTt2TBdddFG65ppr0hxzzFHRYzR3b7zxRj43ETABmrK2DV0AgMbulFNOSf3790+lUil9+eWXOZhsttlm6Y477khbbLFF4eU55JBD0korrZQmTJiQXnjhhfSPf/wj3XXXXenVV19NvXv3rncAOfnkk9Puu++eunTpUrEyP/fcc2ns2LHp1FNPTRtuuGHF9tvSAkicm2jp6NevX4119913X4OVC2BGCSAAv2DTTTdNK664YtXrvfbaK/Xs2TNdf/31DRJA1lprrbTddtvln/fYY4+06KKL5lBy1VVXpUGDBqXGaOTIkfm5kqGG/6d9+/aqA2gydMECmEFxER1didq2rfkdzg8//JCOOOKI1KdPn9ShQ4e02GKLpbPPPju3nISffvopDRgwID/i57Jvv/02zTvvvGn11VdPkyZNmuHzsf766+fnDz/8cJrbPfTQQzm8RNeneA9bbbVVevPNN6vWR/eeI488Mv8cLT7lrl6/1OXnxhtvTAMHDsx1Ms8886Sdd945ffbZZ1Xr4xv73XbbLf8cLTexz2hhmZqPPvooHXDAAbn+Yp/dunVLv/3tb6coR7mL3GOPPZb23XffvF2nTp1yl7Tvvvtuiv1efPHFackll8znJlqKDjzwwDq7mkUXsejaFsdeeeWV0+OPP17nGItx48alE088MS288MJ5n3HejzrqqLy8tmuvvbaqjrp27Zp22GGH9Mknn0yzXmu/16iDEF0Ay+cmuuWV67h6+crd9f7zn//kVpP55psvzTXXXDm4jh49Opfx0EMPzV0K55xzzhxkZ0W5AeqiBQTgF8QF29dff52DRHyTf+GFF6bvv/8+X2iXxbpf//rX6eGHH84tJDHY+t57780X9HExft555+WLuGilWGONNdKf//zndO655+bfjQvhOEZcZLZp02aGz8f777+fn+MCfGoeeOCB3JITF9YRNCIAxfuIskQ3rujSs80226R33nknt+xEeSNMhO7du091v1HmuHiNYDF48ODcRe1vf/tbevLJJ9OLL76Yg0681wgT0VWs3J1toYUWmmZ3regKFhe7888/fw4el1xySb7Ajm5Is88+e43tDzrooHyceF9vv/123jZCTPkiPMS6uBCP7l/7779/1XZxrChrjKcJsSz2F0HtsMMOy8feeuut09xzz53LUjZ58uR8vp944om0zz77pMUXXzx3gYt6izq87bbbqrb9y1/+ko4//vg8BuYPf/hD+uqrr3Ldr7322lV19Eti22jluuCCC9Kxxx6bjxfKz1MT5yQ+d8ccc0x677338nHjvbZu3TqHtKiXp59+Op/HOC8nnHBCRcsNUKcSAHW68soro+liikeHDh1KQ4YMqbHtbbfdlteddtppNZZvt912pVatWpXee++9qmWDBg0qtW7duvTYY4+Vbrzxxvx7559//i+ehYcffjhve8UVV5S++uqr0ogRI0p33XVXqV+/fvkYzz33XN7uww8/zNtF+cuWW265Uo8ePUrffPNN1bKXX345l2PXXXetWnbWWWfl3419/JLx48fnfS611FKln376qWr5nXfemfdxwgknTFGX5TJOy48//jjFsqFDh+bfv/rqq6fY58CBA3NZys4888y8/Pbbb8+vR44cWWrfvn1po402Kk2aNKlqu7///e9V9RnGjRtX6tatW2mllVYqTZgwoWq7ONex3TrrrFO17Jprrsl19/jjj9co56WXXpq3ffLJJ/Pr4cOHl9q0aVP6y1/+UmO7V199tdS2bdsplk9L+bMSn4PaomzVy1f+rMS5qV43O+64Y/6sbLrppjV+f7XVViv17du36nUlyw1Qmy5YAL8guuTcf//9+RFdUqILTHwjfMstt1Rt89///je3XsS31NVFl6xoHak+a1Z86xxdgaJbUnQ1Wmeddab4vWnZc889c6tEdCPafPPNc9evaFmpPk6lus8//zy99NJLudtTdKMpW2aZZdKvfvWrXPaZ8fzzz+cWoXgPMbVuWZQpupnFwPiZEd/Yl8VA+5hBK7o5xTfu0VpTW7RAlFswQrRwRPe48vuK1p/x48fnLkfxzX/Z3nvvnbtslcsZ7yeOFcurd6/baaedcgtI7W5n0foQ7zNax8qPcne4aAkL8RmJ1pJoRai+Xa9evdIiiyxStd2sEt3RqtfNKquskj+P8RmqLpZH16qJEyc2inIDzZsuWAC/IMYBVL+433HHHdPyyy+fu+rEIPQYABxdfiIQRD/76spdZGJ9WWx/xRVX5G5LceF+5ZVXVnUVmh7RTSa6CEXgiW5ScYza41GqKx87ukHVFr8bXcUixMzotLjT2m9cmEf3pJkR3cOi61DUS3RfK4+hCdFVrba4IK4uxjTEmJrymJGplTPOQ3RJK68vP0fYqS7qtvasU++++24ePzO17mnlQfexXZS/dhnLqoeDWWGBBRao8bpz5875Ocar1F4egSPqN7ryNXS5geZNAAGYQfEterSCxFiHuFCL1owZFRf94eeff877iP7302vppZdu1lPZHnzwwTl8RIvFaqutli+OI6DFmJC4SG4MohxxHsrjeGorX+DHdlH2aAGra3xPhKVZaWpjiqa2vBz2GrrcQPMmgADMhHJXlRiMHvr27Zu7+sS9Lqq3grz11ltV68teeeWVPBg7Bm9H16jozhUDmMvfTlda+dgx8Lq2KF+0opRbP2akJab6fstdj8piWfX3PCNuuumm3D3tnHPOqVoWQW1qN0eMABeBsCzOSXQ7i3u11C5ntHiURbesmDmsHObK28Vg7er7i3MdrSnRZa0sBtG//PLLaYMNNphmncV2cVEfATOmS66PGTk39VXJcgPUZgwIwAyKcQlx47fowlPuYhUXuzGF7t///vca28asSHHhGDNQlX83xmJEd61oQYnZh2LmqJhxaVaJ7kgxK1eME6l+Ef/aa6/l91G+UA/lIDI9d0KPbmkxjeull15aYwrX+NY8uifFWJCZEd+4V+92FWL2palNURyza0W9lsVMVhEaynUeASPOVcwgVX2/l19+ee5yVC5nvJ/ofnTZZZdVBczwr3/9a4ppfWNsRHQPi23r6kIWXdpCzCwW7ydm4Kr9nuJ1jDmZXjNybuqrkuUGqE0LCMAviAvqcktG9O2/7rrr8rfuMbVpDGIOW265Zf7WPKacjW/Ll1122Xxxf/vtt+euROVpZ0877bTc6vHggw/mlpL4Vj3GdBx33HH5Hg3Vw0AlnXXWWfmCPLo0xTTB5Wl4o9UlBsWXxT0fQryP6PIUff3jvdU1PiTWnXHGGbklJwbSx9iY8jS8MWZiZkNVjKu55pprctmWWGKJNHTo0Ny6NLVphqMlI1oiIhREK0fc72PNNdfM0+SGGKcRN2iMi+lNNtkkLy9vF+NwytMpR0iJuoguYNGiE/uLcxkhMc5f9RaIXXbZJd9jY7/99ssDsmM64whI8TmJ5dHFLgJN/F6c8zh+eUrfOO/R8nLrrbfmAfR/+tOfpqteIkRGKIg6j+AU9x6JckYIrLRKlhtgClPMiwXAVKfhnW222fKUtpdccklp8uTJNWpq7NixpcMOO6zUu3fvUrt27UqLLLJInta2vN2wYcPyFKYHH3xwjd+bOHFinvo1fu+7776bau2Xp1aN6Vinpa5peMMDDzxQWmONNUodO3YsderUqbTllluW3njjjSl+/9RTTy3NN998eZrZ6ZmS94Ybbigtv/zyeXrirl27lnbaaafSp59+WmObGZmGN+pgjz32KM0zzzylOeecs7TxxhuX3nrrrTxN7G677TbFPh999NHSPvvsU5p77rnz9nH86tMNV592d8CAAfnc9OzZs7T//vvXWd8XXHBBPla8n5VXXjlPqRtT/W6yySY1tovpbc8444zSkksumbeN48d2J598cmn06NE1tr355ptLa665ZmmOOebIjyjHgQceWHr77bdLM+Kyyy4rLbjggnmK3OpT8k5tGt7an5WpnYcTTzwxL4/pnWdFuQGqaxX/mTKWAEDjVr4JYtxMcGpTEFdCDMiOVpTollRXlysAZowxIABQbbB77e/lrr766vTtt9/mO7EDUH/GgADA/+/pp5/OY1d++9vf5jEncePDGKy+1FJL5WWzQozHqev+JtXFDSRjjApAcyCAAMD/LwbPxz08YsasaPWIC/+4m/jpp58+ywLADTfckLuSTUsMdNcCAzQXxoAAQAOKe5a8/vrr09wmZiebe+65CysTwKwkgAAAAIUxCB0AACiMMSDTmHZxxIgR+cZL1W8+BQAALVmpVEpjx45NvXv3Tq1bz3h7hgAyFRE+YiAiAAAwpU8++STNP//8aUYJIFMRLR/liu3UqdMMVywAADRHY8aMyV/Ul6+XZ5QAMhXlblcRPgQQAACoaWaHKRiEDgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGHaFncoAKApevfdd9PYsWMbuhjMpLnmmistssgi6o9GQwABAKYZPhZddNEWV0O95myV9h3YPv3PsPHpi+9Lqal75513hBAaDQEEAJiqcsvHtddemxZffPEWU1MdR72TFn9s37T9CUPST12abgB78803084776wFi0ZFAAEAflGEjxVWWKHl1NSI1ik9ltLiAwak1Hu5hi4NNCsGoQMAAIURQAAAgMIIIAAAQGEEEIAG9uOPP6YXXnghPwNAc/+7IYAANLC33norDRw4MD8DQHP/u2EWrEZo0qRJ6fHHH0+ff/55mnfeedNaa62V2rRpkxqDxly2pqJ2Ha6++urpqaeemmadzsp6L+/7s88+S1999VXq3r17mm+++Qo7t5V8b+PHj08XX3xxev/999NCCy2UDjjggNS+ffvpOlZd5yVeP/TQQ+mTTz5Jffr0Seuvv35ad91187bVj7PvvvumZ555pqoOu3Xrlr755pspnouuWwBolErUafTo0XHXofxcpJtvvrnUr1+/fOzyI17H8obWmMvWVNRVh23btp1mnc7Keq9r30We20q+tyOPPHKKuozXsfyXjlXXutatW9dZLx07dpzquul91H6Pw4YNy8vjGRqbFvv5/OzFUunETv/33IS12PPXzA1r4PNa3+tkXbAakVtuuSVtt912aemll05Dhw7NNw2K53gdy2O9sjWf8xs39WrVqlX+djzE69rne1Z+Jsr7nmeeefLrTTfdNF122WX5OcoVy2fl566S7+2oo45KZ511Vq7LeA/RihHP8TqWb7311tM81rbbblvjvITJkyfn57gD9IUXXphWXXXV/Pqnn37K6/bff//0z3/+M9dV27b/15jco0eP/NypU6f8PPvss1e9ju2WX375/HpW1y0ANGoVj0TNRNEtIBMnTszfim655ZalSZMm1VgXr2N5//7983ZFa8xlaypq12H11xMmTKhRh+U6jfWzqt7Lx99iiy1Kffv2rXGM6vuO9bPi3FbyMzVu3Ljc0tGzZ89cl9XF61ge/y9vvvnmUxxr/PjxuUVj9tlnzz/H8aI+Ylk8evToUVWOn376qUYrSGxXvQ7bt2+f12222WalBRZYIB+3TZs2+bl6XcZz+ffK+27ob7JgWlrs51MLCI3YsCbeAmIMSCMRfc2HDx+err/++tS6dc2GqXg9aNCgqj7p0Qdd2Zr2+X3kkUeqXse357XPb/l1mBWfiXJ5jjzyyHTnnXemf//731XHqL7vI444Iq+v9Oeukp/3GIsxceLEdNppp1W1RJTF65122imde+65aeGFF57iWE8++WRu0Sj/HD766KOq9X/729/SPvvsk8vx0ksvVS2P3ylvV67DHXbYIddjx44d08cff5zr7pxzzkk777xzfi7XZfn5T3/6U1XdtmvXLu/rzTffnMkahVmn/Lks/79C01I+b/59aV7ebOL/XwogjUR0GQlLLbVUnevLy8vbFakxl62pqF2HtV9PbXntnytV7+XfiYvluo5Rfl1eX+lzW8nPVAwED1tssUWd6xdccMGp/iNdff91Hau8z1hXPk5t5TpaaaWVcgD57rvvahy3/FzervZz7Lvc3SvCCjRW8aXBGmus0dDFYCbOW/DvS/M0vIn+fymANBIx60547bXXqvqaVxfLq2+nbE37/NZ+Xfv8ll9X36aSn4ny75Qvymsfo7zv8vpKf+4q+XmPWahCtCb84Q9/mGL9Bx98UOOCv65yTO1Ysc/yuvJxaivX0XPPPZef55577hrHLT+Xt6v9HPsut4DE+JPFF1/8F98zFP1Na1y89uvXT8U3QeXz5t+X5uXNpv7/ZcU7hTUTxoD8P8aA1J8xINOuj+qMAYHGpaH7mjcYY0BoxIY18TEgAsgsqtiZEdNytmrVKl+UPfXUU6UxY8bk53gdyxtyutvGXLamonYdXnvttfl1eZB0vK5dp7Oy3sv7XnHFFfPxN91009L//M//5Ofy8ll5biv53mKq3XgPUZfxHj777LP8XK7brbbaaprHim2qn5fqU+Yuuuiipb/97W+lVVddtcby/fbbr3TZZZfl3y9P/xuD1uO5U6dO+TkGt5dfx3bLL798fl27bhv6DwlMS4v9fAogNGLDBJDmqTHdByRmymkMF/iNuWzN6T4gtet0Vtb7tO4DUsS5reR7m5n7gJSPVfR9QGq/x4b+QwLT0mI/nwIIjdiwJh5AWsV/GrobWGM0ZsyY1Llz5zR69OiqOf2L0pjvNt6Yy9ZUuBP6tOujJd4J/YUXXkgDBw5Mw4YNSyussMJMfrJg1mixn88RL6X0j3VS2ufRlHovl5qqFnv+mrkXGvi81vc62SD0RiguTIqearc5lK2pqKsOf6lOZ2W9N/Q5reTxI2wceuihM3WsutZtsMEG+VHXtrWP4/8LAJg+7oQOAAAURgABaGADBgzIzejxDADN/e+GLlgADWz22WfXNxuAFvN3QwsIAABQGAEEAAAojC5YAMBU/fjjj1XTfrYkHUe9kxZPKb351lvppy8mp6bqzTffbOgiwBQEEABgqt566638vPfee7eoWuo1Z6u078D26X/O+X364vumf8u0ueaaq6GLAFUEEABgqrbeeuv8HLPtxMDXlubXKTWL8LHIIos0dDGgijuhN8I7oQMAQHO9TjYIHQAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAEEAAAoPnRAgIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFKZtcYdqWkqlUn4eM2ZMQxcFAAAajfL1cfl6eUYJIFMxduzY/NynT5+ZPTcAANCsr5c7d+48w7/XqjSz0aWZmzx5choxYkSaa665UqtWrRq6OAAA0ChEfIjw0bt379S69YyP6BBAAACAwhiEDgAAFEYAAQAACiOAAAAAAggAAND8aAEBAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAGYTv369Uu77767+prFzjrrrLTgggumNm3apOWWW059V1CrVq3SSSedpE6BBiWAAC3SkCFD8sXY888/X+f6ddddNy211FL1Ps5///tfF3wz4L777ktHHXVUWmONNdKVV16Z/vrXv9b7HLQ0PnNAY9e2oQsA0FS8/fbbqXXr1jN8MXjRRRcJIdPpoYceynV8+eWXp/bt28/MaWrxpvWZ++mnn1Lbtv70Aw1LCwjAdOrQoUNq165dk6qvH374ITUlI0eOTB07dhQ+ZpHZZptNAAEanAACMJNjQCZMmJBOPvnktMgii+QLu27duqU111wz3X///Xl9bBvfRIfo7lV+VA8HRxxxROrTp08ON4sttlg6++yzU6lUmuJb60MOOSTNM888aa655kq//vWv02effTZFf/74OZa98cYb6fe//32ae+65c3nCK6+8kssTYyuirL169Up77rln+uabb2ocq7yPd955J+28886pc+fOqXv37un444/P5frkk0/SVlttlTp16pT3cc4550xX3U2cODGdeuqpaaGFFsrvNery2GOPTePGjavaJo4b3a6iXsp1FV3lpubxxx9Pv/3tb9MCCyyQ9xn1eNhhh+X6qi7e95xzzpk++OCDtPHGG6c55pgj9e7dO51yyilT1HWlz0mI5VHXPXv2zPtccskl0xVXXDHF+4m6OPHEE9PCCy9c9X6iO1r1Ovolv/SZm9pnpj7nuxLlBloW7bBAizZ69Oj09ddfT7E8wsUviYu3wYMHpz/84Q9p5ZVXTmPGjMljSl544YX0q1/9Ku27775pxIgROZBcc801NX43Lu7iovXhhx9Oe+21Vx5sfe+996YjjzwyX7Ced955NS4q//Of/6RddtklrbrqqunRRx9Nm2+++VTLFRflEYpi/ET5wjnKEBfge+yxR76QfP3119M//vGP/Pz000/XuEgN22+/fVp88cXT6aefnu6666502mmnpa5du6b/+Z//Seuvv34644wz0r/+9a/0pz/9Ka200kpp7bXXnmZdRR1dddVVabvttssX+M8880yuuzfffDPdeuuteZuooyjTs88+m/75z3/mZauvvvpU93njjTemH3/8Me2///45/MXvXXjhhenTTz/N66qbNGlS2mSTTXL9nXnmmemee+7JF80RjCKIzKpz8uWXX+b1Ub8HHXRQvri/++678/7j83LooYfm7SZPnpyP/cQTT6R99tkn1/2rr76ajxnh4LbbbkvTY1qfuWmZ2fNdqXIDLUwJoAW68sor48p8mo8ll1yyxu/07du3tNtuu1W9XnbZZUubb775NI9z4IEH5n3Vdtttt+Xlp512Wo3l2223XalVq1al9957L78eNmxY3u7QQw+tsd3uu++el5944olVy+LnWLbjjjtOcbwff/xximXXX3993v6xxx6bYh/77LNP1bKJEyeW5p9//lyu008/vWr5d999V+rYsWONOqnLSy+9lPf5hz/8ocbyP/3pT3n5Qw89VLUs9jXHHHNMc3/Tek+DBw/O5fzoo49q7DOOc/DBB1ctmzx5cj537du3L3311Vez7JzstddepXnnnbf09ddf19h2hx12KHXu3LnqPVxzzTWl1q1blx5//PEa21166aV5n08++WRpek3tMxem9pmZ2fNdyXIDLYcuWECLFt1V4tvi2o9lllnmF3+3S5cuuQXh3XffnamBwjHNbHTjqS5aB+I6Mb4lD/FNfTjggANqbHfwwQdPdd/77bffFMtiXEXZzz//nFt94pv5EC02dbVYlEU5V1xxxVyu+Oa++vuPLkrRsvJL7zUcfvjhU7zXEN+4z4zq7ym6TsV7ihaTKOeLL744xfbRAlFWbpEYP358euCBB2bJOYnfufnmm9OWW26Zf47ylR/RFSxa38p1Hy020XowYMCAGttF60OIVplZaWbPd0OXG2iadMECWrToOhUXW7XF+Im6umZVF113on/8oosumqfsjS4+0SVnesLLRx99lMchxPiB6uJirry+/ByzQvXv37/GdtHffmpqbxu+/fbbPF7l3//+dx7oXV1cCNcW4yqqi7EBMXYkxjzUXl57HElt5fdQu8zRFSwuasvvdUZ9/PHH6YQTTkj/+7//m7777rtpvqc4fox/qS7OWxg+fPgsOSdfffVVGjVqVO5WFo+6lM9FhNjojhZdtKa13awys+e7ocsNNE0CCMBMin7w77//frr99tvz/Sti3EL0fb/00ktrfKNctOotA2W/+93v0lNPPZXHM8TYhhiUHf33IzTFc23xLfj0LAu1B2hPTe1xJvURYzpinE0Eq6OPPjp/Ax+Dy2OsRozPqOs9Fa1chhjcvdtuu9W5TTmsxrZLL710Ovfcc+vcLgZ2z0oze74butxA0ySAANRDDNSNgd3x+P7773MoicHp5QAytYvuvn375q4/Y8eOrfGN+1tvvVW1vvwcF3kffvhhHlhe9t577013GaN14MEHH8wtINFiUDYzXcdmRvk9xPHKrQnlAdrRQlB+rzMiBjrHIOcY2L7rrrtWLS/PQFZbHD+6DpVbPUL8fogZuWbFOYlWgdhPhKUNN9xwmu8nZgd7+eWX0wYbbFDvoFbJoPdLKlluoOUwBgRgJtXuehStCtENp/r0o/GtfIgL7eo222yzfGH697//vcbyaEGJC7lNN900v46xAuHiiy+usV3M9jS9yt9k126pOP/881MR4r3Wdbzyt+bTmtFrRt5T/Py3v/1tqr9Tva5j23gd93WJi+dZcU6ijNtuu20eB/Laa69NUZ7oolW9hSpaby677LIptospf2fkfi5T+8zNCpUsN9ByaAEBmElLLLFEWnfdddPAgQNzS0hMwXvTTTfVGOwc60IMbI4L17go3WGHHfLA5PXWWy/9+c9/zmMQll122dyNK7pzxdSs8c1y+ffjIjYu3iPwlKd8LX97Pz3fOsc9HKJlJqafjemF55tvvnys+Aa/CPHeogtSjIOIi+J11lknT5kbrRdbb711rocZFV2uoo5iWti4AI73GBf6tceClMV4hhg8HuVYZZVV8oDyGPwe9yIpj1+YFeckprWNgdhxzL333jt/ZqLbWAw+j9aW+DnE2KGY1jcmEIjt11hjjRyGovUllsd0wHWNVarL1D5zs0Ilyw20IA09DRdAQ07D+9xzz9W5fp111vnFaXhjutaVV1651KVLlzw96YABA0p/+ctfSuPHj68xpWlM/9q9e/c8rWn1f3bHjh1bOuyww0q9e/cutWvXrrTIIouUzjrrrDxFbHU//PBDnlq1a9eupTnnnLO09dZbl95+++28r+rTpJanVC1PK1vdp59+WvrNb36TyxrTv/72t78tjRgxYqrTstbex9Smx62rnuoyYcKE0sknn1zq379/fq99+vQpDRo0qPTzzz9P13Hq8sYbb5Q23HDDXCfzzDNPae+99y69/PLLufxxfmvv8/333y9ttNFGpdlnn73Us2fP/F4nTZpUY5+VPifhyy+/zNvGe4599urVq7TBBhuU/vGPf9TYLj43Z5xxRq7PDh06lOaee+7SwIEDc72NHj26NL2m9ZmbFee7UuUGWo5W8Z+GDkEAzJiXXnopLb/88unaa69NO+20k+qbhhiUHi1TMUZnVnJOAKaPMSAAjVz0pa8tuv/EVLC/dAdynBOAxsYYEIBGLsZuDBs2LI9PaNu2bR6/EI999tnHNKct6JzEvU3qCqO1760C0NgJIACNXNzdO6aXPfXUU3M3orhpXEz1G4OlaTnn5I9//GMeuD8telUDTYExIADQBLzxxhtpxIgR09zml+43AtAYCCAAAEBhDEIHAAAKYwzIVEyePDk3dc8111zTdaMvAABoCUqlUho7dmzq3bt3npFxRgkgUxHhY1bNZAIAAE3dJ598kuaff/4Z/j0BZCqi5aNcsZ06darf2QEAgGZizJgx+Yv68vXyjBJApqLc7SrChwACAAA1zewwBYPQAQCAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFKZtcYcCAKiffsfc1eKrcPjpm7f4OqBp0wICAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAA0HIDyCWXXJKWWWaZ1KlTp/xYbbXV0t133121/ueff04HHnhg6tatW5pzzjnTtttum7788ssa+/j444/T5ptvnmafffbUo0ePdOSRR6aJEyc2wLsBAAAadQCZf/750+mnn56GDRuWnn/++bT++uunrbbaKr3++ut5/WGHHZbuuOOOdOONN6ZHH300jRgxIm2zzTZVvz9p0qQcPsaPH5+eeuqpdNVVV6UhQ4akE044oQHfFQAAEFqVSqVSY6+Krl27prPOOittt912qXv37um6667LP4e33norLb744mno0KFp1VVXza0lW2yxRQ4mPXv2zNtceuml6eijj05fffVVat++/XQdc8yYMalz585p9OjRuSUGAGh4/Y65K7V0w0/fvKGLQAs3pp7XyY2uBaS6aM3497//nX744YfcFStaRSZMmJA23HDDqm0GDBiQFlhggRxAQjwvvfTSVeEjbLzxxrmiyq0odRk3blzepvoDAACorEYZQF599dU8vqNDhw5pv/32S7feemtaYokl0hdffJFbMLp06VJj+wgbsS7Ec/XwUV5fXjc1gwcPzkmu/OjTp88seW8AANCSNcoAsthii6WXXnopPfPMM2n//fdPu+22W3rjjTdm6TEHDRqUm5HKj08++WSWHg8AAFqitqkRilaOhRdeOP88cODA9Nxzz6W//e1vafvtt8+Dy0eNGlWjFSRmwerVq1f+OZ6fffbZGvsrz5JV3qYu0doSDwAAoIW1gNQ2efLkPEYjwki7du3Sgw8+WLXu7bffztPuxhiREM/RhWvkyJFV29x///15gEx04wIAABpOo2sBia5Qm266aR5YPnbs2Dzj1SOPPJLuvffePDZjr732SocffnieGStCxcEHH5xDR8yAFTbaaKMcNHbZZZd05pln5nEfxx13XL53iBYOAABoWI0ugETLxa677po+//zzHDjipoQRPn71q1/l9eedd15q3bp1vgFhtIrEDFcXX3xx1e+3adMm3XnnnXnsSASTOeaYI48hOeWUUxrwXQEAAE3mPiANwX1AAKDxcR8Q9wGh4TXr+4AAAADNiwACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhWlb3KEAAKivfsfc1eIrcfjpm7f4OmjKtIAAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAABouQFk8ODBaaWVVkpzzTVX6tGjR9p6663T22+/XWObddddN7Vq1arGY7/99quxzccff5w233zzNPvss+f9HHnkkWnixIkFvxsAAKC6tqmRefTRR9OBBx6YQ0gEhmOPPTZttNFG6Y033khzzDFH1XZ77713OuWUU6peR9AomzRpUg4fvXr1Sk899VT6/PPP06677pratWuX/vrXvxb+ngAAgEYaQO65554ar4cMGZJbMIYNG5bWXnvtGoEjAkZd7rvvvhxYHnjggdSzZ8+03HLLpVNPPTUdffTR6aSTTkrt27ef5e8DAABoAl2wahs9enR+7tq1a43l//rXv9I888yTllpqqTRo0KD0448/Vq0bOnRoWnrppXP4KNt4443TmDFj0uuvv15g6QEAgEbdAlLd5MmT06GHHprWWGONHDTKfv/736e+ffum3r17p1deeSW3bMQ4kVtuuSWv/+KLL2qEj1B+HevqMm7cuPwoi7ACAAC0oAASY0Fee+219MQTT9RYvs8++1T9HC0d8847b9pggw3S+++/nxZaaKGZHvx+8skn17vMAABAE+yCddBBB6U777wzPfzww2n++eef5rarrLJKfn7vvffyc4wN+fLLL2tsU349tXEj0Y0runuVH5988kmF3gkAANBoA0ipVMrh49Zbb00PPfRQ6t+//y/+zksvvZSfoyUkrLbaaunVV19NI0eOrNrm/vvvT506dUpLLLFEnfvo0KFDXl/9AQAANPMuWNHt6rrrrku33357vhdIecxG586dU8eOHXM3q1i/2WabpW7duuUxIIcddlieIWuZZZbJ28a0vRE0dtlll3TmmWfmfRx33HF53xE0AACAhtHoWkAuueSS3AUqbjYYLRrlxw033JDXxxS6Mb1uhIwBAwakI444Im277bbpjjvuqNpHmzZtcveteI7WkJ133jnfB6T6fUMAAIDitW2MXbCmpU+fPvlmhb8kZsn673//W8GSAQAAza4FBAAAaL4EEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAIIAAAQPOjBQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAaFoB5IUXXkivvvpq1evbb789bb311unYY49N48ePr8QhAACAZqAiAWTfffdN77zzTv75gw8+SDvssEOaffbZ04033piOOuqoShwCAABoBioSQCJ8LLfccvnnCB1rr712uu6669KQIUPSzTffXIlDAAAAzUBFAkipVEqTJ0/OPz/wwANps802yz/36dMnff3115U4BAAA0AxUJICsuOKK6bTTTkvXXHNNevTRR9Pmm2+el3/44YepZ8+elTgEAADQDFQkgJx//vl5IPpBBx2U/vznP6eFF144L7/pppvS6quvXolDAAAAzUDbSuxkmWWWqTELVtlZZ52V2rRpU4lDAAAAzUDF7gMyatSo9M9//jMNGjQoffvtt3nZG2+8kUaOHFmpQwAAAE1cRVpAXnnllbTBBhukLl26pOHDh6e99947de3aNd1yyy3p448/TldffXUlDgMAADRxFWkBOfzww9Mee+yR3n333TTbbLNVLY/ZsB577LFKHAIAAGgGKhJAnnvuuXwzwtrmm2++9MUXX1TiEAAAQDNQkQDSoUOHNGbMmDpvUNi9e/dKHAIAAGgGKhJAfv3rX6dTTjklTZgwIb9u1apVHvtx9NFHp2233bYShwAAAJqBigSQc845J33//fepR48e6aeffkrrrLNOvhfIXHPNlf7yl79U4hAAAEAzUJFZsDp37pzuv//+9OSTT6aXX345h5EVVlghbbjhhpXYPQAA0ExUJICUrbHGGvkBAAAwy7pgHXLIIemCCy6YYvnf//73dOihh1biEAAAQDNQkQBy880319nysfrqq6ebbrqpEocAAACagYoEkG+++SaPA6mtU6dO6euvv67EIQAAgGagIgEkZry65557plh+9913pwUXXLAShwAAAJqBigSQww8/PB111FHpxBNPTI8++mh+nHDCCemYY45Jhx122Azta/DgwWmllVbKU/jGtL5bb711evvtt2ts8/PPP6cDDzwwdevWLc0555z5XiNffvlljW3iPiSbb755mn322fN+jjzyyDRx4sRKvF0AAKAhZ8Hac88907hx4/I9P0499dS8rF+/fumSSy5Ju+666wztK8JLhIsIIREYjj322LTRRhulN954I80xxxx5mwg1d911V7rxxhtz16+DDjoobbPNNnka4DBp0qQcPnr16pWeeuqp9Pnnn+dytGvXLv31r3+txFsGAABmQqtSqVRKFfTVV1+ljh075paJSu0vWjAimKy99tpp9OjRqXv37um6665L2223Xd7mrbfeSosvvngaOnRoWnXVVXPXry222CKNGDEi9ezZM29z6aWX5juzx/7at2//i8cdM2ZMDjdxvBjLAgA0vH7H3NXQRaARGH765g1dhBZtTD2vkyvSBau6CAeVCh8h3ljo2rVrfh42bFiaMGFCjZscDhgwIC2wwAI5gIR4XnrppavCR9h4441zZb3++usVKxsAANAAASTGX+yyyy6pd+/eqW3btqlNmzY1HjNr8uTJ+T4iMcXvUkstlZd98cUXuQWjS5cuNbaNsBHryttUDx/l9eV1dYkuZBFQqj8AAIBGOAZk9913z4O+jz/++DTvvPOmVq1aVWK3eSzIa6+9lp544ok0q8Xg95NPPnmWHwcAAFqyigSQCAiPP/54Wm655VKlxMDyO++8Mz322GNp/vnnr1oeA8vHjx+fRo0aVaMVJFphYl15m2effbbG/sqzZJW3qW3QoEF5Nq+yaAHp06dPxd4PAABQoS5YcaFeqbHssZ8IH7feemt66KGHUv/+/WusHzhwYJ7N6sEHH6xaFtP0RgvMaqutll/H86uvvppGjhxZtc3999+fB8ksscQSdR63Q4cOeX31BwAA0AgDyPnnn5/v+TF8+PCKdLu69tpr8yxXcS+QGLMRj59++imvjxH3e+21V26tePjhh/Og9D322COHjpgBK8S0vRE0YlzKyy+/nO6999503HHH5X1H0AAAAJrwNLxzzz13+vHHH/N9O+LGf9FCUd233347/QWayviRK6+8Mo81Kd+I8IgjjkjXX399HjweM1xdfPHFNbpXffTRR2n//fdPjzzySL5/yG677ZZOP/30PEh+epiGFwAaH9PwEkzD27Dqe53ctlItIJUyPXlottlmSxdddFF+TE3fvn3Tf//734qVCwAAqL+KBJBoXQAAZi3f/gPNQcVuRPj+++/ncRY77rhj1eDvuCO5G/8BAAAVDSCPPvpovvP4M888k2655Zb0/fff5+UxAPzEE0+sxCEAAIBmoCIBJGbAOu200/JUt3GX8rL1118/Pf3005U4BAAA0AxUJIDEPTd+85vfTLG8R48e6euvv67EIQAAgGagIgEk7kj++eefT7H8xRdfTPPNN18lDgEAADQDFQkgO+ywQzr66KPzDQPjPh6TJ09OTz75ZPrTn/6Udt1110ocAgAAaAYqEkD++te/pgEDBqQ+ffrkAehxF/K11147rb766nlmLAAAgIrcByRuHBgtHxdccEE64YQT8niQCCHLL798WmSRRdQyAABQ2QCy8MIL5/t9ROCIVhAAAIBZ0gWrdevWOXh888039d0VAADQzFVkDMjpp5+ejjzyyPTaa69VYncAAEAzVe8uWCFmuvrxxx/Tsssum29E2LFjxxrrv/3220ocBgAAaOIqEkDOP//8SuwGAABo5uodQCZMmJAeffTRdPzxx6f+/ftXplQAAECzVO8xIO3atUs333xzZUoDAAA0axUZhL711lun2267rRK7AgAAmrGKjAGJaXhPOeWU9OSTT6aBAwemOeaYo8b6Qw45pBKHAQAAmriKBJDLL788denSJQ0bNiw/qmvVqpUAAgAAVC6AfPjhh5XYDQAA0MxVZAwIAABAYS0ge+655zTXX3HFFZU4DAAA0MRVJIB89913U9wb5LXXXkujRo1K66+/fiUOAQAANAMVCSC33nrrFMsmT56c9t9//7TQQgtV4hAAAEAzMMvGgLRu3Todfvjh6bzzzptVhwAAAJqYWToI/f33308TJ06clYcAAABaWhesaOmorlQqpc8//zzdddddabfddqvEIQAAgGagIgHkxRdfnKL7Vffu3dM555zzizNkAQAALUdFAsjDDz9cid0AAADNXOtK3Qn93XffnWJ5LBs+fHglDgEAADQDFQkgu+++e3rqqaemWP7MM8/kdQAAABULIDEGZI011phi+aqrrppeeuklNQ0AAFQugLRq1SqNHTt2iuWjR49OkyZNqsQhAACAZqAiAWTttddOgwcPrhE24udYtuaaa1biEAAAQDNQkVmwzjjjjBxCFltssbTWWmvlZY8//ngaM2ZMeuihhypxCAAAoBmoSAvIEksskV555ZX0u9/9Lo0cOTJ3x9p1113TW2+9lZZaaqlKHAIAAGgGKtICEnr37p3++te/Vmp3AABAM1SRFpArr7wy3XjjjVMsj2VXXXVVJQ4BAAA0AxUJIDHYfJ555plieY8ePbSKAAAAlQ0gH3/8cerfv/8Uy/v27ZvXAQAAVCyAREtHDEKv7eWXX07dunVT0wAAQOUCyI477pgOOeSQ9PDDD+f7f8Qjpt/94x//mHbYYYdKHAIAAGgGKjIL1qmnnpqGDx+eNthgg9S27f/tcvLkyXkqXjNjAQAAFQ0g7du3TzfccEMOItHtqmPHjmnppZfOY0AAAAAqfh+Q0LVr17TeeuvVOSMWAABAvceAjBo1Kh144IE5dPTs2TM/4ueDDjoorwMAAKhIC8i3336bVltttfTZZ5+lnXbaKS2++OJ5+RtvvJGGDBmSHnzwwfTUU0+lueeeuz6HAQAAmol6BZBTTjklj/94//33c8tH7XUbbbRRfj7vvPPqW04AAKCld8G67bbb0tlnnz1F+Ai9evVKZ555Zrr11lvrcwgAAKAZqVcA+fzzz9OSSy451fVLLbVU+uKLL+pzCAAAoBmpVwCJweZx/4+p+fDDD/PMWAAAAPUOIBtvvHH685//nMaPHz/FunHjxqXjjz8+bbLJJmoaAACozCD0FVdcMS2yyCJ5Kt4BAwakUqmU3nzzzXTxxRfnEHLNNdfU5xAAAEAzUq8AMv/886ehQ4emAw44IA0aNCiHj9CqVav0q1/9Kv39739Pffr0qVRZAQCAln4n9P79+6e77747fffdd+ndd9/NyxZeeGFjPwAAgMoHkLK42eDKK69cqd0BAADNUL0GoQMAAMwIAQQAACiMAAIAADT+ALLCCivkgefl6Xh//PHHSpYLAABohmY6gMS9Pn744Yf888knn5y+//77SpYLAABohmZ6Fqzlllsu7bHHHmnNNdfM9/84++yz05xzzlnntieccEJ9yggAALT0ADJkyJB04oknpjvvvDPfeDDuBdK27ZS7i3UCCAAAUK8Asthii6V///vf+efWrVunBx98MPXo0UOtAgAAs/ZGhJMnT67EbgAAgGauYndCf//999P555+fB6eHJZZYIv3xj39MCy20UKUOAQAANHEVuQ/IvffemwPHs88+m5ZZZpn8eOaZZ9KSSy6Z7r///kocAgAAaAYq0gJyzDHHpMMOOyydfvrpUyw/+uij069+9atKHAYAAGjiKtICEt2u9tprrymW77nnnumNN96YoX099thjacstt0y9e/fOM2jddtttNdbvvvvueXn1xyabbFJjm2+//TbttNNOqVOnTqlLly65bO5TAgAAzSSAdO/ePb300ktTLI9lMzozVtzccNlll00XXXTRVLeJwPH5559XPa6//voa6yN8vP7667n7V0wTHKFmn332maFyAAAAjbQL1t57750v8D/44IO0+uqr52VPPvlkOuOMM9Lhhx8+Q/vadNNN82NaOnTokHr16jXV1ph77rknPffcc2nFFVfMyy688MK02Wab5ZslRssKAADQhAPI8ccfn+aaa650zjnnpEGDBuVlcaF/0kknpUMOOSRV2iOPPJJbVuaee+60/vrrp9NOOy1169Ytrxs6dGjudlUOH2HDDTfM9yqJgfG/+c1v6tznuHHj8qNszJgxFS83AAC0dBUJIDEOIwahx2Ps2LF5WQSSWSG6X22zzTapf//+eerfY489NreYRPBo06ZN+uKLL6bo9hV3aO/atWteNzWDBw9OJ5988iwpMwAAUOH7gJTNquBRtsMOO1T9vPTSS+cpf+NeI9EqssEGG8z0fqPlpnp3sWgB6dOnT73LCwAAVHgQekNacMEF0zzzzJPee++9/DrGhowcObLGNhMnTswzY01t3Eh5XEnMmlX9AQAAVFaTDyCffvpp+uabb9K8886bX6+22mpp1KhRadiwYVXbPPTQQ2ny5MlplVVWacCSAgAAFe+CVV9xv45ya0b48MMP83S+MYYjHjFOY9ttt82tGTEG5KijjkoLL7xw2njjjfP2iy++eB4nEjNzXXrppWnChAnpoIMOyl23zIAFAABNvAUkLvBj7MW7775bkQI9//zzafnll8+PEOMy4ucTTjghDzJ/5ZVX0q9//eu06KKL5hsMDhw4MD3++OO5C1XZv/71rzRgwIBcrph+d80110z/+Mc/KlI+AACgAVtA2rVrl0NBpay77rqpVCpNdf299977i/uIlpLrrruuYmUCAAAa0RiQnXfeOV1++eWV2BUAANCMVWQMSMwydcUVV6QHHnggd4maY445aqw/99xzK3EYAACgiatIAHnttdfSCiuskH9+5513prhJIQAAQMUCyMMPP6w2AQCAYu8DEtPnxiDxn376Kb+e1mByAACg5alIAIkbAcaUtzE1bkx7+/nnn+flMU3uEUccUYlDAAAAzUBFAshhhx2Wp+P9+OOP0+yzz161fPvtt0/33HNPJQ4BAAA0AxUZA3Lfffflrlfzzz9/jeWLLLJI+uijjypxCAAAoBmoSAvIDz/8UKPlo+zbb7+tcYdyAACgZatIAFlrrbXS1VdfXWPq3cmTJ6czzzwzrbfeepU4BAAA0AxUpAtWBI0YhP7888+n8ePHp6OOOiq9/vrruQXkySefrMQhAACAZqAiLSBLLbVUvgHhmmuumbbaaqvcJWubbbZJL774YlpooYUqcQgAAKAZqEgLSOjcuXP685//XKndAQAAzVDFAsh3332XLr/88vTmm2/m10sssUTaY489UteuXSt1CAAAoImrSBesxx57LPXr1y9dcMEFOYjEI37u379/XgcAAFCxFpADDzww33TwkksuSW3atMnLJk2alA444IC87tVXX1XbAABAZVpA3nvvvXTEEUdUhY8QPx9++OF5HQAAQMUCyAorrFA19qO6WLbsssuqaQAAoH5dsF555ZWqnw855JD0xz/+Mbd2rLrqqnnZ008/nS666KJ0+umnz+whAACAZqZVqVQqzcwvtm7dOt/x/Jd+PbaJ8SBNzZgxY/LUwqNHj06dOnVq6OIAQOp3zF1qAVJKw0/fXD004evkmW4B+fDDD2f2VwEAgBZqpgNI3759K1sSAACg2avYjQhHjBiRnnjiiTRy5Mg0efLkGutijAgAAEBFAsiQIUPSvvvum9q3b5+6deuWx32Uxc8CCAAAULEAcvzxx6cTTjghDRo0KA9OBwAAqEtF0sKPP/6YdthhB+EDAACY9QFkr732SjfeeGMldgUAADRjFemCNXjw4LTFFluke+65Jy299NKpXbt2Ndafe+65lTgMAADQxFUsgNx7771pscUWy69rD0IHAACoWAA555xz0hVXXJF23313tQoAAMzaMSAdOnRIa6yxhmoGAABmfQD54x//mC688MJK7AoAAGjGKtIF69lnn00PPfRQuvPOO9OSSy45xSD0W265pRKHAQAAmriKBJAuXbqkbbbZphK7AgAAmrGKBJArr7yyErsBAACauYqMAQEAACisBaR///7TvN/HBx98UInDAAAATVxFAsihhx5a4/WECRPSiy++mO+MfuSRR1biEAAAQDPQtlLT8NbloosuSs8//3wlDgEAADQDs3QMyKabbppuvvnmWXkIAACgCZmlAeSmm25KXbt2nZWHAAAAWloXrOWXX77GIPRSqZS++OKL9NVXX6WLL764EocAAACagYoEkK233rrG69atW6fu3bunddddNw0YMKAShwAAAJqBigSQE088sRK7AQAAmjk3IgQAAJpGC0h0tZrWDQhDrJ84cWJ9DgMAADQT9Qogt95661TXDR06NF1wwQVp8uTJ9TkEAADQjNQrgGy11VZTLHv77bfTMccck+6444600047pVNOOaU+hwAAAJqRio0BGTFiRNp7773T0ksvnbtcvfTSS+mqq65Kffv2rdQhAACAlh5ARo8enY4++ui08MILp9dffz09+OCDufVjqaWWqkwJAQCAZqNeXbDOPPPMdMYZZ6RevXql66+/vs4uWQAAAGWtSnHb8nrMgtWxY8e04YYbpjZt2kx1u1tuuSU1NWPGjEmdO3fOLTydOnVq6OIAQOp3zF1qAVJKw0/fXD004evkerWA7Lrrrr84DS8AAEBFAsiQIUPq8+sAAEAL407oAABAYQQQAACgMAIIAADQNMaAAEBRzAAF0DxoAQEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAAWm4Aeeyxx9KWW26ZevfunVq1apVuu+22GutLpVI64YQT0rzzzps6duyYNtxww/Tuu+/W2Obbb79NO+20U+rUqVPq0qVL2muvvdL3339f8DsBAAAafQD54Ycf0rLLLpsuuuiiOtefeeaZ6YILLkiXXnppeuaZZ9Icc8yRNt544/Tzzz9XbRPh4/XXX0/3339/uvPOO3Oo2WeffQp8FwAAQF3apkZm0003zY+6ROvH+eefn4477ri01VZb5WVXX3116tmzZ24p2WGHHdKbb76Z7rnnnvTcc8+lFVdcMW9z4YUXps022yydffbZuWUFAABoGI2uBWRaPvzww/TFF1/kbldlnTt3TqusskoaOnRofh3P0e2qHD5CbN+6devcYgIAADScRtcCMi0RPkK0eFQXr8vr4rlHjx411rdt2zZ17dq1apu6jBs3Lj/KxowZU+HSAwAATaoFZFYaPHhwbk0pP/r06dPQRQIAgGanSQWQXr165ecvv/yyxvJ4XV4XzyNHjqyxfuLEiXlmrPI2dRk0aFAaPXp01eOTTz6ZJe8BAABasiYVQPr3759DxIMPPlijq1SM7VhttdXy63geNWpUGjZsWNU2Dz30UJo8eXIeKzI1HTp0yNP2Vn8AAADNfAxI3K/jvffeqzHw/KWXXspjOBZYYIF06KGHptNOOy0tssgiOZAcf/zxeWarrbfeOm+/+OKLp0022STtvffeeareCRMmpIMOOijPkGUGLAAAaFiNLoA8//zzab311qt6ffjhh+fn3XbbLQ0ZMiQdddRR+V4hcV+PaOlYc80187S7s802W9Xv/Otf/8qhY4MNNsizX2277bb53iEAAEDDalWKm2swhejaFYPRYzyI7lgADa/fMXc1dBGARmL46Zs3dBFatDH1vE5uUmNAAACApk0AAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIVpcgHkpJNOSq1atarxGDBgQNX6n3/+OR144IGpW7duac4550zbbrtt+vLLLxu0zAAAQBMNIGHJJZdMn3/+edXjiSeeqFp32GGHpTvuuCPdeOON6dFHH00jRoxI22yzTYOWFwAA+D9tUxPUtm3b1KtXrymWjx49Ol1++eXpuuuuS+uvv35eduWVV6bFF188Pf3002nVVVdtgNICAABNugXk3XffTb17904LLrhg2mmnndLHH3+clw8bNixNmDAhbbjhhlXbRvesBRZYIA0dOrQBSwwAADTJFpBVVlklDRkyJC222GK5+9XJJ5+c1lprrfTaa6+lL774IrVv3z516dKlxu/07Nkzr5uWcePG5UfZmDFjZtl7AACAlqrJBZBNN9206udlllkmB5K+ffum//znP6ljx44zvd/BgwfnMAMAAMw6TbILVnXR2rHoooum9957L48LGT9+fBo1alSNbWIWrLrGjFQ3aNCgPIak/Pjkk09mcckBAKDlafIB5Pvvv0/vv/9+mnfeedPAgQNTu3bt0oMPPli1/u23385jRFZbbbVp7qdDhw6pU6dONR4AAEAL74L1pz/9KW255Za521VMsXviiSemNm3apB133DF17tw57bXXXunwww9PXbt2zSHi4IMPzuHDDFgAANDwmlwA+fTTT3PY+Oabb1L37t3TmmuumafYjZ/Deeedl1q3bp1vQBiDyjfeeON08cUXN3SxAQCAlFKrUqlUUhNTilmwokUlxoPojgXQ8Podc1dDFwFoJIafvnlDF6FFG1PP6+QmPwYEAABoOgQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMK0Le5QAABQf/2OuavFV+Pw0zdvsnWgBQQAACiMAAIAABRGAAEAAAojgAAAAIUxCB2gCTDgEoDmQgsIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDBtizsUwMzpd8xdqg4AmgktIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUJi2xR0KmBn9jrlLxQEAzYYWEAAAoDDNOoBcdNFFqV+/fmm22WZLq6yySnr22WcbukgAANCiNdsuWDfccEM6/PDD06WXXprDx/nnn5823njj9Pbbb6cePXqkpkDXGwAAmptm2wJy7rnnpr333jvtscceaYkllshBZPbZZ09XXHFFQxcNAABarGbZAjJ+/Pg0bNiwNGjQoKplrVu3ThtuuGEaOnRonb8zbty4/CgbPXp0fh4zZkxqKJPH/dhgxwYAoPEa04DXqOVjl0qlmfr9ZhlAvv766zRp0qTUs2fPGsvj9VtvvVXn7wwePDidfPLJUyzv06fPLCsnAADMjM7npwY3duzY1Llz5xn+vWYZQGZGtJbEmJGyyZMnp2+//TZ169YttWrVaqrpLwLKJ598kjp16lRgaZs39apOmwqfVXXaVPisqtOmwme1adRptHxE+Ojdu/dM/X6zDCDzzDNPatOmTfryyy9rLI/XvXr1qvN3OnTokB/VdenSZbqOFydTAKk89apOmwqfVXXaVPisqtOmwme18dfpzLR8NOtB6O3bt08DBw5MDz74YI0WjXi92mqrNWjZAACgJWuWLSAhulPttttuacUVV0wrr7xynob3hx9+yLNiAQAADaPZBpDtt98+ffXVV+mEE05IX3zxRVpuueXSPffcM8XA9PqILlsnnnjiFF23UK+Njc+qem0qfFbVa1Phs6pem4oOjfB6tVVpZufPAgAAmEHNcgwIAADQOAkgAABAYQQQAACgMAIIAABQGAFkOjz22GNpyy23zHd7jLui33bbbVPddr/99svbxLS/1K9O33zzzfTrX/863+hmjjnmSCuttFL6+OOPVWs96vX7779PBx10UJp//vlTx44d0xJLLJEuvfRSdToNgwcPzp+9ueaaK/Xo0SNtvfXW6e23366xzc8//5wOPPDA1K1btzTnnHOmbbfddooboTL9dfrtt9+mgw8+OC222GL5c7rAAgukQw45JI0ePVo11vOzWhbzz2y66aa/+DetpZveOh06dGhaf/3189+quNHb2muvnX766acGKXNzqdeYwXSXXXbJN5COel1hhRXSzTff3GBlbuwuueSStMwyy1TdbDDue3f33Xc32r9TAsh0iPuHLLvssumiiy6a5na33nprevrpp2f6tvQtyS/V6fvvv5/WXHPNNGDAgPTII4+kV155JR1//PFpttlmK7yszale4/44MR31tddemwPeoYcemgPJ//7v/xZe1qbi0Ucfzf9ox//b999/f5owYULaaKONcl2XHXbYYemOO+5IN954Y95+xIgRaZtttmnQcjflOo36i8fZZ5+dXnvttTRkyJD8ud1rr70auuhN/rNaFl+SRfig/nUa4WOTTTbJy5999tn03HPP5X9XW7d2iVWfet11111zKIm/T6+++mr+N/V3v/tdevHFF31s6xBfLJ5++ulp2LBh6fnnn8+BeKuttkqvv/564/w7FdPwMv2iym699dYpln/66ael+eabr/Taa6+V+vbtWzrvvPNUaz3qdPvtty/tvPPO6rDC9brkkkuWTjnllBrLVlhhhdKf//xndT2dRo4cmev20Ucfza9HjRpVateuXenGG2+s2ubNN9/M2wwdOlS9zkSd1uU///lPqX379qUJEyao05n8rJa9+OKL+e/V559/PtW/aUx/na6yyiql4447TpVVuF7nmGOO0tVXX11ju65du5Yuu+wydT2d5p577tI///nPRvl3SjyvgMmTJ+dmwiOPPDItueSSldhlaun1edddd6VFF100bbzxxrl5dpVVVtFNoAJWX331/G3SZ599lrtgPPzww+mdd97J3zwxfcrdgLp27Zqf49um+PZuww03rNomWu6i21B8M8qM1+nUtoluBW3bNtv75xZSrz/++GP6/e9/n1tJo2sL9avTkSNHpmeeeSb/nYp/X+Nmx+uss0564oknVG09P6tRnzfccEPukhnXBf/+979zN6J1111X3f6CSZMm5fqKFqXoitUY/04JIBVwxhln5D+K0UeZ+ot/0GOsQjQlRrP2fffdl37zm9/kpsJoNmTmXXjhhXncRzTVtm/fPtdvXIhEf2V+WfwRjG5ra6yxRlpqqaWq+ilHXXbp0qXGtnEhEuuY8Tqt7euvv06nnnpq2meffVRnPes1umHEhV10zaD+dfrBBx/k55NOOintvffeuatgjFXYYIMN0rvvvquK6/FZ/c9//pMvmmPMQtzBe999981d3RdeeGH1OhXRVS3Gd0R9xZjkqK/4m98Y/075KqmeIlX+7W9/Sy+88IL+tBX8xyjEH8j4YxmWW2659NRTT+UB0/HtEjMfQKLPbbSC9O3bNw9aj364MW6p+jcj1C3qKsYk+HazuDodM2ZM2nzzzfMf0bjIY+brNf6/f+ihh/Shr+Bntfz3Ki6O99hjj/zz8ssvnx588MF0xRVX5MHWzHi9hhj3OWrUqPTAAw+keeaZJ/eCiDEgjz/+eFp66aVVax1i4o6XXnoptyjddNNNabfddmu0X9wKIPUU/yPEN/bRjFW96euII47Ig/yGDx9e30O0OPEPTbQoxQVHdYsvvrgLv3qIGVmOPfbY/I1IXNCFmDEj/rGKwb4CyLTFoNI777wzh7ZoQSqLbizjx4/Pfyirf7sUs4vo4jJzdVo2duzY3EoXM+XE57Zdu3Yz+KlvmaZWrxE+YoKP2t+Cxmw4a621Vp7wgxmr03nnnTc/1/X3yqyNM/9Zjc/p3//+9xxMyl3bY4KVuOaKVnuzN9YtWjnKLUQDBw7MEyLEl+Tbb799o/s7pQtWPcXYj5ihKS7iyo/4NjnGg9x7772VOUst8H+gmJ6v9pR8MVYhvrVn5kRTdjxqz8zSpk2bqm/xmFKMlYk/knEBHBdw/fv3r7E+/pGPC+P4xrMsPrtx8RF9b5nxOi23fMTYpPj3IL65NwNe/ev1mGOOmeLvVTjvvPPSlVde6aM6E3Xar1+//Dff36vK1muMVQr+XtVP/G0fN25co/w7pQVkOsR4hPfee6/q9Ycffpj/4Y7BUtHyEf0Tq4uTHIkymsKYuTqNABeJPcYmrLfeerlfbUwf5xu6+n1Wo/ta1G3cWyHCXDTNXn311encc8/1UZ1G94Drrrsu3X777fmb+HJ/2bg/TdRjPMf0sDHFcdRzDJSOe1jEP+qrrrqqep2JOi2Hj7gIiSmj43U8Qvfu3XNoZsbrNf4u1fVtZ/zbUFcI5JfrNKYyjn9TTzzxxPwNfXQXvuqqq9Jbb72Vu8Awc/+uxgDp+CY/urZFC31cZ0UXrJiyN1pMmNKgQYPyvX3i/+doPY76jWum+DK8Uf6dapC5t5qYhx9+OE9VVvux22671bm9aXgrU6eXX355aeGFFy7NNttspWWXXbZ02223VfCstsx6jWk3d99991Lv3r1zvS622GKlc845pzR58uSGLnqjVVd9xuPKK6+s2uann34qHXDAAXnKw9lnn730m9/8Jtc1M1enU/scx+PDDz9UrfX4rNb1O6bhrd///2Hw4MGl+eefP///v9pqq5Uef/xxn9N61us777xT2mabbUo9evTI9brMMstMMS0v/8+ee+6Zrz9juvLu3buXNthgg9J9993XaP9OtYr/NEz0AQAAWhpjQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIBUlP8PbfwcSyOqSrgAAAAASUVORK5CYII=", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -978,9 +1189,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "3a35cffc6cb04372891197be605e0c75", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -988,9 +1214,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "4cb3c88961624744baf1d28362207336", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyAAAAMgCAYAAADbcAZoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXLNJREFUeJzt/QWYXOX9P+4/ERICRIoECAQS3C14cCgUUgoFWqA4FFq0EDS4FbcPFKkAKbRQihcoUNw1uHuBEhwSIBCd//V+vv/Z3+5mN1mZPbs7ue/rmuzOmTNHZzbP6zxyupRKpVICAAAoQNciVgIAACCAAAAAhVIDAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCBA1XvvvfdSly5d0siRI1NHcscdd6QVVlghzTzzzHn7vv7661RtzjzzzLTQQgulbt265X0tyvHHH5+PaW2DBg1Ku+66a+poYptmm222Js0b+xT7Vhaf6ZgWn/Gy9dZbLz9oXEf9LMCMQgABmqxc2Kn96N+/f1p//fXT7bffXviRvP/+++tsy0wzzZQLuzvvvHN65513KrKORx99NBf4Kh0Ovvjii/TLX/4y9erVK1144YXpyiuvTLPOOmsqykUXXdTmgew///lPOuyww9LQoUPT5Zdfnk455ZRUbT766KP8+XjuuedSR9UZthGYsXRv7w0AOp8TTzwxDR48OJVKpfTJJ5/kguxmm22WbrnllvTTn/608O054IAD0iqrrJImTpyYnnnmmfSnP/0p3XbbbenFF19MAwYMaHUAOeGEE/LV0n79+lVsm5966qn0zTffpJNOOilttNFGqWgRQOacc842vQp87733pq5du6ZLL7009ejRIxXp6KOPTkcccUQhhfv4fMQV9SJqeL7//vvUvXv36Qa/9tzGzuD111/Pn02gfQggQLNtuummaeWVV655vscee6S55547XX311e0SQNZee+20zTbb5N932223tNhii+VQ8te//jWNGDEidUSffvpp/lnJUNMR9zFqeCoRPr777rtm1RBFIX16BfXOKJrrTU/RYa+9TZo0KU2ZMqVZ+92zZ8823SZg2sR/oNWiEB0FzfoFvig0HnzwwWngwIH5P/zFF188nXXWWbnmpHw1d4kllsiP+L3syy+/TPPOO29ac8010+TJk5u9PRtssEH++e677073Cn2ElyjYxj5sscUW6dVXX615PZqtHHroofn3qPEpN/Wq3d6+Iddee20aMmRIPiZRy7Djjjum//3vfzWvR/v8XXbZJf8eNTexzOnVRDz77LM5+PXp0yf3F9hwww3T448/Pt1+Dw31E4gr4S+//HJ64IEHavapOX0GosAXNTcLL7xwPq+xvCOPPDKNHz++Zp5YZjS7is9AeR1NbfJV7hPx9ttv55q13r17px122CG/9tBDD6Vf/OIXaYEFFsjrjs/WQQcdVOfzM61j0Vx33XVXWmuttfLnI7YpPsOxr+UmgHH+ysG3/n42dVvLotngJptskj+PUXMXNY3l70pjfUAaUrsPyLS28bjjjsvNFj/77LOplrHXXnvlff7hhx+adJzKx/uNN97In/e+ffumueaaKx1zzDF5Hz744IP8/YrP7zzzzJPOPvvsOu+fMGFCOvbYY/P3Jt4bxyC+m/fdd1+D/bni78h5551X8xl85ZVXavY3Lo5EUIvX/vjHPzapP1D5O/LII4+k4cOH522Pbfj5z3/e4PEBWqf6Lg8BbW7MmDHp888/zwWLuMp9wQUXpG+//TYXPMritZ/97Ge5ABE1JNH0484778wF+iiMn3vuubmAHrUU0UfgqKOOSuecc05+77777pvXEYWC6LzcXFFwDXPMMUej89x99925QB99RqKAEoXC2I/YlmjGFQWUrbbaKheoomYntjfCRIjCSWNim6OgF4W+U089NTdR+7//+79csIkQEYW62NcoyEZTsXJztigsNSbCQhTGovAWfSqi0BgFqyhkRohYbbXVmnV8ouC2//775wJ1bEuIGqym+vWvf53PW9Q6RcB84okn8r5GeLvxxhvzPNGnJfbvySefTH/5y1/ytAiUzQk5URiPwn8UNmeZZZaacDdu3Li099575/Mby4/z9uGHH+bXKimOe9ToLbfccvk8RUH3rbfeyucyLLnkknl6FJyjwB7nqPZ+NmdbI2j/5Cc/Sauvvno644wz8gAFERDiOMQ6Wmpa2xjHNl675ppr0n777VcnDFx33XVp6623blKNS23bbrttXudpp52Wm0GefPLJafbZZ8+f17gwcPrpp6e///3v6ZBDDsnfkXXWWSe/b+zYsflzsv3226c999wzN0+MpnvxGYjjVr/pWITbCEexT3FeYh3x/YpjGBcvoslZHNPYv2l9X+uL78WPfvSjfOwj7MR3JY5NHCOggkoATXT55ZfH5dipHj179iyNHDmyzrw33XRTfu3kk0+uM32bbbYpdenSpfTWW2/VTBsxYkSpa9eupQcffLB07bXX5vedd955092e++67L8972WWXlT777LPSRx99VLrttttKgwYNyut46qmn8nzvvvtuni+2v2yFFVYo9e/fv/TFF1/UTHv++efzduy88841084888z83ljG9EyYMCEvc5lllil9//33NdNvvfXWvIxjjz12qmNZ3sZp2XLLLUs9evQovf322zXTYl979+5dWmeddWqmHXfccXmZ9ZXXVXsfll566dK6665baq7nnnsuL+vXv/51nemHHHJInn7vvffWTNtll11Ks846a7PXEe+LZR1xxBFTvTZu3Lippp166qn5fP/3v/+d5rFYcMEF87Kb6txzz83LiM9WY+L81f9sNXdby/u7//7710ybMmVKadiwYfm8115/zBf7Nq1zG+e19rmd1jauscYapdVWW63OtBtuuCHPH9+vpiof77322qtm2qRJk0rzzz9/3t/TTjutZvpXX31V6tWrV51zEfOOHz++zjJjvrnnnru0++6710wrf5f79OlT+vTTT+vMv/nmm5dmmWWW0v/+97+aaW+++Wape/fu0/0slI/jRhttlI992UEHHVTq1q1b6euvv27ysQCmTxMsoNli1KZomhKPv/3tb3kUrLgqfsMNN9TM8+9//zvXXkRfjNriinmUo2qPmhU1EEsvvXRulrTPPvukddddd6r3Tcvuu++er3JGs5Vhw4blZj9xhb52P5XaRo8enUcEiiYYceW0LK50//jHP87b3hJPP/10rhGKfah95Ti2KZqZxRXh5oqruNGpeMstt8y1NWVxlfdXv/pVevjhh/PV46KUj000U6l/XkNL9rExUXNQX9SalcV5jpq4uJofn6m4Al5J5f45N998c+5j0FzN3dbatRDRHCieR21E1Na1lRgxLmqwyrWGIWooorlYfA+bK/4OlMX3P76Dsb9RC1r7uEYNYO2R6mLech+OONbRDDNqf+L9USNZX9TO1K7ZiO9JHKf4ntQeeGKRRRbJNZ1NFTUqtZtrRY1RLPu///1vk5cBTJ8AAjTbqquumkduike0zY9C51JLLVVTYArxH3YUBKL9fm3RPKP8elkUPC677LLcZyOaXkTziua034/mJRGGok/HCy+8kEf92WmnnRqdv7zuKATVF9sXBcUoMDbXtJYbAaQlhZhofx7NeBrb1iisRfv6osQ+xOhBUbCrLdr1R8GyUgW16E80//zzTzX9/fffrwmO0YQsCqHlgnI026ukaE4UTfKiUB1N1Lbbbrv0z3/+s8lhpDnbGse0dsAMMZhCmF6fo9buYzRhitBR3q5bb701f69b0ocm+rvUFv05IoyXmy/Wnv7VV1/VmRYXDeIiQMwfTdbieMXflobOazRbrC2CfzSjrP+5DA1Na+r2R3OsUH9bgdYRQIBWi8JT1IJEzcKbb77ZomVE/5AQ7bqbu4xll102h6HYhvi9Gkc/aorGCowt6cjf0nVVShSK6w+TGvsRNVRRKD388MPTTTfdlINnudN3S2oppleD8eCDD+Yr6xFoI9xGgT22YXrHtOhtbakoYEc/l3IAib4fMZhA7f5czdFQn63G+nHV7mAfNakR1qIvVPT9iD4wcbyi30hDx6p27VIlNWVbgdYTQICKiOYSITqjhwUXXDDXRESNRm2vvfZazetlUbCLzqLReXvFFVfMV5wrfTW7tvK6414A9cX2xdXa8pCvzSloT2u5Ma32PjdVXAWODtiNbWsU0qO5TO2rtfVvmthQrURLA0TsQxQI64fE6Gwf623JPjZV3NclBgWIEZSiUB+jKkXwbO29XqYljm+MOBYDJMRIS7///e9zTVt5dKbGjmNztzWOaf2bZ8b7QwyI0BrTO9fRDCvWFfemiSAS38FoElmkCD5RAxTNOCPsRefzOF5NHYUrbogaNScxSEB9DU0D2pcAArRa3AAw+ilEU6pyE6sYPjWuAv/hD3+oM2+MJhUFonK77HhvXPmMglmMFhVXiKMwG8OVtpXoPxGj6kSTj9qF9ZdeeinvR2x7WTmINOVO6NFePQpCl1xySZ0haaO/S4wQFX1BWnJFduONN879EGo3xYljdNVVV+WRjGJ0rFAeSSuu2peV+8PUF/vVkru7l49NjA5UW3kEs5bsY3OvTte+Gh2/x+emLUQ/hPrKozGVz29jn4+WbGvt70rMG89jxLMIQK0xvc9wfBcjdMcIVTGqWktrP1qjoeMVfVMee+yxJr8/AkvUNMWFj9rho3Z/M6BjmDHbKQCtEv+hl2syou11FITjinjcebpcGN58881zk6gY5jUKzssvv3wu3EdB+sADD6wpLMcwndEh/J577sn9RaINePTpiDtZxzCvtcNAJZ155pm54LXGGmvkDrLlYXijbXrt+yzEfQlC7Ef0AYgCYexbQzfFi9eiEBc1OdHWP4YULQ/DG1exWxqq4hiV70cRHdyjiVkMaxqF4BiytSyCSrRhj/2J4Y6jUBZ9a6IWJfoj1Bb7dfHFF+dlRxv5CE7l+6dMS5zHGCwghtiNAm3sZwyTGiEnOgDHOW8r0Y8mPjcxhGsM5Ryfteuvv77N2udHrVyEuQhVUbMTn/W4g3z0TYlzEWJ7ou9LhM74/MbnIoZFbu62xtX7aHYUxzbeH9+xaL4V9xxpzjCyDWlsG8v9KOJzG5/tCDzxmYnPbdGiGVjUfsR9N+J4R3+w2N7oW1auVZ2e+N7G35jotxMDGJQvgCyzzDL5bwzQgTRhpCyARofhnXnmmfOQthdffHGd4SvDN998k4exHDBgQGmmmWYqLbroonlY2/J8o0aNykNk1h5+tDwk5yqrrJLfF0NxTm8Y3hi6d1oaGoY33H333aWhQ4fmIUFjWM8YxvOVV16Z6v0nnXRSab755stD9DZlSN5rrrmmtOKKK+bhiWefffbSDjvsUPrwww/rzNOcYXjDM888U9pkk01Ks802Wx5qdP311y89+uijU80XxzSGVY3hWxdYYIHSOeec0+BQrR9//HEe5jWG8o3XmjMk78SJE0snnHBCafDgwfm8Dhw4MA+l/MMPP9SZrzXD8Db2vjg/MVRqHIc555yztOeee+bhk+uf30oMw3vPPfeUtthii/w5jOMZP7fffvvSG2+8UWe+m2++ubTUUkvVDPda3o6mbmt5f2OY5Y033jif3xh+NvZh8uTJddbVkmF4p7WNZU8++WSeHutvifLxrj9kcWPnMrYvhoIui78Jp5xySj5H8b2J708MXx3vj2n1v8vxd6SxcxbvjfO18MILl/7yl7+UDj744Px3qinD8Nb/Ppb/xjRnSGJg+rrEP+0dggCA9vP888/n5mVXXHHFNEeQ64yiZi5uKtnSATKAytMHBABmcH/+85/zUMFbbbVV6syiKWVtETri3jXrrbdeu20TMDV9QADIPv7442keiRj6NPrItFSMbFa/gFhf3E+kGva1s7jlllvy6F7Rpyfu41O/b1P0v5heH4zoo9LY8LVFi5G0YlCL+Bmjv0U/pxgc47DDDmvvTQNq0QQLgCYN1xodpMv3sWiJKBg2NCJXbUW1Cm7rfe0sYnCEGCghhr298sorp7pxaHTsPuGEE6a5jOgw3tqhgislBoCIIZIjYMa9ZGKQiVNOOSWttNJK7b1pQC0CCABZ3HBvWmKo5BiVqKXiSnvtIVIbEkOpVsO+Vou4N0n9+5PUFyOCxSheAE0lgAAAAIXRCR0AACiMTuiNmDJlSm4qEO1hp9dWGAAAZhSlUil98803ublq167Nr88QQBoR4WPgwIGtPT8AAFCVPvjggzT//PM3+30CSCPKI4HEge3Tp0/rzg4AAFSJsWPH5gv19UfOayoBpBHlZlcRPgQQAACoq6XdFHRCBwAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDDdi1sVAM3x5ptvpm+++cZBm0H07t07Lbroou29GQBtTgAB6KDhY7HFFkvVbJ7ZuqTfDOmR/jhqQvr421J7b06H8MYbbwghQNUTQAA6oHLNx9/+9re05JJLpmrU6+s30pIP/iZte+zI9H2/6g5b0/Pqq6+mHXfcUY0XMEMQQAA6sAgfK620UqpKH3VN6cGUllxiiZQGrNDeWwNAQXRCBwAACiOAAAAAhRFAAACAwgggVJVx48alZ555Jv8EAPy/SscjgFBVXnvttTRkyJD8EwDw/yodj1GwOqDJkyenhx56KI0ePTrNO++8ae21107dunUrZD2h9rQ111wzPfroow1uS7z//vvvz4+w3nrr5UftbW3KPE3d96KOCwBQedP7f7wp5ZKi/+/viGWPyR1wm5qtRIPGjBkTd8XKP4t0/fXXlwYNGpTXXX7E85je1uvp379/aa655qozrXv37g1uSzzqz1teRnlbmzJPU/e9qcdl1KhR+bX4CZ3ZDPFZ/t+zpdJxff7fzxncDHG+maE/m9P7f7yp5ZK2KBO1dJvbw/UdZJtaW07WBKsDueGGG9I222yTll122fTYY4/lG1LFz3ge0+P1tlrPqaeemj799NP02Wef5d/j5mdhjjnmSF26dMnPy9uy9dZb50fMu9Zaa6V77rknP+L3WEYs+7DDDpvuPLX3Z1r7Hssp4rgAAMWXb6LMML1ySdH/9xdVJuvs29RiFY9EVaLoGpBJkyblBLv55puXJk+eXOe1eB7TBw8enOer9HrK037605/mR6xnwQUXzPNMnDixzronTJhQmnnmmUtdunQpDRs2rM62xu/x/l69epW6deuWf8bzhuaZZZZZapY5rX2P9cVyYv74fXrHxVVEqsUM8VlWAzJjnW9myM/m9Mo3USaI1ha1ywsNlUvK/89XskzU0m1u6/V3hm1qbTlZH5AOItryvffee+nqq69OXbvWrZiK5yNGjMj9MWK+6ENRyfXUnlYqlfJ6wj/+8Y/UvXv3OusOP/zwQ/652Wab1dnW+P3II49Mt956a37+/fffp6OOOqrRed59992aZTa274888kheTvn32vve0HEpz/vqq6+2+BhBR1D+DJc/01Q3f7uo1r9F0yvf/OQnP8llgk033XSa5ZLy//OVLBO1dJvbev2dZZtaQwDpIKIjUVhmmWUafL08vTxfJddTe1p80euvs7F19+rVq9HtbOx5Y+tubN7arze07/W3Lb6cYccdd5xqXuiM4jM9dOjQ9t4M2pi/XVTr36LplW/KZYnaZYqGyiUNlRdaWyZq6Ta39fo7yza1hgDSQcQoBuGll15Kq6+++lSvx/Ta81VyPbWn1Q4g5XkaW3dDV0PK89ZfRmPz1F5mQ/PWfr2hfa+/bYMGDco/o8/Kkksu2ehxgM5w1TGCdPkzTXXzt4tq/Vs0vfJNuSxRu0zRULmkfnmh/rTOWCbr7NvUKhVvFFYl9AHRBwTa0wzRJ0AfkBnrfNMp6QPS/v0tqrEPiADSRge2JWIItejcHR+iRx99tDR27Nj8M57H9EoNsdbQek455ZSa4dzi97/97W/597nnnjvPG8/L21J76Le11lqrdNddd+XH0KFD87SY/9BDD53uPLX3Z1r7Xp6/KcfFf+JUixnisyyAzFjnmxn2szm98k2UGaZXLmmrMlFLt7k9huK9vgNtkwDSQQ9sJcd3jkTbUe4DUt6Wou4DUnt9TTku/hOnWswQn2UBZMY633RKbXkfkNr/jze1XNIWZaKWbnN7uL6DbFNry8ld4p/2bgbWEY0dOzb17ds3jRkzJvXp06fQdbsTesvvhP7MM8+kIUOGpFGjRqWVVlqp0PMGlTRDfJY/ei6lP62b0l4PpDRghTQjmyHON2lG/2y6E3r13Al9bCvLyTqhd0DxISpiCLXG1lN/WmPbEu/fcMMN82Na65jePE3Zpum9BgB0bNP7f7yp5ZIidcSyR7cOuE3N5U7oAABAYQQQqsoSSyyRq4njJwDg/1U6Hk2wqCqzzDKL9tMA4P9VOjA1IAAAQGEEEAAAoDCaYAF0QOPGjasZArNa9fr6jbRkSunV115L3388Jc3IXn311fbeBIDCCCAAHdBrr72Wf+65556pWs0zW5f0myE90h/P/lX6+Fu3pAq9e/du79MC0OYEEIAOaMstt8w/Y0S3GFyhmv2svTegA4WPRRddtL03A6DNuRN6B7wTOgAAVGs5WSd0AACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAABBAAACA6qMGBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAoTPfiVtW5lEql/HPs2LHtvSkAANBhlMvH5fJycwkgjfjmm2/yz4EDB7b03AAAQFWXl/v27dvs93UptTS6VLkpU6akjz76KPXu3Tt16dKlvTcHAAA6hIgPET4GDBiQunZtfo8OAQQAACiMTugAAEBhBBAAAKAwAggAACCAAAAA1UcNCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAII0GKDBg1Ku+66qyPYxs4888y00EILpW7duqUVVlih6o73t99+m37961+neeaZJ3Xp0iUdeOCBha17vfXWy4+y9957L2/DyJEjU0f8vv30pz+d7nz3339/3of4WRbf03h/bTHP8ccf3ybbWg068mcBOjsBBMjiP9n4z/bpp59u8IhEIW2ZZZZp9dH697//rdDTDP/5z3/SYYcdloYOHZouv/zydMoppxT2iR03blw+V7ULsm0h9ik+f3vvvXe68sor00477ZSqzaOPPpqP5ddff506qs6wjUB16N7eGwB0Xq+//nrq2rVrswPIhRdeKIQ00b333puP8aWXXpp69OiRihQB5IQTTsi/164laIt9XH311dNxxx2X2iPgFVW4j2MZNRH9+vVr03Wts8466fvvv5/u5yXm6d69e7tsY2ew4IIL5mM000wztfemQNVRAwK0WM+ePTvdf87fffdd6kw+/fTT1KtXr8LDR9H7WIkCb6lUygXG5ojjWm3HNgLrzDPPPN2LAzFP7QBS7Zr73Y8a4ThG0fQRqCwBBKhYH5CJEyfmK6iLLrpo/o97jjnmSGuttVa666678usxb9R+lP9zLz9qFxAOPvjgNHDgwBxuFl988XTWWWflgmVtUcg84IAD0pxzzpl69+6dfvazn6X//e9/U7Vpj99j2iuvvJJ+9atfpR/96Ed5e8ILL7yQtyf6VsS2Rv+D3XffPX3xxRd11lVexhtvvJF23HHH1Ldv3zTXXHOlY445Jm/XBx98kLbYYovUp0+fvIyzzz67Scdu0qRJ6aSTTkoLL7xw3tc4lkceeWQaP358zTyx3mh2FcelfKym1x792muvTUOGDMmhJY5PbHMcm2n1e2ion0C0f4/9DHFOy+tvTp+BCBZ77LFHmnvuufMxXn755dNf//rXqfoqvPvuu+m2226rWUesuzl9Iu6888608sor533+4x//mF+L47bBBhuk/v375+O71FJLpYsvvniqZTR2LJrrggsuSEsvvXSaZZZZ8ucstueqq67Kr8UxO/TQQ/PvgwcPnmo/m7qttWttoi9QHNOY94YbbphuH5CG1D6f09rGddddN5+7hsR3dJNNNmnycSo35YzvXyw3jtciiyySrrvuuvz6Aw88kFZbbbV8LmPZd999d533//e//0377LNPfi3mib8xv/jFL6b6zJSblMbyYv44tvPPP3/N6/F3KL77sYxVV101PfTQQ03qDxTfkdlmmy1/p7bccsv8e3xPDjnkkDR58uQmHweY0c04lz6AJhkzZkz6/PPPp5oe4WJ6ohBz6qmn5g7F8Z/62LFjc5+SZ555Jv34xz9Ov/nNb9JHH32UA0m09a8tCvMRJO67775caI0CVhQso1AU/9mfe+65dQoB//znP3NfgWi6E4WMYcOGNbpdUUCJUBR9DcphJrbhnXfeSbvttlsODi+//HL605/+lH8+/vjjdYJR2HbbbdOSSy6ZTjvttFxYPvnkk9Pss8+eC7xReDz99NPT3//+91wQWWWVVXIzmGmJYxSF8W222SaHrieeeCIfu1dffTXdeOONeZ44RrFNTz75ZPrLX/6Sp6255pqNLjMKSrE/sf5Y1ieffJL+7//+Lz3yyCPp2WefbVYtQxSqohAc/TJ+/vOfp6222ipPX2655Zr0/giJUZh766230n777ZcLtRGO4txFH4Pf/e53+XjGPh500EG5cBjHobzu5jQD3H777fNna88998wF0xDbHoEgPlNxlf+WW27JBdEpU6akfffdN1XSn//85xyI41zGfv3www+5gB3nNIJvHLsIsFdffXX+HEcwrL2fzdnWN998M38Wf/vb36Zddtklh5f4fN9xxx35O9ZS09rG+J7FsX3ppZfq9AN76qmn8nuOPvroZq3rq6++ysFxu+22y9se+x+/x/cnBiCIfYvjFoMvxDGNkB8XGsrrjKZiMX98ZiIkxPvjsxYXGiLQ1BbHMfbh2GOPrakBifnjM7n22mvnz14sI8JEBMfaIaUxETQidEVQigskEZLiwkNcTIjvC9AEJYBSqXT55ZdHyXyaj6WXXrrOsVpwwQVLu+yyS83z5ZdfvjRs2LBpHs999903L6u+m266KU8/+eST60zfZpttSl26dCm99dZb+fmoUaPyfAceeGCd+Xbdddc8/bjjjquZFr/HtO23336q9Y0bN26qaVdffXWe/8EHH5xqGXvttVfNtEmTJpXmn3/+vF2nnXZazfSvvvqq1KtXrzrHpCHPPfdcXuavf/3rOtMPOeSQPP3ee++tmRbLmnXWWUvTM2HChFL//v1LyyyzTOn777+vmX7rrbfmZR577LE109Zdd938qC/WFee07LPPPpvqmDbVeeedl9/7t7/9rc42rrHGGqXZZputNHbs2Jrpsc7pfW4aEu+Lddxxxx1NOr+bbLJJaaGFFqozrf6xePfdd/My4/vQVFtsscVU3436zjzzzLzcWH5Lt7W8v9dff33NtDFjxpTmnXfe0oorrlgz7b777svzxc/Gzm2of24b28avv/66NPPMM5cOP/zwOtMPOOCA/Nn89ttvS00VxzrWcdVVV9VMe+211/K0rl27lh5//PGa6XfeeedU56KhY/XYY4/l+a644oqp/p6ttdZa+ftaNn78+NIcc8xRWmWVVUoTJ06smT5y5Mg8//Q+C3EcY9qJJ55YZxvi+A8ZMqTJxwFmdJpgAXVE04SoHaj/aMqV77jCHjUIcZW2uaJzerS1jivJtcVV8Sgr3X777fl5XOktX9msbf/992902XFFtb5oelEWV6yj1idqU0LU2DRUY1EW2xlNbGK7oram9v7HFfioWZnevobhw4dPta8haliaK2qaoslTHJdomlMWNUNLLLFEi5bZGrGPUbMUtRNl0V8ozm8Muxu1VpUQNSsNNQGqfX7LtXrR5CfOTTyvpDjvH374Yb463xLN2dYBAwbkGqmyaPq388475xqujz/+OLWFaHYYzQyjdqRcgxi1ANdcc02uOZh11lmbtbxothQ1GGXxnYljGDViUatQVv699vep9rGKWtloMhlNuOL9DX1vo+amdh+O+J7Ee2J67f4vO+ywQ64Baar6f1OiNmV633vg/yOAAHVE06mNNtpoqkdT/nM+8cQTc/OaxRZbLC277LK5+VQ0RWmKaNsdhatyU4uyKJSUXy//jM61UfCsLQohjak/b/jyyy9zc5nonxCFmmimUZ6voQLqAgssMFWhLAr65aYqtadHE5Pp7WvsQ/1tjgJ7FKTK+9oc5feUmyDVFgGkJctsjVhfNHur3xG6/vlsrYbObYhmZ/G5jcJxHNM4v9HHJlQ6gBx++OG5UB3fndjnaDYV62+q5mxrfGbqNw+M71toat+ZloiQ8/777+e+EiGaHUUTv5YMmRzNnOrvQ3xvou9X/Wmh9vcpmvZFc6pyP7H4/sXxir87DZ3X+p+P8ueu/ncvwkj9+6Q0Jr739ZsJxt/H6X3vgf+PAAJUTPR7ePvtt9Nll12W24pHv4WVVlqppv9Ce6l91bTsl7/8ZW67H1cyoxNvdOwt165E2/v6GhoJp7HRcep3mm9M/UJYURpbb2fsRNvQuY3P4IYbbphrEs4555xc+xO1eNHev7Hz2xoRqqIvyj/+8Y88yMH111+ffzZlWOGit7WlopYpwvrf/va3/Dx+RmCO4NRcjX1vmvJ9iprO3//+9/n7G/3A4nsbxys6ozd0rBr6fLSWUbGg9QQQoKKiY3Z0hI7mGtF5NJpu1R45qbHCb4y5Hx3Uv/nmmzrTX3vttZrXyz+joBEjJ9UWnZ2bKq5U3nPPPemII47IIzxFk5bowBuj4hShvA/1m6rFFeW4klve1+YuM0RBuL6YVnuZcbW2oZvN1a+VaE1AivXF/tUvFNY/n20hOnHHaGL/+te/cuf0zTbbLBeU26IwWha1F9E5PDqFR01BNH2LgnI075vWsWzutsbnvH7AjY7goalX8BszrfMdhe7oGB6jVcX356abbsrN64oujMf6o/N9dPqODurxvY2w19SbJ5Y/d/X/XsSodG1ZgwTUJYAAFVN/CNtolhJNHWoPLVtuL16/wBAFr7gC/4c//KHO9BiRJwpGm266aX5ebu9/0UUXTTUMalOVC031C3LnnXdeKkLsa0PriyvgYVojejUm+qTEUKOXXHJJneMdfWdiZK3ay4zReiIIfPbZZzXTnn/++amaDZVHFGrJnbFjH6NPQvQTqF3Ii/MUn4vo49BWGjq/0TwnwkERn/u4r0gMjxvrL48e19jnvrnbGiG9PEpaiJHmrrjiijxqXNRItEZj21gWza0ifERQin48McRz0eJ41f/exmeqqbV38T2J2pKo/YzPY1mMwKUJFRTHMLxAxUShK4bDjPtQRE1IdPiMK5Yx5GVZvBaiM3KEiShQRIfUzTffPK2//vrpqKOOylci474D0bzi5ptvzkNzRqG5/P6tt946F96j4Fcehrd8FbgpV+2j4240FzvjjDNyAXG++ebL66pfq9JWYt/iKm4MsRuFvSiMx1C7MSxvdOqN49Bc0cE7hgKO2qdYXlydLg/DG1fGy016QtzvJMJOHP/oRB+d1yO4xFCwUaAti6vwcU4jREQ/gzin0bSu9lCsjdlrr73yEMUx7O6oUaPyNsRnIUJOnLv6fX0qaeONN84hID5T5cJyFDgjoI0ePbpN1heF/6FDh+ZmShH4IkhH6CvvZ/lzH5/v+LzH+Yrta+62xnmIcxYd3mNd0dwxznMlwlVj21gOJiuuuGI+9zGccjQ7i+aVRYvhe2Po5ugfEp/Nxx57LPdHiVDRFHGso0Y2mnLF8NnRlCv+3sQQ1vE3pr2aRcIMp72H4QI6hvKwlU899VSDr8fwlNMbhjeG0F111VVL/fr1y8PRLrHEEqXf//73efjVshgSc//99y/NNddceRjb2n+Gvvnmm9JBBx1UGjBgQGmmmWYqLbroonlo0ClTptRZ73fffZeH85199tnzkK5bbrll6fXXX8/Lqj0sbnkI3RhOtr4PP/yw9POf/zxva9++fUu/+MUvSh999FGjQ/nWX0Zjw+M2dJwaEkOAnnDCCaXBgwfnfR04cGBpxIgRpR9++KFJ62nMNddck4cE7dmzZz4+O+ywQ97X+mJ43BjmtUePHqUVVlghD3na0FCtjz76aB5eNOZr7pC8n3zySWm33XYrzTnnnPn9yy67bIPD27ZmGN7G3vevf/2rtNxyy+XhYwcNGlQ6/fTTS5dddtlUw8xWYhjeP/7xj6V11lknD+8ax33hhRcuHXrooXmI3NpOOumk0nzzzZeHm629HU3d1vL+xrmK+WNd8R279tpr66ynpcPwTmsby84444w8/ZRTTim1RGPfj8bOZawrvuu1h7ouf6biux/DFccwvvX/Fk3v79n555+f3xPHMP5mPfLII/lz/pOf/GS6w/A29H0s/50AmqZL/NPeIQigtZ577rl8hTY6x8aQmkDlRY1a+eZ99UeG68yir1KMbBU3ZIwaKKBt6QMCdDoxFGd90awnhnyd3h3IgZaJ65WXXnppbuLXmcNHDAxQ/9pr9KOJobmjCSnQ9vQBATqd6LsR/Qqir0SM3x8dreMR/Q7q30uAypowYUIuqE1LtM9vzYhT0Tl+Wp2Kox1/9Eephn3tDL777rs8Std9992XXnzxxdwvq744TnG8GhN9verfO6O9PP7447kW5xe/+EXuOxI3MIxgFf1bYhrQ9jTBAjqdGPc/hs995ZVXcqfduBobI/RE59nadzem8u6///7pdpKPDtHR+bylosP6tG5UGFfgYzuqYV87g2huFTf0i5sk7rPPPnl44fqi5mBad7eP4W87yjC3sR0xCEYM/BDBKcJsjNp22mmn5c7/QNsTQABoshiqNGqfpiVG05p33nlbfFRjpKyGmtnVvo9JecSmzr6v1SKO07SGsY1aohglDCAIIAAAQGF0QgcAAAqjsfQ0huSLO87GTaTcmAgAAP6fGEnum2++SQMGDMgjUDaXANKICB9G0wEAgIZ98MEHaf7550/NJYA0Imo+yge2T58+zT6wAABQjcaOHZsv1JfLy80lgDSi3OwqwocAAgAAdbW0m4JO6AAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAArTvbhVAdBSg464bYY/eO+dNmyGPwYA1UANCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAADDjBpBTTz01rbLKKql3796pf//+acstt0yvv/56nXnWW2+91KVLlzqP3/72t3Xmef/999OwYcPSLLPMkpdz6KGHpkmTJhW8NwAAQG3dUwfzwAMPpH333TeHkAgMRx55ZNp4443TK6+8kmadddaa+fbcc8904okn1jyPoFE2efLkHD7mmWee9Oijj6bRo0ennXfeOc0000zplFNOKXyfAACADhpA7rjjjjrPR44cmWswRo0aldZZZ506gSMCRkP+85//5MBy9913p7nnnjutsMIK6aSTTkqHH354Ov7441OPHj3afD8AAIBO0ASrvjFjxuSfs88+e53pf//739Occ86ZlllmmTRixIg0bty4mtcee+yxtOyyy+bwUbbJJpuksWPHppdffrnB9YwfPz6/XvsBAABUeQ1IbVOmTEkHHnhgGjp0aA4aZb/61a/SggsumAYMGJBeeOGFXLMR/URuuOGG/PrHH39cJ3yE8vN4rbG+JyeccEKb7g8AAMzoOnQAib4gL730Unr44YfrTN9rr71qfo+ajnnnnTdtuOGG6e23304LL7xwi9YVtSjDhw+veR41IAMHDmzF1gMAAJ2mCdZ+++2Xbr311nTfffel+eeff5rzrrbaavnnW2+9lX9G35BPPvmkzjzl5431G+nZs2fq06dPnQcAAFDlAaRUKuXwceONN6Z77703DR48eLrvee655/LPqAkJa6yxRnrxxRfTp59+WjPPXXfdlUPFUkst1YZbDwAAdKomWNHs6qqrrko333xzvhdIuc9G3759U69evXIzq3h9s802S3PMMUfuA3LQQQflEbKWW265PG8M2xtBY6eddkpnnHFGXsbRRx+dlx01HQAAQPvocDUgF198cR75Km42GDUa5cc111yTX48hdGN43QgZSyyxRDr44IPT1ltvnW655ZaaZXTr1i0334qfURuy44475vuA1L5vCAAAULzuHbEJ1rREx/C4WeH0xChZ//73vyu4ZQAAQNXVgAAAANVLAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAMOPeBwQAGjLoiNtm+APz3mnDZvhjAHR+akAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAAAEEAACoPmpAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAGDGDSCnnnpqWmWVVVLv3r1T//7905Zbbplef/31OvP88MMPad99901zzDFHmm222dLWW2+dPvnkkzrzvP/++2nYsGFplllmycs59NBD06RJkwreGwAAoEMHkAceeCCHi8cffzzdddddaeLEiWnjjTdO3333Xc08Bx10ULrlllvStddem+f/6KOP0lZbbVXz+uTJk3P4mDBhQnr00UfTX//61zRy5Mh07LHHttNeAQAAoUupVCp15EPx2Wef5RqMCBrrrLNOGjNmTJprrrnSVVddlbbZZps8z2uvvZaWXHLJ9Nhjj6XVV1893X777emnP/1pDiZzzz13nueSSy5Jhx9+eF5ejx49prvesWPHpr59++b19enTp833E2BaBh1xmwNEeu+0YY4C0O5aW07ucDUg9cWOhdlnnz3/HDVqVK4V2WijjWrmWWKJJdICCyyQA0iIn8suu2xN+AibbLJJPlgvv/xy4fsAAAD8P91TBzZlypR04IEHpqFDh6ZlllkmT/v4449zDUa/fv3qzBthI14rz1M7fJRfL7/WkPHjx+dHWYQVAACgsjp0DUj0BXnppZfSP/7xj0I6v0dVUvkxcODANl8nAADMaDpsANlvv/3Srbfemu677740//zz10yfZ555cufyr7/+us78MQpWvFaep/6oWOXn5XnqGzFiRG7uVX588MEHbbBXAAAwY+twAST6xEf4uPHGG9O9996bBg8eXOf1IUOGpJlmmindc889NdNimN4YdneNNdbIz+Pniy++mD799NOaeWJEregks9RSSzW43p49e+bXaz8AAIAq7wMSza5ihKubb7453wuk3GcjmkX16tUr/9xjjz3S8OHDc8f0CAr7779/Dh0xAlaIYXsjaOy0007pjDPOyMs4+uij87IjaAAAAO2jwwWQiy++OP9cb7316ky//PLL06677pp/P/fcc1PXrl3zDQij43iMcHXRRRfVzNutW7fcfGvvvffOwWTWWWdNu+yySzrxxBML3hsAAKBT3QekvbgPCNCRuA8IwX1AgI6g6u8DAgAAVA8BBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAB0rgDyzDPPpBdffLHm+c0335y23HLLdOSRR6YJEyZUYhUAAEAVqEgA+c1vfpPeeOON/Ps777yTtttuuzTLLLOka6+9Nh122GGVWAUAAFAFKhJAInyssMIK+fcIHeuss0666qqr0siRI9P1119fiVUAAABVoCIBpFQqpSlTpuTf77777rTZZpvl3wcOHJg+//zzSqwCAACoAhUJICuvvHI6+eST05VXXpkeeOCBNGzYsDz93XffTXPPPXclVgEAAFSBigSQ8847L3dE32+//dJRRx2VFllkkTz9uuuuS2uuuWYlVgEAAFSB7pVYyHLLLVdnFKyyM888M3Xr1q0SqwAAAKpAxe4D8vXXX6e//OUvacSIEenLL7/M01555ZX06aefVmoVAABAJ1eRGpAXXnghbbjhhqlfv37pvffeS3vuuWeaffbZ0w033JDef//9dMUVV1RiNQAAQCdXkRqQ4cOHp9122y29+eabaeaZZ66ZHqNhPfjgg5VYBQAAUAUqEkCeeuqpfDPC+uabb7708ccfV2IVAABAFahIAOnZs2caO3ZsgzconGuuuSqxCgAAoApUJID87Gc/SyeeeGKaOHFift6lS5fc9+Pwww9PW2+9dSVWAQAAVIGKBJCzzz47ffvtt6l///7p+++/T+uuu26+F0jv3r3T73//+0qsAgAAqAIVGQWrb9++6a677kqPPPJIev7553MYWWmlldJGG21UicUDAABVoiIBpGzo0KH5AQAA0GZNsA444IB0/vnnTzX9D3/4QzrwwAMrsQoAAKAKVCSAXH/99Q3WfKy55prpuuuuq8QqAACAKlCRAPLFF1/kfiD19enTJ33++eeVWAUAAFAFKhJAYsSrO+64Y6rpt99+e1pooYUqsQoAAKAKVKQT+vDhw9N+++2XPvvss7TBBhvkaffcc08enve8886rxCoAAIAqUJEAsvvuu6fx48fne36cdNJJedqgQYPSxRdfnHbeeedKrAIAAKgCFRuGd++9986PqAXp1atXmm222Sq1aAAAoEpU9D4gYa655qr0IgEAgCpRkU7on3zySdppp53SgAEDUvfu3VO3bt3qPAAAACpWA7Lrrrum999/Px1zzDFp3nnnTV26dHF0AQCAtgkgDz/8cHrooYfSCiusUInFAQAAVaoiTbAGDhyYSqVSJRYFAABUsYoEkLjXxxFHHJHee++9SiwOAACoUhVpgrXtttumcePGpYUXXjjNMsssaaaZZqrz+pdfflmJ1QAAAJ1cRQKIu50DAACFBZBddtmlEosBAACqXEX6gIS33347HX300Wn77bdPn376aZ52++23p5dffrlSqwAAADq5igSQBx54IC277LLpiSeeSDfccEP69ttv8/Tnn38+HXfccZVYBQAAUAUqEkBiBKyTTz453XXXXalHjx410zfYYIP0+OOPV2IVAABAFahIAHnxxRfTz3/+86mm9+/fP33++eeVWAUAAFAFKhJA+vXrl0aPHj3V9GeffTbNN998lVgFAABQBSoSQLbbbrt0+OGHp48//jh16dIlTZkyJT3yyCPpkEMOSTvvvHMlVgEAAFSBigzDe8opp6R99903DRw4ME2ePDkttdRS+eevfvWrPDIWQGsMOuI2BxAAqkSrA0ipVMo1H+eff3469thjc3+QGAVrxRVXTIsuumhlthIAAKgKFQkgiyyySL7fRwSOqAUBAABokz4gXbt2zcHjiy++aO2iAACAKleRTuinnXZaOvTQQ9NLL71UicUBAABVqiKd0GOkq3HjxqXll18+34iwV69edV7/8ssvK7EaAACgk6tIADnvvPMqsRgAAKDKtTqATJw4MT3wwAPpmGOOSYMHD67MVgEAAFWp1X1AZppppnT99ddXZmsAAICqVpFO6FtuuWW66aabKrEoAACgilWkD0gMw3viiSemRx55JA0ZMiTNOuusdV4/4IADKrEaAACgk6tIALn00ktTv3790qhRo/Kjti5dugggAABA5QLIu+++W4nFAAAAVa4ifUAAAAAKqwHZfffdp/n6ZZddVonVAAAAnVxFAshXX3011b1BXnrppfT111+nDTbYoBKrAAAAqkBFAsiNN9441bQpU6akvffeOy288MKVWAUAAFAF2qwPSNeuXdPw4cPTueee21arAAAAZsQakMa8/fbbadKkSW25CgCYYQw64rY0o3vvtGHtvQlARwggUdNRW6lUSqNHj0633XZb2mWXXSqxCgAAoApUJIA8++yzUzW/mmuuudLZZ5893RGyAACAGUdFAsh9991XicUAAABVrmul7oT+5ptvTjU9pr333nuVWAUAAFAFKhJAdt111/Too49ONf2JJ57IrwEAAFQsgEQfkKFDh041ffXVV0/PPfecIw0AAFQugHTp0iV98803U00fM2ZMmjx5ciVWAQAAVIGKBJB11lknnXrqqXXCRvwe09Zaa61KrAIAAKgCFRkF6/TTT88hZPHFF09rr712nvbQQw+lsWPHpnvvvbcSqwAAAKpARWpAllpqqfTCCy+kX/7yl+nTTz/NzbF23nnn9Nprr6VlllmmEqsAAACqQEUCSBgwYEA65ZRT8t3Pr7vuunTsscem2WefvdnLefDBB9Pmm2+elxd9S2666aY6r8eoWjG99uMnP/lJnXm+/PLLtMMOO6Q+ffqkfv36pT322CN9++23rd5HAACgAwSQyy+/PF177bVTTY9pf/3rX5u1rO+++y4tv/zy6cILL2x0nggco0ePrnlcffXVdV6P8PHyyy+nu+66K91666051Oy1117N2g4AAKCD9gGJzuZ//OMfp5rev3//XPDfZZddmrysTTfdND+mpWfPnmmeeeZp8LVXX3013XHHHempp55KK6+8cp52wQUXpM022yydddZZuWYFAADoxDUg77//fho8ePBU0xdccMH8WqXdf//9OdxEp/e99947ffHFFzWvPfbYY7nZVTl8hI022ih17do13xgRAADo5DUgEQaiE/qgQYPqTH/++efTHHPMkSopml9ttdVWOfC8/fbb6cgjj8w1JhE8unXrlj7++OO8PbV1794990eJ1xozfvz4/CiLEbwAAIAOGEC23377dMABB6TevXvn4XjDAw88kH73u9+l7bbbLlVS7eUtu+yyabnllksLL7xwrhXZcMMNW9WM7IQTTqjQVgIAAG3WBOukk05Kq622Wg4AvXr1yo+NN944bbDBBnlkrLa00EILpTnnnDO99dZb+Xn0DYmhgGubNGlSHhmrsX4jYcSIEfnO7eXHBx980KbbDQAAM6KK1ID06NEjXXPNNTmIRLOrCCBROxF9QNrahx9+mPuAzDvvvPn5Gmuskb7++us0atSoNGTIkDwtboY4ZcqUHJKm1bE9HgAAQAcPIGXRz2L99dfPNRItFffrKNdmhHfffTc999xzednxiGZSW2+9da7NiD4ghx12WFpkkUXSJptskudfcsklcz+RPffcM11yySVp4sSJab/99stNt4yABQAAnbwJVtQ27Lvvvjl0zD333PkRv0ehP15rrqeffjqtuOKK+RGGDx+ef48bG0Yn8+js/rOf/Swttthi+QaDUcvx0EMP1am9+Pvf/56WWGKJ3CQsht9da6210p/+9KfW7ioAANBKXUqlUqmlb45+FdHk6X//+1+++V/UPoRXXnklXXXVVWngwIHp0UcfTT/60Y9SZxOjYPXt2zf3B4k7qgPtZ9ARtzn8QPbeacMcCejk5eRWNcE68cQTc/+PaAoVNR/1X4uO6PHz3HPPbc1qAACAKtGqJlg33XRTvrt4/fARoo/GGWeckW688cbWrAIAAKgirQogo0ePTksvvXSjry+zzDLTvPkfAAAwY2lVAInO5u+9916jr8cIVjFyFQAAQKsDSAx9e9RRR6UJEyZM9dr48ePTMccck4fEBQAAqEgn9JVXXjktuuiieSjeGPo2BtV69dVX00UXXZRDyJVXXulIAwAArQ8g888/f3rsscfSPvvsk0aMGJHDR+jSpUv68Y9/nP7whz/koXgBAABaHUDC4MGD0+23356++uqr9Oabb+ZpcWdyfT8AAICKB5CyuNngqquuWqnFAQAAVahVndABAACaQwABAAAKI4AAAAAdP4CstNJKueN5eTjecePGVXK7AACAKtTiABL3+vjuu+/y7yeccEL69ttvK7ldAABAFWrxKFgrrLBC2m233dJaa62V7/9x1llnpdlmm63BeY899tjWbCMAADCjB5CRI0em4447Lt166635xoNxL5Du3adeXLwmgAAAAK0KIIsvvnj6xz/+kX/v2rVruueee1L//v0dVQAAoG1vRDhlypRKLAYAAKhyFbsT+ttvv53OO++83Dk9LLXUUul3v/tdWnjhhSu1CgAAoJOryH1A7rzzzhw4nnzyybTccsvlxxNPPJGWXnrpdNddd1ViFQAAQBWoSA3IEUcckQ466KB02mmnTTX98MMPTz/+8Y8rsRoAAKCTq0gNSDS72mOPPaaavvvuu6dXXnmlEqsAAACqQEUCyFxzzZWee+65qabHNCNjAQAAFW2Cteeee6a99torvfPOO2nNNdfM0x555JF0+umnp+HDh1diFQAAQBWoSAA55phjUu/evdPZZ5+dRowYkacNGDAgHX/88emAAw6oxCoAAIAqUJEAEnc7j07o8fjmm2/ytAgkAAAAbXIfkDLBAwAAaNNO6AAAAE0hgAAAAIURQAAAgM4TQCZOnJg23HDD9Oabb1ZmiwAAgKrV6gAy00wzpRdeeKEyWwMAAFS1ijTB2nHHHdOll15aiUUBAABVrCLD8E6aNClddtll6e67705DhgxJs846a53XzznnnEqsBgAA6OQqEkBeeumltNJKK+Xf33jjjaluUggAAFCxAHLfffc5mgAAQLHD8L711lvpzjvvTN9//31+XiqVKrl4AACgk6tIAPniiy/yULyLLbZY2myzzdLo0aPz9D322CMdfPDBlVgFAABQBSoSQA466KA8HO/777+fZplllprp2267bbrjjjsqsQoAAKAKVKQPyH/+85/c9Gr++eevM33RRRdN//3vfyuxCgAAoApUpAbku+++q1PzUfbll1+mnj17VmIVAABAFahIAFl77bXTFVdcUWfo3SlTpqQzzjgjrb/++pVYBQAAUAUq0gQrgkZ0Qn/66afThAkT0mGHHZZefvnlXAPyyCOPVGIVAABAFahIDcgyyyyTb0C41lprpS222CI3ydpqq63Ss88+mxZeeOFKrAIAAKgCFakBCX379k1HHXVUpRYHAABUoYoFkK+++ipdeuml6dVXX83Pl1pqqbTbbrul2WefvVKrAAAAOrmKNMF68MEH06BBg9L555+fg0g84vfBgwfn1wAAACpWA7Lvvvvmmw5efPHFqVu3bnna5MmT0z777JNfe/HFFx1tAACgMjUgb731Vjr44INrwkeI34cPH55fAwAAqFgAWWmllWr6ftQW05ZffnlHGgAAaF0TrBdeeKHm9wMOOCD97ne/y7Udq6++ep72+OOPpwsvvDCddtppLV0FAABQZbqUSqVSS97YtWvXfMfz6b095on+IJ3N2LFj89DCY8aMSX369GnvzYEZ2qAjbmvvTQA6iPdOG9bemwAzvLGtLCe3uAbk3XffneEPPgAAUFAAWXDBBVv6VgAAYAZVsRsRfvTRR+nhhx9On376aZoyZUqd16KPCAAAQEUCyMiRI9NvfvOb1KNHjzTHHHPkfh9l8bsAAgAAVCyAHHPMMenYY49NI0aMyJ3TAQAAGlKRtDBu3Li03XbbCR8AAEDbB5A99tgjXXvttZVYFAAAUMUq0gTr1FNPTT/96U/THXfckZZddtk000wz1Xn9nHPOqcRqAACATq5iAeTOO+9Miy++eH5evxM6AABAxQLI2WefnS677LK06667OqoAAEDb9gHp2bNnGjp0qMMMAAC0fQD53e9+ly644IJKLAoAAKhiFWmC9eSTT6Z777033XrrrWnppZeeqhP6DTfcUInVAAAAnVxFAki/fv3SVlttVYlFAQAAVawiAeTyyy+vxGIAAIAqV5E+IAAAAIXVgAwePHia9/t45513KrEaAACgk6tIADnwwAPrPJ84cWJ69tln853RDz300EqsAgAAqALdKzUMb0MuvPDC9PTTT1diFQAAQBVo0z4gm266abr++uvbchUAAEAn0qYB5Lrrrkuzzz57W64CAACY0ZpgrbjiinU6oZdKpfTxxx+nzz77LF100UWVWAUAAFAFKhJAttxyyzrPu3btmuaaa6603nrrpSWWWKISqwAAAKpARQLIcccdV4nFAAAAVc6NCAEAgM5RAxJNraZ1A8IQr0+aNKk1qwEAAKpEq2pAbrzxxnTDDTc0+IgbEPbs2TN17968jPPggw+mzTffPA0YMCCHl5tuuqnO69HB/dhjj03zzjtv6tWrV9poo43Sm2++WWeeL7/8Mu2www6pT58+qV+/fmmPPfZI3377bWt2FQAAaO8akC222GKqaa+//no64ogj0i233JJDwIknntisZX733Xdp+eWXT7vvvnvaaqutpnr9jDPOSOeff37661//mgYPHpyOOeaYtMkmm6RXXnklzTzzzHmeWO/o0aPTXXfdle/Kvttuu6W99torXXXVVa3YWwAAoEN0Qg8fffRR7owewSACwXPPPZeWWWaZFt28MB4NidqP8847Lx199NE14eeKK65Ic889d64p2W677dKrr76a7rjjjvTUU0+llVdeOc9zwQUXpM022yydddZZuWYFAADopJ3Qx4wZkw4//PC0yCKLpJdffjndc889ufajJeFjet599918f5FodlXWt2/ftNpqq6XHHnssP4+f0eyqHD5CzB/9VZ544omKbxMAAFBQDUg0hzr99NPTPPPMk66++uoGm2RVUoSPEDUetcXz8mvxs3///nVej34ocUf28jwNGT9+fH6UjR07tsJbDwAAtCqARF+P6AgetR/R9CoeDYlO6R3dqaeemk444YT23gwAAKhqrQogO++883SH4a2kqGkJn3zySR4Fqyyer7DCCjXzfPrpp3XeF8MAx8hY5fc3ZMSIEWn48OF1akAGDhzYBnsBAAAzrlYFkJEjR6YixahXESKin0k5cERQiL4de++9d36+xhprpK+//jqNGjUqDRkyJE+7995705QpU3JfkcbEkMHxAAAAOsEoWJUS9+t466236nQ8jxG1og/HAgsskA488MB08sknp0UXXbRmGN4Y2WrLLbfM8y+55JLpJz/5Sdpzzz3TJZdckofh3W+//fIIWUbAAgCA9tXhAsjTTz+d1l9//Zrn5WZRu+yyS65xOeyww/K9QuK+HlHTsdZaa+Vhd8v3AAl///vfc+jYcMMN8+hXW2+9db53CAAA0L66lOLmGkwlmnbFEL8xzHDcUR1oP4OOuM3hB7L3ThvmSEAnLye3+j4gAAAATSWAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAACCAAAAA1UcNCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFKZ7casCWmLQEbc5cABA1VADAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACF6XQB5Pjjj09dunSp81hiiSVqXv/hhx/Svvvum+aYY44022yzpa233jp98skn7brNAABAJw0gYemll06jR4+ueTz88MM1rx100EHplltuSddee2164IEH0kcffZS22mqrdt1eAADg/+meOqHu3buneeaZZ6rpY8aMSZdeemm66qqr0gYbbJCnXX755WnJJZdMjz/+eFp99dXbYWsBAIBOXQPy5ptvpgEDBqSFFloo7bDDDun999/P00eNGpUmTpyYNtpoo5p5o3nWAgsskB577LFpLnP8+PFp7NixdR4AAMAMHkBWW221NHLkyHTHHXekiy++OL377rtp7bXXTt988036+OOPU48ePVK/fv3qvGfuuefOr03Lqaeemvr27VvzGDhwYBvvCQAAzHg6XROsTTfdtOb35ZZbLgeSBRdcMP3zn/9MvXr1avFyR4wYkYYPH17zPGpAhBAAAJjBa0Dqi9qOxRZbLL311lu5X8iECRPS119/XWeeGAWroT4jtfXs2TP16dOnzgMAAKisTh9Avv322/T222+neeedNw0ZMiTNNNNM6Z577ql5/fXXX899RNZYY4123U4AAKATNsE65JBD0uabb56bXcUQu8cdd1zq1q1b2n777XPfjT322CM3pZp99tlzLcb++++fw4cRsAAAoP11ugDy4Ycf5rDxxRdfpLnmmiuttdZaeYjd+D2ce+65qWvXrvkGhDGy1SabbJIuuuii9t5sAAAgpdSlVCqVHImpRSf0qFGJe4voD0J7GnTEbU4AwP/fe6cNcyygk5eTO30fEAAAoPMQQAAAgMJ0uj4gAMCMS7NUzdDo/NSAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAAojgAAAAIURQAAAgMIIIAAAQGEEEAAAoDACCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQmO7FrQoAgNYadMRtM/xBfO+0YTP8MejM1IAAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAFAYAQQAACiMAAIAABRGAAEAAArjRoR0aG62BABQXQSQDkzhGwCAaqMJFgAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAUpqoDyIUXXpgGDRqUZp555rTaaqulJ598sr03CQAAZmjdU5W65ppr0vDhw9Mll1ySw8d5552XNtlkk/T666+n/v37t/fmAQDQQoOOuG2GP3bvnTas0x6Dqq0BOeecc9Kee+6Zdtttt7TUUkvlIDLLLLOkyy67rL03DQAAZlhVWQMyYcKENGrUqDRixIiaaV27dk0bbbRReuyxxxp8z/jx4/OjbMyYMfnn2LFjU3uZMn5cu60bAICOa2w7llHL6y6VSi16f1UGkM8//zxNnjw5zT333HWmx/PXXnutwfeceuqp6YQTTphq+sCBA9tsOwEAoCX6npfa3TfffJP69u3b7PdVZQBpiagtiT4jZVOmTElffvllmmOOOVKXLl0KT5URfD744IPUp0+fQtdN23BOq49zWl2cz+rjnFYf57TjiJqPCB8DBgxo0furMoDMOeecqVu3bumTTz6pMz2ezzPPPA2+p2fPnvlRW79+/VJ7ivAhgFQX57T6OKfVxfmsPs5p9XFOO4aW1HxUdSf0Hj16pCFDhqR77rmnTo1GPF9jjTXaddsAAGBGVpU1ICGaU+2yyy5p5ZVXTquuumoehve7777Lo2IBAADto2oDyLbbbps+++yzdOyxx6aPP/44rbDCCumOO+6YqmN6RxRNwY477ripmoTReTmn1cc5rS7OZ/VxTquPc1o9upRaOn4WAABAM1VlHxAAAKBjEkAAAIDCCCAAAEBhBBAAAKAwAkg7OPXUU9Mqq6ySevfunfr375+23HLL9Prrrzf5/f/4xz/y3dnjfXTO8zly5Mh8Dms/Zp555sK2mbb5jn799ddp3333TfPOO28erWWxxRZL//73vx3uTnpO11tvvam+p/EYNmxYYdtNZb+jMST/4osvnnr16pUGDhyYDjrooPTDDz84zJ30nE6cODGdeOKJaeGFF87/hy6//PJ5xFM6PgGkHTzwwAO5kPL444+nu+66K3+BNt5443yfkul577330iGHHJLWXnvtQraVtjufcSfX0aNH1zz++9//Otyd+JxOmDAh/fjHP87f0euuuy7/x/nnP/85zTfffIVuO5U7pzfccEOd7+hLL72UunXrln7xi184zJ3wfF511VXpiCOOyMPcv/rqq+nSSy9N11xzTTryyCML3XYqd06PPvro9Mc//jFdcMEF6ZVXXkm//e1v089//vP07LPPOswdXQzDS/v69NNPYyjk0gMPPDDN+SZNmlRac801S3/5y19Ku+yyS2mLLbYobBup7Pm8/PLLS3379nVYq+icXnzxxaWFFlqoNGHChEK3jbb9u1vbueeeW+rdu3fp22+/ddg74fncd999SxtssEGdacOHDy8NHTq0gC2kLc7pvPPOW/rDH/5QZ9pWW21V2mGHHRzwDk4NSAcwZsyY/HP22Wef5nxRzRjVknvssUdBW0Zbns9vv/02LbjggrkZwBZbbJFefvllB7wTn9N//etfaY011shX8OKGp8sss0w65ZRT0uTJkwvcUir9Pa0trphvt912adZZZ3WgO+H5XHPNNdOoUaPSk08+mZ+/8847uYnkZpttVth2UtlzOn78+KmaL0fzuocfftih7uDciLCdTZkyJf3sZz/Lbcen9YWJ1+I/vueeey7NOeecadddd83vuemmmwrdXipzPh977LH05ptvpuWWWy7/kT3rrLPSgw8+mEPI/PPP7zB3wnO6xBJL5OZXO+ywQ9pnn33SW2+9lX8ecMABuckHne+c1haF1tVWWy098cQTadVVV23zbaRtzuf555+fmzHHPZgnTZqUm+xcfPHFDncnPae/+tWv0vPPP5/LQtEP5J577skX9OLCT4QTOrD2roKZ0f32t78tLbjggqUPPvig0XnGjh1bGjRoUOnf//53zTRNsDrv+WxINNtZeOGFS0cffXSbbRtte04XXXTR0sCBA3NTybKzzz67NM888zj0VfA93WuvvUrLLrtsm24XbXs+77vvvtLcc89d+vOf/1x64YUXSjfccEP+zp544okOfSc9p9FMK5qjd+3atdStW7fSYostVtpnn31KM888c2HbSssIIO0o2qPOP//8pXfeeWea8z377LO5HWR8ucqPLl265Ef8/tZbbxW2zbT+fDZmm222KW233XYOcSc9p+uss05pww03rDMtLhrEd3f8+PFtuJW09fc0+nz06dOndN555znYnfh8rrXWWqVDDjmkzrQrr7yy1KtXr9LkyZPbcCtp6+/o999/X/rwww9LU6ZMKR122GGlpZZaykHv4PQBaZ9ap7TffvulG2+8Md17771p8ODB05w/mna8+OKLuflV+RFVk+uvv37+PfoQ0HnOZ0OiujjOcQzfSuc8p0OHDs3NrqLpQNkbb7yRz2mPHj3aeItpy+/ptddem5tz7Ljjjg50Jz6f48aNS1271i32xKhm5eXReb+j0Q8kRhyMZnXXX399boZFB9feCWhGtPfee+cRkO6///7S6NGjax7jxo2rmWennXYqHXHEEY0uQxOszn0+TzjhhNKdd95Zevvtt0ujRo3KNR9RZfzyyy+3017Q2nP6/vvv5xGS9ttvv9Lrr79euvXWW0v9+/cvnXzyyQ5uJ/+7G1fOt91224K3mEqfz+OOOy5/R6+++up8df0///lPbvr6y1/+0sHupOf08ccfL11//fX5/9IHH3wwj3I2ePDg0ldffdVOe0FTCSDtIHJfQ48YmrVs3XXXzSGjMQJI5z6fBx54YGmBBRYo9ejRI7dJ3myzzUrPPPNMO+0BlfqOPvroo6XVVlut1LNnzzwk7+9///s6fULofOf0tddey/NFYZXOfT4nTpxYOv7443PoiAs+0f8j+gsorHbecxphZckll8x/c+eYY44cUP73v/+10x7QHEbBAgAACqMPCAAAUBgBBAAAKIwAAgAAFEYAAQAACiOAAAAAhRFAAACAwgggAABAYQQQAACgMAIIAABQGAEEAAAojAACAAAURgABAAAKI4AAAACFEUAAAIDCCCAAAEBhBBAAAKAwAggAAJCK8v8DFtH5xCj+/T0AAAAASUVORK5CYII=", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -998,9 +1239,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "d6939de009994a6cb8e1435934302081", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -1008,9 +1264,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "a261578844614fe8888311cc0b9f6858", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -1018,9 +1289,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "8184a3d3559f49278acda32781665171", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyAAAAMgCAYAAADbcAZoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAATpBJREFUeJzt3Qe0VNXBNuB9qaIIiCKIoqCioFix9ygRFY3YEv0sWKLGXmIjRowV7MYeExVjTeyfGjWKxooNe6/EgoqKFEWp5197f2vufy9cmszdF4bnWWuYO+ecOW3OGs47u1UVRVEEAACADBrl2AgAAIAAAgAAZKUEBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBGABNXz48FBVVRUGDx4c5iUPPvhgWHPNNcNCCy2U9m/06NENvUsAlJEAAjCX4g18vFGu+VhyySXDL37xi/DAAw9kP7//+c9/au1L06ZNw/LLLx/22Wef8NFHH5VlG88880z405/+VPZw8O2334Zf//rXoUWLFuHyyy8PN9xwQ1hkkUXKug0AGlaTBt4+QMU4/fTTQ5cuXUJRFOGrr75KwWS77bYL9957b9h+++2z78+RRx4Z1l133TBp0qTw0ksvhauvvjrcf//94fXXXw8dO3ac6wBy2mmnhX333Te0adOmbPv8wgsvhHHjxoUzzjgj9OrVq2zrBWDeIYAAlMm2224b1llnnerXBxxwQGjfvn245ZZbGiSAbLrppmHXXXdNf++3335hpZVWSqHk+uuvD/379w/zopEjR6bncoYaAOYtqmAB1JN4Ex2rEjVpUvu3nh9++CH8/ve/D506dQrNmzcPK6+8cjj//PNTyUn0448/hm7duqVH/Ltk1KhRYamllgobbbRRmDJlyhzvz5ZbbpmeP/7445ku9+ijj6bwEqs+xWPYcccdw9tvv109P1a9Ov7449PfscSnVNUrtimZmdtuuy307NkznZMlllgi7LXXXuHzzz+vnr/FFluEfv36pb9jyU1cZyxhmZH//ve/4dBDD03nL65z8cUXD7vtttt0+1GqIvfEE0+Egw8+OC3XqlWrVCXtu+++m269V1xxRVh11VXTZxNLig477LA6q5rFKmKxalvc9nrrrReefPLJdAzxUdOECRPCqaeeGlZcccW0zvi5n3DCCWn6tG688cbqc9S2bduw++67h08//TTMrngNxap/7dq1qw5z0cSJE8Nqq60WVlhhhXT9ATQkJSAAZTJmzJjwzTffpJvAePN36aWXhu+//z7daJfEeb/61a/CY489lkpIYmPrhx56KN3Qx5vxiy66KN18xlKKjTfeOJx88snhwgsvTO+NN8JxG/GGunHjxnO8fx9++GF6jjfgM/LII4+kkpx4Yx2DRgxA8TjivsRqXJ07dw4777xzeO+991LJTtzfGCaieNM7I3GfYylMDBYDBw5MVdT+/Oc/h6effjq8/PLLKejEY41hIlYVK1VnizfMM6uuFauCxZv0ZZZZJgWPK6+8MgWAt956Kyy88MK1lj/88MPTduJxvfvuu2nZGGJKbWaiOC9WLYvVvw455JDq5eK24r7G9jRRnBbXF4PaMccck7bdt2/fsNhii6V9KZk6dWr6vJ966qlw0EEHhe7du6cqcPG8xXN49913Vy971llnhVNOOSW1gfntb38bvv7663TuN9tss+pzNCvxOK699tqw+uqrh9/97nfhzjvvTNNjAHrzzTfTsWpTAzS4AoC5ct1118Wii+kezZs3LwYPHlxr2bvvvjvNO/PMM2tN33XXXYuqqqrigw8+qJ7Wv3//olGjRsUTTzxR3Hbbbel9F1988Sz357HHHkvLXnvttcXXX39djBgxorj//vuLzp07p2288MILabmPP/44LRf3v2TNNdcsllxyyeLbb7+tnvbqq6+m/dhnn32qp5133nnpvXEdszJx4sS0zh49ehQ//vhj9fT77rsvrWPAgAHTncvSPs7M+PHjp5s2dOjQ9P6///3v062zZ8+eaV9Kzj333DT9nnvuSa9HjhxZNGvWrNh6662LKVOmVC932WWXVZ/PaMKECcXiiy9erLvuusWkSZOql4ufdVxu8803r552ww03pHP35JNP1trPq666Ki379NNPp9fDhw8vGjduXJx11lm1lnv99deLJk2aTDd9Vv7yl7+k9d94443Fs88+m9Z99NFHz9E6AOqLKlgAZRKr5Dz88MPpEavSxKow8Zfs0q/Q0b/+9a9UehHbYtQUq2TF0pGavWbFX+NjVaBYLSlWNdp8882ne9/M7L///qlUIlYj6tOnT6p6E0tWarZTqemLL74Ir7zySqr2FKv/lMRf03/5y1+mff85XnzxxVQiFI8hdq1bEvcpVjOLDeN/jlhSVBIb2scetGI1p1hSEEtrphVLIEolGFEs4YjV40rHFUt/YlWlo48+OjRq9P//ezzwwANTla3SfsbjiduK02tWr9tzzz1TCci01c5iqUc8zlg6VnqUqsPFkrAoXiOxtCSWftRcrkOHDqFr167Vy82ueKy9e/cORxxxRNh7771TSdLZZ589R+sAqC+qYAGUSWwHUPPmfo899ghrrbVWqqoTG6E3a9YsVfmJgWDRRRet9d54kxrF+SVx+VidJlZbijfu1113XXVVodkxYMCAVEUoBp5YTSpuY9r2KDWVth2rQU0rvjdWFYshZk6r8MxsvfHGPFZP+jli9bBYnSuel1h9rdSGJopV1aYVb+RratmyZWpTU2ozMqP9jJ9DrJJWml96jmGnpnhuYxW1mt5///3UfmZG1dNK7TTicnH/p93HkprBaXZdc801KXjEdceqajUDG0BDEkAA6kn8FT2WgsS2DvEmMJZmzKl40x/99NNPaR2xXcTsio2OK7kr2/jrfgwfscRiww03DK1bt04BLbYJiaUJ84K4H/FzKLXjmVZskF5aLu57LAGrq31PDEtzKrb3KDV0j+1O4jkCmBcIIAD1aPLkyek5NkaPlltuuVTVJ451UbMU5J133qmeX/Laa6+lxtix8XasGhWrc8UbyXijXR9K244Nr6cV9y+WopRKP+akJKbmektVj0ritJrHPCduv/32VD3tggsuqJ4Wg9qMBkeMAS4GwpL4mcRqZ3Gslmn3M5Z4lMRqWbHnsFKYKy33wQcf1Fpf/KxjaUqsslYSSyBeffXVsNVWW830nMXlYglIDJixu+S5FY8rBrStt946leAcd9xxqUrWzz3XAOWkDQhAPYntEv7973+nG8BSFat4sxu70L3ssstqLRt7RYo3qLEHqtJ7Y1uMWF0rlqDEXqRiz1Gxx6X6EqsjxV65YjuRmjfxb7zxRjqO0o16VAoiszMSeqyWFkeGv+qqq2p1PRt/7Y/Vk2JbkJ8jlhTUrHYVxV6jZtRFcexdK57XktiTVQwNpXMeA0b8rC655JJa641VmWKVrtJ+xuOJPYn99a9/rQ6Y0U033TRdt76xTUesHhaXrasKWalL3NizWDye2APXtMcUX8c2J3Mitk+JpSpx3+Nxx+phsde1adcN0BCUgACUSbyhLpVkxLr9N998c/rV/aSTTkqNmKMddtgh/Woeu5yNv5avscYa6eb+nnvuSVWJSt3OnnnmmanUY8iQIamkJP6qHtt0/PGPf0yDC9YMA+V03nnnpRvyWF0n3rCWuuGNpS6xUXxJHKsiiscRqzzFNgrx2OpqHxLnnXPOOakkJzakj21jSt3wxjYTPzdUxXY1N9xwQ9q3VVZZJQwdOjSVLs2om+FYkhFLImIoiKUccbyPTTbZJHWTG8V2GnGAxhgCttlmmzS9tFxsh1PqTjmGlHguYglDLNGJ64ufZQyJ8fOrWdIRG4D/85//TF3ixobksTvjGJDidRKnxyp2MdDE98XPPG6/1KVv/Nxjyctdd92VGpXHUozZEaulxQbzcX9KXQLHzzDufwxdsTMAgAZVb/1rASzA3fAutNBCqUvbK6+8spg6dWqt5ceNG1ccc8wxRceOHYumTZsWXbt2Td3alpYbNmxY6nr1iCOOqPW+yZMnp65f4/u+++67WXbDG7vunZm6uuGNHnnkkWLjjTcuWrRoUbRq1arYYYcdirfeemu6959xxhnF0ksvnbqZnZ0uef/xj38Ua621VuqeuG3btsWee+5ZfPbZZ7WWmZNueOM52G+//YollliiaNmyZdG7d+/inXfeKZZbbrmiX79+063z8ccfLw466KBiscUWS8vH7dfsbrhmt7vdunVLn0379u2LQw45pM7zfckll6RtxeNZb731Upe6savfbbbZptZysevfc845p1h11VXTsnH7cbnTTjutGDNmTK1l77jjjmKTTTYpFllkkfSI+3HYYYcV7777bjE7Pv3006J169bpM5vWTjvtlNb50Ucfzda6AOpLVfynYSMQANSf0iCIcTDBGXVBXA6xylMsRYnVqeqqcgXA/9EGBADmUGzsPu3vd3//+9/DqFGj0kjsAMyYNiAAMIeeffbZ1HZlt912S21O4sCHscF3jx490rT6ENvj1DW+SU1xAMnYRgVgXiaAAMAcio3n4xgescesWOoRb/z32WefMGjQoHoLAP/4xz9SVbKZiQ3dlcAA8zptQABgPhDH9njzzTdnukzsnWyxxRbLtk8AP4cAAgAAZKMROgAAkI02IDPpTnHEiBFpIKiag0oBAEAlK4oijBs3LnTs2DE0alT+8goBZAZi+IgNDAEAYEH06aefhmWWWabs6xVAZiCWfJROfKtWrcp+4gEAYF40duzY9EN86X643ASQGShVu4rhQwABAGBBU1VPzRA0QgcAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyaZJvU8D87v333w/jxo1r6N1gPrfooouGrl27NvRuANBABBBgtsPHSiut5GzNRIeWVeHgns3CX4ZNDF9+XzhXM/Hee+8JIQALKAEEmC2lko8bb7wxdO/e3VmrQ4vR74XuTxwcfjNgcPixjbBWl7fffjvstddeStIAFmACCDBHYvhYe+21nbW6jGgUwhMhdO/WLYSOazpHAFAHjdABAIBsBBAAACAbAQQAAMhGAJlHjR8/Prz00kvpGQDAPQOVQgCZR73zzjuhZ8+e6RkAwD0DlUIvWAAAhClTpoQnn3wyfP755+Hrr78O7dq1C0svvXTYdNNNQ+PGjWf7/V988UVYaqmlpnvfrObP6XKVasoCcPwCCADAAu7OO+8Mv//978Pw4cOnm9e5c+dwwQUXhJ133nmO3l/zfbOaP7vrqXR3LiDHrwoWAMACLN707rrrrmGJJZYIVVVVYdtttw1//etf03MUp8f5cbmZvX+11VYLQ4cOTQONxuf4Ok4/4YQTZjq/tN5ZrWdG268Udy5Ix19QpzFjxhTx9MTnhjBs2LC0/fgM8wLX5Gz4/OWiOLXV/z3jOoL54Pt58uTJRefOnYvtt98+Pe+www7FlClT0rz4HF+X5nfp0iUtX9f7a76vJL6O72vSpEl6rmt+fF9c74QJE2a6ntJy026/UkyexXnMffz1fR+sCtY86scff0zPb7/9dkPvCtS6FkvXJvwcvtug/Obm+zm2NYjVfY4//vhw3333hVtuuSU0avR/FWTic//+/cNGG20UjjvuuDQ/Lr/FFltM9/6a7yuJr7fZZpv0vliaUtf80vqvuOKKma6ntNy0268UT87iPFba8Qsg86hS3b+99tqroXcFprs2N954Y2eFn8V3G8xb38+xoXPUokWL9NyjR49a80uvS/NLy0/7/mnfV1J6X+l5WqX3ffjhhzNdT2n6tNuvFF/M4jxW2vELIPOo2OAouvHGG0P37t0bencg/cIWA3Hp2oSfw3cbzFvfz7GXpZqlJ2+88UbYYIMNqufH1zXnl5af9v3Tvq+k9L4Zlc6U1r/CCivMdD2l5abdfqVYahbnsdKOXwCZR5V+KYjhY+21127o3YFqM/oVC2aH7zaYt76fYxevMbg88MAD6fnss88Od999d6r2M3Xq1DBw4MA0/cEHHwxdunRJy9f1/prvK4nvj+9r0qRJWv/vfve76ebH9cf1HnrooeHPf/7zDNdTWm7a7VeKTWdxHivt+PWCBQCwgIrjS8QuXu+///7U21Vsr7H99tuHq6++Oj3fe++9aXqcf/755083HkXp/fF9ffv2rdV7U3wd33fMMcek57rmx/fF9TZr1mym6yktV2njYczueay041cCAgCwAIvjS9x+++1p/ImiKFJpRXyUfPvtt2n+jMahqPn+2FC6JP5iX3pfrFY0s/mzu55KtvMCdPwCCADAAi7e3O64444/eyT0mu+vawTvWc2f3fVUup0XkOMXQAAASDe5c9PF66zeP7vrn9v9mN81XgCOXxsQAAAgGwFkHtWtW7cwbNiw9AwA4J6BSqEK1jxq4YUX1v0uAOCegYqjBAQAAMhGAAEAALJRBQuYLePHj0/PL730kjM2Ay1Gvxe6hxDefued8OOXU52nOrz99tvOC8ACTgABZss777yTng888EBnbAY6tKwKB/dsFv5ywf+EL78vnKeZWHTRRZ0fgAWUAALMlr59+6bn2DNb7CSBGfuVkzPL8NG1a1dnCWABVVUUhZ/p6jB27NjQunXrMGbMmNCqVav8nwwAAFTgfbBG6AAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAAggAABA5VECAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGTTJN+m5i9FUaTnsWPHNvSuAABANqX739L9cLkJIDMwbty49NypU6d6OfEAADCv3w+3bt267OutKuor2sznpk6dGkaMGBEWXXTRUFVV1dC7AwAAWcR4EMNHx44dQ6NG5W+xIYAAAADZaIQOAABkI4AAAADZCCAAAIAAAgAAVB4lIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAZdS5c+ew7777Oqf17LzzzgvLL798aNy4cVhzzTWdb4D5iAACMAODBw8OVVVV4cUXX6xz/hZbbBF69Ogx1+fvX//6V/jTn/7kc5hN//73v8MJJ5wQNt5443DdddeFs88+27kDmI80aegdAKgk7777bmjUqNEcB5DLL79cCJlNjz76aDrH11xzTWjWrNnP+ZgAaEBKQADKqHnz5qFp06bz1Tn94Ycfwvxk5MiRoUWLFsIHwHxKAAGoxzYgkyZNCqeddlro2rVrWGihhcLiiy8eNtlkk/Dwww+n+XHZWPoRxepepUfNcPD73/8+dOrUKYWblVdeOZx//vmhKIpa2/3xxx/DkUceGZZYYomw6KKLhl/96lfh888/T+uqWb0r/h2nvfXWW+F//ud/wmKLLZb2J3rttdfS/sS2FXFfO3ToEPbff//w7bff1tpWaR3vvfde2GuvvULr1q1Du3btwimnnJL269NPPw077rhjaNWqVVrHBRdcMFvnbvLkyeGMM84IK6ywQjrWeC7/8Ic/hAkTJlQvE7cbq13F81I6V7Gq3Iw8+eSTYbfddgvLLrtsWmc8j8ccc0w6XzXF427ZsmX46KOPQu/evcMiiywSOnbsGE4//fTpznW5P5MoTo/nun379mmdq666arj22munO554Lk499dSw4oorVh9PrI5W8xzNToCLn1esQlhznz/44IN03L/5zW9me10AP4cqWACzMGbMmPDNN99MNz2Gi1mJN5oDBw4Mv/3tb8N6660Xxo4dm9qUvPTSS+GXv/xlOPjgg8OIESNSILnhhhtqvTfeHMab1sceeywccMABqbH1Qw89FI4//vh0w3rRRRfVuoH+5z//Gfbee++wwQYbhMcffzz06dNnhvsVb8pjKIrtJ0o3oXEf4g34fvvtl4LDm2++Ga6++ur0/Oyzz9YKRlG8Ue3evXsYNGhQuP/++8OZZ54Z2rZtG/7yl7+ELbfcMpxzzjnhpptuCscdd1xYd911w2abbTbTcxXP0fXXXx923XXXdIP/3HPPpXP39ttvh7vuuistE89R3Kfnn38+/O1vf0vTNtpooxmu87bbbgvjx48PhxxySAp/8X2XXnpp+Oyzz9K8mqZMmRK22WabdP7OPffc8OCDD6ab/RiMYhCpr8/kq6++SvPj+T388MNTOHjggQfS+uP1cvTRR6flpk6dmrb91FNPhYMOOiid+9dffz1tM4bBu+++O8yOJZdcMlx55ZXpGojnIoakuO64vzEoXXHFFbO1HoCfrQCgTtddd128M5/pY9VVV631nuWWW67o169f9es11lij6NOnz0zP8GGHHZbWNa277747TT/zzDNrTd91112Lqqqq4oMPPkivhw0blpY7+uijay237777pumnnnpq9bT4d5y2xx57TLe98ePHTzftlltuScs/8cQT063joIMOqp42efLkYplllkn7NWjQoOrp3333XdGiRYta56Qur7zySlrnb3/721rTjzvuuDT90UcfrZ4W17XIIovMdH0zO6aBAwem/fzvf/9ba51xO0cccUT1tKlTp6bPrlmzZsXXX39db5/JAQccUCy11FLFN998U2vZ3XffvWjdunX1Mdxwww1Fo0aNiieffLLWcldddVVa59NPP13MiXgNLLzwwsV7771XnHfeeWkd8fgA6psqWACzEKtIxdKBaR+rr776LM9dmzZtUgnC+++/P8fnOTZOj93Mxl+oa4qlA/GX+PgreRR/qY8OPfTQWssdccQRM1z37373u+mmxXYVJT/99FMq9Ym/zEexxKauEouSuJ/rrLNO2q/4y33N449VlGLJyqyONTr22GOnO9YolrD8HDWPKVadiscUS0zifr788svTLR9LIEpKJRITJ04MjzzySL18JvE9d9xxR9hhhx3S33H/So9YFSyWvpXOfSyxiaUe3bp1q7VcLG2KYqnMnLjssstS9blY4hSrz8WSmlh1DqC+qYIFMAux6lS8uZ5WbD9RV9WsmmLVnXhTt9JKK6Uue2MVn3ijNzvh5b///W9qhxCrxdQUb0JL80vPsVeoLl261FouthOYkWmXjUaNGpXaq9x6662pnUBN8UZ4WrFdRU3xZja2HYltHqadPm07kmmVjmHafY5VwWKIKR3rnPrkk0/CgAEDwv/+7/+G7777bqbHFLcf27/UFD+3aPjw4fXymXz99ddh9OjRqVpZfNSl9FnEEBuro8UqWjNbbnbF6nKXXHJJqooV257EvwFyEEAA6lFs9/Dhhx+Ge+65J41fEdstxDr7V111Va0ShNxqlgyU/PrXvw7PPPNMas8Q2zbERtmxbUAMTfF5WrEkYHamRdM20J6RaduZzI3YpiO2s4nB6sQTT0wlB7GRdWyrEds71HVMuZX2ITbm79evX53LlMJqXHa11VYLF154YZ3LxQbpcyq2X4liOIvtYmLYA6hvAghAPYu/NMeG3fHx/fffp1ASG6eXAsiMbrqXW265VPVn3LhxtX5xf+edd6rnl57jzenHH3+cGpbX7NVodsUb0CFDhqQSkFhiUPJzqo79HKVjiNsrlSaUGmjHEoLSsc6J2EA7Ns6ODdv32Wef6umlHsimFbcfq4qVSj2i+P4o9shVH59JLM2I64lhqVevXjM9ntg72Kuvvhq22mqrsgS1WE0sBuLYi1bsLCAGoNjwv0kTtwZA/dIGBKAeTVv1KJYqxGo4NbtNjb/KR/FGu6btttsu3ZjGuvo1xRKUeAO67bbbptexrUA0be9FsYej2VUquZi2pOLiiy8OOcRjrWt7pV/7Z9aj15wcU/z7z3/+8wzfU/Ncx2Xj6ziuS7zpr4/PJO7jLrvsktqBvPHGG9PtT6yiVbOEKpbe/PWvf51uudjl75yM5xKvtVLPbLEntBhEYlsTo8oDOfiZA6AerbLKKmm8hZ49e6aSkNgF7+23316rsXOcF8WGzfHGNd6U7r777qlh8i9+8Ytw8sknpzYIa6yxRqrGFatzxa5Z4y/ipffHm9h48x4DT6nL19Kv97Pza3kcsyOWzMTuZ2P3wksvvXTaVvwFP4d4bPEX+NgOIt4cb7755qnL3Fh60bdv33Qe5lSschXPUewGON64x2OMN/rTtgUpie1XYqlA3I/1118/NSiPjd/jWCSldhf18ZnEboxjA/K4zQMPPDBdM7HaWAwEsbQl/h3FtkOxW9/YgUBcfuONN05hKJa+xOmxOlVdbZXqctRRR6X9iuuP11usZhcDSexKObZZiscFUG/qvZ8tgPm8G94XXnihzvmbb775LLvhjd21rrfeekWbNm1Sd7TdunUrzjrrrGLixIm1urCN3b+2a9cudeVa86t53LhxxTHHHFN07NixaNq0adG1a9fUZWrsIramH374IXXn27Zt26Jly5ZF3759i3fffTetq2a3uKUudEvdytb02WefFTvttFPa19j962677VaMGDFihl35TruOGXWPW9d5qsukSZOK0047rejSpUs61k6dOhX9+/cvfvrpp9naTl3eeuutolevXumcLLHEEsWBBx5YvPrqq2n/4+c77To//PDDYuutt07d07Zv3z4d65QpU2qts9yfSfTVV1+lZeMxx3V26NCh2GqrrYqrr7661nLxujnnnHPS+WzevHmx2GKLFT179kznbcyYMbN1Tu655560DxdccEGt6WPHjk3Xb+w6uub1CVBuVfGf+os3ADSUV155Jay11lrhxhtvDHvuuacPYiZio/RYMhXb6PhMAOqXNiAAFSC2AZhWrP4Tu4Kd1Qjk+EwActIGBKACxLYbw4YNS+0TYi9Gsf1CfBx00EE/q3tW5s/PJI5tUlcYnXZsFYCGJIAAVIA4unfsXvaMM85I1YjiIIGxq9/YWJoF5zOJjctjw/2ZUfMaaGjagABAhXjrrbfCiBEjZrrMrMYbAahvAggAAJCNRugAAEA22oDMwNSpU1Mx9qKLLjpbg3gBAEAlKIoijBs3LnTs2DH1plhuAsgMxPCh5xgAABZUn376aVhmmWXKvl4BZAZiyUfpxLdq1arsJx4AAOZFY8eOTT/El+6Hy00AmYFStasYPgQQAAAWNFX11AxBI3QAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIpkm+TQEwuzqfdP8Cf7KGD+qzwJ8DgEqkBAQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYvWMA8SS9QAFCZlIAAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAAC24AGThwYFh33XXDoosuGpZccsnQt2/f8O6779Za5qeffgqHHXZYWHzxxUPLli3DLrvsEr766qtay3zyySehT58+YeGFF07rOf7448PkyZMzHw0AADBPB5DHH388hYtnn302PPzww2HSpElh6623Dj/88EP1Msccc0y49957w2233ZaWHzFiRNh5552r50+ZMiWFj4kTJ4ZnnnkmXH/99WHw4MFhwIABDXRUAABAVFUURTEvn4qvv/46lWDEoLHZZpuFMWPGhHbt2oWbb7457LrrrmmZd955J3Tv3j0MHTo0bLDBBuGBBx4I22+/fQom7du3T8tcddVV4cQTT0zra9as2Sy3O3bs2NC6deu0vVatWtX7cQK1dT7pfqdkATd8UJ+G3gWABdLYer4PnudKQKYVDzxq27Zteh42bFgqFenVq1f1Mt26dQvLLrtsCiBRfF5ttdWqw0fUu3fvdDLffPPNOrczYcKENL/mAwAAWIACyNSpU8PRRx8dNt5449CjR4807csvv0wlGG3atKm1bAwbcV5pmZrhozS/NG9GbU9i0is9OnXqVE9HBQAAC655OoDEtiBvvPFGuPXWW+t9W/3790+lLaXHp59+Wu/bBACABU2TMI86/PDDw3333ReeeOKJsMwyy1RP79ChQ2pcPnr06FqlILEXrDivtMzzzz9fa32lXrJKy0yrefPm6QEAACxAJSCxTXwMH3fddVd49NFHQ5cuXWrN79mzZ2jatGkYMmRI9bTYTW/sdnfDDTdMr+Pz66+/HkaOHFm9TOxRKzaiWWWVVTIeDQAAME+XgMRqV7GHq3vuuSeNBVJqsxHbZbRo0SI9H3DAAeHYY49NDdNjqDjiiCNS6Ig9YEWx294YNPbee+9w7rnnpnX88Y9/TOtWygEAAA1nngsgV155ZXreYostak2/7rrrwr777pv+vuiii0KjRo3SAISx96rYw9UVV1xRvWzjxo1T9a1DDjkkBZNFFlkk9OvXL5x++umZjwYAAJivxgFpKMYBgYZlHBCMAwLQMBb4cUAAAIDKMc81QgcAACqXAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABk0yTfpoA50fmk+50wAKDiKAEBAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAQAABAAAqjxIQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAYP4KIC+99FJ4/fXXq1/fc889oW/fvuEPf/hDmDhxYjk2AQAAVICyBJCDDz44vPfee+nvjz76KOy+++5h4YUXDrfddls44YQTyrEJAACgApQlgMTwseaaa6a/Y+jYbLPNws033xwGDx4c7rjjjnJsAgAAqABlCSBFUYSpU6emvx955JGw3Xbbpb87deoUvvnmm3JsAgAAqABlCSDrrLNOOPPMM8MNN9wQHn/88dCnT580/eOPPw7t27cvxyYAAIAKUJYAcvHFF6eG6Icffng4+eSTw4orrpim33777WGjjTYqxyYAAIAK0KQcK1l99dVr9YJVct5554XGjRuXYxMAAEAFKNs4IKNHjw5/+9vfQv/+/cOoUaPStLfeeiuMHDmyXJsAAADmc2UJIK+99lro2rVrOOecc8L555+fwkh05513pkAyJ5544omwww47hI4dO4aqqqpw991315q/7777puk1H9tss02tZWIA2nPPPUOrVq1CmzZtwgEHHBC+//77MhwpAADQ4AHk2GOPDfvtt194//33w0ILLVQ9PfaGFQPFnPjhhx/CGmusES6//PIZLhMDxxdffFH9uOWWW2rNj+HjzTffDA8//HC477770j4cdNBBP+PIAACAea4NyAsvvBD+8pe/TDd96aWXDl9++eUcrWvbbbdNj5lp3rx56NChQ53z3n777fDggw+mfYq9c0WXXnppCkOxdCaWrAAAAPNxCUgMBGPHjq1zgMJ27dqFcvvPf/4TllxyybDyyiuHQw45JHz77bfV84YOHZqqXZXCR9SrV6/QqFGj8Nxzz5V9XwAAgMwB5Fe/+lU4/fTTw6RJk9Lr2C7jk08+CSeeeGLYZZddQjnF6ld///vfw5AhQ1KbkzjuSCwxmTJlSpofS1xiOKmpSZMmoW3btjMtjZkwYUIKUTUfAADAPBhALrjggtTIO974//jjj2HzzTdPY4Esuuii4ayzzgrltPvuu6fAs9pqq4W+ffumNh6xulUsFZkbAwcODK1bt65+xFHcAQCAebANSLxhjw2+n3766fDqq6+mMLL22munqk/1bfnllw9LLLFE+OCDD8JWW22V2oZM2/Xv5MmTU89YM2o3EsXeumJj+pJYAiKEAADAPBhASjbeeOP0yOmzzz5LbUCWWmqp9HrDDTdM3QAPGzYs9OzZM0179NFHw9SpU8P6668/03Ys8QEAAMzjVbCOPPLIcMkll0w3/bLLLgtHH330HK0rlp688sor6RF9/PHH6e/YpiTOO/7448Ozzz4bhg8fntqB7Ljjjqm6V+/evdPy3bt3T+1EDjzwwPD888+nUpnDDz88Vd3SAxYAAFRAALnjjjvqLPnYaKONwu233z5H63rxxRfDWmutlR5RrBYV/x4wYEBo3LhxGvQwtgFZaaWV0gCDsZTjySefrFV6cdNNN4Vu3bqlKlmx+91NNtkkXH311WU4UgAAoMGrYMUqULEdyLTiSOTffPPNHK1riy22CEVRzHD+Qw89NMt1xB6vbr755jnaLgAAMJ+UgMQqUHHwv2k98MADqZE4AABA2UpAYjWp2M7i66+/DltuuWWaFttnxO55L774YmcaAAAoXwDZf//900B+ccyPM844I03r3LlzuPLKK8M+++xTjk0AAAAVoGzd8B5yyCHpEUtBWrRoEVq2bFmuVQMAABWirOOARO3atSv3KgEAgApRlkboX331Vdh7773TOBtNmjRJ3eXWfAAAAJStBGTfffdNAwWecsopaUTyqqoqZxcAAKifAPLUU0+lwQDXXHPNcqwOAACoUGWpgtWpU6eZDh4IAABQtgASx/o46aSTwvDhw51VAACgfqtg/eY3vwnjx48PK6ywQlh44YVD06ZNa80fNWpUOTYDAADM58oSQIx2DgAAZAsg/fr1K8dqAACACleWNiDRhx9+GP74xz+GPfbYI4wcOTJNe+CBB8Kbb75Zrk0AAADzubIEkMcffzysttpq4bnnngt33nln+P7779P0V199NZx66qnl2AQAAFAByhJAYg9YZ555Znj44YdDs2bNqqdvueWW4dlnny3HJgAAgApQlgDy+uuvh5122mm66UsuuWT45ptvyrEJAACgApQlgLRp0yZ88cUX001/+eWXw9JLL12OTQAAABWgLAFk9913DyeeeGL48ssvQ1VVVZg6dWp4+umnw3HHHRf22WefcmwCAACoAGUJIGeffXbo1q1b6NSpU2qAvsoqq4TNNtssbLTRRqlnLAAAgLKMA1IURSr5uOSSS8KAAQNSe5AYQtZaa63QtWtXZxkAAChvAFlxxRXTeB8xcMRSEAAAgHqpgtWoUaMUPL799tu5XRUAAFDhytIGZNCgQeH4448Pb7zxRjlWBwAAVKi5roIVxZ6uxo8fH9ZYY400EGGLFi1qzR81alQ5NgMAAMznyhJALr744nKsBgAAqHBzHUAmTZoUHn/88XDKKaeELl26lGevAACAijTXbUCaNm0a7rjjjvLsDQAAUNHK0gi9b9++4e677y7HqgAAgApWljYgsRve008/PTz99NOhZ8+eYZFFFqk1/8gjjyzHZgAAgPlcWQLINddcE9q0aROGDRuWHjVVVVUJIAAAQPkCyMcff1yO1QAAABWuLG1AAAAAspWA7L///jOdf+2115ZjMwAAwHyuLAHku+++m25skDfeeCOMHj06bLnlluXYBAAAUAHKEkDuuuuu6aZNnTo1HHLIIWGFFVYoxyYAAIAKUG9tQBo1ahSOPfbYcNFFF9XXJgAAgPlMvTZC//DDD8PkyZPrcxMAAMCCVgUrlnTUVBRF+OKLL8L9998f+vXrV45NAAAAFaAsAeTll1+ervpVu3btwgUXXDDLHrIAAIAFR1kCyGOPPVaO1QAAABWuUblGQn///fenmx6nDR8+vBybAAAAKkBZAsi+++4bnnnmmemmP/fcc2keAABA2QJIbAOy8cYbTzd9gw02CK+88oozDQAAlC+AVFVVhXHjxk03fcyYMWHKlCnl2AQAAFAByhJANttsszBw4MBaYSP+Hadtsskm5dgEAABQAcrSC9Y555yTQsjKK68cNt100zTtySefDGPHjg2PPvpoOTYBAABUgLKUgKyyyirhtddeC7/+9a/DyJEjU3WsffbZJ7zzzjuhR48e5dgEAABQAcpSAhJ17NgxnH322eVaHQAAUIHKUgJy3XXXhdtuu2266XHa9ddfX45NAAAAFaAsASQ2Nl9iiSWmm77kkksqFQEAAMobQD755JPQpUuX6aYvt9xyaR4AAEDZAkgs6YiN0Kf16quvhsUXX9yZBgAAyhdA9thjj3DkkUeGxx57LI3/ER+x+92jjjoq7L777uXYBAAAUAHK0gvWGWecEYYPHx622mqr0KTJ/61y6tSpqStePWMBAABlDSDNmjUL//jHP1IQidWuWrRoEVZbbbXUBgQAAKDs44BEbdu2Db/4xS/q7BELAABgrtuAjB49Ohx22GEpdLRv3z494t+HH354mgcAAFCWEpBRo0aFDTfcMHz++edhzz33DN27d0/T33rrrTB48OAwZMiQ8Mwzz4TFFltsbjYDAABUiLkKIKeffnpq//Hhhx+mko9p52299dbp+aKLLprb/QRgAdP5pPvDgmz4oD4NvQsA814VrLvvvjucf/7504WPqEOHDuHcc88Nd91119xsAgAAqCBzFUC++OKLsOqqq85wfo8ePcKXX345N5sAAAAqyFwFkNjYPI7/MSMff/xx6hkLAABgrgNI7969w8knnxwmTpw43bwJEyaEU045JWyzzTbONAAAUJ5G6Ouss07o2rVr6oq3W7duoSiK8Pbbb4crrrgihZAbbrhhbjYBAABUkLkKIMsss0wYOnRoOPTQQ0P//v1T+IiqqqrCL3/5y3DZZZeFTp06lWtfWcAs6D3gAABUorkeCb1Lly7hgQceCN999114//3307QVV1xR2w8AAKD8AaQkDja43nrrlWt1AABABZqrRugAAABzQgABAACyEUAAAIB5P4CsvfbaqeF5qTve8ePHl3O/AACACvSzA0gc6+OHH35If5922mnh+++/L+d+AQAAFehn94K15pprhv322y9ssskmafyP888/P7Rs2bLOZQcMGDA3+wgAACzoAWTw4MHh1FNPDffdd18aeDCOBdKkyfSri/MEEAAAYK4CyMorrxxuvfXW9HejRo3CkCFDwpJLLumsAgAA9TsQ4dSpU8uxGgAAoMKVbST0Dz/8MFx88cWpcXq0yiqrhKOOOiqssMIK5doEAAAwnyvLOCAPPfRQChzPP/98WH311dPjueeeC6uuump4+OGHy7EJAACgApSlBOSkk04KxxxzTBg0aNB000888cTwy1/+shybAQAA5nNlKQGJ1a4OOOCA6abvv//+4a233irHJgAAgApQlgDSrl278Morr0w3PU7TMxYAAFDWKlgHHnhgOOigg8JHH30UNtpoozTt6aefDuecc0449thjy7EJAACgApQlgJxyyilh0UUXDRdccEHo379/mtaxY8fwpz/9KRx55JHl2AQAAFAByhJA4mjnsRF6fIwbNy5Ni4EEAACgXsYBKRE8AACAem2EDgAAMDsEEAAAIBsBBAAAmH8CyKRJk8JWW20V3n///fLsEQAAULHmOoA0bdo0vPbaa+XZGwAAoKKVpQrWXnvtFa655ppyrAoAAKhgZemGd/LkyeHaa68NjzzySOjZs2dYZJFFas2/8MILy7EZAABgPleWAPLGG2+EtddeO/393nvvTTdIIQAAQNkCyGOPPeZsAgAAebvh/eCDD8JDDz0Ufvzxx/S6KIpyrh4AAJjPlSWAfPvtt6kr3pVWWilst9124YsvvkjTDzjggPD73/++HJsAAAAqQFkCyDHHHJO64/3kk0/CwgsvXD39N7/5TXjwwQfLsQkAAKAClCWA/Pvf/w7nnHNOWGaZZWpN79q1a/jvf/87R+t64oknwg477BA6duyYGrDffffdtebHal0DBgwISy21VGjRokXo1avXdIMgjho1Kuy5556hVatWoU2bNqkk5vvvv5+LIwQAAOaZAPLDDz/UKvmoGQSaN28+x+taY401wuWXX17n/HPPPTdccskl4aqrrgrPPfdc6vK3d+/e4aeffqpeJoaPN998Mzz88MPhvvvuS6HmoIMO+hlHBgAAzHMBZNNNNw1///vfq1/HkoupU6emsPCLX/xijta17bbbhjPPPDPstNNO082LpR8XX3xx+OMf/xh23HHHsPrqq6ftjhgxorqk5O23307Vvv72t7+F9ddfP2yyySbh0ksvDbfeemtaDgAAmM+74Y1BIzZCf/HFF8PEiRPDCSeckEogYgnI008/Hcrl448/Dl9++WWqdlXSunXrFDSGDh0adt999/Qcq12ts8461cvE5Rs1apRKTOoKNtGECRPSo2Ts2LFl228AAKCMJSA9evRIAxDG0oZYMhGrUe28887h5ZdfDiussEIolxg+ovbt29eaHl+X5sXnJZdcstb8Jk2ahLZt21YvU5eBAwemMFN6dOrUqWz7DQAAlLEEJIo37SeffHKYX/Xv3z8ce+yxtUpAhBAAAJhHA8h3330XrrnmmtQGI1pllVXCfvvtl0oeyqVDhw7p+auvvkq9YJXE12uuuWb1MiNHjqz1vsmTJ6fqYKX31yU2lp/TBvMAAEADVMGKvUx17tw59U4Vg0h8xL+7dOmS5pVLXF8MEUOGDKlVUhHbdmy44YbpdXwePXp0GDZsWPUyjz76aGoUH9uKAAAA83kJyGGHHZYGHbzyyitD48aN07QpU6aEQw89NM17/fXXZ3tdcbyODz74oFbD81deeSWVpCy77LLh6KOPTr1kxTFGYiA55ZRT0pghffv2Tct37949bLPNNuHAAw9MXfVOmjQpHH744amBelwOAACYzwNIDAy33357dfiI4t+xTUXN7nlnR+xJq2bXvaV2Gf369QuDBw9OPWzFRu5xXI9Y0hEbvsdudxdaaKHq99x0000pdMSeuWLvV7vssksqkQEAACoggKy99tqp7cfKK69ca3qcFgcVnBNbbLFFGu9jRuIYI6effnp6zEgsLbn55pvnaLsAAMA8HEBee+216r+PPPLIcNRRR6WSkA022CBNe/bZZ9No5oMGDSrPngIAAPO9qmJmxQ0zEas2xdKIWb09LhPbg8xvYuP22LXwmDFjQqtWrRp6dxZInU+6v6F3AaDBDB/Ux9kHKvI++GeXgMTG4QAAAFkCyHLLLfdz3woAACygyjYQ4YgRI8JTTz2VBgGMY27UFNuIAAAAlCWAxO5xDz744NCsWbOw+OKLp3YfJfFvAQQAAChbAImDAQ4YMCD0798/NU4HAACoS1nSwvjx49NI48IHAABQ7wHkgAMOCLfddls5VgUAAFSwslTBGjhwYNh+++3Dgw8+GFZbbbXQtGnTWvMvvPDCcmwGAACYz5UtgDz00ENh5ZVXTq+nbYQOAABQtgBywQUXhGuvvTbsu+++zioAAFC/bUCaN28eNt54Y6cZAACo/wBy1FFHhUsvvbQcqwIAACpYWapgPf/88+HRRx8N9913X1h11VWna4R+5513lmMzAADAfK4sAaRNmzZh5513LseqAACAClaWAHLdddeVYzUAAECFK0sbEAAAgGwlIF26dJnpeB8fffRROTYDAADM58oSQI4++uharydNmhRefvnlNDL68ccfX45NAAAAFaBJubrhrcvll18eXnzxxXJsAgAAqAD12gZk2223DXfccUd9bgIAAJiP1GsAuf3220Pbtm3rcxMAAMCCVgVrrbXWqtUIvSiK8OWXX4avv/46XHHFFeXYBAAAUAHKEkD69u1b63WjRo1Cu3btwhZbbBG6detWjk0AAAAVoCwB5NRTTy3HagAAgApnIEIAAGD+KAGJVa1mNgBhFOdPnjx5bjYDAABUiLkKIHfdddcM5w0dOjRccsklYerUqXOzCQAAoILMVQDZcccdp5v27rvvhpNOOince++9Yc899wynn3763GwCAACoIGVrAzJixIhw4IEHhtVWWy1VuXrllVfC9ddfH5ZbbrlybQIAAFjQA8iYMWPCiSeeGFZcccXw5ptvhiFDhqTSjx49epRnDwEAgIoxV1Wwzj333HDOOeeEDh06hFtuuaXOKlkAAAAlVUUctnwuesFq0aJF6NWrV2jcuPEMl7vzzjvD/Gbs2LGhdevWqYSnVatWDb07C6TOJ93f0LsA0GCGD+rj7AMVeR88VyUg++yzzyy74QUAAChLABk8ePDcvB0AAFjAGAkdAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAABBAAACAyqMEBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALJpkm9TAMDs6nzS/Qv0yRo+qE9D7wJQT5SAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQz3wWQP/3pT6GqqqrWo1u3btXzf/rpp3DYYYeFxRdfPLRs2TLssssu4auvvmrQfQYAAObTABKtuuqq4Ysvvqh+PPXUU9XzjjnmmHDvvfeG2267LTz++ONhxIgRYeedd27Q/QUAAP5PkzAfatKkSejQocN008eMGROuueaacPPNN4ctt9wyTbvuuutC9+7dw7PPPhs22GCDBthbAABgvi4Bef/990PHjh3D8ssvH/bcc8/wySefpOnDhg0LkyZNCr169apeNlbPWnbZZcPQoUMbcI8BAID5sgRk/fXXD4MHDw4rr7xyqn512mmnhU033TS88cYb4csvvwzNmjULbdq0qfWe9u3bp3kzM2HChPQoGTt2bL0dAwAALKjmuwCy7bbbVv+9+uqrp0Cy3HLLhX/+85+hRYsWP3u9AwcOTGEGAACoP/NlFayaYmnHSiutFD744IPULmTixIlh9OjRtZaJvWDV1Wakpv79+6c2JKXHp59+Ws97DgAAC575PoB8//334cMPPwxLLbVU6NmzZ2jatGkYMmRI9fx33303tRHZcMMNZ7qe5s2bh1atWtV6AAAAC3gVrOOOOy7ssMMOqdpV7GL31FNPDY0bNw577LFHaN26dTjggAPCscceG9q2bZtCxBFHHJHChx6wAACg4c13AeSzzz5LYePbb78N7dq1C5tssknqYjf+HV100UWhUaNGaQDC2Ki8d+/e4Yorrmjo3QYAAEIIVUVRFM7E9GIvWLFEJbYHUR2rYXQ+6f4G2jIADW34oD4NvQuwwBpbz/fB830bEAAAYP4hgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2TfJtijnV+aT7nTQAACqKEhAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAshFAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACCbJvk2BQAwezqfdP8CfaqGD+rT0LsA9UYJCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANk0ybcpAABmR+eT7l+gT9TwQX0aeheoR0pAAACAbAQQAAAgGwEEAADIRgABAACyEUAAAIBsBBAAACAbAQQAAMhGAAEAALIRQAAAgGwEEAAAIBsBBAAAyEYAAQAAsmkSKtjll18ezjvvvPDll1+GNdZYI1x66aVhvfXWa+jdAgBgJjqfdP8Cf36GD+pTseegYktA/vGPf4Rjjz02nHrqqeGll15KAaR3795h5MiRDb1rAACwwKrYAHLhhReGAw88MOy3335hlVVWCVdddVVYeOGFw7XXXtvQuwYAAAusiqyCNXHixDBs2LDQv3//6mmNGjUKvXr1CkOHDq3zPRMmTEiPkjFjxqTnsWPHhoYydcL4Bts2AAANZ2wD3oOWtl0URb2svyIDyDfffBOmTJkS2rdvX2t6fP3OO+/U+Z6BAweG0047bbrpnTp1qrf9BACAurS+ODS4cePGhdatW5d9vRUZQH6OWFoS24yUTJ06NYwaNSosvvjioaqqqkH3bX4V03MMcJ9++mlo1apVQ+8OFcy1hmuNSuI7jYa+1mLJRwwfHTt2rJftVmQAWWKJJULjxo3DV199VWt6fN2hQ4c639O8efP0qKlNmzb1up8LinhBCyC41qgkvtdwnVHp32mt66Hko6IboTdr1iz07NkzDBkypFaJRny94YYbNui+AQDAgqwiS0CiWJ2qX79+YZ111kljf1x88cXhhx9+SL1iAQAADaNiA8hvfvOb8PXXX4cBAwakgQjXXHPN8OCDD07XMJ36E6u0xXFYpq3aBq415le+13CdUUmaN9C9WlVRX/1rAQAALAhtQAAAgHmTAAIAAGQjgAAAANkIIAAAQDYCCPXm8ssvD507dw4LLbRQWH/99cPzzz/vbDPbBg4cGNZdd92w6KKLhiWXXDL07ds3vPvuu7WW+emnn8Jhhx0WFl988dCyZcuwyy67TDcA6SeffBL69OkTFl544bSe448/PkyePNknQZ0GDRoUqqqqwtFHH+06o+w+//zzsNdee6XvrBYtWoTVVlstvPjii9XzY79AsffOpZZaKs3v1atXeP/992utY9SoUWHPPfdMg8bFAZMPOOCA8P333/u0qDZlypRwyimnhC5duqTraIUVVghnnHFGur7mmWst9oIF5XbrrbcWzZo1K6699trizTffLA488MCiTZs2xVdffeVkM1t69+5dXHfddcUbb7xRvPLKK8V2221XLLvsssX3339fvczvfve7olOnTsWQIUOKF198sdhggw2KjTbaqHr+5MmTix49ehS9evUqXn755eJf//pXscQSSxT9+/f3KTCd559/vujcuXOx+uqrF0cddZTrjLIaNWpUsdxyyxX77rtv8dxzzxUfffRR8dBDDxUffPBB9TKDBg0qWrduXdx9993Fq6++WvzqV78qunTpUvz444/Vy2yzzTbFGmusUTz77LPFk08+Way44orFHnvs4dOi2llnnVUsvvjixX333Vd8/PHHxW233Va0bNmy+POf/zzPXGsCCPVivfXWKw477LDq11OmTCk6duxYDBw40BnnZxk5cmT86aZ4/PHH0+vRo0cXTZs2TV+sJW+//XZaZujQoel1DByNGjUqvvzyy+plrrzyyqJVq1bFhAkTfBJUGzduXNG1a9fi4YcfLjbffPPqAOI6o1xOPPHEYpNNNpnh/KlTpxYdOnQozjvvvOpp8fpr3rx5ccstt6TXb731VvqOe+GFF6qXeeCBB4qqqqri888/92GR9OnTp9h///2Lmnbeeedizz33nGeuNVWwKLuJEyeGYcOGpeK8kkaNGqXXQ4cOdcb5WcaMGZOe27Ztm57jNTZp0qRa11m3bt3CsssuW32dxedYxaHmAKS9e/cOY8eODW+++aZPgmqxKl+sqlfzenKdUU7/+7//G9ZZZ52w2267peqga621VvjrX/9aPf/jjz9OAyfXvAZbt26dqjDX/E6LVWHiekri8vH/2Oeee84HRrLRRhuFIUOGhPfeey+9fvXVV8NTTz0Vtt1223nmWqvYkdBpON98802qfzjtqPPx9TvvvNNg+8X8a+rUqalO/sYbbxx69OiRpsUvz2bNmqUvyGmvszivtExd12FpHkS33npreOmll8ILL7ww3QlxnVEuH330UbjyyivDscceG/7whz+k6+3II49M32P9+vWr/k6q6zur5ndaDC81NWnSJP0w4zuNkpNOOin90BZ/lGvcuHG6JzvrrLNSe45oXrjWBBBgvvh1+o033ki/4EA5ffrpp+Goo44KDz/8cOowA+rzh5T4a/LZZ5+dXscSkPi9dtVVV6UAAuXyz3/+M9x0003h5ptvDquuump45ZVX0o94HTt2nGeuNVWwKLslllgiJe5peyOKrzt06OCMM0cOP/zwcN9994XHHnssLLPMMtXT47UUq/uNHj16htdZfK7rOizNg1iVb+TIkWHttddOv+7Fx+OPPx4uueSS9Hf8RdB1RjnE3oZWWWWVWtO6d++eeuqr+Z00s/8743O8XmuKvfrF3op8p1ESe3uMpSC77757qoa89957h2OOOSb1LjmvXGsCCGUXi5N79uyZ6h/W/OUnvt5www2dcWZL7CQjho+77rorPProo6k7wZriNda0adNa11nspjf+Z166zuLz66+/XutLNP7SHbsUnPZGgAXTVlttla6R+Ath6RF/pY5VFUp/u84oh1iFdNquxGMd/eWWWy79Hb/j4o1dze+0WI0m1rev+Z0Wf3SJwbkkfj/G/2Nj/X2Ixo8fn9pq1BR/GI7XyTxzrc11M3aYQTe8sTeFwYMHp54UDjrooNQNb83eiGBmDjnkkNRF4H/+85/iiy++qH6MHz++Vje8sWveRx99NHXDu+GGG6bHtN3wbr311qkr3wcffLBo166dbniZqZq9YLnOKGc3z02aNEldpL7//vvFTTfdVCy88MLFjTfeWKtr1Ph/5T333FO89tprxY477lhn16hrrbVW6sr3qaeeSr236YaXmvr161csvfTS1d3w3nnnnakL+hNOOGGeudYEEOrNpZdemm4O43ggsVve2I80zK74+0hdjzg2SEn8ojz00EOLxRZbLP1HvtNOO6WQUtPw4cOLbbfdtmjRokX6Av79739fTJo0yQfBbAcQ1xnlcu+996YfReIPdN26dSuuvvrqWvNj96innHJK0b59+7TMVlttVbz77ru1lvn222/TTWAc1yF2Kb7ffvulbqShZOzYsek7LN6DLbTQQsXyyy9fnHzyybW6n2/oa60q/jP35SgAAACzpg0IAACQjQACAABkI4AAAADZCCAAAEA2AggAAJCNAAIAAGQjgAAAANkIIAAAQDYCCAAAkI0AAgAAZCOAAAAA2QggAABANgIIAACQjQACAABkI4AAAADZCCAAAEA2AggAABBy+X+28Z4Q2cnEtgAAAABJRU5ErkJggg==", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -1028,9 +1314,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "90866127a4974d898d58adcc056e415c", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -1038,9 +1339,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "ce1a1ee87cbc45458985b79f8a2644ad", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -1048,9 +1364,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "b9a89ef39f7643a295a1d04476b79368", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -1058,9 +1389,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "3dd6d014b35e491dacd9ad1978292bfe", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -1068,9 +1414,24 @@ }, { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "632b64769c654c07bd743790190ebbbc", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], "text/plain": [ - "
" + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, @@ -1091,13 +1452,28 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", - "text": [] + "text": [ + "c:\\Users\\admin\\Desktop\\RocketPy\\venv\\Lib\\site-packages\\numpy\\lib\\_function_base_impl.py:571: RuntimeWarning: Mean of empty slice.\n", + " avg = a.mean(axis, **keepdims_kw)\n", + "c:\\Users\\admin\\Desktop\\RocketPy\\venv\\Lib\\site-packages\\numpy\\_core\\_methods.py:136: RuntimeWarning: invalid value encountered in divide\n", + " ret = um.true_divide(\n", + "C:\\Users\\admin\\Desktop\\RocketPy\\rocketpy\\tools.py:590: RuntimeWarning: Degrees of freedom <= 0 for slice\n", + " covariance_matrix = np.cov(list_x, list_y)\n", + "c:\\Users\\admin\\Desktop\\RocketPy\\venv\\Lib\\site-packages\\numpy\\lib\\_function_base_impl.py:2914: RuntimeWarning: divide by zero encountered in divide\n", + " c *= np.true_divide(1, fact)\n", + "c:\\Users\\admin\\Desktop\\RocketPy\\venv\\Lib\\site-packages\\numpy\\lib\\_function_base_impl.py:2914: RuntimeWarning: invalid value encountered in multiply\n", + " c *= np.true_divide(1, fact)\n", + "c:\\Users\\admin\\Desktop\\RocketPy\\venv\\Lib\\site-packages\\numpy\\_core\\fromnumeric.py:3860: RuntimeWarning: Mean of empty slice.\n", + " return _methods._mean(a, axis=axis, dtype=dtype,\n", + "c:\\Users\\admin\\Desktop\\RocketPy\\venv\\Lib\\site-packages\\numpy\\_core\\_methods.py:144: RuntimeWarning: invalid value encountered in scalar divide\n", + " ret = ret.dtype.type(ret / rcount)\n" + ] } ], "source": [ @@ -1136,7 +1512,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -1171,9 +1547,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The following input file was imported: monte_carlo_analysis_outputs\\monte_carlo_class_example_customized.inputs.txt\n", + "A total of 0 simulations results were loaded from the following output file: monte_carlo_analysis_outputs\\monte_carlo_class_example_customized.outputs.txt\n", + "\n", + "The following error file was imported: monte_carlo_analysis_outputs\\monte_carlo_class_example_customized.errors.txt \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\admin\\Desktop\\RocketPy\\rocketpy\\simulation\\monte_carlo.py:138: UserWarning: This class is still under testing and some attributes may be changed in next versions\n", + " warnings.warn(\n" + ] + } + ], "source": [ "test_dispersion = MonteCarlo(\n", " filename=\"monte_carlo_analysis_outputs/monte_carlo_class_example_customized\",\n", @@ -1187,18 +1582,50 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting Monte Carlo analysis \n", + "Iterations completed: 000010 | Average Time per Iteration: 0.449 s | Estimated time left: 0 s\n", + "Completed 10 iterations. In total, 10 simulations are exported.\n", + "Total wall time: 4.5 s \n", + "Results saved to monte_carlo_analysis_outputs\\monte_carlo_class_example_customized.outputs.txt\n" + ] + } + ], "source": [ "test_dispersion.simulate(number_of_simulations=10, append=False)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Monte Carlo Simulation by RocketPy\n", + "Data Source: monte_carlo_analysis_outputs\\monte_carlo_class_example_customized\n", + "Number of simulations: 10\n", + "Results: \n", + "\n", + " Parameter Mean Median Std. Dev. 95% PI Lower 95% PI Upper\n", + "--------------------------------------------------------------------------------------------------------------\n", + " apogee 3238.512 3238.136 777.943 1999.052 4267.947\n", + " apogee_time 24.875 25.060 2.608 20.379 28.010\n", + " x_impact 1994.748 1855.935 596.286 1091.269 2859.472\n", + " index 5.500 5.500 2.872 1.225 9.775\n", + " average_reynolds_number 1057974.328 1076980.672 191947.145 741972.395 1301327.838\n", + " date 513.750 12.000 872.524 6.000 2025.000\n" + ] + } + ], "source": [ "test_dispersion.prints.all()" ] @@ -1207,7 +1634,7 @@ "metadata": { "hide_input": false, "kernelspec": { - "display_name": "rpy", + "display_name": "venv", "language": "python", "name": "python3" }, @@ -1221,7 +1648,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.0" + "version": "3.13.9" } }, "nbformat": 4, From 150ee0e1dd7d50fe811c9925572c20c3b6ab0160 Mon Sep 17 00:00:00 2001 From: x25tang Date: Fri, 5 Dec 2025 05:53:49 +0800 Subject: [PATCH 20/32] REV: Remove background documents form mrs.rst --- docs/user/mrs.rst | 25 ------------------------- 1 file changed, 25 deletions(-) diff --git a/docs/user/mrs.rst b/docs/user/mrs.rst index ff8ce84a5..e58f7a784 100644 --- a/docs/user/mrs.rst +++ b/docs/user/mrs.rst @@ -204,31 +204,6 @@ Finally, we can compare the ellipses for the apogees and landing points using th Note we can pass along parameters used in the usual `ellipses` method of the `MonteCarlo` class, in this case the `ylim` argument to expand the y-axis limits. -You can also use the ``background`` parameter to automatically download and display -a background map. The ``background`` parameter accepts: -- ``"satellite"`` - uses Esri.WorldImagery for satellite imagery -- ``"street"`` - uses OpenStreetMap.Mapnik for street maps -- ``"terrain"`` - uses Esri.WorldTopoMap for terrain maps -- Any contextily provider name (e.g., ``"CartoDB.Positron"``) - -To view all available providers, you can use ``contextily.providers``: - -.. jupyter-execute:: - - import contextily - # List all available providers - print(list(contextily.providers.keys())) - -For example, to display a satellite background map: - -.. jupyter-execute:: - - original_results.compare_ellipses(mrs_results, background="satellite") - -Note that if both ``image`` and ``background`` parameters are provided, the ``image`` -parameter takes precedence. The background map is automatically downloaded based on the -environment's latitude and longitude coordinates. - Calculating Confidence Intervals -------------------------------- From 93a0b3be170acbcaea430e461db81f1aab0cfd7c Mon Sep 17 00:00:00 2001 From: x25tang Date: Fri, 5 Dec 2025 06:43:57 +0800 Subject: [PATCH 21/32] TST: Refactor Monte Carlo plot tests to remove cleanup function - Since we switched to MockMonteCarlo for testing. Since it does not inherit MonteCarlo.__init__(), no files that need cleanup are produced. - Removed the `_post_test_file_cleanup` function to streamline test cases. - Updated tests to directly handle file cleanup for test_ellipses_background_save. --- .../test_monte_carlo_plots_background.py | 249 ++++++++---------- 1 file changed, 104 insertions(+), 145 deletions(-) diff --git a/tests/unit/simulation/test_monte_carlo_plots_background.py b/tests/unit/simulation/test_monte_carlo_plots_background.py index 7a2ab4429..1ad289203 100644 --- a/tests/unit/simulation/test_monte_carlo_plots_background.py +++ b/tests/unit/simulation/test_monte_carlo_plots_background.py @@ -60,19 +60,6 @@ def __init__(self, latitude=32.990254, longitude=-106.974998): self.longitude = longitude -def _post_test_file_cleanup(): - """Clean monte carlo files after test session if they exist.""" - files_to_cleanup = [ - "monte_carlo_test.png", - "monte_carlo_test.errors.txt", - "monte_carlo_test.inputs.txt", - "monte_carlo_test.outputs.txt", - ] - for filepath in files_to_cleanup: - if os.path.exists(filepath): - os.remove(filepath) - - @patch("matplotlib.pyplot.show") def test_ellipses_background_none(mock_show): """Test default behavior when background=None (no background map displayed). @@ -82,13 +69,10 @@ def test_ellipses_background_none(mock_show): mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. """ - try: - mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) - # Test that background=None does not raise an error - result = mock_monte_carlo.plots.ellipses(background=None) - assert result is None - finally: - _post_test_file_cleanup() + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) + # Test that background=None does not raise an error + result = mock_monte_carlo.plots.ellipses(background=None) + assert result is None @patch("matplotlib.pyplot.show") @@ -100,13 +84,10 @@ def test_ellipses_background_satellite(mock_show): mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. """ - try: - mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) - # Test that background="satellite" does not raise an error - result = mock_monte_carlo.plots.ellipses(background="satellite") - assert result is None - finally: - _post_test_file_cleanup() + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) + # Test that background="satellite" does not raise an error + result = mock_monte_carlo.plots.ellipses(background="satellite") + assert result is None @patch("matplotlib.pyplot.show") @@ -118,13 +99,10 @@ def test_ellipses_background_street(mock_show): mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. """ - try: - mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) - # Test that background="street" does not raise an error - result = mock_monte_carlo.plots.ellipses(background="street") - assert result is None - finally: - _post_test_file_cleanup() + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) + # Test that background="street" does not raise an error + result = mock_monte_carlo.plots.ellipses(background="street") + assert result is None @patch("matplotlib.pyplot.show") @@ -136,13 +114,10 @@ def test_ellipses_background_terrain(mock_show): mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. """ - try: - mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) - # Test that background="terrain" does not raise an error - result = mock_monte_carlo.plots.ellipses(background="terrain") - assert result is None - finally: - _post_test_file_cleanup() + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) + # Test that background="terrain" does not raise an error + result = mock_monte_carlo.plots.ellipses(background="terrain") + assert result is None @patch("matplotlib.pyplot.show") @@ -154,13 +129,10 @@ def test_ellipses_background_custom_provider(mock_show): mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. """ - try: - mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) - # Test that custom provider does not raise an error - result = mock_monte_carlo.plots.ellipses(background="CartoDB.Positron") - assert result is None - finally: - _post_test_file_cleanup() + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) + # Test that custom provider does not raise an error + result = mock_monte_carlo.plots.ellipses(background="CartoDB.Positron") + assert result is None @patch("matplotlib.pyplot.show") @@ -174,26 +146,23 @@ def test_ellipses_image_takes_precedence_over_background(mock_show, tmp_path): tmp_path : pytest fixture providing a temporary directory. """ - try: - mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) - dummy_image_path = tmp_path / "dummy_image.png" - dummy_image_path.write_bytes(b"dummy") - - # Test that when both image and background are provided, image takes precedence - # This should not attempt to download background map - import numpy as np - - mock_image = np.zeros((100, 100, 3), dtype=np.uint8) # RGB image - - with patch("imageio.imread") as mock_imread: - mock_imread.return_value = mock_image - result = mock_monte_carlo.plots.ellipses( - image=str(dummy_image_path), background="satellite" - ) - assert result is None - mock_imread.assert_called_once() - finally: - _post_test_file_cleanup() + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) + dummy_image_path = tmp_path / "dummy_image.png" + dummy_image_path.write_bytes(b"dummy") + + # Test that when both image and background are provided, image takes precedence + # This should not attempt to download background map + import numpy as np + + mock_image = np.zeros((100, 100, 3), dtype=np.uint8) # RGB image + + with patch("imageio.imread") as mock_imread: + mock_imread.return_value = mock_image + result = mock_monte_carlo.plots.ellipses( + image=str(dummy_image_path), background="satellite" + ) + assert result is None + mock_imread.assert_called_once() @patch("matplotlib.pyplot.show") @@ -245,25 +214,22 @@ def test_ellipses_background_contextily_not_installed(mock_show): mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. """ - try: - mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) - from rocketpy.tools import import_optional_dependency as original_import - - # Create a mock function that only raises exception when importing contextily - def mock_import_optional_dependency(name): - if name == "contextily": - raise ImportError("No module named 'contextily'") - return original_import(name) - - with patch( - "rocketpy.plots.monte_carlo_plots.import_optional_dependency", - side_effect=mock_import_optional_dependency, - ): - with pytest.raises(ImportError) as exc_info: - mock_monte_carlo.plots.ellipses(background="satellite") - assert "contextily" in str(exc_info.value).lower() - finally: - _post_test_file_cleanup() + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) + from rocketpy.tools import import_optional_dependency as original_import + + # Create a mock function that only raises exception when importing contextily + def mock_import_optional_dependency(name): + if name == "contextily": + raise ImportError("No module named 'contextily'") + return original_import(name) + + with patch( + "rocketpy.plots.monte_carlo_plots.import_optional_dependency", + side_effect=mock_import_optional_dependency, + ): + with pytest.raises(ImportError) as exc_info: + mock_monte_carlo.plots.ellipses(background="satellite") + assert "contextily" in str(exc_info.value).lower() @patch("matplotlib.pyplot.show") @@ -275,17 +241,14 @@ def test_ellipses_background_with_custom_xlim_ylim(mock_show): mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. """ - try: - mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) - # Test using custom xlim and ylim - result = mock_monte_carlo.plots.ellipses( - background="satellite", - xlim=(-5000, 5000), - ylim=(-5000, 5000), - ) - assert result is None - finally: - _post_test_file_cleanup() + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) + # Test using custom xlim and ylim + result = mock_monte_carlo.plots.ellipses( + background="satellite", + xlim=(-5000, 5000), + ylim=(-5000, 5000), + ) + assert result is None @patch("matplotlib.pyplot.show") @@ -297,6 +260,7 @@ def test_ellipses_background_save(mock_show): mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. """ + filename = "monte_carlo_test.png" try: mock_monte_carlo = MockMonteCarlo( environment=SimpleEnvironment(), filename="monte_carlo_test" @@ -305,9 +269,10 @@ def test_ellipses_background_save(mock_show): result = mock_monte_carlo.plots.ellipses(background="satellite", save=True) assert result is None # Verify file was created - assert os.path.exists("monte_carlo_test.png") + assert os.path.exists(filename) finally: - _post_test_file_cleanup() + if os.path.exists(filename): + os.remove(filename) @patch("matplotlib.pyplot.show") @@ -319,19 +284,16 @@ def test_ellipses_background_invalid_provider(mock_show): mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. """ - try: - mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) - with pytest.raises(ValueError) as exc_info: - mock_monte_carlo.plots.ellipses(background="Invalid.Provider.Name") - assert "Invalid map provider" in str(exc_info.value) - assert "Invalid.Provider.Name" in str(exc_info.value) - assert ( - "satellite" in str(exc_info.value) - or "street" in str(exc_info.value) - or "terrain" in str(exc_info.value) - ) - finally: - _post_test_file_cleanup() + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) + with pytest.raises(ValueError) as exc_info: + mock_monte_carlo.plots.ellipses(background="Invalid.Provider.Name") + assert "Invalid map provider" in str(exc_info.value) + assert "Invalid.Provider.Name" in str(exc_info.value) + assert ( + "satellite" in str(exc_info.value) + or "street" in str(exc_info.value) + or "terrain" in str(exc_info.value) + ) @patch("matplotlib.pyplot.show") @@ -343,35 +305,32 @@ def test_ellipses_background_bounds2img_failure(mock_show): mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. """ - try: - mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) - from rocketpy.tools import import_optional_dependency as original_import - import contextily - - # Create a mock contextily module with a failing bounds2img - mock_contextily = MagicMock() - mock_contextily.providers = contextily.providers - - def mock_bounds2img(*args, **kwargs): - raise ConnectionError("Network error: Unable to fetch tiles") - - mock_contextily.bounds2img = mock_bounds2img - - def mock_import_optional_dependency(name): - if name == "contextily": - return mock_contextily - return original_import(name) - - with patch( - "rocketpy.plots.monte_carlo_plots.import_optional_dependency", - side_effect=mock_import_optional_dependency, - ): - with pytest.raises(RuntimeError) as exc_info: - mock_monte_carlo.plots.ellipses(background="satellite") - assert "Failed to fetch background map tiles" in str(exc_info.value) - assert "satellite" in str(exc_info.value) - assert "Network connectivity" in str( - exc_info.value - ) or "Service unavailability" in str(exc_info.value) - finally: - _post_test_file_cleanup() + mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) + from rocketpy.tools import import_optional_dependency as original_import + import contextily + + # Create a mock contextily module with a failing bounds2img + mock_contextily = MagicMock() + mock_contextily.providers = contextily.providers + + def mock_bounds2img(*args, **kwargs): + raise ConnectionError("Network error: Unable to fetch tiles") + + mock_contextily.bounds2img = mock_bounds2img + + def mock_import_optional_dependency(name): + if name == "contextily": + return mock_contextily + return original_import(name) + + with patch( + "rocketpy.plots.monte_carlo_plots.import_optional_dependency", + side_effect=mock_import_optional_dependency, + ): + with pytest.raises(RuntimeError) as exc_info: + mock_monte_carlo.plots.ellipses(background="satellite") + assert "Failed to fetch background map tiles" in str(exc_info.value) + assert "satellite" in str(exc_info.value) + assert "Network connectivity" in str( + exc_info.value + ) or "Service unavailability" in str(exc_info.value) From 940c8802f992631bfc6c1106a38e0c5f2400c5b7 Mon Sep 17 00:00:00 2001 From: x25tang Date: Fri, 5 Dec 2025 06:49:08 +0800 Subject: [PATCH 22/32] TST: Enhance Monte Carlo plot tests with file cleanup - Added file cleanup functionality to the Monte Carlo plot tests to ensure generated files are removed after execution. --- .../test_monte_carlo_plots_background.py | 84 ++++++++++--------- 1 file changed, 46 insertions(+), 38 deletions(-) diff --git a/tests/integration/simulation/test_monte_carlo_plots_background.py b/tests/integration/simulation/test_monte_carlo_plots_background.py index 3c54305a8..07561d3d8 100644 --- a/tests/integration/simulation/test_monte_carlo_plots_background.py +++ b/tests/integration/simulation/test_monte_carlo_plots_background.py @@ -5,6 +5,7 @@ """ import os +import shutil import numpy as np import matplotlib.pyplot as plt @@ -92,43 +93,50 @@ def test_all_background_options(example_kennedy_env): output_dir = "kennedy_background_tests" os.makedirs(output_dir, exist_ok=True) - monte_carlo = MockMonteCarlo(env=example_kennedy_env) - - background_options = [ - (None, "no_background"), - ("satellite", "satellite"), - ("street", "street"), - ("terrain", "terrain"), - ("CartoDB.Positron", "cartodb_positron"), - ] - - print(f"Testing {len(background_options)} background options...") - print(f"Output directory: {output_dir}/") - - for background, name in background_options: - print(f" Testing {name}...", end=" ") - - # Temporarily change filename to save with desired name - original_filename = monte_carlo.filename - monte_carlo.filename = os.path.join(output_dir, f"kennedy_{name}") - - try: - monte_carlo.plots.ellipses( - background=background, - xlim=(-5000, 5000), - ylim=(-5000, 5000), - save=True, - ) - - # Check if file was created - expected_file = f"{monte_carlo.filename}.png" - if not os.path.exists(expected_file): - raise FileNotFoundError( - f"Expected file {expected_file} was not created after plotting." + try: + monte_carlo = MockMonteCarlo(env=example_kennedy_env) + + background_options = [ + (None, "no_background"), + ("satellite", "satellite"), + ("street", "street"), + ("terrain", "terrain"), + ("CartoDB.Positron", "cartodb_positron"), + ] + + print(f"Testing {len(background_options)} background options...") + print(f"Output directory: {output_dir}/") + + for background, name in background_options: + print(f" Testing {name}...", end=" ") + + # Temporarily change filename to save with desired name + original_filename = monte_carlo.filename + monte_carlo.filename = os.path.join(output_dir, f"kennedy_{name}") + + try: + monte_carlo.plots.ellipses( + background=background, + xlim=(-5000, 5000), + ylim=(-5000, 5000), + save=True, ) - print(f"✓ Saved to {expected_file}") - finally: - # Restore original filename - monte_carlo.filename = original_filename - print(f"\nAll tests completed! Check the '{output_dir}/' directory for results.") + # Check if file was created + expected_file = f"{monte_carlo.filename}.png" + if not os.path.exists(expected_file): + raise FileNotFoundError( + f"Expected file {expected_file} was not created after plotting." + ) + print(f"✓ Saved to {expected_file}") + finally: + # Restore original filename + monte_carlo.filename = original_filename + + print( + f"\nAll tests completed! Check the '{output_dir}/' directory for results." + ) + finally: + # Clean up generated files and directory + if os.path.exists(output_dir): + shutil.rmtree(output_dir) From 7178139d078472937676a1973a1fc8ce48823687 Mon Sep 17 00:00:00 2001 From: x25tang Date: Fri, 5 Dec 2025 06:50:49 +0800 Subject: [PATCH 23/32] DOC: Update docstring for background map provider resolution - Enhanced the docstring for the background map provider function to include details on potential ValueError exceptions. --- rocketpy/plots/monte_carlo_plots.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index 8422a6cb2..6e911b8d5 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -79,6 +79,13 @@ def _resolve_map_provider(self, background, contextily): ------- object The resolved contextily provider object. + + Raises + ------ + ValueError + If the map provider string cannot be resolved in contextily.providers. + This may occur if the provider name is invalid. Check the provider name + or use one of the built-in options: 'satellite', 'street', or 'terrain'. """ if background == "satellite": map_provider = "Esri.WorldImagery" From d84bbfad5d6886a0fa68dcdcdedd4ebdd90c5ba1 Mon Sep 17 00:00:00 2001 From: x25tang Date: Fri, 5 Dec 2025 08:21:47 +0800 Subject: [PATCH 24/32] ENH: Improve error handling in Monte Carlo background map fetching - Enhanced exception handling for various error scenarios when fetching background map tiles, including invalid coordinates, network issues, and image data errors. - Added detailed error messages to guide users on potential causes and solutions for encountered issues. --- rocketpy/plots/monte_carlo_plots.py | 42 +++++++++++++++++++++++------ 1 file changed, 34 insertions(+), 8 deletions(-) diff --git a/rocketpy/plots/monte_carlo_plots.py b/rocketpy/plots/monte_carlo_plots.py index 6e911b8d5..3c9123870 100644 --- a/rocketpy/plots/monte_carlo_plots.py +++ b/rocketpy/plots/monte_carlo_plots.py @@ -1,5 +1,7 @@ from pathlib import Path +import urllib +from PIL import UnidentifiedImageError import matplotlib.pyplot as plt import numpy as np from matplotlib.transforms import offset_copy @@ -161,17 +163,41 @@ def _get_background_map(self, background, xlim, ylim): bg, mercator_extent = contextily.bounds2img( west, south, east, north, source=source_provider, ll=True ) - except Exception as e: + except ValueError as e: + raise ValueError( + f"Input coordinates or zoom level are invalid.\n" + f" - Provided bounds: W={west:.6f}, S={south:.6f}, E={east:.6f}, N={north:.6f}\n" + f" - Provider: {source_provider}\n" + f" - Tip: Ensure West < East and South < North.\n" + f" - Tip: Ensure coordinates are within Web Mercator limits (approx +/-85 lat).\n" + f"Original error: {str(e)}" + ) from e + + except (urllib.error.URLError, urllib.error.HTTPError, TimeoutError) as e: + raise ConnectionError( + f"Network error while fetching tiles from provider '{background}'.\n" + f" - Provider: {source_provider}\n" + f" - Status: Check your internet connection.\n" + f" - The tile server might be down or blocking requests (rate limited).\n" + f" - Original error: {str(e)}" + ) from e + + except UnidentifiedImageError as e: raise RuntimeError( - f"Failed to fetch background map tiles from provider '{background}'. " - f"This could be due to:\n" - f" - Network connectivity issues\n" - f" - Invalid coordinate bounds (west={west:.6f}, south={south:.6f}, " - f"east={east:.6f}, north={north:.6f})\n" - f" - Service unavailability\n" - f" - Invalid map provider configuration\n\n" + f"The provider '{background}' returned invalid image data.\n" + f" - Provider: {source_provider}\n" + f" - Cause: This often happens when the API requires a key/token that is missing or invalid.\n" + f" - Result: The server likely returned an HTML error page instead of a PNG/JPG." + f" - Original error: {str(e)}" ) from e + except Exception as e: + raise RuntimeError( + f"An unexpected error occurred while generating the map.\n" + f" - Bounds: {west:.6f}, {south:.6f}, {east:.6f}, {north:.6f}\n" + f" - Provider: {source_provider}\n" + f" - Error Detail: {str(e)}" + ) from e local_extent = convert_mercator_extent_to_local( mercator_extent, origin_lat, origin_lon, earth_radius ) From 551dafcedb2dd7187e394c6cf8e52fed1df26acf Mon Sep 17 00:00:00 2001 From: x25tang Date: Fri, 5 Dec 2025 08:22:14 +0800 Subject: [PATCH 25/32] TST: Parameterize tests for bounds2img failure scenarios - Introduced parameterized tests to cover various exception types raised during background map fetching, including ValueError, ConnectionError, and RuntimeError. - Enhanced assertions to verify specific error messages, improving clarity on the nature of failures encountered. - Updated the test for bounds2img to handle different network and image data errors, ensuring comprehensive coverage of edge cases. --- .../test_monte_carlo_plots_background.py | 107 ++++++++++++++++-- 1 file changed, 97 insertions(+), 10 deletions(-) diff --git a/tests/unit/simulation/test_monte_carlo_plots_background.py b/tests/unit/simulation/test_monte_carlo_plots_background.py index 1ad289203..2f643c691 100644 --- a/tests/unit/simulation/test_monte_carlo_plots_background.py +++ b/tests/unit/simulation/test_monte_carlo_plots_background.py @@ -1,9 +1,11 @@ # pylint: disable=unused-argument,assignment-from-no-return import os +import urllib.error # pylint: disable=unused-import import pytest from unittest.mock import MagicMock, patch import matplotlib.pyplot as plt +from PIL import UnidentifiedImageError # pylint: disable=unused-import from rocketpy.plots.monte_carlo_plots import _MonteCarloPlots from rocketpy.simulation import MonteCarlo @@ -297,24 +299,106 @@ def test_ellipses_background_invalid_provider(mock_show): @patch("matplotlib.pyplot.show") -def test_ellipses_background_bounds2img_failure(mock_show): - """Test that RuntimeError is raised when bounds2img fails to fetch map tiles. +@pytest.mark.parametrize( + "exception_factory,expected_exception,expected_messages", + [ + # ValueError case: invalid coordinates or zoom level + ( + lambda: ValueError("Invalid coordinates"), + ValueError, + [ + "Input coordinates or zoom level are invalid", + "Provided bounds", + "Tip: Ensure West < East and South < North", + ], + ), + # ConnectionError case: network errors (URLError) + ( + lambda: urllib.error.URLError("Network error: Unable to fetch tiles"), + ConnectionError, + [ + "Network error while fetching tiles from provider", + "Check your internet connection", + "The tile server might be down or blocking requests", + ], + ), + # ConnectionError case: network errors (HTTPError) + ( + lambda: urllib.error.HTTPError( + "http://example.com", 500, "Internal Server Error", None, None + ), + ConnectionError, + [ + "Network error while fetching tiles from provider", + "Check your internet connection", + "The tile server might be down or blocking requests", + ], + ), + # ConnectionError case: network errors (TimeoutError) + ( + lambda: TimeoutError("Request timed out"), + ConnectionError, + [ + "Network error while fetching tiles from provider", + "Check your internet connection", + "The tile server might be down or blocking requests", + ], + ), + # RuntimeError case: UnidentifiedImageError (invalid image data) + ( + lambda: UnidentifiedImageError("Cannot identify image file"), + RuntimeError, + [ + "returned invalid image data", + "API requires a key/token that is missing or invalid", + "server likely returned an HTML error page instead of a PNG/JPG", + ], + ), + # RuntimeError case: other unexpected exceptions + ( + lambda: Exception("Unexpected error occurred"), + RuntimeError, + [ + "An unexpected error occurred while generating the map", + "Bounds", + "Provider", + "Error Detail", + ], + ), + ], +) +def test_ellipses_background_bounds2img_failure( + mock_show, exception_factory, expected_exception, expected_messages +): + """Test that appropriate exceptions are raised when bounds2img fails. + + This is a parameterized test that covers all exception types handled in + the _fetch_background_map method: + - ValueError: invalid coordinates or zoom level + - ConnectionError: network errors (URLError, HTTPError, TimeoutError) + - RuntimeError: UnidentifiedImageError (invalid image data) + - RuntimeError: other unexpected exceptions Parameters ---------- mock_show : Mocks the matplotlib.pyplot.show() function to avoid showing the plots. + exception_factory : callable + A function that returns the exception to raise in mock_bounds2img. + expected_exception : type + The expected exception type to be raised. + expected_messages : list[str] + List of expected message substrings in the raised exception. """ mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) from rocketpy.tools import import_optional_dependency as original_import import contextily - # Create a mock contextily module with a failing bounds2img mock_contextily = MagicMock() mock_contextily.providers = contextily.providers def mock_bounds2img(*args, **kwargs): - raise ConnectionError("Network error: Unable to fetch tiles") + raise exception_factory() mock_contextily.bounds2img = mock_bounds2img @@ -327,10 +411,13 @@ def mock_import_optional_dependency(name): "rocketpy.plots.monte_carlo_plots.import_optional_dependency", side_effect=mock_import_optional_dependency, ): - with pytest.raises(RuntimeError) as exc_info: + with pytest.raises(expected_exception) as exc_info: mock_monte_carlo.plots.ellipses(background="satellite") - assert "Failed to fetch background map tiles" in str(exc_info.value) - assert "satellite" in str(exc_info.value) - assert "Network connectivity" in str( - exc_info.value - ) or "Service unavailability" in str(exc_info.value) + + error_message = str(exc_info.value) + for expected_msg in expected_messages: + assert expected_msg in error_message, ( + f"Expected message '{expected_msg}' not found in error: {error_message}" + ) + + assert "Esri.WorldImagery" in error_message From 72c4a6ebe1e5dbef4f5fd8526316ba89333cff96 Mon Sep 17 00:00:00 2001 From: x25tang Date: Fri, 5 Dec 2025 08:22:28 +0800 Subject: [PATCH 26/32] TST: Parameterize background map option tests in Monte Carlo plots - Introduced parameterization for the `test_all_background_options` function to streamline testing of various background map options. - Enhanced the test structure by removing hardcoded background options and utilizing pytest's parameterization feature for improved clarity and maintainability. - Updated docstring to reflect new parameters and their usage in the test. --- .../test_monte_carlo_plots_background.py | 75 +++++++++---------- 1 file changed, 34 insertions(+), 41 deletions(-) diff --git a/tests/integration/simulation/test_monte_carlo_plots_background.py b/tests/integration/simulation/test_monte_carlo_plots_background.py index 07561d3d8..97db07c97 100644 --- a/tests/integration/simulation/test_monte_carlo_plots_background.py +++ b/tests/integration/simulation/test_monte_carlo_plots_background.py @@ -8,6 +8,7 @@ import shutil import numpy as np import matplotlib.pyplot as plt +import pytest from rocketpy.simulation import MonteCarlo from rocketpy.plots.monte_carlo_plots import _MonteCarloPlots @@ -75,7 +76,17 @@ def __init__(self, env): } -def test_all_background_options(example_kennedy_env): +@pytest.mark.parametrize( + "background,name", + [ + (None, "no_background"), + ("satellite", "satellite"), + ("street", "street"), + ("terrain", "terrain"), + ("CartoDB.Positron", "cartodb_positron"), + ], +) +def test_all_background_options(example_kennedy_env, background, name): """Test all background map options and save images. This function tests: @@ -89,6 +100,10 @@ def test_all_background_options(example_kennedy_env): ---------- example_kennedy_env : rocketpy.Environment Environment fixture for Kennedy Space Center. + background : str or None + Background map option to test. + name : str + Name identifier for the background option (used in filename). """ output_dir = "kennedy_background_tests" os.makedirs(output_dir, exist_ok=True) @@ -96,47 +111,25 @@ def test_all_background_options(example_kennedy_env): try: monte_carlo = MockMonteCarlo(env=example_kennedy_env) - background_options = [ - (None, "no_background"), - ("satellite", "satellite"), - ("street", "street"), - ("terrain", "terrain"), - ("CartoDB.Positron", "cartodb_positron"), - ] - - print(f"Testing {len(background_options)} background options...") - print(f"Output directory: {output_dir}/") - - for background, name in background_options: - print(f" Testing {name}...", end=" ") - - # Temporarily change filename to save with desired name - original_filename = monte_carlo.filename - monte_carlo.filename = os.path.join(output_dir, f"kennedy_{name}") - - try: - monte_carlo.plots.ellipses( - background=background, - xlim=(-5000, 5000), - ylim=(-5000, 5000), - save=True, + # Temporarily change filename to save with desired name + original_filename = monte_carlo.filename + monte_carlo.filename = os.path.join(output_dir, f"kennedy_{name}") + + try: + monte_carlo.plots.ellipses( + background=background, + xlim=(-5000, 5000), + ylim=(-5000, 5000), + save=True, + ) + + expected_file = f"{monte_carlo.filename}.png" + if not os.path.exists(expected_file): + raise FileNotFoundError( + f"Expected file {expected_file} was not created after plotting." ) - - # Check if file was created - expected_file = f"{monte_carlo.filename}.png" - if not os.path.exists(expected_file): - raise FileNotFoundError( - f"Expected file {expected_file} was not created after plotting." - ) - print(f"✓ Saved to {expected_file}") - finally: - # Restore original filename - monte_carlo.filename = original_filename - - print( - f"\nAll tests completed! Check the '{output_dir}/' directory for results." - ) + finally: + monte_carlo.filename = original_filename finally: - # Clean up generated files and directory if os.path.exists(output_dir): shutil.rmtree(output_dir) From 2e53b53e4a74e053026e7958008a3fb123458026 Mon Sep 17 00:00:00 2001 From: x25tang Date: Fri, 5 Dec 2025 08:31:16 +0800 Subject: [PATCH 27/32] MNT: Formatting monte_carlo_class_usage.ipynb with ruff --- .../monte_carlo_analysis/monte_carlo_class_usage.ipynb | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb b/docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb index 78b84cb50..78d770153 100644 --- a/docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb +++ b/docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb @@ -986,10 +986,8 @@ "source": [ "# Example: Plot ellipses with satellite background map\n", "test_dispersion.plots.ellipses(\n", - " background=\"satellite\",\n", - " xlim=(-200, 3500),\n", - " ylim=(-200, 3500)\n", - ")\n" + " background=\"satellite\", xlim=(-200, 3500), ylim=(-200, 3500)\n", + ")" ] }, { @@ -1026,9 +1024,7 @@ "source": [ "# Example: Plot ellipses with street map background\n", "test_dispersion.plots.ellipses(\n", - " background=\"street\",\n", - " xlim=(-200, 3500),\n", - " ylim=(-200, 3500)\n", + " background=\"street\", xlim=(-200, 3500), ylim=(-200, 3500)\n", ")" ] }, From c9748c63e916720b1048c702ded3385d5bb46e0d Mon Sep 17 00:00:00 2001 From: x25tang Date: Fri, 5 Dec 2025 11:45:19 +0800 Subject: [PATCH 28/32] TST: Refactor imports in Monte Carlo plot tests for consistency - Moved import statements for numpy and rocketpy.tools to the top of the test functions to adhere to best practices and improve readability. - Added pylint disable comments for imports outside of the top-level to maintain code quality standards. --- .../simulation/test_monte_carlo_plots_background.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/tests/unit/simulation/test_monte_carlo_plots_background.py b/tests/unit/simulation/test_monte_carlo_plots_background.py index 2f643c691..ea3532c67 100644 --- a/tests/unit/simulation/test_monte_carlo_plots_background.py +++ b/tests/unit/simulation/test_monte_carlo_plots_background.py @@ -1,9 +1,10 @@ # pylint: disable=unused-argument,assignment-from-no-return import os import urllib.error # pylint: disable=unused-import -import pytest from unittest.mock import MagicMock, patch +import pytest + import matplotlib.pyplot as plt from PIL import UnidentifiedImageError # pylint: disable=unused-import @@ -154,7 +155,7 @@ def test_ellipses_image_takes_precedence_over_background(mock_show, tmp_path): # Test that when both image and background are provided, image takes precedence # This should not attempt to download background map - import numpy as np + import numpy as np # pylint: disable=import-outside-toplevel mock_image = np.zeros((100, 100, 3), dtype=np.uint8) # RGB image @@ -217,7 +218,7 @@ def test_ellipses_background_contextily_not_installed(mock_show): Mocks the matplotlib.pyplot.show() function to avoid showing the plots. """ mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) - from rocketpy.tools import import_optional_dependency as original_import + from rocketpy.tools import import_optional_dependency as original_import # pylint: disable=import-outside-toplevel # Create a mock function that only raises exception when importing contextily def mock_import_optional_dependency(name): @@ -391,8 +392,8 @@ def test_ellipses_background_bounds2img_failure( List of expected message substrings in the raised exception. """ mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) - from rocketpy.tools import import_optional_dependency as original_import - import contextily + from rocketpy.tools import import_optional_dependency as original_import # pylint: disable=import-outside-toplevel + import contextily # pylint: disable=import-outside-toplevel mock_contextily = MagicMock() mock_contextily.providers = contextily.providers From 4b65f03a8bbee8948e94eceaaadfecc9d5bc68e1 Mon Sep 17 00:00:00 2001 From: x25tang Date: Sat, 6 Dec 2025 04:18:25 +0800 Subject: [PATCH 29/32] TST: Skip tests requiring contextily in Monte Carlo plot tests - Added pytest.importorskip for contextily in both integration and unit test files to ensure tests are only run if the required library is installed. --- .../simulation/test_monte_carlo_plots_background.py | 4 ++++ tests/unit/simulation/test_monte_carlo_plots_background.py | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/tests/integration/simulation/test_monte_carlo_plots_background.py b/tests/integration/simulation/test_monte_carlo_plots_background.py index 97db07c97..cb4183995 100644 --- a/tests/integration/simulation/test_monte_carlo_plots_background.py +++ b/tests/integration/simulation/test_monte_carlo_plots_background.py @@ -15,6 +15,10 @@ plt.rcParams.update({"figure.max_open_warning": 0}) +pytest.importorskip( + "contextily", reason="This test requires contextily to be installed" +) + class MockMonteCarlo(MonteCarlo): """Create a mock class to test the method without running a real simulation. diff --git a/tests/unit/simulation/test_monte_carlo_plots_background.py b/tests/unit/simulation/test_monte_carlo_plots_background.py index ea3532c67..cc0e7d561 100644 --- a/tests/unit/simulation/test_monte_carlo_plots_background.py +++ b/tests/unit/simulation/test_monte_carlo_plots_background.py @@ -13,6 +13,10 @@ plt.rcParams.update({"figure.max_open_warning": 0}) +pytest.importorskip( + "contextily", reason="This test requires contextily to be installed" +) + class MockMonteCarlo(MonteCarlo): """Create a mock class to test the method without running a real simulation. From bbb603f289264eff8f7679104b40879800c981a8 Mon Sep 17 00:00:00 2001 From: x25tang Date: Sat, 6 Dec 2025 04:23:08 +0800 Subject: [PATCH 30/32] TST: Update contextily import in Monte Carlo plot tests - Replaced direct import of contextily with pytest.importorskip to ensure tests are skipped if the library is not available, enhancing test robustness. --- tests/unit/simulation/test_monte_carlo_plots_background.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/unit/simulation/test_monte_carlo_plots_background.py b/tests/unit/simulation/test_monte_carlo_plots_background.py index cc0e7d561..50957a140 100644 --- a/tests/unit/simulation/test_monte_carlo_plots_background.py +++ b/tests/unit/simulation/test_monte_carlo_plots_background.py @@ -397,7 +397,8 @@ def test_ellipses_background_bounds2img_failure( """ mock_monte_carlo = MockMonteCarlo(environment=SimpleEnvironment()) from rocketpy.tools import import_optional_dependency as original_import # pylint: disable=import-outside-toplevel - import contextily # pylint: disable=import-outside-toplevel + + contextily = pytest.importorskip("contextily") mock_contextily = MagicMock() mock_contextily.providers = contextily.providers From c6bae7f85c3ec0e8e8d2bb04693c3d9013a85d58 Mon Sep 17 00:00:00 2001 From: x25tang Date: Sun, 7 Dec 2025 10:43:51 +0800 Subject: [PATCH 31/32] Update contextily dependency in pyproject.toml and requirements-optional.txt - Modified contextily dependency in pyproject.toml to conditionally require it for Python versions below 3.14. --- pyproject.toml | 2 +- requirements-optional.txt | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 1479ecd11..48aeb8bc6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -65,7 +65,7 @@ monte-carlo = [ "multiprocess>=0.70", "statsmodels", "prettytable", - "contextily>=1.0.0", + "contextily>=1.0.0; python_version < '3.14'", ] all = ["rocketpy[env-analysis]", "rocketpy[monte-carlo]"] diff --git a/requirements-optional.txt b/requirements-optional.txt index 7f7f91d17..58ed1030b 100644 --- a/requirements-optional.txt +++ b/requirements-optional.txt @@ -6,5 +6,4 @@ timezonefinder imageio multiprocess>=0.70 statsmodels -prettytable -contextily>=1.0.0 \ No newline at end of file +prettytable \ No newline at end of file From e450d253600bd4fb2d6547d3a30222e10e464a8e Mon Sep 17 00:00:00 2001 From: x25tang Date: Sun, 7 Dec 2025 11:11:51 +0800 Subject: [PATCH 32/32] DOC: Update monte_carlo_class_usage.ipynb to note about contextily issue on python 3.14 --- .../monte_carlo_analysis/monte_carlo_class_usage.ipynb | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb b/docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb index 78d770153..2fb46fa86 100644 --- a/docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb +++ b/docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb @@ -949,7 +949,13 @@ "- `\"terrain\"` - uses Esri.WorldTopoMap for terrain maps\n", "- Any contextily provider name (e.g., `\"CartoDB.Positron\"`)\n", "\n", - "Note that if both `image` and `background` parameters are provided, the `image` parameter takes precedence. The background map is automatically downloaded based on the environment's latitude and longitude coordinates." + "Note that if both `image` and `background` parameters are provided, the `image` parameter takes precedence. The background map is automatically downloaded based on the environment's latitude and longitude coordinates.\n", + "\n", + "> **Note on Python 3.14 Support:**\n", + "> Currently, the `background` feature is automatically enabled only for **Python 3.13 and lower**.\n", + "> This is due to the lack of pre-built binary wheels for `rasterio` (a core dependency) on Python 3.14 (see [rasterio issue #3419](https://github.com/rasterio/rasterio/issues/3419)).\n", + ">\n", + "> **Advanced Users:** If you are using Python 3.14 and are comfortable compiling C-extensions from source (e.g., setting up a GDAL environment), you can manually install `contextily`. Once installed, this feature will become available." ] }, {