From 308ffbdffef1559d33f11143b69f3ccb8bdc04e3 Mon Sep 17 00:00:00 2001 From: Shiv Shankar Singh Date: Tue, 15 Aug 2023 01:39:44 +0530 Subject: [PATCH] update the documentation --- README.md | 135 - LICENSE => climate_library/LICENSE.txt | 2 +- climate_library/README.md | 294 + climate_library/climate_library/__init__.py | 0 .../climate_library/climate_index.py | 174 + climate_library/setup.py | 28 + xclim/pre_data.ipynb | 6614 ----------------- xclim/tx10p_index.nc | Bin 5466715 -> 0 bytes 8 files changed, 497 insertions(+), 6750 deletions(-) delete mode 100644 README.md rename LICENSE => climate_library/LICENSE.txt (99%) create mode 100644 climate_library/README.md create mode 100644 climate_library/climate_library/__init__.py create mode 100644 climate_library/climate_library/climate_index.py create mode 100644 climate_library/setup.py delete mode 100644 xclim/pre_data.ipynb delete mode 100644 xclim/tx10p_index.nc diff --git a/README.md b/README.md deleted file mode 100644 index 8bec030..0000000 --- a/README.md +++ /dev/null @@ -1,135 +0,0 @@ - -# ClimateIndex calculator - -The `ClimateIndex` class provides a systematic and convenient interface for preprocessing climate data and calculating various climate indices. It can handle different climate variables and allows for the selection, resampling, and filling of missing values according to user-defined parameters. It is currently designed to calculate indices such as `tx10p`, `tx90p`, `tn10p`, `tn90p`, `warm spell duration`, `cold spell duration`, and `frost days`. - -# Class Definition - -## Initialization -To initialize the ClimateIndex class, you must provide the path to the NetCDF data file containing the climate data you wish to process. - -``` {.python language="Python"} -climate_index = ClimateIndex(datafile='/path/to/your/datafile.nc') -``` - -- `datafile` (str): Path to the NetCDF file containing the climate - data. - -## Preprocessing Method - -``` {.python language="Python"} -climate_index.pre_process(time_range=None, fill_missing=None, resample_freq=None, months=None, season=None, resample_method='mean') -``` - -- `time_range` (tuple, optional): This parameter allows you to specify a start and end time for the data you want to analyze. By providing a tuple with two date strings, you can subset the dataset to include only the observations within that time frame. - - Example: `time_range=('1961-01-01', '1990-12-31')` will include only the data from January 1, 1961, to December 31, 1990. - - Use Case: This can be useful when analyzing climate patterns over specific periods or when comparing different decades. - -- `fill_missing` (int, float, or 'interpolate', optional): This parameter provides options to handle missing values (NaN) in the dataset. - - If a numerical value is provided, all missing values will be replaced with that number. - - If `interpolate` is specified, linear interpolation will be used to estimate missing values based on neighbouring observations. - - Example: `fill_missing=0` will replace all NaN values with 0. - - Use Case: Handling missing values is crucial in climate analysis to avoid bias and errors in subsequent calculations. - -- `resample_freq` (str, optional): This parameter defines the frequency at which the data should be resampled. It allows you to change the time-frequency of the dataset. - - Example: `resample_freq='MS'` will resample the data to monthly frequency, starting at the beginning of each month. - - Use Case: Resampling is useful when analysing data at a different temporal resolution, such as monthly or yearly. - -- `months` (list, optional): This parameter allows you to select specific months from the dataset. - - Example: `months=[1, 2, 3]` will include only the data from January, February, and March. - - Use Case: Useful for seasonal analysis or when studying climate behaviour during particular months. - -- `season` (str, optional): This parameter enables the selection of data for a specific meteorological season. - - Example: season='JJA' will include only the data from the summer months (June, July, August). - - Use Case: Helpful for analyzing seasonal patterns and variations in climate. - -- `resample_method` (str, optional, default='mean'): This parameter defines the method used for resampling when changing the time-frequency with `resample_freq`. - - Default is `mean`, meaning that the mean value of the observations within each resampling period will be used. - - Other methods, such as `sum`, `max`, etc., can be specified if needed. - - Use Case: This provides flexibility in how the data is aggregated when resampling, allowing for different types of analysis and interpretation. - -## Climate Indices Calculation Methods - -### tx10p (Temperature Exceeding 10th Percentile) - -``` {.python language="Python"} -tx10p_index = climate_index.calculate_tx10p() -``` -- Description: The tx10p index calculates the number of days when the maximum temperature exceeds the 10th percentile of a reference period. -- Calculation: It's computed by first calculating the 10th percentile of daily maximum temperature over a reference period (e.g., 1961-1990) and then counting how many days in the target period exceed this threshold. - - -### tx90p (Temperature Exceeding 90th Percentile) - -``` {.python language="Python"} -tx90p_index = climate_index.calculate_tx90p() -``` -- Description: The tx90p index calculates the number of days when the maximum temperature exceeds the 90th percentile of a reference period. -- Calculation: Similar to tx10p, but using the 90th percentile as the threshold. - -### tn10p (Temperature Below 10th Percentile) - -``` {.python language="Python"} -tn10p_index = climate_index.calculate_tn10p() -``` -- Description: The tn10p index calculates the number of days when the minimum temperature is below the 10th percentile of a reference period. -- Calculation: It's computed by first calculating the 10th percentile of daily minimum temperature over a reference period and then counting how many days in the target period fall below this threshold. - -### tn90p (Temperature Exceeding 90th Percentile) - -``` {.python language="Python"} -tn90p_index = climate_index.calculate_tn90p() -``` -- Description: The tn90p index calculates the number of days when the minimum temperature exceeds the 90th percentile of a reference period. -- Calculation: Similar to tn10p, but using the 90th percentile as the threshold. - -### Frost Days - -``` {.python language="Python"} -frost_days_index = climate_index.calculate_frost_days() -``` -- Description: The frost days index counts the number of days when the minimum temperature falls below 0°C (or another specified threshold). -- Calculation: The number of days in the target period when the daily minimum temperature falls below the freezing point. - - -### Warm Spell Duration Index - -``` {.python language="Python"} -warm_spell_index = climate_index.calculate_warm_spell() -``` -- Description: This index measures the duration of warm spells, defined as periods when the daily maximum temperature exceeds the 90th percentile for at least a specified number of consecutive days. -- Calculation: Length of consecutive periods when daily maximum temperature exceeds the 90th percentile of a reference period. - - ### Cold Spell Duration Index - -``` {.python language="Python"} -cold_spell_index = climate_index.calculate_cold_spell() -``` -- Description: This index measures the duration of cold spells, defined as periods when the daily minimum temperature is below the 10th percentile for at least a specified number of consecutive days. -- Calculation: Length of consecutive periods when daily minimum temperature falls below the 10th percentile of a reference period. - -These indices provide various ways to quantify temperature extremes and their occurrence, helping in understanding and analyzing climate patterns, trends, and variability. - -# Example Usage - -``` {.python language="Python"} -climate_index = ClimateIndex(datafile='/path/to/your/datafile.nc') -climate_index.pre_process() -tx10p_index = climate_index.calculate_tx10p() - -def plot_tx10p(data, title): - # Take the mean along latitude and longitude - data_mean = data.mean(dim=['latitude', 'longitude']) - - data_mean.plot(figsize=(10, 5)) - plt.title(title) - plt.xlabel('Time') - plt.ylabel('tx10p Index') - plt.grid(True) - plt.show() - -plot_tx10p(tx10p_index, "tx10p test") - -``` -This example demonstrates how to initialize the ClimateIndex class with a specified data file, preprocess the data, calculate the tx10p index, and then plot the resulting time series after taking the mean along latitude and longitude. - diff --git a/LICENSE b/climate_library/LICENSE.txt similarity index 99% rename from LICENSE rename to climate_library/LICENSE.txt index 8a82f79..fd3ae46 100644 --- a/LICENSE +++ b/climate_library/LICENSE.txt @@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. +SOFTWARE. \ No newline at end of file diff --git a/climate_library/README.md b/climate_library/README.md new file mode 100644 index 0000000..2db39bf --- /dev/null +++ b/climate_library/README.md @@ -0,0 +1,294 @@ + +# ClimateIndex Library + +# ClimateIndex Class + +The `ClimateIndex` class provides a systematic and convenient interface for preprocessing climate data and calculating a wide range of climate indices. It can handle different climate variables, including temperature and precipitation, and allows for the selection, resampling, and filling of missing values according to user-defined parameters. + +## Temperature-related Indices + +For temperature-related analyses, it can calculate indices such as: + +- **tx10p**: The percentage of days when daily maximum temperature is below the 10th percentile +- **tx90p**: The percentage of days when daily maximum temperature is above the 90th percentile +- **tn10p**: The percentage of days when daily minimum temperature is below the 10th percentile +- **tn90p**: The percentage of days when daily minimum temperature is above the 90th percentile +- **frost_days**: Number of frost days (when daily minimum temperature is below 0°C) +- **warm_spell_duration_index**: Warm spell duration index +- **cold_spell_duration_index**: Cold spell duration index + +## Precipitation-related Indices + +For precipitation-related analyses, it can calculate indices such as: + +- **percentile_p**: The sum of precipitation in wet days exceeding a given percentile during a time period +- **precip_days**: The number of days with precipitation exceeding a specified threshold +- **rxnday**: The highest n-day total precipitation amount for a given resampling frequency + +## Testing + +The class also includes a testing method to ensure all calculations are performed correctly. The modularity of the class allows for easy expansion to include additional climate indices in the future. + + +## Installation + +### From PyPI (when available) + +You can install the package using pip: + +```bash +pip install climate_library +``` + +### From GitHub + +Alternatively, you can install the library directly from the GitHub repository: + +```bash +pip install git+https://github.com/shiv3679/climate-indices.git +``` + +### Dependencies + +The following packages are required dependencies and will be installed automatically: + +- xarray +- xclim +- numpy + +### Compatibility + +The library is compatible with Python 3.6 and higher. + + +## Usage + +### Initialization + +Create an instance of the `ClimateIndex` class by providing the path to your climate data file. This class is the main entry point for working with climate indices in this library. + +#### Example + +```python +from climate_library.climate_index import ClimateIndex + +# Path to the NetCDF file containing climate data +datafile = 'path/to/your/datafile.nc' + +# Create an instance of the ClimateIndex class +climate_index = ClimateIndex(datafile) +``` + +The `datafile` parameter should be the path to a NetCDF file that contains the climate data you want to analyze. The file must include dimensions for time, latitude, and longitude, and it must contain the relevant climate variables (e.g., temperature, precipitation) that you wish to use in calculating climate indices. + +Once you have created an instance of the `ClimateIndex` class, you can use its methods to preprocess the data and calculate various climate indices, as described in the following sections. + + +## Preprocessing Method + +``` {.python language="Python"} +climate_index.pre_process(time_range=None, fill_missing=None, resample_freq=None, months=None, season=None, resample_method='mean') +``` + +- `time_range` (tuple, optional): This parameter allows you to specify a start and end time for the data you want to analyze. By providing a tuple with two date strings, you can subset the dataset to include only the observations within that time frame. + - Example: `time_range=('1961-01-01', '1990-12-31')` will include only the data from January 1, 1961, to December 31, 1990. + - Use Case: This can be useful when analyzing climate patterns over specific periods or when comparing different decades. + +- `fill_missing` (int, float, or 'interpolate', optional): This parameter provides options to handle missing values (NaN) in the dataset. + - If a numerical value is provided, all missing values will be replaced with that number. + - If `interpolate` is specified, linear interpolation will be used to estimate missing values based on neighbouring observations. + - Example: `fill_missing=0` will replace all NaN values with 0. + - Use Case: Handling missing values is crucial in climate analysis to avoid bias and errors in subsequent calculations. + +- `resample_freq` (str, optional): This parameter defines the frequency at which the data should be resampled. It allows you to change the time-frequency of the dataset. + - Example: `resample_freq='MS'` will resample the data to monthly frequency, starting at the beginning of each month. + - Use Case: Resampling is useful when analysing data at a different temporal resolution, such as monthly or yearly. + +- `months` (list, optional): This parameter allows you to select specific months from the dataset. + - Example: `months=[1, 2, 3]` will include only the data from January, February, and March. + - Use Case: Useful for seasonal analysis or when studying climate behaviour during particular months. + +- `season` (str, optional): This parameter enables the selection of data for a specific meteorological season. + - Example: season='JJA' will include only the data from the summer months (June, July, August). + - Use Case: Helpful for analyzing seasonal patterns and variations in climate. + +- `resample_method` (str, optional, default='mean'): This parameter defines the method used for resampling when changing the time-frequency with `resample_freq`. + - Default is `mean`, meaning that the mean value of the observations within each resampling period will be used. + - Other methods, such as `sum`, `max`, etc., can be specified if needed. + - Use Case: This provides flexibility in how the data is aggregated when resampling, allowing for different types of analysis and interpretation. + +#### Example Usage + +```python +climate_index.pre_process(time_range=('2000-01-01', '2020-12-31'), resample_freq='M', fill_missing='interpolate') +``` + +This example demonstrates how to preprocess the data by selecting a time range, resampling to monthly frequency, and interpolating missing values. Adjust these parameters according to your specific needs and analysis goals. + +### Climate Indices Calculation Methods + +#### Temperature Indices + +##### TX10P (Temperature Exceeding 10th Percentile) + + +```python +tx10p_index = climate_index.calculate_tx10p() +``` +- **Description**: Calculates the number of days when the maximum temperature exceeds the 10th percentile of a reference period. +- **Calculation**: Computed by first calculating the 10th percentile of daily maximum temperature over a reference period and then counting how many days in the target period exceed this threshold. + +##### TX90P (Temperature Exceeding 90th Percentile) + + +```python +tx90p_index = climate_index.calculate_tx90p() +``` +- **Description**: Calculates the number of days when the maximum temperature exceeds the 90th percentile of a reference period. +- **Calculation**: Similar to TX10P, but using the 90th percentile as the threshold. + +##### TN10P (Temperature Below 10th Percentile) + +```python +tn10p_index = climate_index.calculate_tn10p() +``` +- **Description**: Calculates the number of days when the minimum temperature is below the 10th percentile of a reference period. +- **Calculation**: Similar to TX10P, but for daily minimum temperature. + +##### TN90P (Temperature Exceeding 90th Percentile) + +```python +tn90p_index = climate_index.calculate_tn90p() +``` +- **Description**: Calculates the number of days when the minimum temperature exceeds the 90th percentile of a reference period. +- **Calculation**: Similar to TN10P, but using the 90th percentile as the threshold. + +##### Frost Days + + +```python +frost_days_index = climate_index.calculate_frost_days() +``` +- **Description**: Counts the number of days when the minimum temperature falls below 0°C. +- **Calculation**: Number of days when daily minimum temperature falls below freezing. + +##### Warm Spell Duration Index + + +```python +warm_spell_index = climate_index.calculate_warm_spell() +``` +- **Description**: Measures the duration of warm spells when daily maximum temperature exceeds the 90th percentile for consecutive days. +- **Calculation**: Length of periods exceeding the 90th percentile of maximum temperature. + +##### Cold Spell Duration Index + + +```python +cold_spell_index = climate_index.calculate_cold_spell() +``` +- **Description**: Measures the duration of cold spells when daily minimum temperature falls below the 10th percentile for consecutive days. +- **Calculation**: Length of periods falling below the 10th percentile of minimum temperature. + +#### Precipitation Indices + +##### Percentile Precipitation + + +```python +rXXp_index_time_series, rXXp_days_count = climate_index.calculate_percentile_p(precip_var='tp', percentile=95, wet_day_thresh_mm=1.0, reference_period=('1961-01-01', '1990-12-31'), resample_freq='Y') +``` +- **Description**: Calculates the sum of precipitation on days exceeding a specified percentile. +- **Calculation**: Sum of precipitation on days exceeding the threshold defined by the percentile. +- **Example**: To calculate the sum of precipitation on days exceeding the 95th percentile and the number of such days, with a wet day threshold of 1 mm, and reference period from 1961 to 1990, use percentile=95, wet_day_thresh_mm=1.0, reference_period=('1961-01-01', '1990-12-31'). + + +##### Precipitation Days + + +```python +precip_days_index = climate_index.calculate_precip_days(precip_var='tp', threshold_mm=10.0) +``` +- **Description**: Counts the number of days with precipitation above a specified threshold. +- **Calculation**: Number of days with precipitation exceeding the threshold. +- **Example**: To calculate the number of days with precipitation above 10 mm, use threshold_mm=10.0. + +##### RXnDay + +```python +rxnday_index, heavy_precip_count = climate_index.calculate_rxnday(precip_var='tp', n_days=5, threshold_mm=50.0, resample_freq='Y') +``` +- **Description**: Finds the maximum precipitation sum for a specified number of consecutive days. +- **Calculation**: Maximum sum of precipitation for the defined number of consecutive days. +- **Example**: To calculate the maximum 5-day consecutive precipitation sum and count the number of periods with more than 50 mm, use n_days=5, threshold_mm=50.0. + +These indices provide various ways to quantify temperature and precipitation extremes, trends, and variability, aiding in climate analysis, pattern recognition, and decision-making. + +### Testing Indices + +The `test_indices` method provides a way to test the implemented indices for a specific data type (either 'temperature' or 'precipitation'). + +```python +climate_index.test_indices(data_type='temperature') +``` + +#### Importance + +- **Validation**: Tests the implemented indices to ensure that they are functioning correctly. +- **Debugging**: Helps in identifying and resolving any errors or inconsistencies. +- **Flexibility**: Allows testing for different data types (temperature or precipitation) based on the user's needs. + +#### Functionality + +- **Temperature Testing**: If `data_type='temperature'`, the following methods will be tested: + - `calculate_tx10p` + - `calculate_tx90p` + - `calculate_tn10p` + - `calculate_tn90p` + - `calculate_frost_days` + - `calculate_warm_spell` + - `calculate_cold_spell` + +- **Precipitation Testing**: If `data_type='precipitation'`, the following methods will be tested: + - `calculate_percentile_p` + - `calculate_precip_days` + - `calculate_rxnday` + +#### Example Usage + +- To test all temperature-related indices: + ```python + climate_index.test_indices(data_type='temperature') + ``` + +- To test all precipitation-related indices: + ```python + climate_index.test_indices(data_type='precipitation') + ``` + +## Authors + +### Shiv Shankar Singh +- **Role**: Lead Developer +- **Affiliation**: [IISER Mohali](https://www.iisermohali.ac.in/) +- **Contributions**: Developed the core algorithms and preprocessing methods, conducted testing, and contributed to the documentation. +- **Email**: shivshankarsingh.py@gmail.com +- **GitHub**: [shiv3679](https://github.com/shiv3679) + +### Akshit Nanda +- **Role**: Co-Developer +- **Affiliation**: [IISER Mohali](https://www.iisermohali.ac.in/) +- **Contributions**: Contributed to the development of precipitation indices and data analysis +- **Email**: nandaakshit2000@gmail.com + + +The authors would like to acknowledge the support of Dr. Raju Attada and [Sree Hari](sreeharik@iisermohali.ac.in) from the WEATHER AND CLIMATE MODELLING RESEARCH GROUP (IISER MOHALI) in the development of this library. + +### Contact + +For any inquiries or collaboration, please feel free to reach out to the authors via the provided email addresses. + + +## License + +This project is licensed under the MIT License. \ No newline at end of file diff --git a/climate_library/climate_library/__init__.py b/climate_library/climate_library/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/climate_library/climate_library/climate_index.py b/climate_library/climate_library/climate_index.py new file mode 100644 index 0000000..e013d6f --- /dev/null +++ b/climate_library/climate_library/climate_index.py @@ -0,0 +1,174 @@ +import xarray as xr +import numpy as np +from xclim.indices import tx10p, tx90p, tn10p, tn90p, warm_spell_duration_index, cold_spell_duration_index, frost_days +from xclim.core.calendar import percentile_doy +import warnings + +class ClimateIndex: + def __init__(self, datafile): + self.datafile = datafile + self.data = None + + def pre_process(self, time_range=None, fill_missing=None, resample_freq=None, months=None, season=None, resample_method='mean'): + try: + print("Loading data...") + self.data = xr.open_dataset(self.datafile) + print("Data loaded successfully.") + if 'time' not in self.data.dims: + raise ValueError("Time dimension not found in the dataset.") + print("Time axis found.") + if time_range: + start_time, end_time = time_range + self.data = self.data.sel(time=slice(start_time, end_time)) + print("Time selection completed.") + if months: + self.data = self.data.sel(time=self.data['time.month'].isin(months)) + print("Month selection completed.") + if season: + self.data = self.data.sel(time=self.data['time.season'] == season) + print("Season selection completed.") + if resample_freq: + resampler = self.data.resample(time=resample_freq) + if resample_method in dir(resampler): + self.data = getattr(resampler, resample_method)() + else: + raise ValueError(f"Unknown resampling method: {resample_method}.") + print("Resampling completed.") + if fill_missing: + if isinstance(fill_missing, (int, float)): + print(f"Filling missing values with specified value: {fill_missing}...") + self.data = self.data.fillna(fill_missing) + elif fill_missing == 'interpolate': + print("Filling missing values using interpolation...") + self.data = self.data.interpolate_na(dim='time', method='linear') + else: + print(f"Unknown method to fill missing values: {fill_missing}. Skipping this step.") + print("Missing values handling completed.") + except Exception as e: + print(f"An error occurred while processing the data: {str(e)}") + + def calculate_tx10p(self, temp_var='t2m'): + tasmax_per = percentile_doy(self.data[temp_var], per=10, window=5).sel(percentiles=10) + return tx10p(self.data[temp_var], tasmax_per) + + def calculate_tx90p(self, temp_var='t2m'): + tasmax_per = percentile_doy(self.data[temp_var], per=90, window=5).sel(percentiles=90) + return tx90p(self.data[temp_var], tasmax_per) + + def calculate_tn10p(self, temp_var='t2m'): + tasmin_per = percentile_doy(self.data[temp_var], per=10, window=5).sel(percentiles=10) + return tn10p(self.data[temp_var], tasmin_per) + + def calculate_tn90p(self, temp_var='t2m'): + tasmin_per = percentile_doy(self.data[temp_var], per=90, window=5).sel(percentiles=90) + return tn90p(self.data[temp_var], tasmin_per) + + def calculate_frost_days(self, temp_var='t2m'): + return frost_days(self.data[temp_var], thresh='273.15 K') + + def calculate_warm_spell(self, temp_var='t2m'): + tasmax_per = percentile_doy(self.data[temp_var], per=90, window=5).sel(percentiles=90) + return warm_spell_duration_index(self.data[temp_var], tasmax_per) + + def calculate_cold_spell(self, temp_var='t2m'): + tasmin_per = percentile_doy(self.data[temp_var], per=10, window=5).sel(percentiles=10) + return cold_spell_duration_index(self.data[temp_var], tasmin_per) + + + def calculate_percentile_p(self, precip_var='tp', percentile=95, wet_day_thresh_mm=1.0, reference_period=('1961-01-01', '1990-12-31'), resample_freq='Y'): + pr = self.data[precip_var] # Use the user-specified variable name + # Exclude leap day (February 29th) if present + pr = pr.where((pr['time.month'] != 2) | (pr['time.day'] != 29), drop=True) + + # Convert the wet day threshold to meters + wet_day_thresh_meters = wet_day_thresh_mm / 1000.0 + + # Calculate the specified percentile for the reference period + reference_period_data = pr.sel(time=slice(*reference_period)) + wet_days_reference = reference_period_data.where(reference_period_data >= wet_day_thresh_meters) + p_reference = wet_days_reference.groupby('time.dayofyear').reduce(np.nanpercentile, q=percentile, dim='time') + + # Identify wet days + wet_days = pr.where(pr >= wet_day_thresh_meters) + + # Compare each day with the corresponding percentile + exceeding_days = wet_days.groupby('time.dayofyear') > p_reference + + # Sum the precipitation for those days (rXXp index) + rXXp_index_time_series = (exceeding_days * pr).resample(time=resample_freq).sum() + + # Count the number of days exceeding the specified percentile + rXXp_days_count = exceeding_days.resample(time=resample_freq).sum(dim='time') + + return rXXp_index_time_series * 1000, rXXp_days_count + + + + def calculate_precip_days(self, precip_var='tp', threshold_mm=10.0): + # Convert the threshold to meters + threshold_meters = threshold_mm / 1000.0 + + # Identify days with precipitation exceeding the threshold + heavy_precip_days = self.data['tp'].where(self.data['tp'] >= threshold_meters) + + # Count the number of days exceeding the threshold per year + precip_days_index = heavy_precip_days.groupby('time.year').count(dim='time') + + return precip_days_index + + def calculate_rxnday(self, precip_var='tp', n_days=5, threshold_mm=50.0, resample_freq='Y'): + pr = self.data[precip_var] # Use the user-specified variable name + + # Calculate the rolling n-day precipitation total + rolling_nday_total = pr.rolling(time=n_days).sum() + + # Find the maximum n-day total for each time period (e.g., year) + rxnday_index = rolling_nday_total.resample(time=resample_freq).max() + + # Count the number of n-day heavy precipitation periods + heavy_precip_periods = rolling_nday_total.where(rolling_nday_total >= threshold_mm / 1000.0) + heavy_precip_count = heavy_precip_periods.resample(time=resample_freq).count(dim='time') + + return rxnday_index * 1000, heavy_precip_count + + def test_indices(self, data_type='temperature'): + # Methods to test for temperature data + temp_methods_to_test = [ + self.calculate_tx10p, + self.calculate_tx90p, + self.calculate_tn10p, + self.calculate_tn90p, + self.calculate_frost_days, + self.calculate_warm_spell, + self.calculate_cold_spell, + ] + + # Methods to test for precipitation data + precip_methods_to_test = [ + self.calculate_percentile_p, + self.calculate_precip_days, + self.calculate_rxnday + ] + + # Choose the methods to test based on the data type + if data_type == 'temperature': + methods_to_test = temp_methods_to_test + elif data_type == 'precipitation': + methods_to_test = precip_methods_to_test + else: + raise ValueError("Invalid data type. Choose 'temperature' or 'precipitation'.") + + # Suppress warnings during testing + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + + # Iterate through the methods and print success or error message + for method in methods_to_test: + try: + print(f"Testing {method.__name__}...") + _ = method() + print(f"Performed successful test for {method.__name__}!") + except Exception as e: + print(f"An error occurred while testing {method.__name__}: {str(e)}") + continue + diff --git a/climate_library/setup.py b/climate_library/setup.py new file mode 100644 index 0000000..0c2d904 --- /dev/null +++ b/climate_library/setup.py @@ -0,0 +1,28 @@ +from setuptools import setup, find_packages + +setup( + name='climate_library', + version='0.1.0', + packages=find_packages(), + install_requires=[ + 'xarray', + 'xclim' + ], + author='Shiv Shankar Singh, Akshit Nanda', + author_email='shivshankarsingh.py@gmail.com', + description='A library for calculating climate indices', + long_description=open('README.md', encoding='utf-8').read(), + long_description_content_type='text/markdown', + url='https://github.com/shiv3679/climate-indices', + license='MIT', + classifiers=[ + 'Development Status :: 3 - Alpha', + 'Intended Audience :: Science/Research', + 'License :: OSI Approved :: MIT License', + 'Programming Language :: Python :: 3', + 'Programming Language :: Python :: 3.6', + 'Programming Language :: Python :: 3.7', + 'Programming Language :: Python :: 3.8', + 'Programming Language :: Python :: 3.9', + ], +) diff --git a/xclim/pre_data.ipynb b/xclim/pre_data.ipynb deleted file mode 100644 index 4c247a0..0000000 --- a/xclim/pre_data.ipynb +++ /dev/null @@ -1,6614 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# Import all the libraries needed \n", - "\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import xarray as xr\n", - "import cartopy as cp\n", - "import cartopy.feature as cfeature\n", - "import cartopy.crs as ccrs\n", - "from pylab import *\n", - "from xclim.core.calendar import percentile_doy\n", - "from xclim.indices import tx10p\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "data = xr.open_dataset('/home/posiden/Documents/Datasets/era5/india.1960.1990.nc')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Dimensions: (time: 10957, bnds: 2, longitude: 161, latitude: 141)\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 1961-01-01T11:00:00 ... 1990-12-31T11:00:00\n", - " * longitude (longitude) float32 60.0 60.25 60.5 60.75 ... 99.5 99.75 100.0\n", - " * latitude (latitude) float32 40.0 39.75 39.5 39.25 ... 5.75 5.5 5.25 5.0\n", - "Dimensions without coordinates: bnds\n", - "Data variables:\n", - " time_bnds (time, bnds) datetime64[ns] ...\n", - " t2m (time, latitude, longitude) float32 ...\n", - "Attributes:\n", - " CDI: Climate Data Interface version 2.0.4 (https://mpimet.mpg.de...\n", - " Conventions: CF-1.6\n", - " history: Thu Aug 10 10:42:11 2023: cdo sellonlatbox,60,100,5,40 land...\n", - " frequency: day\n", - " CDO: Climate Data Operators version 2.0.4 (https://mpimet.mpg.de...\n" - ] - } - ], - "source": [ - "print(data)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Climate Index Calculations " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xclim/core/utils.py:461: RuntimeWarning: All-NaN slice encountered\n", - " result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n" - ] - } - ], - "source": [ - "from xclim.core.calendar import percentile_doy\n", - "from xclim.indices import tx10p\n", - "\n", - "data = data.rename_vars({\"t2m\": \"tasmax\"}) # Renaming 't2m' to 'tasmax'\n", - "\n", - "# Calculate the 10th percentile for each day of the year with a 5-day window\n", - "tasmax_per = percentile_doy(data['tasmax'], per=10, window=5).sel(percentiles=10)\n", - "\n", - "# Calculate the tx10p index (number of days with tasmax below the 10th percentile)\n", - "cold_days = tx10p(data['tasmax'], tasmax_per)\n", - "\n", - "# saving the file for easy visualisation\n", - "cold_days.to_netcdf('tx10p_index.nc')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/IAAAIxCAYAAADuaYOWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADlp0lEQVR4nOzdd1hT59sH8O9JCGGDIBsEN6ICDtx7VdtaO6y2tmqHnXTZbad2qZ12oO3vra2tratVO7R1b+vABSqIGxSZsnfGef8IiSCgBAgn4/u5Lq+WcHJyJyc55D7P/dyPIIqiCCIiIiIiIiKyCDKpAyAiIiIiIiKihmMiT0RERERERGRBmMgTERERERERWRAm8kREREREREQWhIk8ERERERERkQVhIk9ERERERERkQZjIExEREREREVkQJvJEREREREREFoSJPBEREREREZEFYSJPZCJLliyBIAhwcHBASkpKrd8PGzYM3bp1kyAyYMeOHRAEAb///rskj2+sixcv4rbbboOnpycEQcALL7xQ77ahoaEQBAGCIEAmk8Hd3R1dunTBtGnTsGnTppYLuoXoj+WOHTsMt/3zzz+YPXt2ndsLgoBnnnmmUY918eJFw2srCAIUCgW8vLwQHR2NmTNn4uTJk43ab/XYqsdd13NrCv1nsr59iqKIDh06QBAEDBs2rFkesz6hoaF46KGHTPoYLWX27Nk13hf1/TP1a2rOSktLMXv27GZ7Lze36udN/d+tDh064MUXX0ROTk6j9tncn9/GMtX50Bjr1q3DtGnT0L17dygUCgiCUO+2KpUKc+bMQWhoKJRKJcLCwvD111/X2m7ZsmVYsGBBrdv15+lPP/20UbHqj5v+n1wuh6+vL+69914kJSU1ap/m5MqVK5g9ezaOHTtW63f6c1l1w4YNs+lzF5k3O6kDILJ2FRUVeOutt7B06VKpQ7FYM2fOxIEDB/DDDz/Az88P/v7+N9x+4MCBhi8xxcXFSE5OxooVK3DLLbfgnnvuwfLly6FQKFoidJPr2bMn9u3bh/DwcMNt//zzD2JjY+v98tpUzz77LKZMmQKtVov8/HwcPXoUP/zwA77++mvMnTsXr7zySqP2u2/fPgQFBTVztLW5urpi8eLFtb6c7dy5E+fOnYOrq6vJY1i7di3c3NxM/jgtYcaMGRg7dqzh5/T0dNx9992G94metTzfxigtLcWcOXMAwGyTgurnzbKyMhw6dAizZ8/Grl27cOjQIYmjazxTnw8bYu3atdi/fz969OgBpVKJw4cP17vt008/jaVLl+L9999HdHQ0Nm7ciOeffx5FRUV44403DNstW7YMJ06cuOGF7ab46KOPMHz4cFRWVuLQoUN47733sHXrVhw/fhyBgYEmecyWcOXKFcOFkqioqBq/u/5cRmTumMgTmdjYsWOxbNkyvPzyy4iMjJQ6nBZVVlYGBweHG44+NMSJEyfQp08f3HnnnQ3a3sPDA/369TP8PGrUKMTExGD27NmYM2cO3nrrLcyfP79JMZkLNze3Gs+1JbRp06bGY95666148cUXcffdd+PVV19Ft27dMG7cOKP321LPY/Lkyfj1118RGxtbI7lcvHgx+vfvj8LCQpPH0KNHD5M/RksJCgqqcQHm4sWLAGq/T6yJSqWCIAiws5P2a5QoiigvL4ejo2OT93X9eXP48OEoKirC+++/j9OnT6NTp05Nfgxb9X//93+QyXRFsM8880y9ifzJkyexePFifPjhh4YLosOGDcPVq1fxwQcf4Mknn4Snp2eLxNyxY0fD+2HIkCHw8PDAo48+iiVLluDNN99s0r5LS0vh5OTUHGE2q+vPZUTmjqX1RCb26quvwsvLC6+99toNt9OXwy1ZsqTW764vOdaXfyUkJODee++Fu7s7PD098eKLL0KtViM5ORljx46Fq6srQkND8fHHH9f5mOXl5XjxxRfh5+cHR0dHDB06FEePHq213aFDh3DHHXfA09MTDg4O6NGjB1atWlVjG33Z8qZNm/DII4/A29sbTk5OqKioqPc5p6am4sEHH4SPjw+USiW6dOmCzz77DFqtFsC1Er+zZ8/i33//NZT66RMFY82ePRtdu3bFN998g/LycsPtc+bMQd++feHp6Qk3Nzf07NkTixcvhiiKhm0effRReHp6orS0tNZ+R4wYga5duxp+/u2339C3b1+4u7vDyckJ7dq1wyOPPHLD2O69994a+wCA8ePHQxAE/Pbbb4bbjhw5AkEQ8PfffwOoXb760EMPITY2FgBqlEde/5otXboUXbp0gZOTEyIjI7Fu3bobxnczjo6OWLx4MRQKBT755BPD7dnZ2Xj66acRHh4OFxcX+Pj4YMSIEdi9e3etfVz/Pr/e0qVLIQgC9u3bV+t37733HhQKBa5cuXLTWO+//34AwPLlyw23FRQUYPXq1fUep4a8R/bs2QOFQoGXX365xn31n43Fixcbbru+tF5/HJctW4bXXnsN/v7+cHFxwfjx45GZmYmioiI8/vjjaN26NVq3bo2HH34YxcXFhvtLcf4wljHnkW3btuGxxx6Dl5cX3NzcMG3aNJSUlCAjIwOTJk2Ch4cH/P398fLLL0OlUtV6HT7++GN8+OGHaNOmDRwcHNC7d29s3bq1VkxnzpzBlClTapyD9J8fPf2xWbp0KV566SUEBgZCqVTi7NmzDXp/X7x4Ed7e3gB07yP9Z1J//B966CGEhobWiq2uMl99Kfi3336LLl26QKlU4qeffmrwczGWu7s7ANSqYGrIsazPX3/9hf79+8PJyQmurq4YPXp0jc/0yZMna533Dh8+DEEQap0j77jjDvTq1avex2rO82FTXl99En8zf/zxB0RRxMMPP1zj9ocffhhlZWXYsGEDAF1yv379eqSkpNR4Xtf7/PPP0bZtW7i4uKB///7Yv39/g+Koiz6prz5VcOXKlejfvz+cnZ3h4uKCW265pdZ3iIceegguLi44fvw4xowZA1dXV4wcORKArmLxvffeQ5cuXeDg4AAvLy8MHz4c//33n+H+oihi4cKFiIqKgqOjI1q1aoWJEyfi/PnzNR5HP10xLi4OgwcPNvztnTdvXo3vFNHR0YbXVP+66c+PdX3m6lJZWYkPPvgAYWFhUCqV8Pb2xsMPP4zs7GwjX1WipmEiT2Rirq6ueOutt7Bx40Zs27atWfc9adIkREZGYvXq1XjsscfwxRdfYObMmbjzzjtx2223Ye3atRgxYgRee+01rFmzptb933jjDZw/fx7ff/89vv/+e1y5cgXDhg2r8Qdy+/btGDhwIPLz8/Htt9/izz//RFRUFCZPnlxn0vDII49AoVBg6dKl+P333+stYc/OzsaAAQOwadMmvP/++/jrr78watQovPzyy4Y5i/qycT8/PwwcOBD79u3Dvn37blpafyPjx49HaWlpjVLRixcv4oknnsCqVauwZs0aQ1nw+++/b9jm+eefR15eHpYtW1Zjf4mJidi+fTtiYmIA6MrDJ0+ejHbt2mHFihVYv3493nnnHajV6hvGNWrUKCQmJiI9PR0AoFarsXPnTjg6OmLz5s2G7bZs2QI7O7t6y3PffvttTJw40RBLXa/Z+vXr8c033+C9997D6tWr4enpibvuuqvWFyNjBQQEoFevXvjvv/8Mzzc3NxcA8O6772L9+vX48ccf0a5dOwwbNszoubOTJ0+Gn59frS/ParUa3333He666y4EBATcdD9ubm6YOHEifvjhB8Nty5cvh0wmw+TJk+u8T0PeI4MGDcIHH3yAzz77DH/99RcAXVISExODBx98EI8++uhNY3vjjTeQlZWFJUuW4LPPPsOOHTtw//3345577oG7uzuWL1+OV199FUuXLq1RZtsYTT1/GMPY88iMGTPg7u6OFStW4K233sKyZcvw2GOP4bbbbkNkZCR+//13TJ8+HZ999lmd84e/+eYbbNiwAQsWLMAvv/wCmUyGcePG1UgYExMTER0djRMnTuCzzz7DunXrcNttt+G5554zlMFXN2vWLKSmpuLbb7/F33//DR8fnwa9v/39/Q0J2KOPPmr4TL799tuNei3/+OMPLFq0CO+88w42btyIwYMHG/1c6iKKItRqNdRqNYqLi7F9+3YsWLAAAwcORNu2bQ3bGXssq1u2bBkmTJgANzc3LF++HIsXL0ZeXh6GDRuGPXv2AAC6du0Kf39/bNmyxXC/LVu2wNHREYmJiYaLdfpz5KhRo+p9vOY6HzbH69sQJ06cgLe3N/z8/GrcHhERYfg9ACxcuBADBw6En59fjedVXWxsLDZv3owFCxbg119/RUlJCW699VYUFBQ0KrazZ88CgOGi1EcffYT7778f4eHhWLVqFZYuXYqioiLD+7G6yspK3HHHHRgxYgT+/PNPzJkzB2q1GuPGjcP777+P22+/HWvXrsWSJUswYMAApKamGu77xBNP4IUXXsCoUaPwxx9/YOHChTh58iQGDBiAzMzMGo+TkZGBBx54AA8++CD++usvjBs3DrNmzcIvv/wCQPed4scffwQAvPXWW4bXbcaMGQ1+HbRaLSZMmIB58+ZhypQpWL9+PebNm4fNmzdj2LBhKCsrM/7FJWoskYhM4scffxQBiHFxcWJFRYXYrl07sXfv3qJWqxVFURSHDh0qdu3a1bD9hQsXRADijz/+WGtfAMR3333X8PO7774rAhA/++yzGttFRUWJAMQ1a9YYblOpVKK3t7d49913G27bvn27CEDs2bOnIR5RFMWLFy+KCoVCnDFjhuG2sLAwsUePHqJKparxWLfffrvo7+8vajSaGs932rRpDXp9Xn/9dRGAeODAgRq3P/XUU6IgCGJycrLhtpCQEPG2225r0H5vtu2iRYtEAOLKlSvr/L1GoxFVKpX43nvviV5eXjVen6FDh4pRUVG14nVzcxOLiopEURTFTz/9VAQg5ufnNyhevbNnz4oAxJ9//lkURVHcs2ePCEB89dVXxbZt2xq2Gz16tDhgwADDz/pjuX37dsNtMTExYn2ndwCir6+vWFhYaLgtIyNDlMlk4ty5c28Yo/49+sknn9S7zeTJk0UAYmZmZp2/V6vVokqlEkeOHCneddddtWKr/j6v67m9++67or29fY39r1y5UgQg7ty584bxV/9M6vd94sQJURRFMTo6WnzooYdEURTFrl27ikOHDq13Pzd6j2i1WvHWW28VPTw8xBMnTojh4eFiWFiYWFxcXGMfISEh4vTp02s91/Hjx9fY7oUXXhABiM8991yN2++8807R09PT8HNLnj9upq73ibHnkWeffbbW8wUgfv7557Vi7tmzZ63HDggIEMvKygy3FxYWip6enuKoUaMMt91yyy1iUFCQWFBQUGOfzzzzjOjg4CDm5uaKonjt2AwZMuSmz72+93d2dnat46A3ffp0MSQkpNbt+uNUHQDR3d3dEJuxz6U+ISEhIoBa//r06SOmp6fX2Lahx/L6z69GoxEDAgLE7t27G7YRRVEsKioSfXx8apzXHnzwQbFdu3aGn0eNGiU+9thjYqtWrcSffvpJFEVR3Lt3rwhA3LRp0w2fW3OcD5v6+jY0ntGjR4udO3eu83f29vbi448/bvj5tttuq/N9o/8MdO/eXVSr1YbbDx48KAIQly9ffsP49Mdt5cqVokqlEktLS8Vdu3aJHTp0EOVyuRgfHy+mpqaKdnZ2tT6nRUVFop+fnzhp0iTDbdOnTxcBiD/88EONbX/++WcRgPh///d/9cayb9++Os9Vly5dEh0dHcVXX33VcNvQoUPr/E4RHh4u3nLLLYaf4+Li6j1X1vWZGzp0aI2/B8uXLxcBiKtXr66xnX6/CxcurPf5EDU3jsgTtQB7e3t88MEHOHToUIPLDxvi9ttvr/Fzly5dIAhCjfnJdnZ26NChQ52d86dMmVKjjCwkJAQDBgzA9u3bAeiuwJ86dQoPPPAAABhGa9RqNW699Vakp6cjOTm5xj7vueeeBsW+bds2hIeHo0+fPjVuf+ihhyCKYrNXL+iJ1Uqhq8cyatQouLu7Qy6XQ6FQ4J133sHVq1eRlZVl2O7555/HsWPHsHfvXgBAYWEhli5diunTp8PFxQUADGV7kyZNwqpVq5CWltaguNq3b4/Q0FDDKNTmzZvRvXt3PPjgg7hw4QLOnTuHiooK7Nmz54YjUA0xfPjwGg3dfH194ePjU+d7xFh1vb7ffvstevbsCQcHB9jZ2UGhUGDr1q2N6oD81FNPAdDNOdX75ptv0L17dwwZMqTB+xk6dCjat2+PH374AcePH0dcXNwNpz809D0iCAJ+/vlnuLq6onfv3rhw4QJWrVoFZ2fnBsVV12caAG677bZat+fm5tYorzdWU88fDdWY84gxr0Ndsd19991wcHAw/Ozq6orx48dj165d0Gg0KC8vx9atW3HXXXfBycmpVkzl5eW1ypDrO7c15/u7IUaMGIFWrVoZfm7Mc6nLoEGDEBcXh7i4OOzduxeLFy9GdnY2RowYYehc35hjqZecnIwrV65g6tSpNUrNXVxccM8992D//v2GqUsjR47E+fPnceHCBZSXl2PPnj0YO3Yshg8fbqhQ2rJlC5RKJQYNGtS4F7LKzc6HzfX6NtSNSruN6Tdz2223QS6XG37Wj+o39LM8efJkKBQKODk5YciQIdBoNPj9998RERGBjRs3Qq1WY9q0aTVeDwcHBwwdOrTOaqvrPz///vsvHBwcbnjeXbduHQRBwIMPPljjcfz8/BAZGVnrcfz8/Gp9p4iIiGiWv23VY/Lw8MD48eNrxBQVFQU/Pz/JV2kg28JEnqiF3HfffejZsyfefPPNGnM6m+L6pjf29vZwcnKq8QVWf3v1OeF615fv6W+7evUqABjK1l5++WUoFIoa/55++mkAqLU0UUPL3q9evVrntvrSaH0MzU3/B13/OAcPHsSYMWMA6JLDvXv3Ii4uztDMp3qZ3IQJExAaGmoo7V6yZAlKSkoMZfWArinQH3/8YfiSExQUhG7dutWYj12fkSNHGubxbtmyBaNHj0b37t3h6+uLLVu2YO/evSgrK2tyIu/l5VXrNqVS2SwlgSkpKVAqlYb35ueff46nnnoKffv2xerVq7F//37ExcVh7NixjXo8X19fTJ48Gd999x00Gg0SEhKwe/duo5eQEgQBDz/8MH755Rd8++236NSpEwYPHlzntsa8RwDd63vHHXegvLwcY8eORffu3RscV12f6RvdXtfnuimPZcz5o6Eacx4x5nUw5txWWVmJ4uJiXL16FWq1Gl9//XWtmG699dY6Y6rrfNXc7++GuD6OxjyXuri7u6N3797o3bs3BgwYgEceeQTLli1DUlISPvvsMwCNO5bV46wrfkB3PtZqtcjLywMAwzluy5Yt2LNnD1QqFUaMGIFRo0bVOEcOHDiwyY3+bnY+bK7Xt6Gx1PW3r6SkBJWVlUY1urv+eSmVSgC1z1f1mT9/PuLi4nDkyBGkpqbi/Pnzhoaz+vdBdHR0rddk5cqVtV4PJyenWqtWZGdnIyAg4Ib9AzIzMyGKInx9fWs9zv79+2s9jin/tlWPKT8/H/b29rViysjIaLb3AlFDsGs9UQsRBAHz58/H6NGj8b///a/W7/Vfnq9vDmeqhBbQzSer6zb9H8PWrVsD0M0Nvfvuu+vcR+fOnWv83NARAy8vL8N88Or08x/1j92cRFHE33//DWdnZ/Tu3RsAsGLFCigUCqxbt65GAvPHH3/Uur9MJkNMTAzeeOMNfPbZZ1i4cCFGjhxZ6zWYMGECJkyYgIqKCuzfvx9z587FlClTEBoaiv79+9cb38iRI7F48WIcPHgQBw4cwFtvvQVANwK3efNmpKSkwMXFxWw7gaelpeHw4cMYOnSooZv3L7/8gmHDhmHRokU1ti0qKmr04zz//PNYunQp/vzzT2zYsAEeHh6GEUJjPPTQQ3jnnXfw7bff4sMPP6x3O2PeI4CummLRokXo06cP1q5di9WrVze4UqWxpDh/NFRjziNNVd+5zd7eHi4uLlAoFJDL5Zg6dWqNC3HVVZ8XDtR9bmuO97eDg0OdTUHrSwiuj6NVq1ZGP5eG0o/ixsfHA2jasdT/XanvvC+TyQyVBkFBQejUqRO2bNmC0NBQ9O7dGx4eHhg5ciSefvppHDhwAPv372/W+en1MeXre73u3btjxYoVyMjIqHEx6vjx4wCAbt26NcvjNES7du0Mfyevp38f/P777wgJCbnpvur67Hh7e2PPnj3QarX1JvOtW7eGIAjYvXu34UJEdXXdZmqtW7eGl5eXoe/F9Vpi+VIiPSbyRC1o1KhRGD16NN577z0EBwfX+J2vry8cHByQkJBQ4/Y///zTZPEsX74cL774ouGPbEpKCv777z9MmzYNgO4LWceOHREfH4+PPvqoWR975MiRmDt3Lo4cOYKePXsabv/5558hCAKGDx/erI8H6DpGJyYm4o033jAkPvolpKqXIJaVlWHp0qV17mPGjBmYPXs2HnjgASQnJ99wGTulUomhQ4fCw8MDGzduxNGjR2+ayAuCgLfffhsymcxQKj5q1Ci88sorSElJwZAhQ+ptIFj9cfXPozmWpWqIsrIyzJgxA2q1Gq+++qrhdkEQan3ZSkhIwL59+2p9BhqqV69eGDBgAObPn48TJ07g8ccfb3DpenWBgYF45ZVXcOrUKUyfPr3e7Yx5j6Snp+PBBx/E0KFDsXnzZtx999149NFH0bNnz2b7sl8XKc4fDWXK80h91qxZg08++cTwOS8qKsLff/+NwYMHQy6Xw8nJCcOHD8fRo0cRERFhGPE3VkPf3zcaDQ0NDUVWVhYyMzPh6+sLQNccbOPGjQ2KobmeS12OHTsGAPDx8QHQtGPZuXNnBAYGGpZj1f/dKSkpwerVqw2d7PVGjRqFVatWITg42DClolOnTmjTpg3eeecdqFSqBlUnNfV8aMrX93oTJkzAW2+9hZ9++qnGSjdLliyBo6NjjTXOm3uk2Ri33HIL7OzscO7cuUZfpBw3bhyWL1+OJUuW1Ftef/vtt2PevHlIS0vDpEmTmhKygbGVCXXFtGLFCmg0GvTt27dZYiJqLCbyRC1s/vz56NWrF7KysmospaOfB/bDDz+gffv2iIyMxMGDB2t1SW9OWVlZuOuuu/DYY4+hoKAA7777LhwcHDBr1izDNt999x3GjRuHW265BQ899BACAwORm5uLpKQkHDlypMYSQcaYOXMmfv75Z9x222147733EBISgvXr12PhwoV46qmnmrRmcX5+vmHOYklJCZKTk7FixQrs3r0bkyZNqjGKc9ttt+Hzzz/HlClT8Pjjj+Pq1av49NNP673S7+HhgWnTpmHRokUICQnB+PHja/z+nXfeweXLlzFy5EgEBQUhPz8fX375JRQKBYYOHXrDuH18fNCtWzds2rQJw4cPN3ypHTVqFHJzc5Gbm4vPP//8ps9fX8o9f/58jBs3DnK5vFm/gKampmL//v3QarUoKCjA0aNH8cMPPyAlJQWfffaZoQwd0H3pef/99/Huu+9i6NChSE5OxnvvvYe2bdvetJP/jTz//POYPHkyBEEwlPQ2xrx58266TUPfIxqNBvfff79hGTm5XI4lS5YYOnrv2bPHZEmAFOcPY5jqPFIfuVyO0aNH48UXX4RWq8X8+fNRWFhY47P/5ZdfYtCgQRg8eDCeeuophIaGoqioCGfPnsXff//doD4dDX1/u7q6IiQkBH/++SdGjhwJT09PtG7dGqGhoZg8eTLeeecd3HfffXjllVdQXl6Or776ChqNpsHPtzmeS/XzpkqlQlJSEj766CMolcoaI9GNPZYymQwff/wxHnjgAdx+++144oknUFFRgU8++QT5+fm1PosjR47EwoULkZOTgwULFtS4/ccff0SrVq1uuPScXnOcD5v6+qakpCAuLg4AcO7cOQC60WwAhooDQNex/9FHH8W7774LuVyO6OhobNq0Cf/73//wwQcf1Cit7969O9asWYNFixahV69ekMlk9Y6gN7fQ0FC89957ePPNN3H+/HmMHTsWrVq1QmZmJg4ePAhnZ+ebVkvcf//9+PHHH/Hkk08iOTkZw4cPh1arxYEDB9ClSxfcd999GDhwIB5//HE8/PDDOHToEIYMGQJnZ2ekp6djz5496N69u6FvSkO1b98ejo6O+PXXX9GlSxe4uLggICCgQSueALppkr/++ituvfVWPP/88+jTpw8UCgUuX76M7du3Y8KECbjrrruMiomo0SRttUdkxap3yL7elClTRAA1utaLoigWFBSIM2bMEH19fUVnZ2dx/Pjx4sWLF+vtOp2dnV3j/tOnTxednZ1rPd71HfL1XWmXLl0qPvfcc6K3t7eoVCrFwYMHi4cOHap1//j4eHHSpEmij4+PqFAoRD8/P3HEiBHit99+26DnW5+UlBRxypQpopeXl6hQKMTOnTuLn3zySY2OxqJofNd6VHVcFgRBdHFxETt37ixOnTpV3LhxY533+eGHH8TOnTuLSqVSbNeunTh37lxx8eLFIgDxwoULtbbfsWOHCECcN29erd+tW7dOHDdunBgYGCja29uLPj4+4q233iru3r27QfHPnDlTBCB++OGHNW7v2LGjCEBMSEiocXtdnd0rKirEGTNmiN7e3qIgCDWeBwAxJiam1uNe30W9LvpuyPp/crlcbNWqldirVy/xhRdeEE+ePFnrPhUVFeLLL78sBgYGig4ODmLPnj3FP/74o85O3de/z+t6btX3q1QqxbFjx94w5uoa+h6tq2t9Q94jb775piiTycStW7fWuO9///0n2tnZic8//7zhtvq61v/2228Nirmuc0BLnT9upr7VDZpyHmlozPrHnj9/vjhnzhwxKChItLe3F3v06FHn5//ChQviI488IgYGBooKhUL09vYWBwwYIH7wwQeGbeo7NqJo3Pt7y5YtYo8ePUSlUikCqHH8//nnHzEqKkp0dHQU27VrJ37zzTf1dq2v6/Pb0OdSn+u71svlcrFNmzbixIkTxaNHj9baviHHsr7P7x9//CH27dtXdHBwEJ2dncWRI0eKe/furfUYeXl5okwmE52dncXKykrD7b/++qsIoMErKTTX+bApr6/+fV3Xv+sfp7KyUnz33XfFNm3aiPb29mKnTp3Er776qtY+c3NzxYkTJ4oeHh6G56WPs67Pn/751rVyQnU3er9f748//hCHDx8uurm5iUqlUgwJCREnTpwobtmyxbBNfecVURTFsrIy8Z133hE7duwo2tvbi15eXuKIESPE//77r8Z2P/zwg9i3b1/R2dlZdHR0FNu3by9OmzatxveV+s5TdX0Wly9fLoaFhYkKhaLGa9KQrvWiqFvN49NPPxUjIyNFBwcH0cXFRQwLCxOfeOIJ8cyZMzd72YiajSCKdbQYJiKier300ktYtGgRLl26VGdzHTK9v//+G3fccQfWr19vaDhFdPHiRbRt2xaffPIJXn75ZanDISIiMhmW1hMRNdD+/ftx+vRpLFy4EE888QSTeAkkJiYiJSUFL730EqKiomoslUZERERkK5jIExE1kL4Z0+23344PPvhA6nBs0tNPP429e/eiZ8+e+Omnn4xaV5mIiIjIWrC0noiIiIiIiMiC1L1wIxERERERERGZJSbyRERERERERBaEiTwRERERERGRBWGzuzpotVpcuXIFrq6ubKREREREREREJieKIoqKihAQEACZ7MZj7kzk63DlyhUEBwdLHQYRERERERHZmEuXLiEoKOiG2zCRr4OrqysA3Qvo5ubWoPuoVCps2rQJY8aMgUKhMGV41EJ4TK0Pj6l14fG0Pjym1oXH0/rwmFofHlPzUlhYiODgYEM+eiNM5OugL6d3c3MzKpF3cnKCm5sbPwRWgsfU+vCYWhceT+vDY2pdeDytD4+p9eExNU8Nmd7NZndEREREREREFoSJPBEREREREZEFYSJPREREREREZEGYyFcTGxuL8PBwREdHSx0KERERERERUZ2YyFcTExODxMRExMXFSR0KERERERERUZ2YyBMRERERERFZECbyRERERERERBaEiTwRERERERGRBWEiT0RERERERGRBmMgTERERERERWRBJE/lFixYhIiICbm5ucHNzQ//+/fHvv/8CAFQqFV577TV0794dzs7OCAgIwLRp03DlypUb7nPJkiUQBKHWv/Ly8pZ4SkREREREREQmZSflgwcFBWHevHno0KEDAOCnn37ChAkTcPToUQQFBeHIkSN4++23ERkZiby8PLzwwgu44447cOjQoRvu183NDcnJyTVuc3BwMNnzICIiIiIiImopkiby48ePr/Hzhx9+iEWLFmH//v149NFHsXnz5hq///rrr9GnTx+kpqaiTZs29e5XEAT4+fmZJGYiIiIiIiIiKUmayFen0Wjw22+/oaSkBP37969zm4KCAgiCAA8Pjxvuq7i4GCEhIdBoNIiKisL777+PHj161Lt9RUUFKioqDD8XFhYC0JX3q1SqBsWv366h25P54zG1Pjym1oXH0/rwmFoXHk/rw2NqfXhMzYsxx0EQRVE0YSw3dfz4cfTv3x/l5eVwcXHBsmXLcOutt9barry8HIMGDUJYWBh++eWXeve3f/9+nD17Ft27d0dhYSG+/PJL/PPPP4iPj0fHjh3rvM/s2bMxZ86cWrcvW7YMTk5OjX9yRERERERERA1QWlqKKVOmoKCgAG5ubjfcVvJEvrKyEqmpqcjPz8fq1avx/fffY+fOnQgPDzdso1KpcO+99yI1NRU7duy46ZOqTqvVomfPnhgyZAi++uqrOrepa0Q+ODgYOTk5DX4slUqFzZs3Y/To0VAoFA2Oj8wXj6n14TG1Ljye1ofH1LrweFofHlPrw2NqXgoLC9G6desGJfKSl9bb29sbmt317t0bcXFx+PLLL/Hdd98B0L25Jk2ahAsXLmDbtm1GJfEAIJPJEB0djTNnztS7jVKphFKprHW7QqEw+g3dmPs0VoVag1PpRXB3VCC0tXOLPKYtasljSi2Dx9S68HhaHx5T68LjaX14TK0Pj6l5MOYYmN068qIoGkbH9Un8mTNnsGXLFnh5eTVqf8eOHYO/v39zhyq599clYkLsXiw7mCp1KERERERERNRCJB2Rf+ONNzBu3DgEBwejqKgIK1aswI4dO7Bhwwao1WpMnDgRR44cwbp166DRaJCRkQEA8PT0hL29PQBg2rRpCAwMxNy5cwEAc+bMQb9+/dCxY0cUFhbiq6++wrFjxxAbGyvZ8zSViEAPAKmIv5QvcSRERERERETUUiRN5DMzMzF16lSkp6fD3d0dERER2LBhA0aPHo2LFy/ir7/+AgBERUXVuN/27dsxbNgwAEBqaipksmuFBfn5+Xj88ceRkZEBd3d39OjRA7t27UKfPn1a6mm1mIhgdwDAibQCaLQi5DJB4oiIiIiIiIjI1CRN5BcvXlzv70JDQ9GQPnw7duyo8fMXX3yBL774oqmhWYQO3i5wVMhRUqnB+exidPR1lTokIiIiIiIiMjGzmyNPDWcnl6FboK75X/zlAomjISIiIiIiopbARN7CRQR5AAASLudLGgcRERERERG1DCbyFi4iSDdPniPyREREREREtoGJfDWxsbEIDw9HdHS01KE0WGTViHxSeiEq1VppgyEiIiIiIiKTYyJfTUxMDBITExEXFyd1KA0W4uUEd0cFKtVanM4skjocIiIiIiIiMjEm8hZOEIRq5fX50gZDREREREREJsdE3groE/mES5wnT0REREREZO2YyFsBfed6jsgTERERERFZPybyVkDf8O5MVjHKKjXSBkNEREREREQmxUTeCvi5O8DHVQmNVsTJKyyvJyIiIiIismZM5K3EtfJ6JvJERERERETWjIm8lYjUN7zjPHkiIiIiIiKrxkTeSkQEewAAEjgiT0REREREZNWYyFuJiEDdiPyFnBIUlKkkjoaIiIiIiIhMhYl8NbGxsQgPD0d0dLTUoRitlbM92ng6AQCOc1SeiIiIiIjIajGRryYmJgaJiYmIi4uTOpRGiaiaJ8/15ImIiIiIiKwXE3krol9Png3viIiIiIiIrBcTeSsSYehcz9J6IiIiIiIia8VE3op0C3SHIADpBeXIKiqXOhwiIiIiIiIyASbyVsRZaYcO3i4AgIRLHJUnIiIiIiKyRkzkrUwE58kTERERERFZNSbyViYyWN+5niPyRERERERE1oiJvJWpPiIviqK0wRAREREREVGzYyJvZbr4u0IhF5BXqsLlvDKpwyEiIiIiIqJmxkS+mtjYWISHhyM6OlrqUBpNaSdHmJ8bACCe8+SJiIiIiIisDhP5amJiYpCYmIi4uDipQ2kSridPRERERERkvZjIW6HIqnny8ZfyJY2DiIiIiIiImh8TeSsUUdW5/kRaATRaNrwjIiIiIiKyJkzkrVAHbxc4KuQoqdTgQk6x1OEQERERERFRM2Iib4Xs5DJ0C6xqeHeJ8+SJiIiIiIisCRN5K1V9PXkiIiIiIiKyHkzkrZS+c308O9cTERERERFZFSbyVkrfuT4xvRCVaq20wRAREREREVGzYSJvpUK8nODuqEClWovTmUVSh0NERERERETNhIl8NbGxsQgPD0d0dLTUoTSZIAjVyuvzpQ2GiIiIiIiImg0T+WpiYmKQmJiIuLg4qUNpFvpEPoGd64mIiIiIiKwGE3krpu9czxF5IiIiIiIi68FE3orpG96dySpGWaVG2mCIiIiIiIioWTCRt2J+7g7wcVVCoxVx8grL64mIiIiIiKwBE3krd628nok8ERERERGRNWAib+Ui9Q3vOE+eiIiIiIjIKkiayC9atAgRERFwc3ODm5sb+vfvj3///dfwe1EUMXv2bAQEBMDR0RHDhg3DyZMnb7rf1atXIzw8HEqlEuHh4Vi7dq0pn4ZZiwj2AAAkcESeiIiIiIjIKkiayAcFBWHevHk4dOgQDh06hBEjRmDChAmGZP3jjz/G559/jm+++QZxcXHw8/PD6NGjUVRUVO8+9+3bh8mTJ2Pq1KmIj4/H1KlTMWnSJBw4cKClnpZZiQjUjchfyClBQZlK4miIiIiIiIioqSRN5MePH49bb70VnTp1QqdOnfDhhx/CxcUF+/fvhyiKWLBgAd58803cfffd6NatG3766SeUlpZi2bJl9e5zwYIFGD16NGbNmoWwsDDMmjULI0eOxIIFC1ruiZmRVs72CPZ0BAAc56g8ERERERGRxbOTOgA9jUaD3377DSUlJejfvz8uXLiAjIwMjBkzxrCNUqnE0KFD8d9//+GJJ56ocz/79u3DzJkza9x2yy233DCRr6ioQEVFheHnwsJCAIBKpYJK1bBRbP12Dd2+JXUPcMOl3DIcTbmKvqHuUodjMcz5mFLj8JhaFx5P68Njal14PK0Pj6n14TE1L8YcB8kT+ePHj6N///4oLy+Hi4sL1q5di/DwcPz3338AAF9f3xrb+/r6IiUlpd79ZWRk1HmfjIyMeu8zd+5czJkzp9btmzZtgpOTkzFPB5s3bzZq+5agKBIAyLH5yGm0KTkldTgWxxyPKTUNj6l14fG0Pjym1oXH0/rwmFofHlPzUFpa2uBtJU/kO3fujGPHjiE/Px+rV6/G9OnTsXPnTsPvBUGosb0oirVuu56x95k1axZefPFFw8+FhYUIDg7GmDFj4Obm1qDnoVKpsHnzZowePRoKhaJB92kpXhdy8ecPh5CldsSttw6VOhyLYc7HlBqHx9S68HhaHx5T68LjaX14TK0Pj6l50VeGN4Tkiby9vT06dOgAAOjduzfi4uLw5Zdf4rXXXgOgG2H39/c3bJ+VlVVrxL06Pz+/WqPvN7uPUqmEUqmsdbtCoTD6Dd2Y+5haVIgXBAHIKKxAXrkGPq4OUodkUczxmFLT8JhaFx5P68Njal14PK0Pj6n14TE1D8YcA7NbR14URVRUVKBt27bw8/OrUeZRWVmJnTt3YsCAAfXev3///rVKQzZt2nTD+1g7F6UdOni7AAASLrHhHRERERERkSWTdET+jTfewLhx4xAcHIyioiKsWLECO3bswIYNGyAIAl544QV89NFH6NixIzp27IiPPvoITk5OmDJlimEf06ZNQ2BgIObOnQsAeP755zFkyBDMnz8fEyZMwJ9//oktW7Zgz549Uj1NsxAR5IEzWcVIuJyPUeH1VycQERERERGReZM0kc/MzMTUqVORnp4Od3d3REREYMOGDRg9ejQA4NVXX0VZWRmefvpp5OXloW/fvti0aRNcXV0N+0hNTYVMdq2wYMCAAVixYgXeeustvP3222jfvj1WrlyJvn37tvjzMyeRwe5YfeQy4rkEHRERERERkUWTNJFfvHjxDX8vCAJmz56N2bNn17vNjh07at02ceJETJw4sYnRWZeIIA8AQMLl/AY1DCQiIiIiIiLzZHZz5Mk0uvi7QiEXkFeqwuW8MqnDISIiIiIiokZiIm8jlHZyhPnpltKLv5wvbTBERERERETUaEzkbUhEkDsA4DjnyRMREREREVksJvLVxMbGIjw8HNHR0VKHYhKRVfPkOSJPRERERERkuZjIVxMTE4PExETExcVJHYpJRATrRuRPpBVCqxUljoaIiIiIiIgag4m8Deng7QJHhRzFFWqczymWOhwiIiIiIiJqBCbyNsROLkO3wKqGd5c4T56IiIiIiMgSMZG3MdXXkyeSSqVai33nrkLDKR5EREREREZjIm9j9J3r49m5niQ0c9Ux3P9/+7F030WpQyEiIiIisjhM5G2MvnN9YnohKtVaaYMhm7T9VBbWJ6QDAP45niFxNEREREREloeJvI0J8XKCu6MClWotTmcWSR0O2ZiySg3e/vOE4efDqXnIL62UMCIiIiIiIsvDRN7GCIJQrbw+X9pgyOZ8ufUMLueVIcDdAe1aO0OjFbHzdLbUYRERERERWRQm8jZIn8gnsHM9taDkjCJ8v/s8AGDOhG4Y3dUXgK7UnoiIiIiIGo6JvA3Sd67niDy1FK1WxBtrj0OtFTEm3Bejw30xorMPAGDn6Wx2ryciIiIiMgIT+WpiY2MRHh6O6OhoqUMxKX3DuzNZxSir1EgbDNmElYcu4XBKHpzt5Zh9R1cAQK+QVnBzsENeqQrHLuVJHCERERERkeVgIl9NTEwMEhMTERcXJ3UoJuXrpoS3qxIarYiTV1heT6aVU1yBef+eAgDMHN0JAR6OAAA7uQxDq0bltyaxvJ6IiIiIqKGYyNsgQRAQyfXkqYV8uD4JBWUqhPu74aEBoTV+NyLMGwCwjfPkiYiIiIgajIm8jdLPk0/gPHkyob1nc7D2aBoEAfjo7u6wk9c85Qzt5ANBAE5lFOFKfplEURIRERERWRYm8jbK0LmeI/JkIuUqDd76Q7dm/NR+IYgK9qi1jaezPXpU3b49maPyREREREQNwUTeRulH5C/klKCgTCVtMGSVFu04hws5JfBxVeLlWzrXu92IMN08+W2cJ09ERERE1CBM5G2Up7M9gj11TceOc1Semtm57GIs2nEOAPDO+HC4OSjq3XZEmG49+b3nclCu4ioKREREREQ3w0TehnE9eTIFURTx9h8nUKnRYmgnb9zW3f+G23fxd4W/uwPKVVrsO3+1haIkIiIiIrJcTORtWKRhnny+tIGQVVl7NA3/nbsKpZ0M70/oBkEQbri9IAgYVrUM3XZ2ryciIiIiuikm8jbsWud6ltZT88gvrcSH65MAAM+N7Ig2Xk4Nup9hnvypLIiiaLL4iIiIiIisARP5amJjYxEeHo7o6GipQ2kR3QLdIQhAekE5sorKpQ6HrMC8f0/hakklOvq44LHB7Rp8v4EdvGBvJ8PlvDKcySo2YYRERERERJaPiXw1MTExSExMRFxcnNShtAgXpR06eLsAABIucVSemibuYi5WxF0CoFsz3t6u4acXJ3s79G/nBUA3Kk9ERERERPVjIm/jrpXX50saB1m2SrUWb649DgCY3DsY0aGeRu+jenk9ERERERHVj4m8jYsM1jW8i+c8eWqC7/ecx+nMYng62+P1cWGN2oc+kT+ckoeCUlVzhkdEREREZFWYyNs4/Yj88bQCNhmjRrmUW4qvtp4BALx5axe0crZv1H6CPZ3Q0ccFGq2InWeymzNEIiIiIiKrwkTexnXxd4VCLiC3pBKX88qkDocsjCiKePvPEyhXadG/nRfu7hnYpP3pR+W5DB0RERERUf2YyNs4pZ0cYX5uALgMHRnvn+MZ2JGcDXu5DB/cdfM1429meFUivyM5CxotK0SIiIiIiOrCRJ4QEaSbJ8+Gd2SMwnIV5vx9EgDw5LD2aF+1AkJT9AppBVcHO+SVqnDsUn6T90dEREREZI2YyBMiq+bJxzORJyN8tjEZWUUVaNvaGU8Pa98s+1TIZRjSyRsAsO1UZrPsk4iIiIjI2jCRJ0RUda4/kVYILcuZqQHiL+Xj5/0pAID3J3SDg0LebPseaViGjg3viIiIiIjqwkS+mtjYWISHhyM6OlrqUFpUB28XOCrkKK5Q43xOsdThkJlTa7R4Y+1xiCJwZ1QABnVs3az7H9rJG4IAJKUXIr2ADRiJiIiIiK7HRL6amJgYJCYmIi4uTupQWpSdXIZugbqGd/GX2PCObuynfSk4eaUQbg52ePO28Gbfv5eLElHBHgCA7RyVJyIiIiKqhYk8Abi2njwb3tGNpBeU4fNNyQCA18d1gber0iSPM6Kzvryey9AREREREV2PiTwBuNa5Pp5L0NENzP7rJEoqNegV0gr3RQeb7HFGdNEl8nvP5qBcpTHZ4xARERERWSIm8gTgWuf6xPRCVKq10gZDZmlLYiY2nsyEnUzAh3d1g0zWtDXjbyTc3w1+bg4oU2mw//xVkz0OEREREZElYiJPAIAQLye4OdihUq3F6cwiqcMhM1Naqca7f+nWjH90cFuE+bmZ9PEEQcDwMN0ydNtZXk9EREREVAMTeQKgS5wiuJ481WPBljNIyy9DoIcjnh/ZsUUec7h+nnxyFkSRyyISEREREelJmsjPnTsX0dHRcHV1hY+PD+68804kJyfX2EYQhDr/ffLJJ/Xud8mSJXXep7y83NRPyaLp58knsHM9VZN4pRCL91wAALx/Z1c42du1yOMO7NAa9nIZLuWW4WwWl0UkIiIiItKTNJHfuXMnYmJisH//fmzevBlqtRpjxoxBSUmJYZv09PQa/3744QcIgoB77rnnhvt2c3OrdV8HBwdTPyWLxhF5up5WK+LNP45DoxUxrpsfRoT5tthjOyvt0K+9FwB2ryciIiIiqq5lhtbqsWHDhho///jjj/Dx8cHhw4cxZMgQAICfn1+Nbf78808MHz4c7dq1u+G+BUGodV+6schg3Yj8maxilFVq4Ggvlzgiktqyg6k4mpoPF6Ud3h3ftcUff0Rnb+w6nY1tp7LwxND2Lf74RERERETmSNJE/noFBbqSbk9Pzzp/n5mZifXr1+Onn3666b6Ki4sREhICjUaDqKgovP/+++jRo0ed21ZUVKCiosLwc2FhIQBApVJBpVI1KHb9dg3d3hx5Ocrh7WKP7OJKxKdeRa+QVlKHJClrOKZNkV1UgfkbTgEAXhjZHl5O8hZ/LQZ30J0LDqXk4WphKdwcFU3an60fU2vD42l9eEytC4+n9eExtT48pubFmOMgiGbSRUoURUyYMAF5eXnYvXt3ndt8/PHHmDdvHq5cuXLDMvn9+/fj7Nmz6N69OwoLC/Hll1/in3/+QXx8PDp2rN2oa/bs2ZgzZ06t25ctWwYnJ6fGPykL9H+nZDiRJ8NdoRoM8zeLtwZJ5KfTMhy5KkOws4gXu2tgwtXmbuijY3JklgmY3lGDnq35niQiIiIi61RaWoopU6agoKAAbm43XiXKbBL5mJgYrF+/Hnv27EFQUFCd24SFhWH06NH4+uuvjdq3VqtFz549MWTIEHz11Ve1fl/XiHxwcDBycnJu+gLqqVQqbN68GaNHj4ZC0bRRQyl9s/0cvtx2DuMj/PD5vRFShyMpazmmjbH7bA4e+ekIZAKw+ol+6BZo2uXmbmTehmQs3puCOyP98cnE7k3aly0fU2vE42l9eEytC4+n9eExtT48pualsLAQrVu3blAibxal9c8++yz++usv7Nq1q94kfvfu3UhOTsbKlSuN3r9MJkN0dDTOnDlT5++VSiWUSmWt2xUKhdFv6Mbcx5z0CPEEcA4nrhRZ9PNoTpZ+TI1VrtJgzjpdSf20/qHoEeolaTyjwv2xeG8Kdp29CpncDvJmKA2wtWNq7Xg8rQ+PqXXh8bQ+PKbWh8fUPBhzDCTtWi+KIp555hmsWbMG27ZtQ9u2bevddvHixejVqxciIyMb9TjHjh2Dv79/U8K1CfrO9RdySlBQxrkytih2+1mkXC2Fr5sSL43pJHU46B3aCq4OdsgtqeSKCkREREREkDiRj4mJwS+//IJly5bB1dUVGRkZyMjIQFlZWY3tCgsL8dtvv2HGjBl17mfatGmYNWuW4ec5c+Zg48aNOH/+PI4dO4ZHH30Ux44dw5NPPmnS52MNPJ3tEezpCAA4fpnryduas1lF+HbnOQDA7PFd4eog/ZVZhVyGIR29AQDbkrgMHRERERGRpIn8okWLUFBQgGHDhsHf39/w7/ry+RUrVkAURdx///117ic1NRXp6emGn/Pz8/H444+jS5cuGDNmDNLS0rBr1y706dPHpM/HWnA9edskiiLeXHsCKo2IEWE+GNvNfJZvHBHmA4DryRMRERERARLPkW9on73HH38cjz/+eL2/37FjR42fv/jiC3zxxRdNCc2mRQa5Y31COhKYyNuU3w9fxoELuXBQyDDnjq4QBIna1NdhWGdvCAKQmF6IjIJy+LnXv2oFEREREZG1k3REnsyTfkQ+gaX1NiO3pBIf/ZMEAHhhVCcEe5rXsoteLkpEVr0vtydzVJ6IiIiIbBsTeaqlW6A7BAFILyhHVlG51OFQC5j7TxLySlUI83PFo4PqbzopJZbXExERERHpMJGnWlyUdujg7QKADe9swf7zV/Hb4csAgA/v6gaF3DxPC/pEfs+ZHJSrNBJHQ0REREQkHfP8xi6R2NhYhIeHIzo6WupQJHet4R0TeWsliiKWHUjFwz/GAQDu79MGvUI8JY6qfl0D3ODrpkSZSoMDF3KlDoeIiIiISDJM5KuJiYlBYmIi4uLipA5FcpHB7gDAhndWKqe4AjN+OoQ31h5HmUqDAe29MOvWMKnDuiFBEDC8s25UfjvL64mIiIjIhjGRpzpVb3jX0NUFyDJsTcrE2AW7sPVUFuzlMrx1Wxf88mhfuJnBmvE3M7yqvH7rqUy+L4mIiIjIZkm6/ByZry7+rlDIBeSWVOJyXpnZdTEn45VWqvHB+iQsO5AKAAjzc8WC+6IQ5ucmcWQNN6hDa9jLZbiUW4Zz2cXo4OMqdUhERERERC2OI/JUJ6Wd3JDgcRk6yxd/KR+3fbXHkMTPGNQWf8QMtKgkHgCclXbo2043j5/d64mIiIjIVjGRp3pFBHGevKVTa7T4eusZ3LPoP1zIKYGfmwN+ndEXb90eDgeFXOrwGoXL0BERERGRrWMiT/WKNHSuz5c0Dmqc1KulmPy//fhs82motSJui/DHhhcGY2CH1lKH1iT6RP7QxTwUlKkkjoaIiIiIqOUxkad6RVR1rj+RVgitlo3FLIUoilh16BLGfbkLh1Py4Kq0wxeTI/HN/T3g4WQvdXhNFuLljHbezlBrRew+ky11OERERERELY6JPNWrg7cLHBQyFFeocT6nWOpwqAHySirx1C9H8OrvCSip1KBPW0/8+8Jg3NUjCIIgSB1esxnRmeX1RERERGS7mMhTvezkMnQL0I3Kx19iwztzt/N0Nm5ZsAsbTmZAIRfw2tgwLH+sH4JaWd+KAyO66BL5ncnZrBYhIiIiIpvDRJ5u6Np68vmSxkH1K1dpMPuvk5j+w0FkFVWgg48L1j49EE8Naw+5zHpG4auLDvWEq9IOV0sq2cOBiIiIiGwOE/lqYmNjER4ejujoaKlDMRuRVfPk47kEnVk6kVaA8V/vwZL/LgIApvcPwbpnB6FboLu0gZmYQi7D4E66pn3bWV5PRERERDaGiXw1MTExSExMRFxcnNShmA39iHxieiEq1VppgyEDjVbEtzvP4a6Fe3EmqxjerkoseTgacyZ0s9hl5Yw1vGqe/FYm8kRERERkY+ykDoDMW6iXE9wc7FBYrsbpzCKrH+m1BJfzSvHSqngcuJALALilqy/m3h0BT2fL70hvjGGdfSAIwMkrhcgsLIevm4PUIRERERERtQiOyNMNCYJgGJXnXGTp/XE0DeMW7MaBC7lwtpfj44kR+PbBXjaXxAOAt6vS8N5keT0RERER2RIm8nRTEUG6UfgEdq6XTEGpCs8uP4oXVh5DUYUaPdt44J/nB2NS72CrWlbOWFyGjoiIiIhsERN5uimOyEvrv3M5GPvlLvwdfwVymYAXR3fCqif6I8TLWerQJDciTJfI7zmbgwq1RuJoiIiIiIhaBufI003pO9efySpGWaUGjva20UxNahVqDT7dmIzv91yAKAJtWzvji8lRiAr2kDo0s9E1wA3erkpkF1XgwPlcDOnkLXVIREREREQmxxF5uik/Nwd4uyqh0Yo4eYXl9S0hOaMIE77Zi//brUvip/Rtg/XPDWISfx2ZTGB5vQ3bfz4XO9IFiKIodShERERELYqJPN2UIAiIDOJ68i1BqxWxeM8FjP9mD05lFMHL2R7fT+uNj+7qDid7FtDUZXjYtUSeCZ3tOJqah0d+Poy1F+U4eDFP6nCIiIiIWhQTeWoQ/Tz5BM6TN5kKtQaPLz2M99clolKtxYgwH2x4YQhGhftKHZpZG9SxNRRyAam5pTiXXSJ1ONQCsosq8NQvR6DS6C7cHGMjTiIiIrIxTOSriY2NRXh4OKKjo6UOxewYOtdzRN4kKtVaxPx6BFuSMqG0k+GDO7th8fTe8HZVSh2a2XNR2qFvWy8AXIbOFqg0WsQsO4KMwnLIqhZsSEjjeYmIiIhsCxP5amJiYpCYmIi4uDipQzE7+hH5CzklKChTSRuMlVFptHhu+VFsScqC0k6GHx6KxoP9Qmx6WTljjQjjPHlb8dE/STh4IRcuSjvMHt8FAHA8rVDiqIiIiIhaFhN5ahBPZ3sEezoCAI5zVL7ZqDVazFx5DBtOZsBeLsP/pvXGwA6tpQ7L4ugT+biLuSgs54Uma7X26GX8uPciAOCzSZEYH+EPASLSC8qRVVQubXBERERELYiJPDWYYZ58Wr6kcVgLjVbEK78nYF1COhRyAd9O7YmhXD6tUUJbO6Nda2eotSJ2n86ROhwygZNXCjBrzXEAwDPDO+CWrn5wUdrBV3d9EQmcJ09EREQ2hIk8NZi+cz2/MDedVivi9dUJWHs0DXYyAbFTemJEGJvaNcVwltdbrbySSjyx9DDKVVoM7eSNmaM7GX7XxkXX8I6NOImIiMiWMJGnBmPn+uah1Yp4848T+O3wZchlAr66vwfGdPWTOiyLN7Iqkd95OgtaLZehsxYarYjnVhzF5bwytPF0wlf39YBcdq1/hD6R59KYREREZEuYyFODdQt0hyAAVwrKkV1UIXU4FkkURcz++ySWH0yFTAA+nxSJW7v7Sx2WVegd6gkXpR1yiivZxdyKfLYpGbvP5MBRIcd3U3vB3UlR4/fVR+RFkRdwiIiIyDYwkacGc1HaoYO3CwCOyjeGKIp4f10Sft6XAkEAPpkYiQlRgVKHZTXs7WQY3FHXKJDl9dZhw4l0LNxxDgAwf2IEuvi71dom0AlQyAXklapwKbespUMkIiIikgQTeTKKvryeZazGEUUR8zacwg97LwAA5t3dHff0CpI4KutzbZ58psSRUFOdySzCS6viAQAzBrXFHZEBdW5nJwPC/FwBAPG8wEhEREQ2gok8GSUyWNfwLv5SvrSBWJjPN5/GdzvPAwA+uLMbJke3kTgi6zSss67r/4m0QmQVcjkyS1VYrsITSw+jpFKD/u288Pq4sBtuHxFY1YiTiTwRERHZCCby1cTGxiI8PBzR0dFSh2K2Iqs1vON81Ib5ausZfL3tLABg9vhwPNgvROKIrJePq4NhdYXtySyvt0RarYgXV8bjfE4JAtwd8M2UHrCT3/hPVfdAXck9K4WIiIjIVjCRryYmJgaJiYmIi4uTOhSz1cXfDfZ2MuSVqpBytVTqcMzewh1n8fnm0wCAt27rgocGtpU4IuvHZegs2zfbz2JLUibs7WT4dmoveLkob3of/Yj8ibQCaLhiAREREdkAJvJkFHs7GboG6Ea/jrG8/oa+330eH29IBgC8OrYzZgxuJ3FEtmFEVSK/+0wOKtQaiaMhY2w/lYUvtugufH0woZuhJ8fNtPN2hpO9HKWVGpzNKjZhhERERETmgYk8GS0q2AMAE/kbWbL3Aj5YnwQAmDmqE54e1kHiiGxHtwB3tHZRorRSg4MXcqUOhxroYk4JnltxFKIIPNC3DSZFBzf4vnKZgO5Vo/JseEdEtuBoah4mLvoPb649LnUoRCQRJvJkNH0if5SJfJ1+2Z+C2X8nAgCeHdEBz4/qKHFEtkUmEzAiTNf0juX1lqGkQo0nlh5GUbkaPdt44N3xXY3eR2TVeYkN74jImpWrNPjonyTcs+g/HErJw68HUlFQqpI6LCKSABN5MlqP4FYAgKQrhSxdvs7KuFS89ccJAMATQ9vhxdGdJI7INo2oNk+eTRnNmyiKeHV1ApIzi+DtqsSiB3vB3s74P00RQfrO9Wx4R0TW6eCFXIz7cjf+t+s8tCJgX9UI9HAqq8+IbBETeTJasKcjPJ3tUanRIvFKodThmI3Vhy/j9TW6ErdHBrbF62PDIAiCxFHZpkEdvaGQC0i5WorzOSVSh0M38H+7z2N9QjrsZAIWPtATvm4OjdqPfkWNpHReYCQi61JSocY7f57ApO/24UJOCXzdlFg8vTfu7BEAAIi7mCdxhEQkBUkT+blz5yI6Ohqurq7w8fHBnXfeieTk5BrbPPTQQxAEoca/fv363XTfq1evRnh4OJRKJcLDw7F27VpTPQ2bIwgC58lf589jaXjl93iIIjCtfwjevr0Lk3gJuSjt0KetJwBdAzUyT/+dzcG8f08BAN4ZH47oUM9G7yuolSNaOSmg0ohISi9qrhCJiCS150wOxnyxCz/vSwEA3BcdjE0zh2JkF1/0rjpnHmYiT2STJE3kd+7ciZiYGOzfvx+bN2+GWq3GmDFjUFJScwRt7NixSE9PN/z7559/brjfffv2YfLkyZg6dSri4+MxdepUTJo0CQcOHDDl07EpTOSvWZ+QjhdXxUMrAvf3aYPZ47syiTcDwztzGTpzlpZfhmeWH4VWBO7pGYSp/UKatD9BEDhPnoisRkGZCq/9noAHFx9AWn4Zglo54pdH+2LePRFwd1QAgOHi57HL+axEIrJBdlI++IYNG2r8/OOPP8LHxweHDx/GkCFDDLcrlUr4+fk1eL8LFizA6NGjMWvWLADArFmzsHPnTixYsADLly9vnuBtHBN5nY0nM/D8iqPQaEVM7BWED+/sBpmMSbw5GNnFFx+sT8LBC7koKlfB1UEhdUhUpVylwZNLDyO3pBLdAt3w4V3dmuXiV0SQB3YkZyP+UgHQvxkCJSKSwNakTLyx9jgyCysAANP7h+DVsWFwVtb82h7q5YTWLvbIKa7EibQC9AppfFUTEVkeSRP56xUU6JoUeXrWPBHt2LEDPj4+8PDwwNChQ/Hhhx/Cx8en3v3s27cPM2fOrHHbLbfcggULFtS5fUVFBSoqKgw/Fxbq5n2rVCqoVA3rBKrfrqHbW7qufs4AgJSrpcjML4Gns73EETW/mx3T7cnZeGb5Mai1IiZE+uODO7pAo1FDw4viZiHI3R6hXk64eLUUO05lYmxXX5v7nJojURTxxtqTOJ5WgFZOCnxzXyTk0EKl0hq9r+uPZ1d/FwBA/KU8HmMLxc+odeHxNE5eaSU+WJ+MvxLSAegS9Y/u7Iro0FYAxDpfxx7BHticlIX953IQEeBq8hh5TK0Pj6l5MeY4CKKZtHQWRRETJkxAXl4edu/ebbh95cqVcHFxQUhICC5cuIC3334barUahw8fhlKprHNf9vb2WLJkCaZMmWK4bdmyZXj44YdrJOx6s2fPxpw5c2rdvmzZMjg5OTXDs7NOHx6VI6tcwONhGnRtZRZvoxaTlC/g/07JoBEF9PDSYmpHLeQciDc7ay7KsDNdhj7eWjzQwfhEkZrf7gwBv1+QQ4CIp8O16OTefOeOwkrg7cN2ECBiXh8NHOTNtmsiIpM6dlXAbxdkKFYJECBieICIcUFa2N/kPLb9ioA/UuTo1kqLx8L4d47I0pWWlmLKlCkoKCiAm5vbDbc1mxH5Z555BgkJCdizZ0+N2ydPnmz4/27duqF3794ICQnB+vXrcffdd9e7v+vLNEVRrLd0c9asWXjxxRcNPxcWFiI4OBhjxoy56Quop1KpsHnzZowePRoKhW2U8O4oO461x9Jh79cRt47sIHU4za6+Y/rfuav48Zej0IhajAn3wYJJEVDIuQCEOXI/dxU7lxzGuVIHjB07FBqN2uY+p+bkcEoe/jhwCICIV2/pjBmDQpu0v7o+owvP7kJ6QTkCu/VD37YsM7U0tvi31JrxeN5cdlEF5qxLwsbTun4uHX2cMfeuboisWlLzZgIvF+CP7w4grUKJsWOHmXx6H4+p9eExNS/6yvCGMItE/tlnn8Vff/2FXbt2ISgo6Ibb+vv7IyQkBGfOnKl3Gz8/P2RkZNS4LSsrC76+vnVur1Qq6xzdVygURr+hG3MfS9UzxBNrj6Uj4UqRVT/n6sd0//mreOLXo6hQazGqiw++mdK4Na+pZQzo4ANnezmullTiVFYpwqumhNjS59RcZBaW49mVCVBrRdwe4Y8nh3VotqaQ1Y9nVLAH0gsycDK9GIM61X3OJ/PHz6h14fGsTRRF/HEsDXP+TkR+qQp2MgFPD2uPmBEdoLRreDlRZBtPOChkyCtV4VJBBTr4mL68HuAxtUY8pubBmGPQLBlIfn5+o+4niiKeeeYZrFmzBtu2bUPbtm1vep+rV6/i0qVL8Pf3r3eb/v37Y/PmzTVu27RpEwYMGNCoOKluUcGtAADxl/JhJjM0TOrQxVw8siQO5SothnX2RuwDPZnEmzl7OxkGd/QGwO71UqpUa/H0r0eQXVSBzr6u+HhihMlWdoioWk8+4XKBSfZPRNRU6QVlePSnQ5i5Mh75pSp0DXDDn88MxItjOhuVxAOAQi4zNCDmevJEtsXoLGT+/PlYuXKl4edJkybBy8sLgYGBiI+PN2pfMTEx+OWXX7Bs2TK4uroiIyMDGRkZKCsrAwAUFxfj5Zdfxr59+3Dx4kXs2LED48ePR+vWrXHXXXcZ9jNt2jRDh3oAeP7557Fp0ybMnz8fp06dwvz587Flyxa88MILxj5duoEwf1co7WQoKFPhQk7Jze9gwY6m5uGhH+NQWqnB4I6t8e2DvYz+Y0vSGBHGZeik9t66kzickgdXBzt8N7UXnOxNVwymL0eN5xJ0RGRmRFHE8oOpGPP5Lmw7lQV7uQyv3NIZf8QMRNeAhpXS10W/DF3cxdzmCpWILIDRifx3332H4OBgAMDmzZuxefNm/Pvvvxg3bhxeeeUVo/a1aNEiFBQUYNiwYfD39zf8018okMvlOH78OCZMmIBOnTph+vTp6NSpE/bt2wdX12ulQ6mpqUhPTzf8PGDAAKxYsQI//vgjIiIisGTJEqxcuRJ9+/Y19unSDSjkMnQL1P3hseZl6E6kFWLaDwdRXKFGv3ae+N/U3nBQMIm3FMPCdCPyx9MKkFVUu9klmdaqQ5fwy/5UCALw5X1RCG3tbNLH61aVyF/OK8PVYh5vIjIPl3JL8eDiA5i15jiKKtSICvbA+ucGIWZ4hyb32eldlcgfTuGIPJEtMXpYJD093ZDIr1u3DpMmTcKYMWMQGhpqdKJ8s3JsR0dHbNy48ab72bFjR63bJk6ciIkTJxoVDxkvKtgDh1PycOxSPu7ueeP+BpYorQR456dDKCpXIzq0FRZPj4bjzVrIklnxcXVA90B3HE8rwM7TOTBtGknVJVzOx1t/nAAAvDCyE0aEmX7OupuDAu28nXE+uwQJlwswPKz+pUqJiExNqxXx876LmL8hGWUqDRwUMrw8pjMeHtgW8mZqTNezjQdkgm5J4KzCcvi4OTTLfonIvBl9CbBVq1a4dOkSAGDDhg0YNWoUAF1SruEC2jZHPy/LGkfkT2cWITZRjoIyNXq28cCPD/eBs9Is+kOSkfTl9TtOZ0scie3IKa7Ak0sPo1Ktxaguvnh2RMutbBFVNU+e5fVEJKXz2cWY/L99mP13IspUGvRt64kNzw/BjMHtmi2JBwBXBwU6++lWWTrEUXkim2F0In/33XdjypQpGD16NK5evYpx48YBAI4dO4YOHaxvCTK6MX0in5ReiHKV9VzIKVdp8MhPR1CiFtA90A1LHukDFybxFkufyO89exVqLrNrcmqNFs8uO4orBeVo19oZn0+ONPmSSNVFVJXXs+Fd06Tll0Grtf5GpkTNTa3R4rud5zDuy92Iu5gHZ3s53r+zG5Y/1s9k04uiQ3UNiDlPnsh2GJ3If/HFF3jmmWcQHh6OzZs3w8XFBYCu5P7pp59u9gDJvAW1ckRrF3uoNCJOXmn4uofm7nBKHjKLKuCqEPHj9F5wc+ByHJase6A7WrsoUVKpwbnClksobdX8Daew7/xVONvL8d3Ulv/8RFRdYEy4bBsrapjCT/9dxMB52zDl+/2oUFvPRVoiU0vOKMI9i/7D3H9PoUKtxeCOrbFx5hBM7Rdi0guanCdPZHuMHmKsrKzEyy+/XOt2a+gIHxsbi9jYWE4RMIIgCIgK9sCWpCwcu5SPXiGtpA6pWew7dxUA0NldhLsjk3hLJ5MJGNbZG78fvoyT+UzkTemv+Cv4v90XAACf3huJjr4ts6ZxdeH+brCTCcgprkRafhmCWjm1eAyWbPeZbMz5+yQAYP/5XLyx5gQ+vdd0SwYSWQOVRotFO87h621noNKIcHWww9u3h+PeXkEt8tnRj8ifvFKIkgo1pwIS2QCjR+R9fX3xyCOPYM+ePaaIR1IxMTFITExEXFyc1KFYFGucJ7//vC6R7+jO0TxrMbyzrrw+mYm8ySSlF+K13xMAAE8Na49x3f0licNBIUeYv+4CAsvrjXMhpwQxvx6BVgT6tvWETABWH7mMb3eelzo0IrNVVK7CXQv34vPNp6HSiBjVxQdbXhyKSb2DW+wCmL+7IwI9HKHRilb1fYyI6md0Ir98+XIUFBRg5MiR6NSpE+bNm4crV66YIjayEFHBuqvAxy5ZRzlXaaXa0CSroxsTeWsxoL0XBAHIKBOQXlAudThWp6BUhSeWHkaZSoPBHVvj5TGdJY0ngg3vjFZYrsKMn+JQWK5r8Pnzo33w7viuAICPN57ChhMZEkdIZJ7+PHYFJ9IK4e6owJf3ReH/pvWGrwSd43tznjyRTTE6kR8/fjxWr16NK1eu4KmnnsLy5csREhKC22+/HWvWrIFarTZFnGTGIoLdIQjApVzrWLf5cEoeVBoRAe4O8FRKHQ01l1bO9ugeoOvq+1/V1AlqPi/9Fo/U3FIEtXLEV/f1aNaOzI0RqW94d4kj8g2h0Yp4bvlRnMsugb+7A76d2gtKOzmmDwjFtP4hEEVg5spjOJHG15PoeluSMgEAjw9phwlRgZJNQ9HPkz900ToGVojoxoxO5PW8vLwwc+ZMxMfH4/PPP8eWLVswceJEBAQE4J133kFpaWlzxklmzM1BgfbeuqaH1lDOpZ8f37edJzgl1LoM7OAFANhzlol8c0q5WoItSZmQywR8N7UXWjnbSx2SYUT+eFoBO683wPwNp7AjORsOChn+b1pv+LheG0185/ZwDO7YGmUqDR79KQ4ZrGghMiiuUOO/qr8pY8J9JY1FP0/+aGoe1Bou0UJk7RqdyGdkZODjjz9Gly5d8Prrr2PixInYunUrvvjiC6xduxZ33nlnM4ZJ5s6a5snvq5of36+tdTTuo2sGVSXye89dZXLXjDYn6kaj+rb1RNcAd4mj0eno4wIHhQzFFWqczymWOhyztvrwZfxvl24O/CcTI9EtsOYxtJPL8M2Unujg44LMwgrM+DkOpZWsviMCgF2ns1Gp0SLEywkdfFwkjaWTjytcHexQUqnBqYwiSWMhItMzOpFfs2YNxo8fjzZt2mDZsmWIiYlBWloafvnlFwwfPhwPPPAAVqxYgR07dpggXDJX1pLIl1SoDc2x+rb1lDgaam5RQR6wl4nIK1UhMd16lkuU2qaTukRe6tGo6uzkMnSvSkjjWV5fryOpeZi15jgA4NkRHTA+MqDO7dwdFfhhejRaOSlwIq0QL66M58UwIgBbqi5kju7iK/nKDjKZYFg9iPPkiayf0Yn8ww8/jICAAOzduxfHjh3DM888Aw8PjxrbtGvXDm+++WZzxUgWoHoib8lf7uIu5kKjFRHsqev+StbF3k5mWIlg95kciaOxDjnFFTiUovvCOLqrn8TR1KQvr09gw7s6pReU4Ymlh1Gp0WJMuC9mjup0w+3beDnhf9N6w14uw4aTGfh0U3ILRUpkntQaLbYlZwEARpvJhcxozpMnshlGJ/Lp6en47rvvEB0dXe82jo6OePfdd5sUGFmWMD9XOChkKCpX43xOidThNJq+rL5/Oy+JIyFTCTMk8tkSR2IdtiVlQSsC3QLdzO7iV0RVw7t4LkFXS1mlBo//fBjZRRUI83PFF5OjIGtAg8LoUE/Mvbs7AGDhjnP4/fBlU4dKZLYOpeQhv1QFDyeFYSRcar2r4jiUkgtRtNyBFSK6OaMTeScnJ8P/l5WVobCwsMY/sk3Vy1gtubx+/3ndyGI/JvJWq7OH7ovNoYt5KKvUSByN5duUqFuSbEy4eY3GA0Bk1Yh84pVCVKrZ+ElPFEW8ujoBx9MK4Olsj/+b1hvOSrsG3/+eXkGIGd4eADBrTQIOXmAJL9kmfX+QEWE+sJM3uu1Us4oM9oBCLiCzsAKX88qkDoeITMjos05JSQmeeeYZ+Pj4wMXFBa1atarxj2zXtfJ6yyznKipXGZZW6t+eiby18nEA/N0dUKnR4sAFdq9vitJKtWGKwpiu5lFWWl2IlxPcHRWo1GiRzMZPBgt3nMPf8VdgJxOw8IGeCPZ0uvmdrvPS6M4Y180PKo2IJ5YeQspVy63EImoMURQNibw59QdxUMgNDSs5T57IuhmdyL/66qvYtm0bFi5cCKVSie+//x5z5sxBQEAAfv75Z1PE2GJiY2MRHh5+w2kDVL+oYN2FHEsdkdfPjw/1coK/u3mVCFPzEYRr3es5T75pdp3OQYVaizaeTujs6yp1OLUIglCtvD5f2mDMxKaTGfhko25u+3sTujW6+kgmE/D5pCh0D3RHXqkKj/50CAVlquYMlcisnckqRmpuKeztZBjc0VvqcGrQz5OP4zx5IqtmdCL/999/Y+HChZg4cSLs7OwwePBgvPXWW/joo4/w66+/miLGFhMTE4PExETExcVJHYpFimrjAQA4lV6EcpXllSyzrN52DKqquNjDRL5JrpXVS9+tuT6RbHhncCqjEDNXHgMATOsfgil92zRpf472cnw/vTf83BxwNqsYzyw7wrWryWboR+MHtvcyampKS9DPkz+cwhF5ImtmdCKfm5uLtm3bAgDc3NyQm6s7SQwaNAi7du1q3ujIogS4O8DbVQm1VjSUqFuSfeeqGt2xrN7q9W/vCUEAkjOLkFlYLnU4Fkmt0WJrkq5b8xgz61ZfnX5EPsHGG97lllRixk+HUFKpwYD2Xnj79vBm2a+vmwO+n94bjgo5dp/Jwey/T7LBFtmETVWJ/CgzKqvX0zfeO51ZjPzSSomjISJTMTqRb9euHS5evAgACA8Px6pVqwDoRuqvX4aObIsgCBa7nnxBmQonr+i+6HNE3vq1crI3NGdkeX3jHLyYi4IyFTyd7c2mW3NdIqvOSaczi1BaqZY2GImoNFo89cthXM4rQ4iXE2Kn9ISiGRtzdQt0x4L7oiAIwC/7U/HTfxebbd9E5iirsBzxVd9zRnUxv0Tey0WJdt7OAIDDKSyvJ7JWjVpHPj4+HgAwa9Ysw1z5mTNn4pVXXmn2AMmy6BP5oxaWyMddyIVWBNq1doavm4PU4VALGNyxNQAuQ9dYm07qRqNGhvlA3oBly6Ti6+YAXzcltCJwIs02V1aZ/ddJHLiQCxelHf5vWm+0crZv9se4pasfXhsbBgB4b10itletrU1kjbZUVSNFBnuY7XeG6BDOkyeydkYn8jNnzsRzzz0HABg+fDhOnTqF5cuX48iRI3j++eebPUCyLD30I/Kp+ZLGYSz9+vH9WFZvMwZ10DUn2ns2B1otS4GNUaNbsxmX1evZ8jz5pftT8OuBVAgC8OV9UehkwqaETwxph3t7BUErAs8uO8qVAshqbUnSnf9Gd/GROJL69Q6tWk+eneuJrFaTa+vatGmDu+++G5GRkc0RD1m47kHuEAQgLb8M2UUVUofTYIb58Syrtxk9QzzgZC9HTnElkjJsc6S2sU5eKURafhkcFXJDZYM505fXx9vYPPn/zuVg9l8nAQCv3hKGkSYuARYEAR/e1R192nqiuEKNR3+KQ06x5fwdIGqIkgo19pzVTckaHW6+FzL1nesTLhdYZANiIro5oxJ5rVaLH374Abfffju6deuG7t2744477sDPP//M5jYEAHB1UKCDtwsAy5knn196LZHr285T4miopSjt5IZ+CJwnbxx9k6chnVrDQSGXOJqbu9bwLl/aQFpQytUSPP3rEWi0Iu6MCsCTQ9u1yOPa28nw3YO9EOLlhMt5ZXhi6WEmEWRVdp/JRmXVspudfF2kDqdeIV5OaO1ij0qN1iIbEBPRzTU4kRdFEXfccQdmzJiBtLQ0dO/eHV27dkVKSgoeeugh3HXXXaaMkyzItYZ3ljEv68CFXIgi0MHHBT6u5jnXjUxDP5rMZeiMs+mkftk58x2Nqi4i0AMAkHK1FHkl1t/BuahchRk/HUJ+qQqRQe6Yd09Eiy4P2MrZHounR8PNwQ6HU/Lw+uoEXuwnq7E5UTc/flQX8112E9BVyPTmPHkiq9bgRH7JkiXYtWsXtm7diqNHj2L58uVYsWIF4uPjsWXLFmzbtg0///yzKWMlC6FfT95SRuRZVm+79In8wYu5KKvkqGFDpF4txamMIshlAkaEme/80OrcnRRo21rXwTnBykemNFoRM1cew5msYvi4KvHd1N6SVE108HHBogd7QS4T8MexK/hm29kWj4Gouak1Wmw7VTU/3gyXnbse58kTWbcGJ/LLly/HG2+8geHDh9f63YgRI/D666/j119/bdbgWlpsbCzCw8MRHR0tdSgWTT8in3CpwCKaiO3XN7pjIm9z2nu7wN/dAZVqLQ7yi06DbErUjcb3CfU0SfdzUzGU11vIBcbG+mxTMrYkZcHeTob/TesNP3fpqowGdmiN9yd008W1+TTWJVyRLBai5nA4JQ95pSq4OyoQHWq+y27q6efJH07Ns4jvY0RknAYn8gkJCRg7dmy9vx83bpxhWTpLFRMTg8TERMTFxUkdikXr7OsKR4UcRRVqnMsuljqcG8otqcSpqs7K/Tg/3uYIglCtvJ7L0DXEJkO3evMfjaouoqpzvTU3vPvzWBoW7jgHAPj4ngjDRVUpTenbBo8OagsAeGlVvMVUahHVRd+tfkSYD+zkTe4XbXLhAW5wVMiRX6oy++9jRGS8Bp+FcnNz4etb/xc3X19f5OVxDg4BdnIZugfqRr/MfT35A1Wj8Z19XeHlopQ4GpLCoI66ZejY8O7mcksqDSWallBWWl1k1Yh8/OV8q5yvHX8pH6/+ngAAeHJoe9zZI1DiiK5549YuGBHmgwq1FjN+OoS0/DKpQyIyWvVlNy3l/KeQywwX9DhPnsj6NDiR12g0sLOzq/f3crkcarW6WYIiy2cp8+SvldVzNN5WDerQGoIAnMooQlZhudThmLWtSZnQikDXADcEtXKSOhyjdA1wh1wmILuoAhlWdpwzC8vx+NJDqFBrMSLMB6/c0lnqkGqQywR8dX8PhPm5Iqe4AjN+OoSSCn5fIMtyLrsYF6+Wwl4uw5BO3lKH02DRnCdPZLXqz8yvI4oiHnroISiVdY9aVlRwrVi6xtC5PjVf0jhuZl9VIt+/PefH2ypPZ3t0C3DH8bQC7D6Tg3t6BUkdktkylNVbSLf66hzt5ejk64qk9ELEXyqAv7uj1CE1i3KVBo8vPYzMwgp09HHBl/dFQS4zv07aLko7fD+9N+6M3Yuk9EI8v+IYvpvayyxjJaqL/vzXv70XXJQN/vosud5V8+TjUpjIE1mbBo/IT58+HT4+PnB3d6/zn4+PD6ZNm2bKWMmC6BP55Mwis+0GnlNcgdOZujljfdsykbdlhnnyZ1leX5+ySg12V/URsLT58XqRVraevCiKmLXmOOIv5cPdUYHvp/eGq4NC6rDqFdTKCf+b1hv2djJsScrE/A2npA6JqMEsraxer0cbD8gE4FJuGTKtrBqJyNY1+JLijz/+aMo4yMr4uzvAx1WJrKIKHE8rQJ+25le6fuC87up0mJ+rRXXfpuY3qGNrLNxxDrvP5ECrFSHjKGEtu85ko1ylRVArR4T5uUodTqNEBHlgRdwlJFhJw7vvdp3H2qNpkMsELHqgJ0K8nKUO6aZ6tmmFT++NxHPLj+J/u86jXWtn3NenjdRhEd1QVlG5YargqC6Wlci7OigQ5ueGxPRCHLqYh9si/KUOiYiaifm33CSLJAjCtfL6S+bZYGXfed3oK8vqqVdIKzgq5MgprjCsYkA1bTp5raxeECzzQkdEtYZ3lr4U07ZT10a03x0fjgEdWkscUcPdERmAF0Z1BAC89ccJ/HeOlTBk3rYlZUEUdecQKZd0bCz9PPk4zpMnsipM5MlkzL3h3b5zXD+edJR2ckPDwz1nuQzd9dQaLbaessxl56rr7OcKpZ0MReVqXLxaInU4jXYmswjPLT8GUQTu79MGU/uFSB2S0Z4f2RF3RAZArRXx1C9HcJ5LY5EZM5TVW9hovJ5+nvwhzpMnsipM5MlkzLnhXVZROc5ll0AQgH6cH0/gMnQ3EncxD/mlKrRyUqB3SCupw2k0hVyGrgFuAGCx5fV5JZWY8fMhFFeo0aetJ+bc0dUiKyQEQcDHEyPQo40HCspUePSnQ8gvrZQ6LKJaSivVhv4poyxsfrxe76oR+cQrhSjmihFEVoOJfDWxsbEIDw9HdHS01KFYhYggDwgCcKWg3OyW9dpfNT8+3N8N7k7m2xyKWs6QqoZ3By7kolxlng0apbIpMQMAMLKLL+zklv1nIyLIA4CuvN7SqDRaxCw7gpSrpQhq5YhFD/SEvZ3lHg8HhRz/m9obgR6OuJBTgqd+OQKVRit1WEQ17D6Tgwq1ZfcH8Xd3RKCHI7SieQ6uEFHjNOgbQM+ePZGXp5vn/N5776G0tNSkQUklJiYGiYmJiIuLkzoUq+CitEMnH90fvaNmVl7Psnq6XgcfF/i5OaBSreU8wmpEUaw2P94yR6OqiwzWd663vBH5D9Yl4r9zV+FkL8f/TesNL5e6l4O1JN6uSix+qDec7eXYd/4qZv+dBNGy2xeQldlSVVY/qouvRVa/6HGePJH1aVAin5SUhJIS3XzCOXPmoLiYc9moYa41vMuXNI7rHdCvH89EnqoIgmBYho7l9dckphciLb8MDgoZBldNP7Bk+hH5E2kFFjX6u+xAKn7alwIA+HxSFLr4u0kcUfMJ83PD11N6QCYAqw6nYfUFmUX3MCDrodGK2HYqC4DlX8jkPHki69Og5eeioqLw8MMPY9CgQRBFEZ9++ilcXFzq3Padd95p1gDJskW18cDKQ5fMqpQrs7Ac53NKIBOAaDNcFo+kM6hja/x2+DJ2nc7GG7d2kTocs6AfjR/S0RuO9nKJo2m6tl7OcFXaoahCjdOZRega4C51SDd1NDUP7/x5AgDw0uhOGNvNT+KImt+IMF+8eVs43l+XiN2ZMoxesBc92njg7h6BuD0igEuEkiSOpObhakkl3BzsLP77QnRVIn80NR9qjdbip0kRUQMT+SVLluDdd9/FunXrIAgC/v33X9jZ1b6rIAhM5KkG/Yh8wuV8aLQi5GawPre+rL5rgDvcHTk/nq4ZVLWE16mMImQVlcPH1fKWGWpumxL13eqtI3mUyQREBLtj79mrSLhcYBGJfOz2s1BrRYzr5odnRnSQOhyTeWRgKPxcFfjm36NILpDhaGo+jqbm4711iRjW2Qd39wjEiC4+UNpZ/gUlsgz6svrhYT5QWHji29HHBW4OdigsVyMpvQjdg8z/3EdEN9agRL5z585YsWIFAEAmk2Hr1q3w8fExaWBkHTr5usLJXo6SSg3OZhWjsxk0itmvL6vn+vF0HS8XJboFuuFEWiH2ns3BXT2CpA5JUpdyS5GUXgiZAIwMs55zfkSQR1Uin4/7+7SROpwbupJfZijtffmWzhY9R/dmBEHAmHBfqC9qET14OP45mYW1R9Nw8kohNidmYnNiJtwc7HBbRADu6RmIXiGtrPr1IOkZlp2z8LJ6QHcRs1dIK2xPzkbcxVwm8kRWwOjLi1qtlkk8NZhcJqB7oO6PxbFLeRJHo7OP8+PpBgZ1qFqG7jTnyeu/xPZp62lVpc2RVV9g4y+Zf8O7VYcuQSsCfdt6or133VParJG3qxIzBrfD+ucGY9PMIXhyaHv4uTmgsFyN5QdTMfHbfRj6yQ58vvk0LuRwPj01v3PZxTifUwKFXMDQTpbfHwTgPHkia9OoOqFz587h2WefxahRozB69Gg899xzOHfunNH7mTt3LqKjo+Hq6gofHx/ceeedSE5ONvxepVLhtddeQ/fu3eHs7IyAgABMmzYNV65cueF+lyxZAkEQav0rLzevJdBsRVQbDwDm0fDuSn4ZUq6WQi4TDOuqElWnX4Zu99kciDbePlu/7NyYcOsoq9fTN7xLzixCWaX5LjWo1mixMu4SAGBKX/OuHDClTr6ueH1cGPa+PgK/zuiLe3oGwdlejtTcUny19QyGf7oDdy3ci6X7LiKvhGvRU/PQX8js184Lrg7WMQ1PP08+7mKezf99I7IGRifyGzduRHh4OA4ePIiIiAh069YNBw4cQNeuXbF582aj9rVz507ExMRg//792Lx5M9RqNcaMGWPokF9aWoojR47g7bffxpEjR7BmzRqcPn0ad9xxx0337ebmhvT09Br/HBw431UKParmyR81g4Z3+rL6boHuVvOHmZpXr9BWcFDIkF1UgeTMIqnDkUxeSSUOXtCN2lhDWWl1/u4O8HZVQqMVkZhuvqPyO09nI72gHK2cFLjFSnoUNIVcJmBgh9b4bFIk4t4ahS/vi8LQTt6QCbq/L2//eRJ9PtqCx34+hH+Pp6NCbb4Xacj86RN5S+9WX11EkDvs5bq/b5dyy6QOh4iaqEFz5Kt7/fXXMXPmTMybN6/W7a+99hpGjx7d4H1t2LChxs8//vgjfHx8cPjwYQwZMgTu7u61Lg58/fXX6NOnD1JTU9GmTf0jFIIgwM+PX3zMQVSwbuT7dGYRSirUcFYa/bZrNvpGdyyrp/oo7eTo184LO5Kzsft0DsL8rGeZL2NsPZUFrQiE+7sh2NNJ6nCalSAIiAxyx5akLMRfKkCvEPPsRr3sQCoA4J6eQXBQsMFbdU72dpgQFYgJUYHIKirHX8euYM2RNCSmcz49NV1OcQWOpOqmA47sYj2JvINCjm6BbjiSmo+4i7lo42Vd53YiW2N0RpWUlIRVq1bVuv2RRx7BggULmhRMQYFuZMTTs/4vVQUFBRAEAR4eHjfcV3FxMUJCQqDRaBAVFYX3338fPXr0qHPbiooKVFRUGH4uLCwEoCvtV6lUDYpdv11Dt7clXk5y+LopkVlYgaMpV9FXwiVc9p3TzXuODnG/6bHiMbU+DT2mA9p5YkdyNnaezsJD/YNbIjSzs/FEOgBgZFhrs/0MNOUz2tXfFVuSsnAsNQ8qlfk1NUwvKMf2ZF2Tu3t7BpjtMWhujTmmrRzkmN4vGNP7BeN0ZhH+OJaOvxLSkVlYgeUHU7H8YCqCWzliQqQ/JkT5I9TL2VTh03Us9e/ophPpEEWga4ArvJ3tLC7+G+nZxgNHUvNx8EIO7ogw/iKFpR5Tqh+PqXkx5jgIopGTZIKDg/H555/j3nvvrXH7qlWr8PLLLyM1NdWY3RmIoogJEyYgLy8Pu3fvrnOb8vJyDBo0CGFhYfjll1/q3df+/ftx9uxZdO/eHYWFhfjyyy/xzz//ID4+Hh07dqy1/ezZszFnzpxaty9btgxOTrxa2RwWJ8uQkCvDHW00GBkozbysq+XAe0ftIBNEzIvWQMkBLqpHeikwL94OCkHE3D4aKCx71SGjVWqANw7JodIKeCVCjSArzHuS8gR8e0oObwcRb/UwvxLsfy/JsOGyDB3cRDzb1fziM3daEThTKOBQtoD4qwIqtNdG40NdRPT21qKnlwhnzrCiOvzfKRlO5MkwLkiDscHWNZf8eK6A75Pl8HUU8UYUzy1E5qa0tBRTpkxBQUEB3NxuXBVq9Ij8Y489hscffxznz5/HgAEDIAgC9uzZg/nz5+Oll15qdNDPPPMMEhISsGfPnjp/r1KpcN9990Gr1WLhwoU33Fe/fv3Qr18/w88DBw5Ez5498fXXX+Orr76qtf2sWbPw4osvGn4uLCxEcHAwxowZc9MXsHp8mzdvxujRo6FQ8JvB9S67XkDCpjMod/HHrbdGSRLD6iNpwNGTiAzywF3j+950ex5T69PQYyqKIn48vwuZRRVo3aUvBtrYUoVbkrKgOngMgR4OeGziYLMtSW7KZ7RfSSW+nbcD2eUCBg0fDTdH8/mMqzVazP18N4AKPH1LBG6N8Jc6pBZjivNuaaUaW5Ky8Wf8Few5exUXiwVcLJbjz1QBQzu2xoSoAPQO8YBKI6JSrUWlWosKtRaVGi0q1JprP9e4/drPqmq332xb3f41qNSI8HK2x5ND2mJsV1/IZOb5GWsqS/w7WlapwWuHtgPQ4sk7BiLc37qmV/UrqcT383Ygs0xA/2Gj0MrJuBVJLPGY0o3xmJoXfWV4QxidyL/99ttwdXXFZ599hlmzZgEAAgICMHv2bDz33HPG7g4A8Oyzz+Kvv/7Crl27EBRUu8RRpVJh0qRJuHDhArZt29bg5FpPJpMhOjoaZ86cqfP3SqUSSqWy1u0KhcLoN3Rj7mMLeoV6ATiDhMuFkr0+B1PyAQD927c2KgYeU+vTkGM6qKM3Vh+5jH3n8zAszLb6bWxN1k1BGdPVD/b25r/sXGM+o74eCrTxdEJqbimSMksxqGq1AnOw80wmMgor0MpJgdsiA6Gws73yoeY877orFLindxvc07tNrfn0W05lY8up7GZ5HGNlFVXg+VUJ6B7ojtfGhpnVe7C5WdLf0R1nclGu0iLQwxERwZ5meyGzsXw9FGjv7Yxz2SVISCvGqEY287OkY0oNw2NqHow5BkYn8oIgYObMmZg5cyaKinQdnV1dXY3dDQDdqNezzz6LtWvXYseOHWjbtm2tbfRJ/JkzZ7B9+3Z4eRk/MiaKIo4dO4bu3bs3Kk5quu6B7pAJQEZhOTIKyuHn3rIrCIiiiAPndR24+9vY6Co1zpBOrbH6yGXsOpODWVIH04LUGi22Jum7NVv3BYyIIHek5pYi/nK+WSVRyw/qpqhN7BUEpQ0m8abk4+qAGYPbYcbgdkjOKMKao5fx17ErSC8oh0IuQGknh72dDEo72XX/lcNeXsdtVT8r67m97p9lUMhl2JqUhf/tOofjaQV4cPEBDOrQGq+NDUP3IHepXyabtqWqW/3ocF+rS+L1okM9cS67BHEpuY1O5IlIek1qH97YBF4vJiYGy5Ytw59//glXV1dkZOjWLHZ3d4ejoyPUajUmTpyII0eOYN26ddBoNIZtPD09DSNF06ZNQ2BgIObOnQsAmDNnDvr164eOHTuisLAQX331FY4dO4bY2NgmxUuN56y0QydfV5zKKMKxS3kY696ypaKXcsuQll8GhVxArxCuH083N7CDLrFLSi9EdlEFvF1rV+1Yo0MpecgrVcHDSYHoUOv+rEQGeWBdQjoSLudLHYrBlfwyQ5O7+/rY7trxLaGznytmjeuC18eGQRTR4uXt3QLd8UC/Nvhm21n8eiAFe87mYM83e3BbhD9eHtMZbVtbYXMKM6fRith6SpfIj7KibvXX6x3qiRVxl3DoYp7UoRBRE0jawmnRokUoKCjAsGHD4O/vb/i3cuVKAMDly5fx119/4fLly4iKiqqxzX///WfYT2pqKtLT0w0/5+fn4/HHH0eXLl0wZswYpKWlYdeuXejTp0+LP0e6pkcbDwDA0Uv5Lf7Y+87rSoUjgzzgZC/d8ndkOVq7KA1zI/eezZE4mpaz6aTuS+zIMF/Yya27y19E1chn/CXzWUt+ZdwlaEWgXztPtPd2kTocmyAIgmRz1Fu7KDH7jq7Y9tIw3NUjEIIArE9Ix+jPd+KtP44jq6hckrhs1bFLecgproSrgx36tjPPZSmbg/4i7fHLBShXseEdkaWSNKO5WcP80NDQm24DADt27Kjx8xdffIEvvviiKaGRCUQFe2D5wUs4lprf4o+9n2X11AiDO7VGYnohdp3Jxp09AqUOx+REUcSmRF3V05iu1jsapdet2pSfrMJy+Li17JSf66k1WqyMuwQAuJ+j8TYl2NMJX0yOwmOD2+HjjaewIzkbv+xPxerDaXh0UFs8PrQd3Bw4d9XUNifqqmGGdfaBwoovZLbxdEJrFyVyiitwPK0A0aHWe9GCyJpZ71mKzE5UcNUV4LQCaLQtt5yLKIrYd+4qAKB/Oyby1HBDOnoDAPacyWnQRUVLl5RehMt5ZXBQyAzP3Zo5K+3Q0Uc3RSz+svSj8juSs5FRWI5WTgqM7Wbd/QmobuEBbljycB+seLwfooI9UKbS4JvtZzH04+34fvd5jp6a2OaqC5mjrXzeuCAIhlH5uIu5EkdDRI1lVCKvUqkwfPhwnD592lTxkBXr4OMCZ3s5Sis1OJ1Z1GKPe/FqKTIKy2Evl6En58eTEXqFtIKDQoasogqcziyWOhyT21zV5GlwR2842ttGkzV9eb05zJNfxiZ3VKVfOy+sfXoAvn2wF9p7OyOvVIUP1idh5Gc78fvhyy16MdxWnM8uxrnsEtjJBAzrbP0XMntXjcJznjyR5TIqkVcoFDhx4oTVdvEk05LLBEQEeQAAjrXgPPn953Wj8VFtPOCg4JdjajgHhRx92uqqOHafkWaJqpZkKKu38tGo6iKCPQBIPyKfll+GHVVN7lhWT4Bu1HRsNz9sfGEI5t3dHX5uDkjLL8PLv8Xj1i93Y2tSpk1UCrWULVWrdfRr52UT0xj0I/KHLuZCywtDRBbJ6NL6adOmYfHixaaIRXKxsbEIDw9HdHS01KFYraiqhnctOU+eZfXUFEOqliXbfca6G95dzivFySuFkAnASCvu1ny9yGoj8lImRdWb3LVjkzuqxk4uw3192mDHK8Pw+rgwuDnYITmzCI/+dAiTvtuHwyksjW4Om6stO2cLwv3d4GQvR2G5Gmezrb/ijMgaGd3srrKyEt9//z02b96M3r17w9m55vIon3/+ebMF19JiYmIQExODwsJCuLtzHVdTiKoa/WqpEXlRFA0j8v2YyFMjDO7oDSAJBy5cRblKY7VVHfovsdGhnvB0tpc4mpYT5ucGe7kM+aUqpOaWIsSr5Zf8Umu0WFXV5G5K35AWf3yyDA4KOZ4c2h73R7fBwp1nsWTvRcRdzMM9i/ZhVBdfvDq2Mzr5Nm1ZYFt1tbgCh1N0Jea2sq66nVyGqGAP/HfuKuIu5vK9Q2SBjB6RP3HiBHr27Ak3NzecPn0aR48eNfw7duyYCUIka9KjKpE/nVWE4gq1yR/vfE4JsooqYG8nMyx/R2SMTr4u8HFVolylNXzRs0b6ZedsZTRKz95Ohi4BumUGpSqv317V5M7T2R632MBqAdQ07k4KzBrXBTteGYb7ooMhE3Rl4WMX7MLLv8UjLb9M6hAtzrZTWdCKulHqQA9HqcNpMZwnT2TZjB6R3759uyniIBvh4+aAAHcHXCkoR8LlfAxo39qkj6cvq+/VppXVjqSSaQmCgEEdW2PNkTTsOpONgR1M+56VQl5JJQ5WdS4eE2573dIjg9wRfykfCZfycUdkQIs//nI2uaNG8Hd3xLx7IjBjcDt8ujEZG05m4PfDl/FX/BVM7x+Cp4d1QCsbqq5pClsrq9dj53oiy9bo5efOnj2LjRs3oqxMd+WXDVeooQzz5FugvJ5l9dQcqi9DZ422ncqCRisizM8VbbycpA6nxembcCZIMCJfvcndfdHBLf74ZPk6+Ljg26m9sObpAejb1hOVai3+b/cFDPl4O2K3n0Vppemr3yxZuUpj6IFia4l8jzatIBOAy3llyCgolzocIjKS0Yn81atXMXLkSHTq1Am33nor0tPTAQAzZszASy+91OwBkvUxzJM3ccM73fx43VXm/u2ZyFPj6UfhT14pRE5xhcTRND9Dt/qutjcaD1xreHc8rQBqjbZFH1vf5K5/Oy82uaMm6dmmFVY83g8/PhyNMD9XFFWo8cnGZAz9ZAd+2Z8CVQu/ty3F3rM5KFNpEODugK5V02xshYvSDl38dc/5EJsmElkcoxP5mTNnQqFQIDU1FU5O10ZuJk+ejA0bNjRrcGSdooJ1pVzHLpm2S/TZrGLkFFfAQSFDZDCbF1LjebsqDV929p61rlH5skoNdp7WLa1nS8vOVdfO2wUuSjuUqTQt2r1ZrdFiZZyurP7+vlxyjppOEAQM7+yDf54bjC8mRyKolSOyiyrw1h8nMOaLXdhwIl3qEM2Ovqx+VLivTS6vHM158kQWy+hEftOmTZg/fz6CgoJq3N6xY0ekpKQ0W2BkvboHukMuE5BVVIF0E5Zy6cvqe4W04rxTajJrXYZuz9kclKu0CPRwtLnRKD25TEC3QN1zT7jUcuX125OzkVlYwSZ31OxkMgF39QjC1peG4t3x4fBytseFnBI8+csRLldXjVYrYkuSbmrLKBtadrO63pwnT2SxjE7kS0pKaozE6+Xk5ECpVDZLUGTdHO3l6Fy1zIkp58nvO8/146n5DK6aJ7/7TLZV9QTZdFJXVj/aRkej9CKr5snHX85vscdcdkB38ZtN7shUlHZyPDywLXa+OhwDqqaY6aecEXDscj5yiivgqrSz2V46vUN0I/JJ6YUtspqQpdh9JhtTFx/ApdxSqUMhqpfRifyQIUPw888/G34WBAFarRaffPIJhg8f3qzBkfUydcM7rZbz46l59Q5tBaWdDJmFFTiT1XLl16ak1mixJUlXVjrGxkeEI1o4kU/LL8OOqikNbHJHpuaitDNcjDyVUSRxNOZjS1VZ/dDO3rC3a3T/Z4vm5+6AoFaO0IrA0VSW1+t9tuk0dp/JwTfbzkodClG9jD5rffLJJ/juu+8wbtw4VFZW4tVXX0W3bt2wa9cuzJ8/3xQxkhUydcO7M1nFyC2phKNCju6BHiZ5DLItDgo5+rTVjVxYS3n94ZQ85JWq4O6oQJ+qeZK2KqKq4d2p9CKUqzQmf7yVB1MhsskdtaDOfrr3WXJGocSRmA9bXXbuevp58nGcJw8AyC2pNFzUXZdwBSWsVCAzZXQiHx4ejoSEBPTp0wejR49GSUkJ7r77bhw9ehTt27c3RYwtJjY2FuHh4YiOjpY6FKvXoyqRN1WX6H3ndIlW79BWNnuVnZrfkGrl9dZgU9WX2JFdfGAnt+3PSVArR3g520OtFZGUbtpER63RYuWhSwCAKWxyRy2ks5+uD8T57BJUqtnB/mJOCc5kFcNOJmBYZx+pw5GUfp78Ic6TBwDsOp0N/Qy6kkoN/jnOJpFknuwacyc/Pz/MmTOnuWORXExMDGJiYlBYWAh3d3Y5N6X23i5wVdqhqEKN5MwidA1o3tfbMD+eZfXUjAZ3ag38o2ukWKHWWPS8ZlEUDaNRY8Jtc9m56gRBQESQO7YnZyPhcgF6tGllssfadirL0OTO1qc0UMsJcHeAq4MdisrVOJddbFiJw1bppxX1becJd0eFxNFISz8ifzQ1HyqNFgobv7C7I1nXANHT2R65JZX47fBl3NubU6DI/DTqk5qXl4dPP/0Ujz76KGbMmIHPPvsMubm8ikcNJ5MJiKhaEq6558lrtSIOXNC9H221eQ2ZRmdfV3i7KlGu0uKwhZcgJmcWITW3FEo7GYZ0ai11OGahpebJLz+oW3LuXja5oxYkCIKh0Wwy58kbKpJstVt9dR28XeDmoFuCM/GKbU+90GpF7KqaPvfu+HDIBODghVxcyCmRODKi2oxO5Hfu3Im2bdviq6++Ql5eHnJzc/HVV1+hbdu22LlzpyliJCtlqnnypzKKkF+qgrO9HN0DWVlBzUcQBAzuULUMnYWvJ7/ppO5L7OCO3nCyb1RxltWJrLq4GG/C1TRqNLnrw7J6almd/aoS+UzbTuRzSyoNZeRM5HWDK73168mnWPZF6qZKSCtAbkklXJV2uLW7P4Z00k2p+/3wJYkjI6rN6EQ+JiYGkyZNwoULF7BmzRqsWbMG58+fx3333YeYmBhTxEhWKipYV7ra3CPy+rL66LaeNl8eRs1vcCf9evKWPU9+U6Ju2bkxNt7kqTr9iPz5nBIUlatM8hj6JncD2nuhbWtnkzwGUX3C/DgiDwDbT2VBK+pej2DP2ksq2yLOk9fZfkpXVj+4U2so5DLc20tXUr/6cBo0WutZepasg9FZzrlz5/DSSy9BLr9WDiiXy/Hiiy/i3LlzzRocWTf9iPzZ7OJm/dK8vyqRZ1k9mcLAqhH5E2mFuFpcIXE0jZOWX4YTaYWQCbpGd6TT2kWJQA9HiKKuEWdzq97k7n6OxpME9A3vbD2Rv9YfhBcy9ap3rhdF201Y9RVTwzrp/jaOCveBh5MCGYXlFn8B35yczixCVmG51GFYPKMT+Z49eyIpKanW7UlJSYiKimqOmMhGeLte+9KccLl5vjRrtCIO6BvdMZEnE/BxdTCMau09d1XiaBpn80ndaHzvEE94uSgljsa86Mvrm+ucVJ2+yZ2Xsz1u6coGg9Ty9HPk0/LLUGiiqhNzV67SYFdVQjaajT4Nuge6w14uQ05xBVKulkodjiSuFlcgoapHytDOupJ6pZ0cd0YFAgB+O3RZqtCsSnpBGW79cjdGfLYTG05wRYCmaFAin5CQYPj33HPP4fnnn8enn36KPXv2YM+ePfj0008xc+ZMvPDCCyYOl6xNVBsPAM1XXp+UXojCcjVclXboGmDbHXnJdPRz5naftsyr8/omT+yYXpu+vD7BBA3v9E3uJvYK4rKYJAl3JwX83BwAAKdtdFR+37mrKK3UwM/NAd0C+T1Bz0EhR/cg3YVMW50nv+uMbtm5cH83+FZ9TgBgUlXH+k2JGcgtqZQqPKtx/HIB1FoRxRVqPPnLEcz9N8kkS1HbggZ1OIqKioIgCDVKbV599dVa202ZMgWTJ09uvujI6vUI9sD6hHQcbaaGd/urzY+39XWxyXQGd2yN/+06j91nciCKIgRBkDqkBssvrTSs6jCaZaW1RATpG94174j85bxSNrkjs9DZzxUZheU4lVFkaHBmSwzd6sN9LOrc3RJ6h7bC4ZQ8HLqYi4m9gqQOp8XtSK4qq68ajdcLD3BD1wA3nLxSiD+PpeHhgW2lCM9qnK9aAcDL2R5XSyrx3c7zOH65AF/f34NVgkZqUKZz4cIFnD9/HhcuXLjhv/Pnz5s6XrIyhs71l/KbZU7WvnMsqyfTiw71hL2dDBmF5TiXXSx1OEbZdioLGq2IMD9XhHix2dr1uge6QxB0pcc5zdgDYVXcJTa5I7Ngyw3vtFoRW6vWj2dZfW3RIfp58rbX8E6jFbFLPz++c+3eMfpReZbXN925LN33pqn9QxA7pSec7OX479xV3P71nmZvgG3tGpTIh4SENPifJYuNjUV4eDiio6OlDsVmdAt0h51MQE5xBdLyy5q0L7VGi4NVI4392zORJ9NxUMjRt63uC8+u05a1DJ1+2Tk2eaqbq4MC7b1dADRfeX31JndT+nI0nqTV2YYT+YS0AmQVVcBFaYd+7WyvGuFmeoXoOtefyy6xuRLy+Mv5yCtVwdXBDj2rpn1WNyEqAPZyGRLTC3HCBM1QbYl+AKS9twtui/DHnzED0c7bGekF5Zj07T4sO5Bq0w0XjdGo2uO0tDSsWrUK33zzDb766qsa/yxZTEwMEhMTERcXJ3UoNsNBIUeYv+5LRVOvwiWmF6KoQg03Bzt08ee8NzKtwR0tbxm6cpUGO6tGHMaw2Vq9mru8vnqTuzEcBSSJVV9L3ta+LG+uWnZzaCdvKO3kN9na9rRytkcHH92FzMM2Nk9eX1Y/pKN3nVMzPZzsDX1lfjvENeUbSxRFnMvWldbrL5p39HXFnzEDMbarHyo1Wryx9jhe/T0B5SqNlKFahAbNka/uxx9/xJNPPgl7e3t4eXnVmF8kCAKee+65Zg2QrF9UsAdOpBXiWGo+bo8IaPR+9GX1fdp6QS7jvDcyrUEdvAGcwv7zuahQayziS+GeMzkoU2kQ4O7AZpA3EBnkgTVH0hDfTCPyy/RN7nqzyR1Jr4OPC+QyAQVlKmQWVsDP3eHmd7ISWxJ1a4SPCueym/WJDm2Fs1nFOHQx16b6qOxM1r03hl43P766e3sHY11COv44dgWzbu0CB4X5/903N7kllSgoU0EQUGOamauDAose7Ilvd57HJxtP4bfDl5GUUYhFD/RCsKeThBGbN6O/Ubzzzjt45513UFBQgIsXL3KOPDVZVLCulKupI/L79MvOsayeWkCYnytauyhRptLgSEq+1OE0yKaq0agxXf3Y5OkG9CPyCZcLmjxieTmv1FAFcX80y+pJeko7ueEL9KmMQomjaTmpV0uRnFkEuUzA8DrmQJNObxucJ59TXIGEqnL5YZ3qT+QHdWgNf3cHFJSpsKWq1wIZRz8aH+DuCEf7mhdCBEHAU8PaY+mjfeHpbI8TaYUY/80ew99Qqs3oRL60tBT33XcfZDKOKlDz0De8O55WAFUjl59Qa7SIq5ofz3lv1BJkMsGiyus1WhFbk3QjDpwff2Nd/N2gkAvILanE5bym9e5YWdXkbmAHL4SyyR2ZCVucJ7+5KvHqE+oJDyd7iaMxX9FVKxkcTyuwmdLmXad1y851DXCDj1v9FSpymWDo5r+KTe8axTA/vmoKR10GdmiNv58dhMggd+SXqvDQjwfx9dYz0GptaypQQxidjT/66KP47bffTBEL2ah2rZ3h6mCHCrW20V8qjqcVoKRSAw8nBbr4sWSYWsa1RN78G94dSc3D1ZJKuDsqEN2WF7tuxEEhR1jVeSThcuPnyas1WqyM082lvJ9LzpEZ6exrg4l8VUXSKF7IvKFgT0d4uyqh0oiIt5EO4vUtO1cXfSK/+0w2rjSxSbMt0nesb+994wvbgR6OWPVkf0zp2waiCHy2+TQeX3oIBWWqlgjTYhidyM+dOxc7d+7EsGHD8Oyzz+LFF1+s8Y/IWDKZYBiVP9rIPxr6svq+bT0h4/x4aiGDOugS+RNXCsy+w++mk7ovsSPDfKCoo5EP1XStvD6/0fvYeioLWUVsckfmRz8if8pGEvn80krEXdQ1b2NF0o0JgoDoUN2Ux0M20PBOoxWx60z9y85dL8TLGX3bekIUgdWHOSpvLP0a8vpGdzeitJPjo7u64+OJEbC3k2FLUhYmfLPHpqYE3YzR3+Y++ugjbNy4EZmZmTh+/DiOHj1q+Hfs2DEThEi2wLCefGp+o+6//7y+rJ7z46nl+Lg5IMzPFaII7D1rvqPyoihiU2LVsnNd+SW2ISKDPAA0rXfHcja5IzOlX0v+bHYx1I2c0mZJtidnQaMVEebnysZZDaCfJ3/IBubJH7uUj/xSFdwc7NCj6rvozRjWlD98meXeRtKX1re7yYh8dZN6B2P1kwMQ6OGIi1dLcVfsf/jzWJqpQrQoRn+z+Pzzz/HDDz8gKSkJO3bswPbt2w3/tm3bZooYyQYYEvlLxl/9VWm0hj82bHRHLc0S5smfzixGytVS2NvJMLjjzUsHCYgI1o3In0grgKYRX9Qu5bLJHZmv4FZOcLKXo1KtxcWrJVKHY3Kbqy5kjurCC5kNoZ8nfyglz+oTVX23+sGd6l52ri7juvvBRWmH1NxSHLSBix3NpVylwaXcUgBAhwaMyFfXPcgd654dhMEdW6NMpcHzK45h9l8nG91by1oYncgrlUoMHDjQFLGQDdMn8ueyS4ye/5JwOR+llRp4Otujk4+rCaIjqt+gqsR4z5kcs12TWV9WP7hDazgrjV511CZ19HGFk70cJZUanK8aQTDGqkNsckfmSyYT0NHXNsrrK9Qa/H97dx4fVXnvD/xzZiaZ7Pu+sySBsIQAQXEDtKBoraC4X5Vfa9FrbLV2pXWB9taltkorUXvbCtxbAVdQr1pBERABCUuAElmyQDayL5M9szy/PyYzJCQhmWRmzpmTz/v1ykuZzJzzTL6ZyfnO8zzf766ePdBjqZ3aaEyOtb7/tXSacLpG3b8fO3s+cL1UtfqL+XnrcHNmLADrez0Nz7n6dlgEEKjXITJQ7/DjQ/29sf7/zcGjCyYCANbvPYu7/3s/agydzh6qx3A4kX/sscfwyiuvuGIsssvNzUVGRgays7PlHsqYEx6gR2KYLwDH96TaltVzfzzJYU5KGLx1GlQ2d9rbqigNl9U7TquRMDXOOit/1MGCd8ZeRe7umZPs9LEROcOknkT+tMoT+X1F9WjrNiMqUI9p8cFyD8cj6LQaZCWFAAAOnlXvPvnali57QdNL9Y8fyLJZ1uX1nxw/j5ZOFmAbDtuH4uOjAkbcAlerkfCz69Pxt/tnI1Cvw8FzjbjplT1jql1ibw4n8gcOHMCGDRswfvx43Hzzzbj11lv7fHmynJwcFBQUIC8vT+6hjEn2fvIO7pPfV8T+8SQfX28t5vQsQ1Ti8vrKpg4cr2iGJAHXcVmpQ0Za8G5HT5G7iABvzgCSYo2Vgnf2ZfUZ0fyw3wFjYZ/87p7Z+KnxQYgKHLzt3EBmJoVgQqQ/Oo0WfHzsvCuGpzr21nNOWKW2MCMaH/7oKqRHB6K2pQt3//d+rPu6RLErI13F4UQ+JCQEt956K+bNm4eIiAgEBwf3+SIaqQv75JuG/ZgukxkHz7HQHcnLtk9+jwLb0NkuYmcnhyIiwPGlbGPZ9J73JEdbMG38pqfI3axEFrkjxbIVvDtVrd5EXgiBz3v6x/NDNcfY9snnqXhG/sKy+qGr1V9MkiR70Tsurx8e26rFS/WQd8S4CH9sybkC38uMg8kisPqjAjz+Vj7au01OOb4ncHiz5Lp161wxDqI+ibwQYljLbo6VN6PTaEFEgDdSnfTGQOSoq1IjgE+tbRC7TRZFJW/benons/2Z4zJ7ZuS/Pd8y7LiWNbTbWxndlZ3o0vERjUZaTyJf2tCO9m4T/LzVVz/jeEUzqg1d8PPWYi4/7HfIjKQQaDUSKpo6UNnUgbgQX7mH5FRmi7DPyC+YNLIisEtnxuMPn53C4dImFNa0YCLrNF2SfUbegYr1Q/Hz1uHPd83AjMQQPPvJt/ggvxInz7fg9ftmYdwYqE+jnKtNGvOmxAXBSyuhvq0b5Y0dw3qMbVn9ZePDR7zfhmi0JscEISLAG+3dZhwuVc7sRXO70V5DgrNRjksK80OInxe6zZZh9619K89a5O6qiREsckeKFhGgR0SAN4SwdrZQI9uKpHlpkfDx0so8Gs8SoNdhcqw1MVVjP/n8skY0dxgR7Otl39rpqKhAHyzo6T3/zkH2lL8UIQSKa4ffQ94RkiTh+1eNw8YfXo7IQD1OVbfge6/ssb/+1czhRH7cuHEYP378oF9EI+XjpcXk2CAAwJFhLmW1JfJcVk9y0mgkXDVReW3odpyqhtkikB4dyKRyBCRJwvSefvLDKXhnNFvsSyzvnsOWc6R8tn3yp4b5QZWnsV3I84PMkbHtkz+kwn3yO3s6GVydGgHtKGon3D47AQDw3uGKMd8K7VJqWrrQ2mWCRgKSwv1cco4548Lw8Y+uwuzkULR0mfDD/zmIP352akQtZD2Fw4n8448/jscee8z+9cgjj2Du3Llobm7GihUrXDFGGkPsy+uHUfCu03hh9pNL5khuvdvQKcW2E6xWP1q25fXHhvHh4hffssgdeZb0aOuH52oseFfW0I6TVS3QaiT7rCk5Rs375G2J/PxR/m5cOykKEQHeqGvtsrc5pP6KaqyrfpLC/KDXuW51TFSQDzatuBzLr0gBAKz9shDL1x1AY1u3y84ppxG1n+v99bOf/Qxvvvkmfvvb3+LUqVMOHeu5555DdnY2AgMDERUVhSVLlvQ7hhACq1atQlxcHHx9fTF//nycOHFiyGO/9957yMjIgF6vR0ZGBrZs2eLQ2EgeF/bJD/1HI7+sCV0mCyID9U7db0M0EraCd8cqmhXxB6PTaMaunv1/3B8/chdm5JuGvO+mAyxyR57FXvBOhYl870Kfof7eMo/GM81OsS45P1llgEFFLdZqWjpxvKKn7ZwD/eMH4qXVYGlWPAAWvbuUC/vjXV/PykurwarvTcGaO2fAx0uDr87U4buv7MFxB1vJegKnXWksXrwY7733nkOP2bVrF3JycrB//35s374dJpMJixYtQlvbhV7Mf/jDH/DSSy9h7dq1yMvLQ0xMDBYuXIiWlsH/6Ozbtw933nkn7rvvPhw9ehT33Xcf7rjjDnzzzTcjfn7kHrZE/t+VBnSbLr1Eqfeyeu6PJ7lFB/kgPToQQgBfF8k/K7+3qA7t3WbEBvtganyQ3MPxWLYZ+cKaVrR1DV4Jt3eRu7vnsMgdeQbb0vrTKqxcz2r1oxcd5IPEMF9YBHDEwdbASrb7tPVv9LT4YEQGjr6by+091et3nKxBXWvXqI+nRs6uWD8cS7LiseWRK5Ec7oeKpg7c9vpevJ2nrg9bnJbIv/vuuwgLC3PoMf/617+wfPlyTJkyBZmZmVi3bh1KS0tx6NAhANbZ+DVr1uA3v/kNbr31VkydOhUbNmxAe3s7Nm7cOOhx16xZg4ULF2LlypWYNGkSVq5cieuuuw5r1qwZzVMkNxgX4Y9gXy90m4YuLrW/uKd/PJfVk0IoqQ2dfVl9RjQ/6BqFqCAfxAb7wCKAf1cM/ml+7yJ3yeFcIUSeIS06EJIE1LV2qyoBaW434psSFvp0hmwV7pPfeaoGADA/fXSz8TZp0YHITAyBySKw9UiFU46pNq6oWD8ck2OD8OGjV+G6SVHoNlnwi/eO4dA59fwuO9xrJCsrq89FoRACVVVVqK2txauvvjqqwTQ3Wy+SbB8IlJSUoKqqCosWLbLfR6/XY968edi7dy8eeuihAY+zb98+/OQnP+lz2/XXXz9oIt/V1YWurgt/wAwGawJpNBphNA5vKZHtfsO9Pw1uenwQviqsx6Gz9ZgcPfALvvf++OzkIJf83BlT9XF1TOeOD8Xf95Rg9+ladHd3y5ZAmy3Cvqz02vQI1f4Ou+s1OjUuCOebO3GktAEzE/uvbjCaLXgrz7qs/o5Zcar9ebsD33fdSycBSaF+ONfQjhPljbhignM/GJcrnp8XnIfZIpAa5Y+4IG/+Po1CVmIw3j9SgQMl9X2uiz31Z2oyW+xt566eEOa053FbViyOljVh84FS3H9Zgkd9gO6OmNr3yIf6uP13x08HvHp3Jl7bXYK61i5MjwtU9O+vI2NzOJFfsmRJn39rNBpERkZi/vz5mDRpkqOHsxNC4IknnsBVV12FqVOnAgCqqqz9j6Oj+36aGh0djXPnzg16rKqqqgEfYzvexZ577jmsXr263+3btm2Dn59jlRW3b9/u0P2pP79ODQANPtlfgLD6fw94n9PNEoxmLYK9BE7s34UCF75fMqbq46qYdpsBraRFZXMn1r//KaJlartbbADq23Tw1QrUf/sNPnGsfInHcfVrVN8mAdDis7yTiG0u6Pf9o/USalu1CPASMJ49jE9KXTqcMYHvu+4TJKx/c7fuPICmU66p7uzueP7ztPU5JXu14JNPPnHrudWmvR0AdDh0rgEf/d8n0Pas5fXU12ixATB06uCnE6g4vhfnB77MdJi3CfCStCisbcPrb3+KZA9sKe+qmHaZgcpma8pZnL8PNUOXOnOJcQBSJOCTT0rkGcAwtVtfdMPicCL/zDPPOPqQYXn00Udx7Ngx7Nmzp9/3Lv5USwgx5Cddjjxm5cqVeOKJJ+z/NhgMSExMxKJFixAUNLy9pUajEdu3b8fChQvh5eU1rMfQwPxO1+Kz/z2COhGAG2+8asD7nP6iECgoxrzJcbjppmkuGQdjqj7uiOmWuoPYW9wAXfxU3Hi5PC3Inv/XKQDnsHBKHG7+rmteH0rgrtdocFE9/m/9IdRa/HHjjVf3+/67Gw4BqMe9l4/H9xalumwcYwHfd93vtL4Qx3cWQxuWhBtvnOLUY8sRzy6TBb8+/CUAMx666XJ77R0aGYtF4NXTX6K5w4SkGVciI9rPo1+jL31+BkAJFkyOxXdvmu7UY+/rPo4Pjp5HpW8K/vPGDKce25Vc/TotOG8ADuxHqJ8X7rhl0dAPGONsK8OHw+FE3hV+9KMf4cMPP8Tu3buRkJBgvz0mxlppuaqqCrGxsfbba2pq+s249xYTE9Nv9v1Sj9Hr9dDr+xe78PLycvgXeiSPob5mpVj3GZfUt6PdCAT79f95HuhphXJlaoTLf96Mqfq4MqZXp0Vhb3ED9hY34PtXT3DJOS6ltqUL27+1Lhu8YVrsmPjddfVrNCvZuty4vLEDLd0CYb0qYJc1tGNPT+HNey5PHhM/b3fg+677ZMSFAADO1LS67GfuznjuK6lFW5cZkYF6zEqJgGYUPcLJanZyGL44WYP8coO9AKinvka/KrS+X183Odrp478zOwkfHD2Pj49V4Zmbp8LX23Vt1lzBVTE912jdvjwhMsAjf2fczZGf0bCL3Wk0Gmi12kt+6XSOfS4ghMCjjz6K999/Hzt27MC4ceP6fH/cuHGIiYnps9Sju7sbu3btwhVXXDHocefOndtveci2bdsu+RhSjjB/bySHW7c05A/Q8qmj24z8np7Ol7PQHSmMreDdvqL6ITsvOEtHtxkf5Fdg+boDuPy5L1Da0A4fLw2uGWVbHbIK9vXC+AhrvY5jF70nbc4rhRDWuLPIHXmiC5XrW2GxuGZpvTvt6ymEOz8tkkm8k8zu6Sd/0MP7yde0dOLfFdbZTlf8fbx8fDgSQn3R0mXCZycG3s47Ftn2x49nq2inG3bmfak+7Hv37sUrr7wCIRz7A5CTk4ONGzfigw8+QGBgoH0WPTg4GL6+vpAkCY8//jieffZZpKamIjU1Fc8++yz8/Pxwzz332I9z//33Iz4+Hs899xwAa6/7a665Bi+88AJuueUWfPDBB/j8888HXLZPyjQjMQTn6tuRX9rUr8fnoXONMJoF4oJ9kBTmWA0DIlfLiA1CuL836tu6caS0EZe56MMmi0Vgf0k9thyuwKf/rkJrr9ZoMxJD8MTCNAToFbHoShWmJwSjuK4Nx8qbMT89CoC1yN3bB8sBAHfPkWcbBdFopYT7wVunQYfRjNKGdqREePbF9qFzPYVwUxzrpESDy+7pJ3/wXIPD1/pKsuuUdbXa9IRgRASMvu3cxTQaCbfPSsTLn5/G2wfLsKSnv/xY584e8mPNsK/ybrnlln63nTx5EitXrsRHH32Ee++9F7/73e8cOvlrr70GAJg/f36f29etW4fly5cDAH7xi1+go6MDjzzyCBobG3HZZZdh27ZtCAy8UEWitLQUGs2FxQVXXHEFNm/ejCeffBJPPfUUJkyYgLfeeguXXXaZQ+Mj+cxIDMEH+ZXIL+v/6e++Ymtrr8snsH88KY9GI+HKiRH48Ggl9hTWOT2RP1PdgvePVOCDIxWobO60354Q6oulWfFYmhWP8fxj6XTTE0KwNb8SR3tWAwHAF99Wo7alCxEBera4Io+l02qQGhWAE5UGnKpu8ehE3mi22F+jM5ND5R2MikxLCIa3ToO61m6caxh+IS6l2dlTrd72Yawr3DYrHmu+OI29RfUoa2hHIiecUGzrIc9rE6cb0XRNZWUlnnnmGWzYsAHXX3898vPz7ZXmHTGcT/UkScKqVauwatWqQe+zc+fOfrctW7YMy5Ytc3hMpAy24jT5ZU39ChXuL7b2f+SyelKqq1OtifzuM3X46aL0UR+vrrULH+ZXYsuRChzv1cs80EeH706PxdKsBMxODuUyUhfKTLTuCz1a3mx/T9p4oAwAcPvsBHhph71TjUhx0mMCrYl8VQuunxIj93BGrKDSgC6TBSF+F7bD0OjpdVpMjw/GwXONOHiuCZ6YmprMFnxlT+Rdt+0sIdQPV06IwJ7COrxzqBxPLExz2bk8gcUiUFzXMyMfxUTe2RxK5Jubm/Hss8/ilVdewYwZM/DFF1/g6qv7V/AlGq2MuCB4azVobDeitKHdvve0rctk/7R9LhN5UqirU60XCcfKm9DU3o0QP+8hHtFfp9GM7QXV2HKkArtO18Lcs3dVp5EwPz0SS7MScN3kKPh4eVYxHU81JS4YWo2EutYunG/uhNki8NUZ60Xh3dlcVk+ebVLPPvlTVS0yj2R0bMvqZybxg01nm50ShoPnGnG4tAlXOf4nTXZHyppg6DQh1M8LmQkhLj3X7bMTsKewDu8dKsfj16WO6d/FyuYOdBot8NJKSAyVqSevig07kf/DH/6AF154ATExMdi0adOAS+2JnEWv02JyXBCOljUhv6zJnsgfPNcIk0UgIdSXy5VIsWKCfZAWHYDT1a3YW1SPG6fFDv0gWD+5/qakAVuOlOPT41Vo6bXvPTMhGLfOTMB3p8ci3AV7++jSfLy0SI8ORMF5A46VN+F4RbO9yF1SON+LyLOlRVsT+ZNVw297pESHSq2J/Cwuq3e67JRQvL7L+mHJVR7YZXPnqRoA1g/atS5OrK+fEoMgHx0qmjqwt6geV/UUwR2LinqW1SeH+0PHlWtON+xE/le/+hV8fX0xceJEbNiwARs2bBjwfu+//77TBkdjW1ZiCI6WNeFIaRNumWEtGLK/pxotl9WT0l01MRKnq1vx1ZnaIRP5wppWbDlSjq1HKlHR1GG/PT7Euu99SVY8JnJJmuwyE4NRcN6AQ+casTW/EgBwD4vckQpMigkCAJytb0en0eyxK30O95qRJ+eyfThSXNeO1hR5xzISX560rqBaMMn13Vx8vLS4ZUY8/nf/Obx9sGxMJ/LF9kJ33OriCsNO5O+//37VFxbLzc1Fbm4uzGaz3EMh9N0nb7Ovp18zl9WT0l2dFoE3vi7B7tN1/eo8AEB9axc+Omrd9360vNe+d70ON06LxdKZ8ZiTEjaml+QpzfSEEGw6UIaN35SirduMiAA9vsMid6QC0UF6BPt6obnDiMKaVkyND5Z7SA6rbOrA+eZOaDWSvaYFOU+InzdSowJwpqYVxS2e9XepxtCJgvMGSBJwTap72rLeMTsR/7v/HP51ogrN7UYE+43N/umsWO9aw07k169f78JhKENOTg5ycnJgMBgQHMw/AnKzJfLW4jVmGM3CXujr8glM5EnZLhsXBm+tBhVNHThb345xEf7oNJrxxbc1eP9wOXadroWpZ9+7ViNhflokls6Mx3cmR3vsbJjaTU+w/l1o67Z+2HsHi9yRSkiShPSYQBwoacCpqhaPTORt++MzYoPg583Wm64wOyUMZ2paUWLwrETeVq1+enyw27amTY0PwqSYQJysasGHxypx3+XJbjmv0hTVWJfWs5uOa/CdjhQrOdwPoX5eaGw34tvzLWhs74bZIpAU5of4EBbMIGXz89ZhVnIo9hXXY93XJeg2WfDx8fNo6byw7316QjCWZsXj5sw4l/S0JedKiw6Ej5cGnUYLAOAuFrkjFZlkS+SrPbPgnS2R5/5418lOCcWmA6UeNyNv6x/vyrZzF5MkCbfPTsTv/q8A7xwsG7uJPJfWuxQTeVIsSZKQmRiCnadqkV/aiPM9PbO5rJ48xdVpEdhXXI//2XfOflt8iC+WZMVhaVY8JkYFyjg6cpSXVoMpccE4dK6RRe5IddI9vHL94Z5Cd+wf7zrZKWEAgNI2oKndiMhg5S8XN5kt2H3G9W3nBrJkRhye//RbHCtvxrfnDZgcG+TW88utpdOImpYuAJyRdxWuCSRF671Pfl9Pobu5XFZPHmLx1Fj4eGkQoNfhjtkJ2PTDy/HVLxbg59dPYhLvoZbNSkCQjw6PLpgo91CInMqTW9C1d5twotJacZ8z8q6TEOqLSdEBsAgJf9tTIvdwhuVwaRNaetrOTXdx27mLhQfo8Z3J1joq7xwsd+u5laC4p2J9ZKC1Bgc5HxN5UjRbIr+vuB7/tu2P54w8eYhxEf448Jvv4OCT38EflmVi7oRwFq/zcHfPScKxVdfjMr4PkcrYWtBVGTrR3G6UeTSOOVbeDLNFICbIB3HBPnIPR7UkScJPFlp7z/3P/lJUGzplHtHQbG3n5qW5vu3cQG6fnQAA2JpfgW6Txe3nl5NtWf34CC6rdxUm8qRotkS+2tAFi7AmRjH8I00eJMjHi8XriEjxAn287PVnPK2ffO/98WrvsCS3BWkRGBco0Gm04C9fnJF7OEP6Uob98b1dkxqJqEA9Gtq6seNktSxjkIt9fzzb57oME3lStBA/b4zr9UkeZ+OJiIhcw75P3sMK3tn7x3NZvctJkoSbk6ydOzbnlaGkrk3mEQ2u2tCJb21t59Lcuz/eRqfV4LZZ1ln5t8fY8nrb0nq2nnMdJvKkeLZZeQC4fHyYfAMhIiJSMVsif9KD9skLIXColBXr3WlCEDA/LQJmi8BL20/LPZxB2arVZyaEIMzfW7Zx3N6TyO88VeMR2xGchRXrXY+JPCle70SeFeuJiIhcwxML3hXXtaGp3Qi9ToOMMVYVXE5PfMe6V/6jo5X2GkZK82XP/nh3V6u/2PjIAMxODoVFAO8frpB1LO5iMltwtq4dAGfkXYmJPCnelRPDodVYW9FFBXF/PBERkSvYZuRPV7VACCHzaIbHtj8+MyEE3jpe1rrL5NhA3DIjDgDw4menZB5Nf0azBXvO1AGQb398b3fMTgQAvHOwzGNeW6NR3tiBbrMFep0GcT21N8j5+I7XS25uLjIyMpCdnS33UKiXiVGB+PjHV+Hv98+WeyhERESqNT4iADqNhJYuEyqaOuQezrBwf7x8nliYBp1Gwq7TtdhXVC/3cPo4fK4RLV0mhPl7Y3p8sNzDwY3TY+HnrUVxXZv9wyc1K66zLqsfF+EvS7eAsYKJfC85OTkoKChAXl6e3EOhi0yKCUJkoF7uYRAREamWt05jXwZ72kMK3vWuWE/ulRzuj7vnJAEA/vDZSUXNNNuq1c9Li1RE29cAvQ43TYsFALx9sEzm0bheUU1PoTtWrHcpJvJEREREBMCzCt41txtxpsY68zczKUTewYxRP7p2Iny9tDhS2oTPv62Rezh2OxWyP76323uW13987Dzaukwyj8a17IXu2EPepZjIExERERGAXi3oPCCRP9xTrX58hD/CA7hqTw5RQT74/lUpAIAXPzsJs0X+Wfmq5k6crGqBJAFXpyonkc9OCUVKuB/aus345Ph5uYfjUuwh7x5M5ImIiIgIAJAe7TmJ/CHuj1eEFddMQLCvF05Xt2LrEfmrsu86bZ2Nn5Eob9u5i0mSZJ+Vf0flPeXZQ949mMgTEREREYALM/JFta0wmi0yj+bSuD9eGYJ9vfCf8ycAAF7afhpdJrOs4/nypHV//Pw0+avVX+y2mQnQSMCBsw0oqWuTezgu0djWjfq2bgDWYnfkOkzkiYiIiAgAkBDqiwC9DkazsM+qKZHJbEF+WRMAJvJK8MDcFEQH6VHR1IGN35TKNg6j2YKvC21t55SzrN4mJtgH16RZx/XuIXUWvbNVrI8N9oG/XifzaNSNiTwRERERAbAu/02Lti6HPVllkHk0gztZ1YIOoxmBPjpM5PJd2fl6a/HYdWkAgLU7CtEqUzG3Qz1t58L9vTFNAW3nBmLrKf/uoXJF1BRwNnvFer4uXY6JPBERERHZpccEAVD2Pnn7/vikUEW0FyPg9tkJGBfhj/q2bvzjqxJZxvBlT7V6pbSdG8h1k6MQ6ueFakMXdp+plXs4TlfUMyM/IZLL6l2NiTwRERER2U3q2Sev5F7y3B+vPF5aDX66yDor/7evitHQs0/anXbZ+scrcFm9jV6nxZKseADAOyrsKc8e8u7DRL6X3NxcZGRkIDs7W+6hEBEREcnCE3rJM5FXphunxmJqfBBau0x49ctCt577fHMHTla1QCMB1yio7dxAbp9lXV6/vaBalg88XKm4p/Xc+Agm8q7GRL6XnJwcFBQUIC8vT+6hEBEREcnC1oKuvLFDtr3Ol1LV3ImKpg5oJCAzMUTu4VAvGo2En18/CQDwP/vPoaKpw23n3tkzGz8jMQShCmo7N5CMuCBMjQ+C0SzwQb78LfucpdtkwbmGdgDAhCgurXc1JvJEREREZBfq742oQD0AZe6TP1xqnY2fFBOEAFbFVpxrUiNw+fgwdJss+PPnp9123p09++Pnpyuv7dxAbEXv3sorgxDqKHpX2tAGs0XAz1uLmCAfuYejekzkiYiIiKgP2/J6JSbyXFavbJIk4Rc3WGfl3z1UjsIa1/8OdZss+LqwHoAy284N5HuZcfDWaXCyqgUnKpXbIcIRRbUXKtZLkjKLDaoJE3kiIiIi6mOSPZFXXoLBRF75ZiaFYlFGNCwC+ONnrp+VP3SuEa1dJkQEeGNqnDLbzl0sxM8b10+JAaCeondFtv3xrFjvFkzkiYiIiKgPWws6pRW86zSacaKyGQATeaX72fXp0EjAv05UIb+syaXnsi2rv0bBbecGcvusBADA1vxKdBrNMo9m9NhD3r2YyBMRERFRH/YZ+eoWRe3fPV7RDKNZIDJQj4RQX7mHQ5eQFh2IW2daE9UXPj3p0t8jW6E7T9kfb3PlxAjEBfugucOI7QXVcg9n1Gwz8kzk3YOJPBERERH1MTEqABoJaGo3oralS+7h2NmX1SeFcg+uB3j8O6nw1mqwr7geewrrXHKOyqYOnKq2tZ2LcMk5XEWrkbCsZ1b+bQ9fXi+EsLeeY8V692AiT0RERER9+HhpkRJuvRhX0vJ67o/3LAmhfrj38iQAwB/+dcols/K22fispFCE+Cm77dxAlvX0lN9TWIdKN7brc7a61m4YOk2QJNjfO8i1mMgTERERUT9Kq1wvhMDhnkR+JhN5j5GzYCL8vbU4XtGMT/9d5fTj29vOpXlGtfqLJYX74fLxYRACeO9QudzDGTHbsvqEUF/4eGllHs3YwES+l9zcXGRkZCA7O1vuoRARERHJypbIK2VG/lx9O+rbuuGt1WBqfJDcw6FhigjQ48GrxwMA/vjZKZjMFqcd29p2zrpkf8Ekz9of35utp/w7h8phsSinJoUjuD/e/ZjI95KTk4OCggLk5eXJPRQiIiIiWV0oeKeMFnS2ZfXTEoKh13HGz5M8ePU4hPl7o7iuDe86cdb54NkGtHWbERGgR0as5364s3hqLAL0OpQ2tOObkga5hzMixbWsWO9uTOSJiIiIqB9bC7oz1a0wK2CW8FAp98d7qkAfL+QsmAgAWPP5Gae1Wtt52ro/fp6HtZ27mK+3FjdnxgIA/u9YpcyjGRnOyLsfE3kiIiIi6icpzA8+Xhp0mSw4W98m93Au7I9PYiLvie69LAnxIb6oMnTif/addcox7fvj0z1zf3xvttZ5Bzx0Rt6WyI+PZKE7d2EiT0RERET9aDUS0qKVUfDO0GnEqWrrGGYmh8g6FhoZHy8tHv9OKgAg98siNHcYR3W8iqYOnK5u7Wk75/mJfHZKGADgTE0r6luV0/JxODqNZpQ3Wivuc0befZjIExEREdGA0hWSyOeXNkEI6yqBqEAfWcdCI3frzARMjApAc4cRf9tdPKpj2WbjZyaFItjPyxnDk1WYvzfSoq1JcN7ZRplH45iz9W0QAgjy0SEiwPNaAHoqJvJERERENCCltKBj/3h10Gok/GxROgDgH3tKUNsy8plnW/94NSyrt5kzzjor72nL64tqegrdRQVAkjy3VoGnkTWR3717N26++WbExcVBkiRs3bq1z/clSRrw68UXXxz0mOvXrx/wMZ2dnS5+NkRERETqYk/kq+VN5A+z0J1qXD8lGpmJIegwmrF2x5kRHaPLZMbenrZztr3lajBnXDgA4MDZeplH4hj7/vgILqt3J1kT+ba2NmRmZmLt2rUDfv/8+fN9vt544w1IkoTbbrvtkscNCgrq91gfHy7DIiIiInKELZE/W9+Gjm7nVBp3lNkicKS0CQATeTWQJAm/vME6K7/xQClK69sdPsbBs41o6zYjMlCPKXGe23buYnN69skXVBpg6BxdDQF3slesj2KhO3fSyXnyxYsXY/HixYN+PyYmps+/P/jgAyxYsADjx4+/5HElSer3WCIiIiJyTGSAHmH+3mho68aZmhZMTwhx+xhOV7egtcuEAL3OXnyPPNsVEyJwdWoEvjpTh5c/P42X75zh0ONt++PnpUWqail3TLAPksP9cK6+HYfONWKBh6w2YA95eciayDuiuroaH3/8MTZs2DDkfVtbW5GcnAyz2YwZM2bgd7/7HbKysga9f1dXF7q6LuzRMRgMAACj0QijcXifhtnuN9z7k/IxpurDmKoL46k+jKkypUX5Y39JN05UNGFy9PBn3JwVzwPF1iXUmQnBsJhNsMizMIDg3NfoE9dNxFdn6rA1vwLfvyIJk2KG/yHNlyetifw1E8NU934xOzkE5+rbsb+wDleNd/0KlNHGVAhhn5FPDvVRXTzczZGfnySEEC4cy7BJkoQtW7ZgyZIlA37/D3/4A55//nlUVlZecpn8/v37UVhYiGnTpsFgMODPf/4zPvnkExw9ehSpqakDPmbVqlVYvXp1v9s3btwIPz+/ET0fIiIiIjV4r0SD3VUazI+1YGmKxe3n/98zGhys0+CGBAsWJ7r//OQ6605rkF+vwZRQC1ZMGl5sG7qA1Yd10EDg99lm+HnMtOTwfFMjYWORFuMCBR6fqvxPrZq6gGd64vHiZWboWEp9VNrb23HPPfegubkZQUGX3jbiMYn8pEmTsHDhQrzyyisOHddisWDmzJm45ppr8Je//GXA+ww0I5+YmIi6urohf4A2RqMR27dvx8KFC+Hl5fktMIgxVSPGVF0YT/VhTJXp7YPl+M0HBbhiQhg2LJ897Mc5K57XvvQVyho78MYDM3H1xIgRH4dGz9mv0eLaNty4di/MFoFND2Zj9jBqIGw8UIZnPvoWs5NDsOnBOaMeg9KUNrTjupf3wEsr4dCvr4Wvt9al5xttTL8uqsfy9YcwLtwP2x6/ygUjHFsMBgMiIiKGlch7xGdYX331FU6dOoW33nrL4cdqNBpkZ2fjzJnBq2Lq9Xro9fp+t3t5eTn8Cz2Sx5CyMabqw5iqC+OpPoypsmTEhwAAztS0jSguo4lnTUsnyho7IEnA7HER/L1QCGe9RtPjQnDH7ARsOlCGlz4vxNsPzR1yz/tXhdbWbAsmRavy92F8VBBignxQZejEv6taccUE93x4NdKYljZaO4NNiApUZTzczZGfoUcsfvjHP/6BWbNmITMz0+HHCiGQn5+P2NhYF4yMiIiISN1SewrM1bZ0oaGt263nPnyuCQCQHh2IIB8mCWr04+tSoddpkHe20d4bfjBdJjP2Ftnazqmnf3xvkiR5VD/5ohpWrJeLrIl8a2sr8vPzkZ+fDwAoKSlBfn4+SktL7fcxGAx455138OCDDw54jPvvvx8rV660/3v16tX47LPPUFxcjPz8fPzgBz9Afn4+Hn74YZc+FyIiIiI1CtDrkBjmCwA4WWVw67lt/eNnsu2casUG+2L5FSkAgBf+dRIWy+C7fvNKGtHebUZUoB4ZseppO3cxj0rkbRXr2UPe7WRN5A8ePIisrCx7RfknnngCWVlZePrpp+332bx5M4QQuPvuuwc8RmlpKc6fP2//d1NTE1asWIHJkydj0aJFqKiowO7duzFnjvr20BARERG5Q3q0NWk6VdXi1vMeOmdN5GclMZFXs/+cPwGBPjqcrGrBR8cqB72fWtvOXeyynkT+cGkjuk3KLvDIHvLykTWRnz9/PoQQ/b7Wr19vv8+KFSvQ3t6O4ODgAY+xc+fOPvd/+eWXce7cOXR1daGmpgafffYZ5s6d6+JnQkRERKRettZg7kzku0xmHC9vBgDM4oy8qoX4eePheRMAAH/adnrQ5HXnaevS+wWTPKO/+khNjApAmL83Oo0W/LuyWe7hDKqty4TzzdY98uM5I+92HrFHnoiIiIjkk96TyJ90YyL/7woDus0WhPt7Izmc7YDV7v9dmYKIAD1KG9rxVl5pv++XNbSjsKYVWo2EK1XevUCSJGSnWD+8UvLy+pI667L6cH9vhPp7yzyasYeJPBERERFdkm1G/nR1yyX3MDvT4XMX9sereRk1Wfl56/Dj6yYCAP78RSHau019vm+bjZ+VFIpgX/UXPpwzLhyAshN527L68ZFcVi8HJvJEREREdEkpEf7w1mrQ3m1GeWOHW85p3x/PZfVjxl3ZSUgM80VdaxfWfX22z/d29eyPnz9JndXqL2bbJ593tgFmN3145ih7xfpILquXAxP5XnJzc5GRkYHs7Gy5h0JERESkGF5aDSZEWS/W3VG5XgiBQ6VM5Mcab50GP12YDgB4fVcRmtqt7Q47jWZ8XVgPAJifpu798TaTY4MQoNehpdPk9m4Rw1XUs7Seibw8mMj3kpOTg4KCAuTl5ck9FCIiIiJFSY+2Xqyfrnb9Pvnyxg7UtnTBSythWvzABY9Jnb6XGYdJMYFo6TThtV1FAKyz0h1GM6KD9JgcGyjzCN1Dq5EwW+H75NlDXl5M5ImIiIhoSOkx1hZ07ih4Z1tWPyUuGD5eWpefj5RDo5Hwixuss/Lrvz6LquZO7Dxl3R8/Py1qTNVLUHI/ebNF2IvdsWK9PJjIExEREdGQ3NmCjvvjx7YF6VGYnRyKLpMFf/7ijL1//Pz0sbE/3uayXom8EMraJ1/Z1IEukwXeWg0SQn3lHs6YxESeiIiIiIZka0FXXNeGLpPZpediIj+2SZKEXy6eBAB4K68URbVt0GkkXJmq7rZzF5sWHwK9ToP6tm4U1bbJPZw+bBXrUyL8oNMypZQDf+pERERENKTYYB8E+uhgtggU1bguqWjtulDci4n82JWdEoZrJ0XBVrB9ZnIognzU33auN2+dBjOTlLlP3vbBAgvdyYeJPBERERENSZKkC8vrq11XRftoWRMsAogP8UV0kI/LzkPK9/Pr02HbEr8gfWxUq7/YhX3y9TKPpC/2kJcfE3kiIiIiGhbb8npXFrzjsnqymRwbhBXXjEdSmB9umREn93BkYdsn/43C9smzh7z8dHIPgIiIiIg8g61yvSsL3jGRp95WLp6MlYsnyz0M2WQlhUKnkXC+uRPljR1IDPOTe0gArLUyACbycuKMPBERERENS3q0dUb+tIsSeYtF4HApE3kiG19vLaYnBANQzj755g4jalu6AHBpvZyYyBMRERHRsNgS+crmTjR3GJ1+/MLaVrR0muDnrbXvxyca6+aMCwegnES+uGd/fFSgHoFjrAChkjCR7yU3NxcZGRnIzs6WeyhEREREihPs54XYYGsButPVzp+Vty2rn5EYwpZWRD3s/eTPKiORZ8V6ZeA7ZC85OTkoKChAXl6e3EMhIiIiUiRXFrzj/nii/malhEKSgJK6NtQYOuUejn1GfkIUl9XLiYk8EREREQ2bLZE/VeX8FnSHexL5mUzkieyCfLyQEWstNKmEWXlb6znOyMuLiTwRERERDZu9l7yTZ+Qb2rrtlbBnJjKRJ+rtQj95JSTy1tfpeCbysmIiT0RERETDlh5tnRk8WdXi1L7Wttn41KgABPuxgBZRb5cpJJE3mS04V2/bI8+l9XJiIk9EREREwzYhyh9ajYSWThPONztvv+4htp0jGlR2ijWRP1nVgqb2btnGUdbYAaNZwMdLg7hgX9nGQUzkiYiIiMgBep0W4yKsM3GnnFi5/tBZ7o8nGkx4gB4To6xL2fN6XityKKqx7o8fHxEAjUaSbRzERJ6IiIiIHJTu5H3y3SYLjpY3AeCMPNFgLuyTr5dtDLZCd+O5rF52TOSJiIiIyCGTop2byBecN6DLZEGInxfGRzBBIBqIEvbJs2K9cjCRJyIiIiKHOLuXvL1/fFIoJInLdYkGYtsn/+9KA1q7TLKMobinYv2EKCbycmMi30tubi4yMjKQnZ0t91CIiIiIFGtSjLVyfVFNK4xmy6iPx/7xREOLC/FFQqgvzBZhf82424UZea6ckRsT+V5ycnJQUFCAvLw8uYdCREREpFgJob7w89ai22zB2Z7e7yMlhMDBc9alwtwfT3RpcvaTb2jrRmO7EQDsBS9JPkzkiYiIiMghGo2EtGjnLK+vbO5EtaELWo2EzIQQJ4yOSL3k3Cdvm42PD/GFn7fO7eenvpjIExEREZHDJjmpcr1tf/yUuCD4emtHPS4iNZszLhwAkF/WhE6j2a3nLmbFekVhIk9EREREDrPNyI+2l7x9f3wSl9UTDSUl3A+RgXp0my04Wtbk1nMX2QrdsWK9IjCRJyIiIiKHOXtGnvvjiYYmSZJs++SLanoK3bFivSIwkSciIiIih9la0JU2tKNthK2w2rtNKDhvAMBEnmi47Pvkz7o5kbdVrGehO0VgIk9EREREDgsP0CMiQA8AOD3C5fVHy5phtgjEBvsgLsTXmcMjUi3bjPyhc41Oaf84HF0mM8oaOwBwRl4pmMgTERER0YiMdnn94VL2jydyVFpUIIJ9vdDebcaJSoNbzlla3w6zRSBAr0NUoN4t56RLYyJPRERERCNiW14/0hZ09v3xLHRHNGwajYTsFNs++Xq3nNO+rD7SH5IkueWcdGlM5HvJzc1FRkYGsrOz5R4KERERkeKlj2JG3mIR9hl57o8ncoy7+8nbKtaPZ8V6xWAi30tOTg4KCgqQl5cn91CIiIiIFM++tL66BUIIhx5bXNeGpnYjfLw0yIgLcsXwiFSrd+V6i8Wx195I9J6RJ2VgIk9EREREI5IaFQhJAhraulHb2uXQY2394zMTQuCl5SUpkSOmxAXBz1sLQ6cJp0ZYbNIR7CGvPHzXJCIiIqIR8fXWIjnMDwBwuqrVoceyfzzRyOm0Gvtrx9XL64UQKGYPecVhIk9EREREI3ah4J1j1bMPcX880ai4a598bUsXWrpM0EhAcrifS89Fw8dEnoiIiIhGLD3Gur/dkYJ3Te3dKOyZ4ctixXqiEZkzLhwA8E1Jg8M1KhxhW1afGOYHvU7rsvOQY5jIExEREdGI9S54N1xHSpsAAOMj/RHm7+2KYRGp3vSEYHjrNKhr7UJJXZvLznOh0B2X1SuJrIn87t27cfPNNyMuLg6SJGHr1q19vr98+XJIktTn6/LLLx/yuO+99x4yMjKg1+uRkZGBLVu2uOgZEBEREY1ttqX1p6tbYB5m9Wz2jycaPR8vLWYkhgBw7fJ6VqxXJlkT+ba2NmRmZmLt2rWD3ueGG27A+fPn7V+ffPLJJY+5b98+3Hnnnbjvvvtw9OhR3HfffbjjjjvwzTffOHv4RERERGNeSrg/9DoNOo0WlDa0D+sxLHRH5Bzu2CfPHvLKpJPz5IsXL8bixYsveR+9Xo+YmJhhH3PNmjVYuHAhVq5cCQBYuXIldu3ahTVr1mDTpk2jGi8RERER9aXVSEiNDsC/Kww4VWXAuIhLz9qZzBbklzUBYCJPNFq2fvLfuDCRL+bSekWSNZEfjp07dyIqKgohISGYN28efv/73yMqKmrQ++/btw8/+clP+tx2/fXXY82aNYM+pqurC11dF3qfGgzWqqtGoxFGo3FY47Tdb7j3J+VjTNWHMVUXxlN9GFPPlRrpj39XGFBQ0Yzr0iMADB7PE5UGdBjNCPLRISlEz3h7EL5GlWdabAC0GgkVTR04W2tAfIivQ48fKqYd3WZUNHUAAJJC+Xp1NUd+vopO5BcvXozbb78dycnJKCkpwVNPPYVrr70Whw4dgl6vH/AxVVVViI6O7nNbdHQ0qqqqBj3Pc889h9WrV/e7fdu2bfDzc6zFwvbt2x26PykfY6o+jKm6MJ7qw5h6HkujBECL3UfPYELnqT7fuzieu89b7xvv041//etT9w2SnIavUWVJ8NPiXKuEv3+wE9mRI6teP1hMK9oAIXTw0wns3/k5JGk0I6WhtLcPb3sSoPBE/s4777T//9SpUzF79mwkJyfj448/xq233jro46SLfsOEEP1u623lypV44okn7P82GAxITEzEokWLEBQUNKyxGo1GbN++HQsXLoSXl9ewHkPKxpiqD2OqLoyn+jCmnivwTB0++J/DMGgCcOONVwEYPJ7b3z4GoArXz0rDjfPHyzRiGgm+RpXpmOYU/vH1ORhDknDjjVMceuxQMf34eBVw7BjSY0Nw002XOWvINAjbyvDhUHQif7HY2FgkJyfjzJkzg94nJiam3+x7TU1Nv1n63vR6/YAz/F5eXg6/SY3kMaRsjKn6MKbqwniqD2PqeaYkWPe6n61vhxka+Hhd6DV9cTyPlDUDsPbAZpw9E1+jyjJ3QiT+8fU55J1rGnFcBovpuYZOAMDEqEDG3A0c+Rl7VB/5+vp6lJWVITY2dtD7zJ07t9/SkG3btuGKK65w9fCIiIiIxqSoQD1C/LxgEUBhTeug96tq7kRFUwc0EpDZ0zaLiEYnOyUMkgQU17ahtqVr6Ac4wN56LoqF7pRG1kS+tbUV+fn5yM/PBwCUlJQgPz8fpaWlaG1txc9+9jPs27cPZ8+exc6dO3HzzTcjIiICS5cutR/j/vvvt1eoB4DHHnsM27ZtwwsvvICTJ0/ihRdewOeff47HH3/czc+OiIiIaGyQJAnp0dZ+8ierWga9n63t3OTYIPjrPWphKJFiBft52V9/eWedW72+iBXrFUvWRP7gwYPIyspCVlYWAOCJJ55AVlYWnn76aWi1Whw/fhy33HIL0tLS8MADDyAtLQ379u1DYGCg/RilpaU4f/68/d9XXHEFNm/ejHXr1mH69OlYv3493nrrLVx2Gfd0EBEREbnKpBjr9dmpqsH3eLJ/PJFruKKfvMUiUGzvIX/ptpLkfrJ+FDp//nwIMXhlxc8++2zIY+zcubPfbcuWLcOyZctGMzQiIiIickB6jLVA8CVn5EuZyBO5wpxx4diw75xTE/kqQyc6jGboNBKSwhzr5EWu51F75ImIiIhImdJjrEtvTw2SyHcazThRYS10NzOJiTyRM2WPs76mvq0yoLnDOb3ebcvqk8P94KVl2qg0jAgRERERjVpazx7dmpYuNLZ19/v+sfJmmCwCUYF6JIT6unt4RKoWFeiD8RH+EAI4dM45s/JFNdwfr2RM5ImIiIho1AJ9vBAfYk3QT1X3n5XvvT9ekiS3jo1oLJjTs0/+Gyctry+y749nIq9ETOR7yc3NRUZGBrKzs+UeChEREZHHuVDw7tKJPBE53xwnF7wrrrPNyLPQnRIxke8lJycHBQUFyMvLk3soRERERB4nPWbgFnRCCBzuKXQ3k4k8kUvYEvnj5c1o7zaN+nhFNdYZefaQVyYm8kRERETkFOmDtKA7W9+OhrZueOs0mBIXJMfQiFQvIdQP8SG+MFkEjpQ2jepYrV0mVBk6AQATIpjIKxETeSIiIiJyikk9LehOV7f2aTFsW1Y/PT4Yep1WlrERjQXO2idf3FOxPiLAG8F+XqMeFzkfE3kiIiIicopxEf7QaSS0dplQ0dRpv53744nc48I++fpRHcfWeo6F7pSLiTwREREROYW3TmNvVdW7cv1hJvJEbmFL5I+UNqHLZB7xcYp7Ktaz9ZxyMZEnIiIiIqex7ZM/U22d0TN0GHG6xprUs9AdkWuNj/BHRIA3ukwWHC9vHvFxbDPyrFivXEzkiYiIiMhp7AXvehL5o+XNEAJICfdDRIBezqERqZ4kSU7ZJ2+vWM8ZecViIk9ERERETmPrJX+6J5E/3FM9m7PxRO4xJ2V0/eTNFoGSeibySsdEnoiIiIicxjYjX1zXBpMFOFzWBID744ncZc64cADWIpMms8Xhx1c0dqDbZIG3ToP4UF9nD4+chIk8ERERETlNfIgvAvU6mCwCVR3A0TLrPl0m8kTukR4TiCAfHVq7TPj2fMvQD7iIvWJ9hD+0GsnZwyMnYSLfS25uLjIyMpCdnS33UIiIiIg8kiRJSOuZlT9cp0FbtxmBeh1SowJlHhnR2KDVSMhOse2Td7wN3YXWcyx0p2RM5HvJyclBQUEB8vLy5B4KERERkcdKi7Ym7d/UWGfzZiSFcGaPyI0u9JN3fJ/8hYr13B+vZEzkiYiIiMipbAXvWk3W5J3L6oncy5bI551tgMUiHHpsEXvIewQm8kRERETkVLaCdzZM5Inca2p8MHy9tGhsN6KwZ4Z9uIo5I+8RmMgTERERkVNN6pXISxIwIzFEvsEQjUFeWg1mJocAcKyffFN7N+pauwEA47hHXtGYyBMRERGRU4X4eSM6UA8ASI8KQKCPl8wjIhp75qRY29A5sk/etqw+JsgHAXqdS8ZFzsFEnoiIiIicLi3auiw3KylE3oEQjVEXCt7VQ4jh7ZO3L6uP4my80jGRJyIiIiKnu31WPML0ArfPipd7KERjUlZSCLy0EqoNXShtaB/WY1joznMwkSciIiIip1s8NQbPzDRjWnyw3EMhGpN8vLTITAgBMPx98mw95zmYyBMREREREamQo/3kbYn8eBa6Uzwm8r3k5uYiIyMD2dnZcg+FiIiIiIhoVBxJ5I1mC0rrrUvwOSOvfEzke8nJyUFBQQHy8vLkHgoREREREdGozEoOhUYCShvacb6545L3LW1oh8ki4OetRUyQj5tGSCPFRJ6IiIiIiEiFAn28MCXOWqdiqFn5opoLy+o1GsnlY6PRYSJPRERERESkUsNdXm+rWD8+gsvqPQETeSIiIiIiIpUabiJfzIr1HoWJPBERERERkUplp1gT+TM1rahv7Rr0fvbWc1GsWO8JmMgTERERERGpVJi/N9KirbPseWcbB7yPEMK+tJ4z8p6BiTwREREREZGKDbW8vqGtG80dRkgSMC6CM/KegIk8ERERERGRis0ZFw4AOHC2fsDvF9dZ+8fHh/jCx0vrtnHRyDGRJyIiIiIiUrE5PfvkCyoNMHQa+32/uI7L6j0NE/lecnNzkZGRgezsbLmHQkRERERE5BQxwT5IDveDRQCHzvXfJ1/M/fEeh4l8Lzk5OSgoKEBeXp7cQyEiIiIiInIa26z8QPvki3pm5MdHcn+8p2AiT0REREREpHKXKnhXwqX1HoeJPBERERERkcpd1lPw7lh5Ezq6zfbbjRagvLEDAHvIexIm8kRERERERCqXGOaLmCAfGM0CR8ou7JOv7QQsAgj00SEyQC/jCMkRTOSJiIiIiIhUTpKkAZfX13RIAIDxkQGQJEmWsZHjmMgTERERERGNAQMn8tb/TmChO48iayK/e/du3HzzzYiLi4MkSdi6dav9e0ajEb/85S8xbdo0+Pv7Iy4uDvfffz8qKysvecz169dDkqR+X52dnS5+NkRERERERMp1WU8if7i0Ed0mCwCgumdGnoXuPIusiXxbWxsyMzOxdu3aft9rb2/H4cOH8dRTT+Hw4cN4//33cfr0aXzve98b8rhBQUE4f/58ny8fHx9XPAUiIiIiIiKPMDEqAGH+3ug0WnC8ohkAE3lPpZPz5IsXL8bixYsH/F5wcDC2b9/e57ZXXnkFc+bMQWlpKZKSkgY9riRJiImJcepYiYiIiIiIPJkkSchOCcVnJ6pxoKQB02L9ubTeQ8mayDuqubkZkiQhJCTkkvdrbW1FcnIyzGYzZsyYgd/97nfIysoa9P5dXV3o6uqy/9tgMACwLu83Go3DGpvtfsO9PykfY6o+jKm6MJ7qw5iqC+OpPoypOsxKCsFnJ6qxv7gOiyeHocsiQStJiA3yZmxl5sjPXxJCCBeOZdgkScKWLVuwZMmSAb/f2dmJq666CpMmTcI///nPQY+zf/9+FBYWYtq0aTAYDPjzn/+MTz75BEePHkVqauqAj1m1ahVWr17d7/aNGzfCz89vRM+HiIiIiIhIacpagT8e18FHK/D/0ix47VstIn0EnswyD/1gcqn29nbcc889aG5uRlBQ0CXv6xGJvNFoxO23347S0lLs3LlzyCfVm8ViwcyZM3HNNdfgL3/5y4D3GWhGPjExEXV1dcM+l9FoxPbt27Fw4UJ4eXkNe3ykXIyp+jCm6sJ4qg9jqi6Mp/owpupgtgjMenYH2rrMWJYVi3ePnMeCtHD8932z5B7amGcwGBARETGsRF7xS+uNRiPuuOMOlJSUYMeOHQ4l8QCg0WiQnZ2NM2fODHofvV4PvV7f73YvLy+H36RG8hhSNsZUfRhTdWE81YcxVRfGU30YU8/mBSA7JQw7T9XikxM1AKw95BlT+TkSA0X3kbcl8WfOnMHnn3+O8PBwh48hhEB+fj5iY2NdMEIiIiIiIiLPYusn395tXU7PQneeR9YZ+dbWVhQWFtr/XVJSgvz8fISFhSEuLg7Lli3D4cOH8X//938wm82oqqoCAISFhcHb2xsAcP/99yM+Ph7PPfccAGD16tW4/PLLkZqaCoPBgL/85S/Iz89Hbm6u+58gERERERGRwtj6yduMj2Ai72lkTeQPHjyIBQsW2P/9xBNPAAAeeOABrFq1Ch9++CEAYMaMGX0e9+WXX2L+/PkAgNLSUmg0FxYWNDU1YcWKFaiqqkJwcDCysrKwe/duzJkzx7VPhoiIiIiIyANMiw+BXqdBl8kCABjPGXmPI2siP3/+fFyq1t5w6vDt3Lmzz79ffvllvPzyy6MdGhERERERkSp56zSYmRSKfcX18NcJhPp5yz0kcpCi98gTERERERGR89n2yUf5yjwQGhHFV60nIiIiIiIi57ozOxFfF9Zimr5e7qHQCHBGnoiIiIiIaIyJC/HFpgfnYEb40NuZSXmYyPeSm5uLjIwMZGdnyz0UIiIiIiIiogExke8lJycHBQUFyMvLk3soRERERERERANiIk9ERERERETkQZjIExEREREREXkQJvJEREREREREHoSJPBEREREREZEHYSJPRERERERE5EGYyBMRERERERF5ECbyRERERERERB6EiTwRERERERGRB2EiT0RERERERORBmMj3kpubi4yMDGRnZ8s9FCIiIiIiIqIBMZHvJScnBwUFBcjLy5N7KEREREREREQDYiJPRERERERE5EGYyBMRERERERF5ECbyRERERERERB6EiTwRERERERGRB2EiT0RERERERORBdHIPQImEEAAAg8Ew7McYjUa0t7fDYDDAy8vLVUMjN2JM1YcxVRfGU30YU3VhPNWHMVUfxlRZbPmnLR+9FCbyA2hpaQEAJCYmyjwSIiIiIiIiGktaWloQHBx8yftIYjjp/hhjsVhQWVmJwMBASJI0rMcYDAYkJiairKwMQUFBLh7hBdnZ2bL0vZfjvO4+51iK6Vg5J2OqrnMynuo7L2OqrnPKFU9gbPx85TgnX6PqOy9jqqxzCiHQ0tKCuLg4aDSX3gXPGfkBaDQaJCQkjOixQUFBbn0RaLVat/9xlOu8cj3XsRDTsXJOG8ZUPecEGE81npcxVc85AffHExg7P9+xEtOx9LNlTHnOoWbibVjszsPl5OSMmfPK9Vzdbaz8bMdKPIGx8/MdKzEdSz9bxpTn9FRj5ec7VmI6ln62jCnPOVxcWu8kBoMBwcHBaG5ulm2WkZyLMVUfxlRdGE/1YUzVhfFUH8ZUfRhTz8UZeSfR6/V45plnoNfr5R4KOQljqj6MqbownurDmKoL46k+jKn6MKaeizPyRERERERERB6EM/JEREREREREHoSJPBEREREREZEHYSJPRERERERE5EGYyBMRERERERF5ECbyRERERERERB6EifwIsNC/5+vs7JR7CORkJpPJ/v98jRIpT3l5Oc6fPw+Ar1E1Ykw9H6+N1IfXRurG9nND6O7uxssvvwx/f39MmzYN8+bNk3tINEK2X/Uf//jHKCgowDvvvIOwsDCZR0Wj1d3djaeffhoNDQ2IjY3Fr371K/j6+so9LBoFo9GIf/7znwgJCcHkyZMxadIkuYdEo2A0GvHoo4/i008/xaOPPopf/OIXcg+JRonXRurBayN14rXR2MAZ+Uv49NNPERcXh61bt2LdunVYunQpnnzySX5i6aEkSUJTUxPeffddfPnll3j77bflHhKN0tatW5GcnIwDBw7Ax8cHL774IlasWAEhBD959lB//etfER0djTfeeAOPP/44brvtNvtr1WKxyDw6clRZWRmuvPJKHD9+HO+88w7uvvtuvj49HK+N1IXXRurDa6OxgzPyl3DHHXcgLCwMr7/+OhobG/HFF1/gP/7jP/D888/joYce4idbHmjPnj14/fXXkZaWhj//+c/Iz89HYmKi3MOiEejq6sLSpUuRlZWF3//+9wCADz74APfccw/q6+vh4+Mj8wjJESaTCa+88grWrVuHX/3qV7jnnntw7Ngx/P3vf8fevXtx4MABaDT87NnT/OMf/8DmzZuxbds2SJKE8vJyREdHw8vLS+6h0Qjx2kh9eG2kHrw2Glt4VdSL2Wy2/39JSQn27t2Lq6++GgAQGhqKZcuWYcWKFfjnP/+JPXv2yDVMGiZbPHt/Aunl5YXCwkL85Cc/QWBgIJ577jk5h0gO6v0aPX78OHbu3InrrrvOfltVVRVWrFjBmVsP0traivb2dvv/L1u2DHfddRcAYPr06ZgyZQp0Oh1qa2vlHCYNU+94CiFw8OBBZGZmoqmpCXfccQcWLlyIOXPmYMWKFaiqqpJ5tOSo4uJiXhupCK+N1OfYsWO8NhpDmMj3eOqpp/DUU0/Z/52SkgKTyQSDwQAA6OjoAAA888wzaGtrw6efforW1lZZxkpD6x1PSZIgSRIA4ODBg0hNTUVgYCD+67/+C//4xz9w8OBBvP766ygqKpJzyDSEi1+js2fPRnh4ONauXYtPP/0UP//5z/HII49gx44dSE1NxWuvvWZP/rjwSJl+/vOfY+7cuWhoaIBWq8W9996Lp59+GhqNxh6z0NBQtLa2IioqSubR0lBs8ayvrwdgfe89ceIEAGDNmjUAgLVr1+Lhhx/GRx99hGeeeQYVFRUA+BpVqm3btuHo0aP2D1HHjRsHo9HIayMPZYunLaHjtZHnu/g1mp2djbCwMF4bjRFjPpH/4IMPEBMTg+3btyM+Ph6NjY0ArHsxly5ditdffx0A4OvrC6PRiPDwcCxfvhzvvvtun0qQpAyXiqdNaGgoAOA//uM/kJKSgjlz5uDNN9+UZbw0tIFiavvj8+abbyI2NharVq3C1q1bsX37drzzzjt45JFH8PLLL+PTTz8FcOFihZTh9ddfR3BwMDZv3owTJ06gsLAQkiRh/PjxAKyvV1vM/vWvfyErKwuSJMFoNMo5bBrExfEsLi62f2/p0qVYs2YNNm/ejF/84he47rrr8NBDD+G5557D119/jSNHjgDga1Rp1q9fj9jYWPzsZz/D1VdfjR//+MeorKyEJEm8NvJAF8fzRz/6kb2DhA2vjTzLQK/R8vJyALw2GlPEGNba2ipuvvlm8dvf/nbA77/33nsiPT1drFmzRgghRGdnpxBCiNraWuHr6yu++uort42VhjZUPIUQIicnR7z22mvi9OnTYsqUKSI0NFRoNBrxz3/+040jpeEaTky7u7vFokWLxIYNG/rcPmXKFPHrX//a1UMkB3z11Vdi3LhxIjY2VmzcuFEUFRWJmTNnir/97W/97msymYTRaBQzZ84Uf/3rX/t932w2u2PIdAmDxfO///u/7fc5cuSIyMrKEikpKaKioqLP4+Pj48Vrr73m7mHTEP7+97+LiRMnik2bNona2lrx5ptvCn9/f5Gfny+EsF4bTZo0iddGHmKgeAYEBNjjKYQQjz76KK+NPMhQr1EhhDAajbw2GgPG9Iz8zp07sX//fvzmN79BY2MjfvWrX+GFF16wfwJ53XXXYdGiRfjTn/6EyspK6PV6AMCRI0cQGRmJwMBAOYdPFxksnps2bbIvOdJoNHjssccwZcoUXHPNNThz5gx++MMf4plnnrEvByXluFRMbassamtrkZeXh/nz5wOw7qNvbm6Gr68v/P39ZRw9XezDDz/EjTfeiJKSEtx9990YP3486uvr7cure9dA0Gq1qKurQ01Njb21VX5+PpYvXw4ALHynAAPFs6GhAZWVlfb7pKWl4d5770VZWRm+/vpr++21tbUICwvj31EFEULAbDZjx44dmDt3Lu666y5ERETgnnvuQXx8vP0998orr+S1kQe4VDzj4uLss7EmkwlarZbXRh5gqNdob7w2GhvG5JWQ6FmWW11djSuvvBJffvklZs2ahfz8fOzduxcPPPAAfvSjH8FiseCJJ55AQkICbrrpJrz55psoLCzEG2+8gbS0NKSmpsr8TAgYOp733XcfHn/8cbS2tmLmzJlYvnw59u3bh1dffRXh4eF48sknUVlZiWPHjsn8TMhmuDGtqKhAVFQUEhMT8fDDD+PYsWMoLy/HT3/6U7S1teGWW26R+ZlQb88//zzWrl0LvV5vX347f/58e4EsrVbb5/6ff/45xo0bh7i4OPzgBz/AnDlz0NTUBIvFwr19CjBQPOfNm9en4Jmfnx+WL1+OJUuW4Kc//SlWrVqF/Px8rFy5EjqdDtdee61cw6eLSJIErVaLgoIC6PV6VFdXA7D2F5ckCR9++CH27duH6OhoPPbYY7w2Urih4rllyxbs27cPOp0O06dP57WRBxgqplu3bsX+/fvR3t6O8PBwXhuNBTKuBnCbt99+Wzz44INizZo14tixY/bbN23aJIKDg8Ujjzwinn76adHd3S2EEGL9+vXisssuE3/84x+FEEJUVVWJG264QUyePFnEx8eLK6+8UpSUlMjxVEiMLJ7Z2dn2ZYAmk6nfMZuamtwzeBrQaF+ju3fvFpGRkSItLU0kJCSIBQsWiDNnzsjyXMhqsJhevCT+oYceEgsWLBDNzc39jnHXXXcJrVYrAgMDxezZs8W3337r8nHTwEYST4vFYr+9u7tb/PjHPxazZs0S6enpYt68eaKwsNBt46f+Bovp5s2bRXJysli0aJEIDw8XkyZNEr/97W/FggULxPTp08Xzzz8vhOC1kdKMJJ5Tp04Vf/rTn4QQvDZSopHENDMz0/4a5bWR+qk6ka+rqxPLli0TMTEx4uGHHxZXXXWViIuLE+vXrxdCCGGxWMTUqVOFJEli3bp19sdZLBZx2223iR/84Aeiq6tLCGHdA3b+/Hlx/PhxOZ4KidHH88EHHxzwDxXJxxmvUVtMS0tLxYEDB8SBAwfkeCrUY7CY9t6nZ7FY7Ang+vXrRVBQUJ/Xpi0BvPvuu0VKSor4+OOP3fskyM4Z8eyd7Le2tjKBl9lgMe39HltTUyNefPFFMW/ePGEwGOy3//CHPxRLly4V1dXVQgghOjo6eG0kM2fEs66uToaR02BGG9MlS5bYY3ru3DleG6mYTu4VAa705ZdforS0FAcPHrTvHVmyZAlWr16N4OBgLFmyBI888ghycnLQ3t4Ok8kEnU4HSZIQGBiIgoICeHt7AwC8vb0RExODmJgYOZ/SmDbaeJ44caLf0l2SlzNeo7aYJiYmIjExUc6nQxg8pqtWrUJQUBCWLFkCIYR9j3tCQgKCg4Oxa9cu+zJr297N1atXc5muzJwRz971DPz9/TFhwgT3PxGyGyymv/3tbxEcHIylS5ciNDQUhw4dwsKFCxEYGIju7m54e3sjMDAQO3bssO+x1ev1vDaSmTPi6evrK/OzoN6cEVMfHx8AQFJSEpKSkuR8OuRCqt4jv3HjRiQkJCA+Pt7e13Tp0qU4e/Ys1q5di/r6ejz00ENYuHAhXnnlFezYsQMAUFVVhcrKSnz/+9+3H4stGuTnzHiSMjCm6jNUTOvq6qDRaOyF7cLCwtDd3d2n0J0Nk3j5OTOepAyXimlubi5qamqg0+lQX1+PgwcPArBOZlRXV+P06dO466677Ik8r43k54x4+vn5yfkU6CLOfI2Suqkmkd+9ezc+++yzPv1LU1NTceLECQBAQEAAAODkyZO49tpr0dHRgffffx8ajQZvvvkmoqKicM899+DGG2/EjBkzYDQacdNNN8nyXIjxVCPGVH0cjWlnZye2bNkC4EJhu6ysLFgslj4VzUkejKf6jCSmW7duBQCsXLkSH3/8Ma688ko88sgjmD17NgwGA1asWOH250FWjKf6MKY0KnKv7R+t2tpacf/99wtJkkRmZmafQitFRUUiMjJSzJs3T7zwwgti7ty5Yty4ceKLL74QmZmZ4sknn7Tv46uurhbbtm0TL774otiyZYs8T4YYTxViTNVnNDF96qmnhBAX9sHX1taK//zP/xQ7duyQ46mQYDzVaLTvuzZbtmwRv/zlL8U999wj3n77bRmeCQnBeKoRY0rO4NGJvNFoFK+++qq4/vrrxebNm4Wfn5947rnnRGdnp/0+e/bsET/84Q/FzJkzxaOPPipqa2uFEELcd9994rbbbpNr6DQAxlN9GFP1YUzVhfFUH8ZUXRhP9WFMyVk8OpEXQoj9+/eLjz76SAghxOrVq0VkZKQ4cuRIv/vZqs8LYZ3Zmzp1qviv//ovIUT/9jkkH8ZTfRhT9WFM1YXxVB/GVF0YT/VhTMkZPD6R792nVggh4uLixIoVK+ytGHp/v6OjQ3R3d4tXX31VZGVl9enJSMrAeKoPY6o+jKm6MJ7qw5iqC+OpPowpOYPHJ/I2tk+s3n77baHT6cS2bdv6fL+8vFy8+uqrYvbs2SIsLExs3LhRjmHSMDGe6sOYqg9jqi6Mp/owpurCeKoPY0qjIQkhhNwF95ztiiuugL+/v73SdW1tLSIjI7Fp0yZUVlbipz/9qdxDJAcwnurDmKoPY6oujKf6MKbqwniqD2NKjlJVIm8ymaDT6XDixAlkZmbipZdeQlFREfbs2YMNGzZg6tSpcg+RHMB4qg9jqj6MqbownurDmKoL46k+jCmNlKoS+d7mzJmDgwcPIikpCX/9619x/fXXyz0kGgXGU30YU/VhTNWF8VQfxlRdGE/1YUzJERq5B+BsRUVFmDZtGk6cOIG//e1vOHv2LF8EHozxVB/GVH0YU3VhPNWHMVUXxlN9GFMaCdUl8lqtFrfddhvq6urwgx/8QO7h0CgxnurDmKoPY6oujKf6MKbqwniqD2NKI6HapfVEREREREREaqS6GXkiIiIiIiIiNWMiT0RERERERORBmMgTEREREREReRAm8kREREREREQehIk8ERERERERkQdhIk9ERERERETkQZjIExEREREREXkQJvJERETkkFWrVmHGjBlyD4OIiGjMkoQQQu5BEBERkTJIknTJ7z/wwANYu3Yturq6EB4e7qZRERERUW9M5ImIiMiuqqrK/v9vvfUWnn76aZw6dcp+m6+vL4KDg+UYGhEREfXg0noiIiKyi4mJsX8FBwdDkqR+t128tH758uVYsmQJnn32WURHRyMkJASrV6+GyWTCz3/+c4SFhSEhIQFvvPFGn3NVVFTgzjvvRGhoKMLDw3HLLbfg7Nmz7n3CREREHoiJPBEREY3ajh07UFlZid27d+Oll17CqlWr8N3vfhehoaH45ptv8PDDD+Phhx9GWVkZAKC9vR0LFixAQEAAdu/ejT179iAgIAA33HADuru7ZX42REREysZEnoiIiEYtLCwMf/nLX5Ceno7vf//7SE9PR3t7O379618jNTUVK1euhLe3N77++msAwObNm6HRaPD3v/8d06ZNw+TJk7Fu3TqUlpZi586d8j4ZIiIihdPJPQAiIiLyfFOmTIFGc2F+IDo6GlOnTrX/W6vVIjw8HDU1NQCAQ4cOobCwEIGBgX2O09nZiaKiIvcMmoiIyEMxkSciIqJR8/Ly6vNvSZIGvM1isQAALBYLZs2ahTfffLPfsSIjI103UCIiIhVgIk9ERERuN3PmTLz11luIiopCUFCQ3MMhIiLyKNwjT0RERG537733IiIiArfccgu++uorlJSUYNeuXXjsscdQXl4u9/CIiIgUjYk8ERERuZ2fnx92796NpKQk3HrrrZg8eTK+//3vo6OjgzP0REREQ5CEEELuQRARERERERHR8HBGnoiIiIiIiMiDMJEnIiIiIiIi8iBM5ImIiIiIiIg8CBN5IiIiIiIiIg/CRJ6IiIiIiIjIgzCRJyIiIiIiIvIgTOSJiIiIiIiIPAgTeSIiIiIiIiIPwkSeiIiIiIiIyIMwkSciIiIiIiLyIEzkiYiIiIiIiDwIE3kiIiIiIiIiD/L/ASexS7Y7GK0DAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "cold_days_mean = cold_days.mean(dim=['latitude', 'longitude']) # Averaging over the spatial dimensions\n", - "\n", - "# Plotting the time series\n", - "plt.figure(figsize=(12, 6))\n", - "cold_days_mean.plot()\n", - "plt.title('Number of Days with Daily Maximum Temperature Below the 10th Percentile')\n", - "plt.xlabel('Time')\n", - "plt.ylabel('Number of Days')\n", - "plt.grid(True)\n", - "plt.minorticks_on()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "\n", - "cold_days_mean = cold_days.mean(dim=['latitude', 'longitude']) # Averaging over the spatial dimensions\n", - "\n", - "# Convert to a pandas Series for easier manipulation\n", - "cold_days_series = cold_days_mean.to_series()\n", - "\n", - "# Calculate a linear trendline\n", - "slope, intercept = np.polyfit(cold_days_series.index.year, cold_days_series.values, 1)\n", - "trendline = slope * cold_days_series.index.year + intercept\n", - "\n", - "# Calculate a 10-year moving average\n", - "moving_average = cold_days_series.rolling(window=10*365, center=True).mean() \n", - "\n", - "# Plotting the time series, trendline, and moving average\n", - "plt.figure(figsize=(12, 6))\n", - "plt.plot(cold_days_series.index, cold_days_series.values, label='Daily Data')\n", - "plt.plot(cold_days_series.index, trendline, label='Trendline', color='red')\n", - "plt.plot(moving_average.index, moving_average.values, label='10-Year Moving Average', color='green')\n", - "plt.title('Number of Days with Daily Maximum Temperature Below the 10th Percentile')\n", - "plt.xlabel('Time')\n", - "plt.ylabel('Number of Days')\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.minorticks_on()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/IAAAIhCAYAAADtv4ENAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3wT9f/A8VfSvUsLHdDSsqGsMspU9h4yREBQQERU6gB/KCJDliIOxIHKV1miLGU4QJbsXUZZZdMyO6DQvdLmfn+ExIa20ELbtOn7+XjcA3K53L0vn+Sa932WSlEUBSGEEEIIIYQQQpQKalMHIIQQQgghhBBCiPyTRF4IIYQQQgghhChFJJEXQgghhBBCCCFKEUnkhRBCCCGEEEKIUkQSeSGEEEIIIYQQohSRRF4IIYQQQgghhChFJJEXQgghhBBCCCFKEUnkhRBCCCGEEEKIUkQSeSGEEEIIIYQQohSRRF6IIrJkyRJUKhW2trZcvXo1x/Pt2rWjXr16JogMdu7ciUql4vfffzfJ8QsqIiKCnj174ubmhkqlYuzYsXlu6+/vj0qlQqVSoVarcXFxoU6dOgwbNowtW7YUX9DFRF+WO3fuNKzbuHEj06ZNy3V7lUrFG2+88VjHioiIMLy3KpUKKysr3N3dCQoKYty4cZw5c+ax9ps9tuxx53ZuT0L/ncxrn4qiUL16dVQqFe3atSuUY+bF39+fESNGFOkxisu0adOMPhd5LUX9npZkKSkpTJs2rdA+y4Ut+3VT/3erevXqvPPOO9y5c+ex9lnY39/HVVTXw4L4+++/GTZsGPXr18fKygqVSpXnthqNhunTp+Pv74+NjQ21a9fmm2++ybHd8uXLmTdvXo71+uv0559//lix6stNv1hYWODp6clzzz3H2bNnH2ufJcmtW7eYNm0aoaGhOZ7TX8uya9euXZm+domSzdLUAQhh7tLT05k8eTLLli0zdSil1rhx4zh06BCLFi3Cy8sLb2/vh27funVrw4+YpKQkzp8/z8qVK+natSvPPvssK1aswMrKqjhCL3KNGzfmwIEDBAQEGNZt3LiR+fPn5/nj9Um9+eabDBkyBK1WS1xcHMePH2fRokV88803zJ49m3ffffex9nvgwAF8fHwKOdqcnJycWLhwYY4fZ7t27eLy5cs4OTkVeQzr1q3D2dm5yI9THEaNGkW3bt0MjyMjI+nfv7/hc6JnLuf7OFJSUpg+fTpAiU0Ksl83U1NTOXLkCNOmTWP37t0cOXLExNE9vqK+HubHunXrOHjwII0aNcLGxoajR4/mue2YMWNYtmwZM2fOJCgoiM2bN/P222+TmJjIBx98YNhu+fLlnD59+qE3tp/Exx9/TPv27cnIyODIkSPMmDGDf//9l1OnTlGpUqUiOWZxuHXrluFGSWBgoNFzD17LhCjpJJEXooh169aN5cuXM378eBo2bGjqcIpVamoqtra2D619yI/Tp0/TrFkz+vbtm6/tXV1dadGiheFxp06dCA4OZtq0aUyfPp3JkyczZ86cJ4qppHB2djY61+JQuXJlo2P26NGDd955h/79+/Pee+9Rr149unfvXuD9Ftd5DBo0iF9//ZX58+cbJZcLFy6kZcuWJCQkFHkMjRo1KvJjFBcfHx+jGzARERFAzs+JOdFoNKhUKiwtTfszSlEU0tLSsLOze+J9PXjdbN++PYmJicycOZMLFy5Qs2bNJz5GWfXjjz+iVusawb7xxht5JvJnzpxh4cKFfPTRR4Ybou3atSM2NpZZs2bx2muv4ebmViwx16hRw/B5aNOmDa6urrz88sssWbKESZMmPdG+U1JSsLe3L4wwC9WD1zIhSjppWi9EEXvvvfdwd3dnwoQJD91O3xxuyZIlOZ57sMmxvvnXyZMnee6553BxccHNzY133nmHzMxMzp8/T7du3XBycsLf359PP/0012OmpaXxzjvv4OXlhZ2dHW3btuX48eM5tjty5AjPPPMMbm5u2Nra0qhRI1avXm20jb7Z8pYtWxg5ciQVKlTA3t6e9PT0PM/52rVrvPDCC3h4eGBjY0OdOnX44osv0Gq1wH9N/C5dusQ///xjaOqnTxQKatq0adStW5dvv/2WtLQ0w/rp06fTvHlz3NzccHZ2pnHjxixcuBBFUQzbvPzyy7i5uZGSkpJjvx06dKBu3bqGx7/99hvNmzfHxcUFe3t7qlatysiRIx8a23PPPWe0D4DevXujUqn47bffDOuOHTuGSqXir7/+AnI2Xx0xYgTz588HMGoe+eB7tmzZMurUqYO9vT0NGzbk77//fmh8j2JnZ8fChQuxsrLis88+M6y/ffs2Y8aMISAgAEdHRzw8POjQoQN79uzJsY8HP+cPWrZsGSqVigMHDuR4bsaMGVhZWXHr1q1Hxvr8888DsGLFCsO6+Ph41qxZk2c55eczsnfvXqysrBg/frzRa/XfjYULFxrWPdi0Xl+Oy5cvZ8KECXh7e+Po6Ejv3r2Jjo4mMTGR0aNHU758ecqXL89LL71EUlKS4fWmuH4UVEGuI9u3b+eVV17B3d0dZ2dnhg0bRnJyMlFRUQwcOBBXV1e8vb0ZP348Go0mx/vw6aef8tFHH1G5cmVsbW1p2rQp//77b46YLl68yJAhQ4yuQfrvj56+bJYtW8b//d//UalSJWxsbLh06VK+Pt8RERFUqFAB0H2O9N9JffmPGDECf3//HLHl1sxX3xT8hx9+oE6dOtjY2LB06dJ8n0tBubi4AORowZSfsszLn3/+ScuWLbG3t8fJyYnOnTsbfafPnDmT47p39OhRVCpVjmvkM888Q5MmTfI8VmFeD5/k/dUn8Y+yfv16FEXhpZdeMlr/0ksvkZqayqZNmwBdcr9hwwauXr1qdF4Pmjt3LlWqVMHR0ZGWLVty8ODBfMWRG31Sn72r4KpVq2jZsiUODg44OjrStWvXHL8hRowYgaOjI6dOnaJLly44OTnRsWNHQNdiccaMGdSpUwdbW1vc3d1p3749+/fvN7xeURS+++47AgMDsbOzo1y5cgwYMIArV64YHUffXTEkJISnn37a8Lf3k08+MfpNERQUZHhP9e+b/vqY23cuNxkZGcyaNYvatWtjY2NDhQoVeOmll7h9+3YB31Uhnowk8kIUMScnJyZPnszmzZvZvn17oe574MCBNGzYkDVr1vDKK6/w5ZdfMm7cOPr27UvPnj1Zt24dHTp0YMKECaxduzbH6z/44AOuXLnCTz/9xE8//cStW7do166d0R/IHTt20Lp1a+Li4vjhhx/4448/CAwMZNCgQbkmDSNHjsTKyoply5bx+++/59mE/fbt27Rq1YotW7Ywc+ZM/vzzTzp16sT48eMNfRb1zca9vLxo3bo1Bw4c4MCBA49sWv8wvXv3JiUlxaipaEREBK+++iqrV69m7dq1hmbBM2fONGzz9ttvc+/ePZYvX260v7CwMHbs2EFwcDCgax4+aNAgqlatysqVK9mwYQNTp04lMzPzoXF16tSJsLAwIiMjAcjMzGTXrl3Y2dmxdetWw3bbtm3D0tIyz+a5U6ZMYcCAAYZYcnvPNmzYwLfffsuMGTNYs2YNbm5u9OvXL8cPo4KqWLEiTZo0Yf/+/YbzvXv3LgAffvghGzZsYPHixVStWpV27doVuO/soEGD8PLyyvHjOTMzkwULFtCvXz8qVqz4yP04OzszYMAAFi1aZFi3YsUK1Go1gwYNyvU1+fmMPPXUU8yaNYsvvviCP//8E9AlJcHBwbzwwgu8/PLLj4ztgw8+ICYmhiVLlvDFF1+wc+dOnn/+eZ599llcXFxYsWIF7733HsuWLTNqZvs4nvT6URAFvY6MGjUKFxcXVq5cyeTJk1m+fDmvvPIKPXv2pGHDhvz+++8MHz6cL774Itf+w99++y2bNm1i3rx5/PLLL6jVarp3726UMIaFhREUFMTp06f54osv+Pvvv+nZsydvvfWWoRl8dhMnTuTatWv88MMP/PXXX3h4eOTr8+3t7W1IwF5++WXDd3LKlCmP9V6uX7+e77//nqlTp7J582aefvrpAp9LbhRFITMzk8zMTJKSktixYwfz5s2jdevWVKlSxbBdQcsyu+XLl9OnTx+cnZ1ZsWIFCxcu5N69e7Rr1469e/cCULduXby9vdm2bZvhddu2bcPOzo6wsDDDzTr9NbJTp055Hq+wroeF8f7mx+nTp6lQoQJeXl5G6xs0aGB4HuC7776jdevWeHl5GZ1XdvPnz2fr1q3MmzePX3/9leTkZHr06EF8fPxjxXbp0iUAw02pjz/+mOeff56AgABWr17NsmXLSExMNHwes8vIyOCZZ56hQ4cO/PHHH0yfPp3MzEy6d+/OzJkz6dWrF+vWrWPJkiW0atWKa9euGV776quvMnbsWDp16sT69ev57rvvOHPmDK1atSI6OtroOFFRUQwdOpQXXniBP//8k+7duzNx4kR++eUXQPebYvHixQBMnjzZ8L6NGjUq3++DVqulT58+fPLJJwwZMoQNGzbwySefsHXrVtq1a0dqamrB31whHpcihCgSixcvVgAlJCRESU9PV6pWrao0bdpU0Wq1iqIoStu2bZW6desatg8PD1cAZfHixTn2BSgffvih4fGHH36oAMoXX3xhtF1gYKACKGvXrjWs02g0SoUKFZT+/fsb1u3YsUMBlMaNGxviURRFiYiIUKysrJRRo0YZ1tWuXVtp1KiRotFojI7Vq1cvxdvbW8nKyjI632HDhuXr/Xn//fcVQDl06JDR+tdff11RqVTK+fPnDev8/PyUnj175mu/j9r2+++/VwBl1apVuT6flZWlaDQaZcaMGYq7u7vR+9O2bVslMDAwR7zOzs5KYmKioiiK8vnnnyuAEhcXl6949S5duqQAys8//6woiqLs3btXAZT33ntPqVKlimG7zp07K61atTI81pfljh07DOuCg4OVvC7vgOLp6akkJCQY1kVFRSlqtVqZPXv2Q2PUf0Y/++yzPLcZNGiQAijR0dG5Pp+ZmaloNBqlY8eOSr9+/XLElv1zntu5ffjhh4q1tbXR/letWqUAyq5dux4af/bvpH7fp0+fVhRFUYKCgpQRI0YoiqIodevWVdq2bZvnfh72GdFqtUqPHj0UV1dX5fTp00pAQIBSu3ZtJSkpyWgffn5+yvDhw3Oca+/evY22Gzt2rAIob731ltH6vn37Km5ubobHxXn9eJTcPicFvY68+eabOc4XUObOnZsj5saNG+c4dsWKFZXU1FTD+oSEBMXNzU3p1KmTYV3Xrl0VHx8fJT4+3mifb7zxhmJra6vcvXtXUZT/yqZNmzaPPPe8Pt+3b9/OUQ56w4cPV/z8/HKs15dTdoDi4uJiiK2g55IXPz8/BcixNGvWTImMjDTaNr9l+eD3NysrS6lYsaJSv359wzaKoiiJiYmKh4eH0XXthRdeUKpWrWp43KlTJ+WVV15RypUrpyxdulRRFEXZt2+fAihbtmx56LkVxvXwSd/f/MbTuXNnpVatWrk+Z21trYwePdrwuGfPnrl+bvTfgfr16yuZmZmG9YcPH1YAZcWKFQ+NT19uq1atUjQajZKSkqLs3r1bqV69umJhYaGcOHFCuXbtmmJpaZnje5qYmKh4eXkpAwcONKwbPny4AiiLFi0y2vbnn39WAOXHH3/MM5YDBw7keq26fv26Ymdnp7z33nuGdW3bts31N0VAQIDStWtXw+OQkJA8r5W5fefatm1r9PdgxYoVCqCsWbPGaDv9fr/77rs8z0eIwiY18kIUA2tra2bNmsWRI0fy3fwwP3r16mX0uE6dOqhUKqP+yZaWllSvXj3XkfOHDBli1IzMz8+PVq1asWPHDkB3B/7cuXMMHToUwFBbk5mZSY8ePYiMjOT8+fNG+3z22WfzFfv27dsJCAigWbNmRutHjBiBoiiF3npBT8nWFDp7LJ06dcLFxQULCwusrKyYOnUqsbGxxMTEGLZ7++23CQ0NZd++fQAkJCSwbNkyhg8fjqOjI4Ch2d7AgQNZvXo1N2/ezFdc1apVw9/f31ALtXXrVurXr88LL7xAeHg4ly9fJj09nb179z60Bio/2rdvbzSgm6enJx4eHrl+Rgoqt/f3hx9+oHHjxtja2mJpaYmVlRX//vvvY42A/PrrrwO6Pqd63377LfXr16dNmzb53k/btm2pVq0aixYt4tSpU4SEhDy0+0N+PyMqlYqff/4ZJycnmjZtSnh4OKtXr8bBwSFfceX2nQbo2bNnjvV37941al5fUE96/civx7mOFOR9yC22/v37Y2tra3js5ORE79692b17N1lZWaSlpfHvv//Sr18/7O3tc8SUlpaWoxlyXte2wvx850eHDh0oV66c4fHjnEtunnrqKUJCQggJCWHfvn0sXLiQ27dv06FDB8PI9Y9Tlnrnz5/n1q1bvPjii0ZNzR0dHXn22Wc5ePCgoetSx44duXLlCuHh4aSlpbF37166detG+/btDS2Utm3bho2NDU899dTjvZH3Pep6WFjvb349rGl3Qcab6dmzJxYWFobH+lr9/H6XBw0ahJWVFfb29rRp04asrCx+//13GjRowObNm8nMzGTYsGFG74etrS1t27bNtbXVg9+ff/75B1tb24ded//++29UKhUvvPCC0XG8vLxo2LBhjuN4eXnl+E3RoEGDQvnblj0mV1dXevfubRRTYGAgXl5eJp+lQZQtksgLUUwGDx5M48aNmTRpklGfzifx4KA31tbW2NvbG/2A1a/P3idc78Hme/p1sbGxAIZma+PHj8fKyspoGTNmDECOqYny2+w9NjY21231TaP1MRQ2/R90/XEOHz5Mly5dAF1yuG/fPkJCQgyD+WRvJtenTx/8/f0NTbuXLFlCcnKyoVk96AYFWr9+veFHjo+PD/Xq1TPqj52Xjh07Gvrxbtu2jc6dO1O/fn08PT3Ztm0b+/btIzU19YkTeXd39xzrbGxsCqVJ4NWrV7GxsTF8NufOncvrr79O8+bNWbNmDQcPHiQkJIRu3bo91vE8PT0ZNGgQCxYsICsri5MnT7Jnz54CTyGlUql46aWX+OWXX/jhhx+oWbMmTz/9dK7bFuQzArr395lnniEtLY1u3bpRv379fMeV23f6Yetz+14/ybEKcv3Ir8e5jhTkfSjItS0jI4OkpCRiY2PJzMzkm2++yRFTjx49co0pt+tVYX++8+PBOB7nXHLj4uJC06ZNadq0Ka1atWLkyJEsX76cs2fP8sUXXwCPV5bZ48wtftBdj7VaLffu3QMwXOO2bdvG3r170Wg0dOjQgU6dOhldI1u3bv3EA/096npYWO9vfmPJ7W9fcnIyGRkZBRro7sHzsrGxAXJer/IyZ84cQkJCOHbsGNeuXePKlSuGAWf1n4OgoKAc78mqVatyvB/29vY5Zq24ffs2FStWfOj4AdHR0SiKgqenZ47jHDx4MMdxivJvW/aY4uLisLa2zhFTVFRUoX0WhMgPGbVeiGKiUqmYM2cOnTt35n//+1+O5/U/nh8cHK6oElrQ9SfLbZ3+j2H58uUBXd/Q/v3757qPWrVqGT3Ob42Bu7u7oT94dvr+j/pjFyZFUfjrr79wcHCgadOmAKxcuRIrKyv+/vtvowRm/fr1OV6vVqsJDg7mgw8+4IsvvuC7776jY8eOOd6DPn360KdPH9LT0zl48CCzZ89myJAh+Pv707Jlyzzj69ixIwsXLuTw4cMcOnSIyZMnA7oauK1bt3L16lUcHR1L7EjgN2/e5OjRo7Rt29Ywmvcvv/xCu3bt+P777422TUxMfOzjvP322yxbtow//viDTZs24erqaqghLIgRI0YwdepUfvjhBz766KM8tyvIZwR0rSm+//57mjVrxrp161izZk2+W6o8LlNcP/Lrca4jTyqva5u1tTWOjo5YWVlhYWHBiy++aHQjLrvs/cIh92tbYXy+bW1tcx0UNK+E4ME4ypUrV+BzyS99Le6JEyeAJytL/d+VvK77arXa0NLAx8eHmjVrsm3bNvz9/WnatCmurq507NiRMWPGcOjQIQ4ePFio/dPzUpTv74Pq16/PypUriYqKMroZderUKQDq1atXKMfJj6pVqxr+Tj5I/zn4/fff8fPze+S+cvvuVKhQgb1796LVavNM5suXL49KpWLPnj2GGxHZ5bauqJUvXx53d3fDuBcPKo7pS4XQk0ReiGLUqVMnOnfuzIwZM/D19TV6ztPTE1tbW06ePGm0/o8//iiyeFasWME777xj+CN79epV9u/fz7BhwwDdD7IaNWpw4sQJPv7440I9dseOHZk9ezbHjh2jcePGhvU///wzKpWK9u3bF+rxQDdidFhYGB988IEh8dFPIZW9CWJqairLli3LdR+jRo1i2rRpDB06lPPnzz90GjsbGxvatm2Lq6srmzdv5vjx449M5FUqFVOmTEGtVhuainfq1Il3332Xq1ev0qZNmzwHEMx+XP15FMa0VPmRmprKqFGjyMzM5L333jOsV6lUOX5snTx5kgMHDuT4DuRXkyZNaNWqFXPmzOH06dOMHj06303Xs6tUqRLvvvsu586dY/jw4XluV5DPSGRkJC+88AJt27Zl69at9O/fn5dffpnGjRsX2o/93Jji+pFfRXkdycvatWv57LPPDN/zxMRE/vrrL55++mksLCywt7enffv2HD9+nAYNGhhq/Asqv5/vh9WG+vv7ExMTQ3R0NJ6enoBucLDNmzfnK4bCOpfchIaGAuDh4QE8WVnWqlWLSpUqGaZj1f/dSU5OZs2aNYaR7PU6derE6tWr8fX1NXSpqFmzJpUrV2bq1KloNJp8tU560uthUb6/D+rTpw+TJ09m6dKlRjPdLFmyBDs7O6M5zgu7prkgunbtiqWlJZcvX37sm5Tdu3dnxYoVLFmyJM/m9b169eKTTz7h5s2bDBw48ElCNihoy4TcYlq5ciVZWVk0b968UGIS4nFJIi9EMZszZw5NmjQhJibGaCodfT+wRYsWUa1aNRo2bMjhw4dzjJJemGJiYujXrx+vvPIK8fHxfPjhh9ja2jJx4kTDNgsWLKB79+507dqVESNGUKlSJe7evcvZs2c5duyY0RRBBTFu3Dh+/vlnevbsyYwZM/Dz82PDhg189913vP766080Z3FcXJyhz2JycjLnz59n5cqV7Nmzh4EDBxrV4vTs2ZO5c+cyZMgQRo8eTWxsLJ9//nmed/pdXV0ZNmwY33//PX5+fvTu3dvo+alTp3Ljxg06duyIj48PcXFxfPXVV1hZWdG2bduHxu3h4UG9evXYsmUL7du3N/yo7dSpE3fv3uXu3bvMnTv3keevb8o9Z84cunfvjoWFRaH+AL127RoHDx5Eq9USHx/P8ePHWbRoEVevXuWLL74wNEMH3Y+emTNn8uGHH9K2bVvOnz/PjBkzqFKlyiNH8n+Yt99+m0GDBqFSqQxNeh/HJ5988sht8vsZycrK4vnnnzdMI2dhYcGSJUsMI3rv3bu3yJIAU1w/CqKoriN5sbCwoHPnzrzzzjtotVrmzJlDQkKC0Xf/q6++4qmnnuLpp5/m9ddfx9/fn8TERC5dusRff/2Vr3E68vv5dnJyws/Pjz/++IOOHTvi5uZG+fLl8ff3Z9CgQUydOpXBgwfz7rvvkpaWxtdff01WVla+z7cwziX7dVOj0XD27Fk+/vhjbGxsjGqiH7cs1Wo1n376KUOHDqVXr168+uqrpKen89lnnxEXF5fju9ixY0e+++477ty5w7x584zWL168mHLlyj106jm9wrgePun7e/XqVUJCQgC4fPkyoKvNBgwtDkA3Yv/LL7/Mhx9+iIWFBUFBQWzZsoX//e9/zJo1y6hpff369Vm7di3ff/89TZo0Qa1W51mDXtj8/f2ZMWMGkyZN4sqVK3Tr1o1y5coRHR3N4cOHcXBweGRrieeff57Fixfz2muvcf78edq3b49Wq+XQoUPUqVOHwYMH07p1a0aPHs1LL73EkSNHaNOmDQ4ODkRGRrJ3717q169vGDclv6pVq4adnR2//vorderUwdHRkYoVK+ZrxhPQdZP89ddf6dGjB2+//TbNmjXDysqKGzdusGPHDvr06UO/fv0KFJMQj82kQ+0JYcayj5D9oCFDhiiA0aj1iqIo8fHxyqhRoxRPT0/FwcFB6d27txIREZHnqNO3b982ev3w4cMVBweHHMd7cIR8/ai0y5YtU9566y2lQoUKio2NjfL0008rR44cyfH6EydOKAMHDlQ8PDwUKysrxcvLS+nQoYPyww8/5Ot883L16lVlyJAhiru7u2JlZaXUqlVL+eyzz4xGNFaUgo9az/0Rl1UqleLo6KjUqlVLefHFF5XNmzfn+ppFixYptWrVUmxsbJSqVasqs2fPVhYuXKgASnh4eI7td+7cqQDKJ598kuO5v//+W+nevbtSqVIlxdraWvHw8FB69Oih7NmzJ1/xjxs3TgGUjz76yGh9jRo1FEA5efKk0frcRnZPT09XRo0apVSoUEFRqVRG5wEowcHBOY774CjqudGPhqxfLCwslHLlyilNmjRRxo4dq5w5cybHa9LT05Xx48crlSpVUmxtbZXGjRsr69evz3Wk7gc/57mdW/b92tjYKN26dXtozNnl9zOa26j1+fmMTJo0SVGr1cq///5r9Nr9+/crlpaWyttvv21Yl9eo9b/99lu+Ys7tGlBc149HyWt2gye5juQ3Zv2x58yZo0yfPl3x8fFRrK2tlUaNGuX6/Q8PD1dGjhypVKpUSbGyslIqVKigtGrVSpk1a5Zhm7zKRlEK9vnetm2b0qhRI8XGxkYBjMp/48aNSmBgoGJnZ6dUrVpV+fbbb/MctT63729+zyUvD45ab2FhoVSuXFkZMGCAcvz48Rzb56cs8/r+rl+/XmnevLlia2urODg4KB07dlT27duX4xj37t1T1Gq14uDgoGRkZBjW//rrrwqQ75kUCut6+CTvr/5zndvy4HEyMjKUDz/8UKlcubJibW2t1KxZU/n6669z7PPu3bvKgAEDFFdXV8N56ePM7funP9/cZk7I7mGf9wetX79ead++veLs7KzY2Ngofn5+yoABA5Rt27YZtsnruqIoipKamqpMnTpVqVGjhmJtba24u7srHTp0UPbv32+03aJFi5TmzZsrDg4Oip2dnVKtWjVl2LBhRr9X8rpO5fZdXLFihVK7dm3FysrK6D3Jz6j1iqKbzePzzz9XGjZsqNja2iqOjo5K7dq1lVdffVW5ePHio942IQqNSlFyGWJYCCFEnv7v//6P77//nuvXr+c6uI4oen/99RfPPPMMGzZsMAw4JURERARVqlThs88+Y/z48aYORwghhCgy0rReCCHy6eDBg1y4cIHvvvuOV199VZJ4EwgLC+Pq1av83//9H4GBgUZTpQkhhBBClBWSyAshRD7pB2Pq1asXs2bNMnU4ZdKYMWPYt28fjRs3ZunSpQWaV1kIIYQQwlxI03ohhBBCCCGEEKIUyX3iRiGEEEIIIYQQQpRIksgLIYQQQgghhBCliCTyQgghhBBCCCFEKSKD3eVCq9Vy69YtnJycZCAlIYQQQgghhBBFTlEUEhMTqVixImr1w+vcJZHPxa1bt/D19TV1GEIIIYQQQgghypjr16/j4+Pz0G0kkc+Fk5MToHsDnZ2d8/UajUbDli1b6NKlC1ZWVkUZnigmUqbmR8rUvEh5mh8pU/Mi5Wl+pEzNj5RpyZKQkICvr68hH30YSeRzoW9O7+zsXKBE3t7eHmdnZ/kSmAkpU/MjZWpepDzNj5SpeZHyND9SpuZHyrRkyk/3bhnsTgghhBBCCCGEKEUkkRdCCCGEEEIIIUoRSeSFEEIIIYQQQohSRPrIZzN//nzmz59PVlaWqUMRQgghhBDCpBRFITMz0/DbWKPRYGlpSVpamvxeNhNSpsXPysoKCwuLJ96PJPLZBAcHExwcTEJCAi4uLqYORwghhBBCCJPIyMggMjKSlJQUwzpFUfDy8uL69ev5GoxLlHxSpsVPpVLh4+ODo6PjE+1HEnkhhBBCCCGEgVarJTw8HAsLCypWrIi1tTUqlQqtVktSUhKOjo6o1dJD1xxImRYvRVG4ffs2N27coEaNGk9UMy+JvBBCCCGEEMIgIyMDrVaLr68v9vb2hvVarZaMjAxsbW0l6TMTUqbFr0KFCkRERKDRaJ4okZfSEkIIIYQQQuQgiZ0Qha+wujDIt1MIIYQQQgghhChFJJEXQgghhBBCCCFKEZMm8t9//z0NGjTA2dkZZ2dnWrZsyT///APopkKYMGEC9evXx8HBgYoVKzJs2DBu3br10H0uWbIElUqVY0lLSyuOUxJCCCGEEEKUckuWLMHV1dXweNq0aQQGBposHiEeZNJE3sfHh08++YQjR45w5MgROnToQJ8+fThz5gwpKSkcO3aMKVOmcOzYMdauXcuFCxd45plnHrlfZ2dnIiMjjRZbW9tiOCMhhBBCCCGEKYwYMcJQiWdlZYWnpyedO3dm0aJFaLXaAu1r0KBBXLhwoVDj8/f3N8RnZ2eHv78/AwcOZPv27QXe14gRI+jbt2+hxidKF5Mm8r1796ZHjx7UrFmTmjVr8tFHH+Ho6MjBgwdxcXFh69atDBw4kFq1atGiRQu++eYbjh49yrVr1x66X5VKhZeXl9EihBBCCCGEMG/dunUjMjKSiIgI/vnnH9q3b8/bb79Nr169yMzMzPd+7Ozs8PDwKPT4ZsyYQWRkJOfPn+fnn3/G1dWVTp068dFHHxX6sYR5KzHTz2VlZfHbb7+RnJxMy5Ytc90mPj4elUpl1MwlN0lJSfj5+ZGVlUVgYCAzZ86kUaNGeW6fnp5Oenq64XFCQgKga96v0WjyFb9+u/xuL0o+KVPzI2VqXqQ8zY+UqXmR8iy9NBoNiqKg1WrRarUoikKqJkv3b0YWFumaQht5+1HsrCzyfSxFUbC2tjYk4N7e3gQGBtKsWTNDzfyoUaMA+PLLL1myZAlXrlzBzc2NXr16MWfOHBwdHQFd0/p33nmHu3fvGvYNuunadu/eTefOnbl69apRheH48eM5cuQIO3fuzDNGR0dHQ3w+Pj489dRTeHl5MXXqVPr370+tWrXIysri1VdfZceOHURFRVG5cmVef/113nrrLQCmT5/O0qVLgf9GQP/3339p164d77//PuvXr+fGjRt4eXkxZMgQpkyZgpWVVZ7vmf7fgrZaEI9H/53Kbfq5glwvTZ7Inzp1ipYtW5KWloajoyPr1q0jICAgx3ZpaWm8//77DBkyBGdn5zz3V7t2bZYsWUL9+vVJSEjgq6++onXr1pw4cYIaNWrk+prZs2czffr0HOu3bNliNHdmfmzdurVA24uST8rU/EiZmhcpT/MjZWpepDxLH0tLS7y8vEhKSiIjI4PUjCxazj1oklgOvNMCO+v8zbWt0WjIzMw0VMrpNW3alHr16vHbb78xcOBAADIyMvj444+pXLkyV69eZfz48YwbN44vvvgC0OUeiqIY9pWenk5WVhYJCQkEBgbi7+/PTz/9ZEiuMzMz+eWXX/jwww9zHF9Pq9WSlpaW4/mXXnqJWbNmsXr1at5++200Gg0VKlRg4cKFuLu7c+jQIcaNG4eLiwv9+vXjlVde4dSpUyQkJDB//nwAypUrR0JCAtbW1nzzzTd4e3tz5swZxo4di5WVFW+//fZD37vExMR8vcfiyWVkZJCamsru3btztBJJSUnJ935MnsjXqlWL0NBQ4uLiWLNmDcOHD2fXrl1GybxGo2Hw4MFotVq+++67h+6vRYsWtGjRwvC4devWNG7cmG+++Yavv/4619dMnDiRd955x/A4ISEBX19funTp8tCbBtlpNBq2bt1K586d87zjJUoXKVPzI2VqXqQ8zY+UqXmR8iy90tLSuH79Oo6Ojtja2mKZkf8m6YXNydkJe+v8pSxWVlZYWlrm+vs9ICCAU6dOGZ6bMGGC4bn69euTmppKcHAwP/74IwC2traoVCrD9jY2NlhYWBgejxo1iqVLlzJ58mQA/vjjD1JTUxk2bBgODg65xqdWq7G1tc0Rn7OzMx4eHkRFRRmemz17tlF8oaGh/P333wwfPhxnZ2ecnJzIysrKUVE5Y8YMw//r1avH9evXWb16NVOmTMk1JkVRSExMxMnJqdhaWZR1aWlp2NnZ0aZNmxzjuOV1Eyg3Jk/kra2tqV69OqC7WxYSEsJXX33FggULAN0fgYEDBxIeHs727dvznVjrqdVqgoKCuHjxYp7b2NjYYGNjk2O9lZVVgf/wPM5rHldkfCrHrsbh525PvUouxXLMsqg4y1QUDylT8yLlaX6kTM2LlGfpk5WVhUqlQq1Wo1arcbCxImxGV7RaLYkJiTg5O6FWF89QWwVpWq8fSC6v2LI/t2PHDj7++GPCwsJISEggMzOTtLQ0UlNTcXBwMGyn/1cfg/7xSy+9xJQpUzh8+DAtWrRgyZIlDBw4ECcnp0fGmFt8iqIY3m+AH374gZ9++omrV6+SmppKRkYGgYGBRvHktq/ff/+defPmcenSJZKSksjMzMTZ2TnP90TfnP5h75soXGq12jAg44PXxoJcK0tcaSmKYuivrk/iL168yLZt23B3d3+s/YWGhuLt7V3YoZrc/3ZfIXj5MX4/esPUoQghhBBCCDOlUqmwt7bE3toSO2sLw/+LYymsWuKzZ89SpUoVAK5evUqPHj2oV68ea9as4ejRo4Ym6vnto+zh4UHv3r1ZvHgxMTExbNy4kZEjRz5WbLGxsdy+fdsQ3+rVqxk3bhwjR45ky5YthIaG8tJLL5GRkfHQ/Rw8eJDBgwfTvXt3/v77b44fP86kSZMe+TpROpm0Rv6DDz6ge/fu+Pr6kpiYyMqVK9m5cyebNm0iMzOTAQMGcOzYMf7++2+ysrKIiooCwM3NDWtrawCGDRtGpUqVDM1Ppk+fTosWLahRowYJCQl8/fXXhIaGGr6c5qShjysAJ2/EmTQOIYQQQgghSqrt27dz6tQpxo0bB8CRI0fIzMzkiy++MNRCr169usD7HTVqFIMHD8bHx4dq1arRunXrx4rvq6++Qq1WG6aT27NnD61atWLMmDGGbS5fvmz0Gmtra7KysozW7du3Dz8/PyZNmmRYd/Xq1ceKSZR8Jk3ko6OjefHFF4mMjMTFxYUGDRqwadMmOnfuTEREBH/++ScAgYGBRq/bsWMH7dq1A+DatWtGzUDi4uIYPXo0UVFRuLi40KhRI3bv3k2zZs2K67SKTQMfXXP6M7cS0GRpsbIocQ0shBBCCCGEKDbp6elERUWRlZVFdHQ0mzZtYvbs2fTq1Ythw4YBUK1aNTIzM/nmm2/o3bs3+/bt44cffijwsbp27YqLiwuzZs0y6pv+MImJiURFRaHRaAgPD+eXX37hp59+Yvbs2YbuxtWrV+fnn39m8+bNVKlShWXLlhESEmKosQfdnPSbN2/m/PnzuLu74+LiQvXq1bl27RorV64kKCiIDRs2sG7dugKflygdTJrIL1y4MM/n/P39DdMhPMyD0zt8+eWXfPnll08aWqng7+6Ak60liWmZXIhOpG5F6ScvhBBCCCHKrk2bNuHt7Y2lpSXlypWjYcOGfP311wwfPtxQ+RcYGMjcuXOZM2cOEydOpE2bNsyePduQ6OeXWq1mxIgRfPzxx/l+7dSpU5k6dSrW1tZ4eXnRokUL/v33X9q3b2/Y5rXXXiM0NJRBgwahUql4/vnnGTNmDP/8849hm1deeYWdO3fStGlTkpKS2LFjB3369GHcuHG88cYbpKen07NnT6ZMmcK0adMKdF6idFAp+cmWy5iEhARcXFyIj48v0Kj1GzdupEePHsU6oMvQnw6y71Iss/vX5/lmlYvtuGWBqcpUFB0pU/Mi5Wl+pEzNi5Rn6ZWWlkZ4eDhVqlQxGlVbq9WSkJDw0MHTyppXXnmF6OhoQ0vi0kbKtPjl9f2CguWhUlqlXAPpJy+EEEIIIUSxio+PZ9u2bfz666+8+eabpg5HlEEmn35OPJmG9/vJn7geb+JIhBBCCCGEKBv69OnD4cOHefXVV+ncubOpwxFlkCTy2cyfP5/58+fnGAGyJNPXyJ+PTiRNk4WtlYVpAxJCCCGEEMLMPThOlxDFTZrWZxMcHExYWBghISGmDiXfvF1sKe9oQ5ZW4cytBFOHI4QQQgghhBCiiEkiX8qpVCpD83rpJy+EEEIIIYQQ5k8SeTPw34B30k9eCCGEEEIIIcydJPJmoIHv/QHvpEZeCCGEEEIIIcyeJPJmoOH9Gvkrt5NJSNOYNhghhBBCCCGEEEVKEnkz4OZgjU85OwBOS/N6IYQQQgghhDBrksibiQb6+eQlkRdCCCGEEMJklixZgqurq+HxtGnTCAwMNDweMWIEffv2Lfa4hHmRRN5M/DfgXZxJ4xBCCCGEEKK4qVSqhy4jRowwdYgGX331FUuWLDF1GKKUszR1AKJwNDBMQSc18kIIIYQQomyJjIw0/H/VqlVMnTqV8+fPG9bZ2dkZba/RaLCysiq2+LJzcXExyXGFeZEa+Wzmz59PQEAAQUFBpg6lwOpXckGlgptxqdxJSjd1OEIIIYQQwlwoCiQnm2ZRlHyF6OXlZVhcXFxQqVSGx2lpabi6urJ69WratWuHra0tv/zyCwCLFy+mTp062NraUrt2bb777jvDPiMiIlCpVKxdu5b27dtjb29Pw4YNOXDggNGxlyxZQuXKlbG3t6dfv37ExsY+NNYHm9a3a9eOt956i/feew83Nze8vLyYNm2a0Wvi4+MZPXo0Hh4eODs706FDB06cOJGv90aYJ0nkswkODiYsLIyQkBBTh1JgTrZWVC3vAEjzeiGEEEIIUYhSUsDREbWzM64+PqidncHRsXiWlJRCO40JEybw1ltvcfbsWbp27cqPP/7IpEmT+Oijjzh79iwff/wxU6ZMYenSpUavmzRpEuPHjyc0NJSaNWvy/PPPk5mZCcChQ4cYOXIkY8aMITQ0lPbt2zNr1qwCx7Z06VIcHBw4dOgQn376KTNmzGDr1q0AKIpCz549iYqKYuPGjRw9epTGjRvTsWNH7t69++RvjCiVpGm9GWno48rl28mcuB5Ph9qepg5HCCGEEEKIEmPs2LH079/f8HjmzJl88cUXhnVVqlQhLCyMBQsWMHz4cMN248ePp2fPngBMnz6dunXrcunSJWrXrs1XX31F165def/99wGoWbMm+/fvZ9OmTQWKrUGDBnz44YcA1KhRg2+//ZZ///2Xzp07s2PHDk6dOkVMTAw2NjYAfP7556xfv57ff/+d0aNHP/6bIkotSeTNSAMfF9Yevyk18kIIIYQQovDY20NSElqtloSEBJydnVGri6lhr719oe2qadOmhv/fvn2b69ev8/LLL/PKK68Y1mdmZubow96gQQPD/729vQGIiYmhdu3anD17ln79+hlt37Jly8dK5LPz9vYmJiYGgKNHj5KUlIS7u7vRNqmpqVy+fLlAxxHmQxJ5M9LA1xXQDXinKAoqlcq0AQkhhBBCiNJPpQIHB9BqIStL9//iSuQLkYODg+H/Wq0WgB9//JHmzZsbbWdhYWH0OPugePrf1/rXK/nsw/8oDw68p1KpDMfQarV4e3uzc+fOHK/LPs2dKFskkTcjAd7OWKpVxCZncDMuFZ9yhXcHUwghhBBCCHPh6elJpUqVuHLlCkOHDn3s/QQEBHDw4EGjdQ8+flKNGzcmKioKS0tL/P39C3XfovSSRN6M2FpZUMvLiTO3Ejh1I14SeSGEEEIIIfIwbdo03nrrLZydnenevTvp6ekcOXKEe/fu8c477+RrH2+99RatWrXi008/pW/fvmzZsqXAzeofpVOnTrRs2ZK+ffsyZ84catWqxa1bt9i4cSN9+/Y16jIgyo7S1yZGPFQDH1cATsh88kIIIYQQQuRp1KhR/PTTTyxZsoT69evTtm1blixZQpUqVfK9jxYtWvDTTz/xzTffEBgYyJYtW5g8eXKhxqlSqdi4cSNt2rRh5MiR1KxZk8GDBxMREYGnpwxwXVaplMLq2GFGEhIScHFxIT4+Hmdn53y9RqPRsHHjRnr06JGjj0txWnn4Gu+vPUWrau4sf6WFyeIwByWlTEXhkTI1L1Ke5kfK1LxIeZZeaWlphIeHU6VKFWxtbQ3rTTLYnShSUqbFL6/vFxQsD5XSMjP6GvlTN+LRauUejRBCCCGEEEKYG0nkzUxNT0dsrdQkpmcSHpts6nCEEEIIIYQQQhQySeSzmT9/PgEBAQQFBZk6lMdmaaGmbkXd3Jcyn7wQQgghhBBCmB9J5LMJDg4mLCyMkJAQU4fyRBr46BL5E9dlwDshhBBCCCGEMDeSyJuhhvf7yUuNvBBCCCGEEEKYH0nkzZC+Rv7MrQQ0WVoTRyOEEEIIIYQQojBJIm+G/N0dcLK1JD1Ty4XoRFOHI4QQQgghhBCiEEkib4bUapWhVv7kDeknL4QQQgghhBDmRBJ5M9VA+skLIYQQQgghhFmSRN5MNZSR64UQQgghhBCPYefOnahUKuLi4kwdisiDJPJmSl8jfz46kTRNlmmDEUIIIYQQoojt3r2b3r17U7FiRVQqFevXr8+xjaIoTJs2jYoVK2JnZ0e7du04c+ZMrtt16tSJrl275njuu+++w8XFhWvXrhXFaeTK398flUrFypUrczxXt25dVCoVS5YsKbTjtWrVisjISFxcXAptn49Sq1YtrK2tuXnzZrEdszSTRN5MebvYUt7RhiytwplbCaYORwghhBBCiCKVnJxMw4YN+fbbb/Pc5tNPP2Xu3Ll8++23hISE4OXlRefOnUlMNB4gWqVSsXjxYg4dOsSCBQsM68PDw5kwYQJfffUVlStXLvRz0Gg0eT7n6+vL4sWLjdYdPHiQqKgoHBwcCjUOa2trvLy8UKlUhbrfvOzdu5e0tDSee+65Qr0hkZeHvc+lhSTy2cyfP5+AgACCgoJMHcoTU6myD3gXZ9pghBBCCCFEqaUoCskZybpFk/zf/4thURQl33F2796dWbNm0b9//zzPY968eUyaNIn+/ftTr149li5dSkpKCsuXL8+xva+vL1999RXjx48nPDwcRVF4+eWX6dixIyNGjCAsLIwePXrg6OiIp6cnL774Infu3DG8ftOmTTz11FO4urri7u5Or169uHz5suH5iIgIVCoVq1evpl27dtja2vLLL7/keX5Dhw5l165dXL9+3bBu0aJFDB06FEtLS6Ntr127Rp8+fXB0dMTZ2ZmBAwcSHR0NwPnz51GpVJw7d87oNXPnzsXf3x9FUXI0rV+yZAmurq5s3ryZOnXq4OjoSLdu3YiMjDS8PjMzk7feestwvhMmTGD48OH07ds3z3PSW7hwIUOGDOHFF19k0aJFhnJfsGABlSpVQqs1nlL7mWeeYfjw4YbHf/31F02aNMHW1paqVasyffp0MjMzDc+rVCp++OEH+vTpg4ODA7NmzSIrK4uXX36ZKlWqYGdnR61atfjqq6+MjpOfc1IUhU8//ZSqVatiZ2dHw4YN+f333x95zk/K8tGblB3BwcEEBweTkJBQrM1IikoDHxe2n4uRkeuFEEIIIcRjS9Gk4Djb0STHTpqYhIN14dQ2h4eHExUVRZcuXQzrbGxsaNu2Lfv37+fVV1/N8Zrhw4ezbt06XnrpJZ599llOnz7N6dOniYyMpG3btrzyyivMnTuX1NRUJkyYwMCBA9m+fTugayHwzjvvUL9+fZKTk5k6dSr9+vUjNDQUtfq/+tQJEybwxRdfsHjxYmxsbPKM39PTk65du7J06VImT55MSkoKq1atYteuXfz888+G7RRFoW/fvjg4OLBr1y4yMzMZM2YMgwYNYufOndSqVYsmTZrw66+/Mn36dMPrli9fzpAhQ/KshU9JSeHzzz9n2bJlqNVqXnjhBcaPH8+vv/4KwJw5c/j1119ZvHgxderU4auvvmL9+vW0b9/+oeWSmJjIb7/9xqFDh6hduzbJycns3LmT9u3b89xzz/HWW2+xY8cOOnbsCMC9e/fYvHkzf/31FwCbN2/mhRde4Ouvv+bpp5/m8uXLjB49GoAPP/zQcJwPP/yQ2bNn8+WXX2JhYYFWq8XHx4fVq1dTvnx59u/fz+jRo/H29mbgwIH5PqfJkyezdu1avv/+e2rUqMHu3bt54YUXqFChAm3btn3ouT8JSeTNWMP7/eRPSI28EEIIIYQo46KiogBdQpydp6cnV69ezfN1//vf/6hXrx579uzh999/x8PDg6lTp9K4cWM+/vhjw3aLFi3C19eXCxcuULNmTZ599lmj/SxcuBAPDw/CwsKoV6+eYf3YsWPzbEXwoJEjR/J///d/TJo0id9//51q1aoRGBhotM22bds4efIk4eHh+Pr6ArBs2TLq1q1LSEgIQUFBDB06lG+//daQyF+4cIGjR48a3RB4kEaj4YcffqBatWoAvPHGG8yYMcPw/DfffMPEiRPp168fAN9++y0bN2585DmtXLmSGjVqULduXQAGDx7MwoULad++PW5ubnTr1o3ly5cbEvnffvsNNzc3w+OPPvqI999/31BDX7VqVWbOnMl7771nlMgPGTKEkSNHGh07+42MKlWqsH//flavXm1I5B91TsnJycydO5ft27fTsmVLw/H37t3LggULJJEXj0fftP7K7WQS0jQ421qZOCIhhBBCCFHa2FvZkzQxCa1WS0JiAs5OzkY1ykV97ML2YI2zoiiGda+99ppR8/akpCQ8PDwYPXo069evNyR0R48eZceOHTg65mypcPnyZWrWrMnly5eZMmUKBw8e5M6dO4bm4deuXTNK5Js2bZrv2Hv27Mmrr77K7t27WbRoUY7EFODs2bP4+voakniAgIAAXF1dOXv2LEFBQQwePJh3332XgwcPEhAQwPLlywkMDCQgICDPY9vb2xuSeABvb29iYmIAiI+PJzo6mmbNmhmet7CwoEmTJjmaxT9o4cKFvPDCC4bHL7zwAm3atCEuLg5XV1eGDh3K6NGj+e6777CxseHXX39l8ODBWFhYALqyCAkJ4aOPPjLsIysri7S0NFJSUrC3132Gcnuff/jhB3766SeuXr1KamoqGRkZhhsj+TmnsLAw0tLS6Ny5s9F+MzIyaNSo0UPP+0lJIm/G3B1tqORqx824VE7fiKdV9fKmDkkIIYQQQpQyKpUKB2sHtFotWVZZOFg7FFsiX5i8vLwAXc28t7e3YX1MTIyhln7GjBmMHz8+x2stLS2N+qFrtVp69+7NnDlzcmyr33fv3r3x9fXlxx9/pGLFimi1WurVq0dGRobR9gUZqM7S0pIXX3yRDz/8kEOHDrFu3boc22S/MZHXem9vb9q3b8+KFSuYOXMmK1euzLVrQXZWVsaVgiqVKscYBrndJHmYsLAwDh06REhICBMmTDCsz8rKYsWKFbz++uv07t0brVbLhg0bCAoKYs+ePcydO9ewrVarZfr06bm2arC1tTX8/8H3efXq1YwbN44vvviCli1b4uTkxGeffcahQ4fyfU76hH7Dhg1UqlTJaLuHdZMoDJLIm7mGvi7cjEvlhCTyQgghhBCiDKtSpQpeXl5s3brVUFuakZHBrl27DAm5h4cHHh4ej9xX48aNWbNmDf7+/jkGmgOIjY3l7NmzLFiwgKeffhrQjcxeGEaOHMnnn3/OoEGDKFeuXI7nAwICuHbtGtevXzfUyoeFhREfH0+dOnUM2w0dOpQJEybQu3dvLl++zODBgx87JhcXFzw9PTl8+LDhfLOysjh+/HiOpv/ZLVy4kDZt2jB//nyj9cuWLWPhwoW8/vrr2NnZ0b9/f3799VcuXbpEzZo1adKkiWHbxo0bc/78eapXr16gmPfs2UOrVq0YM2aMYV32wQjzc04BAQHY2Nhw7dq1Im1GnxtJ5M1cAx9XNp6KkpHrhRBCCCGEWUtKSuLSpUuGx+Hh4YSGhuLm5kblypVRqVSMHTuWjz/+mBo1alCjRg0+/vhj7O3tGTJkSIGOFRwczI8//sjzzz/Pu+++S/ny5bl06RIrV67kxx9/pFy5cri7u/O///0Pb29vrl27xvvvv18o51mnTh3u3LljaDL+oE6dOtGgQQOGDh3KvHnzDIPdtW3b1qh5ef/+/Xn99df5v//7P9q3b5+jRrmg3nzzTWbPnk316tWpXbs233zzDffu3ctz8DyNRsOyZcuYMWOGUVcDgFGjRvHpp59y4sQJGjZsyNChQ+nduzdnzpwxaoYPMHXqVHr16oWvry/PPfccarWakydPcurUKWbNmpVnvNWrV+fnn39m8+bNVKlShWXLlhESEkKVKlXyfU5OTk6MHz+ecePGodVqeeqpp0hISGD//v04Ojoajaxf2EzaJub777+nQYMGODs74+zsTMuWLfnnn38MzyuKwrRp06hYsSJ2dna0a9eOM2fOPHK/a9asMdwdCQgIyLXJSVnx3xR0MnK9EEIIIYQwX0eOHKFRo0aG2vZ33nmHRo0aMXXqVMM27733HmPHjmXMmDE0bdqUmzdvsmXLFpycnAp0rIoVK7Jv3z6ysrLo2rUr9erV4+2338bFxQW1Wo1arWblypUcPXqUevXqMW7cOD777LNCO1d3d3fs7OxyfU6lUrF+/XrKlStHmzZt6NSpE1WrVmXVqlVG2zk7O9OrVy9Onz7N888//8QxTZgwgeeff55hw4bRsmVLHB0d6dq1q1Hz9uz+/PNPYmNjDeMOZFejRg3q16/PwoULAejQoQNubm6cP38+x02Xrl278vfff7N161aCgoJo0aIFc+fOxc/P76Hxvvbaa/Tv359BgwbRvHlzYmNjjWrn83tOM2fOZOrUqcyePZs6derQtWtX/vrrL6MbAkVBpRRkcsZC9tdff2FhYWFoBrF06VI+++wzjh8/Tt26dZkzZw4fffQRS5YsoWbNmsyaNYvdu3dz/vz5PL9sBw4c4Omnn2bmzJn069ePdevWMXXqVPbu3Uvz5s3zFZd++rn4+HicnZ3z9RqNRsPGjRvp0aNHjv4jppSYpqHB9C0oChyZ3InyjkXbV8OclNQyFY9PytS8SHmaHylT8yLlWXqlpaURHh5OlSpVjBIWrVZLQkICzs7FN9idKFpFWaZarZY6deowcOBAZs6cWaj7NpXCOKe8vl9QsDzUpN/A3r1706NHD2rWrEnNmjX56KOPcHR05ODBgyiKwrx585g0aRL9+/enXr16LF26lJSUFJYvX57nPufNm0fnzp2ZOHEitWvXZuLEiXTs2JF58+YV34mVIE62VlQtrxvYQZrXCyGEEEIIIYrC1atX+fHHH7lw4QKnTp3i9ddfJzw8vMDdFkqSknxOJaaPfFZWFr/99hvJycm0bNmS8PBwoqKi6NKli2EbGxsb2rZty/79+/McVfHAgQOMGzfOaF3Xrl0fmsinp6eTnp5ueJyQkADo7iRrNJp8xa/fLr/bF6f6FZ25fDuZ0Kv3eLqam6nDKTVKcpmKxyNlal6kPM2PlKl5kfIsvTQaDYqioNVqjaYO0zfk1T8nSr/CLtMlS5Ywfvx4FEWhXr16bNmyhVq1apXqz0thn5NWq0VRFDQajWEKPb2CXC9NnsifOnWKli1bkpaWhqOjI+vWrSMgIID9+/cDGKaC0PP09OTq1at57i8qKirX10RFReX5mtmzZzN9+vQc67ds2ZLnIBJ52bp1a4G2Lw4W8SrAgm3HL1It7bypwyl1SmKZiicjZWpepDzNj5SpeZHyLH0sLS3x8vIiKSkpx1RpAImJiSaIShSlwihTFxcXNmzYkGO9vpK0NCqKc8rIyCA1NZXdu3eTmZlp9FxKSkq+92PyRL5WrVqEhoYSFxfHmjVrGD58OLt27TI8n9u8fXmNfPi4r5k4cSLvvPOO4XFCQgK+vr506dKlQH3kt27dSufOnUtcPzDv63Gs+d9hojW2dO/e9pHvn9ApyWUqHo+UqXmR8jQ/UqbmRcqz9EpLS+P69es4Ojoa9eFVFIXExEScnJzk96SZkDItfmlpadjZ2dGmTZtc+8jnl8kTeWtra8Ngd02bNiUkJISvvvqKCRMmALoadm9vb8P2MTExOWrcs/Py8spR+/6o19jY2GBjk3MQOCsrqwL/4Xmc1xS1Br5uWKpVxCZncDsli0quuY9wKXJXEstUPBkpU/Mi5Wl+pEzNi5Rn6ZOVlYVKpUKlUhkNgKZvSvzgelF6SZkWP/13K7drY0GulSWutBRFIT09nSpVquDl5WXUHCsjI4Ndu3bRqlWrPF/fsmXLHE24tmzZ8tDXmDtbKwtqeelG+T95Pc60wQghhBBCiBJNn0wUpJmvECJ/9N1VHuwfX1AmrZH/4IMP6N69O76+viQmJrJy5Up27tzJpk2bUKlUjB07lo8//pgaNWpQo0YNPv74Y+zt7Y1GCRw2bBiVKlVi9uzZALz99tu0adOGOXPm0KdPH/744w+2bdvG3r17TXWaJUIDH1fO3ErgxI14utf3fvQLhBBCCCFEmWRhYYGrqysxMTEA2Nvbo1Kp0Gq1ZGRkkJaWJrW3ZkLKtHhptVpu376Nvb09lpZPloqbNJGPjo7mxRdfJDIyEhcXFxo0aMCmTZvo3LkzAO+99x6pqamMGTOGe/fu0bx5c7Zs2WI0h/y1a9eMPnStWrVi5cqVTJ48mSlTplCtWjVWrVqV7znkzVVDHxdWHJYp6IQQQgghxKN5eXkBGJJ50LWcTU1Nxc7OTvpTmwkp0+KnVqupXLnyE7/fJk3kFy5c+NDnVSoV06ZNY9q0aXlus3PnzhzrBgwYwIABA54wOvPSwMcVgFM34tFqFdRq+aIKIYQQQojcqVQqvL298fDwMJpKcPfu3bRp00bGPTATUqbFz9raulBaP5h8sDtRPGp6OmJrpSYxPZPw2GSqVXA0dUhCCCGEEKKEs7CwMPTltbCwIDMzE1tbW0n6zISUaeklHSHKCEsLNXUrugDSvF4IIYQQQgghSjNJ5MuQBj66RP7E9XgTRyKEEEIIIYQQ4nFJIp/N/PnzCQgIICgoyNShFImG9/vJS428EEIIIYQQQpRekshnExwcTFhYGCEhIaYOpUjoa+TP3EpAk6U1cTRCCCGEEEIIIR6HJPJliL+7A062lqRnarkQnWjqcIQQQgghhBBCPAZJ5MsQtVpF/Ur6Ae+kn7wQQgghhBBClEaSyJcxDaSfvCgB4lM0rD5ynTRNlqlDEUIIIYQQotSReeTLmIYycr0wMUVRePWXIxy8cpfo+DTe7FjD1CEJIYQQQghRqkiNfBnTwNcVgPPRiVIbKkxizbGbHLxyF4AtYdEmjkYIIYQQQojSRxL5Mqaiiy3lHa3J0iqcuZVg6nBEGXMvOYOPN541PD51M56YhDQTRiSEEEIIIUTpI4l8GaNSqaSfvDCZ2f+c5W5yBjU9HQnwdgZg5/nbJo5KCCGEEEKI0kUS+TJIP5+8jFwvitPh8LusPnIDgI/71adzgCcA28/FmDIsIYQQQgghSh1J5LOZP38+AQEBBAUFmTqUItXwfo38CamRF8UkI1PLB+tOATA4yJem/m50rOMBwJ6Lt0nPlPEahBBCCCGEyC9J5LMJDg4mLCyMkJAQU4dSpPQ18lduJ5OQpjFxNKIs+HHPFS7FJOHuYM373WsDUK+iC+UdbUjOyCIk/J6JIxRCCCGEEKL0kES+DHJ3tKGSqx0Ap6V5vShiV2OT+frfiwBM6lkHV3trANRqFe1rVQCkeb0QQgghhBAFIYl8GdXQ9/588pLIiyKkKApT/jhDeqaWVtXc6deoktHzHWrrmtfvOC+JvBBCCCGEEPkliXwZJSPXi+Lw98lIdl+4jbWFmpl966FSqYyef6pGeawsVITfSebK7SQTRSmEEEIIIUTpIol8GSUj14uiFp+qYcbfYQC83q4a1So45tjGydaKZlXcAGleL4QQQgghRH5JIl9G1a/kgkoFN+NSiU1KN3U4wgx9seU8txPTqVLegdfbVctzu/a1pHm9EEIIIYQQBSGJfBnlZGtF1fIOgNTKi8IXej2OZQevAvBR33rYWlnkua2+n/zh8LskpWcWS3xCCCGEEEKUZpLIl2Eyn7woCplZWj5YewpFgX6NKtGqevmHbl+1giP+7vZoshT2XrxdTFEKIYQQQghRekkiX4ZJP3lRFJbsjyAsMgEXOysm9ayTr9d0qO0JwL9npXm9EEIIIYQQjyKJfBnWwNcV0I1cryiKaYMRZuFWXCpzt14A4P3utSnvaJOv1/03Dd1ttFr5LAohhBBCCPEwkshnM3/+fAICAggKCjJ1KMUiwNsZS7WKO0kZ3IpPM3U4wgxM+/MMKRlZNPUrx6Cmvvl+XbMqbjhYW3AnKZ3Tt6SFiBBCCCGEEA8jiXw2wcHBhIWFERISYupQioWtlQW1vJwAOHk9zrTBiFJva1g0W8KisVSr+KhffdRq1aNfdJ+1pZqnauj60ss0dEIIIYQQQjycJPJlXAPDgHdSCyoeX3J6Jh/+cRqAUU9XNdwgKgh983pJ5IUQQgghhHg4SeTLuIaGAe/iTBuIKNXmbbvArfg0fMrZ8XbHGo+1D/188idvxBOTKF09hBBCCCGEyIsk8mWcvkb+1I14GWRMPJawWwks2hcBwMw+9bCzznvO+IfxcLalfiXdjaWd52UaOiGEEEIIIfIiiXwZV9PTERtLNYnpmYTHJps6HFHKZGkVPlh3iiytQo/6XrS/3zz+celfv0Oa1wshhBBCCJEnSeTLOEsLNXUrOgPSvF4U3PLD1wi9HoejjSUf9q77xPvT95Pfc/EOGZnaJ96fEEIIIYQQ5kgSefHfgHfXZcA7kX8xiWl8uukcAOO71MTT2faJ99mgkgvlHa1JSs8kJOLuE+9PCCGEEEIIcySJvKChrwx4Jwpu5t9nSUzLpIGPCy+29C+UfarVKtrVktHrhRBCCCGEeBhJ5IWhRv7MrQQ0WdKcWTza7gu3+evELdQq+LhffSwKMGf8o3SQfvJCCCGEEEI8lCTy2cyfP5+AgACCgoJMHUqxquLugJONJemZWi5EJ5o6HFHCpWmymLxeN2f88Fb+1Ls/0nxheapGeSzVKq7cSSb8jgzAKIQQQgghxIMkkc8mODiYsLAwQkJCTB1KsVKrVdQ3zCcv/eTFw327/RLX7qbg5WzL/3WpVej7d7a1olkVN0Ca1wshhBBCCJEbSeQF8F/zeuknLx7mUkwiC3ZfBmDaMwE42lgWyXGkeb0QQgghhBB5k0ReANDwfo28jFwv8qIoCh+sO40mS6FjbQ+61vUqsmPp55M/FB5LUnpmkR1HCCGEEEKI0kgSeQFAA19XAM5HJ5KmyTJtMKJE+u3oDQ6H38XOyoLpfeqiUhXeAHcPqlreAT93ezRZCnsv3imy4wghhBBCCFEaSSIvAKjoYkt5R2uytApnbiWYOhxRwtxNzmD2xrMAjO1UA59y9kV6PJVKRXvDNHTRRXosIYQQQgghShtJ5AWgS5ykn7zIy8cbz3IvRUNtLydGPlWlWI7Zsc79fvLnb6PVKsVyTCGEEEIIIUoDkybys2fPJigoCCcnJzw8POjbty/nz5832kalUuW6fPbZZ3nud8mSJbm+Ji0trahPqVRrICPXi1wcvBLL70dvoFLBR/3qY2VRPJeNZlXcsLe24HZiurQSEUIIIYQQIhuTJvK7du0iODiYgwcPsnXrVjIzM+nSpQvJyf/NHR0ZGWm0LFq0CJVKxbPPPvvQfTs7O+d4ra2tbVGfUqnW8H6N/AmpkRf3pWdmMWndKQCeb1aZJn7liu3YNpYWPFW9PCDT0AkhhBBCCJFd0cwdlU+bNm0yerx48WI8PDw4evQobdq0AcDLy3hk7D/++IP27dtTtWrVh+5bpVLleK14OH2N/JXbySSkaXC2tTJxRMLU/rfrCpdvJ1Pe0ZoJXWsX+/E71PZgS1g0289F83anGsV+fCGEEEIIIUoikybyD4qP1zXpdnNzy/X56OhoNmzYwNKlSx+5r6SkJPz8/MjKyiIwMJCZM2fSqFGjXLdNT08nPT3d8DghQdeMV6PRoNFo8hW7frv8bl8SOduoqeRqy824NE5cvUuLqrmXQ1lhDmX6JK7GpvDNjksATOxWC3ur4n8vnqqmawFw4kY8kfeSKO9o80T7K+tlam6kPM2PlKl5kfI0P1Km5kfKtGQpSDmoFEUpEaNIKYpCnz59uHfvHnv27Ml1m08//ZRPPvmEW7duPbSZ/MGDB7l06RL169cnISGBr776io0bN3LixAlq1MhZqzdt2jSmT5+eY/3y5cuxty/a0blLmsXn1YTeVfNM5Sw6VioRHw1hAooC359Vcz5eTU0XLWPqaCnC2eYe6rOTFtxIVjGkWhbNPeQzKYQQQgghzFNKSgpDhgwhPj4eZ2fnh25bYhL54OBgNmzYwN69e/Hx8cl1m9q1a9O5c2e++eabAu1bq9XSuHFj2rRpw9dff53j+dxq5H19fblz584j30A9jUbD1q1b6dy5M1ZWpbdJ+v/2hPPZlot0q+vJN4MbmjockzKXMn0cf52M5J3fTmFtqWbjG63wczfdDa15/15i/s4rhfKZLMtlao6kPM2PlKl5kfI0P1Km5kfKtGRJSEigfPny+UrkS0TT+jfffJM///yT3bt355nE79mzh/Pnz7Nq1aoC71+tVhMUFMTFixdzfd7GxgYbm5xNdq2srAr8gX6c15Qkjfx0zelP3Uwo1edRmEp7mRZUfKqGj/+5AMAb7atT3cvFpPF0CvBi/s4r7LsUi6KywNryycfoLGtlau6kPM2PlKl5kfI0P1Km5kfKtGQoSBmYdNR6RVF44403WLt2Ldu3b6dKlbznp164cCFNmjShYcOC18gpikJoaCje3t5PEm6ZUL+SCyoV3IxLJTYp/dEvEGbn003nuJOUTtUKDrza9uGDShaHhj6uuDtYk5ieyZGIu6YORwghhBBCCJMzaSIfHBzML7/8wvLly3FyciIqKoqoqChSU1ONtktISOC3335j1KhRue5n2LBhTJw40fB4+vTpbN68mStXrhAaGsrLL79MaGgor732WpGejzlwsrWiankHQOaTL4uOXbvH8sPXAPiob31sLC1MHBGo1Sra1fIAZBo6IYQQQgghwMSJ/Pfff098fDzt2rXD29vbsDzYfH7lypUoisLzzz+f636uXbtGZGSk4XFcXByjR4+mTp06dOnShZs3b7J7926aNWtWpOdjLmQ++bJJk6Xlg7WnUBR4trEPLau5mzokgw617yfy5yWRF0IIIYQQwqR95PM7zt7o0aMZPXp0ns/v3LnT6PGXX37Jl19++SShlWkNfFxYe/ym1MiXMYv3hXMuKhFXeysm9axj6nCMPF2zPJZqFVduJxNxJxn/+61GhBBCCCGEKItMWiMvSqYGvq4AnLwRl++bLaJ0u3EvhS+36gaD/KB7HdwcrE0ckTFnWyua+uvmlJfm9UIIIYQQoqyTRF7kEODtjKVaxZ2kDG7Fp5k6HFHEFEVh2p9nSNVk0czfjeea5j5zhKl1rO0JwA5pXi+EEEIIIco4SeRFDrZWFtT0dALg5PU40wYjitzfJyPZdjYGKwsVH/Wrh0qlMnVIuWp/v5/8oSt3SU7PNHE0QgghhBBCmI4k8tnMnz+fgIAAgoKCTB2KyTX01c0dfkL6yZutjEwtczad462VxwEY3aYqNe7fwCmJqlVwoLKbPRlZWvZeumPqcIQQQgghhDAZSeSzCQ4OJiwsjJCQEFOHYnIN7o9cf1JGrjdLl2IS6ffdPr7feRlFgeea+PBWxxqmDuuhVCrVf6PXn5Xm9UIIIYQQouwy6aj1ouRq4KOrkT91Ix6tVkGtLpnNrUXBKIrCsoNX+WjDWdIztbjaW/FJ//p0q+dt6tDypX1tD5bsj2DH+RgURSmx3QCEEEIIIYQoSpLIi1zV9HTCxlJNYnom4bHJVKvgaOqQxBOKSUzj3d9OsuvCbQDa1KzAZwMa4Olsa+LI8q95FTfsrS2ISUznzK0E6lVyMXVIQgghhBBCFDtpWi9yZWWhpm5FZ0Ca15uDTaej6PrlbnZduI2NpZppvQNY+lJQqUriQTcQY+vq5QGZhk4IIYQQQpRdksiLPOn7yZ+4LgPelVbJ6ZlM+P0kr/1ylHspGgK8nfn7zacY0bpKqW2WbugnL4m8EEIIIYQoo6RpvciTfuR6qZEvnY5evcc7q0O5GpuCSgWvtqnGO51rYm1Zuu/fta+lS+RP3IjjTlI65R1tTByREEIIIYQQxat0/6IXRUpfI3/mVgKaLK1pgxH5psnSMnfrBZ77YT9XY1Oo5GrHilda8H732qU+iQfwcrGlbkVnFAV2nr9t6nCEEEIIIYQodqX/V70oMlXcHXCysSQ9U8uF6ERThyPyIfxOMgN+OMDX/15Eq0C/RpX4Z+zTtKjqburQCpW+ef0OaV4vhBBCCCHKIEnkRZ7UahX1ffTN66WffEmmKAorDl+jx1d7OHE9DmdbS75+vhFfDgrE2dbK1OEVuvb3E/ndF25LaxEhhBBCCFHmSCKfzfz58wkICCAoKMjUoZQY+ub10k++5LqTlM4rPx9l4tpTpGqyaFnVnU1j2/BMw4qmDq3INPRxxc3BmsT0TEIi7po6HCGEEEIIIYqVJPLZBAcHExYWRkhIiKlDKTEa3q+Rl5HrS6bt56LpNm83285GY22hZlKPOvw6qjkVXe1MHVqRslCraFerAiDN64UQQgghRNkjiXxpdvgwTJsGGzZAdHSRHKKBrysA56MTSdNkFckxRMGlZmQxef0pRi45wp2kDGp5OvHHG615pU1V1OrSOa1cQck0dEIIIYQQoqyS6edKs40bYfr0/x77+kJQEDRtqvu3SRMoV+6JDlHRxZbyjtbcScrgzK0Emvg92f7Ekzt5I46xq0K5cjsZgJefqsK7XWtha2Vh4siK19M1KmChVnH5djJXY5Pxc3cwdUhCCCGEEEIUC0nkS7OmTWHYMDhyBM6ehevXdcvatf9tU736f4l906bQuDE4Oub7ECqVigY+rmw/F8OpG3GSyJtQllbh+52XmLftIplaBS9nWz5/riFP1Shv6tBMwsXOiqZ+5TgUfpft52J4qXUVU4ckhBBCCCFEsZBEvjTr1Uu3ACQmwvHjEBKiW44cgcuX4dIl3bJypW47lQrq1DGuuW/YEGxt8zxMAx8Xtp+LkZHrTej63RTGrQrlyNV7APSs781H/erham9t4shMq0NtD0nkhRBCCCFEmSOJvLlwcoI2bXSL3t27cPTof4l9SAjcuAFhYbpl6VLddpaWUL++cc19vXpgpZu2rOH9ketPyMj1xU5RFNYcu8m0P8+QlJ6Jo40lM/rUpV+jSqhUZaMv/MN0rOPB7H/OcejKXZLTM3GwkUuaEEIIIYQwf/Kr15y5uUHnzrpFLypKl9TrE/uQELh9W1ebf/w4/PijbjsbGwgMhKAgmtYPpPqdDMKVSiSmaXAyw3nJS6J7yRlMWn+KjaeiAGjm78YXAxvi62Zv4shKjmoVHPF1s+P63VT2XbpDl7pepg5JCCGEEEKIIieJfFnj5WXcJF9RdP3q9Ym9PsmPi4NDh+DQIZyAbUCStR1ZOwKhTav/au+rVtU11xeFaveF24z/7QQxielYqlW806Umr7aphkUZGZE+v1QqFR1qebD0wFW2n4uRRL6M+SP0Fn+Gq+mSpdU3IBJCCCGEKBMkkS/rVCqoXFm39O+vW6couv712frbpx0+gmN6KoQc0C165crpkvrszfJ9fCS5f0xpmizmbDrH4n0RAFSr4MBXgxtRr5KLaQMrwdrX1iXyO87HoCiKdDkoI3aci+HdtadRFDX7LsfSqW5FU4ckhBBCCFFsJJEXOalUutHuq1eH558HYOn2C/z+6zZesLzNcKvbugQ/NBTu3YOtW3WLnqencWIfFAQeHqY5l1IkPlXDsIWHOHF/UMFhLf2Y2L0OdtZla1q5gmpR1R07KwuiE9I5cytBbnqUARF3knlr5XEURff45M0ESeSFEEIIUaZIIp/N/PnzmT9/PllZWaYOpcSp7+fG7Ap+/M+1NsPf76BbmZEBp08bN8s/dQqio2HDBt2iVwRz3JuTxDQNwxcd5sSNeMrZWzF3UCDta8nNj/ywtbKgdfXybDsbzY5zMZLIm7nk9ExeXXaUxLRMbK3UpGm0MqOGEEIIIcocSeSzCQ4OJjg4mISEBFxcJBnITp8c3YxLJTYpHXdHG7C21s1L37gxjB6t2zA1FU6cMB4p/9y5Ipnj3lwkp2fy0uIQQq/H4WpvxfJXWlDH29nUYZUqHWp7sO1sNNvPx/BmxxqmDkcUEUVReG/NSc5HJ1LByYYPe9bmjZUnOHUzQbpVCCGEEKJMkURe5IuzrRVVKzhw5XYyJ2/E0752HrXFdnbQooVu0UtMhGPHjGvuC2mO+9IuJSOTl5aEcOTqPZxtLfnl5eaSxD+G9rUrABB6Pe6/G03C7Py45wobTkZiqVbx/dDG1PawR61SiE3O4FZ8GpVc7UwdohBCCCFEsZBEXuRbQx9XrtxO5sSNuLwT+dw4OUHbtrpF7+5d42nwjhx5rDnuS7M0TRav/HyEw+F3cbKxZNnLzaVZ+GPydrGjjrczZyMT2Hn+Ns828TF1SKKQ7bt0h0/+OQfA1N4BNPV3Q6PRUNEebiTDyetxksgLIYQQosyQRF7kWwMfF9Ydv1k4/VHd3KBLF92ip5/jPnuz/EfMcW9I7mvVAovSMyhcmiaL0cuOsu9SLA7WFiwZ2YyGvq6mDqtU61jbg7ORCWw/HyOJvJm5cS+FN5YfQ6vAs419eLGFn+G5yg4KN5JVhN6Io3t9bxNGKYQQQghRfCSRF/nWwMcVgJM34oqmP2pec9xnmwaPI0cgPt4wx72Bo6Ouj332ZvkldI77jEwtY349xu4Lt7GzsmDxS81o4icD/z2p9rU9+HbHJXZfuI0mS4uVhdrUIYlCkKbJ4rVfjnIvRUO9Ss581K+e0bWnsqPC/hg4eV0GvBNCCCFE2SGJvMi3uhWdsVSruJNUTP1Rs89x/+yzunVa7X9z3Otr7Y8dg6Qk2L1bt+jp57jPntxXqmTS5F6TpeWN5cfYfi4GWys1C0c0pVkVN5PFY04CfV1xc7DmbnIGRyLu0bKau6lDEk9IURQmrTvN6ZsJuDlY88MLTbC1Mm55U9lRNwfd6ZvxaLUKanXJu3knhBBCCFHYJJEX+WZrZUFNTyfCIhNM1x9VrYYaNXTLkCG6dVlZcPascbP8h81xnz2xb9q02Oa4z8zSMnZlKFvCorG2VPPjsKa0qla+WI5dFlioVbStWYF1x2+y43yMJPJmYNnBq6w5dgO1Cr59vhE+5exzbONlD7ZWahLTM7lyJ5nqHmVv5gshhBBClD2SyIsCaejrQlhkAiduxJec/qgWFroB8OrVgxEjdOv0c9xnr7k/fVo3x/3ff+sWvcqVc85x7+paqCFmaRXeWX2CDacisbZQs+DFJjxdo0KhHkPopqFbd/wm28/F8EGPOqYORzyBkIi7zPgrDID3u9emVfXcb3pZqKCutzNHr8Vx8kacJPJCCCGEKBMkkRcF0sDHlRWHr3PiepypQ3m47HPcv/qqbl1qqq6mPntyf/48XLumW9as+e/1NWpg0bgxVR0cUDk7Q7Nm4ODwWKFkaRXe/f0Ef564haVaxXdDG9O+VvG0Aihr2tSsgIVaxaWYJK7FplDZPWcNrij5ohPSGPPrMTK1Cr0aePPK01Ufun39SrpE/sT1OPo3loEOhRBCCGH+JJHPZv78+cyfP5+srCxTh1JiBd4fWf3UzXiytAoWpak/qp0dtGypW/QSEnLOcX/lCly8iPriReoDLFqka9KffY77pk3zNce9VqvwwdpTrD12Ewu1im+HNKJTgGeRnmZZ5mJnRRO/chwOv8v2c9GMaF3F1CGJAsrI1PL6L0e5nZhOLU8nPh3Q4JEDazbw0U3beKIwZtQQQgghhCgFJJHPJjg4mODgYBISEnBxkfm8c1PT0wl7awuS0jO5fDuJmp5Opg7pyTg7Q7t2ukUvNhaOHiXr4EFiNm7E68YNVDdvwpkzumXJEt12j5jjXlEUpvxxmlVHrqNWwbxBgXSrV0K6I5ixDrU9dIn8+duSyJdCM/4+w7FrcTjbWrLgxSbYWz/6z1SDSrrrdVhkAhmZWqwtZcYCIYQQQpg3SeRFgVioVdSv5MKh8LuEXosr/Yl8btzdoUsXtO3bc7hhQ3r06IHVnTv/TX+XjznulSZNWG9VicOJrliU9+HzQY3p3bCiac+rjOhQ24NP/jnHwSuxpGRk5isRFCXD6iPX+eXgNVQq+GpwI/zL5687S2U3O1zsrIhP1XAhOpF6leRGrBDC/CmKbtaOQp8OWAhRKsgvXFFggZVdORR+l+PX4xgY5GvqcIqHtzf07q1bwHiO++zN8u/Pca86dIh+QD8g084eywNN/muSHxQE1arpmuuLQlfDwxGfcnbcuJfKvkuxdJauDKXCyRtxTF5/GoBxnWrSvnb+x5FQqVQ08HFhz8U7nLgRJ4m8EMLs/XMqkul/hVHH24nFLzUzdThCCBOQRF4UWKP7/eRDS/qAd0UptznuFQXl0iX+Wvgn0dv30iDqEo3vXMEqNQX27NEtei4u/yX2+uS+cmWTznFvLlQqFR1qe/DzgatsPxcjiXwpcCcpndeWHSUjU0unOp680b56gfdhSOSvxzG0uV8RRCmEEKZ3OzGdD/88zcZTUQBEJaRxOzGdCk42Jo5MCFHcJJEXBRboWw6A81EJ0nQ5O5WKLyMUvqY2dKjNjD51ad7MVzcyfvaa+9BQXc39v//qFr0KFXIm997Sp/5xtL+fyO84F4OiKNLssATLzNLyxvJj3IpPo2p5B+YOaoj6MQbRbOjjCsBJGfBOCGGGFEVhfehNpv8VRlyKBgu1CntrCxLTMjl69a6MwSNEGSQZmCgwLxdbvJxtiUpI49SNeJpXdTd1SCXCN/9e5Ot/LwIwpVcAw1r6654ICNAtw4frHms0ukHzsif3p07p+tz/849u0atUyXgwvaZNdX34xUO1rOqOrZWaqIQ0wiITqFtRmlqXVLrxDO7iYG3Bgheb4Gxr9Vj7aXi/pdCF6ES5wSiEMCuR8alMWnea7ediAAjwdubTAQ1YFXKdZQevEhJxTxJ5Icogk3bSnT17NkFBQTg5OeHh4UHfvn05f/680TYjRoxApVIZLS1atHjkvtesWUNAQAA2NjYEBASwbt26ojqNMilQmtcb+WHXZb7YegGAid1r8/JTDxkt3coKAgPhlVdgwQLd9HeJiXDoEHz7LYwYAXXr6vrQ37wJf/wBkydDt25QvjxUrQqDBsFnn8HOnbop9IQRWysLnqpeHoAd93/4iJLnj9Cb/LQ3HIDPn2tIjScYPNPT2RZPZxu0Cpy5Jd8JIUTppygKKw9fo8vc3Ww/F4O1hZrxXWryxxutqVfJhab+uhaSRyLumjhSIYQpmLTKYteuXQQHBxMUFERmZiaTJk2iS5cuhIWF4eDw32jF3bp1Y/HixYbH1tbWD93vgQMHGDRoEDNnzqRfv36sW7eOgQMHsnfvXpo3b15k51OWBFZ2ZdOZKEnkgZ/2XOGTf84BML5LTV5tW63gO7G1hWbNdIteUpJuRPzsg+ldvAjh4bpl9WrddioV1Kr1X819UJDuRoGd3ZOfXCnWvrYH287GsP1cDG90qGHqcMQDzkYmMGHNSQBeb1eN7vWfvDapgY8rW8OiOXE9jiB/tyfenxBCmMr1uylMXHuKvZfuALoKlM8GNDC64dn0/nXu9C3p6ihEWWTSb/ymTZuMHi9evBgPDw+OHj1KmzZtDOttbGzw8vLK937nzZtH586dmThxIgATJ05k165dzJs3jxUrVhRO8GWc1Mjr/HwgglkbzgLwVscahZswOjrC00/rFr1793Q1+Nmb5V+7BufO6ZZfftFtZ2Ghm9M+e7P8+vXhETfBzEn7WrpRz49fjyM2KR13RxkIqKSIS8ng1WVHSdNoebpGecZ3qVUo+23o46JL5KWfvBCilNJqFZYdvMqcTedIycjCxlLNu11r8VLrKlg8MH5IJVc7KrrYcis+jdDrcbSqVt5EUQshTKFE3bqLj9f9+HJzM65J2blzJx4eHri6utK2bVs++ugjPDzynprowIEDjBs3zmhd165dmTdvXq7bp6enk56ebniccL+pskajQaPR5Ct2/Xb53b60q+1hj1oFkfFp3IhNxNPZ1tQhFbpHlenKkBtM/TMMgNfaVOGNtv5FX/6OjtCmjW7Ri4lBdfQoqiNHdP8ePYoqOhpOnNAtCxcCoFhbozRogNK0qW5p3Bjq1NEl/WaogoMltT0dORedxPazUfQNrFjmvqclUZZW4a0Vx7h2NwUfV1u+GFAPbVYm2qyC7+vB8qzrraupOnH9npRxKSXfUfMi5Vkw4XeS+WD9GY5cjQMgyL8cH/cNwN/dIc/rZOPKrtw6FcWhy3cIqlz048FImZofKdOSpSDloFIURSnCWPJNURT69OnDvXv32JNtmq5Vq1bh6OiIn58f4eHhTJkyhczMTI4ePYqNTe41bNbW1ixZsoQhQ4YY1i1fvpyXXnrJKGHXmzZtGtOnT8+xfvny5djb2xfC2ZmnOScsuJWiYmTNLBq6l4iPUbE5GKNixWVdAtzeW0sfP23JmTlOUbCNjaXcpUu4XrqE68WLuF6+jHVSUo5NM21siK9alXs1ahBXrRpxNWqQ7OVlNnPc/31Nzdabahq5axlRU2vqcASw4ZqaLTfVWKkVxtbLwsfh0a/Jr5RMmBiiuz/9cdNMHB5v3DwhhChWWQrsvKXin+tqNIoKa7XCM35aWnsqPGoSjz1RKn4Pt6C2i5bXA+TvnBClXUpKCkOGDCE+Ph5nZ+eHbltiauTfeOMNTp48yd69e43WDxo0yPD/evXq0bRpU/z8/NiwYQP9+/fPc38PTjf1sCmoJk6cyDvvvGN4nJCQgK+vL126dHnkG6in0WjYunUrnTt3xsqqbPx63K85w6ojN7H0rEaPLjVNHU6hy6tM/wi9xcqDpwF4sUVlpvSoVfKnN1MUNFeu/Fdjf/QoqmPHsExKwv3sWdzPnv1vUxcXlCZNUBo3NtTe4+tbKue497oWx9YfD3M52ZrOXduBNqvMfU9Lkq1hMWw5EArA7P4N6NPwyfrF5/Yd/eHyXq7eTcGrbjOeri7NTEubsvi31JxJeT7ahehEJq47w8mbutagrau5M6tPAD7l8jfOTZXIRH7/7gDX06zo2q1Djub3hU3K1PxImZYsCQUYxLpEJPJvvvkmf/75J7t378bHx+eh23p7e+Pn58fFixfz3MbLy4uoqCijdTExMXh6eua6vY2NTa61+1ZWVgX+QD/Oa0qrxn5urDpyk5M3E8z6nLOX6V8nbvHe2tMoCgxtXpkZfeqV/CRer3Zt3TJ0qO5xVhZcuJBjjntVfDyq7dth+/b/Xluhwn997fX/FmDcClNpWqU85eytuJei4eStJJr46m7MlaXvaUlxKSaJ99bqboC91NqfAU0rF9q+s5dnQ19Xrt5N4cytJDrUkemYSiv5jpoXKc+cNFlavt95mW+2X0STpeBka8mUngE819SnQL8r6vqUw8nGksT0TC7HphbbdKtSpuZHyrRkKEgZFEoiHxcXh6ura4FfpygKb775JuvWrWPnzp1UqfKQKbvui42N5fr163h75/0DrWXLlmzdutWon/yWLVto1apVgWMUeQv01U17cupGPFlapcjvApvaP6ciGbsqFK0Cg5r6MrM0JfG5sbDQ9ZGvUweGDdOt089xn32k/JMndXPcb9yoW/R8fHLOce9WskYKt1CraFuzAutDb7HjXIwhkRfFKzFNw6vLjpCUnknzKm580KNOkR2roa8rf564JQPeCSFKrNM343n395OcjdTVvHWq48GsvvXxcin4eEMWahWN/cqx68JtjkTcK7ZEXghhegXuCDtnzhxWrVpleDxw4EDc3d2pVKkSJ06cKNC+goOD+eWXX1i+fDlOTk5ERUURFRVFamoqAElJSYwfP54DBw4QERHBzp076d27N+XLl6dfv36G/QwbNswwQj3A22+/zZYtW5gzZw7nzp1jzpw5bNu2jbFjxxb0dMVDVPdwxMHaguSMLC7GJJo6nCK1NSyaN1ccJ0ur0L9xJWb3r4/aTG5cLDuxjOfXPM+1+Gv/zXE/apRujvujR3Of416lghs3YP16mDQJunYFd3eoVg0GD4bPP4ddu3SvNbH2tXUDY26X+eRNQqtVGP/bCS7fTsbL2ZZvhzTGyqLoxmBo6KP7EXvyRlyRHUMIIR5HmiaLzzafo8/8fZyNTKCcvRVfDQ7kx2FNHyuJ1wu6P598iMwnL0SZUuAa+QULFvDL/Smutm7dytatW/nnn39YvXo17777Llu2bMn3vr7//nsA2rVrZ7R+8eLFjBgxAgsLC06dOsXPP/9MXFwc3t7etG/fnlWrVuHk9N88mteuXUOdbXCuVq1asXLlSiZPnsyUKVOoVq0aq1atkjnkC5mFWkUDH1cOXIkl9Foctb3Ms7Zz54XbjFkeSqZW4ZmGFflsQEOzSeI1WRombZ/E9YTrrD+3nndbvct7rd/D0drxv40eNsd99mb5ly7BlSu6RX+zT6XSNefP3iy/YcNineO+bc0KWKhVXIxJ4vq9lGI7rtD5ftdlNp+JxtpCzQ8vNqGCU9FOA1i3ogsWahUxielExac90Y9jIYQoLMeu3eO9309yKUY38GzP+t5M71OX8oUwNWoTP11ruJCIuw8dE0oIYV4KnMhHRkbi6+sLwN9//83AgQPp0qUL/v7+BU6UHzVgvp2dHZs3b37kfnbu3Jlj3YABAxgwYECB4hEFF1j5fiJ/PY7BzQqvz2tJcS5OxcIVJ9BkKfSo78XcgQ3NqguBlYUVfwz+g7Gbx7L76m5m7p7JwuMLmd1xNi80eAG1Ko+a07zmuD961LhZ/rVrcPasbvn5Z912lpa5z3FfRP2yXO2taVK5HIcj7rLz/B3ci+QoIjc7z8fw+ZbzAMzoU5dAX9ciP6adtQU1PBw5F5XIiRtxeLmU/LEchBDmKzUji8+3nGfRvnAUBco72jCrb1261Su8MTwCfV2xVKuITkjnxr1UfN1kxiUhyoICt28sV64c169fB2DTpk106tQJ0CXlWVmPMRGwKNUa+rgCEHo9zqRxFIUDV2L56ZyajEwtnQM8+WpwIyyLsEmwqTTybsTO4Tv5/bnfqeJahVuJtxi+fjgtfmrB/uv787+jcuWgUyd4/31YswauXoWoKNiwAaZNg169wNMTMjMhNBR++glefRWaNAEnJ2jeHN54A5Ys0fXTL8Trib55/c4Ltwttn+LhrsWm8PbKUBQFnm9WuVhv9OmvSyfM8LokhCg9DlyOpdtXu1m4V5fE929ciW3vtCnUJB50NzDrVdJ1Kzp69V6h7lsIUXIVuEa+f//+DBkyhBo1ahAbG0v37t0BCA0NpXr16oUeoCjZGlV2BXTTpySnZ+JgUyImQnhiSemZjFl+Ao2iol3N8nw7pFGR9us1NZVKxbMBz9KzZk++OvgVs/bMIuRWCK0XtWZwvcF80vET/Fz9Cr5jT0/o0UO3ACgK3Lypq7HX19ofOaKrzT98WLfoOThA48bGzfKrVXusafA61PZgzqZzHAy/R69yBT8NUTApGZmMXnaE+FQNjSq7Mu2ZgGI9fkNfV1Yduc5JGfDusSmKwpGr96jj7YyjmVzXhSguSemZfPLPWX45eA0AbxdbPu5X33BTuSgE+Zcj9HocIRF36duoUpEdRwhRchT4r/OXX36Jv78/169f59NPP8XRUdeXNjIykjFjxhR6gKJk83S2xdvFlsj4NE7eiKdlNfNouHw4PJak9EzcbBS+HdwQG0sLU4dULGwtbZnw1ASGBw5nyvYpLDy+kJWnV7L+3HrGtxzPhKcmGPefLyiVSjfavY8P6AesVBRdv/rs/e2PHoXkZNizR7foubr+N0K+PsHPxxz3NT0dqeRqx824VC7Gm0/XiJJIURTeX3OKc1GJlHe05vuhTYr9+9Mg24B30l/08Xyy6RwLdl2hhocja8a0wtlWpiQSIj92XbjNB2tPcTNON3Dz880qM7FH7SL/DjXxc+PHPeEciZAaeSHKigIn8hkZGYwfPz7HenMYEX7+/PnMnz9fuggUUKCvK5HxUYRejzObRP7A5VgAarko2FiVjSQ+Oy9HL3585keCmwUzdtNYdl3dxaw9s1gUuujR/ecLSqXS1bTrR7wHXbP68+f/S+zvz3FPXBxs26Zb9Dw8jBP7oCBdSwCjQ6joUNuDZQevciZOkrqitHBvOH+euIWlWsX8IY1NMthcLS8nbCzVJKRlEhGbQpXyDsUeQ2m27vgNFuy6AsDFmCTeXH6chcObmmXXIiEKS3yKhlkbwvjt6A0AfN3s+KR/A1pXL18sx296f+T689GJxKdocLGXm29CmLsC/1X29PRk5MiR7N27tyjiMang4GDCwsIICQkxdSilin4Aq9Dr5nMX+OAV3RQu1Z0fPiCjuQv0CmTH8B2sGbjGqP9885+as+/avqI7sIUFBATo5rf/5hs4eFA3ld2xY/C//8Err0CjRrqB82JidPPbT58OvXuDl5eulr5/f/j4Y9i6Fe7epW3NCgCcl0S+yOy/fIfZ/5wDYFLPOjSvapobe1YWagIq6mbRkGnoCub4tXtMWHMKgL6BFbG1UrPrwm1mbThr4siEKLnuJKXT7avd/Hb0BioVjGjlz6a32xRbEg+6QfSq3r9peeya+fweE0LkrcCJ/IoVK4iPj6djx47UrFmTTz75hFu3bhVFbKKU+C+RjzNpHIUlPlXDmVu6vrU1XMp2Ig+62uz+dfoTFhzGJx0/wcnaiSO3jvDU4qcY/PtgrsZdLZ5ArKx0yfsrr+iS+WPHICFBl+R/8w0MH65L/vVz3K9bp5vjvksXcHenQ+/WfPvnp/Tbs47ov7eUiDnuzcmtuFTeXH6cLK1Cv0aVGNHK36TxmPNAnEUlKj6NV5cdNQzwOXdgIPMGBQKwZH8Eyw5EmDQ+IUqq9cdvEhmfRiVXO1a/2pJpz9Q1yZhBTWU+eSHKlAIn8r1792bNmjXcunWL119/nRUrVuDn50evXr1Yu3YtmZmZRRGnKMHq++jmbY5OSCcyPtXU4Tyxw+F30SpQxd0eF2tTR1Ny6PvPX3jzAqMajUKFilVnVlF7fm2mbJ9CUkZS8QdlZ5dztPuEBNi1C774QtdU//4gnOorl+l1djeTdyzCp38vcHHRJf7Dh+tuBBw4AKml//NrCoqi8OaK48QmZxDg7czH/eqbvF96Q199P3kZ8C4/0jRZjF52hJjEdGp5OvHloEDUahXd6nnzbtdaAEz7K4zdMvODEDlsDYsG4OWnqhDk72ayOJren09e+skLUTY8doc3d3d3xo0bx4kTJ5g7dy7btm1jwIABVKxYkalTp5KSklKYcYoSzN7akpqeTgCEXoszbTCF4OAVXf/45lVN98e4JNP3nz/26jHa+rUlLTONWXtmUfObmiwNXYpW0Zo2QEdHaNMG3nkHVqyAixfh7l3YupV9L43jn5qtiHXz1A2yp5/f/q23oFUr3TR4gYEwahQsWKAbdC8jw7TnUwpciE7i6NV7WFuqWfBiE+ysTT+uRIP7NfJnbsWTmWXiz2QJpygK7/1+kpM34ilnb8VPw5sajVQ/pl01+jeuRJZWIfjXY1yMltYsQujdS84w1IB3DvB8xNZFS18jH3ojjvRMGe9JCHP32Il8VFQUn376KXXq1OH9999nwIAB/Pvvv3z55ZesW7eOvn37FmKYoqQzp+b1+oHuWlSRRP5h9P3n1w5cS9VyVYlMimTEHyNo/lNz9l4rYWNo3J/j3mbKB7ze7wPavrGUzJu34O+/dXPc9+ypGzQvKwtOnICFC+G113SD5zk5QbNmMGYMLF4Mp06BtDwysuVMFABPVy+Pr5u9iaPRqeLugJONJWkaLReiTdBapBT5ftdlwwCF3w1tkqMMVSoVs/vXJ8i/HInpmYxcGkJsUrqJohWiZNlxPgatArW9nEx+/atS3gF3B2syMrWcvimtkYQwdwVO5NeuXUvv3r2pXLkyy5cvJzg4mJs3b/LLL7/Qvn17hg4dysqVK9m5c2cRhCtKqkb3E/njpTyRj0vJ4GxUAgDN/GXC8UdRqVT0q9OPsDFhzOk0x9B//unFTzPo90HF138+n+pVdMbeQiEpPZMTGhtdAv/hh7qEPioKrl+HtWvhgw+gc2fdDYCMDN2o+d9/DyNHQoMGumb5Tz0FY8fCr7/qRtjXlt1a3y33m5V2qWva2qjs1GoV9e9PQ3dCBrzL07awaD7bfB6Aac/UzXPmERtLCxa82JTKbvZcv5vKa78clRo/IfivWb2pa+NB9zdZXysvzeuFMH8FTuRfeuklKlasyL59+wgNDeWNN97A1dXVaJuqVasyadKkwopRlAKBlV0BOHWjdDdjPRR+F0WB6h6OVHCyMXU4pYaNpQ3vtX6Pi29e5JXGr6BCxeozq6n1bS0mb59smv7zubBQq6jpqhvAcPeFO8ZP6ue479cPPvoItmyB2Fi4fBlWroTx46FtW13T/ZQU2LcPvvoKXngBatfWJf0dOsB778Hq1RAermu+b+ZuxaVy6mY8KhV0rGP6H7LZ6ZvXy8j1ubsQncjbK4+jKPBCi8q80MLvodu7OVizaERTnGwtCYm4x8S1p1DKwGdciLykabLYdX/ciJKQyAOGPvohksgLYfYKnMhHRkayYMECgoKC8tzGzs6ODz/88IkCE6VLtQqOONpYkqrJKtXNWPXN6luaaNqs0s7T0ZP/9f4fx149Rjv/dqRnpfPRno9KTv95oNb9mQj2XrrziC3RJfdVq8KgQfDZZ7BzJ8THG/etb9kSbG11g+zt2KHbbtAg3esqVIBu3WDyZPjjD7h5s2hPzgT0tVFN/cpR3rFk3fwKvD/g3Ynr0sT0QfeSMxi19AjJGVm0qOrGh73r5ut11T2cmD+kMRZqFWuP3eS7nZeLOFIhSq4DV2JJycjC09mGehVdTB0OAE38dDXyR6/eRauVG21CmLMCz41hb/9f/5/U1FQ0Go3R887Ozk8elSh1LNQqGvi4sP9yLKHX4wxzOJc2+oHuWkgi/0QCvQLZPmw768+tZ/zW8Vy5d4URf4zgm8PfMK/bPJ6q/FSxxpOpzSRVk0p8SjwV7GPQqODwjRvsu2qDrRVkZGWg0Wp0/2Zp8vfYV0NGRQc0PVuTkdkEzZ0YMqJvoYmNIePubTQJcWSoY9GoN+N+djP+B8A/DvzVbvj7B+Jb/ylsglpAUBCUL765hgvbljBd//guAV4mjiQnfY38+ehE0jRZ2FqZfhC+kkCTpWXMr8e4djcFXzc7vhvaBCuL/N/Xb1OzAtOeqcuU9af5bPN5qlVwoFs97yKMWIiSSX8js1MdT9Rq087UoVe3ogu2VmrupWi4cieJ6h5Opg5JCFFECpzIJycnM2HCBFavXk1sbGyO57OySm+fufnz5zN//vxSfQ6mFOjrej+Rv8eQ5pVNHU6B3U3O4FyUbjTmFjJi/RPT95/vUaMHXx/6mpm7Z3I08ihPL36agXUHMqfTHHydfUnNTCVFk5Lnkqp5yPOZj3j+/qLRGt9wxFb3z1NLiuDE7YBK95dc3QW2o9Jux3sb+P8O/hp7/J0q418pAP9azfFr0pHKPnWxtbQtggALT3yKhkNXSsZozbnxdrGlvKMNd5LSOXMrwVBTVdbN+CuMA1dicbC24KdhQbg5FHyezRdb+HE5Jokl+yMYuyqU31ztDWMSCFEWaLUK/569n8iXoOuftaWaQF9XDl65y5GIe5LIC2HGCpzIv/fee+zYsYPvvvuOYcOGMX/+fG7evMmCBQv45JNPiiLGYhMcHExwcDAJCQm4uMgPkoIq7SPXH7pfG1/L0wl3R5scrU3E47GxtOHd1u8yrOEwpu6Yyo/HfmT1mdWsPrPaJPFYqixRq6zJzFJjZ2VDOXs7rC2ssVJb6f61sHr0Y3X+trNSW2GptuR2ym0i4iKIiL1MRMwFIpJvkqrScMsZbjnDflKAc6A5B6fXwmldrN6ZdvjbeOJfvjr+/oH4V6iBv6s/fi5++Ln6mTzR33E+hkytQi1PJ/zLO5g0ltyoVCoa+rjw77kYTlyPk0Qe+OXgVZYdvIpKBfMGN6KW1+P/yJ/csw7hd5LZdeE2o34O4Y/gp/ByKdk3n4QoLKduxhOdkI6DtQWt8hgk0lSC/N04eOUuIRH3GNys9FWsCCHyp8CJ/F9//cXPP/9Mu3btGDlyJE8//TTVq1fHz8+PX3/9laFDhxZFnKIU0A94dzEmicQ0DU62VqYNqIAOGJrVS218UfB09GRB7wWMCRrDuM3j2BGxw+h5eyv7HIudpV2B1ttb2WNnlfdzaq2af/75B5sqTXlteSh+DvbsGte+2N8LRVG4k3JHl9zfCiPi7H4irp0iIi6ciMxYIhw0pFhDpGUqkVkRHIiOgOhtOfbj5eCFfzl//F398XfR/evn6oe/qz+VXSpjb1W0UyEZmtWXoNHqH9TQ15V/z8XIgHfoxgCZ9ucZAMZ3qfXErSgsLdR8M6QRA77fz4XoJF5eGsJvr7XE3rrAPy2EKHX0zerb1qqAjWXJ6rajv2l55OpdE0cihChKBf5re/fuXapUqQLo+sPfvau7SDz11FO8/vrrhRudKFU8nGyp5GrHzbhUTt2Ip1X10tXvV98/Pq/pl0ThaOjVkO3Dt3M7+TYWagvsLO2wtbRFpSr6/oX6VhbNqrhhqVZxNTaFq7HJ+LkXb22ySqWigkMFKjhUIKhSEAQNN3peiYkh9tAOIo7vIOLyUSKizxNhkUiEK1x1gfBykGwNUclRRCVHcfDGwVyP42rrSiWnSlRyrqT7N/v/7/9bwaECalWBxz0lTZPFzvO60ZpLYv94vQb3m3ufvFG2B7y7FpvCmF+PkqlVeKZhRca0q1Yo+3W2tWLh8CD6zt/HmVsJjF0Zyg8vNCkx/YWFKCrbzv7XP76kaexXDpUKrsamEJOQhoeztJQRwhwVOJGvWrUqERER+Pn5ERAQwOrVq2nWrBl//fVXjmnoRNkT6OvKzbhUjl+PK1WJ/J2kdMNo+82rSCJfHCo4VDDZsZ1sLWlcuRyHI+6y5+KdYk/kH0Xl4UH53oMo33sQTfUrb93SzWd/5AhKyGHung4hQnuPCFd0Cf79fyPKqQh3U5FkqSUuLY64tDjO3D6T57Gs1FZ4O3k/MuG3s7Izet3+y3dIycjC28WWepVK7uCW+gHvrtxJJj5Vg4td6WopVBiS0jN55ecj3EvRUL+SC58OaFCoN8583ez537AmPP+/Q2wJi+bTzed5v3vtQtu/ECXN9bspnItKxEKtokNtD1OHk4OzrRW1vZw5G5nAkav36FFfBqMUwhwVOJF/6aWXOHHiBG3btmXixIn07NmTb775hszMTObOnVsUMYpSJNDXlQ2nIktdP3n9gF21vZwo9xgDP4nS56ka5TkccZe9F+88cv7sEqFiRejTB/r0QQW4KwruERE0OXLEkODz9xFITERBIcEGbjrDTSe46WHLzVre3PRx4WY5S27apHEz/Q7RSdFotBquxV/jWvy1hx6+nG05o0T/3E1LEi2saFGpDqFRblRyrkQF+wrF0rKiINwcrPF1s+P63VRO34yndSm6wVgYtFqFcatCOR+dSAUnG34c1rRIRu9v4ufGpwMaMHZVKD/sukzVCg4MbOpb6McRoiTYcr9ZfZB/OVztS+ZvhiD/crpEPkISeSHMVYET+XHjxhn+3759e86dO8eRI0eoVq0aDRs2LNTgROmj7ycfej0ORVFK3I/6vBy4optTXJrVlx1P1yjP3K0X2Hf5DplZWiwLMP1WiaBSQZUquuW553TrtFq4eBFVSAguR47gEhJCwPHjcCUVDoYbv97dHU1QJ6Ka1uZmHR9u+pXjpmUqNxNucjPx/nL//ymaFO6l3eNe2j1Ox5z+bx/WsCocVv3v/i7t3OlWvRs9a/SkW/VulLMrGYPLNfBx5frdVEKvx5W5RH7u1gtsDYvG2lLN/15sUqSD0fVtVIkrt5P4evslJq07RWU3e5nKU5ilbWElt1m9XhO/cvx84Kr0kxfCjD3xiDSVK1emcmUZEVPo1KvogoVaxe3EdG7Fp1HJ1e7RLyoBDly+3z9efnSWGQ18XHG2tSQhLZMTN+LNY0RztRpq1dItL7ygW5eZCWFhuhp7fc39iRMQG4vVpq34btqKod7U21s3r33TphD0AvRsiuLuTnx6/H8JfsJNDl+7yC9HQlFZ3KWadwa3Em8SkxxDbGosv576lV9P/YqFyoJWvq3oWaMnvWr2IqBCgMlu7AX6uLLhZGSZG/DuzxO3+HbHJQA+6V+fRpWL/jM+tlNNLt9JZsPJSF775Sjrx7QukTMaCPG44lIyOBxRcqfd1Avy1w3ce+ZWAsnpmTjYyCCUQpibAn2rtVotS5YsYe3atURERKBSqahSpQoDBgzgxRdfLDW1r6Lo2FlbUNvLiTO3Egi9FlcqEvmYxDQu305GpZL+8WWJhVrFUzXKs/FUFHsv3jGPRD43lpbQoIFuGTlSty49HU6eNE7uz5yByEj480/dcp/K3x/Xpk1xDQqibtOm0KQ/kZG3cNe0pm/diswb3AiAjKwMDt44+P/s3Xd4W+X1wPGvJMt7rzjxjBPHibOc2M4iiyxIWCFll1lGac0uBfKjpVBaKFBGgRRoC4S9EzYZkE2WR+wMx3vvvbek3x/X8iBOYju2Jcvn8zz3SSxfXb3ytWSd+573HL5L/Y5v074lqSyJvbl72Zu7l0d+eoRAl8DOoH5p0NJT1twPpdFY8O5Yfg1//CwRgN8uDmbdbL9heVy1WsXzV84kv7KRxPwafvNODJt/dx4u9qOvNoGwTLtSytDpDUwa42h29VW6G+dq11mAeDRmIwkxGvQ5l9RgMHDppZdy2223UVBQwPTp05k6dSo5OTncfPPNXH755UM5TjGCdPWTrzLtQProYMf6+LCxzvJhc5RZOFEpuLc3rczEIxlmNjbKzPvvfgdvvaUE9bW1sG8fvPgi/PrXMGmSsm92Nnz+OTz8MCxfDq6uXH/TKl785p/cEf8N/PwzNDZirbFmceBinln5DCd+f4Kse7N4dfWrXDjxQmw0NuTU5PDv2H+z5sM1eDzrwaUfXcobsW+QX5s/5E93mq8LahUU1TRTWts85I9naqW1zdz+biwt7XrOD/XioQuHt/CcrVbDf2+MZKyLLZllDUR/GE+bTj+sYxBiqBjbzpnzbLxRZFBHG7rskfF5TAjRP32ekd+4cSN79uzhp59+4vzze/Zd3rFjB2vXruXdd9/lxhtvHPRBipEl3N+VDw7ljpiCd5JWP3otClFmKI7kVVPb3Iaz7Si+kOPgAOedp2xGNTUQF9c1cx8TAzk5BJTnE1CeD0m74Lm/KCn9U6d2pOQrqflBM2YQPSea6DnRNLQ2sCNrB9+mfst3ad9RUFfAN6nf8E3qN/AdzBwzk4tCLuKiSRcx13cuGvXgFmNzsLFiorcjqSX1JObXsDLMclsxNbfpuOO9OIprm5no7ci/rp2FxgSt4LydbfnfTZFc+foB9qWX85evT/D3tdMkc0+MaC3tOnallAKw0ozbbhpFBrnzVUKhrJMXwkL1OZD/6KOP+L//+79TgniAZcuW8cgjj/DBBx+M6EB+w4YNbNiwAZ1OZ+qhjGizOgreHSuooU2nR2vmRcQOdfSPl6JMo4+/uz3jPR3IKm/gYEYFq6aa/wezYeXiAsuWKVuH/206xL6PtnCZrojL2zta4hUXw7Fjyvb228qOWi3MnAmRkThERXFJZCSXrN6A4eLXSSxJ5LvU7/gu7TsO5h8ksSSRxJJEntr3FB52HqwOWc1FIRdxwYQLBq1g3gw/V1JL6jmaXz0iZtIGwmAw8H+bj5GQV42LnZb/3Rhp0otTU8e58K9rZnHHe7F8eCiXiV6O/GbheJONR4hzdTCzkoZWHd5ONszwdTH1cM4qsmPJWHxO1cgs6iqEOKM+v6KPHj3KhRdeeNrvr169msTExEEZlKlER0eTlJRETEyMqYcyogV7OuJka0Vzm56U4jpTD+eMSmqbySxvQK2COcHuph6OMIGFHesG96aVm3gkI8PXhW3smhBJyyP/p6ylLyqC/HzYvBkefRQuuADc3aGtTZnJf/11uPVWJah3cUG1aBHh/9jIo3lB7F/4NiUPFPHu2ne5eurVuNi4UNFUwftH3+faL67F6zkvlmxcwrM/P0tSWRIGg2HA457ZseQn0YLXyf9vbxab4gvQqFVsuG62WRSZWxk2hv9bPQWAv32XxI7kEhOPSIiB255UDMDyKWNQmyDTpb8mjXHCydaKhlYdyWb+eUwI0X99npGvrKxkzJjTz2KMGTOGqipZgyOUYkcz/VzZl15OQl4108z4qrUxrX6ar8voTqsexRaFePLewZzRt05+AIpqmjiaX4NKpXyQ7eTrq2xr1ypfGwzK2npjIb2YGCVFv65OWVP/88+dd/VyduaGiAhuiIqiLeI19geo+K42ju/SvyepLIk9OXvYk7OHh398mCDXoB4F8zT0PQV/ZmfBu5HVGrOvdqaU8vQPJwH480VTWBhiPoWtbls0noyyej6OyePuD4/wxe8XMNnH2dTDEqJfDAYDPyYpafWrRkhWj0atIiLQjV0pZcRmV5r15zEhRP/1OZDX6XRYWZ1+d41GQ3t7+6AMSox84f5dgfz18wJNPZzTOihp9aPe/AkeaNQqsisayatsxN/d3tRDMlvG3skRAW54OdmcfsfuPe6vukq5Ta+H1NSe6+2PHFGK7O3cCTt3ogWWAEs8PXk2MpKsqGV8F9jKt6Sys2g/2dXZbIjZwIaYDdhr7Tk/6HyCm4NZ3r4crfbMF+Im+zhjrVFT3dhGXmUTAR6Wc57TS+u458Mj6A1wTZQ/Ny0IMvWQelCpVPz1smnkVDRyILOCWzfG8mX0eWf+HRLCzBwvqKW4thl7aw3zJ4yczwxRQe7sSikjJqeKm8+TpS1CWJI+B/IGg4Gbb74ZG5ve//C2tLQM2qDEyNdVub7apOM4mwOZUuhutHOy1TI7wJWY7Cr2ppVz3dwAUw/JbG3rCORXTR3AbJRaDZMnK1v3HvcnTvRsg3f0KJSXw5YtjN8Cd6FsDQE+/LQkgG8n6vnOKovCtgq+S/sOgC/+/QUPL3yY22ffftq2dtZWaqaMdSIxv4aE/GqLCeRrGtu47Z1Y6lraiQpy46+XmWdBOWsrNa9dP5vL/72frPIG7ngvlo9un4etdnALGwoxVIxp9YtDvEbU762xtWpsdqVFZiMJMZr1eY38TTfdhLe3Ny4uLr1u3t7eI7rQnRhc4R0F7zLK6qltbjPtYE6jsLqJnIpGNGpVZ4sWMTqN2jZ0/VDT1Na5FGXQqjVbWSlr52+9VVlLHxurzNAfPgwbNsAtt8C0aaBW45BbzKXvHeY/f4kl/9EKjrwOTxxxxafZmsL6Qu7dci/jXwri+f3P09Da0OvDzfBzBeComV9g7Kt2nZ7oD+PJrmjE19WO166PwNrKfItZudpb8+ZNkbjYaTmSW81Dnx89p7oHQgyn7SeVtPoVIySt3mimnytajYqS2hbyq5pMPRwhxCDq84z828ZKxEL0gaejDX5uduRXNXE0r8as1msaGdPqp/m64CTr40e1RZM8efHHVH5OL0enN5ikXZe525VSSrveQIi3I+OHsoiara3Swi4qquu2hgYlDb9j5l4VE0N4WhrhX1Xz8LewMRyeXgQ5lPLg9gf5x5ZH+YPDSqLn3YNT1Hlgr8y+z/R35b2DORy1kIJ3f//+JPvSy7Hr6Nvu6Wj+qerBXo689uvZ3PjWYb5OLGSClyP3rggx9bCEOKO8ykZOFtWiVsGyyd6mHk6/2FlrmObrwpHcamKyK2X5mBAWxHwv3YsRryu93jyLIEr/eGE0w9cFZ1srapvbOZpfberhmKVtJ84hrf5cOTjAwoVw333wwQfKWvuqKtq3bCH91zdye+A60r4M4M2vILgSyjUtrG/+lqDvV/HkGkeqI6bCrbey+MfPmFGUSkpuGTr9yJ4J/iQml7d/zgbgxatnEjZu5BSPWzDRk7+tnQbAiz+m8nVioYlHJMSZ/XhSef+LDHLH3cHaxKPpv6ggpStPbI55fh4TQgxMn2fkheivcH9Xvj1aZLbr5DvXx4+gojViaFhp1CyY4MmWE8XsTStnVoAsteiuuU3HrhRjteZBSqs/V66uGJYtI725mUlr1qDVavlNWRk3xhzio9i3+VvTVlLtG3jsfAPPNydxz6Ek7vsIvm6CVrUVbd9NRzN/jjLzHxkJYWFwloJ55iImu5I/fXkcgPtXTOLCaWNNPKL+u2ZOABll9fx3bxYPfpaIn5sds+V1J8yUMZBfOWVkpdUbdV8nL4SwHDIjL4bMrI518gl51Wa3DjKvspH8qias1CoiA+XDo1DS60HWyffmQEYFDa06fJxtmW7O7Yu8vLBaczE3PPYFSX+v4cN1HxLmOokaW3hyCQQ+qOGBC22osW3H9ugReOMNuO02CA8HZ2dYsADuuQfeew9OngSdztTP6BT5VY3c+V4cbToDa6b7cPeyiaYe0oA9snoKK6Z409qu5453Y8mvajT1kIQ4RU1TG4cylQB45QhbH29k/JyTWlJPdWOriUcjhBgsEsh3s2HDBsLCwojqvjZTDNjUcS5YqVWU17eaXYEV4/r4GX4uONhIYopQKhEDHMmtps5MCzSayraOas0rw8agHiH1AzRqDddOv5Zj95zksys/Y8aYGdRrdLw4rwWfB6256P+WUPzQ72HZMiWIb26GAwfglVfgxhuVGXpXV1i6FB58ED75BDIywIQXJRtb27n93TgqGloJG+vMP6+cOWLOR280ahX/umYWU8Y6U17fym3vxFLfIm1shXnpXh8kaCjrgwwhD0cbgr2UscdJer0QFqNPgfzs2bOpqlJe+H/9619pbLTMq+bR0dEkJSURExNj6qFYBFuthiljlXWb5pZeL2n14pf83e0J8rCnXW/gYKakHxrp9Aa2n0vbORNTq9RcEXYFR357hC+v/pIJrtPRq1v53no3453f4r4/Tqcg5zikpCjr7++7T1mPb28P9fWwezc8/zxccw1MnAgeHrBqFfzf/8HmzZCXNyzBvV5v4A+fJnKyqBZPR2v+e1Mk9tYj/yKkg40Vb94UiZeTDcnFdTzw2VFGePkCYWGM738jrVr9L0UFyjp5ISxNnwL5kydP0tCgtPN54oknqK+vH9JBCcthjv3kDQZDZ5rcPCl0J7oxdleQ9PouCXlVlNe34mRrxdzxI/f1olapuWzyZey4/gDeLX/BRh9Kc3sz/zr0L4JfnUh02r/IvWghvPgi7N2rtME7dgzefhuio2HOHLC2hqoq2L4dnn4a1q2DgAAYOxYuvhieeAK++w5KSwd9/P/6KY0fjhej1ah4/foIfF3tBv0xTGWcqx3/vTESGys1O1PKeTNFzc8ZFSO+IKEY+Vrb9exOUf4ejNS0eqOIIFknL4Sl6dPl/PDwcG655RYWLlyIwWDgn//8J46Ojr3u+9hjjw3qAMXIFt7R7smcAvm8yiYKqpvQalREdlyhFgJgUYgX7x/MZW9auamHYjaM1eqXTfY26x7lfeXvbo+v3XnYNkSyfm0bH5x8gX25+/h37L/5b/x/uTn8ZtYvXM94t/FKD/tp0+Dmm5U7t7bCiRMQE6NssbFKsF9SogTw333X7YH8uwrpRUVBRAS4Dawex66UUv71UxoAf187ncggy3vfCvd35fmrZnL3R0c4XqXm5o1xjHG2YW24L5fP9mWyz8ipyi8sx6GsCupa2vF0tCHcz9XUwzknxsr1iXk1NLfpsNVqTDwiIcS56lMgv3HjRv7yl7/w7bffolKp+OGHH7CyOvWuKpVKAnnRQ3hHwbvjBTW06fRoNaYPBA5kKkFauL8rdtbyh0x0mT/BA41aRVZ5A3mVjaO+367BYGDrCWV9vNlUqz9HKpWKGX4u7Eopw04/iz0372F3zm7+uvuv7MzeyX/j/8tbR97ihpk38H8L/48Qj249zq2tYdYsZbvjDuW2piZITOwK7GNiIDlZSbnPy4NNm7ruP3FiV2AfGQmzZ8NpLop39/ruDAB+PTeAq6L8B/PHYVYunjGOcc7WPL/5AMdrrSmpbeGNPZm8sSeTKWOdWTfLl8vCx+HtbGvqoYpRojOtfor3iK5HARDkYY+nozXl9a0cL6ixyAuCQow2fQrkQ0ND+fjjjwFQq9X89NNPeHt7D+nAhGUY7+HQ2Z87uaiO6X6mr3h9UNLqxWk422oJ93clLqeKfenlXDsnwNRDMqn00nqyKxqx1qhZEupl6uEMmpl+ruxKKSMxvxqVKoilQUtZGrSUfbn7eHLPk2zL2MbGhI28m/gu1067lkcXPcoUrym9H8zODubNUzajujqIj+8Z3GdmQnq6snX8PUWlgilTes7cz5wJtl2BakZZPQczK1GrIPr8kVuhvq+m+7pwVbCeN1YtZV9GFZuP5LMjuZSTRbX8vaiWp384yXkTPfnVbD9WTR1jEXUChHkyGAz82BHIj/S0elAuYkYGurPlRDEx2VUSyAthAfr9F1Cv1w/FOISFUqtVzPR3ZW9aOQl5VSYP5A0GAwcyOgrdSSAverEoxJO4nCr2ppWN+kB+W8eH2PMmeuBoQd0dZvor70NH82t63L4wYCFbr9/KofxDPLnnSb5L+44Pjn3Ah8c+5MqpV/KnRX9i+pjpZ38AJydYskTZjCorlaDeGNjHxkJ+PiQlKds77yj7WVnB9Omdgf3OJnesdFYsmTqOcRa0Lv5sbKzUXDjNhwun+VDd2Mq3R4vYFJ9PfG41e9PK2ZtWjr21hgun+bBull9nNo0Qg+VEYS2FNc3YaTWcN9HT1MMZFJFBbmw5UUxcTiUwwdTDEUKcowHlOWdkZHD33XezYsUKVq5cyT333ENGRka/j/P0008TFRWFk5MT3t7erF27lpSUlM7vt7W18fDDDzN9+nQcHBwYN24cN954I4WFhWc87saNG1GpVKdszc3N/R6jOHezOgreHTGDdfLZFY0U1zZjrVEzW/rHi14s6mhD93O6FNva1lmt3jLS6o1mdKx1zSir77XV4Fy/uXx73bfE3h7L2slrMWDg0xOfMuP1Gaz7ZB2xhbHoDf28qO3ufmq1+6Ii+OYbeOwxWLMGvLygvR2OHIH//hfuuIPb7r2CEy9eyQsv3gl33w3vvqsE/kPQ495gMJBbk8sPaT/w/P7nuev7u3j/6Pu06kzbd9rV3prr5wWy6ffnsevBpdy7PIQAd3saW3Vsii/g+jcPseAfP/H09ydJLq416ViF5TCm1S8K8bSY9eTGWfjYnCr0o/zvmxCWoN9TLFu3buXSSy8lPDyc8847D4PBwP79+5k6dSrffPMNK1eu7POxdu/eTXR0NFFRUbS3t/Poo4+yatUqkpKScHBwoLGxkfj4eP785z8zc+ZMqqqquO+++7j00kuJjY0947GdnZ17XBQAsLWVdXWmYFwnbw4F74z948MDXC3mD7MYXDP9XHCytaKmqY1jBTWdnRdGm+KaZhLzqlGpYPkUy1pK5elog6+rHQXVTRwrqGHBhN5n2yLGRbD56s0cLTnK3/b8jc+TPmdz8mY2J2/G1sqWEPcQJnlMItQjlEkekzo3D/s+Zvv4+CjV7i++WPnaYIDc3M5Z+7KdP2OTeATnlgZsjsbD0fiu+zo6Kmvsu6flBwcr6fpnoTfoyavJ40TZCZLKkjr/TSpLor61Z1eaDTEbeGj7Q0RHRfPbyN/iaW/amckgTwfuXzmJ+1aEEJ9bxab4Ar49WiTr6cWg225BafVGU8c5Y6tVU93YRkZZPSFjnEw9JCHEOeh3IP/II49w//33849//OOU2x9++OF+BfJbtmzp8fXbb7+Nt7c3cXFxLF68GBcXF7Zv395jn1deeYU5c+aQm5tLQMDp015VKhU+PpY1izRSzeyY/cosa6CmsQ0Xe63JxiJp9eJsrDRqFkzwYOuJEvamlo3aQH77SeVD7OwAN7ydLC8YmuHnQkF1E0fzTx/Id+47ZgafXvkpSWVJnQF9c3szx0qPcaz02Cn7u9u5dwX27l0B/kT3iThYO5z+gVQqCAxUtl/9irveOMDhzHIem2LDLdblXWn58fFKj/s9e5TNyM2tRzE9fWQEuY46TnQE6d0D9oa2hl6HYKW2YpLHJMK8whjnOI7Pkj6jqL6IP+38E3/b+zdunHEj98277/Q1A4aJSqUiItCdiEB3HrskjJ3JZWyKz2dniqynF+euoLqJpKJa1CqlY4el0GrUzPJ340BmBTHZVRLICzHC9fuv2smTJ/n0009Puf03v/kNL7300jkNpqZGWa/o7n76Ahw1NTWoVCpcXV3PeKz6+noCAwPR6XSEh4fz5JNPMmvWrF73bWlpoaWlpfPr2lolNa+trY22tlPTLntj3K+v+48mzjZq/N3syKtqIi6nnEUmWmumrI9XKtZHBbqc9VzJObU8fT2nC4Ld2XqihD1pZdy5OGgYRmZ+th4vAmBZqKfZvgbO5TU6bZwTPxwvJiG3qs/3D3EN4Z1L3+HNi98kuzqbtMq0U7a82jwqmyo5mH+Qg/kHTzmGn5MfIe4hyuYR0vn/IJcgtJqui5yZZQ0cyqpErVaz/OL5tLnYwpVXKt/U6eDkSVTx8ahiYzHExZKbnchJ1ypONG4nKWk7J8rgZCw0WPf+XLRqLSHuIUzxnEKYV5jyr2cYE90nYq3putNT5z/Fp0mf8vLhl0koSeA/8f/hP/H/4YLgC7h7zt2sHL8SVR+yAPpqIOdUDSwP9WB5qAdVja18f7yErxIKOZJX02M9/QVh3lwWPo55491lPf0wGal/R7ceU5Zwzg5wxdlGPeLGfyazA1yUQD6rnCtnj+33/UfqORWnJ+fUvPTnPKgMBkO/Fsn4+/vzwgsvcKXxA0WHTz/9lAcffJDc3Nz+HK6TwWDgsssuo6qqir179/a6T3NzMwsXLmTy5Mm8//77pz3WwYMHSU9PZ/r06dTW1vKvf/2L77//nsTEREJCQk7Z//HHH+eJJ5445fYPP/wQe/vR3X5qsLyTqia+Qs0afx0X+JlmXVZJEzyVYIWVysA/5ujQmr4TnjBT5c3w5BEr1CoDT0fpsB1lqzAa2+HRWA16g4pHw9vxtsAaa2k1Kl5N0uBuY+AvswdvvXmLvoWiliIKWwopaCmgsLmQwhZlq9PVnfZ+GjSMsRnDOJtxjLMZR2m9H1nVfkx1Hsvdk11RqVToDXpKW0vJa87r3HKbc8lvyadF39LrcbU6CC2HsDKYWqb8G9zuhodHCA0TQ6maOJHqCRNoP0sbPIPBQFJDEl+Xfc3hmsMYUN7H/W39ucTrEpa4LcFGbTPwH9wQKGuC2HI1MWUqKlq6AncXrYEILwNRnnrGnSFBYqgYDKAzgFqlbML8/DtJTUqNmssCdSwbZ1lryU9Wq3j9pAYPGwOPDeJ7nxBicDQ2NnLddddRU1ODs7PzGfftdyD/17/+lRdffJFHHnmEBQsWoFKp2LdvH8888wx/+MMf+NOf/jSgQUdHR/Pdd9+xb98+/Pz8Tvl+W1sbV155Jbm5uezateusT6w7vV7P7NmzWbx4MS+//PIp3+9tRt7f35/y8vI+P05bWxvbt29n5cqVaLWmSx03VxsP5PD371NYOsmT/94w2yRj+PBwHn/55iTzxrvx3m+izrq/nFPL059zuuyFveRVNfH6r8NZbkGplX3xzdEiHvjsGBO8HNhyz3mmHs5pnctrtK65nYindmAwwMGHl+DhOPRBaEVjBWmVaaRWpvaYxU+vTKepvem093PQOuDr5Etebd5p97PWWDPJfVLPGXbHYCbm1mMdn4AqLg5VbCykpqLq5c++YeJEDBERGCIjlX9nzQKH3qPcjKoMNsRsYOPRjZ1r6j3tPLl99u3cGXEnYx37P8tnNBTvuwaDgSN5NXyZUMj3x4upaWrv/N5kHyfWho8lIsCVNp2BVp2e1nY9Le3d/u24TflaR2u7QflX94v9Ttm35zG6fw3gaqfl9kVB3DgvwGJrtozEv6N1zW3M/ccu2nQGtt17HuM9TXC1ZwjVNbcT+dQO9AbY98fFjOlnHYmReE7Fmck5NS+1tbV4enr2KZDvd2r9n//8Z5ycnHj++edZv349AOPGjePxxx/nnnvuGdCA7777br7++mv27Nlz2iD+qquuIisrix07dvQriAdQq9VERUWRlpbW6/dtbGywsTn1Q5xWq+33L/RA7jMaRAQpa9KPFtRiZWU1qKmYfXU4pxqA+RO8+nWO5Jxanr6c08WTvPjgUC4HMqu4cLrvMI3MPPyUoixBuWCqz4j43R/Ia9RdqyXY04GMsgaSShpY5nbmGenB4OPig4+LD4vGL+pxu96gp6C2gNSKVFIrUvkhOZ4f0xIwaIpoUxXT0NZAamUqoATskz0nM9VrKmFeYYR5hTHVayoT3Cdgpe7lT/p4YMn5XV/X1ipr7Lu3wcvMRJWejio9HT75RNlPrT61x/2MGWBry2Tvybxy0Sv8bfnfePPIm7x86GVyanJ4+uen+eeBf3LNtGu4f979zBrb+3K2vhjs9925E7yYO8GLxy+b1mM9fXJxHf/YcvpMiaFU3dTGc9vSeO9gHvetCOGKCD+sNJaZKjaS/o7uSyqjTWdggpcDk8a6mno4g85dq2WyjzNJRbUkFtRzkcfA1smPpHMq+kbOqXnozznodyCvUqm4//77uf/++6mrU/74OTkN7E3AYDBw9913s3nzZnbt2sX48eNP2ccYxKelpbFz5048PPpfpMxgMJCQkMD06X3o/yuGRNhYZ7QaFZUNreRVNhHgMbxLFgwGA4c6KtbPnyCF7sTZLQpRAvm96eWmHsqwamnXsSu5FLC8tnO/NNPPlYyyBhLzalg22XSVqdUqNf4u/vi7+LM8eDm74g/g3VrJfStC+P35QWRVZZFXm0eASwDBbsG9B+x95ewMS5cqm1FFBcTFdQX2MTFQUAAnTijbxo3Kflptjx73LpGRPBB5N/fMvYcvk7/kxYMvsj9vP+8dfY/3jr7HksAl3D/vfi6edDEatXnMONtYaTr701c1tPLtsSK+TiigoKoJG60GGys11lbqbv9qsNb0cluPr43bL28/db/ux/zxZAkvbE+loLqJRzYd4797M/njBaFcMNXHJBe7heLHjmr1KyyoWv0vRQW5kVRUS0x2JRfNGHgGjRDCtM6phOtAA3ij6OhoPvzwQ7766iucnJwoLi4GwMXFBTs7O9rb27niiiuIj4/n22+/RafTde7j7u6OtbVSkOfGG2/E19eXp59+GoAnnniCefPmERISQm1tLS+//DIJCQls2LDhnMYrBs5WqyFsrDOJ+TUcyasa9kA+vbSe8vpWbLVqZvq7DOtji5Fp/gQP1Cql6Fh+VSN+bqOjXsb+jAoaWnWMcbZhhq9lv1Zm+ruy6UgBR/OrTT2UTuml9UqROxVcHeWPtcaaUM9QQj1Dh+5BPTyUHverVnXdVlSkBPXGwD4mBsrLldn8+Hj4z3+U/WxtsZo1iysiI7ki6k4OL7+Hl4q/5NOkz9ids5vdObuZ4DaBe+feyy2zbsHReugzH/rKzcGaG+YFcsO8QJM8/q8i/LhoxljeP5jDhp3pZJQ1cOf78YT7u/LI6snMk+4qw65Np2dnSseFTAsO5COC3HnnQA5xOVWmHooQ4hyYNIfrtddeo6amhqVLlzJ27NjO7ZOO1L78/Hy+/vpr8vPzCQ8P77HP/v37O4+Tm5tLUVFR59fV1dXccccdTJkyhVWrVlFQUMCePXuYM2fOsD9H0cXYxssU/eQPdMzGRwS6YWNlHjNDwry52Gk7f2f3pY2eWfltJ7p6J6stvBLXDD/lQsXR/Br6WS5myHx8WCkYu2yyN2NdTFhlcOxYuOQSeOIJ+P57KC2F7Gz47DN4+GFYtkyZ3W9uhgMH4JVX4MYbmbPoGj685Vuyf47i4dY5uKodyKjK4J4t9+D3gh8PbnuQnOoc0z0vM2Or1XDbomB2P3Q+dy+biJ1WQ0JeNdf85yA3v32YpMJaUw9xVDmUWUldczuejtaE+7uZejhDJipIeW4nCmuob2k/y95CCHNl0qaqZ/vgFBQU1KcPV7t27erx9YsvvsiLL754LkMTQyA8wJV3DuSYJJA/mCn940X/LQrxIj63mr3p5VwzJ8DUwxlyer2B7R1ppavCLDutHmDKWGes1CoqGlopqG4yedZFc5uOz+PzAbjW3H7fuve4v+IK5Ta9HtLTe6637+hx77ftIP/YBn/Wwjvh8NICNWluNTx/4HleOvAi68av4f6l65kfsMCkT8tcONtq+cOqUG6YF8jLO9L4+HAeu1LK2J1axmUzx/GHVaH4u4+OrCBT+vGk8v63bLK3RbcoHOtih6+rHQXVTSTkVrMwxDRtgYUQ58Yyq6oIs2S8un2isJbWjqq9w0GvN3AwsxKQ9fGifxZPUj7c/Jxejk5vHjO2Q+lIXjXl9S042ViNirReW62GyWOVJWKJeTUmHg1sPVFMdWMbY11sWRo6AjolqNUwaRJcdx28+CLs3Qs1NXD0KLz1FvzudziER/H7RGuSX9bzzYewPBN06Pks61sWvH0e8/7oxsdPXEnbt19DWZmpn5HJeTvb8re10/nxgSVcPGMsBgN8mVDIsud38fjXJ6io773NoDh3BkPXhcyVo+BCpnFWPia70sQjEUIMVL8C+ba2Ns4//3xSU1OHajzCggV52ONqr6W1Xc/JouFLF0wtraOyoRU7rYbpvq7D9rhi5Jvp54qTjRXVjW0cLzB9oDfUtiUpNUjOn+yNtdXouM47088VwCzWyX9wSEmrvzrKf+TOBlpZKQXxbrkF/v1vOHwYamtRx8Ry8f2v8aP2VhJ/DOGWBBXW7XDIsZpr+ZwJOy7j2cu9qQsLJuqZZ1A/+yz89BNUV5v6GZlEkKcDr143m2/uWsjCiZ606Qxs3J/N4md38tKPqZIOPQROFtVRUN2ErVbNwomWP0MdEeQOIOvkhRjB+vVJTavVcvz4cammKgZEpVJ1fmgezvT6gxlKWn1kkNuoCU7E4LDSqDuzOPaNgur12zvWx6+aarlFnn7J+J6UaOJAPr20nsPditxZFBsbiIiAO++E//2PGXtTeeuDenKXfcNfbC7Aq92GPBd4eCUEXJXPo94H+P7dP9F84Qpwc4OQEGXW/4UXlFn/+npTP6NhM93Phfdvm8v7t85luq8LDa06XvoxjSXP7mTjz1l9zm4zGAzszNrJSwdfYl/uPlraZWb/l4yz8QsnemFnbfm1dIwz8vG5VbTrhi9LUggxePod1dx44428+eabQzEWk9uwYQNhYWFERUWZeigWyxQF7w5I2zlxDhZN8gJgT6plp/2ml9aTWd6AtUbNko7nPBrM6Ohicbyg1qTLJ8ymyN1wsbdnzPkX8/gjW8j9SzVvXfoW0z3DaLCGjbPg0uvA62EVV10JH9mmU7vpI/jDH2DxYnBxgWnT4Oab4dVX4dAhpeieBVsY4slX0efx6nWzCPKwp6Khlce/SWLFC7v5KqEA/Wl+dxtaG3gj9g2mvzadZe8u4/6t97Po7UW4PePGindX8Lc9f2Nvzl4J7IHtJ5WMJEuuVt/dJG8nnGytaGzVcbKoztTDEUIMQL+L3bW2tvK///2P7du3ExkZiYODQ4/vv/DCC4M2uOEWHR1NdHQ0tbW1uLhYdtslUwkPcAWGL5DX6w0cylLWf42GNb9i8C3qSLGMz62ivqUdRxuT1ggdMsa0+gUTPXCy1Zp4NMNnopcjdloN9S3tZJbVEzLm3NqqDkT3InfXzTWzInfDwNbKlltm3cLN4TezM3MnL2x5gcSWRPLr8vlsKnw2FazRsLzWk3UJLVx6qBpvY4/7d95RDmJlpQT3UVGdfe6ZNg20lvO7rFaruHjGOC6Y6sMnMXm89GMauZWN3PtxAm/szuShC0NZMskLlUpFVlUWG2I28OaRN6lurgbAQevAosBFxBXGUdZYxk9ZP/FT1k+Acg4W+C9gaeBSlgYtZY7vHGysbEz4bIdXUU0TxwtqUamUpUWjgVqtIjLQjZ0pZcRkVzLdTz73CjHS9PsT6fHjx5k9ezbAKWvlJeVenE14RxprVnkD1Y2tuNpbD+njJRfXUd3YhoO1hukW3hNbDI1AD3v83e3Iq2ziUGYFy6dY5mxN97Zzo4mVRs00X2disqtIzK8xSSBvLHI3zsWWJZNGRxDRG5VKxaKARdT51bF69WoSyxLZdHITm5M3k1KRwg/OJfywGH67RM15DlNYV+vL5UfbCPz5uFIoLyFB2f77X+WANjYQHq4E9sbgfvJk0IzstGmtRs318wJZN9uXt/Zl8cbuTJKKarnp7cME+2aB4xZ25/6AAWWWfoLbBO6eczc3h9+Mi60LBoOB5PJkdmXvYlfOLnZl76K0oZQdWTvYkbUD6ArslwQuYWnQUub6zrXowP7HjrT62QFueDlZ7vP8pcggd3amlBGXU8VvFo439XCEEP3U70B+586dQzEOMUq4OVgT5GFPdkUjCXnVQ16Z2ZhWHzXeHa1G1seL/lOpVCwK8eLDQ7nsTSu3yEC+pLa5M0tmpQU+v7OZ6edKTHYVR/OruSLCb9gfv6vIXcDILXI3yFQqFVG+UUT5RvH0iqc5WXayM6iPK4pjb/0J9qpPcH84zLpwFuvG3sjl9X6EHStGFRuntMKrrlbS7g8d6jqwgwPMnt0zuJ8wQanAP8LYW1tx17IQLpvlyV1f/ost2RvJrcyBjiLki/xX8PDC+1gdshq1quv5qVQqpnhNYYrXFH4X9bsegf3unN3syt5FSUPJKYH9fL/5LA1aapGB/bak0XkhMzKwq3K9wWCQCTkhRpgB54imp6eTkZHB4sWLsbOzkzcA0Wfh/q7DF8h3FLqTtHpxLhaHeHYE8pa5Tt5Y5GlWgCvezrYmHs3wm9FRuyMxf/g7E3QvcndV1PBfRBgppnhN4VGvR3l08aPkVOfwZfKXbE7ezN7cvRwpPsKR4iP8GZjkO4nLl1/O5aFPEtXsjjouvqvHfVwcNDQoBfP27u06uItLz8A+MhICAsDMP9Ockj6vBq3KDtu2ZTi1X0xBegD7XP2IGNOKj8vpX9e9BfYpFSnKjH3HVtJQws7snezMViZzjIF954y931xsrUbme0ddcxsHOy76rxhlFzJn+rui1agorWshr7KJAA97Uw9JCNEP/Q7kKyoquOqqq9i5cycqlYq0tDSCg4O57bbbcHV15fnnnx+KcQoLEu7vypcJhUO+Tl6nN3A4q6PQnQTy4hzMn+CJWgUZZQ0UVjcxztWyipEZZ6NWjYLeyb2Z2bE29GRhLa3t+mHtbvFRZ5G7MaOjyN0gCHQN5N5593LvvHspayjj65Sv2Zy8me2Z20mtSOWZn5/hmZ+fwdfJl7WT17LurnUsDnwGK4MKUlKUoD42VgnwExKgpkZpdffTT10P4uXVM7CPigIf078+DAYDO7J28MrhV/g65ese6fN3zbmLW8JvobhazXNbk/nxZCkfHc5jU3wBt5w3nt8tmYCL/dlrBqhUKiZ7Tmay52TujLwTg8FAakVqj1T84vrirsB+N9hobJjvP79zjf1ICux3p5bRpjMQ7OnARG9HUw9nWNlqlWWH8bnVxGRXSiAvxAjT70D+/vvvR6vVkpuby5QpUzpvv/rqq7n//vslkBdnFR6gpHIl5lUPaSbHyaJaapvbcbKxYuo45yF5DDE6uNhpmenvypHcavallXOVBbUHq21u40CG0lpvNLWd6y7A3R5Xey3VjW0kF9cyo6OWx1BrbtPxRWeRO8v5nRpOXg5e3Dr7Vm6dfSu1LbX8kPYDm5I38X3a9xTUFbAhZgMbYjbgbufOpaGXcvnky1l57ZXY3XijcoC2NqVonjGwj42Fo0eVNfc//KBsRr6+PQP7iAjwGJ6LxA2tDbx/9H1eOfwKJ8pOdN6+asIq7plzT4/0eRcf+N9NUcRkV/KPH5KJy6ni9d0ZfHQ4l3uWh3BrP9dCq1QqQj1DCfUM5beRvz1tYG+cve8e2C/0W4hdvR2rDasH88cxqH4cpWn1RlFB7sTnVhObU8mvTLC0SAgxcP0O5Ldt28bWrVvx8+v5Yg8JCSEnJ2fQBiYs15SxTlhr1FQ1tpFT0UiQp8PZ7zQAxrT6qPHuWMn6eHGOFoV4cSS3mj1pZRYVyO9KUWajJng5MMFrdM1GGalUKqb7urA3rZzE/JphC+S3HJcid4PJ2caZq6ddzdXTrqa5vZmfMn9i08lNfJ36NeWN5WxM2MjGhI04aB1YHbKayydfzkUhF+ESHq4UxbvtNuVAzc1KMG8M7GNiICkJCgqU7csvux40OLjnzH1EBDgNXsHE01Wfvzn8Zu6acxeTPSef9r5RQe58fud8fjxZynNbk0ktqefJb5MI8XZk8Tm0mOwtsE+rTOuRil9UX9QV2ANfvfMVL1zwAucFnDfgxx0KbTo9O5JLAVgxSgP5iI518rHZVSYeiRCiv/odyDc0NGBvf2rqTXl5OTY2llP4RAwdGysNYeOcScirJiGvesgCeeOaN0mrF4NhUYgnL/+Uxs/p5ej1BtQWUpRs24mO3slTTZ82bErh/q7sTSvnaF41zAsclsf88LAUuRsqtla2XDTpIi6adBHt+nb25e5j88nNbE7eTF5tHp8nfc7nSZ+jVWtZHryc5eOXE+QaRIBLAIEugXhHRaGaM6frgPX1cORIz+A+PR0yM5Xt00+V/VQqpTJ+9+A+PBzs+r5soi/p8y62fevColKpWBk2hmWTvfn9B3FsPVFCXE7VOQXyvT3GJI9JTPKYxB0Rd/QI7Hdm7eTLk19yuPAwC99eyBVhV/CP5f9ggvuEQXv8cxGTVUltczvuDtbM7sgWHG2MgXxaaT1VDa24OQxtN6GR4quEAv71YxqvXjebMMnqFGaq34H84sWLeffdd3nyyScB5Q1cr9fz3HPPcf755w/6AIVlCvd37Qzk187yHfTjt+v0HO7oHz9/ggTy4tyF+7viaGNFVWMbJwprLaLnbku7jl0pSgG/VaN0NsrIOAt/dJgK3qWX1nUWubvagjI8zJGV2qqz2vpLF75EXFEcm09uZlPyJpLLk9mSvoUt6Vt63MdGY6ME9a6BBDh3/OsSQODlswi4+TL8Xfyxrm1QCuh1T8vPzYWTJ5XtvfeUg2k0vfe4t+4ZMPUnfb6/NGoVUUHubD1RQkpx3YCO0VfdA/tbZtzCB3zAPu0+3k58m8+TPuer5K+4e87d/Gnxn3CzM23wvP2kkla/bLL3qL2Y5uFowwQvBzLKGojLqRq1mQm/9NquDDLLG/j3rnRevW62qYcjRK/6Hcg/99xzLF26lNjYWFpbW3nooYc4ceIElZWV/Pzzz0MxxmGzYcMGNmzYgE6nM/VQLN6sAFc27ocjQ1Tw7kRhLXUt7TjbWjFlrFxJFedOq1Ezf4IH25NK2JNWZhGB/IGMCupb2vF2smHmMKWTmytjwbu00joaWtpxsBlwU5c++ehwHqAUuTtTRXExuFQqFZHjIokcF8nfl/+d5PJkvkz+ksSSRHKqc8ityaWwrpAWXQtplWmkVab1fhxUjHUaqwT3EwMJiJhAoMsyAgzOBObWEJCUj2vMcSXALy2FxERl+9//lAPY2MDMmRAZSVZ4EBscTvBm3lf9Tp/vj1AfJeU/pWRoA/lfctO68dqa17hv/n08uO1BtmZs5YWDL7AxcSOPLX6M30X9DmvN8M8CGwyGzo4do3V9vFFUkDsZZQ3E5FRKIA8U1zST3HHBa9uJEqobW3G1l0wFYX76/UklLCyMo0eP8tprr6HRaGhoaGDdunVER0czduzYoRjjsImOjiY6Opra2lpcXEb+h3RzFt7R7ulkYS0t7TpsrDSDenxjWv2c8R6j9iq7GHyLQzzZnlTC3rQyos+faOrhnLPuvZMtZanAQHk72+LjbEtxbTPHC2qYO4RLcroXufv13IAhexxxdpM9J/PIwkd63NaqayW/Np/cmtzO4D6npue/ze3NFNYVUlhXyMH8g70e23mhM4EXBRJgM43ARmsCSpoJzKggIDGbwLw6UsoO83LlYb4uAEPHyy+40Za7VXO5Jfh6XEKWwCCmoBsD+eyKBprbdNhqB/fv7tlM857Gluu3sDV9Kw9uf5Djpce5b+t9vBrzKs+ueJa1k9cOaxvj5OI68quasLFSsyjEc9ge1xxFBLrxcUwecbJOHoBdKaWd/2/V6fkqoZCbFgSZbkBCnMaAphx8fHx44oknBnssYhQJcLfH3cGayoZWkgprmTXIa9MOGNfHS1q9GEQLQ5R1pXE5VcMyazuU9Pqu2ajRvj7eaIafC8VJzRzNH9pA3ljkztfVblDXKovBYa2xJtgtmGC34F6/bzAYKGss6wz0fxnk51TnUNFUQW1LLcdKj3HMeEcrILRj+4VVWRru2a9jdXozasNuYLfyDWOP++5p+f7+A+px7+Vo0/l3N62k3mRZRRdMvIAVwSt468hb/Hnnn0mvTGfdp+tYFLCI51c9T5Rv1LCMw1itfuFET+ytR+57+WCICnIHlKVFprjIY26MS8783OzIr2ri09g8CeSFWRrQO1dVVRVvvvkmJ0+eRKVSMWXKFG655Rbc3d0He3zCQqlUKmb6ubAzpYyEvOpBDeTbdXpiOtbHzwuW30kxeII87Dv/sB/OquT8ySO30nhCfjVldS042VhJQcgOM/1d2ZZUQmJ+9ZA+zoeHjEXu/CVjaARSqVR4O3jj7eBN5LjIXvdpaG0gtya319n8nOoc8mvzsbWy5aaZN3HXnLuY4j5J6XHfvZjemXrcdw/sIyP71ONepVIROsaJA5kVJBebts6HRq3h9ojbuWbaNTz787M8f+B59ubuZc7/5nDd9Ot4evnTBLgMbbaKcX38aE+rBwj0sMfT0Yby+haOFdR0BvajUZtOz750pSXr3y+fzu3vxHKisJYThTVMHSfZusK89DuQ3717N5dddhnOzs5ERip/wF5++WX++te/8vXXX7NkyZJBH6SwTOH+bp2B/GA6VlBDQ6sOV3stU3xkfbwYPCqVikUhXnx0OJc9aWUjOpA3zsYvneyNtZW0ZwQ66wQMZcG79NI6DmdXolGruCpSitxZKgdrB6Z4TWGK15Rev9+ubweUQnydwsKU7aablK/b2uD48Z7F9I4dU3rcf/+9shn5+Z3a476XyZVQHyWQH+qCd33lZOPEk8ue5LeRv+XRHY/yXuJ7fHjsQ75I+oL7593P+kXrcbYZ/L/jxTVK5o1KBcunSCCvUqmICnLjh+PFxGRXjupAPja7ivqWdjwdrVk00ZOVYWP47lgRn8XmM/VSCeSFeen3p7fo6GiuuuoqsrKy2LRpE5s2bSIzM5NrrrmG6OjooRijsFDhAa4Agx7IG9Pq5453H/XrfsXgM66l3JtWbuKRnBtj2zmZjepinKHMrWykqqF1SB7jw0PGInfeUuRuFLNSW/UM4nuj1cKsWXD77fCf/0B8PNTWwsGD8MorSsAfFqak2efnw+bN8OijsGoVeHjAxIlwzTXw/POwezfU1Zms4N3Z+Dn78c7ad4i9I5alQUtp0bXwj5//wcSXJ/JazGudFz4Gy48ds/Hh/q54OUnrZJB+8ka7UpX18YtDvFCrVVwZ6QfAlwkFtLRLMWxhXvo9I5+RkcEXX3yBRtO1fkaj0fDAAw/w7rvvDurghGUL75j9yqlopLKhFfdB6l16MNOYVi/pwmLwLZjggVoF6aX1FNU0Mdal7/2hzUV6aT0ZZQ1oNSqWhsoabSMXOy3jPR3IKm8gMb+apaGDm3HRvcjddXOkyJ0YADs7mDtX2Yzq65Ugv/vMfXo6ZGQo2yefKPupVKydEIK1rR8ZQVNgqkHpcW9rPheUZo+dzY4bd/BN6jf8cfsfSa1I5fff/55XDr/CcyufY03ImkEpiCfV6k9lnIWPy6lCrzeM2omQ3R3r45d2ZNwtCvHqLIT6Y1IpF80Y2YW9zcXu1DK8HG0IGyeZs+ei3zPys2fP5uTJk6fcfvLkScLDwwdjTGKUcLHXEuzpAEDiIM3Kt+n0xGZL/3gxdFztrTt7jo/UWXnjh9j5EzxxttWaeDTmxdiGbijS6384XkRNkxS5E4PM0REWL4YHHoCPPoK0NKishO3b4amn4PLLlQJ5BgN26an86vgOHvp2A8yfD05Oyqz/HXcos/5Hjigp/SakUqm4NPRSjv/uOK+sfgUPOw9Olp/k4o8uZuV7K0ksTjyn49e3tHMgQ8ncWylp9Z3Cxjljp9VQ09RGelm9qYdjEoXVTSQX16FWKV1qADRqFb+K8AXgs7g8Uw7PYmSXN3DTW4e55NV9/G9vJgaDwdRDGrH6FMgfPXq0c7vnnnu49957+ec//8m+ffvYt28f//znP7n//vu57777hni4wtIY29ANVj/5o/nVNLbqcHewZpK306AcU4hfWjzC0+u3JSlp9atkNuoUMzrXyVcP+rE/6kirlyJ3Ysi5ucGKFbB+PWzaBLm5UFwM337Lmytu4qcJUbR6eEF7u1JU77//hd/+FmbPVoL7efPgrrvgnXfgxAnQDX9KsVaj5a45d5FxTwYPLXgIa401P2X9xKw3ZvGbr35DYV3hgI67J7WMVp2eIA97Jno7DvKoRy6tRs2sjiWPMR0TIqPN7lRlNj7c37VH3/grI5R6JntSyyiqaTLJ2CxJUlEtADq9gb99d5K7PzpCQ8vgLp8ZLfqUWh8eHo5KpepxxeShhx46Zb/rrruOq6++evBGJyxeeIArm44UDNo6eWNavayPF0NpYYgXL+9I5+f08hGXglha28yR3GpA0kp7M9NfmZFPyKvBYDAMWl/rtBIpcidMbMwYuOgiDpSP4cmTJTx+8RRuDtT2rJQfGwvV1XDokLIZOTgoQX73gnoTJgyoDV5/udi68MzKZ7gz8k7W/7SeT058wtsJb/PJiU/444I/8scFf8TB2qHPx+ueVj+cfetHgsggd/ZnVBCbXcWv5waaejjDztg//pfLqoI8HZgz3p3DWZVsii8g+vyJphiexcjsyPgI9LCnoKqJb48WkVpSx+vXRxDsJRfX+qNPgXxWVtZQj0OMUsYZ+cS86kH50GxMl5O0ejGUZgW44mCtobKhlaSiWqb5jpxKttu7FXka42w+a2PNRdhYFzRqFeX1LRTVNDPOdXBqIHx0WIrcCfMw2ceJH0+WkFJaDwtnKGn369Yp3zQYlHX1xsA+JkZZf9/QAHv3KpuRq6sS1HdvgzfAHvd9Md5tPB9f8TH3zbuPP2z7A/vz9vPE7if4T9x/+Nuyv3HTzJvQqM/c/7xdp2dHshKsrZC0+lNEGgve5Yy+GfnWdj0/pyufIc/vpT7KVZH+HM6q5LPYPH6/dIJcBDoHGWUNgPIznRfszu/ejye1pJ5LX/2Z56+ayQVTz95OUyj6FMgHBo6Oq3IbNmxgw4YN6EyQQjZaTfZxxtpKTU1TG1nlDed0Ja6lXdf5x0f6YouhpNWomT/Bkx9PlrAnrWxEBfLbTiiB/Kqp8iG2N3bWGiaNceJkUS1H86sHJZDvUeRurhS5E6ZlrFyf3FsLOpVKqXZvrHgPSlp9cnLPWfuEBGXm/scflc3I27tnYD8EtZPm+c1j3y37+OLkFzz848NkVmVy69e38q9D/+L5Vc+zInjFae8bk11FTVMbbvbazirtosusAFfUKsirbKK4pnlUXXSMzansbDs3tZcCbGum+/CXr46TXdFITHYVc8aP3hZ95yqjY0Z+gpcDEYHufHvPQu768AiHsyr57Xtx/G7pBB5cFSpL0Pqg31XrAQoKCvj5558pLS1Fr9f3+N4999wzKAMzhejoaKKjo6mtrcXFZeR8MB/JrK3UTBvnTHxuNQl51ecUyB/Nr6G5TY+no7WsexNDblGIEsjvTS3n90tHRppdXXMb+zOUdf2rwuSK9+mE+7twsqiWxPwaLpx27hWKexS5C5Eid8K0JncE8qnFdX1bGqTRwNSpymbscd/aqqydN87aG3vcl5b26HGvBVZ5eKBZuBDmzDljj/v+UKlUXBF2BZdMuoQNMRt4cs+THC05ysr3VrImZA3PrXyOMK+wU+5nbDu3bPIYrDT9rvds8ZxstUwZ68yJwlpicyq5eMY4Uw9p2Bir1S+e5NXra8Le2oqLZ4zjk9g8Po3Nk0B+gAwGAxmlxkBe+azu7WTLB7fN5Zkfkvnfvixe25XBsfwaXr521qB1tLJU/Q7k3377be68806sra3x8PDokVqiUqlGdCAvTCPc360zkF8322/AxzGm1c8N9pCUJzHkjP3k43KqaGxtx956QNdFh9WulDLadAaCvRzkYtcZzPBz5aPDeYNW8O7DQ7kAXCNF7oQZCPJ0QKtR0dCqo6C6CX93+/4fxNpaqXZvrHgP0NQEiYk91twbkpOxq6iAr75SNqMJE3qm5RuL7PWTjZUND8x/gJtm3sSTe55kQ8wGvk/7ni3pW5joPhEfRx/GOIzp/Pe9o9U0qh0IHKshv9YDbwdvrDUSKHQXFeSuBPLZVaMqkN/VEcj3llZvdFWUH5/E5vHd0SIev3Qqjjbm/3ff3JTWtdDQqkOjVhHg0fXeo9Wo+dPFYcz0d+XhL46yL72cS17Zx79/PZuZHctwxan6/Rv42GOP8dhjj7F+/XrUarmaKc5deIAr/Mw5F7zrXB8vafViGIz3dMDX1Y6C6iYOZVWe8Y+/udjWUeRJZuPPbEa3FnTnWswwraSOmOwqpchdlBS5E6an1aiZ4OVIcnEdycV1Awvke2Nnp1S7nzev86b2ykoOvfYa87VaNEeOKEG+sb/9L3rcExras5heeLhyzD7wsPfgpQtfIjoqmod/fJjNyZtJrUgltSL11J1t4N4dygbgbud+SsDv4+ij/N+x6zYvBy+s1JYfuEUEurFxf/aoqlxfWN1ESonSds54kb43swPcCPZyILOsge+OFnJ1lCyV6i/jbLy/mx02VqfWtLhk5jhCfZz47XtxZJU3cOXrB/jrZVO5Zo78rHvT73ekxsZGrrnmGgnixaCZ1XGl7WRRLc1tOmy1Zy5W05vmNh3xuVUAzJNAXgwDlUrF4kmefHQ4j72p5WYfyLe069jZUeRJ1sef2aQxTthYqalrbieroqEz/W8gPjyszMYvn+wtxQWF2Zjs40RycR0pxbVD273CyYmKadPQr1mDRqtVbqushLg4ZdbeuO4+L09Zh5+cDO+9p+yn0cC0aT1n7qdPV7IBTiPEI4RNV28iuzqbnOociuuLKa4vpqShhJ1pqSQW5mBvV4+tTR0lDSW069upbKqksqmSpLKkMz4VFSq8HLy6An7HMfg4dAX7Po4+zPKZhYf9yP4MEhmk1A44WVRLfUv7qJh1Ns7Gzwpw69F27pdUKhVXRvjzzJZkPovNl0B+ALrWx5/+7+qkMU58ddd5PPhpItuSSnhk0zGO5FbzxGVTBxQjWLJ+vzpvvfVWPvvsMx555JGhGI8Yhfzc7PBwsKaioZUThbUDKkCTkFdNS7seLycbJnj1vQ2NEOdi4UQvPjqcx770MlMP5awOZiqFfLycbAjv6JUueqfVqJnaUbvjaH71gAP55jYdm+ILALhWitwJMxLq4wwU9l7wbqi5u8PKlcpmVFLSFdgbg/uSEiVVPzER3nxT2c/aGmbO7FlQb8oUsOr5cTbINYgg16Aet12W/DPerdU8ddF0rpsbgN6gp7KpkpL6ks5gv7i+WPm6objz9uL6Ysoay9Ab9JQ2lFLaUMqx0mO9PjWNSsPiwMVcPvly1k5ei7/LyMvCGetih5+bHflVTRzJrWLRKKjrYWw7d37o2Z/rr2b78s9tKcTmVJFRVn9OF3pHI2PF+glnWd7nbKvl9esjeG13Bs9vS+GT2DxOFtfy71/Pxs9tkLKILEC/A/mnn36aiy++mC1btjB9+nS0xiusHV544YVBG5wYHVQqFeH+rvyUXEpCXvWAAvnuafWyPl4Ml/MmeqBSQWpJvdlX+N12ohhQeiePpL73pjLT35X43GoS82q4fNbAand8f0yK3Anz1FnwrsQEgXxvOnrcc9FFytcGAxQU9KyUHxurzOYbC+y99pqyr729sla/e3AfEgLdMkdLaptJ7Fi+t2KKkj2lVqnxtPfE096Tqd5Tzzg8nV5HeWN5z2C/22x/cX0xebV5pFaksjN7Jzuzd3LPlnuIGhfFuinruHzy5YR6hg76j22oRAW5k19VQEy25QfySts5pQjsL/vH98bb2Zalk7z4KbmUz2LzeWT15KEeokXpXrH+bNRqFdHnT2SGnwv3fHSEo/k1XPLKPl6+dpbF/172Vb8D+aeeeoqtW7cSGqq8If2y2J0QA9E9kB+Ig5lKIC9p9WI4udpbM8PPlcS8avamlXFlpHnOvuj1hs5qzauGMo3WgszsyFo4l4J3Hx2WInfCPBlb0GWWNdDarsfaysyWS6pU4OenbGvXKrcZDJCV1TO4j4uDujr4+WdlM3J2VqrjdwT3B63GgsHAzAA3vAewxEWj1jDGcQxjHMcwY8yM0+6XWZXJ5pOb2Zy8mf15+4kpjCGmMIb1P61niueUzqB+9tjZZv2ZOSLQjc1HCogdBevkY7MraWjV4eloQ9jYU9vO9ebKSH9+Si7li/h8Hlw1STog9ENmx4x8f7pULQrx4pu7F/L7D+I5ml/DTW8d5g+rQvndkgmjfmKi34H8Cy+8wFtvvcXNN988BMMRo1V4gCsACXlV/b5vc5uOI7nVAMyfIIG8GF6LJnqSmFfNvvRysw3kjxbUUFLbgqONlbxG+shY8O5EYS1tOj3afn5QS5Uid8KMjXWxxcnWirrmdjLK6pnSxwDGpFQqCA5WtquuUm7T6yE1tWdwf+QI1NbCzp3KBlwGLLJzpm7aTChe0jV7P25wq7IHuwXzhwV/4A8L/kBxfTFfp3zNppOb2JG1g5PlJ/n73r/z971/J8AlgMsnX87lky9nYcBCNGrzWvcbFaS0VkvIqx7Q+99IsitVWRq35DRt53qzbLI37g7WlNW1sCetjGWT5QJ5XzS2tlNQ3QSceY18b/zc7Pn0t/N5/OsTfByTx3NbU0jIq+b5q2bibKs9+wEsVL9fmTY2Npx33nlDMRYxis3omP3Kq2yior6lX/eNz6miVafHx9mWIA9ZNyOGl7HC7b60cvR6g4lH0ztjWv2SUK9eq8SKUwV5OOBka0VLu56UAawj/kiK3AkzplKpOtPrB/L7bTbUapg8Ga6/Hv71L2VWvra2a139nXeii4igVW2Fe1MtgTF74W9/U2b5fX2VQP6yy+DJJ2HLFigvH7Sh+Tj6cEfEHWy5fgulfyzlg3Uf8Kspv8Jea09uTS7/OvQvlr6zFJ/nfbjt69v4LvU7mtubB+3xz0WItyPOtlY0tuo4WVRr6uEMqc718ZP7nqptbaXm8lm+AHwakz8k47JExtl4N3vtgPrD22o1/ONXM/jHuulYa9RsTyrhsld/HtnvYeeo34H8vffeyyuvvDIUYzG5DRs2EBYWRlRUlKmHMuq42Gk718v0N72+K63e3axT1YRlmhXghoO1hoqGVpLM9ANPV9s5mTXoK7Va1aMNXX80t+n4Ik75cHedFLkTZmrSGCWQN0nBu6FkZQUzZsBvfgOvvcb2jd8w7f7PuOOuf2PYsAFuuUWpfq9WQ1ERfP01PPYYrF4NXl4wfjxceSU8+yzs2AE1/Xv998bV1pXrpl/H51d9Tvkfy/nqmq+4aeZNuNu5U95YzptH3uTijy7G6zkvrv78aj45/gl1LaY7L2q1isiOWfmY7P5nSo4UBdVNpJbUK23nJvZvzfVVHRl4P54s6fcE1GiVWd5R6O4cCwReMyeAz+6cj6+rHVnlDazd8DPfJBYOxhBHnH6n1h8+fJgdO3bw7bffMnXq1FOK3W3atGnQBjfcoqOjiY6Opra2FhcXF1MPZ9QJ93cjo6yBhLxqlk/pe8BxoCOQl5RhYQrWVmrmT/Dgx5Ol7EsvZ5qveb13ZJTVk15aj1aj4vzJ5t0iz9zM9HPl5/QKjuZX9ysg//5YEbXN7fi62klBHmG2umbkzfMC5GDZllRCq5UW/6VLUF0c1vWNhgZISOhKyY+JUdL0s7OV7fPPu/adNKlnj/tZs5QiewNgp7Xj0tBLuTT0Utr17ezJ2cOmk5v4MvlLCuoK+PTEp3x64lOsNdasCF7BusnruDT0Urwchve9JCLQjR3JpcRmV3LrwvHD+tjDxTgbPzvADRf7/qVnh/o4MdPPhcT8GjYfKeC2RcFDMUSLYuwhHzwI3aVm+rvyzd0LueejI+xLL+fuj46QkFfNI6snW/RSkF/qdyDv6urKunXrhmIsYpQLD3Dli/j8fs3IN7XqOvefH+w5NAMT4iwWTvTkx5Ol7E0r484lE0w9nB62d8zGzwv2GNXryAbCuOQnsZ8z8h8eUtLqr50jRe6E+VJa0I3w1PqzaNfp2ZmsBGsrf5mR5OAA552nbEY1NV097o3V8XNylAA/NRU++EDZT62GqVN7BvfTp4ONTb/GZ6W2Ytn4ZSwbv4yXV79MbGEsm09uZlPyJlIrUvk+7Xu+T/se9bdqFgYsZN3kdaydvJZA18Bz+bH0iXGdfGxOFQaDwSIzHo394wd6kfvKSH8S82v4PC6fWxeOt8if0WDqSw/5/nB3sOad38zh+W0p/HtXBm/uy+JYfg2v/noW3k6jY0lbvwP5t99+eyjGIQSz/F0BJbVerzf0qehIXE4VbToD41xs8Xe3G+IRCtG7RZOUmZKYrCqaWnXYWZvPOnTj+vhVU31MPJKRZ6a/kl2RWlLX5/OaWlJHbI5S5M5cix8KARDakVpfWNNMTVMbLnaWd6EvLqeKqsY2XO21RPalta2LCyxbpmxGZWU9+9vHxEBxMRw7pmxvvaXsp9We2uM+LOyUHveno1apmeM7hzm+c3hq+VOcLD/ZGdTHF8WzJ2cPe3L2cN/W+5g9djbrJq/j8imXM8VzypAEkDP8XLDWqCmrayG3spFAj3OfRTUnLe26zrZzSyYNLNvhkpnjePLbJJKL6zhWUNN58Vf0rrOH/CAF8gAatYqHLpzMDD9XHvwskcPZlVz88j7+/evZnctDLNnoyT0QZi/UxwkbKzV1ze2d62jO5kCm8iY8b4L0jxemE+zpgK+rHa06PYeyKkw9nE6ltc0c6chYWdmP5SpC4eNsi5eTDTq9gROFfZuVNxa5WzFFitwJ8+Zir2Wsi/I7ajb95AeZMSNpWaj3wFuEeXkp6+f//GdlPX1REeTnw5dfwqOPwqpV4O4ObW1KsP/663DrrUpQ7+yszPjfdx+8/z6kpCiV9s9CpVIR5hXGo4sfJe6OOLLvzealC15iceBi1Co18UXx/Gnnn5j676ks3riY7OrsgT23M7DVapjeUSfEEtfJx2ZX0diqw8vJhqnjBta1wcVOy4XTlIvkn8bmDebwLI5ebyCrvGNG3nvwAnmjC6f58PVd5xHi7UhpXQvX/OcgG3/OwmAwzyLEg6Xf72rjx48nODj4tJsQA6XVqJnesb64r+n1BzI61sdL/3hhQiqVioUTu6rXm4sfT5ZiMChryXxcJKjsL5VK1dlPvi/p9d2L3F07R4rcCfMXagmV60/DYDCw/aQSyK8Y7EKfvr5Ktfu//Q22blWq3WdkwCefwIMPwtKl4OQETU2wf79SUf+GG5QK+25uyoz/ww/DZ58p6/HPEmwEugZy77x72X3zbor/UMz/Lvkfa0LWYK2xZl/uPsJfD+fzpM/PeIyBiAxSshgssZ+8cX380kle5zQRZCx691VCIc1tukEZmyUqrGmiuU2PVqPC321oMmiDvRz5Mvo8Lpoxlna9gce/SeKBTxNparXc89Lv1Pr77ruvx9dtbW0cOXKELVu28Mc//nGwxiVGqXB/V2JzqkjIq+KKCL8z7tvQ0t5ZTXqeBPLCxBZN8uST2Dz2mlEgvy2pI61eqtUP2Ew/F348WcLR/Oqz7tu9yN1iKXInRoBQHyd2pZRZZCCfXlpPTkUj1ho1iweYOt1nZ+px372YXi897gHw9FRS8Y1p+VFRMHZsrw/l5eDFrbNv5dbZt5Jdnc11X1zHgfwDXPnZlfw24re8eMGL2GkHJ1CKDHTnDTKJscBAfmfH+viloedWBHZ+sAe+rnYUVDex9UQxl4X7DsbwLI4xrT7Qw2Hg2TF94GBjxavXzmKWvytP/5DM5iMFnCyq5fXrIwjytKzlITDA9nPdtwcffJAPPviAv/71r6SkpPTrWE8//TRRUVE4OTnh7e3N2rVrTzmGwWDg8ccfZ9y4cdjZ2bF06VJOnDhx1mN/8cUXhIWFYWNjQ1hYGJs3b+7X2IRphAe4An2bkY/NqaJdb8DPzQ5/d+kfL0zrvAmeqFSQUlJHSa3pewHXNbexP13JWLlgqgTyAzWjo3ZHX1rQdS9y15caH0KYmkX0kj8N42z8gokeONr0e97q3Bl73N9wgzIjv38/1NUplfL/9z/47W8hIkJZW19ervSx/9vflJn+ceOUWf+1a7tm/StOXbYV5BrE7pt3s37helSoeCPuDeb8bw4nSs/+ObkvIjrqCmSUNVDZ0DooxzQH+VWNpJfWo1GrWBhyboWS1WpV58TTZ7HSU/50jBXrJwxCxfqzUalU3LYomA9um4unozXJxXVc8uo+fup4T7Akg3ZJZPXq1XzxxRf9us/u3buJjo7m4MGDbN++nfb2dlatWkVDQ9f66GeffZYXXniBV199lZiYGHx8fFi5ciV1daf/o3PgwAGuvvpqbrjhBhITE7nhhhu46qqrOHTo0ICfnxge4R0fmpOL6s6aoiRp9cKcuDlYM6NjaYg5pNfvTi2jVacn2NNhUAvLjDbGc5pV3kBNY9tp9+te5O4qKXInRoiuXvK1FreW1Lg+foU51QexslLWzt96q7KWPjZWmaE/fBiMPe6nTVMuAhQWwldfKWvzL7xQmbU3zvg/9xzs2gW1tWg1Wp5a/hTbbtjGGIcxHC89TtR/o/hf/P/O+Zy6O1gzsWM9c1yO5ayTN1arnx3gOihFHo2B/M8Z5eRVNp7z8SxRZvngVqzvi3nBHnx79yJmB7hS19zOre/E8sK2FHR6y3mvG7RA/vPPP8fdvX/VAbds2cLNN9/M1KlTmTlzJm+//Ta5ubnExcUBymz8Sy+9xKOPPsq6deuYNm0a77zzDo2NjXz44YenPe5LL73EypUrWb9+PZMnT2b9+vUsX76cl1566VyeohgGvq52eDra0K43cLzgzDNgBzv6x0tavTAXxiv7e9PKTDwS2HZC+RC7cuoYKQR5DtwcrAnoyPg5WlB92v2Ms/ErpnjjLUXuxAgx0dsRjVpFbXM7xWaQSTRYSuuaOzP7Tmk7Z25sbZVU+t//XqmAf+yYEtzv3QsvvgjXXaf0sQfIylLW1T/0EJx/Pri6wpQpcMMNrPg2icSI/3FB0Aqa2pu4/ZvbueaLa6hp7l/7zF+KssB18p3r488xrd7I392e8yZ6YDDAF/EyK9+bjFJlkjZ4mCcWfFxs+fiO+dw4X2nZ+MrOdBL7sFRupOh3rtGsWbN6fCg0GAwUFxdTVlbGv//973MaTE2N8mZjvCCQlZVFcXExq1at6tzHxsaGJUuWsH//fn7729/2epwDBw5w//3397jtggsuOG0g39LSQktLS+fXtbW1gLL+v63t9DMw3Rn36+v+4vRm+jnzU3IZcdkVzPR16nWf+pZ2jnUE+lGBLkPyc5dzanmG+pzOH+/Ghp2wN62clpZWk6VXt7br2dHRO3n5JE+L/R0ertfodF9ncisbOZJTybwg11O+39ymY1PHh7erI3wt9uc9HOR9d3ipgSAPezLKGjiRX4Wn/eCmoJvqfG4/XoTBADN8nXG304y83ydra5g7V9mMqqtRHTmCKjZW2eLjUeXkQHKysr3/PmOA7zRqnl/rw6PTSvj0xKfEZO7jvXUfMCfwvAENJdzPmY8Ow+Gsih6fi0fcz7RDS7ue/R0ZnQsnuA3a81gXPo6f0yv4PDaP3y0KGlHLq4bjnBp7yAe62Qz7744K+POaUKaPc6KktoXpYx3N+ve3P2Pr9zv22rVre3ytVqvx8vJi6dKlTJ48ub+H62QwGHjggQdYuHAh06ZNA6C4WCnUNGZMz6upY8aMIScn57THKi4u7vU+xuP90tNPP80TTzxxyu3btm3D3r5/a6+3b9/er/3FqWwbVICGLTHJ+NQk9brPiSoVOr0GTxsDR37ewZEhHI+cU8szVOe0XQ/Wag0VDa28+cUP+JqorkpytYr6Fg1OWgMFx/ZTdNw04xguQ/0a1dYq70nb41IJbEg+5fuHy1TUNmtwtzFQk3qY79OGdDijgrzvDh9nvRpQ8/XuWBrShybldLjP54fJynPyU1fx/fffD+tjD7mpU5Xtppuwrq7GNSMD1/R0XNPTcUtPx7aqioe+KGbJQbjmCsiikKXvns+fEj25vjWC2pBJVE2YQL2/PwaN5qwPV98MYMXR/Gq+/OZ7rDvuMlJfoynVKhpbNThrDWTF7yN7kOJtvQ7sNBryq5t5+ZMtTHIZeenbQ3VOm9uhtE4JOdOP7Kfw2JA8zFlZA/7A99+fNM0A+qixse/LM/odyP/lL3/p71365K677uLo0aPs27fvlO/9Mi3UYDCcNVW0P/dZv349DzzwQOfXtbW1+Pv7s2rVKpyd+9Zbsq2tje3bt7Ny5Uq02nNfbzOauWZU8N3GOEp19qxZs7jXfY5tTQWyOX+aH2vWTB2Sccg5tTzDcU6/qYpnV2o5jJ3CmoXjh+QxzubwNyeBPNbM9OPii4bm9WEOhus16pVdxZdvxlCqs2PNmiWnfP/d/x4Gqrl5UQgXL5E2rOdC3neHX5Z9Jkd+Skfl5seaNdMH9dimOJ+Nre08FLML0PP7Sxd2ttgbFQwG2goLUcXGEhkXR3zCQe5038+nk1p5fHY5B9K38s5bW5nVAAZ7ewzh4RgiIzHMno0hMhImTlTW5/c4pIHX03ZTVt+K7/T5hPs6jujXaOIPKUAOq6b7cdFZ/j7m1+bj6+Tb5+Vp8YYkPorJJ8/Kj/sG+bU0lIb6dXo0vwZiDuHlaM0Vl646+x1GOWNmeF+YoIznqe6++26+/vpr9uzZg59fV8sxHx8fQJlhH9utDUdpaekpM+7d+fj4nDL7fqb72NjYYGNjc8rtWq2237/QA7mP6Gl2kAcqFRRUN1PdrMfL6dRzczhbKbpy3kSvIf95yzm1PEN5TpeEerMrtZz9GVX8/vxJQ/IYp2MwGDhWUMO2k0pa/YXTxo2K392hfo2GB7qjVkFJbQuVTTrGdFsDn1pSR1xuNVZqFdfMCRwVP+/hIO+7wydsnFLQMa20Ych+5sN5Pg+lVtDSrsfPzY6pfm6jr0ZIUJCyXXEFbsDHej0rtz/DPYceZ+vEVmbeo+X9rzSsSGpEtX+/Uk3fyMVFqaRvbIMXGQmBgUSNd+f7Y8Ucya/tXDM/Ul+juzuK0S6bMua0448viue5/c/x2YnP2Hr9VpYHL+/Tsa+ZE8hHMflsTSrhyfbpg1JIbzgN1TnNqVLqbwR7OY7I35nh1p+fUZ+L3anVajQazRk3K6v+XRcwGAzcddddbNq0iR07djB+fM/Zq/Hjx+Pj49Mj1aO1tZXdu3ezYMGC0x53/vz5p6SHbNu27Yz3EebDyVbLxI5iGL21oattbusshCeF7oS5WdTRP/xwduVZOy8MloLqJjbsTGfFC7u59NWfKatrwc1ey/wJ8voYDPbWVoR4K7N6ib94T+oqcjdGityJEWmyj5J5mF5WT7tOb+LRnLtDWUpRtqWhXqMviO+FSq3mtgvWE3NnPFO9plJi08aqq1r4v49vp+2dt+Duu2HePKXoXk0N7NgBzz4LV14J48eDtzfrX/0D9+99n7Yvv4KiIlM/pQHLq2wko6wBjVrFeRN7tp0zGAxsTd/KindXEPGfCD4+/jE6g44dWTv6fPwZfi6EjnGipV3Pt0cLB3v4I5ZxffwEb+mgM9j6HHmfqQ/7/v37eeWVV/rd5iI6OpoPP/yQr776Cicnp85ZdBcXF+zs7FCpVNx333089dRThISEEBISwlNPPYW9vT3XXXdd53FuvPFGfH19efrppwGl1/3ixYt55plnuOyyy/jqq6/48ccfe03bF+Yp3N+VtNJ6EvKqTqk4G5NVid4A4z0d8HGRD87CvEzwcmCsiy1FNc0czqpk8SSvIXmcuuY2fjhWzKYj+RzM7KombGOlZtVUH363ZAK22rOvfxR9M9PfhZSSOo7m17BqqpIt1r3I3bVzA0w5PCEGzM/NDntrDY2tOrIrGpjoPbJT0Y1t0iID+9dJydJN9Z5KzO0xPLD1AV6Pe52nk//LLr/jfPjXDwlyDYK2NjhxQmmJFxOj/Hv0KJSX41++m3sB9n8MLz/IKg8PNAsWwJw5ysx9RITSHs/M7UpVOspEBLp1zpa36dr45MQnPLf/OY6WHAVAo9Jw9bSreXD+g8waO6vPx1epVFwZ6cffvjvJp7H5/Hpu4OA/iRHIWLFeWuEOvj4H8pdddtkptyUnJ7N+/Xq++eYbfv3rX/Pkk0/268Ffe+01AJYuXdrj9rfffpubb74ZgIceeoimpiZ+//vfU1VVxdy5c9m2bRtOTl1/aHJzc1F3W9OzYMECPv74Y/70pz/x5z//mQkTJvDJJ58wt3v1T2HWwgNc+Swuv9cZeWP/eJmNF+ZIpVKxKMSTT2Pz2ZtWNqiBfLtOz960cjYdKWDbiWJa2rtmz+YFu7Nulh8XTvfB2VZS1wbbDD9XPo3N79G25rujRdQ2t+PnZseiieb/IVaI3qjVKkLGOJGYV01ycd2IDuSb23ScKFQy9iIC3Uw8GvNjp7XjtYtfY3nwcm77+jYO5B8g/PVw3rz0TX4V9isID1e2225T7tDcDEePojt0mK/f/JqwghQmVeZjV1EB33yjbEZBQV3p+FFRMHu2kqpvRnYlG9vOeVHXUsd/4//LSwdfIq82DwAHrQO3z76d++bdR6DrwILwtbN8+ccPySTmVZNSXDe6ajScRlcPeRNVALZgA1ojX1hYyF/+8hfeeecdLrjgAhISEjorzfdHX2bwVSoVjz/+OI8//vhp99m1a9cpt11xxRVcccUV/R6TMA/h/q4AHM2rQa839GjjcaCzf7xcbRfmaVGIV0cgX37OxzIYDJworGVTfAFfJxZQXt/a+b0JXg6sm+3HZeHj8HPrX4cN0T8z/VwBpWiPsXjqh4eVtPpr5wSMqFZDQvzS5I5APqW4jotnmHo0A3esoIY2nQEvJxv83OxMPRyzdUXYFUSOi+TaL67lYP5BrvjsCu6MuJMXLngBO223n5utLcyZg2bOHD63i+Tn9Ar+vjyAgJhvWGBtjebIEWX2Pi0NsrOV7bPPuu4fGqoE9sbgPjwcHEwTzDW36difUUE7FcRXb+D/Xnybmhblos8YhzHcM/cefhf5O9zszu0CkKejDcuneLP1RAmfxebxp4vDBmP4I1a7Tk92uVKFXWbkB1+/AvmamhqeeuopXnnlFcLDw/npp59YtGjRUI1NjGKhY5yw02qoa2kno6yekDHKFc2axjaSipRqjvNlRl6YqfMmeqJSQXJxHaW1zQNaO11Y3cSXCQVsji8grbS+83YPB2sumTmOdbN9me7rImtAh0mojxPWGjU1TW3kVDTS0q4nLqcKK7WSSinESGacNUwurjPxSM6NMa0+ImAUFrnrpyDXIPbcvIfHdj7GMz8/w+txr7Mvbx+fXPEJYV6nBp+Rge78nF7BobI2HKdORb9mDRpjUa7qaoiLU9Lxjan5OTmQkqJsH3yg7KdWK63zuhfTmzEDeik4Pdg+SzxAHs/TaLeLNxPbAQj1COXBBQ9y/YzrsbUavKWaV0X6s/VECZuPFPDw6sloNX0uSWZx8quaaNXpsbFS4+sqF9cGW58D+WeffZZnnnkGHx8fPvroo15T7YUYLFYaNdN9XTicXcmRvOrOQP5QVgUGgzITKYWlhLlyd7Bm2jgXjhXUsC+9nHWz+xbo1be088OxIjYfKeBApvK7DmBtpWZl2BjWzfJl8SSvUf2hwFSsrdRMGedMYl41ifnVHMmtBjqK3DnJe5EY2SZ3BPIplhLIS1p9n2g1Wp5e8TTLxi/jhs03cLz0OJH/ieTl1S9z66xbe1wMieyoVh+XW8XyKb84kKsrLF+ubEZlZV2BvTG4LyqCY8eU7e23OwahVYL57sF9WJhy+zkyGAzszd3Lc/uf49vUbzujnoUBC/njgj9y8aSLUasG/+/pkkleeDnZUFbXwo7kUi7oqKsyGhkL3Y33dJDMtSHQ50D+kUcewc7OjokTJ/LOO+/wzjvv9Lrfpk2bBm1wYnQLD3DlcHYlCXnVXBXpD3RPq5fZeGHeFoV4cqyghr1pZw7k23V69qWXs/lIAVtPFNPc1rXufc54d34125fV08fKunczEO7nQmJeNYezKvkmUalIfJ0UuRMWwDgjn1vZSENLOw42ZtGduF8MBgPxHYH8bAnk+2XlhJUk3pnIjV/eyLaMbdz+ze38mPkjb1z8Bi62yjr3WQFuqI2tgVv6cFAvL1i9WtmMCgt7FtOLiYGKCmU2Py4O3nhD2c/WFmbN6hncT5oEmr4VcNXpdXyZ/CXP7n+WwwWHO25VYaebx9+WreeBpZf0/YczAFYaNetm+/LG7kw+i80b1YF8ZllHoTupWD8k+vxOfeONN1p8mtKGDRvYsGEDOt3wtIwSZ2ZcJ5/QMfMFdFbnlrZawtwtCvHi37sy2JtW3rmm2shgMJBUVMvm+AK+SiykrK7rU1GwpwPrZvtyWbgv/u6y7t2czPBzBXL4NDaPNp0Bf3c7FkqRO2EBPBxt8HS0oby+hbTS+s6/vyNJTkUjFQ2tWGvUTPN1NvVwRpwxjmP44dc/8M/9/+TRHY/yyYlPOFxwmI+v+Jg5vnNwtLEibJwzxwtqyawbYDwwbhxceqmyARgMSgp+9+A+NhZqa+HAAWUzcnQ8tcd9cDB0+9va1NbExoSNvHDwBdIr0wGw0dhwxZTr2Rk7BzuVH7fNWznQH1G/XBnhzxu7M9mZUkZpXfOozdzqbD0n6+OHRJ8D+Y0bNw7hMMxDdHQ00dHR1NbW4mJmlTZHI+MHiZSSOppadTS36TjZsT5eZuSFuZsd6IqdVkN5fQvJxXVMGetMcU1z57r3lJKuFFZ3B2sumTGWy2f7MdNP1r2bq5n+yt+FNp2y5uGaKClyJyzHZB8n9qW3kFJcOyIDeWNa/XQ/F2yspPXmQKhVah467yEWBy7m2i+uJas6i/PeOo+nlj3FHxb8gchA93ML5H9JpVKq3QcFgbFAtV4P6ek9g/v4eKivh927lc3IzQ0iIymPmsq//Yt5pWYb5c3KhI+brRvRUdHcNecuth1rYp/hBBFBbsOW3TbR25GIQDficqrYHF/Ab5dMGJbHNTddgbxUrB8KIy93SowaY11s8XayobSuhWMFNVQ2KLOWId6OeDoOfWEUIc6FjZWGecHu7Ewp45UdadQ2tfNzRnmPde8rpnizbpYfS0Jl3ftIEOzpiKONFfUt7VLkTlicUB8n9qWXj9iCd3G5sj5+sMzzm8eR3x7hjm/u4LOkz3jox4f4Kesnrg99FoDM2iG8gKlWK2n0kybBddcpt+l0cPJkV3AfEwOJiWRSxQva7byl2k5TibJrUK2GB6on85uAtTg0z4dGFTtTlP7xS0O9h27cvbgywo+4nCo+jc3jjsXBo/IifUaZ9JAfShLIC7OlUqkI93dlW1IJCXlVFFY3A5JWL0aORSFe7Ewp4/tjxZ23zQly5/LZvqyZPhYXO1n3PpKo1Sqm+7pwILOClWFS5E5YltAxI7vgXef6+AAJ5AeDq60rn1zxCSviV3DvlnvZmrGVI0WJoL6LwsaZFNc24+8xTH/DNBqYNk3Zbr6Z2MJYntv3DJ+f3IQepa7M7Co7/rizmSuO67DSnwBOdN79SWcvrvAJIVK9EnSLlBR9V9chH/ZFM8byxDdJZJQ1EJ9bPeouMlU1tFLZoLTMHe8pM/JDQQJ5YdbCA4yBfDUZpcpVPWk7J0aKNdPH8p89mdhba1g7y5fLZ8m695Hu5vOCqGlq457lIaYeihCDKnQEV66vbW7rXK40O9DVtIOxICqVijsi7mCB/wKu+fwaTpSdAJs/Y9++iMs//IiVUwKwtbLFTmuHnZUddlo75euO/9tZ2Z3x+1bqvochBoOBH9J/4Ln9z7Ere1fn7RdMuICHznuI84POR9XUBImJPYrpGVJS8K0tw7e2DJ7eD0933DEkpOd6+9mzB73HvZOtljXTx/JFfD6fxeaNukA+s1xJqx/nYjsiC2iOBPJTFWbNuE5vf0YF1Y1tAMyVQF6MED4uthz8v+Vn31GMGBdM9RnVFYiF5Zo0xgmVCioaWimra8HLaeQsYUvIrcZggAB3e8mUGQLTvKdx+PbD3L/lfv4T/x8arfYQVwlxP5/bca3UVmcN9o3fTyxJ5Hjp8c77XTvtWh5c8CAzxszoOqC9Pcyfr2wd/vHJIRK/2sGNVmWsaSlQgvysLEhLU7aPPlJ2VKthypSuwD4qSmmLZ3tuv09XRfrxRXw+3yQW8tglYdhbj57QyzgBFyxp9UNm9Pw2iRFphp8rKhWdQfxkHyfcHaxNPCohhBDCsthZawh0tye7opGU4roRFchL//ihZ6+1541L3mBt6Fru/ex9SpraGO+lZd4EJ5rbm2lqb6KprYmm9ibl647/N7U19fh+i66rS0u7vp261jrqWvuWBeJk7cQdEXdw79x78Xfx79N9tuc1kRkwg5uvnw3Txio3VlT07G8fGwsFBXDihLIZC3xbWZ3a437q1H71uJ8z3p1AD3tyKhr54Vgxv4oYPbVVpNDd0JNAXpg1RxsrJnk7dabMSbV6IYQQYmiE+jiRXdFIcnEtC0NGTmvFOOkfP2xWjF/BfeNbee6YFdVFcNcVC5nm2/dOT3qDnpb2ljMG/r3d5mTjxFVTr8LV1rXPj5VT0UBmeQNWahXndW8V6uEBF1ygbEbGHvfdC+pVVCgV8+Pj4T//Ufbrrcd9aKgyo98LlUrFlRF+/HNbKp/G5o2yQF56yA81CeSF2Qv3d5VAXgghhBhioT7ObD1RQmrJyFknr9MbONJRsT5SAvlh4esAl84Yy1eJRTy7NYV3fzOnz/dVq9RKyrzWDuyGcJDAro5q9ZFBbjidre3cufS4d3JS1th3T8sfP76zx/2vIvx4fnsqh7IqyS5vIGiUFH7LlB7yQ04CeWH2wgNc+SQ2D5UK5gW7m3o4QgghhEWaPAIL3qUU19HQqlMy+Doq74uhd8+yCXx3rJg9qWXszyhnwQTzy+DYlVIKDLDt3Jl63Hcrpkd8PNTVndrj3t29M6gfGxnJZZ5WfFkKn8fl8+AFoef83Mxda7uenMpGAIIltX7ISCDfzYYNG9iwYQM6nc7UQxHdLArxxN5aQ2SQO672sj5eCCGEGArGyvWpJfXo9QbUavPve23sHz8rwBXNCBivpQhwt+e6uQG8eyCHZ7eksPn3HmbVJ725TceBzAoAloZ6Dc5Bu/e4//Wvldva23v2uI+NVSrnV1bCtm3KBrwE/J+DGylfT0Z/zQWo58xRAn2vQRqbmcmtbECnN2BvrcHHWQpQDhUJ5LuJjo4mOjqa2tpaXFz6vt5HDC0/N3v2PbwMO63G1EMRQgghLFaguz3WVmqa2nTkVjaOiBRg6R9vOnctm8hnsfkk5FWzLanErDp6HMysoLlNz1gXW0KHMlPDygqmT1e2W25RbmtpgePHe7bBO3EC74YqvJMPwOPd0vIDA3um5EdEgAXEIJ3r470czeoCj6WRQF6MCFKpXgghhBhaVho1Id6OnCisJbm4bkQE8lKx3nS8nWy5deF4Xt2ZznNbU1gxZYzZZEUY18cvDfUa/kDSxkYJyCMiOm9SNTby5iubyN++h9XNBcwpz4CUFGUdfk4OfP551/0nTepZTG/WrEHvcT/UpGL98JBAXgghhBBCAEp6/YnCWlKK67hwmvnMsPamtK6Z3MpGVCqlno4YfncsCeb9Qzmkl9azKT6fKyP71hZuqO1OVQL5JZMGsD5+KNjbM++GS7ioyo0PNGoOP7oc1/ZmiIvrmZaflQWpqcr24YfKfdVqCAs7tce9jfm2iJQe8sNDAnkhhBBCCAF0K3hXUmvikZxdfE41AKFjnHA+W1VyMSScbbX8fukEnvo+mZd+TOPS8HHYWJl2KWR2eQNZ5Q1oNSrOm2g+3Y6mjnNh6jhnThTW8lVCITctCILzz1c2o/JyJbjvXlCvsFBJ1T9+HN5+W9lPq+29x72VeYR2GVKxfliYx9kWQgghhBAmF+rjDEDyCKhcH58r/ePNwY3zg3hrXzYF1U18cDCX3ywcb9LxGKvVRwa6n73t3DC7MsKPE4VJfBqbpwTyv+Tpefoe992D+4oKJeCPi4M33lD2s7OD8PCeM/eTJp22x/1QMRgMXa3nvCW1fihJIC+EEEIIIYCuGfns8gaa23TYmnGh2c718VLozqRstRruXRHC+k3HeHVnOldF+eNoY7oQY1dq1/p4c3NZuC9PfZ/MicJajhfUMM23D4XtTtfjvntgHxd3+h73ERE9Z+679bgfCuX1rdQ2tysd/DwkkB9KEsgLIYQQQggAvJ1scLXXUt3YRnppfd8CDRNoaddxLL8GkEJ35uDKCD/+uyeTzPIG/rc3k/tWTDLJOJrbdBzIUNrOnT/ZTNbHd+PmYM3KqWP47mgRn8flD+z11b3H/ZVXKrfp9ZCW1nPm3tjjftcuZTPq1uOeyEhlFn8QGdPq/dzszPpCoCWQQF4IIYQQQgCgUqmYNMaJw1mVpBTXmW0gf7yglladHg8HawI97E09nFHPSqPmD6tCif4wnv/uyeSGeYF4OA5/MbYDmRW0tOsZ52JLiLd5rs++KtKf744W8WVCAevXTB6cmgJqNYSGKlv3HvdJSWftca8FLnBzQ7NgAcyZ0xXgD7DHvayPHz4SyAshhBBCiE6TfToC+RLzXSff2T8+0E36VJuJ1dN8mO7rwrGCGjbszOCxS8KGfQy7O9rOLQn1Ntvfi4UTPRnrYktRTTM/JpVy0YyxQ/NAVlZKQbwZM+A3v1Fua2mBY8dO6XFvW1UF332nbEaBgT1n7iMiwNX1rA9rrFgvgfzQk0BeCCGEEEJ0Cu1YJ2/OBe+kf7z5UatVPHRhKDe8eZj3D+bwm4VB+LkNb7aEsdCdOa6PN9KoVfxqth+v7kzn09i8oQvke2NjowTlkZGdN7VXV3Pw9ddZYG2NJj5eCfC797j/4ouu+4eEnNrj3rFnwJ5ZLjPyw0UC+W42bNjAhg0b0Ol0ph6KEEIIIYRJdLagKzbPFnQGg4G4XAnkzdHCiZ4smODB/owKXvoxjX9eOXPYHjurvIHsisaOtnOew/a4A3FFhBLI70kro6imibEudqYbjIMDlVOmoF+zBo22o8p/TY2yxv6XPe7T0pTto4+U/dRqmDKlR3CfV6i8NoO9pNDdUJNAvpvo6Giio6Opra3FxcU814QJIYQQQgylSWOUQL6ktoXqxlZc7a1NPKKe8quaKKtrQatRMd1M1/CPViqViocunMzaDT+zKT6f3y4OJqTj92moGWfjo4LcTVo1vy+CPB2YO96dQ1mVbIovIPr8iaYeUk8uLqf2uK+oUAJ64xYTAwUFcOKEsr3zDgBb1BpSvIKYULIEFsxTgvxp00BrXq0ALcHwNhYUQgghhBBmzclWi6+rMkNojun1xrT6qeNcpCq2GQr3d+XCqT7oDfDPbSnD9ri7Usy37Vxvroz0B+DT2DwMBoOJR9MHHh5Kf/tHH4XNmyE/X+lx/8038NhjsGYN7R6eaPU6ppVkYLfxLbjjDpg9W2mDN28e3HWXEvCfOAGSAX3OzPtylRBCCCGEGHaTfZwoqG4ipbiOecEeph5OD7I+3vw9eMEktiUVs/VECUdyq5gVMLTnqqlVx8HMjrZzoebXdq43a6b78JevjpNT0cjhrErmmtnrrE/GjoWLL1Y2YGtiIX9/YyuXtRfxsEdd1+x9dTUcOqRsRg4OSpBvXG8fFQUTJgxpj3tLI4G8EEIIIYToIdTHiZ+SS82ycr0E8uZvorcTv5rtx2dx+TyzJZmPbp83pFXkD3a0nfN1tWOimbad+yV7aysumTmOj2Py+DQ2f2QG8r+QUd5AobM3pbNnw1Ud9REMBsjI6LnePi4OGhpg715lM3J17SrGZwzw/f0luD8NCeSFEEIIIUQPoZ0F78wrkK9vaSe5owifBPLm7b6Vk/gqoZCDmZXsTStn8aShS3k3ro9fEupltm3nenNlpD8fx+Tx/bEinrhsqtmv7T+bzh7y3t0K3alUMHGisl1zjXKbTqdUxu/WBo+EBGXm/scflc3I27tnYB8VBWPGDNtzMmcj+7dFCCGEEEIMOmMgn1pch8FgMJvgKDGvGr0BfF3tGONsa+rhiDPwdbXjhvmBvLkvi2e3JrNwoidq9eD/HhkMBnZ2rI8fKWn1RrMDXAn2ciCzrIHvjhZydVSAqYd0TjoD+bO1ntNoICxM2W66SbmtrQ2OH+85c3/sGJSWwvffK5uRn1/PwD4iAtzdh+hZmS8J5IUQQgghRA/Bno5YqVXUtbRTUN007P3AT0fS6keW3y+dwCcxeRwvqOX740VcPGPcoD9GVnkDuZWNWGvULJgwstLTVSoVV0X6848fkvk0Nn9EB/IGg4HMsgZggD3ktVqlL/2sWXD77cptTU1w9GjPmfuTJ5VCe/n5StE9owkTegb3s2YpRfYsmATyQgghhBCiB2srNRO8HEkpqSOluE4CeTEgHo423L4omBd/TOX5balcMNUHrWZwm2YZq9VHjXfDYQSmpq+b5ctzW1OIy6kivbR+xKzx/6Xi2mYaW3Vo1CoC3Afp/cLODubOVTaj+vpTe9ynpyvr8DMy4OOPlf1UqlN63BMeDraWk8kj7eeEEEIIIcQpjOn15tKCTq83EJ8rgfxIc+ui8Xg4WJNV3sBnsfmDfvxdqR1t5yaNrLR6I29nW87vaJn3edzg/3yGS0apMhsf6G6PtdUQhpiOjrB4MTzwAHz0EaSlQWUlbN8OTz0Fl1+uFMgzGCApCd59F+6+G+bPV2boMzOHbmzDTAL5bjZs2EBYWBhRUVGmHooQQgghhEmZW8G79LJ66prbsbfWMNnHslNmLYmjjRXR508E4F8/pdLcNnj9w3u0nZs8MvrH9+aKCKWn/Bfx+bTr9CYezcAY18cHDySt/ly5ucGKFbB+PWzaBLm5UFwM334Lf/kLXHSRUjTP1haCgoZ/fENEAvluoqOjSUpKIiYmxtRDEUIIIYQwqclmFsgb0+rD/V2xGuT0bDG0fj0vAF9XO0pqW3hnf/agHfdAZjmtHW3nBrQu20wsm+yNh4M1ZXUt7O7IMBhpMnurWG9KY8YoAfzjjysBfXGxMhuvtpz3Dst5JkIIIYQQYtAYZ+QzyuppbTf9LKGsjx+5bKw03L9yEgD/3pVBTVPboBzXxj/j0QAAMVpJREFUuD5+6QhrO/dL1lZqLgv3BeCH48UmHs3AZBgL3Xma6QUVlQq8Rm7WRm8kkBdCCCGEEKfwdbXD0caKdr2BrPIGUw+H+I5AfrYE8iPS5bN8CfF2pKapjf/syTjn4ylt55T+8SOt7VxvFk/yBOBwVqWJRzIwvfaQF0NKAnkhhBBCCHEKlUrFpDHK7Fpyca1Jx1JR30Jmx8WE2f4SyI9EGrWKP14QCsBb+7IprW0+p+NlljeQV9mktJ2bOLLazvUmItANtQpyKxsprjm3n81wa2hpp6hjzMHmOiNvgSSQF0IIIYQQvQr1cQZMv04+PrcagBBvR1zstSYdixi4lWFjmBXgSlObjld2pJ/TsYxp9XPGu2NvPfLazv2Sk62WqeNcADicPbJm5Y0ZOx4O1rg5WJt4NKOHBPJCCCGEEKJX5lLwTtbHWwaVSsXDF04G4KPDueRUDHzJxq6OtPqloZaz7nnOeHcADmdVmHgk/dNVsV7S6oeTSQP5PXv2cMkllzBu3DhUKhVffvllj++rVKpet+eee+60x9y4cWOv92luHlkpKkIIIYQQpmYuveRlfbzlmBfsweJJXrTrDbywPXVAx2hsbedQpjJrvdQC1scbdQXyI2tGPqO0Y338CO4cMBKZNJBvaGhg5syZvPrqq71+v6ioqMf21ltvoVKp+NWvfnXG4zo7O59yX1tb26F4CkIIIYQQFss4I19Q3URd8+BUGu+v1nY9ifnVgMzIW4qHOtbKf5VQSFJh/+svHMiooFWnx8/NjgkWNAscFaQE8qkl9VQ2tJp4NH3XWbFeAvlhZdIFJatXr2b16tWn/b6Pj0+Pr7/66ivOP/98goODz3hclUp1yn2FEEIIIUT/uNpbM8bZhpLaFlJL6ogIdB/2MSQV1dLSrsfVXkuwp+UEbaPZNF8XLp4xlm+PFvHPbSm8dXNUv+5vKW3nfsndwZpJYxxJLaknJruSC6aOjHhGKtabxoipDFFSUsJ3333HO++8c9Z96+vrCQwMRKfTER4ezpNPPsmsWbNOu39LSwstLS2dX9fWKlcG29raaGvr29Vn43593V+YPzmnlkfOqWWR82l55Jyap0nejpTUtpBUUMOMcU59vt9gnc/DmeUAzPJ3ob29/ZyOJc7NYL5G710WzA/Hi9mRXMr+tFKigvqWbWEwGNiZXALAookeFvd+ERnoSmpJPQczylk2aeir8Z/rOdV1a08Z4GZrcedjuPXn56cyGAyGIRxLn6lUKjZv3szatWt7/f6zzz7LP/7xDwoLC8+YJn/w4EHS09OZPn06tbW1/Otf/+L7778nMTGRkJCQXu/z+OOP88QTT5xy+4cffoi9vf2Ano8QQgghhCX4MlvNziI1i3z0XDFeP+yP/3aqmoQKNRcH6FjpaxYfW8Ug+SRTzf4SNeOdDNw7VUdfJtdLmuCpBCs0KgNPR+mw0Qz9OIdTfLmKd9I0+DsYeHCGztTDOauKZvjrEeV8/HOuDrXlJEiYRGNjI9dddx01NTU4Ozufcd8RE8hPnjyZlStX8sorr/TruHq9ntmzZ7N48WJefvnlXvfpbUbe39+f8vLys/4Ajdra2ti+fTsrV65Eq5W2KJZAzqnlkXNqWeR8Wh45p+Zp05ECHt50gjlBbnxwa99ToAfjfBoMBhY9t4eSuhbe/00kc8cPf2q/6DLYr9GS2maWv7iPlnY9b1w/i2V9qED/9v4cnvohhfMmeLDx5ohzHoO5Ka5tZtFze1CrIPb/luFkO7QJ1Od6TnenlnHbe0cI8Xbg+7vPG4IRji61tbV4enr2KZAfEan1e/fuJSUlhU8++aTf91Wr1URFRZGWlnbafWxsbLCxsTnldq1W2+9f6IHcR5g3OaeWR86pZZHzaXnknJqXqb5KynNqaT1WVlb9XpN8LuezoLqJkroWNGoVEUGeaLUWNv06Qg3Wa9TPQ8st543n9d0ZvLA9nRVhY9GcZUp3T5rSmm3ZlDEW+T7h76El0MOenIpGjhbWDVtV/oGe05wqZTJ0oreTRZ6P4dafn+GI6CP/5ptvEhERwcyZM/t9X4PBQEJCAmPHjh2CkQkhhBBCWLaJ3o6oVVDd2EZpXcvZ7zCIjP3jp45zxs5agnhL9LslE3CytSKlpI6vEwvOuG9DS3tnazZL6h//S3OCRk4bus5Cd1KxftiZNJCvr68nISGBhIQEALKyskhISCA3N7dzn9raWj777DNuu+22Xo9x4403sn79+s6vn3jiCbZu3UpmZiYJCQnceuutJCQkcOeddw7pcxFCCCGEsES2Wg1BHdXih7uffGf/+ABpO2epXOy13LlkAgDPb0ultf30dRiMbef83e0suoPBSOonb+whH2xBbQBHCpMG8rGxscyaNauzovwDDzzArFmzeOyxxzr3+fjjjzEYDFx77bW9HiM3N5eioqLOr6urq7njjjuYMmUKq1atoqCggD179jBnzpyhfTJCCCGEEBbK2E8+pbj/Pb/PhXFGXvrHW7ZbzgvCy8mG/KomPjqce9r9dqWWAnB+qLdFtZ37pbnjlWr1ifnVNLeZd8E76SFvOiYN5JcuXYrBYDhl27hxY+c+d9xxB42Njbi4uPR6jF27dvXY/8UXXyQnJ4eWlhZKS0vZunUr8+fPH+JnIoQQQghhuULHKEWXhnNGvrG1naQi5cKBBPKWzd7ainuWK92lXtmRTkPLqW0GlbZzXf3jLZm/ux0+zra06Qwcya029XBOq6apjfJ6ZbmNzMgPvxGxRl4IIYQQQphOaOeM/PAF8ol5Nej0Bsa62DLO1W7YHleYxjVR/gR62FNe38LbP2ed8v2MsnoKqpuwtlIzP9jTBCMcPiqVakSk12d2rI8f42yDk60UuhtuEsgLIYQQQogzMgbyaaX16PTD07k4PrdjfbzMxo8KWo2aB1ZOAuCN3ZlUNbT2+P6uFGU2fu5491FR+LAzkM+uMPFITs+YVh/sKWn1piCBvBBCCCGEOKMAd3tstWpa2/VkVzQMy2N2ro+XQnejxiUzxjFlrDN1Le28tjujx/d2pnStjx8N5nYE8nE5VWcsAGhKnRXrvSWt3hQkkO9mw4YNhIWFERUVZeqhCCGEEEKYDY1axaQxw5der9cbOmfkZX386KFWq3joglAANu7PpqimCVDazsVkKb8Plr4+3miityPuDtY0t+k5Xlhj6uH0KlNaz5mUBPLdREdHk5SURExMjKmHIoQQQghhVkI7AvnhKHiXWd5AdWMbtlo1YeOch/zxhPlYGurFnCB3Wtv1/OvHNAD2d7SdC3C3Z7wFt53rTqVSERWkXMQy13XyUrHetCSQF0IIIYQQZxU6jC3ojP3jZ/i5otXIx9XRRKVS8dCFyqz8p7F5pJfWd0ur97LotnO/NKejDZ05BvJtOj05HctspGK9acg7oxBCCCGEOKvJPsrM+HCk1hvXx0dKWv2oFBnkzoop3ugN8Py2FHanGNvOjY718UbGdfIx2ZXDVmSyr/IqG2nTGbDVqhnnIl0lTEECeSGEEEIIcVbGGfmcykYaW0/t8z2Y4mR9/Kj34AWhqFTww/HizrZz84I9TD2sYTVlrDOONlbUNbeTPAyZMP2R2a1ivVo9erIkzIkE8kIIIYQQ4qy8nGzwcLDGYIC0kvohe5zqxlbSS5Xjz5KK9aPWZB9nLg/37fx6frDHqGg7151GrSLSTNfJd1Wsl/XxpiKBvBBCCCGE6JPOyvUlQ5defyS3GlDW3bo7WA/Z4wjzd//KSWg1ymzvaKlW/0ud/eTNNJAPHiXFB82RBPJCCCGEEKJPugreDV0gL/3jhZG/uz1/uiiM8yZ6sLbb7PxoMrdbIG8wmM86+c6K9TIjbzJWph6AEEIIIYQYGSYPZyAv6+MFcNOCIG5aEGTqYZjMdF9XbKzUVDS0klHWwEQzCZy7esjLjLypyIy8EEIIIYToE+OM/FD1km/X6UnIqwYkkBcCwNpKzewA81onX9nQSlVjG6AUuxOmIYF8Nxs2bCAsLIyoqChTD0UIIYQQwuwY18iX17dQUd8y6Mc/WVRHU5sOZ1srJnhJgCAEQFRnen2FiUeiMK6P93W1G3UFCM2JBPLdREdHk5SURExMjKmHIoQQQghhdhxsrAhwtweGJr0+LkeZcZwd6CYtrYToYFwnf8hM1slndHSVCJa0epOSQF4IIYQQQvTZUKbXx3VUrJdCd0J0mRXgipVaRVFNM/lVTaYeDpnlHYXuJGvGpCSQF0IIIYQQfTaUBe/ipdCdEKewt7Ziup8LYB7r5I0z8lKx3rQkkBdCCCGEEH02VL3ki2qaKKhuQq2Cmf6ug3psIUY6c+onb1wjP0F6yJuUBPJCCCGEEKLPjDPyqSV16PWDt143PqcagCljnXGwkQ7JQnTX2U8+27SBfEu7jtzKRkBm5E1NAnkhhBBCCNFnQZ4OWGvUNLbqBnW9rvSPF+L0IgLdUakgq7yB0tpmk40jt6IRvQEcbazwdrIx2TiEBPJCCCGEEKIftBp150xccnHtoB03LlcCeSFOx8VOyxQfZ8C0s/KdafVeDqhU0lnClCSQF0IIIYQQ/TLYBe+a23ScKKgBYLZUrBeiV+awTj6jTKlYHywV601OAnkhhBBCCNEvnS3oBqng3dH8Gtr1BrydbPBzsxuUYwphaeaaQyBf2jUjL0xLAnkhhBBCCNEvoYM8I999fbyk6wrRu6iOQD65uI7qxlaTjCFDesibDQnku9mwYQNhYWFERUWZeihCCCGEEGbLmFqfVd5AS7vunI8nhe6EODtPR5vOmfCY7Kphf3yDwUCm9JA3GxLIdxMdHU1SUhIxMTGmHooQQgghhNnycbbFydYKnd5ARmnDOR3LYDAQ31HobrYE8kKc0ZzxHgAczqoY9scuq2uhrqUdtQoCPeyH/fFFTxLICyGEEEKIflGpVF0F70rOrXJ9dkUjlQ2tWFupmTrOeTCGJ4TFMuU6+fSOivX+7vbYWGmG/fFFTxLICyGEEEKIfusseHeO6+SNafUzfF0kOBDiLIyV648X1lLf0j6sj51ZJuvjzYkE8kIIIYQQot9CO3pan2vBO1kfL0TfjXO1w8/NDp3eQHzO8K6T795DXpieBPJCCCGEEKLfBquXvDEYkfXxQvSNqfrJSw958yKBvBBCCCGE6LdJY5RAvqimmZrGtgEdo6apjdRS5UKAzMgL0TemWiff1UNeAnlzIIG8EEIIIYToNxc7LeNcbAFIKRnYrHxCXjUGAwR52OPpaDOYwxPCYhkr1yfkVdPcdu7tH/uiqVVHYU0TIKn15kICeSGEEEIIMSChnen1A6tcHydp9UL0W5CHPV5ONrTq9CTmVQ/LY2aVN2AwgKu9FncH62F5THFmEsgLIYQQQogBmdTZgm5gM/LxUuhOiH5TqVTDvk6+q9CdIyqValgeU5yZBPLdbNiwgbCwMKKiokw9FCGEEEIIs3cuBe90egNHciWQF2IgOtfJZw9vIB/sKWn15kIC+W6io6NJSkoiJibG1EMRQgghhDB7oWOUFnTJxXUYDIZ+3TeluI6GVh1ONlaEeDsNxfCEsFjGGfm4nCradPohfzxjxfoJ3lLozlxIIC+EEEIIIQZkgrcDGrWKuuZ2imqa+3XfuI7Z+PAAVzRqSdUVoj8meTvhYqelsVXHicKB1ajoj8wyqVhvbiSQF0IIIYQQA2JjpelMte1ver2sjxdi4NRqFVFBxnXyFUP6WHq9gUzjjLxUrDcbEsgLIYQQQogBM1auT+5nIB8ngbwQ52S4+skX1TbT1KbDSq3C391+SB9L9J0E8kIIIYQQYsAmD6AFXWldM7mVjahUEO7vOkQjE8Kyda9cr9f3r0ZFf2SUKmn1gR72aDUSPpoLORNCCCGEEGLAQn26Ct71VXxOtXLfMU442WqHYlhCWLyp45yxt9ZQ29w+4BaQfSHr482TSQP5PXv2cMkllzBu3DhUKhVffvllj+/ffPPNqFSqHtu8efPOetwvvviCsLAwbGxsCAsLY/PmzUP0DIQQQgghRrfQMcqMfEZZfZ+rZ8flKKnAklYvxMBZadSdr6GhTK+XivXmyaSBfENDAzNnzuTVV1897T4XXnghRUVFndv3339/xmMeOHCAq6++mhtuuIHExERuuOEGrrrqKg4dOjTYwxdCCCGEGPX83Oywt9bQpjOQXd7Qp/vI+nghBsdwrJOXHvLmycqUD7569WpWr159xn1sbGzw8fHp8zFfeuklVq5cyfr16wFYv349u3fv5qWXXuKjjz46p/EKIYQQQoie1GoVk8Y4kZBXTXJxHSFjztwTvrlNx/ECZT29BPJCnJs54z0AOJxdicFgQKUa/FaOxkBeZuTNi0kD+b7YtWsX3t7euLq6smTJEv7+97/j7e192v0PHDjA/fff3+O2Cy64gJdeeum092lpaaGlpaXz69pa5Y9LW1sbbW1tfRqncb++7i/Mn5xTyyPn1LLI+bQ8ck5HrkneDiTkVZNUWM2FYV7A6c9nYm41rTo9Hg7WjHXSyvkeQeQ1an7CxthjbaWmrK6F9JIagjz6N2t+tnNa39JOSa0SJwW42si5H2L9+fmadSC/evVqrrzySgIDA8nKyuLPf/4zy5YtIy4uDhsbm17vU1xczJgxY3rcNmbMGIqLi0/7OE8//TRPPPHEKbdv27YNe/v+tVjYvn17v/YX5k/OqeWRc2pZ5HxaHjmnI097hQrQsPdoBpNb03p875fnc0ehsu8462Z++OGH4RukGDTyGjUv/nYaMupUvPn1HuaPGVj1+tOd09x6ACuctAZ+3innfag1Njb2eV+zDuSvvvrqzv9PmzaNyMhIAgMD+e6771i3bt1p7/fLlJKzpZmsX7+eBx54oPPr2tpa/P39WbVqFc7Ozn0aa1tbG9u3b2flypVotVJ91RLIObU8ck4ti5xPyyPndORyz6xk09uxVOPAmjWLgNOfz28/TABKWT0nlDULx5tmwGJA5DVqnlKs0/n37kxanP1Ys2Z6v+57tnP6VUIhHDvOZF931qyJGqwhi9MwZob3hVkH8r80duxYAgMDSUtLO+0+Pj4+p8y+l5aWnjJL352NjU2vM/xarbbfb1IDuY8wb3JOLY+cU8si59PyyDkdecJ8XQHIr2qiRa/C0abrI2b382kwGDiSVwPAnPGecp5HKHmNmpf5Ez359+5MYnKqB3xeTndOsyubAZjo7STnfBj052c8ovrIV1RUkJeXx9ixY0+7z/z5809JDdm2bRsLFiwY6uEJIYQQQoxKHo42eDoqkyKpZ+hnnVfZRHl9C1qNimm+LsM1PCEs2uwANzRqFflVTRRUNw3qsTPLjT3kpWK9uTFpIF9fX09CQgIJCQkAZGVlkZCQQG5uLvX19Tz44IMcOHCA7Oxsdu3axSWXXIKnpyeXX3555zFuvPHGzgr1APfeey/btm3jmWeeITk5mWeeeYYff/z/9u49uKryXuP4s3bInWSHJCQhBMJFBKJAQgxBaita68AUxaFYZ+QgiLUyTc/YsVcsVZhOa6enIyOSjrYqaltHqlbrKMWBARq0CAESDpJDCDcDhHANCRDIbb/nj7A3iUkgkH1be38/M5kxe6291vvu3+y4Ht613nedfvSjH/m5dwAAAOFjTEb7bPWVtT0H+e3V7Utk3TrYqZjICL+0Cwh18dH9PP8wVurlZej2n2AN+WAV0CC/bds25eXlKS8vT5L01FNPKS8vT88884wiIiK0a9cuzZw5UzfffLPmzZunm2++WZs3b1ZCwpVlTaqrq3Xs2DHP71OmTNHbb7+tlStXavz48Xr99de1atUqFRYW+r1/AAAA4WJ0b4K8e/34oSw7B3iTez35LV4M8m0uo4OnLgf5VIJ8sAnoM/JTp06VMT3PrPjJJ59c8xgbN27s8trs2bM1e/bsvjQNAAAA16F3Qf6sJNaPB7xt0rBk/ankgLYePO21Yx6pa1Rzm0tR/RwaPCDWa8eFd9jqGXkAAAAEJ8+t9cfPdTtQc+5Siypr22dknkiQB7yqYFiyLEvaf/KCTp1v8soxD5xsH40fkRqvCEfPK4AhMAjyAAAA6LNRaQmyLOnMhWad7CZI7DxcL5eRsgbEKj0xJgAtBEKXMy5So9Pb/zHNW8/J7z/pnuiO2+qDEUEeAAAAfRYbFaFhKe0zW3d3e737+fjbGI0HfMLbz8m7g/wIZqwPSgT5DoqLi5WTk6OCgoJANwUAAMB23COC3Qb56ssT3RHkAZ+YNDxFkrTVW0HePWM9I/JBiSDfQVFRkSoqKlRaWhropgAAANjOzZefk9/zlSDvchmVXR6R5/l4wDcKhrd/t/6vtkH1F1v6fLwra8gT5IMRQR4AAABe0dNa8lUnzutcU6vioyI8o/YAvCstIUbDU+NljLT9y76Nyp9tbNap882SuLU+WBHkAQAA4BXuJeiqTpxTm+vKzPXu5+NzhyapXwSXn4CvTBrmnefk91+esT4jMUbx0QFdsRw94C8pAAAAvGJYSryi+zl0qcWlw3WNntfdQT5/KLfVA7406fKEd319Tt4zY30ao/HBiiAPAAAAr4hwWBqV3v48bWXtec/rO6p5Ph7wB3eQ33WkXo3NrTd8HPca8jwfH7wI8gAAAPCa0emJkqS9x9uD/OkLzTp4qj0U5DEiD/hU1oBYZTpj1OoyKqs+e8PHYQ354EeQBwAAgNd4Jrw73j7hXfnlMHFzen85YyMD1SwgLFiW5RmV78tz8qwhH/wI8gAAAPAa94R37hH5HYfPSmL9eMBfrqwnf/qG3t/S5lL16fY5LhiRD14EeQAAAHiNO8h/eaZRzW3Sjssj8hO5rR7wC/eIfFn1WTW1tl33+6vPNKrVZRQXFaGMxBhvNw9eQpDvoLi4WDk5OSooKAh0UwAAAGwpLSFaSXGRchmpplHadbRBEiPygL+MHBivlPgoNbW6tOtI/XW/f/+JK7fVOxyWt5sHLyHId1BUVKSKigqVlpYGuikAAAC2ZFmWRqe3j8qXnnSoqdWlAXGRGp7Ks7aAP/T1OXn3GvIjUrmtPpgR5AEAAOBV7gnvSk+1j+blZw+QZTGyB/hLX9aTZ8Z6eyDIAwAAwKtGZ7QvQdfU1h7eWT8e8C93kN/+ZZ1a21zX9d4D7iCfxl00wYwgDwAAAK9yT3jnls9Ed4BfjclIVEJMP51vatX/HTvX6/cZYzy31jMiH9wI8gAAAPCqjkG+n8PS+KykwDUGCEMRDksFw9zPyfd+GbrTF5pVf7FFliXmtQhyBHkAAAB4Vf/ofspKal+2KmdQgmKjIgLcIiD83Mhz8u4Z6wcnxSomku9tMCPIAwAAwOtGpbfflps3NCmwDQHClDvIlx46I5fL9Oo9B05xW71dEOQBAADgdQumDNNNiUb/VTgk0E0BwtKtmU7FRkaorrFF+y5PYHct7hF5gnzwI8gDAADA6yaPSNZ/39KmYSk8ZwsEQlQ/hyZmJ0nq/Xry7qXnRgzkexvsCPIAAAAAEIImDUuR1Pvn5Jmx3j4I8h0UFxcrJydHBQUFgW4KAAAAAPTJlQnvTsuYqz8nf6mlTUfqGiWxhrwdEOQ7KCoqUkVFhUpLSwPdFAAAAADok7yhSYqMsHS8oUnVZxqvuu+XpxvlMlJCTD8N7B/tpxbiRhHkAQAAACAExURGaEJWkqRrPyfvfj5+5MD+sizL101DHxHkAQAAACBE9XY9efeM9Ux0Zw8EeQAAAAAIUb0N8qwhby8EeQAAAAAIUfnZA+SwpOozjTpWf7HH/TreWo/gR5AHAAAAgBCVEBOpWzKdknoelTfGeG6tv4kZ622BIA8AAAAAIexat9cfP9ekC81tinBYGppMkLcDgjwAAAAAhLBrBfmDl5+PH5ocp6h+REQ7oEoAAAAAEMIKhrUH+aoT53X6fFOX7QdOuie6YzTeLgjyHRQXFysnJ0cFBQWBbgoAAAAAeEVyfJRuTm+fxK70UF2X7ftPNUpiojs7Ich3UFRUpIqKCpWWlga6KQAAAADgNVe7vd49Is8a8vZBkAcAAACAEDdpeIokaeuh0122HWQNedshyAMAAABAiJt0+Tn5ipoGNVxq8bze1CbV1F+SRJC3E4I8AAAAAIS4DGeMslPi5DLS9i+vPCd/sj3DKzk+SgPiowLUOlwvgjwAAAAAhAH3qHzH5+SPX7QkSSNSeT7eTgjyAAAAABAGupvw7sTlIM9t9fYS0CBfUlKi++67T5mZmbIsSx988IFnW0tLi37+859r3Lhxio+PV2Zmph555BHV1NRc9Zivv/66LMvq8nPp0iUf9wYAAAAAglfh5Qnv/vfIWV1sbpMkHb/Yvm1kGiPydhLQIH/hwgVNmDBBK1as6LKtsbFRO3bs0K9+9Svt2LFD//jHP7R3717df//91zxuYmKijh071uknJibGF10AAAAAAFsYkhyrjMQYtbQZlR1uf06eEXl76hfIk0+fPl3Tp0/vdpvT6dTatWs7vfbiiy9q0qRJqq6u1tChQ3s8rmVZysjI8GpbAQAAAMDOLMvSpOHJ+nBnjbYePKP8rESduHzj8giCvK0ENMhfr/r6elmWpaSkpKvud/78eWVnZ6utrU25ubn69a9/rby8vB73b2pqUlNTk+f3hoYGSe2397e0tPT0tk7c+/V2fwQ/ahp6qGlooZ6hh5qGFuoZeqhpaMgf6tSHO2u05cBpfTsnVS0uS/0cljL696O2AXY9n79ljDE+bEuvWZal999/Xw888EC32y9duqQ77rhDY8aM0V//+tcej/P5559r3759GjdunBoaGvTCCy9o9erV2rlzp0aNGtXte5YsWaKlS5d2ef2tt95SXFzcDfUHAAAAAIJNbaP03M5+inQYzR/l0p8rI5QRa7Qoty3QTQt7jY2Nevjhh1VfX6/ExMSr7muLIN/S0qIHH3xQ1dXV2rhx4zU71ZHL5dLEiRP1jW98Q8uXL+92n+5G5IcMGaJTp071+lwtLS1au3atvvWtbykyMrLX7UPwoqahh5qGFuoZeqhpaKGeoYeahgZjjAp/t1F1jS2afkua/rX7hL41ZqD+OKfnO5jhHw0NDUpNTe1VkA/6W+tbWlr03e9+VwcPHtT69euvK8RLksPhUEFBgaqqqnrcJzo6WtHR0V1ej4yMvO4/UjfyHgQ3ahp6qGlooZ6hh5qGFuoZeqip/U0anqxPdh/Xuj0nJUkj0/pT0yBwPTUI6nXk3SG+qqpK69atU0pKynUfwxij8vJyDRo0yActBAAAAAB7mXR5GbqWtvabs0eksvSc3QR0RP78+fPat2+f5/eDBw+qvLxcycnJyszM1OzZs7Vjxw599NFHamtrU21trSQpOTlZUVFRkqRHHnlEgwcP1nPPPSdJWrp0qSZPnqxRo0apoaFBy5cvV3l5uYqLi/3fQQAAAAAIMoXDkzv9PmIgQd5uAhrkt23bprvuusvz+1NPPSVJmjdvnpYsWaIPP/xQkpSbm9vpfRs2bNDUqVMlSdXV1XI4rtxYcPbsWX3/+99XbW2tnE6n8vLyVFJSokmTJvm2MwAAAABgA2MHJap/dD+db2qVJI1IZYJvuwlokJ86daquNtdeb+bh27hxY6ffly1bpmXLlvW1aQAAAAAQkiIclvKzB+jfe08qMdIoIYbn4+0mqJ+RBwAAAAB436TLt9enxQbFIma4TkE/az0AAAAAwLv+qzBbVbUNGtJ6ONBNwQ1gRB4AAAAAwowzLlL/M3ucbrq+1b0RJAjyHRQXFysnJ0cFBQWBbgoAAAAAAN0iyHdQVFSkiooKlZaWBropAAAAAAB0iyAPAAAAAICNEOQBAAAAALARgjwAAAAAADZCkAcAAAAAwEYI8gAAAAAA2AhBHgAAAAAAGyHIAwAAAABgIwR5AAAAAABshCDfQXFxsXJyclRQUBDopgAAAAAA0C2CfAdFRUWqqKhQaWlpoJsCAAAAAEC3CPIAAAAAANgIQR4AAAAAABshyAMAAAAAYCMEeQAAAAAAbIQgDwAAAACAjRDkAQAAAACwkX6BbkAwMsZIkhoaGnr9npaWFjU2NqqhoUGRkZG+ahr8iJqGHmoaWqhn6KGmoYV6hh5qGnqoaXBx5093Hr0agnw3zp07J0kaMmRIgFsCAAAAAAgn586dk9PpvOo+lulN3A8zLpdLNTU1SkhIkGVZvXpPQ0ODhgwZosOHDysxMdHHLbyioKBApaWlfjtfIM/r73OGU03D5ZzUNLTOST1D77zUNLTOGah6SuHx+QbinHxHQ++81DS4zmmM0blz55SZmSmH4+pPwTMi3w2Hw6GsrKwbem9iYqJfvwQRERF+/59joM4bqL6GQ03D5Zxu1DR0zilRz1A8LzUNnXNK/q+nFD6fb7jUNJw+W2rKOa81Eu/GZHc2V1RUFDbnDVRf/S1cPttwqacUPp9vuNQ0nD5baso57SpcPt9wqWk4fbbUlHP2FrfWe0lDQ4OcTqfq6+sDNsoI76KmoYeahhbqGXqoaWihnqGHmoYeampfjMh7SXR0tJ599llFR0cHuinwEmoaeqhpaKGeoYeahhbqGXqoaeihpvbFiDwAAAAAADbCiDwAAAAAADZCkAcAAAAAwEYI8gAAAAAA2AhBHgAAAAAAGyHId1BSUqL77rtPmZmZsixLH3zwQaftx48f1/z585WZmam4uDhNmzZNVVVVXY6zefNm3X333YqPj1dSUpKmTp2qixcverbX1dVp7ty5cjqdcjqdmjt3rs6ePevj3oUnf9XUrampSbm5ubIsS+Xl5T7qVfjyVz337t2rmTNnKjU1VYmJifra176mDRs2+Lp7YamvNT106JAsy+r255133vHs89hjj2n48OGKjY3VyJEj9eyzz6q5udmfXQ0b/qip28cff6zCwkLFxsYqNTVVs2bN8kcXw4o3/u7W1tZq7ty5ysjIUHx8vCZOnKh333230z5cG/mPv2rqxrWRb/mrnlwbBR+CfAcXLlzQhAkTtGLFii7bjDF64IEHdODAAf3zn/9UWVmZsrOzdc899+jChQue/TZv3qxp06bp3nvv1datW1VaWqof/vCHcjiufNQPP/ywysvLtWbNGq1Zs0bl5eWaO3euX/oYbvxVU7ef/exnyszM9Gmfwpm/6vntb39bra2tWr9+vbZv367c3FzNmDFDtbW1fulnOOlrTYcMGaJjx451+lm6dKni4+M1ffp0SdKePXvkcrn08ssva/fu3Vq2bJleeuklPf30037ta7jwR00l6b333tPcuXP16KOPaufOnfrss8/08MMP+62f4cIbf3fnzp2ryspKffjhh9q1a5dmzZqlhx56SGVlZZ59uDbyH3/V1I1rI9/yVz25NgpCBt2SZN5//33P75WVlUaS+eKLLzyvtba2muTkZPPnP//Z81phYaFZvHhxj8etqKgwksznn3/ueW3z5s1GktmzZ493O4FOfFVTt9WrV5sxY8aY3bt3G0mmrKzMm83HV/iqnidPnjSSTElJiee1hoYGI8msW7fOu51AJzda06/Kzc01CxYsuOq5fv/735vhw4f3uc24Ol/VtKWlxQwePNi88sorPmk3unej9YyPjzdvvvlmp2MlJyd76se1UeD4qqZuXBv5l6/qybVRcGJEvpeampokSTExMZ7XIiIiFBUVpU8//VSSdOLECW3ZskVpaWmaMmWK0tPTdeedd3q2S+2jgU6nU4WFhZ7XJk+eLKfTqf/85z9+6g0k79VUar9t6fHHH9df/vIXxcXF+a8T8PBWPVNSUjR27Fi9+eabunDhglpbW/Xyyy8rPT1d+fn5/u1UmOtNTb9q+/btKi8v12OPPXbVY9fX1ys5Odl7jUWveKumO3bs0NGjR+VwOJSXl6dBgwZp+vTp2r17t287gE56W8877rhDq1at0pkzZ+RyufT222+rqalJU6dOlcS1UTDxVk0lro2CgbfqybVRcCLI99KYMWOUnZ2tRYsWqa6uTs3Nzfrd736n2tpaHTt2TJJ04MABSdKSJUv0+OOPa82aNZo4caK++c1vep5Fqa2tVVpaWpfjp6WlcWuKn3mrpsYYzZ8/XwsXLtRtt90WsP6EO2/V07IsrV27VmVlZUpISFBMTIyWLVumNWvWKCkpKVDdC0u9qelXvfrqqxo7dqymTJnS43H379+vF198UQsXLvRV09EDb9W043d58eLF+uijjzRgwADdeeedOnPmjF/6gt7Xc9WqVWptbVVKSoqio6P1xBNP6P3339fIkSMlcW0UTLxVU66NgoO36sm1UXAiyPdSZGSk3nvvPe3du1fJycmKi4vTxo0bNX36dEVEREiSXC6XJOmJJ57Qo48+qry8PC1btkyjR4/Wa6+95jmWZVldjm+M6fZ1+I63avriiy+qoaFBixYtClhf4L16GmP0gx/8QGlpadq0aZO2bt2qmTNnasaMGT0GDfhGb2ra0cWLF/XWW29ddTS+pqZG06ZN04MPPqjvfe97vmw+uuGtmrq/y7/85S/1ne98R/n5+Vq5cmW3E+LBd3pbz8WLF6uurk7r1q3Ttm3b9NRTT+nBBx/Url27PPtwbRQcvFVTro2Cg7fqybVRcOoX6AbYSX5+vsrLy1VfX6/m5mYNHDhQhYWFnn9pHDRokCQpJyen0/vGjh2r6upqSVJGRoaOHz/e5dgnT55Uenq6j3uAr/JGTdevX6/PP/9c0dHRnfa57bbbNGfOHL3xxht+6Akk79Xzo48+Ul1dnRITEyVJf/zjH7V27Vq98cYb+sUvfuHHHuFaNe3o3XffVWNjox555JFuj1VTU6O77rpLt99+u/70pz/5uunogTdq2t13OTo6WiNGjPB8l+Ef16rn/v37tWLFCn3xxRe65ZZbJEkTJkzQpk2bVFxcrJdeeolroyDjjZpybRQ8vFVPro2CDyPyN8DpdGrgwIGqqqrStm3bNHPmTEnSsGHDlJmZqcrKyk777927V9nZ2ZKk22+/XfX19dq6datn+5YtW1RfX3/VW0HhW32p6fLly7Vz506Vl5ervLxcq1evltR+m9JvfvMb/3YEkvpWz8bGRknqsiqBw+HwjALC/3qqaUevvvqq7r//fg0cOLDLtqNHj2rq1KmaOHGiVq5c2e2qE/CvvtQ0Pz9f0dHRnb7LLS0tOnTokOe7DP/qqZ49/U2NiIjw/E3l2ig49aWmXBsFn77Uk2ujIBXImfaCzblz50xZWZkpKyszkszzzz9vysrKzJdffmmMMebvf/+72bBhg9m/f7/54IMPTHZ2tpk1a1anYyxbtswkJiaad955x1RVVZnFixebmJgYs2/fPs8+06ZNM+PHjzebN282mzdvNuPGjTMzZszwa1/Dhb9q2tHBgweZmdVH/FHPkydPmpSUFDNr1ixTXl5uKisrzU9+8hMTGRlpysvL/d7nUOeNmhpjTFVVlbEsy/zrX//qsu3o0aPmpptuMnfffbc5cuSIOXbsmOcH3uePmhpjzJNPPmkGDx5sPvnkE7Nnzx7z2GOPmbS0NHPmzBmf9i/c9LWezc3N5qabbjJf//rXzZYtW8y+ffvMH/7wB2NZlvn44489+3Ft5D/+qmlHXBv5jj/qybVRcCLId7BhwwYjqcvPvHnzjDHGvPDCCyYrK8tERkaaoUOHmsWLF5umpqYux3nuuedMVlaWiYuLM7fffrvZtGlTp+2nT582c+bMMQkJCSYhIcHMmTPH1NXV+aGH4cdfNe2I/1n5jr/qWVpaau69916TnJxsEhISzOTJk83q1av90cWw462aLlq0yGRlZZm2trYu21auXNntOfi3bN/wR02Nab/4/PGPf2zS0tJMQkKCueeeezotsQTv8EY99+7da2bNmmXS0tJMXFycGT9+fJelrrg28h9/1bQjro18x1/15Noo+FjGGOOt0X0AAAAAAOBbPCQIAAAAAICNEOQBAAAAALARgjwAAAAAADZCkAcAAAAAwEYI8gAAAAAA2AhBHgAAAAAAGyHIAwAAAABgIwR5AAAAAABshCAPAACuy5IlS5SbmxvoZgAAELYsY4wJdCMAAEBwsCzrqtvnzZunFStWqKmpSSkpKX5qFQAA6IggDwAAPGpraz3/vWrVKj3zzDOqrKz0vBYbGyun0xmIpgEAgMu4tR4AAHhkZGR4fpxOpyzL6vLaV2+tnz9/vh544AH99re/VXp6upKSkrR06VK1trbqpz/9qZKTk5WVlaXXXnut07mOHj2qhx56SAMGDFBKSopmzpypQ4cO+bfDAADYEEEeAAD02fr161VTU6OSkhI9//zzWrJkiWbMmKEBAwZoy5YtWrhwoRYuXKjDhw9LkhobG3XXXXepf//+Kikp0aeffqr+/ftr2rRpam5uDnBvAAAIbgR5AADQZ8nJyVq+fLlGjx6tBQsWaPTo0WpsbNTTTz+tUaNGadGiRYqKitJnn30mSXr77bflcDj0yiuvaNy4cRo7dqxWrlyp6upqbdy4MbCdAQAgyPULdAMAAID93XLLLXI4rowPpKen69Zbb/X8HhERoZSUFJ04cUKStH37du3bt08JCQmdjnPp0iXt37/fP40GAMCmCPIAAKDPIiMjO/1uWVa3r7lcLkmSy+VSfn6+/va3v3U51sCBA33XUAAAQgBBHgAA+N3EiRO1atUqpaWlKTExMdDNAQDAVnhGHgAA+N2cOXOUmpqqmTNnatOmTTp48KD+/e9/68knn9SRI0cC3TwAAIIaQR4AAPhdXFycSkpKNHToUM2aNUtjx47VggULdPHiRUboAQC4BssYYwLdCAAAAAAA0DuMyAMAAAAAYCMEeQAAAAAAbIQgDwAAAACAjRDkAQAAAACwEYI8AAAAAAA2QpAHAAAAAMBGCPIAAAAAANgIQR4AAAAAABshyAMAAAAAYCMEeQAAAAAAbIQgDwAAAACAjfw/VSntl+ViCVsAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Resample to annual data by taking the mean of each year\n", - "annual_data = cold_days_series.resample('AS').mean()\n", - "\n", - "# Calculate a 10-year moving average of the annual data\n", - "moving_average = annual_data.rolling(window=10, center=True).mean()\n", - "\n", - "# Plotting the time series, trendline, and moving average\n", - "plt.figure(figsize=(12, 6))\n", - "plt.plot(cold_days_series.index, cold_days_series.values, label='Daily Data')\n", - "plt.plot(cold_days_series.index, trendline, label='Trendline', color='red')\n", - "plt.plot(moving_average.index, moving_average.values, label='10-Year Moving Average', color='green')\n", - "plt.title('Number of Days with Daily Maximum Temperature Below the 10th Percentile')\n", - "plt.xlabel('Time')\n", - "plt.ylabel('Number of Days')\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.minorticks_on()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from xclim.core.calendar import percentile_doy\n", - "from xclim.indices import tx90p\n", - "\n", - "\n", - "tasmax_per_90 = percentile_doy(data['t2m'], per=90, window=5).sel(percentiles=90)\n", - "hot_days = tx90p(data['t2m'], tasmax_per_90)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hot_days_mean = hot_days.mean(dim=['latitude', 'longitude']) # Averaging over the spatial dimensions\n", - "\n", - "# Plotting the time series\n", - "plt.figure(figsize=(12, 6))\n", - "hot_days_mean.plot()\n", - "plt.title('Number of Days with Daily Maximum Temperature above the 90th Percentile')\n", - "plt.xlabel('Time')\n", - "plt.ylabel('Number of Days')\n", - "plt.grid(True)\n", - "plt.minorticks_on()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xclim/core/utils.py:461: RuntimeWarning: All-NaN slice encountered\n", - " result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n" - ] - } - ], - "source": [ - "from xclim.indices import tn10p\n", - "\n", - "\n", - "tasmin_per_10 = percentile_doy(data['t2m'], per=10, window=5).sel(percentiles=10)\n", - "cold_nights = tn10p(data['t2m'], tasmin_per_10)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/IAAAIxCAYAAADuaYOWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADl6UlEQVR4nOzdd1hTZ/sH8O9JCGGDIBtEnIgKOHDvVbVVO6y2vlXbatu3pUO77dQuR6dt0fb91dZW62rVDttaJ+6BA1BR3DJkyt4hOb8/QiIIKGGdjO/nurxawsnJnRxykvs893M/giiKIoiIiIiIiIjIJMikDoCIiIiIiIiI6o+JPBEREREREZEJYSJPREREREREZEKYyBMRERERERGZECbyRERERERERCaEiTwRERERERGRCWEiT0RERERERGRCmMgTERERERERmRAm8kREREREREQmhIk8UQtYuXIlBEGAjY0Nrl27VuP3w4YNQ7du3SSIDIiKioIgCPj1118leXxDXb16FXfffTdcXV0hCALmzJlT57Zt27aFIAgQBAEymQzOzs7o0qULZsyYgW3btrVc0C1EdyyjoqL0t/3999+YP39+rdsLgoBnn322QY919epV/WsrCAIUCgXc3NwQHh6OuXPn4syZMw3ab9XYqsZd23NrDN17sq59iqKIDh06QBAEDBs27LaxGWLYsGE19meqqr6Gt/vXtm1bqUOV1EcffYTffvtN6jBq1bZtW9xzzz1Nvs9HH320SfdpqOvXr2P+/PmIiYmp8btHH30UDg4OzR5DcnIy5syZg6FDh8LFxQWCIGDlypV1br9jxw70798fdnZ2aN26NR599FFkZGRU2yY+Ph7z58/H1atXa9y/sd8jqn5eCoIABwcH9O3bFz/99FOD92lMli1bVuvrr/ssq/o73bmttteZyJgwkSdqQWVlZXjrrbekDsOkzZ07F0eOHMH333+PQ4cOYe7cubfdfuDAgTh06BAOHjyIjRs34tlnn8WVK1dw1113YfLkyVCpVC0UefPr2bMnDh06hJ49e+pv+/vvv7FgwYJme8znnnsOhw4dwp49e7Bq1Srce++9+OOPPxAaGoqPP/64wfs9dOgQZs+e3YSR1s7R0RErVqyocfuePXtw6dIlODo6Nmlsy5Ytw7Jlyxp0X2Nz991349ChQ9X+AcDkyZOr3bZ582aJI5WWMSfy5ur69etYsGBBrYl8S7l48SJ+/vlnWFtbY/z48bfdds+ePRg3bhw8PT3x+++/Y+nSpdixYwdGjhyJsrIy/Xbx8fFYsGBBsyWYus/LQ4cO6ZPZmTNnYvny5c3yeC2prkTe29sbhw4dwt13393yQRE1kpXUARBZkrFjx2LNmjV4+eWXERoaKnU4LaqkpAQ2NjYQBKFR+zl9+jT69OmDe++9t17bu7i4oF+/fvqfR40ahYiICMyfPx8LFizAW2+9hcWLFzcqJmPh5ORU7bm2hDZt2lR7zPHjx+PFF1/E/fffj1dffRXdunXDuHHjDN5vSz2PqVOn4ueff0ZkZCScnJz0t69YsQL9+/dHfn5+k8YWHBzc4PsaG3d3d7i7u9e43dPTs8X/DluKWq1GRUUFlEql1KGgpKQEtra2UodBdRgyZAgyMzMBAMeOHcPatWvr3PaVV15Bp06d8Ouvv8LKSvvVPDAwEAMHDsT333+Pp59+ukViru3zMiAgAJ999lmjY1CpVBAEQf/8jIVSqTTb8xWZP47IE7WgV199FW5ubnjttdduu11tpV46t5b1zp8/H4IgIC4uDg8++CCcnZ3h6uqKF198ERUVFUhISMDYsWPh6OiItm3bYsmSJbU+ZmlpKV588UV4eXnB1tYWQ4cOxcmTJ2tsd+zYMUycOBGurq6wsbFBjx49sGHDhmrb6K7kb9u2DY8//jjc3d1hZ2dXbWThVomJiXjkkUfg4eEBpVKJLl264NNPP4VGowFws7T64sWL+Oeff/Tlfw0dmZg/fz66du2Kr7/+GqWlpfrbFyxYgL59+8LV1RVOTk7o2bMnVqxYAVEU9dvMmjULrq6uKC4urrHfESNGoGvXrvqff/nlF/Tt2xfOzs6ws7NDu3bt8Pjjj982tgcffLDaPgBgwoQJEAQBv/zyi/62EydOQBAE/PnnnwBqlp8/+uijiIyMBIBqJZO3vmarVq1Cly5dYGdnh9DQUGzZsuW28d2Jra0tVqxYAYVCUW1UPjMzE8888wyCg4Ph4OAADw8PjBgxAvv27auxjzuVr69atQqCIOhHgat67733oFAocP369TvG+vDDDwNAtS/ZeXl52LhxY53H6dbYdH/vu3fvxtNPP43WrVvDzc0N999/f40Ybi2t173XP/74YyxevBht27aFra0thg0bhvPnz0OlUuH111+Hj48PnJ2dcd9999Uot63rtbq1xFkX565du/DEE0/Azc0NTk5OmDFjBoqKipCWloYpU6bAxcUF3t7eePnll5ukYuXChQuYNm1atfe27u9SR/e3u2bNGrz22mvw9vaGg4MDJkyYgPT0dBQUFODJJ59E69at0bp1azz22GMoLCys8To8++yz+Pbbb9GpUycolUoEBwdj3bp1NWJKS0vDU089BT8/P1hbWyMwMBALFixARUWFfhvdsVmyZAk++OADBAYGQqlUYvfu3SgtLcVLL72EsLAw/Tm3f//++P3332vEVFRUhB9//FH//tMdf925+1a1lfXqSuA3bdqEHj16wMbGRl9pU5/nciebN29GSEgIbGxs0K5dO3z55Zc1tsnPz8fLL7+MwMBAWFtbw9fXF3PmzEFRUdEd93+n8zsAhIeH1xgV7d69OwRBQHR0tP62TZs2QRAEnDp1qtbHioqKQnh4OADgscce07/ut75HLl68iPHjx8PBwQH+/v546aWXanxGlZeX44MPPkBQUBCUSiXc3d3x2GOP6RP025HJ6vcVOyUlBdHR0Zg+fXq1JHfAgAHo1KmTvqJl5cqVePDBBwEAw4cP1z+vW78nREdHY/DgwfrPm0WLFlV7nQ3h4uKCzp07V5sSaMj7edWqVXjppZfg6+sLpVKJixcvAgC2bt2KkSNH6j8Xu3TpgoULF1bbhyHfNe507m3bti3OnDmDPXv21Jjyc7vvW7fSVUk4OTnBzs4OAwcOxM6dOw15SYmaFBN5ohbk6OiIt956C//++y927drVpPueMmUKQkNDsXHjRjzxxBP4/PPPMXfuXNx77724++67sXnzZowYMQKvvfYaNm3aVOP+b7zxBi5fvozvvvsO3333Ha5fv45hw4bh8uXL+m12796NgQMHIjc3F9988w1+//13hIWFYerUqbV+CD7++ONQKBRYtWoVfv31VygUilpjz8zMxIABA7Bt2za8//77+OOPPzBq1Ci8/PLL+jncurJxLy+vauV/3t7eDX7NJkyYgOLiYhw7dkx/29WrV/HUU09hw4YN2LRpE+6//34899xzeP/99/XbvPDCC8jJycGaNWuq7S8+Ph67d+9GREQEAG0J9tSpU9GuXTusW7cOf/31F9555507fsEeNWoU4uPjkZqaCgCoqKjAnj17YGtri+3bt+u327FjB6ysrOqcc/32229j8uTJ+lhqe83++usvfP3113jvvfewceNGuLq64r777qt23BvCx8cHvXr1wsGDB/XPNzs7GwDw7rvv4q+//sIPP/yAdu3aYdiwYQbPfZ86dSq8vLxqfIGsqKjAt99+i/vuuw8+Pj533I+TkxMmT56M77//Xn/b2rVrIZPJMHXqVINimj17NhQKBdasWYMlS5YgKioKjzzySL3uGxkZiQMHDiAyMhLfffcdzp07hwkTJmDWrFnIzMzE999/jyVLlmDHjh2NnnIwe/ZsODs7Y926dXjrrbewZs0aPPHEE7j77rsRGhqKX3/9FTNnzsSnn36Kr776qlGPFR8fj/DwcJw+fRqffvoptmzZgrvvvhvPP/98rVM+3njjDWRkZGDlypX49NNPERUVhYcffhgPPPAAnJ2dsXbtWrz66qtYtWoV3njjjRr3/+OPP/Dll1/ivffew6+//oqAgAA8/PDD1XqApKWloU+fPvj333/xzjvv4J9//sGsWbOwcOFCPPHEEzX2+eWXX2LXrl345JNP8M8//yAoKAhlZWXIzs7Gyy+/jN9++w1r167FoEGDcP/991ebU3zo0CHY2tpi/Pjx+vdfQ6dWnDhxAq+88gqef/55bN26FQ888IDBz6U2MTExmDNnDubOnYvNmzdjwIABeOGFF/DJJ5/otykuLsbQoUPx448/4vnnn8c///yD1157DStXrsTEiROrXei8VX3O74D2vLd37179xaP09HScPn261vOep6cnunfvXuvj9ezZEz/88AMA4K233tK/7lXfNyqVChMnTsTIkSPx+++/4/HHH8fnn39erTpLo9Fg0qRJWLRoEaZNm4a//voLixYtwvbt2zFs2DCUlJTU6/W9k9OnTwMAQkJCavwuJCRE//u7774bH330EQDt+UL3vKpe/EhLS8N//vMfPPLII/jjjz8wbtw4zJs3D6tXr25QbCqVCteuXdNX3hj6fp43bx4SExPxzTff4M8//4SHhwdWrFiB8ePHQ6PR6G9//vnnkZycrL+fod817nTu3bx5M9q1a4cePXo0eMrP6tWrMWbMGDg5OeHHH3/Ehg0b4OrqirvuuovJPElHJKJm98MPP4gAxOjoaLGsrExs166d2Lt3b1Gj0YiiKIpDhw4Vu3btqt/+ypUrIgDxhx9+qLEvAOK7776r//ndd98VAYiffvppte3CwsJEAOKmTZv0t6lUKtHd3V28//779bft3r1bBCD27NlTH48oiuLVq1dFhUIhzp49W39bUFCQ2KNHD1GlUlV7rHvuuUf09vYW1Wp1tec7Y8aMer0+r7/+ughAPHLkSLXbn376aVEQBDEhIUF/W0BAgHj33XfXa7932nb58uUiAHH9+vW1/l6tVosqlUp87733RDc3t2qvz9ChQ8WwsLAa8To5OYkFBQWiKIriJ598IgIQc3Nz6xWvzsWLF0UA4k8//SSKoiju379fBCC++uqrYmBgoH670aNHiwMGDND/rDuWu3fv1t8WEREh1nWqByB6enqK+fn5+tvS0tJEmUwmLly48LYx6v5GP/744zq3mTp1qghATE9Pr/X3FRUVokqlEkeOHCned999NWKr+nde23N79913RWtr62r7X79+vQhA3LNnz23jr/qe1O379OnToiiKYnh4uPjoo4+KoiiKXbt2FYcOHXrb2HT7euaZZ6ptt2TJEhGAmJqaqr9t6NCh1fanex1DQ0P17x9RFMUvvvhCBCBOnDix2j7nzJkjAhDz8vLqjEcnICBAnDlzZo04n3vuuWrb3XvvvSIA8bPPPqt2e1hYmNizZ88a+70dAGJERIT+57vuukv08/OrFq8oiuKzzz4r2tjYiNnZ2aIo3jy+EyZMqPX5Pv/88zVidnV1rfHYtra2Ylpamv62iooKMSgoSOzQoYP+tqeeekp0cHAQr127Vu3+uvfrmTNnRFG8eWzat28vlpeX3/Z56/6WZ82aJfbo0aPa7+zt7asdBx3duftWuuN05coV/W0BAQGiXC6vdi405LnUJSAgQBQEQYyJial2++jRo0UnJyexqKhIFEVRXLhwoSiTycTo6Ohq2/36668iAPHvv/+uts+qz7e+5/cdO3aIAMS9e/eKoiiKq1evFh0dHcVnnnlGHD58uP5+HTt2FKdNm3bb5xUdHV3nZ+jMmTNFAOKGDRuq3T5+/Hixc+fO+p/Xrl0rAhA3btxY676XLVt22xjqG8/PP/8sAhAPHTpU43dPPvmkaG1trf/5l19+qXEe1Bk6dGitr3NwcLB411133THGgIAAcfz48aJKpRJVKpV45coV/Wv1yiuviKJo+Pt5yJAh1bYrKCgQnZycxEGDBlX7PL2Vod816nPure1cLoq1f9+69T1YVFQkurq61jg/qdVqMTQ0VOzTp0+dz4WoOXFEnqiFWVtb44MPPsCxY8dqlIk1xq2dh7t06QJBEKrNT7ayskKHDh1q7Zw/bdq0amWeAQEBGDBgAHbv3g1AW4Z47tw5/Oc//wGgHfnU/Rs/fjxSU1ORkJBQbZ8PPPBAvWLftWsXgoOD0adPn2q3P/rooxBFscmrF3TEWkaRdu3ahVGjRsHZ2RlyuRwKhQLvvPMObty4Ua2k+YUXXkBMTAwOHDgAQFt2umrVKsycOVPfEVlX3jllyhRs2LABKSkp9Yqrffv2aNu2LXbs2AEA2L59O7p3745HHnkEV65cwaVLl1BWVob9+/dj1KhRjXoNhg8fXq2hm6enJzw8PGr9GzFUba/vN998g549e8LGxgZWVlZQKBTYuXMnzp49a/D+dXM2/+///k9/29dff43u3btjyJAh9d7P0KFD0b59e3z//fc4deoUoqOj7zj9oTYTJ06s9rNuhK0+r+X48eOrleJ26dIFAGqUGutuT0xMNDg+ndrOFXU9VmP+DkpLS7Fz507cd999sLOzq3HOKC0txeHDhxscW3Z2do3y+pEjR8LT01P/s1wux9SpU3Hx4kX9iN+WLVswfPhw+Pj4VItJd67cs2dPtX1OnDix1mqiX375BQMHDoSDg4P+b3nFihUN+luuj5CQEHTq1KnabYY+l9p07dq1Rs+WadOmIT8/HydOnNA/Trdu3RAWFlbtce666647riZR3/P7wIEDYWNjU+28N2zYMIwdOxYHDx5EcXExkpKScOHChUaf9wRBwIQJE6rdFhISUu3vfcuWLXBxccGECROqPeewsDB4eXk12QoaVWMy5PbaeHl51Xidb31et/P3339DoVBAoVAgMDAQGzZswHPPPYcPPvigQe/nW78DHDx4EPn5+XjmmWfqfF4N+a7RmHNvfRw8eBDZ2dmYOXNmtXg0Gg3Gjh2L6Ojoek0xIWpqTOSJJPDQQw+hZ8+eePPNN5usa7qrq2u1n62trWFnZwcbG5sat1edE67j5eVV6203btwAoC1zBICXX35Z/0Gv+/fMM88AALKysqrdv75l7zdu3Kh1W11ptC6Gpqb7kNc9ztGjRzFmzBgA2uTwwIEDiI6OxptvvgkA1UopJ02ahLZt2+pLu1euXImioiJ9WT2gbXb022+/oaKiAjNmzICfnx+6det226ZHOiNHjtSX6+3YsQOjR49G9+7d4enpiR07duDAgQMoKSlp9BdaNze3GrcplcomKRu9du0alEql/m9T1zCpb9++2LhxIw4fPozo6GiMHTu2QY/n6emJqVOn4ttvv4VarUZcXBz27dtn8JJ6giDgsccew+rVq/HNN9+gU6dOGDx4sMHx3Ppa6hqi1ee51fb+vd3ttb2H68uQx2rM49y4cQMVFRX46quvapwzdF28bz1nNPZ1qOs8posH0J7L/vzzzxox6fpS1Oc8tmnTJkyZMgW+vr5YvXo1Dh06pL8A1JjX7HZqi8PQ51Kb+r5mcXFxNR7H0dERoije9nHqe363sbHBwIED9Yn8zp07MXr0aAwbNgxqtRr79u3Tl9g39rxX22ejUqmsduzS09ORm5sLa2vrGs87LS2tXq9tfejOG7V9zmVnZ9f426/Pvqoy5Hw+aNAgREdH49ixY4iPj0dubi6+/PJLWFtbN+j9fOtx1/UW8PPzqzOGhnzXaMy5tz50MU2ePLlGTIsXL4YoivqpY0QtybhaRxJZCEEQsHjxYowePRr/+9//avxe9wXj1sY7zZXQAtq5dbXdpvuAbN26NQDtnLf777+/1n107ty52s/1HUlwc3PTzwevStesRvfYTUkURfz555+wt7dH7969AQDr1q2DQqHAli1bqn3Jq23pKJlMhoiICLzxxhv49NNPsWzZMowcObLGazBp0iRMmjQJZWVlOHz4MBYuXIhp06ahbdu26N+/f53xjRw5EitWrMDRo0dx5MgR/bKFI0aMwPbt23Ht2jU4ODgYbbfdlJQUHD9+HEOHDtU3cFq9ejWGDRtWYymjgoKCBj/OCy+8gFWrVuH333/H1q1b4eLioh/JMcSjjz6Kd955B9988w0+/PDDBscjBaVSWWsjyeY8X9RHq1atIJfLMX369GoXuKoKDAxs0ses6zwGoNq5LCQkpM7jfGtvhdrOY6tXr0ZgYCDWr19f7fe3a+h5q6rn+apd8OtKEGuLw9DnUpv6vma2trbVekncGkddDDm/jxw5Eu+88w6OHj2K5ORkjB49Go6OjggPD8f27dtx/fp1dOrUCf7+/nd8Xo2la5y2devWWn9f29KUDaFb+/3UqVM1lqk7depUo9aGN5Szs7P+8/BWDXk/3/o3q5trX3U+/K0a8l2jueli+uqrr+r8zK1aCUTUUpjIE0lk1KhRGD16NN57770aX0o8PT1hY2ODuLi4arff2hG5Ka1duxYvvvii/oP32rVrOHjwIGbMmAFA+8HZsWNHxMbG6hvuNJWRI0di4cKFOHHiRLU10H/66ScIgoDhw4c36eMB2u708fHxeOONN/RfqHVL48jlcv12JSUlWLVqVa37mD17NubPn4///Oc/SEhIuO0ydkqlEkOHDoWLiwv+/fdfnDx58o6JvCAIePvttyGTyfSl4qNGjcIrr7yCa9euYciQIXU2EKz6uLrn0VJLVZWUlGD27NmoqKjAq6++qr9dEIQay3bFxcXh0KFDDf5i3qtXLwwYMACLFy/G6dOn8eSTT8Le3t7g/fj6+uKVV17BuXPnMHPmzAbFIpW2bdvWOFfs2rWrRtl5S7Ozs8Pw4cNx8uRJhISE6EfRm9POnTuRnp6u/1KtVquxfv16tG/fXj8KeM899+Dvv/9G+/bt0apVqwY9jiAIsLa2rpaopKWl1XqOrmtEVNc1Oy4uTj8NB4B+FYr6aIrncubMGcTGxlYrr1+zZg0cHR315+N77rkHH330Edzc3Ay++GLI+X3UqFF444038Pbbb8PPzw9BQUH62//44w+kpaXVa8pWU4zI3nPPPVi3bh3UajX69u3b4P3cia+vL/r06YPVq1fj5Zdf1n/+HD58GAkJCZgzZ45+26YeaTZEU7yfBwwYAGdnZ3zzzTd46KGHar041VzfNRpTaTZw4EC4uLggPj7e4IovoubERJ5IQosXL0avXr2QkZFRbbkxQRDwyCOP4Pvvv0f79u0RGhqKo0eP1uiS3pQyMjJw33334YknnkBeXh7effdd2NjYYN68efptvv32W4wbNw533XUXHn30Ufj6+iI7Oxtnz57FiRMnqi2NZoi5c+fip59+wt1334333nsPAQEB+Ouvv7Bs2TI8/fTTNeaFGiI3N1c/b6+oqAgJCQlYt24d9u3bhylTplTrtHv33Xfjs88+w7Rp0/Dkk0/ixo0b+OSTT+pcM9rFxQUzZszA8uXLERAQUGPO5TvvvIPk5GSMHDkSfn5+yM3NxdKlS6FQKDB06NDbxu3h4YFu3bph27ZtGD58OOzs7ABov9BmZ2cjOzsbn3322R2fv66z8+LFizFu3DjI5fImTaoSExNx+PBhaDQa5OXl4eTJk/j+++9x7do1fPrpp/qpCoD2i/H777+Pd999F0OHDkVCQgLee+89BAYGGrRU1q1eeOEFTJ06FYIg6EsvG2LRokUNvq+Upk+fjrfffhvvvPMOhg4divj4eHz99ddwdnaWOjQsXboUgwYNwuDBg/H000+jbdu2KCgowMWLF/Hnn382ef+L1q1bY8SIEXj77bdhb2+PZcuW4dy5c9WWoHvvvfewfft2DBgwAM8//zw6d+6M0tJSXL16FX///Te++eab25b+AtAvBffMM89g8uTJSEpKwvvvvw9vb29cuHCh2rbdu3dHVFQU/vzzT3h7e8PR0RGdO3fG+PHj4erqilmzZuG9996DlZUVVq5ciaSkpHo/36Z4Lj4+Ppg4cSLmz58Pb29vrF69Gtu3b8fixYv15505c+Zg48aNGDJkCObOnYuQkBBoNBokJiZi27ZteOmll+pMdg05v/fq1QutWrXCtm3b8Nhjj+lvHzVqlH7lkPqU1bdv3x62trb4+eef0aVLFzg4OMDHx6deFQo6Dz30EH7++WeMHz8eL7zwAvr06QOFQoHk5GTs3r0bkyZNwn333XfbfehWS9CtAnLs2DF9DxXdiiIA9BV6Dz74IJ555hlkZGTg9ddfR7du3aq9DrrR+f/9739wdHSEjY0NAgMDay2pbw6NfT87ODjg008/xezZszFq1Cg88cQT8PT0xMWLFxEbG4uvv/4aQPN81+jevTvWrVuH9evXo127drCxsalz5YPa4v7qq68wc+ZMZGdnY/LkyfDw8EBmZiZiY2ORmZlZo9KMqCUwkSeSUI8ePfDwww/XmqB/+umnAIAlS5agsLAQI0aMwJYtW/SjOE3to48+QnR0NB577DHk5+ejT58+WLduHdq3b6/fZvjw4Th69Cg+/PBDzJkzBzk5OXBzc0NwcDCmTJnS4Md2d3fHwYMHMW/ePMybNw/5+flo164dlixZghdffLFRz+vAgQPo378/BEGAvb29fvTjrbfeqpZkAtqy9e+//x6LFy/GhAkT4OvriyeeeAIeHh6YNWtWrfufOnUqli9fjqeffrrGusF9+/bFsWPH8NprryEzMxMuLi7o3bs3du3aVWOd+NqMGjUKp06dqvbFtU2bNujYsWO9Gz5NmzYNBw4cwLJly/Dee+9BFEVcuXKlyf6OvvrqK3z11VeQy+VwcnJCu3btMGHCBDzxxBMIDg6utu2bb76J4uJirFixAkuWLEFwcDC++eYbbN68uVGNo+69914olUoMHz4cHTt2bOQzMj2vvPIK8vPzsXLlSnzyySfo06cPNmzYgEmTJkkdGoKDg3HixAm8//77eOutt5CRkQEXFxd07NixRhlxU5g4cSK6du2Kt956C4mJiWjfvj1+/vnnaksJent749ixY3j//ffx8ccfIzk5GY6OjggMDMTYsWPrNbL92GOPISMjA9988w2+//57tGvXDq+//jqSk5NrLMO1dOlSRERE4KGHHtIv4xYVFQUnJyds3boVc+bMwSOPPAIXFxfMnj0b48aNq/cSg03xXMLCwvDYY4/h3XffxYULF+Dj44PPPvsMc+fO1W9jb2+Pffv2YdGiRfjf//6HK1euwNbWFm3atMGoUaNuez4x5Pwuk8kwbNgwbN68udr5rX///rC3t0dJSUm9KrTs7Ozw/fffY8GCBRgzZgxUKhXefffdGmvJ345cLscff/yBpUuXYtWqVVi4cCGsrKzg5+eHoUOH1isJ1K37rhMZGanvq1K1GeiwYcPw999/45133sGECRNgZ2eHe+65Bx9//HG1C8mBgYH44osvsHTpUn3vgB9++AGPPvpovZ9XYzTF+3nWrFnw8fHB4sWLMXv2bIiiiLZt21arhGqO7xoLFixAamoqnnjiCRQUFCAgIABXr16t9/0feeQRtGnTBkuWLMFTTz2FgoICeHh4ICwsrMVef6JbCWJtbYWJiKheXnrpJSxfvhxJSUktNipC1f3555+YOHEi/vrrr2ZJDsk0CIKAiIgI/ageERGROeOIPBFRAxw+fBjnz5/HsmXL8NRTTzGJl0B8fDyuXbuGl156CWFhYdWWWiQiIiIyZ0zkiYgaoH///vryxw8++EDqcCzSM888gwMHDqBnz5748ccfDVpvmYiIiMiUsbSeiIiIiIiIyITI7rwJERERERERERkLJvJEREREREREJoSJPBEREREREZEJYbO7Wmg0Gly/fh2Ojo5snkRERERERETNThRFFBQUwMfHBzLZ7cfcmcjX4vr16/D395c6DCIiIiIiIrIwSUlJ8PPzu+02TORr4ejoCED7Ajo5OdXrPiqVCtu2bcOYMWOgUCiaMzxqITym5ofH1LzweJofHlPzwuNpfnhMzQ+PqXHJz8+Hv7+/Ph+9HSbytdCV0zs5ORmUyNvZ2cHJyYlvAjPBY2p+eEzNC4+n+eExNS88nuaHx9T88Jgap/pM72azOyIiIiIiIiITwkSeiIiIiIiIyIQwkSciIiIiIiIyIUzkq4iMjERwcDDCw8OlDoWIiIiIiIioVkzkq4iIiEB8fDyio6OlDoWIiIiIiIioVkzkiYiIiIiIiEwIE3kiIiIiIiIiE8JEnoiIiIiIiMiEMJEnIiIiIiIiMiFM5ImIiIiIiIhMiKSJ/PLlyxESEgInJyc4OTmhf//++OeffwAAKpUKr732Grp37w57e3v4+PhgxowZuH79+m33uXLlSgiCUONfaWlpSzwlIiIiIiIiomZlJeWD+/n5YdGiRejQoQMA4Mcff8SkSZNw8uRJ+Pn54cSJE3j77bcRGhqKnJwczJkzBxMnTsSxY8duu18nJyckJCRUu83GxqbZngcRERERERFRS5E0kZ8wYUK1nz/88EMsX74chw8fxqxZs7B9+/Zqv//qq6/Qp08fJCYmok2bNnXuVxAEeHl5NUvMRERERERERFKSNJGvSq1W45dffkFRURH69+9f6zZ5eXkQBAEuLi633VdhYSECAgKgVqsRFhaG999/Hz169Khz+7KyMpSVlel/zs/PB6At71epVPWKX7ddfbcn48djan54TM0Lj6f54TE1Lzye5ofH1PzwmBoXQ46DIIqi2Iyx3NGpU6fQv39/lJaWwsHBAWvWrMH48eNrbFdaWopBgwYhKCgIq1evrnN/hw8fxsWLF9G9e3fk5+dj6dKl+PvvvxEbG4uOHTvWep/58+djwYIFNW5fs2YN7OzsGv7kiIiIiIiIiOqhuLgY06ZNQ15eHpycnG67reSJfHl5ORITE5Gbm4uNGzfiu+++w549exAcHKzfRqVS4cEHH0RiYiKioqLu+KSq0mg06NmzJ4YMGYIvv/yy1m1qG5H39/dHVlZWvR9LpVJh+/btGD16NBQKRb3jI+PFY2p+eEzNC4+n+eExNS88nuaHx9T88Jgal/z8fLRu3bpeibzkpfXW1tb6Zne9e/dGdHQ0li5dim+//RaA9o9rypQpuHLlCnbt2mVQEg8AMpkM4eHhuHDhQp3bKJVKKJXKGrcrFAqD/6Abcp+GKqtQ41xqAZxtFWjb2r5FHtMSteQxpZbBY2peeDzND4+peeHxND88puaHx9Q4GHIMjG4deVEU9aPjuiT+woUL2LFjB9zc3Bq0v5iYGHh7ezd1qJJ7f0s8JkUewJqjiVKHQkRERERERC1E0hH5N954A+PGjYO/vz8KCgqwbt06REVFYevWraioqMDkyZNx4sQJbNmyBWq1GmlpaQAAV1dXWFtbAwBmzJgBX19fLFy4EACwYMEC9OvXDx07dkR+fj6+/PJLxMTEIDIyUrLn2VxCfF0AJCI2KVfiSIiIiIiIiKilSJrIp6enY/r06UhNTYWzszNCQkKwdetWjB49GlevXsUff/wBAAgLC6t2v927d2PYsGEAgMTERMhkNwsLcnNz8eSTTyItLQ3Ozs7o0aMH9u7diz59+rTU02oxIf7OAIDTKXlQa0TIZYLEEREREREREVFzkzSRX7FiRZ2/a9u2LerThy8qKqraz59//jk+//zzxoZmEjq4O8BWIUdRuRqXMwvR0dNR6pCIiIiIiIiomRndHHmqPyu5DN18tc3/YpPzJI6GiIiIiIiIWgITeRMX4ucCAIhLzpU0DiIiIiIiImoZTORNXIifdp48R+SJiIiIiIgsAxP5KiIjIxEcHIzw8HCpQ6m30MoR+bOp+Siv0EgbDBERERERETU7JvJVREREID4+HtHR0VKHUm8BbnZwtlWgvEKD8+kFUodDREREREREzYyJvIkTBKFKeX2utMEQERERERFRs2MibwZ0iXxcEufJExERERERmTsm8mZA17meI/JERERERETmj4m8GdA1vLuQUYiScrW0wRAREREREVGzYiJvBrycbeDhqIRaI+LMdZbXExERERERmTMm8mbiZnk9E3kiIiIiIiJzxkTeTITqGt5xnjwREREREZFZYyJvJkL8XQAAcRyRJyIiIiIiMmtM5M1EiK92RP5KVhHySlQSR0NERERERETNhYl8FZGRkQgODkZ4eLjUoRislb012rjaAQBOcVSeiIiIiIjIbDGRryIiIgLx8fGIjo6WOpQGCamcJ8/15ImIiIiIiMwXE3kzoltPng3viIiIiIiIzBcTeTMSou9cz9J6IiIiIiIic8VE3ox083WGIACpeaXIKCiVOhwiIiIiIiJqBkzkzYi90god3B0AAHFJHJUnIiIiIiIyR0zkzUwI58kTERERERGZNSbyZibUX9e5niPyRERERERE5oiJvJmpOiIviqK0wRAREREREVGTYyJvZrp4O0IhF5BTrEJyTonU4RAREREREVETYyJfRWRkJIKDgxEeHi51KA2mtJIjyMsJABDLefJERERERERmh4l8FREREYiPj0d0dLTUoTQK15MnIiIiIiIyX0zkzVBo5Tz52KRcSeMgIiIiIiKipsdE3gyFVHauP52SB7WGDe+IiIiIiIjMCRN5M9TB3QG2CjmKytW4klUodThERERERETUhJjImyEruQzdfCsb3iVxnjwREREREZE5YSJvpqquJ09ERERERETmg4m8mdJ1ro9l53oiIiIiIiKzwkTeTOk618en5qO8QiNtMERERERERNRkmMibqQA3OzjbKlBeocH59AKpwyEiIiIiIqImwkS+isjISAQHByM8PFzqUBpNEIQq5fW50gZDRERERERETYaJfBURERGIj49HdHS01KE0CV0iH8fO9URERERERGaDibwZ03Wu54g8ERERERGR+WAib8Z0De8uZBSipFwtbTBERERERETUJJjImzEvZxt4OCqh1og4c53l9UREREREROaAibyZu1lez0SeiIiIiIjIHDCRN3OhuoZ3nCdPRERERERkFiRN5JcvX46QkBA4OTnByckJ/fv3xz///KP/vSiKmD9/Pnx8fGBra4thw4bhzJkzd9zvxo0bERwcDKVSieDgYGzevLk5n4ZRC/F3AQDEcUSeiIiIiIjILEiayPv5+WHRokU4duwYjh07hhEjRmDSpEn6ZH3JkiX47LPP8PXXXyM6OhpeXl4YPXo0CgoK6tznoUOHMHXqVEyfPh2xsbGYPn06pkyZgiNHjrTU0zIqIb7aEfkrWUXIK1FJHA0RERERERE1lqSJ/IQJEzB+/Hh06tQJnTp1wocffggHBwccPnwYoijiiy++wJtvvon7778f3bp1w48//oji4mKsWbOmzn1+8cUXGD16NObNm4egoCDMmzcPI0eOxBdffNFyT8yItLK3hr+rLQDgFEfliYiIiIiITJ6V1AHoqNVq/PLLLygqKkL//v1x5coVpKWlYcyYMfptlEolhg4dioMHD+Kpp56qdT+HDh3C3Llzq91211133TaRLysrQ1lZmf7n/Px8AIBKpYJKVb9RbN129d2+JXX3cUJSdglOXruBvm2dpQ7HZBjzMaWG4TE1Lzye5ofH1LzweJofHlPzw2NqXAw5DpIn8qdOnUL//v1RWloKBwcHbN68GcHBwTh48CAAwNPTs9r2np6euHbtWp37S0tLq/U+aWlpdd5n4cKFWLBgQY3bt23bBjs7O0OeDrZv327Q9i1BUSAAkGP7ifNoU3RO6nBMjjEeU2ocHlPzwuNpfnhMzQuPp/nhMTU/PKbGobi4uN7bSp7Id+7cGTExMcjNzcXGjRsxc+ZM7NmzR/97QRCqbS+KYo3bbmXofebNm4cXX3xR/3N+fj78/f0xZswYODk51et5qFQqbN++HaNHj4ZCoajXfVqK25Vs/P79MWRU2GL8+KFSh2MyjPmYUsPwmJoXHk/zw2NqXng8zQ+PqfnhMTUuusrw+pA8kbe2tkaHDh0AAL1790Z0dDSWLl2K1157DYB2hN3b21u/fUZGRo0R96q8vLxqjL7f6T5KpRJKpbLG7QqFwuA/6Ibcp7mFBbhBEIC0/DLklKrh4WgjdUgmxRiPKTUOj6l54fE0Pzym5oXH0/zwmJofHlPjYMgxMLp15EVRRFlZGQIDA+Hl5VWtzKO8vBx79uzBgAED6rx///79a5SGbNu27bb3MXcOSit0cHcAAMQlseEdERERERGRKZN0RP6NN97AuHHj4O/vj4KCAqxbtw5RUVHYunUrBEHAnDlz8NFHH6Fjx47o2LEjPvroI9jZ2WHatGn6fcyYMQO+vr5YuHAhAOCFF17AkCFDsHjxYkyaNAm///47duzYgf3790v1NI1CiJ8LLmQUIi45F6OC665OICIiIiIiIuMmaSKfnp6O6dOnIzU1Fc7OzggJCcHWrVsxevRoAMCrr76KkpISPPPMM8jJyUHfvn2xbds2ODo66veRmJgImexmYcGAAQOwbt06vPXWW3j77bfRvn17rF+/Hn379m3x52dMQv2dsfFEMmK5BB0REREREZFJkzSRX7FixW1/LwgC5s+fj/nz59e5TVRUVI3bJk+ejMmTJzcyOvMS4ucCAIhLzq1Xw0AiIiIiIiIyTkY3R56aRxdvRyjkAnKKVUjOKZE6HCIiIiIiImogJvIWQmklR5CXdim92ORcaYMhIiIiIiKiBmMib0FC/JwBAKc4T56IiIiIiMhkMZGvIjIyEsHBwQgPD5c6lGYRWjlPniPyREREREREpouJfBURERGIj49HdHS01KE0ixB/7Yj86ZR8aDSixNEQERERERFRQzCRtyAd3B1gq5CjsKwCl7MKpQ6HiIiIiIiIGoCJvAWxksvQzbey4V0S58kTERERERGZIibyFqbqevJEUimv0ODQpRtQc4oHEREREZHBmMhbGF3n+lh2ricJzd0Qg4f/7zBWHboqdShERERERCaHibyF0XWuj0/NR3mFRtpgyCLtPpeBv+JSAQB/n0qTOBoiIiIiItPDRN7CBLjZwdlWgfIKDc6nF0gdDlmYknI13v79tP7n44k5yC0ulzAiIiIiIiLTw0TewgiCUKW8PlfaYMjiLN15Ack5JfBxtkG71vZQa0TsOZ8pdVhERERERCaFibwF0iXycexcTy0oIa0A3+27DABYMKkbRnf1BKAttSciIiIiovpjIm+BdJ3rOSJPLUWjEfHG5lOo0IgYE+yJ0cGeGNHZAwCw53wmu9cTERERERmAiXwVkZGRCA4ORnh4uNShNCtdw7sLGYUoKVdLGwxZhPXHknD8Wg7sreWYP7ErAKBXQCs42Vghp1iFmKQciSMkIiIiIjIdTOSriIiIQHx8PKKjo6UOpVl5Oinh7qiEWiPizHWW11Pzyiosw6J/zgEA5o7uBB8XWwCAlVyGoZWj8jvPsryeiIiIiKi+mMhbIEEQEMr15KmFfPjXWeSVqBDs7YRHB7St9rsRQe4AgF2cJ09EREREVG9M5C2Ubp58HOfJUzM6cDELm0+mQBCAj+7vDit59VPO0E4eEATgXFoBrueWSBQlEREREZFpYSJvofSd6zkiT82kVKXGW79p14yf3i8AYf4uNbZxtbdGj8rbdydwVJ6IiIiIqD6YyFso3Yj8lawi5JWopA2GzNLyqEu4klUED0clXr6rc53bjQjSzpPfxXnyRERERET1wkTeQrnaW8PfVdt07BRH5amJXcosxPKoSwCAdyYEw8lGUee2I4K068kfuJSFUhVXUSAiIiIiuhMm8haM68lTcxBFEW//dhrlag2GdnLH3d29b7t9F29HeDvboFSlwaHLN1ooSiIiIiIi08VE3oKF6ufJ50obCJmVzSdTcPDSDSitZHh/UjcIgnDb7QVBwLDKZeh2s3s9EREREdEdMZG3YDc717O0nppGbnE5PvzrLADg+ZEd0cbNrl7308+TP5cBURSbLT4iIiIiInPARL6KyMhIBAcHIzw8XOpQWkQ3X2cIApCaV4qMglKpwyEzsOifc7hRVI6OHg54YnC7et9vYAc3WFvJkJxTggsZhc0YIRERERGR6WMiX0VERATi4+MRHR0tdSgtwkFphQ7uDgCAuCSOylPjRF/NxrroJADaNeOtrep/erGztkL/dm4AtKPyRERERERUNybyFu5meX2upHGQaSuv0ODNzacAAFN7+yO8ravB+6haXk9ERERERHVjIm/hQv21De9iOU+eGuG7/ZdxPr0QrvbWeH1cUIP2oUvkj1/LQV6xqinDIyIiIiIyK0zkLZxuRP5USh6bjFGDJGUX48udFwAAb47vglb21g3aj7+rHTp6OECtEbHnQmZThkhEREREZFaYyFu4Lt6OUMgFZBeVIzmnROpwyMSIooi3fz+NUpUG/du54f6evo3an25UnsvQERERERHVjYm8hVNayRHk5QSAy9CR4f4+lYaohExYy2X44L47rxl/J8MrE/mohAyoNawQISIiIiKqDRN5Qoifdp48G96RIfJLVVjw5xkAwH+HtUf7yhUQGqNXQCs42lghp1iFmKTcRu+PiIiIiMgcMZEnhFbOk49lIk8G+PTfBGQUlCGwtT2eGda+SfapkMswpJM7AGDXufQm2ScRERERkblhIk8IqexcfzolHxqWM1M9xCbl4qfD1wAA70/qBhuFvMn2PVK/DB0b3hERERER1YaJfBWRkZEIDg5GeHi41KG0qA7uDrBVyFFYVoHLWYVSh0NGrkKtwRubT0EUgXvDfDCoY+sm3f/QTu4QBOBsaj5S89iAkYiIiIjoVkzkq4iIiEB8fDyio6OlDqVFWcll6OarbXgXm8SGd3R7Px66hjPX8+FkY4U37w5u8v27OSgR5u8CANjNUXkiIiIiohqYyBOAm+vJs+Ed3U5qXgk+25YAAHh9XBe4Oyqb5XFGdNaV13MZOiIiIiKiWzGRJwA3O9fHcgk6uo35f5xBUbkavQJa4aFw/2Z7nBFdtIn8gYtZKFWpm+1xiIiIiIhMERN5AnCzc318aj7KKzTSBkNGaUd8Ov49kw4rmYAP7+sGmaxxa8bfTrC3E7ycbFCiUuPw5RvN9jhERERERKaIiTwBAALc7OBkY4XyCg3OpxdIHQ4ZmeLyCrz7h3bN+FmDAxHk5dSsjycIAoYHaZeh283yeiIiIiKiapjIEwBt4hTC9eSpDl/suICU3BL4utjihZEdW+Qxh+vmySdkQBS5LCIRERERkY6kifzChQsRHh4OR0dHeHh44N5770VCQkK1bQRBqPXfxx9/XOd+V65cWet9SktLm/spmTTdPPk4dq6nKuKv52PF/isAgPfv7Qo7a6sWedyBHVrDWi5DUnYJLmZwWUQiIiIiIh1JE/k9e/YgIiIChw8fxvbt21FRUYExY8agqKhIv01qamq1f99//z0EQcADDzxw2307OTnVuK+NjU1zPyWTxhF5upVGI+LN305BrRExrpsXRgR5tthj2yut0K+9GwB2ryciIiIiqqplhtbqsHXr1mo///DDD/Dw8MDx48cxZMgQAICXl1e1bX7//XcMHz4c7dq1u+2+BUGocV+6vVB/7Yj8hYxClJSrYWstlzgiktqao4k4mZgLB6UV3p3QtcUff0Rnd+w9n4ld5zLw1ND2Lf74RERERETGSNJE/lZ5edqSbldX11p/n56ejr/++gs//vjjHfdVWFiIgIAAqNVqhIWF4f3330ePHj1q3basrAxlZWX6n/Pz8wEAKpUKKpWqXrHrtqvv9sbIzVYOdwdrZBaWIzbxBnoFtJI6JEmZwzFtjMyCMizeeg4AMGdke7jZyVv8tRjcQXsuOHYtBzfyi+Fkq2jU/iz9mJobHk/zw2NqXng8zQ+PqfnhMTUuhhwHQTSSLlKiKGLSpEnIycnBvn37at1myZIlWLRoEa5fv37bMvnDhw/j4sWL6N69O/Lz87F06VL8/fffiI2NRceONRt1zZ8/HwsWLKhx+5o1a2BnZ9fwJ2WC/u+cDKdzZLivrRrDvI3iT4Mk8uN5GU7ckMHfXsSL3dVoxtXmbuujGDnSSwTM7KhGz9b8myQiIiIi81RcXIxp06YhLy8PTk63XyXKaBL5iIgI/PXXX9i/fz/8/Pxq3SYoKAijR4/GV199ZdC+NRoNevbsiSFDhuDLL7+s8fvaRuT9/f2RlZV1xxdQR6VSYfv27Rg9ejQUisaNGkrp692XsHTXJUwI8cJnD4ZIHY6kzOWYNsS+i1l4/McTkAnAxqf6oZtv8y43dzuLtiZgxYFruDfUGx9P7t6ofVnyMTVHPJ7mh8fUvPB4mh8eU/PDY2pc8vPz0bp163ol8kZRWv/cc8/hjz/+wN69e+tM4vft24eEhASsX7/e4P3LZDKEh4fjwoULtf5eqVRCqVTWuF2hUBj8B92Q+xiTHgGuAC7h9PUCk34eTcnUj6mhSlVqLNiiLamf0b8terR1kzSeUcHeWHHgGvZevAGZ3AryJigNsLRjau54PM0Pj6l54fE0Pzym5ofH1DgYcgwk7VoviiKeffZZbNq0Cbt27UJgYGCd265YsQK9evVCaGhogx4nJiYG3t7ejQnXIug611/JKkJeCefKWKLI3Rdx7UYxPJ2UeGlMJ6nDQe+2reBoY4XsonKuqEBEREREBIkT+YiICKxevRpr1qyBo6Mj0tLSkJaWhpKSkmrb5efn45dffsHs2bNr3c+MGTMwb948/c8LFizAv//+i8uXLyMmJgazZs1CTEwM/vvf/zbr8zEHrvbW8He1BQCcSuZ68pbmYkYBvtlzCQAwf0JXONpIf2VWIZdhSEd3AMCus1yGjoiIiIhI0kR++fLlyMvLw7Bhw+Dt7a3/d2v5/Lp16yCKIh5++OFa95OYmIjU1FT9z7m5uXjyySfRpUsXjBkzBikpKdi7dy/69OnTrM/HXHA9ecskiiLe3HwaKrWIEUEeGNvNeJZvHBHkAYDryRMRERERARLPka9vn70nn3wSTz75ZJ2/j4qKqvbz559/js8//7wxoVm0UD9n/BWXijgm8hbl1+PJOHIlGzYKGRZM7ApBkKhNfS2GdXaHIADxqflIyyuFl3Pdq1YQEREREZk7SUfkyTjpRuTjWFpvMbKLyvHR32cBAHNGdYK/q3Etu+jmoERo5d/l7gSOyhMRERGRZWMiTzV083WGIACpeaXIKCiVOhxqAQv/PoucYhWCvBwxa1DdTSelxPJ6IiIiIiItJvJUg4PSCh3cHQCw4Z0lOHz5Bn45ngwA+PC+blDIjfO0oEvk91/IQqlKLXE0RERERETSMc5v7BKJjIxEcHAwwsPDpQ5Fcjcb3jGRN1eiKGLNkUQ89kM0AODhPm3QK8BV4qjq1tXHCZ5OSpSo1DhyJVvqcIiIiIiIJMNEvoqIiAjEx8cjOjpa6lAkF+rvDABseGemsgrLMPvHY3hj8ymUqNQY0N4N88YHSR3WbQmCgOGdtaPyu1leT0REREQWjIk81apqw7v6ri5ApmHn2XSM/WIvdp7LgLVchrfu7oLVs/rCyQjWjL+T4ZXl9TvPpfPvkoiIiIgslqTLz5Hx6uLtCIVcQHZROZJzSoyuizkZrri8Ah/8dRZrjiQCAIK8HPHFQ2EI8nKSOLL6G9ShNazlMiRll+BSZiE6eDhKHRIRERERUYvjiDzVSmkl1yd4XIbO9MUm5eLuL/frk/jZgwLxW8RAk0riAcBeaYW+7bTz+Nm9noiIiIgsFRN5qlOIH+fJm7oKtQZf7byAB5YfxJWsIng52eDn2X3x1j3BsFHIpQ6vQbgMHRERERFZOibyVKdQfef6XEnjoIZJvFGMqf87jE+3n0eFRsTdId7YOmcwBnZoLXVojaJL5I9dzUFeiUriaIiIiIiIWh4TeapTSGXn+tMp+dBo2FjMVIiiiA3HkjBu6V4cv5YDR6UVPp8aiq8f7gEXO2upw2u0ADd7tHO3R4VGxL4LmVKHQ0RERETU4pjIU506uDvARiFDYVkFLmcVSh0O1UNOUTmeXn0Cr/4ah6JyNfoEuuKfOYNxXw8/CIIgdXhNZkRnltcTERERkeViIk91spLL0M1HOyofm8SGd8Zuz/lM3PXFXmw9kwaFXMBrY4Ow9ol+8GtlfisOjOiiTeT3JGSyWoSIiIiILA4Tebqtm+vJ50oaB9WtVKXG/D/OYOb3R5FRUIYOHg7Y/MxAPD2sPeQy8xmFryq8rSsclVa4UVTOHg5EREREZHGYyFcRGRmJ4OBghIeHSx2K0QitnCcfyyXojNLplDxM+Go/Vh68CgCY2T8AW54bhG6+ztIG1swUchkGd9I27dvN8noiIiIisjBM5KuIiIhAfHw8oqOjpQ7FaOhG5ONT81FeoZE2GNJTa0R8s+cS7lt2ABcyCuHuqMTKx8KxYFI3k11WzlDDK+fJ72QiT0REREQWxkrqAMi4tXWzg5ONFfJLK3A+vcDsR3pNQXJOMV7aEIsjV7IBAHd19cTC+0Pgam/6HekNMayzBwQBOHM9H+n5pfB0spE6JCIiIiKiFsERebotQRD0o/Kciyy9306mYNwX+3DkSjbsreVYMjkE3zzSy+KSeABwd1Tq/zZZXk9EREREloSJPN1RiJ92FD6Oneslk1eswnNrT2LO+hgUlFWgZxsX/P3CYEzp7W9Wy8oZisvQEREREZElYiJPd8QReWkdvJSFsUv34s/Y65DLBLw4uhM2PNUfAW72UocmuRFB2kR+/8UslFWoJY6GiIiIiKhlcI483ZGuc/2FjEKUlKtha20ZzdSkVlahxif/JuC7/VcgikBga3t8PjUMYf4uUodmNLr6OMHdUYnMgjIcuZyNIZ3cpQ6JiIiIiKjZcUSe7sjLyQbujkqoNSLOXGd5fUtISCvApK8P4P/2aZP4aX3b4K/nBzGJv4VMJrC83oIdvpyNqFQBoihKHQoRERFRi2IiT3ckCAJC/biefEvQaESs2H8FE77ej3NpBXCzt8Z3M3rjo/u6w86aBTS1GR50M5FnQmc5Tibm4PGfjmPzVTmOXs2ROhwiIiKiFsVEnupFN08+jvPkm01ZhRpPrjqO97fEo7xCgxFBHtg6ZwhGBXtKHZpRG9SxNRRyAYnZxbiUWSR1ONQCMgvK8PTqE1CptRduYtiIk4iIiCwME/kqIiMjERwcjPDwcKlDMTr6zvUckW8W5RUaRPx8AjvOpkNpJcMH93bDipm94e6olDo0o+egtELfQDcAXIbOEqjUGkSsOYG0/FLIKhdsiEvheYmIiIgsCxP5KiIiIhAfH4/o6GipQzE6uhH5K1lFyCtRSRuMmVGpNXh+7UnsOJsBpZUM3z8ajkf6BVj0snKGGhHEefKW4qO/z+LolWw4KK0wf0IXAMCplHyJoyIiIiJqWUzkqV5c7a3h72oLADjFUfkmU6HWYO76GGw9kwZruQz/m9EbAzu0ljosk6NL5KOvZiO/lBeazNXmk8n44cBVAMCnU0IxIcQbAkSk5pUio6BU2uCIiIiIWhATeao3/Tz5lFxJ4zAXao2IV36Nw5a4VCjkAr6Z3hNDuXxag7RtbY92re1RoRGx73yW1OFQMzhzPQ/zNp0CADw7vAPu6uoFB6UVPLXXFxHHefJERERkQZjIU73pOtfzC3PjaTQiXt8Yh80nU2AlExA5rSdGBLGpXWMMZ3m92copKsdTq46jVKXB0E7umDu6k/53bRy0De/YiJOIiIgsCRN5qjd2rm8aGo2IN387jV+OJ0MuE/Dlwz0wpquX1GGZvJGVifye8xnQaLgMnblQa0Q8v+4kknNK0MbVDl8+1ANy2c3+EbpEnktjEhERkSVhIk/11s3XGYIAXM8rRWZBmdThmCRRFDH/zzNYezQRMgH4bEooxnf3ljoss9C7rSsclFbIKixnF3Mz8um2BOy7kAVbhRzfTu8FZztFtd9XHZEXRV7AISIiIsvARJ7qzUFphQ7uDgA4Kt8Qoiji/S1n8dOhaxAE4OPJoZgU5it1WGbD2kqGwR21jQJZXm8etp5OxbKoSwCAxZND0MXbqcY2vnaAQi4gp1iFpOySlg6RiIiISBJM5MkguvJ6lrEaRhRFLNp6Dt8fuAIAWHR/dzzQy0/iqMzPzXny6RJHQo11Ib0AL22IBQDMHhSIiaE+tW5nJQOCvBwBALG8wEhEREQWgok8GSTUX9vwLjYpV9pATMxn28/j2z2XAQAf3NsNU8PbSByReRrWWdv1/3RKPjLyuRyZqcovVeGpVcdRVK5G/3ZueH1c0G23D/GtbMTJRJ6IiIgsBBP5KiIjIxEcHIzw8HCpQzFaoVUa3nE+av18ufMCvtp1EQAwf0IwHukXIHFE5svD0Ua/usLuBJbXmyKNRsSL62NxOasIPs42+HpaD1jJb/9R1d1XW3LPSiEiIiKyFEzkq4iIiEB8fDyio6OlDsVodfF2grWVDDnFKly7USx1OEZvWdRFfLb9PADgrbu74NGBgRJHZP64DJ1p+3r3Rew4mw5rKxm+md4Lbg7KO95HNyJ/OiUPaq5YQERERBaAiTwZxNpKhq4+2tGvGJbX39Z3+y5jydYEAMCrYztj9uB2EkdkGUZUJvL7LmShrEItcTRkiN3nMvD5Du2Frw8mddP35LiTdu72sLOWo7hcjYsZhc0YIREREZFxYCJPBgvzdwHARP52Vh64gg/+OgsAmDuqE54Z1kHiiCxHNx9ntHZQorhcjaNXsqUOh+rpalYRnl93EqII/KdvG0wJ96/3feUyAd0rR+XZ8I6ILMHJxBxMXn4Qb24+JXUoRCQRJvJkMF0if5KJfK1WH76G+X/GAwCeG9EBL4zqKHFElkUmEzAiSNv0juX1pqGorAJPrTqOgtIK9GzjgncndDV4H6GV5yU2vCMic1aqUuOjv8/igeUHcexaDn4+koi8YpXUYRGRBJjIk8F6+LcCAJy9ns/S5Vusj07EW7+dBgA8NbQdXhzdSeKILNOIKvPk2ZTRuImiiFc3xiEhvQDujkosf6QXrK0M/2gK8dN1rmfDOyIyT0evZGPc0n34397L0IiAdWUj0OOJrD4jskRM5Mlg/q62cLW3Rrlag/jr+VKHYzQ2Hk/G65u0JW6PDwzE62ODIAiCxFFZpkEd3aGQC7h2oxiXs4qkDodu4//2XcZfcamwkglY9p+e8HSyadB+dCtqnE3lBUYiMi9FZRV45/fTmPLtIVzJKoKnkxIrZvbGvT18AADRV3MkjpCIpCBpIr9w4UKEh4fD0dERHh4euPfee5GQkFBtm0cffRSCIFT7169fvzvue+PGjQgODoZSqURwcDA2b97cXE/D4giCwHnyt/g9JgWv/BoLUQRm9A/A2/d0YRIvIQelFfoEugLQNlAj43TwYhYW/XMOAPDOhGCEt3Vt8L78WtmilZ0CKrWIs6kFTRUiEZGk9l/IwpjP9+KnQ9cAAA+F+2Pb3KEY2cUTvSvPmceZyBNZJEkT+T179iAiIgKHDx/G9u3bUVFRgTFjxqCoqPoI2tixY5Gamqr/9/fff992v4cOHcLUqVMxffp0xMbGYvr06ZgyZQqOHDnSnE/HojCRv+mvuFS8uCEWGhF4uE8bzJ/QlUm8ERjemcvQGbOU3BI8u/YkNCLwQE8/TO8X0Kj9CYLAefJEZDbySlR47dc4PLLiCFJyS+DXyharZ/XFogdC4GyrAAD9xc+Y5FxWIhFZICspH3zr1q3Vfv7hhx/g4eGB48ePY8iQIfrblUolvLy86r3fL774AqNHj8a8efMAAPPmzcOePXvwxRdfYO3atU0TvIVjIq/175k0vLDuJNQaEZN7+eHDe7tBJmMSbwxGdvHEB3+dxdEr2SgoVcHRRiF1SFSpVKXGf1cdR3ZRObr5OuHD+7o1ycWvED8XRCVkIjYpD+jfBIESEUlg59l0vLH5FNLzywAAM/sH4NWxQbBXVv/a3tbNDq0drJFVWI7TKXnoFdDwqiYiMj2SJvK3ysvTNilyda1+IoqKioKHhwdcXFwwdOhQfPjhh/Dw8KhzP4cOHcLcuXOr3XbXXXfhiy++qHX7srIylJWV6X/Oz9fO+1apVFCp6tcJVLddfbc3dV297AEA124UIz23CK721hJH1PTudEx3J2Ti2bUxqNCImBTqjQ8mdoFaXQE1L4obBT9na7R1s8PVG8WIOpeOsV09Le59aoxEUcQbm8/gVEoeWtkp8PVDoZBDA5VKY/C+bj2eXb0dAACxSTk8xiaK71HzwuNpmJzicnzwVwL+iEsFoE3UP7q3K8LbtgIg1vo69vB3wfazGTh8KQshPo7NHiOPqfnhMTUuhhwHQTSSls6iKGLSpEnIycnBvn379LevX78eDg4OCAgIwJUrV/D222+joqICx48fh1KprHVf1tbWWLlyJaZNm6a/bc2aNXjssceqJew68+fPx4IFC2rcvmbNGtjZ2TXBszNPH56UI6NUwJNBanRtZRR/Ri3mbK6A/zsng1oU0MNNg+kdNZBzIN7obLoqw55UGfq4a/CfDoYnitT09qUJ+PWKHAJEPBOsQSfnpjt35JcDbx+3ggARi/qoYSNvsl0TETWrmBsCfrkiQ6FKgAARw31EjPPTwPoO57Hd1wX8dk2Obq00eCKIn3NEpq64uBjTpk1DXl4enJycbrut0YzIP/vss4iLi8P+/fur3T516lT9/3fr1g29e/dGQEAA/vrrL9x///117u/WMk1RFOss3Zw3bx5efPFF/c/5+fnw9/fHmDFj7vgC6qhUKmzfvh2jR4+GQmEZJbxRJaewOSYV1l4dMX5kB6nDaXJ1HdODl27gh9UnoRY1GBPsgS+mhEAh5wIQxsj50g3sWXkcl4ptMHbsUKjVFRb3PjUmx6/l4LcjxwCIePWuzpg9qG2j9lfbe3TZxb1IzSuFb7d+6BvIMlNTY4mfpeaMx/POMgvKsGDLWfx7XtvPpaOHPRbe1w2hlUtq3olvch5++/YIUsqUGDt2WLNP7+MxNT88psZFVxleH0aRyD/33HP4448/sHfvXvj5+d12W29vbwQEBODChQt1buPl5YW0tLRqt2VkZMDT07PW7ZVKZa2j+wqFwuA/6Ibcx1T1DHDF5phUxF0vMOvnXPWYHr58A0/9fBJlFRqM6uKBr6c1bM1rahkDOnjA3lqOG0XlOJdRjODKKSGW9D41Fun5pXhufRwqNCLuCfHGf4d1aLKmkFWPZ5i/C1Lz0nAmtRCDOtV+zifjx/eoeeHxrEkURfwWk4IFf8Yjt1gFK5mAZ4a1R8SIDlBa1b+cKLSNK2wUMuQUq5CUV4YOHs1fXg/wmJojHlPjYMgxaJIMJDc3t0H3E0URzz77LDZt2oRdu3YhMDDwjve5ceMGkpKS4O3tXec2/fv3x/bt26vdtm3bNgwYMKBBcVLtwvxbAQBik3JhJDM0mtWxq9l4fGU0SlUaDOvsjsj/9GQSb+SsrWQY3NEdALvXS6m8QoNnfj6BzIIydPZ0xJLJIc22skNI5Xryccl5zbJ/IqLGSs0rwawfj2Hu+ljkFqvQ1ccJvz87EC+O6WxQEg8ACrlM34CY68kTWRaDs5DFixdj/fr1+p+nTJkCNzc3+Pr6IjY21qB9RUREYPXq1VizZg0cHR2RlpaGtLQ0lJSUAAAKCwvx8ssv49ChQ7h69SqioqIwYcIEtG7dGvfdd59+PzNmzNB3qAeAF154Adu2bcPixYtx7tw5LF68GDt27MCcOXMMfbp0G0HejlBayZBXosKVrKI738GEnUzMwaM/RKO4XI3BHVvjm0d6GfxhS9IYEcRl6KT23pYzOH4tB442Vvh2ei/YWTdfMZiuHDWWS9ARkZERRRFrjyZizGd7setcBqzlMrxyV2f8FjEQXX3qV0pfG90ydNFXs5sqVCIyAQYn8t9++y38/f0BANu3b8f27dvxzz//YNy4cXjllVcM2tfy5cuRl5eHYcOGwdvbW/9Pd6FALpfj1KlTmDRpEjp16oSZM2eiU6dOOHToEBwdb5YOJSYmIjU1Vf/zgAEDsG7dOvzwww8ICQnBypUrsX79evTt29fQp0u3oZDL0M1X+8FjzsvQnU7Jx4zvj6KwrAL92rnif9N7w0bBJN5UDAvSjsifSslDRkHNZpfUvDYcS8Lqw4kQBGDpQ2Fo29q+WR+vW2Uin5xTghuFPN5EZBySsovxyIojmLfpFArKKhDm74K/nh+EiOEdGt1np3dlIn/8GkfkiSyJwcMiqamp+kR+y5YtmDJlCsaMGYO2bdsanCjfqRzb1tYW//777x33ExUVVeO2yZMnY/LkyQbFQ4YL83fB8Ws5iEnKxf09b9/fwBSlFAHv/HgMBaUVCG/bCitmhsP2Ti1kyah4ONqgu68zTqXkYc/5LDRvGklVxSXn4q3fTgMA5ozshBFBzT9n3clGgXbu9ricWYS45DwMD6p7qVIiouam0Yj46dBVLN6agBKVGjYKGV4e0xmPDQyEvIka0/Vs4wKZoF0SOCO/FB5ONk2yXyIybgZfAmzVqhWSkpIAAFu3bsWoUaMAaJNyNRfQtji6eVnmOCJ/Pr0AkfFy5JVUoGcbF/zwWB/YK42iPyQZSFdeH3U+U+JILEdWYRn+u+o4yis0GNXFE8+NaLmVLcIq58mzvJ6IpHQ5sxBT/3cI8/+MR4lKjb6Brtj6whDMHtyuyZJ4AHC0UaCzl3aVpWMclSeyGAYn8vfffz+mTZuG0aNH48aNGxg3bhwAICYmBh06mN8SZHR7ukT+bGo+SlXmcyGnVKXG4z+eQFGFgO6+Tlj5eB84MIk3WbpE/sDFG6jgMrvNrkKtwXNrTuJ6XinatbbHZ1NDm31JpKpCKsvr2fCucVJyS6DRmH8jU6KmVqHW4Ns9lzBu6T5EX82BvbUc79/bDWuf6Nds04vC22obEHOePJHlMDiR//zzz/Hss88iODgY27dvh4ODAwBtyf0zzzzT5AGScfNrZYvWDtZQqUWcuV7/dQ+N3fFrOUgvKIOjQsQPM3vByYbLcZiy7r7OaO2gRFG5GpfyWy6htFSLt57Docs3YG8tx7fTW/79E1J5gTEu2TJW1GgOPx68ioGLdmHad4dRVmE+F2mJmltCWgEeWH4QC/85h7IKDQZ3bI1/5w7B9H4BzXpBk/PkiSyPwUOM5eXlePnll2vcbg4d4SMjIxEZGckpAgYQBAFh/i7YcTYDMUm56BXQSuqQmsShSzcAAJ2dRTjbMok3dTKZgGGd3fHr8WScyWUi35z+iL2O/9t3BQDwyYOh6OjZMmsaVxXs7QQrmYCswnKk5JbAr5Vdi8dgyvZdyMSCP88AAA5fzsYbm07jkwebb8lAInOgUmuwPOoSvtp1ASq1CEcbK7x9TzAe7OXXIu8d3Yj8mev5KCqr4FRAIgtg8Ii8p6cnHn/8cezfv7854pFUREQE4uPjER0dLXUoJsUc58kfvqxN5Ds6czTPXAzvrC2vT2Ai32zOpubjtV/jAABPD2uPcd29JYnDRiFHkLf2AgLL6w1zJasIET+fgEYE+ga6QiYAG08k45s9l6UOjchoFZSqcN+yA/hs+3mo1CJGdfHAjheHYkpv/xa7AObtbAtfF1uoNaJZfR8joroZnMivXbsWeXl5GDlyJDp16oRFixbh+vXrzREbmYgwf+1V4Jgk8yjnKi6v0DfJ6ujERN5cDGjvBkEA0koEpOaVSh2O2ckrVuGpVcdRolJjcMfWeHlMZ0njCWHDO4Pll6ow+8do5JdqG3z+NKsP3p3QFQCw5N9z2Ho6TeIIiYzT7zHXcTolH862Cix9KAz/N6M3PCXoHN+b8+SJLIrBifyECROwceNGXL9+HU8//TTWrl2LgIAA3HPPPdi0aRMqKiqaI04yYiH+zhAEICnbPNZtPn4tByq1CB9nG7gqpY6Gmkore2t099F29T1YOXWCms5Lv8QiMbsYfq1s8eVDPZq0I3NDhOoa3iVxRL4+1BoRz689iUuZRfB2tsE303tBaSXHzAFtMaN/AEQRmLs+BqdT+HoS3WrH2XQAwJND2mFSmK9k01B08+SPXTWPgRUiuj2DE3kdNzc3zJ07F7Gxsfjss8+wY8cOTJ48GT4+PnjnnXdQXFzclHGSEXOyUaC9u7bpoTmUc+nmx/dt5wpOCTUvAzu4AQD2X2Qi35Su3SjCjrPpkMsEfDu9F1rZW0sdkn5E/lRKHjuv18PirecQlZAJG4UM/zejNzwcb44mvnNPMAZ3bI0SlRqzfoxGGitaiPQKyypwsPIzZUywp6Sx6ObJn0zMQYWaS7QQmbsGJ/JpaWlYsmQJunTpgtdffx2TJ0/Gzp078fnnn2Pz5s249957mzBMMnbmNE/+UOX8+H6B5tG4j24aVJnIH7h0g8ldE9oerx2N6hvoiq4+zhJHo9XRwwE2ChkKyypwOatQ6nCM2sbjyfjfXu0c+I8nh6Kbb/VjaCWX4etpPdHBwwHp+WWY/VM0istZfUcEAHvPZ6JcrUGAmx06eDhIGksnD0c42lihqFyNc2kFksZCRM3P4ER+06ZNmDBhAtq0aYM1a9YgIiICKSkpWL16NYYPH47//Oc/WLduHaKiopohXDJW5pLIF5VV6Jtj9Q10lTgaamphfi6wlonIKVYhPtV8lkuU2rYz2kRe6tGoqqzkMnSvTEhjWV5fpxOJOZi36RQA4LkRHTAh1KfW7ZxtFfh+Zjha2SlwOiUfL66P5cUwIgA7Ki9kju7iKfnKDjKZoF89iPPkicyfwYn8Y489Bh8fHxw4cAAxMTF49tln4eLiUm2bdu3a4c0332yqGMkEVE3kTfnLXfTVbKg1Ivxdtd1fybxYW8n0KxHsu5AlcTTmIauwDMeuab8wju7qJXE01enK6+PY8K5WqXkleGrVcZSrNRgT7Im5ozrddvs2bnb434zesJbLsPVMGj7ZltBCkRIZpwq1BrsSMgAAo43kQmY458kTWQyDE/nU1FR8++23CA8Pr3MbW1tbvPvuu40KjExLkJcjbBQyFJRW4HJWkdThNJiurL5/OzeJI6HmEqRP5DMljsQ87DqbAY0IdPN1MrqLXyGVDe9iuQRdDSXlajz503FkFpQhyMsRn08Ng6weDQrD27pi4f3dAQDLoi7h1+PJzR0qkdE6di0HucUquNgp9CPhUutdGcexa9kQRdMdWCGiOzM4kbezs9P/f0lJCfLz86v9I8tUtYzVlMvrD1/Wjiz2YyJvtjq7aL/YHLuag5JytcTRmL5t8dolycYEG9doPACEVo7Ix1/PR3kFGz/piKKIVzfG4VRKHlztrfF/M3rDXmlV7/s/0MsPEcPbAwDmbYrD0Sss4SXLpOsPMiLIA1byBredalKh/i5QyAWk55chOadE6nCIqBkZfNYpKirCs88+Cw8PDzg4OKBVq1bV/pHlulleb5rlXAWlKv3SSv3bM5E3Vx42gLezDcrVGhy5wu71jVFcXqGfojCmq3GUlVYV4GYHZ1sFytUaJLDxk96yqEv4M/Y6rGQClv2nJ/xd7e58p1u8NLozxnXzgkot4qlVx3DthulWYhE1hCiK+kTemPqD2Cjk+oaVnCdPZN4MTuRfffVV7Nq1C8uWLYNSqcR3332HBQsWwMfHBz/99FNzxNhiIiMjERwcfNtpA1S3MH/thRxTHZHXzY9v62YHb2fjKhGmpiMIN7vXc5584+w9n4WyCg3auNqhs6ej1OHUIAhClfL6XGmDMRLbzqTh43+1c9vfm9StwdVHMpmAz6aEobuvM3KKVZj14zHklaiaMlQio3YhoxCJ2cWwtpJhcEd3qcOpRjdPPprz5InMmsGJ/J9//olly5Zh8uTJsLKywuDBg/HWW2/ho48+ws8//9wcMbaYiIgIxMfHIzo6WupQTFJYGxcAwLnUApSqTK9kmWX1lmNQZcXFfibyjXKzrF76bs11CWXDO71zafmYuz4GADCjfwCm9W3TqP3ZWsvx3cze8HKywcWMQjy75gTXriaLoRuNH9jezaCpKS1BN0/++DWOyBOZM4MT+ezsbAQGBgIAnJyckJ2tPUkMGjQIe/fubdroyKT4ONvA3VGJCo2oL1E3JYcuVTa6Y1m92evf3hWCACSkFyA9v1TqcExShVqDnWe13ZrHGFm3+qp0I/JxFt7wLruoHLN/PIaicjUGtHfD2/cEN8l+PZ1s8N3M3rBVyLHvQhbm/3mGDbbIImyrTORHGVFZvY6u8d759ELkFpdLHA0RNReDE/l27drh6tWrAIDg4GBs2LABgHak/tZl6MiyCIJgsuvJ55WocOa69os+R+TNXys7a31zRpbXN8zRq9nIK1HB1d7aaLo11ya08px0Pr0AxeUV0gYjEZVag6dXH0dyTgkC3OwQOa0nFE3YmKubrzO+eCgMggCsPpyIHw9ebbJ9ExmjjPxSxFZ+zxnVxfgSeTcHJdq52wMAjl9jeT2RuWrQOvKxsbEAgHnz5unnys+dOxevvPJKkwdIpkWXyJ80sUQ++ko2NCLQrrU9PJ1spA6HWsDgjq0BcBm6htp2RjsaNTLIA/J6LFsmFU8nG3g6KaERgdMplrmyyvw/zuDIlWw4KK3wfzN6o5W9dZM/xl1dvfDa2CAAwHtb4rG7cm1tInO0o7IaKdTfxWi/M4QHcJ48kbkzOJGfO3cunn/+eQDA8OHDce7cOaxduxYnTpzACy+80OQBkmnpoRuRT8yVNA5D6daP78eyeosxqIO2OdGBi1nQaFgKbIhq3ZqNuKxex5Lnya86fA0/H0mEIABLHwpDp2ZsSvjUkHZ4sJcfNCLw3JqTXCmAzNaOs9rz3+guHhJHUrfebSvXk2fneiKz1ejaujZt2uD+++9HaGhoU8RDJq67nzMEAUjJLUFmQZnU4dSbfn48y+otRs8AF9hZy5FVWI6zaZY5UttQZ67nIyW3BLYKub6ywZjpyutjLWye/MFLWZj/xxkAwKt3BWFkM5cAC4KAD+/rjj6Brigsq8CsH6ORVWg6nwNE9VFUVoH9F7VTskYHG++FTF3n+rjkPJNsQExEd2ZQIq/RaPD999/jnnvuQbdu3dC9e3dMnDgRP/30E5vbEADA0UaBDu4OAExnnnxu8c1Erm87V4mjoZaitJLr+yFwnrxhdE2ehnRqDRuFXOJo7uxmw7tcaQNpQdduFOGZn09ArRFxb5gP/ju0XYs8rrWVDN8+0gsBbnZIzinBU6uOM4kgs7LvQibKK5fd7OTpIHU4dQpws0NrB2uUqzUm2YCYiO6s3om8KIqYOHEiZs+ejZSUFHTv3h1du3bFtWvX8Oijj+K+++5rzjjJhNxseGca87KOXMmGKAIdPBzg4Wicc92oeehGk7kMnWG2ndEtO2e8o1FVhfi6AACu3ShGTpH5d3AuKFVh9o/HkFusQqifMxY9ENKiywO2srfGipnhcLKxwvFrOXh9Yxwv9pPZ2B6vnR8/qovxLrsJaCtkenOePJFZq3civ3LlSuzduxc7d+7EyZMnsXbtWqxbtw6xsbHYsWMHdu3ahZ9++qk5YyUToVtP3lRG5FlWb7l0ifzRq9koKeeoYX0k3ijGubQCyGUCRgQZ7/zQqpztFAhsre3gHGfmI1NqjYi562NwIaMQHo5KfDu9tyRVEx08HLD8kV6QywT8FnMdX++62OIxEDW1CrUGu85Vzo83wmXnbsV58kTmrd6J/Nq1a/HGG29g+PDhNX43YsQIvP766/j555+bNLiWFhkZieDgYISHh0sdiknTjcjHJeWZRBOxw7pGd0zkLU57dwd4O9ugvEKDo/yiUy/b4rWj8X3aujZL9/Pmoi+vN5ELjA316bYE7DibAWsrGf43oze8nKWrMhrYoTXen9RNG9f289gSd12yWIiawvFrOcgpVsHZVoHwtsa77KaObp788cQck/g+RkSGqXciHxcXh7Fjx9b5+3HjxumXpTNVERERiI+PR3R0tNShmLTOno6wVchRUFaBS5mFUodzW9lF5ThX2Vm5H+fHWxxBEKqU13MZuvrYpu9Wb/yjUVWFVHauN+eGd7/HpGBZ1CUAwJIHQvQXVaU0rW8bzBoUCAB4aUOsyVRqEdVG161+RJAHrOSN7hfd7IJ9nGCrkCO3WGX038eIyHD1PgtlZ2fD07PuL26enp7IyeEcHAKs5DJ099WOfhn7evJHKkfjO3s6ws1BKXE0JIVBHbXL0LHh3Z1lF5XrSzRNoay0qtDKEfnY5FyznK8dm5SLV3+NAwD8d2h73NvDV+KIbnpjfBeMCPJAWYUGs388hpTcEqlDIjJY1WU3TeX8p5DL9Bf0OE+eyPzUO5FXq9WwsrKq8/dyuRwVFRVNEhSZPlOZJ3+zrJ6j8ZZqUIfWEATgXFoBMvJLpQ7HqO08mw6NCHT1cYJfKzupwzFIVx9nyGUCMgvKkGZmxzk9vxRPrjqGsgoNRgR54JW7OksdUjVymYAvH+6BIC9HZBWWYfaPx1BUxu8LZFouZRbi6o1iWMtlGNLJXepw6i2c8+SJzFbdmfktRFHEo48+CqWy9lHLsjKuFUs36TvXJ+ZKGsedHKpM5Pu35/x4S+Vqb41uPs44lZKHfRey8EAvP6lDMlr6snoT6VZfla21HJ08HXE2NR+xSXnwdraVOqQmUapS48lVx5GeX4aOHg5Y+lAY5DLj66TtoLTCdzN7497IAzibmo8X1sXg2+m9jDJWotrozn/927vBQVnvr8+S6105Tz76GhN5InNT7xH5mTNnwsPDA87OzrX+8/DwwIwZM5ozVjIhukQ+Ib3AaLuBZxWW4Xy6ds5Y30Am8pZMP0/+Isvr61JSrsa+yj4CpjY/XifUzNaTF0UR8zadQmxSLpxtFfhuZm842iikDqtOfq3s8L8ZvWFtJcOOs+lYvPWc1CER1ZupldXr9GjjApkAJGWXIN3MqpGILF29Lyn+8MMPzRkHmRlvZxt4OCqRUVCGUyl56BNofKXrRy5rr04HeTmaVPdtanqDOrbGsqhL2HchCxqNCBlHCWvYeyETpSoN/FrZIsjLUepwGiTEzwXropMQZyYN777dexmbT6ZALhOw/D89EeBmL3VId9SzTSt88mAonl97Ev/bexntWtvjoT5tpA6L6LYyCkr1UwVHdTGtRN7RRoEgLyfEp+bj2NUc3B3iLXVIRNREjL/lJpkkQRBultcnGWeDlUOXtaOvLKunXgGtYKuQI6uwTL+KAVW37czNsnpBMM0LHSFVGt6Z+lJMu87dHNF+d0IwBnRoLXFE9Tcx1AdzRnUEALz122kcvMRKGDJuu85mQBS15xApl3RsKN08+WjOkycyK0zkqdkYe8O7Q5e4fjxpKa3k+oaH+y9yGbpbVag12HnONJedq6qzlyOUVjIUlFbg6o0iqcNpsAvpBXh+bQxEEXi4TxtM7xcgdUgGe2FkR0wM9UGFRsTTq0/gMpfGIiOmL6s3sdF4Hd08+WOcJ09kVpjIU7Mx5oZ3GQWluJRZBEEA+nF+PIHL0N1O9NUc5Bar0MpOgd4BraQOp8EUchm6+jgBgMmW1+cUlWP2T8dQWFaBPoGuWDCxq0lWSAiCgCWTQ9CjjQvySlSY9eMx5BaXSx0WUQ3F5RX6/imjTGx+vE7vyhH5+Ov5KOSKEURmg4l8FZGRkQgODkZ4eLjUoZiFED8XCAJwPa/U6Jb1Olw5Pz7Y2wnOdsbbHIpazpDKhndHrmSjVGWcDRqlsi0+DQAwsosnrOSm/bER4ucCQFteb2pUag0i1pzAtRvF8Gtli+X/6QlrK9M9HjYKOf43vTd8XWxxJasIT68+AZVaI3VYRNXsu5CFsgrT7g/i7WwLXxdbaETjHFwhooap1zeAnj17IidHO8/5vffeQ3FxcbMGJZWIiAjEx8cjOjpa6lDMgoPSCp08tB96J42svJ5l9XSrDh4O8HKyQXmFhvMIqxBFscr8eNMcjaoq1F/Xud70RuQ/2BKPg5duwM5ajv+b0RtuDrUvB2tK3B2VWPFob9hby3Ho8g3M//MsRNNuX0BmZkdlWf2oLp4mWf2iw3nyROanXon82bNnUVSknU+4YMECFBZyLhvVz82Gd7mSxnGrI7r145nIUyVBEPTL0LG8/qb41Hyk5JbARiHD4MrpB6ZMNyJ/OiXPpEZ/1xxJxI+HrgEAPpsShi7eThJH1HSCvJzw1bQekAnAhuMp2HhFZtI9DMh8qDUidp3LAGD6FzI5T57I/NRr+bmwsDA89thjGDRoEERRxCeffAIHB4dat33nnXeaNEAybWFtXLD+WJJRlXKl55ficlYRZAIQboTL4pF0BnVsjV+OJ2Pv+Uy8Mb6L1OEYBd1o/JCO7rC1lkscTeMFutnDUWmFgrIKnE8vQFcfZ6lDuqOTiTl45/fTAICXRnfC2G5eEkfU9EYEeeLNu4Px/pZ47EuXYfQXB9CjjQvu7+GLe0J8uEQoSeJEYg5uFJXDycbK5L8vhFcm8icTc1Gh1pj8NCkiqmciv3LlSrz77rvYsmULBEHAP//8AyurmncVBIGJPFWjG5GPS86FWiNCbgTrc+vK6rv6OMPZlvPj6aZBlUt4nUsrQEZBKTwcTW+Zoaa2LV7Xrd48kkeZTECIvzMOXLyBuOQ8k0jkI3dfRIVGxLhuXnh2RAepw2k2jw9sCy9HBb7+5yQS8mQ4mZiLk4m5eG9LPIZ19sD9PXwxoosHlFamf0GJTIOurH54kAcUJp74dvRwgJONFfJLK3A2tQDd/Yz/3EdEt1evRL5z585Yt24dAEAmk2Hnzp3w8PBo1sDIPHTydISdtRxF5WpczChEZyNoFHNYV1bP9ePpFm4OSnTzdcLplHwcuJiF+3r4SR2SpJKyi3E2NR8yARgZZD7n/BA/l8pEPhcP92kjdTi3dT23RF/a+/JdnU16ju6dCIKAMcGeqLiqQfjg4fj7TAY2n0zBmev52B6fju3x6XCyscLdIT54oKcvegW0MuvXg6SnX3bOxMvqAe1FzF4BrbA7IRPRV7OZyBOZAYMvL2o0GibxVG9ymYDuvtoPi5ikHImj0TrE+fF0G4M6VC5Dd57z5HVfYvsEuppVaXNo5RfY2CTjb3i34VgSNCLQN9AV7d1rn9JmjtwdlZg9uB3+en4wts0dgv8ObQ8vJxvkl1Zg7dFETP7mEIZ+HIXPtp/HlSzOp6emdymzEJeziqCQCxjayfT7gwCcJ09kbhpUJ3Tp0iU899xzGDVqFEaPHo3nn38ely5dMng/CxcuRHh4OBwdHeHh4YF7770XCQkJ+t+rVCq89tpr6N69O+zt7eHj44MZM2bg+vXrt93vypUrIQhCjX+lpca1BJqlCGvjAsA4Gt5dzy3BtRvFkMsE/bqqRFXplqHbdzELooW3z9YtOzcm2DzK6nV0De8S0gtQUm68Sw1WqDVYH50EAJjW17grB5pTJ09HvD4uCAdeH4GfZ/fFAz39YG8tR2J2Mb7ceQHDP4nCfcsOYNWhq8gp4lr01DR0FzL7tXODo415TMPTzZOPvppj8Z9vRObA4ET+33//RXBwMI4ePYqQkBB069YNR44cQdeuXbF9+3aD9rVnzx5ERETg8OHD2L59OyoqKjBmzBh9h/zi4mKcOHECb7/9Nk6cOIFNmzbh/PnzmDhx4h337eTkhNTU1Gr/bGw431UKPSrnyZ80goZ3urL6br7OZvPBTE2rV9tWsFHIkFlQhoT0AqnDkUxOUTmOXtGO2phDWWlV3s42cHdUQq0REZ9qvKPye85nIjWvFK3sFLjLTHoUNIZcJmBgh9b4dEooot8ahaUPhWFoJ3fIBO3ny9u/n0Gfj3bgiZ+O4Z9TqSirMN6LNGT8dIm8qXerryrEzxnWcu3nW1J2idThEFEj1WuOfFWvv/465s6di0WLFtW4/bXXXsPo0aPrva+tW7dW+/mHH36Ah4cHjh8/jiFDhsDZ2bnGxYGvvvoKffr0QWJiItq0qXuEQhAEeHnxi48xCPPXjnyfTy9AUVkF7JUG/9k1GV2jO5bVU12UVnL0a+eGqIRM7DufhSAv81nmyxA7z2VAIwLB3k7wd7WTOpwmJQgCQv2cseNsBmKT8tArwDi7Ua85kggAeKCnH2wUbPBWlZ21FSaF+WJSmC8yCkrxR8x1bDqRgvhUzqenxssqLMOJRO10wJFdzCeRt1HI0c3XCScScxF9NRtt3Mzr3E5kaQzOqM6ePYsNGzbUuP3xxx/HF1980ahg8vK0IyOurnV/qcrLy4MgCHBxcbntvgoLCxEQEAC1Wo2wsDC8//776NGjR63blpWVoaysTP9zfn4+AG1pv0qlqlfsuu3qu70lcbOTw9NJifT8Mpy8dgN9JVzC5dAl7bzn8ADnOx4rHlPzU99jOqCdK6ISMrHnfAYe7e/fEqEZnX9PpwIARga1Ntr3QGPeo129HbHjbAZiEnOgUhlfU8PUvFLsTtA2uXuwp4/RHoOm1pBj2spGjpn9/DGznz/Opxfgt5hU/BGXivT8Mqw9moi1RxPh38oWk0K9MSnMG23d7JsrfLqFqX6ObjudClEEuvo4wt3eyuTiv52ebVxwIjEXR69kYWKI4RcpTPWYUt14TI2LIcdBEA2cJOPv74/PPvsMDz74YLXbN2zYgJdffhmJiYmG7E5PFEVMmjQJOTk52LdvX63blJaWYtCgQQgKCsLq1avr3Nfhw4dx8eJFdO/eHfn5+Vi6dCn+/vtvxMbGomPHjjW2nz9/PhYsWFDj9jVr1sDOjlcrm8KKBBnismWY2EaNkb7SzMu6UQq8d9IKMkHEonA1lBzgojqkFgOLYq2gEEQs7KOGwrRXHTJYuRp445gcKo2AV0Iq4GeGec/ZHAHfnJPD3UbEWz2MrwT7nyQZtibL0MFJxHNdjS8+Y6cRgQv5Ao5lCoi9IaBMc3M0vq2DiN7uGvR0E2HPGVZUi/87J8PpHBnG+akx1t+85pKfyhbwXYIcnrYi3gjjuYXI2BQXF2PatGnIy8uDk9Ptq0INHpF/4okn8OSTT+Ly5csYMGAABEHA/v37sXjxYrz00ksNDvrZZ59FXFwc9u/fX+vvVSoVHnroIWg0Gixbtuy2++rXrx/69eun/3ngwIHo2bMnvvrqK3z55Zc1tp83bx5efPFF/c/5+fnw9/fHmDFj7vgCVo1v+/btGD16NBQKfjO4VbLjFcRtu4BSB2+MHx8mSQwbT6QAJ88g1M8F903oe8fteUzNT32PqSiK+OHyXqQXlKF1l74YaGFLFe44mwHV0Rj4utjgicmDjbYkuTHv0X5F5fhmURQySwUMGj4aTrbG8x6vUGuw8LN9AMrwzF0hGB/iLXVILaY5zrvF5RXYcTYTv8dex/6LN3C1UMDVQjl+TxQwtGNrTArzQe8AF6jUIsorNCiv0KCsQoNytQZlFeqbP1e7/ebPqiq332lb7f7VKFeLcLO3xn+HBGJsV0/IZMb5HmssU/wcLSlX47VjuwFo8N+JAxHsbV7Tq/oVleO7RVFILxHQf9gotLIzbEUSUzymdHs8psZFVxleHwYn8m+//TYcHR3x6aefYt68eQAAHx8fzJ8/H88//7yhuwMAPPfcc/jjjz+wd+9e+PnVLHFUqVSYMmUKrly5gl27dtU7udaRyWQIDw/HhQsXav29UqmEUqmscbtCoTD4D7oh97EEvdq6AbiAuOR8yV6fo9dyAQD927c2KAYeU/NTn2M6qKM7Np5IxqHLORgWZFn9NnYmaKegjOnqBWtr4192riHvUU8XBdq42iExuxhn04sxqHK1AmOw50I60vLL0MpOgbtDfaGwsrzyoaY87zorFHigdxs80LtNjfn0O85lYse5zCZ5HENlFJThhQ1x6O7rjNfGBhnV32BTM6XP0agL2ShVaeDrYosQf1ejvZDZUJ4uCrR3t8elzCLEpRRiVAOb+ZnSMaX64TE1DoYcA4MTeUEQMHfuXMydOxcFBdqOzo6OjobuBoB21Ou5557D5s2bERUVhcDAwBrb6JL4CxcuYPfu3XBzM3xkTBRFxMTEoHv37g2Kkxqvu68zZAKQll+KtLxSeDm37AoCoijiyGVtB+7+Fja6Sg0zpFNrbDyRjL0XsjBP6mBaUIVag51ndd2azfsCRoifMxKzixGbnGtUSdTao9opapN7+UFpgUl8c/JwtMHswe0we3A7JKQVYNPJZPwRcx2peaVQyAUoreSwtpJBaSW75b9yWMtrua3yZ2Udt9f+swwKuQw7z2bgf3sv4VRKHh5ZcQSDOrTGa2OD0N3PWeqXyaLtqOxWPzrY0+ySeJ3wtq64lFmE6GvZDU7kiUh6jWof3tAEXiciIgJr1qzB77//DkdHR6SladcsdnZ2hq2tLSoqKjB58mScOHECW7ZsgVqt1m/j6uqqHymaMWMGfH19sXDhQgDAggUL0K9fP3Ts2BH5+fn48ssvERMTg8jIyEbFSw1nr7RCJ09HnEsrQExSDsY6t2ypaFJ2CVJyS6CQC+gVwPXj6c4GdtAmdmdT85FZUAZ3x5pVO+bo2LUc5BSr4GKnQHhb836vhPq5YEtcKuKSc6UORe96bom+yd1DfSx37fiW0NnLEfPGdcHrY4Mgimjx8vZuvs74T782+HrXRfx85Br2X8zC/q/34+4Qb7w8pjMCW5thcwojp9aI2HlOm8iPMqNu9bfq3dYV66KTcOxqjtShEFEjSNrCafny5cjLy8OwYcPg7e2t/7d+/XoAQHJyMv744w8kJycjLCys2jYHDx7U7ycxMRGpqan6n3Nzc/Hkk0+iS5cuGDNmDFJSUrB371706dOnxZ8j3dSjjQsA4GRSbos/9qHL2lLhUD8X2FlLt/wdmY7WDkr93MgDF7MkjqblbDuj/RI7MsgTVnLz7vIXUjnyGZtkPGvJr49OgkYE+rVzRXt3B6nDsQiCIEg2R721gxLzJ3bFrpeG4b4evhAE4K+4VIz+bA/e+u0UMgpKJYnLUsUk5SCrsByONlbo2844l6VsCrqLtKeS81CqYsM7IlMlaUZzp4b5bdu2veM2ABAVFVXt588//xyff/55Y0KjZhDm74K1R5MQk5jb4o99mGX11ACDO7VGfGo+9l7IxL09fKUOp9mJooht8dqqpzFdzXc0SqdblSk/Gfml8HBq2Sk/t6pQa7A+OgkA8DBH4y2Kv6sdPp8ahicGt8OSf88hKiETqw8nYuPxFMwaFIgnh7aDkw3nrja37fHaaphhnT2gMOMLmW1c7dDaQYmswjKcSslDeFvzvWhBZM7M9yxFRifMv/IKcEoe1JqWW85FFEUcunQDANC/HRN5qr8hHd0BAPsvZNXroqKpO5tagOScEtgoZPrnbs7slVbo6KGdIhabLP2ofFRCJtLyS9HKToGx3cy7PwHVLtjHCSsf64N1T/ZDmL8LSlRqfL37IoYu2Y3v9l3m6Gkz2155IXO0mc8bFwRBPyoffTVb4miIqKEMSuRVKhWGDx+O8+fPN1c8ZMY6eDjA3lqO4nI1zqcXtNjjXr1RjLT8UljLZejJ+fFkgF4BrWCjkCGjoAzn0wulDqfZba9s8jS4oztsrS2jyZquvN4Y5smvYZM7qtSvnRs2PzMA3zzSC+3d7ZFTrMIHf53FyE/34NfjyS16MdxSXM4sxKXMIljJBAzrbP4XMntXjsJznjyR6TIokVcoFDh9+rTZdvGk5iWXCQjxcwEAxLTgPPnDl7Wj8WFtXGCj4Jdjqj8bhRx9ArVVHPsuSLNEVUvSl9Wb+WhUVSH+LgCkH5FPyS1BVGWTO5bVE6AdNR3bzQv/zhmCRfd3h5eTDVJyS/DyL7EYv3Qfdp5Nt4hKoZayo3K1jn7t3CxiGoNuRP7Y1WxoeGGIyCQZXFo/Y8YMrFixojlikVxkZCSCg4MRHh4udShmK6yy4V1LzpNnWT01xpDKZcn2XTDvhnfJOcU4cz0fMgEYacbdmm8VWmVEXsqkqGqTu3ZsckdVWMlleKhPG0S9MgyvjwuCk40VEtILMOvHY5jy7SEcv8bS6Kawvcqyc5Yg2NsJdtZy5JdW4GKm+VecEZkjg5vdlZeX47vvvsP27dvRu3dv2NtXXx7ls88+a7LgWlpERAQiIiKQn58PZ2eu49ocwipHv1pqRF4URf2IfD8m8tQAgzu6AziLI1duoFSlNtuqDt2X2PC2rnC1t5Y4mpYT5OUEa7kMucUqJGYXI8Ct5Zf8qlBrsKGyyd20vgEt/vhkGmwUcvx3aHs8HN4Gy/ZcxMoDVxF9NQcPLD+EUV088erYzujk2bhlgS3VjcIyHL+mLTG3lHXVreQyhPm74OClG4i+ms2/HSITZPCI/OnTp9GzZ084OTnh/PnzOHnypP5fTExMM4RI5qRHZSJ/PqMAhWUVzf54l7OKkFFQBmsrmX75OyJDdPJ0gIejEqUqjf6LnjnSLTtnKaNROtZWMnTx0S4zKFV5/e7KJneu9ta4ywJWC6DGcbZTYN64Loh6ZRgeCveHTNCWhY/9Yi9e/iUWKbklUodocnady4BG1I5S+7rYSh1Oi+E8eSLTZvCI/O7du5sjDrIQHk428HG2wfW8UsQl52JA+9bN+ni6svpebVqZ7UgqNS9BEDCoY2tsOpGCvRcyMbBD8/7NSiGnqBxHKzsXjwm2vG7poX7OiE3KRVxSLiaG+rT4469lkztqAG9nWyx6IASzB7fDJ/8mYOuZNPx6PBl/xF7HzP4BeGZYB7SyoOqaxrC0snoddq4nMm0NXn7u4sWL+Pfff1FSor3yy4YrVF/6efItUF7PsnpqClWXoTNHu85lQK0REeTliDZudlKH0+J0TTjjJBiRr9rk7qFw/xZ/fDJ9HTwc8M30Xtj0zAD0DXRFeYUG/7fvCoYs2Y3I3RdRXN781W+mrFSl1vdAsbREvkebVpAJQHJOCdLySqUOh4gMZHAif+PGDYwcORKdOnXC+PHjkZqaCgCYPXs2XnrppSYPkMyPfp58Mze8086P115l7t+eiTw1nG4U/sz1fGQVlkkcTdPTd6vvanmj8cDNhnenUvJQoda06GPrmtz1b+fGJnfUKD3btMK6J/vhh8fCEeTliIKyCnz8bwKGfhyF1YevQdXCf9um4sDFLJSo1PBxtkHXymk2lsJBaYUu3trnfIxNE4lMjsGJ/Ny5c6FQKJCYmAg7u5sjN1OnTsXWrVubNDgyT2H+2lKumKTm7RJ9MaMQWYVlsFHIEOrP5oXUcO6OSv2XnQMXzWtUvqRcjT3ntUvrWdKyc1W1c3eAg9IKJSp1i3ZvrlBrsD5aW1b/cF8uOUeNJwgChnf2wN/PD8bnU0Ph18oWmQVleOu30xjz+V5sPZ0qdYhGR1dWPyrY0yKXVw7nPHkik2VwIr9t2zYsXrwYfn5+1W7v2LEjrl271mSBkfnq7usMuUxARkEZUpuxlEtXVt8roBXnnVKjmesydPsvZqFUpYGvi63FjUbpyGUCuvlqn3tcUsuV1+9OyER6fhmb3FGTk8kE3NfDDztfGop3JwTDzd4aV7KK8N/VJ7hcXRUajYgdZ7VTW0ZZ0LKbVfXmPHkik2VwIl9UVFRtJF4nKysLSqWySYIi82ZrLUfnymVOmnOe/KHLXD+ems7gynny+y5kmlVPkG1ntGX1oy10NEontHKefGxybos95poj2ovfbHJHzUVpJcdjAwOx59XhGFA5xUw35YyAmORcZBWWwVFpZbG9dHoHaEfkz6bmt8hqQqZi34VMTF9xBEnZxVKHQlQngxP5IUOG4KefftL/LAgCNBoNPv74YwwfPrxJgyPz1dwN7zQazo+nptW7bSsorWRIzy/DhYyWK79uThVqDXac1ZaVjrHwEeGQFk7kU3JLEFU5pYFN7qi5OSit9Bcjz6UVSByN8dhRWVY/tLM7rK0a3P/ZpHk528CvlS00InAykeX1Op9uO499F7Lw9a6LUodCVCeDz1off/wxvv32W4wbNw7l5eV49dVX0a1bN+zduxeLFy9ujhjJDDV3w7sLGYXILiqHrUKO7r4uzfIYZFlsFHL0CdSOXJhLef3xaznIKVbB2VaBPpXzJC1VSGXDu3OpBShVqZv98dYfTYTIJnfUgjp7af/OEtLyJY7EeFjqsnO30s2Tj+Y8eQBAdlG5/qLulrjrKGKlAhkpgxP54OBgxMXFoU+fPhg9ejSKiopw//334+TJk2jfvn1zxNhiIiMjERwcjPDwcKlDMXs9KhP55uoSfeiSNtHq3baVxV5lp6Y3pEp5vTnYVvkldmQXD1jJLft94tfKFm721qjQiDib2ryJToVag/XHkgAA09jkjlpIZy9tH4jLmUUor2AH+6tZRbiQUQgrmYBhnT2kDkdSunnyxzhPHgCw93wmdDPoisrV+PsUm0SScbJqyJ28vLywYMGCpo5FchEREYiIiEB+fj6cndnlvDm1d3eAo9IKBWUVSEgvQFefpn299fPjWVZPTWhwp9bA39pGimUVapOe1yyKon40akywZS47V5UgCAjxc8buhEzEJeehR5tWzfZYu85l6JvcWfqUBmo5Ps42cLSxQkFpBS5lFupX4rBUumlFfdu5wtlWIXE00tKNyJ9MzIVKrYHCwi/sRiVoGyC62lsju6gcvxxPxoO9OQWKjE+D3qk5OTn45JNPMGvWLMyePRuffvopsrN5FY/qTyYTEFK5JFxTz5PXaEQcuaL9e7TU5jXUPDp7OsLdUYlSlQbHTbwEMSG9AInZxVBayTCkU2upwzEKLTVPfu1R7ZJzD7LJHbUgQRD0jWYTOE9eX5Fkqd3qq+rg7gAnG+0SnPHXLXvqhUYjYm/l9Ll3JwRDJgBHr2TjSlaRxJER1WRwIr9nzx4EBgbiyy+/RE5ODrKzs/Hll18iMDAQe/bsaY4YyUw11zz5c2kFyC1Wwd5aju6+rKygpiMIAgZ3qFyGzsTXk992RvsldnBHd9hZN6g4y+yEVl5cjG3G1TSqNbnrw7J6almdvSoT+XTLTuSzi8r1ZeRM5LWDK71168lfM+2L1I0Vl5KH7KJyOCqtML67N4Z00k6p+/V4ksSREdVkcCIfERGBKVOm4MqVK9i0aRM2bdqEy5cv46GHHkJERERzxEhmKsxfW7ra1CPyurL68EBXiy8Po6Y3uJNuPXnTnie/LV677NwYC2/yVJVuRP5yVhEKSlXN8hi6JncD2rshsLV9szwGUV2CvDgiDwC7z2VAI2pfD3/XmksqWyLOk9fafU5bVj+4U2so5DI82EtbUr/xeArUGvNZepbMg8FZzqVLl/DSSy9BLr9ZDiiXy/Hiiy/i0qVLTRocmTfdiPzFzMIm/dJ8uDKRZ1k9NYeBlSPyp1PycaOwTOJoGiYltwSnU/IhE7SN7kirtYMSvi62EEVtI86mVrXJ3cMcjScJ6BreWXoif7M/CC9k6lTtXC+Klpuw6iqmhnXSfjaOCvaAi50CafmlJn8B35icTy9ARn6p1GGYPIMT+Z49e+Ls2bM1bj979izCwsKaIiayEO6ON780xyU3zZdmtUbEEV2jOyby1Aw8HG30o1oHLt2QOJqG2X5GOxrfO8AVbg5KiaMxLrry+qY6J1Wla3LnZm+Nu7qywSC1PN0c+ZTcEuQ3U9WJsStVqbG3MiEbzUafet19nWEtlyGrsAzXbhRLHY4kbhSWIa6yR8rQztqSeqWVHPeG+QIAfjmWLFVoZiU1rwTjl+7DiE/3YOtprgjQGPVK5OPi4vT/nn/+ebzwwgv45JNPsH//fuzfvx+ffPIJ5s6dizlz5jRzuGRuwtq4AGi68vqzqfnIL62Ao9IKXX0suyMvNR/dnLl9503z6ryuyRM7ptekK6+Pa4aGd7omd5N7+XFZTJKEs50CXk42AIDzFjoqf+jSDRSXq+HlZINuvvyeoGOjkKO7n/ZCpqXOk997QbvsXLC3Ezwr3ycAMKWyY/22+DRkF5VLFZ7ZOJWchwqNiMKyCvx39Qks/OdssyxFbQnq1eEoLCwMgiBUK7V59dVXa2w3bdo0TJ06temiI7PXw98Ff8Wl4mQTNbw7XGV+vKWvi03NZ3DH1vjf3svYdyELoihCEASpQ6q33OJy/aoOo1lWWkOIn67hXdOOyCfnFLPJHRmFzl6OSMsvxbm0An2DM0ui71Yf7GFS5+6W0LttKxy/loNjV7MxuZef1OG0uKiEyrL6ytF4nWAfJ3T1ccKZ6/n4PSYFjw0MlCI8s3G5cgUAN3tr3Cgqx7d7LuNUch6+ergHqwQNVK9M58qVK7h8+TKuXLly23+XL19u7njJzOg71yflNsmcrEOXWFZPzS+8rSusrWRIyy/FpcxCqcMxyK5zGVBrRAR5OSLAjc3WbtXd1xmCoC09zmrCHggbopPY5I6MgiU3vNNoROysXD+eZfU1hQfo5slbXsM7tUbEXt38+M41e8foRuVZXt94lzK035um9w9A5LSesLOW4+ClG7jnq/1N3gDb3NUrkQ8ICKj3P1MWGRmJ4OBghIeHSx2Kxejm6wwrmYCswjKk5JY0al8Vag2OVo409m/PRJ6aj41Cjr6B2i88e8+b1jJ0umXn2OSpdo42CrR3dwDQdOX1VZvcTevL0XiSVmcLTuTjUvKQUVAGB6UV+rWzvGqEO+kVoO1cfymzyOJKyGOTc5FTrIKjjRV6Vk77rGpSmA+s5TLEp+bjdDM0Q7UkugGQ9u4OuDvEG79HDEQ7d3uk5pViyjeHsOZIokU3XDREg2qPU1JSsGHDBnz99df48ssvq/0zZREREYiPj0d0dLTUoVgMG4UcQd7aLxWNvQoXn5qPgrIKONlYoYs3571R8xrc0fSWoStVqbGncsRhDJut1ampy+urNrkbw1FAkljVteQt7cvy9splN4d2cofSSn6HrS1PK3trdPDQXsg8bmHz5HVl9UM6utc6NdPFzlrfV+aXY1xTvqFEUcSlTG1pve6ieUdPR/weMRBju3qhXK3BG5tP4dVf41CqUksZqkmo1xz5qn744Qf897//hbW1Ndzc3KrNLxIEAc8//3yTBkjmL8zfBadT8hGTmIt7QnwavB9dWX2fQDfIZZz3Rs1rUAd3AOdw+HI2yirUJvGlcP+FLJSo1PBxtmEzyNsI9XPBphMpiG2iEfk1uiZ3vdnkjqTXwcMBcpmAvBIV0vPL4OVsc+c7mYkd8do1wkcFc9nNuoS3bYWLGYU4djXbovqo7EnQ/m0MvWV+fFUP9vbHlrhU/BZzHfPGd4GNwvg/941NdlE58kpUEARUm2bmaKPA8kd64ps9l/Hxv+fwy/FknE3Lx/L/9IK/q52EERs3g79RvPPOO3jnnXeQl5eHq1evco48NVqYv7aUq7Ej8od0y86xrJ5aQJCXI1o7KFGiUuPEtVypw6mXbZWjUWO6erHJ023oRuTjkvMaPWKZnFOsr4J4OJxl9SQ9pZVc/wX6XFq+xNG0nMQbxUhIL4BcJmB4LXOgSau3Bc6TzyosQ1xlufywTnUn8oM6tIa3sw3ySlTYUdlrgQyjG433cbaFrXX1CyGCIODpYe2xalZfuNpb43RKPiZ8vV//GUo1GZzIFxcX46GHHoJMxlEFahq6hnenUvKgauDyExVqDaIr58dz3hu1BJlMMKnyerVGxM6z2hEHzo+/vS7eTlDIBWQXlSM5p3G9O9ZXNrkb2MENbdnkjoyEJc6T316ZePVp6woXO2uJozFe4ZUrGZxKybOY0ua957XLznX1cYKHU90VKnKZoO/mv4FN7xpEPz++cgpHbQZ2aI0/nxuEUD9n5Bar8OgPR/HVzgvQaCxrKlB9GJyNz5o1C7/88ktzxEIWql1rezjaWKGsQtPgLxWnUvJQVK6Gi50CXbxYMkwt42Yib/wN704k5uBGUTmcbRUID+TFrtuxUcgRVHkeiUtu+Dz5CrUG66O1cykf5pJzZEQ6e1pgIl9ZkTSKFzJvy9/VFu6OSqjUImItpIN4XcvO1UaXyO+7kInrjWzSbIl0Hevbu9/+wraviy02/Lc/pvVtA1EEPt1+Hk+uOoa8ElVLhGkyDE7kFy5ciD179mDYsGF47rnn8OKLL1b7R2QomUzQj8qfbOCHhq6svm+gK2ScH08tZFAHbSJ/+nqe0Xf43XZG+yV2ZJAHFLU08qHqbpbX5zZ4HzvPZSCjgE3uyPjoRuTPWUgin1tcjuir2uZtrEi6PUEQEN5WO+XxmAU0vFNrROy9UPeyc7cKcLNH30BXiCKw8ThH5Q2lW0Ne1+judpRWcnx0X3csmRwCaysZdpzNwKSv91vUlKA7Mfjb3EcffYR///0X6enpOHXqFE6ePKn/FxMT0wwhkiXQryefmNug+x++rCur5/x4ajkeTjYI8nKEKAIHLhrvqLwoitgWX7nsXFd+ia2PUD8XAI3r3bGWTe7ISOnWkr+YWYiKBk5pMyW7EzKg1ogI8nJk46x60M2TP2YB8+RjknKRW6yCk40VelR+F70T/Zryx5NZ7m0gXWl9uzuMyFc1pbc/Nv53AHxdbHH1RjHuizyI32NSmitEk2LwN4vPPvsM33//Pc6ePYuoqCjs3r1b/2/Xrl3NESNZAH0in2T41V+VWqP/sGGjO2pppjBP/nx6Ia7dKIa1lQyDO965dJCAEH/tiPzplDyoG/BFLSmbTe7IePm3soOdtRzlFRpcvVEkdTjNbnvlhcxRXXghsz508+SPXcsx+0RV161+cKfal52rzbjuXnBQWiExuxhHLeBiR1MpVamRlF0MAOhQjxH5qrr7OWPLc4MwuGNrlPx/e3ceHlV59g/8e2Ymmez7vrMkgbCEAEERFNCCorWC4oavyq+16GtstXaldYEurq3SStS+bQXetwKuoFatoAiIgIQlQIksWSAb2ZfJPtvz+2MyQ0ISkklm5sycfD/XlUuZzJzzTO7M5NzzPM99G0x4dEs+Vn94cti1tZTC7kReq9Vizpw5zhgLjWLWRL6ots3u/S/Hy5vQrjchzN8baVGBThgd0cDmdifGe8/WuW1PZuuy+qvHR8Bfa3fX0VEpNSoQft5qtOlNKO6eQbDH24dY5I7cl0olITV6dCyv7zKasLt7D/Roaqc2EhNjLe9/LZ1GnKlR9u/Hru4PXC9Xrf5Sft4a3JwZC8DyXk9Dc76+HWYBBGo1iAzU2v34UH9vbPh/s/DIgvEAgA37zuHu/zmAGl2no4fqMexO5B999FG88sorzhiL7HJzc5GRkYHs7Gy5hzLqhAdokRjmC8D+PanWZfXcH09ymJUSBm+NCpXNnba2Ku6Gy+rtp1ZJmBxnmZU/ZmfBO0OPInfLZyU7fGxEjjChO5E/o/BEfn9RPdr0JkQFajElPlju4XgEjVqFrKQQAMChc8rdJ1/b0mUraHq5/vH9WTbDsrz+kxMX0NLJAmxDYf1QfGxUwLBb4KpVEn52fTr+dt9MBGo1OHS+ETe9sndUtUvsye5E/uDBg9i4cSPGjh2Lm2++GbfeemuvL0+Wk5ODgoIC5OXlyT2UUcnWT97OffL7i9g/nuTj663GrO5liO64vL6yqQMnKpohScB1XFZql+EWvNvZXeQuIsCbM4DktkZLwTvbsvqMaH7Yb4fRsE9+T/ds/OT4IEQFDtx2rj/Tk0IwLtIfnQYzPj5+wRnDUxxb6zkHrFJbmBGND380F+nRgaht6cLd/3MA678ucduVkc5idyIfEhKCW2+9FfPmzUNERASCg4N7fREN18V98k1DfkyX0YRD51nojuRl3Se/1w3b0FkvYmcmhyIiwP6lbKPZ1O73JHtbMG36prvI3YxEFrkjt2UteHe6WrmJvBACn3f3j+eHavax7pPPU/CM/MVl9YNXq7+UJEm2ondcXj801lWLl+shb48xEf7YmnMVvpcZB6NZYM1HBXjsrXy0640OOb4nsHuz5Pr1650xDqJeibwQYkjLbo6XN6PTYEZEgDdSHfTGQGSvuakRwKeWNoh6o9mtkrft3b2T2f7MfpndM/LfXmgZclzLGtptrYzuyk506viIRiKtO5EvbWhHu94IP2/l1c84UdGMal0X/LzVmM0P++0yLSkEapWEiqYOVDZ1IC7EV+4hOZTJLGwz8gsmDK8I7NLp8Xjhs9M4UtqEwpoWjGedpsuyzcjbUbF+MH7eGvz5rmmYlhiCZz75Fh/kV+LUhRa8fu8MjBkF9Wnc52qTRr1JcUHwUkuob9OjvLFjSI+xLqu/Ymz4sPfbEI3UxJggRAR4o11vwpFS95m9aG432GpIcDbKfklhfgjx84LeZB5y39q38ixF7uaOj2CRO3JrEQFaRAR4QwhLZwslsq5ImpcWCR8vtcyj8SwBWg0mxloSUyX2k88va0RzhwHBvl62rZ32igr0wYLu3vPvHGJP+csRQqC4dug95O0hSRK+P3cMNv3wSkQGanG6ugXfe2Wv7fWvZHYn8mPGjMHYsWMH/CIaLh8vNSbGBgEAjg5xKas1keeyepKTSiVh7nj3a0O383Q1TGaB9OhAJpXDIEkSpnb3kx9KwTuDyWxbYnn3LLacI/dn3Sd/eogfVHka64U8P8gcHus++cMK3Ce/q7uTwdWpEVCPoHbC7TMTAADvHakY9a3QLqempQutXUaoJCAp3M8p55g1Jgwf/2guZiaHoqXLiB/+7yH88bPTw2oh6ynsTuQfe+wxPProo7avhx9+GLNnz0ZzczNWrlzpjDHSKGJbXj+Egnedhouzn1wyR3Lr2YbOXWw/yWr1I2VdXn98CB8ufvEti9yRZ0mPtnx4rsSCd2UN7ThV1QK1SrLNmpJ9lLxP3prIzx/h78a1E6IQEeCNutYuW5tD6quoxrLqJynMD1qN81bHRAX5YPPKK7HiqhQAwLovC7Fi/UE0tumddk45Dav9XM+vn/3sZ3jzzTfx29/+FqdPn7brWM8++yyys7MRGBiIqKgoLFmypM8xhBBYvXo14uLi4Ovri/nz5+PkyZODHvu9995DRkYGtFotMjIysHXrVrvGRvK4uE9+8D8a+WVN6DKaERmodeh+G6LhsBa8O17R7BZ/MDoNJuzu3v/H/fHDd3FGvmnQ+24+yCJ35FlsBe8UmMj3LPQZ6u8t82g808wUy5LzU1U66BTUYq2mpRMnKrrbztnRP74/XmoVlmbFA2DRu8u5uD/e+fWsvNQqrP7eJKy9cxp8vFT46mwdvvvKXpyws5WsJ3DYlcbixYvx3nvv2fWY3bt3IycnBwcOHMCOHTtgNBqxaNEitLVd7MX8wgsv4KWXXsK6deuQl5eHmJgYLFy4EC0tA//R2b9/P+68807ce++9OHbsGO69917ccccd+Oabb4b9/Mg1rIn8fyp10Bsvv0Sp57J67o8nuUUH+SA9OhBCAF8XyT8rv6+oDu16E2KDfTA5Pkju4Xgs64x8YU0r2roGroTbs8jd3bNY5I48g3Vp/RkFVq5ntfqRiw7yQWKYL8wCOGpna2B3tueM5W/0lPhgRAaOvJvL7d3V63eeqkFda9eIj6dEjq5YPxRLsuKx9eE5SA73Q0VTB257fR/ezlPWhy0OS+TfffddhIWF2fWYf//731ixYgUmTZqEzMxMrF+/HqWlpTh8+DAAy2z82rVr8Zvf/Aa33norJk+ejI0bN6K9vR2bNm0a8Lhr167FwoULsWrVKkyYMAGrVq3Cddddh7Vr147kKZILjInwR7CvF/TGwYtLHSju7h/PZfXkJtypDZ1tWX1GND/oGoGoIB/EBvvALID/VAz8aX7PInfJ4VwhRJ4hLToQkgTUteoVlYA0txvwTQkLfTpCtgL3ye86XQMAmJ8+stl4q7ToQGQmhsBoFth2tMIhx1QaZ1SsH4qJsUH48JG5uG5CFPRGM37x3nEcPq+c32W7e41kZWX1uigUQqCqqgq1tbV49dVXRzSY5mbLRZL1A4GSkhJUVVVh0aJFtvtotVrMmzcP+/btw4MPPtjvcfbv34+f/OQnvW67/vrrB0zku7q60NV18Q+YTmdJIA0GAwyGoS0lst5vqPengU2ND8JXhfU4fK4eE6P7f8H33B+fnRzklJ87Y6o8zo7p7LGh+PveEuw5Uwu9Xi9bAm0yC9uy0mvTIxT7O+yq1+jkuCBcaO7E0dIGTE/su7rBYDLjrTzLsvo7ZsQp9uftCnzfdS2NBCSF+uF8QztOljfiqnGO/WBcrnh+XnABJrNAapQ/4oK8+fs0AlmJwXj/aAUOltT3ui721J+p0WS2tZ27elyYw57HbVmxOFbWhC0HS3HfFQke9QG6K2Jq2yMf6uPy3x0/DfDq3Zl4bU8J6lq7MDUu0K1/f+0Zm92J/JIlS3r9W6VSITIyEvPnz8eECRPsPZyNEAKPP/445s6di8mTJwMAqqos/Y+jo3t/mhodHY3z588PeKyqqqp+H2M93qWeffZZrFmzps/t27dvh5+ffZUVd+zYYdf9qS+/ThUAFT45UICw+v/0e58zzRIMJjWCvQROHtiNAie+XzKmyuOsmOpNgFpSo7K5Exve/xTRMrXdLdYB9W0a+KoF6r/9Bp/YV77E4zj7NaptkwCo8VneKcQ2F/T5/rF6CbWtagR4CRjOHcEnpU4dzqjA913XCRKWv7nbdh1E02nnVHd2dTz/ecbynJK9WvDJJ5+49NxK094OABocPt+Aj/71CdTda3k99TVarAN0nRr4aQQqTuzDhf4vM+3mbQS8JDUKa9vw+tufItkDW8o7K6ZdJqCy2ZJyFufvR83gpc6cYgyAFAn45JMSeQYwRO2WF92Q2J3IP/300/Y+ZEgeeeQRHD9+HHv37u3zvUs/1RJCDPpJlz2PWbVqFR5//HHbv3U6HRITE7Fo0SIEBQ1tb6nBYMCOHTuwcOFCeHl5Dekx1D+/M7X47P+Ook4E4MYb5/Z7nzNfFAIFxZg3MQ433TTFKeNgTJXHFTHdWncI+4oboImfjBuvlKcF2XP/Pg3gPBZOisPN33XO68MduOo1GlxUj39tOIxasz9uvPHqPt9/d+NhAPW458qx+N6iVKeNYzTg+67rndEW4sSuYqjDknDjjZMcemw54tllNOPXR74EYMKDN11pq71Dw2M2C7x65ks0dxiRNG0OMqL9PPo1+tLnZwGUYMHEWHz3pqkOPfZ+/Ql8cOwCKn1T8N83Zjj02M7k7NdpwQUdcPAAQv28cMctiwZ/wChnXRk+FHYn8s7wox/9CB9++CH27NmDhIQE2+0xMZZKy1VVVYiNjbXdXlNT02fGvaeYmJg+s++Xe4xWq4VW27fYhZeXl92/0MN5DPU2I8Wyz7ikvh3tBiDYr+/P82B3K5Q5qRFO/3kzpsrjzJhenRaFfcUN2FfcgO9fPc4p57ic2pYu7PjWsmzwhimxo+J319mv0axky3Lj8sYOtOgFwnpUwC5raMfe7sKby69MHhU/b1fg+67rZMSFAADO1rQ67WfuynjuL6lFW5cJkYFazEiJgGoEPcLJYmZyGL44VYP8cp2tAKinvka/KrS8X183Mdrh478zOwkfHLuAj49X4embJ8PX23lt1pzBWTE932jZvjwuMsAjf2dczZ6f0ZCL3alUKqjV6st+aTT2fS4ghMAjjzyC999/Hzt37sSYMWN6fX/MmDGIiYnptdRDr9dj9+7duOqqqwY87uzZs/ssD9m+fftlH0PuI8zfG8nhli0N+f20fOrQm5Df3dP5Sha6IzdjLXi3v6h+0M4LjtKhN+GD/AqsWH8QVz77BUob2uHjpcI1I2yrQxbBvl4YG2Gp13H8kvekLXmlEMISdxa5I090sXJ9K8xm5yytd6X93YVw56dFMol3kJnd/eQPeXg/+ZqWTvynwjLb6Yy/j1eODUdCqC9auoz47GT/23lHI+v++LFsFe1wQ868L9eHfd++fXjllVcghH1/AHJycrBp0yZ88MEHCAwMtM2iBwcHw9fXF5Ik4bHHHsMzzzyD1NRUpKam4plnnoGfnx+WL19uO859992H+Ph4PPvsswAsve6vueYaPP/887jlllvwwQcf4PPPP+932T65p2mJIThf34780qY+PT4Pn2+EwSQQF+yDpDD7ahgQOVtGbBDC/b1R36bH0dJGXOGkD5vMZoEDJfXYeqQCn/6nCq09WqNNSwzB4wvTEKB1i0VXijA1IRjFdW04Xt6M+elRACxF7t4+VA4AuHuWPNsoiEYqJdwP3hoVOgwmlDa0IyXCsy+2D5/vLoSbYl8nJRpYdnc/+UPnG+y+1ncnu09bVqtNTQhGRMDI285dSqWScPuMRLz8+Rm8fagMS7r7y492ruwhP9oM+Srvlltu6XPbqVOnsGrVKnz00Ue455578Lvf/c6uk7/22msAgPnz5/e6ff369VixYgUA4Be/+AU6Ojrw8MMPo7GxEVdccQW2b9+OwMCLVSRKS0uhUl1cXHDVVVdhy5YteOKJJ/Dkk09i3LhxeOutt3DFFVfYNT6Sz7TEEHyQX4n8sr6f/u4vtrT2unIc+8eT+1GpJMwZH4EPj1Vib2GdwxP5s9UteP9oBT44WoHK5k7b7QmhvliaFY+lWfEYyz+WDjc1IQTb8itxrHs1EAB88W01alu6EBGgZYsr8lgatQqpUQE4WanD6eoWj07kDSaz7TU6PTlU3sEoyJSEYHhrVKhr1eN8w9ALcbmbXd3V6q0fxjrDbTPisfaLM9hXVI+yhnYkcsIJxdYe8rw2cbhhTddUVlbi6aefxsaNG3H99dcjPz/fVmneHkP5VE+SJKxevRqrV68e8D67du3qc9uyZcuwbNkyu8dE7sFanCa/rKlPocIDxZb+j1xWT+7q6lRLIr/nbB1+uih9xMera+3Ch/mV2Hq0Aid69DIP9NHgu1NjsTQrATOTQ7mM1IkyEy37Qo+VN9vekzYdLAMA3D4zAV7qIe9UI3I76TGBlkS+qgXXT4qRezjDVlCpQ5fRjBC/i9thaOS0GjWmxgfj0PlGHDrfBE9MTY0mM76yJfLO23aWEOqHOeMisLewDu8cLsfjC9Ocdi5PYDYLFNd1z8hHMZF3NLsS+ebmZjzzzDN45ZVXMG3aNHzxxRe4+uq+FXyJRiojLgjeahUa2w0obWi37T1t6zLaPm2fzUSe3NTVqZaLhOPlTWhq1yPEz3uQR/TVaTBhR0E1th6twO4ztTB1713VqCTMT4/E0qwEXDcxCj5enlVMx1NNiguGWiWhrrULF5o7YTILfHXWclF4dzaX1ZNnm9C9T/50VYvMIxkZ67L66Un8YNPRZqaE4dD5RhwpbcJc+/+kye5oWRN0nUaE+nkhMyHEqee6fWYC9hbW4b3D5XjsutRR/btY2dyBToMZXmoJiaEy9eRVsCEn8i+88AKef/55xMTEYPPmzf0utSdyFK1GjYlxQThW1oT8siZbIn/ofCOMZoGEUF8uVyK3FRPsg7ToAJypbsW+onrcOCV28AfB8sn1NyUN2Hq0HJ+eqEJLj33vmQnBuHV6Ar47NRbhTtjbR5fn46VGenQgCi7ocLy8CScqmm1F7pLC+V5Eni0t2pLIn6oaetsjd3S41JLIz+CyeofLTgnF67stH5bM9cAum7tO1wCwfNCudnJiff2kGAT5aFDR1IF9RfWY210EdzQq6l5WnxzuDw1XrjnckBP5X/3qV/D19cX48eOxceNGbNy4sd/7vf/++w4bHI1uWYkhOFbWhKOlTbhlmqVgyIHuarRcVk/ubu74SJypbsVXZ2sHTeQLa1qx9Wg5th2tREVTh+32+BDLvvclWfEYzyVpsstMDEbBBR0On2/EtvxKAMByFrkjBZgQEwQAOFffjk6DyWNX+hzpMSNPjmX9cKS4rh2tKfKOZTi+PGVZQbVggvO7ufh4qXHLtHj834HzePtQ2ahO5Itthe641cUZhpzI33fffYovLJabm4vc3FyYTCa5h0LovU/ean93v2Yuqyd3d3VaBN74ugR7ztT1qfMAAPWtXfjomGXf+7HyHvvetRrcOCUWS6fHY1ZK2KhekudupiaEYPPBMmz6phRtehMiArT4DovckQJEB2kR7OuF5g4DCmtaMTk+WO4h2a2yqQMXmjuhVkm2mhbkOCF+3kiNCsDZmlYUt3jW36UaXScKLuggScA1qa5py3rHzET834Hz+PfJKjS3GxDsNzr7p7NivXMNOZHfsGGDE4fhHnJycpCTkwOdTofgYP4RkJs1kbcUrzHBYBK2Ql9XjmMiT+7tijFh8FarUNHUgXP17RgT4Y9OgwlffFuD94+UY/eZWhi7972rVRLmp0Vi6fR4fGditMfOhind1ATL34U2veXD3jtY5I4UQpIkpMcE4mBJA05XtXhkIm/dH58RGwQ/b7bedIaZKWE4W9OKEp1nJfLWavVT44NdtjVtcnwQJsQE4lRVCz48Xol7r0x2yXndTVGNZWk9u+k4B9/pyG0lh/sh1M8Lje0GfHuhBY3tepjMAklhfogPYcEMcm9+3hrMSA7F/uJ6rP+6BHqjGR+fuICWzov73qcmBGNpVjxuzoxzSk9bcqy06ED4eKnQaTADAO5ikTtSkAnWRL7aMwveWRN57o93nuyUUGw+WOpxM/LW/vHObDt3KUmScPvMRPzuXwV451DZ6E3kubTeqZjIk9uSJAmZiSHYdboW+aWNuNDdM5vL6slTXJ0Wgf3F9fjf/edtt8WH+GJJVhyWZsVjfFSgjKMje3mpVZgUF4zD5xtZ5I4UJ93DK9cf6S50x/7xzpOdEgYAKG0DmtoNiAx2/+XiRpMZe846v+1cf5ZMi8Nzn36L4+XN+PaCDhNjg1x6frm1dBpQ09IFgDPyzsI1geTWeu6T399d6G42l9WTh1g8ORY+XioEaDW4Y2YCNv/wSnz1iwX4+fUTmMR7qGUzEhDko8EjC8bLPRQih/LkFnTteiNOVloq7nNG3nkSQn0xIToAZiHhb3tL5B7OkBwpbUJLd9u5qU5uO3ep8AAtvjPRUkflnUPlLj23OyjurlgfGWipwUGOx0Se3Jo1kd9fXI//WPfHc0aePMSYCH8c/M13cOiJ7+CFZZmYPS6cxes83N2zknB89fW4gu9DpDDWFnRVuk40txtkHo19jpc3w2QWiAnyQVywj9zDUSxJkvCThZbec/97oBTVuk6ZRzQ4a9u5eWnObzvXn9tnJgAAtuVXQG80u/z8crIuqx8bwWX1zsJEntyaNZGv1nXBLCyJUQz/SJMHCfLxYvE6InJ7gT5etvozntZPvuf+eKV3WJLbgrQIjAkU6DSY8Zcvzso9nEF9KcP++J6uSY1EVKAWDW167DxVLcsY5GLbH8/2uU7DRJ7cWoifN8b0+CSPs/FERETOYdsn72EF72z947ms3ukkScLNSZbOHVvyylBS1ybziAZWrevEt9a2c2mu3R9vpVGrcNsMy6z826Nseb11aT1bzzkPE3lye9ZZeQC4cmyYfAMhIiJSMGsif8qD9skLIXC4lBXrXWlcEDA/LQIms8BLO87IPZwBWavVZyaEIMzfW7Zx3N6dyO86XeMR2xEchRXrnY+JPLm9nok8K9YTERE5hycWvCuua0NTuwFajQoZo6wquJwe/45lr/xHxyptNYzczZfd++NdXa3+UmMjAzAzORRmAbx/pELWsbiK0WTGubp2AJyRdyYm8uT25owPh1plaUUXFcT98URERM5gnZE/U9UCIYTMoxka6/74zIQQeGt4WesqE2MDccu0OADAi5+dlnk0fRlMZuw9WwdAvv3xPd0xMxEA8M6hMo95bY1EeWMH9CYztBoV4rprb5Dj8R2vh9zcXGRkZCA7O1vuoVAP46MC8fGP5+Lv982UeyhERESKNTYiABqVhJYuIyqaOuQezpBwf7x8Hl+YBo1Kwu4ztdhfVC/3cHo5cr4RLV1GhPl7Y2p8sNzDwY1TY+HnrUZxXZvtwyclK66zLKsfE+EvS7eA0YKJfA85OTkoKChAXl6e3EOhS0yICUJkoFbuYRARESmWt0ZlWwZ7xkMK3vWsWE+ulRzuj7tnJQEAXvjslFvNNFur1c9Li3SLtq8BWg1umhILAHj7UJnMo3G+opruQnesWO9UTOSJiIiICIBnFbxrbjfgbI1l5m96Uoi8gxmlfnTtePh6qXG0tAmff1sj93BsdrnJ/viebu9eXv/x8Qto6zLKPBrnshW6Yw95p2IiT0REREQAerSg84BE/kh3tfqxEf4ID+CqPTlEBfng+3NTAAAvfnYKJrP8s/JVzZ04VdUCSQKuTnWfRD47JRQp4X5o05vwyYkLcg/HqdhD3jWYyBMRERERACA92nMS+cPcH+8WVl4zDsG+XjhT3YptR+Wvyr77jGU2flqivG3nLiVJkm1W/h2F95RnD3nXYCJPRERERAAuzsgX1bbCYDLLPJrL4/549xDs64X/nj8OAPDSjjPoMppkHc+Xpyz74+enyV+t/lK3TU+ASgIOnmtASV2b3MNxisY2Perb9AAsxe7IeZjIExEREREAICHUFwFaDQwmYZtVc0dGkxn5ZU0AmMi7g/tnpyA6SIuKpg5s+qZUtnEYTGZ8XWhtO+c+y+qtYoJ9cE2aZVzvHlZm0TtrxfrYYB/4azUyj0bZmMgTEREREQDL8t+0aMty2FNVOplHM7BTVS3oMJgQ6KPBeC7flZ2vtxqPXpcGAFi3sxCtMhVzO9zddi7c3xtT3KDtXH+sPeXfPVzuFjUFHM1WsZ6vS6djIk9ERERENukxQQDce5+8bX98UqhbtBcj4PaZCRgT4Y/6Nj3+8VWJLGP4srtavbu0nevPdROjEOrnhWpdF/acrZV7OA5X1D0jPy6Sy+qdjYk8EREREdlM6N4n78695Lk/3v14qVX46SLLrPzfvipGQ/c+aVfabe0f74bL6q20GjWWZMUDAN5RYE959pB3HSbyPeTm5iIjIwPZ2dlyD4WIiIhIFp7QS56JvHu6cXIsJscHobXLiFe/LHTpuS80d+BUVQtUEnCNG7Wd68/tMyzL63cUVMvygYczFXe3nhsbwUTe2ZjI95CTk4OCggLk5eXJPRQiIiIiWVhb0JU3dsi21/lyqpo7UdHUAZUEZCaGyD0c6kGlkvDz6ycAAP73wHlUNHW47Ny7umfjpyWGINSN2s71JyMuCJPjg2AwCXyQL3/LPkfRG80439AOABgXxaX1zsZEnoiIiIhsQv29ERWoBeCe++SPlFpm4yfEBCGAVbHdzjWpEbhybBj0RjP+/PkZl513V/f++Pnp7td2rj/Wondv5ZVBCGUUvSttaIPJLODnrUZMkI/cw1E8JvJERERE1It1eb07JvJcVu/eJEnCL26wzMq/e7gchTXO/x3SG834urAegHu2nevP9zLj4K1R4VRVC05Wum+HCHsU1V6sWC9J7llsUEmYyBMRERFRLxNsibz7JRhM5N3f9KRQLMqIhlkAf/zM+bPyh883orXLiIgAb0yOc8+2c5cK8fPG9ZNiACin6F2RdX88K9a7BBN5IiIiIurF2oLO3QredRpMOFnZDICJvLv72fXpUEnAv09WIb+syannsi6rv8aN28715/YZCQCAbfmV6DSYZB7NyLGHvGsxkSciIiKiXmwz8tUtbrV/90RFMwwmgchALRJCfeUeDl1GWnQgbp1uSVSf//SUU3+PrIXuPGV/vNWc8RGIC/ZBc4cBOwqq5R7OiFln5JnIuwYTeSIiIiLqZXxUAFQS0NRuQG1Ll9zDsbEtq08K5R5cD/DYd1LhrVZhf3E99hbWOeUclU0dOF1tbTsX4ZRzOItaJWFZ96z82x6+vF4IYWs9x4r1rsFEnoiIiIh68fFSIyXccjHuTsvruT/esySE+uGeK5MAAC/8+7RTZuWts/FZSaEI8XPvtnP9WdbdU35vYR0qXdiuz9HqWvXQdRohSbC9d5BzMZEnIiIioj7crXK9EAJHuhP56UzkPUbOgvHw91bjREUzPv1PlcOPb2s7l+YZ1eovlRTuhyvHhkEI4L3D5XIPZ9isy+oTQn3h46WWeTSjAxP5HnJzc5GRkYHs7Gy5h0JEREQkK2si7y4z8ufr21Hfpoe3WoXJ8UFyD4eGKCJAiweuHgsA+ONnp2E0mR12bEvbOcuS/QUTPGt/fE/WnvLvHC6H2ew+NSnswf3xrsdEvoecnBwUFBQgLy9P7qEQERERyepiwTv3aEFnXVY/JSEYWg1n/DzJA1ePQZi/N4rr2vCuA2edD51rQJvehIgALTJiPffDncWTYxGg1aC0oR3flDTIPZxhKa5lxXpXYyJPRERERH1YW9CdrW6FyQ1mCQ+Xcn+8pwr08ULOgvEAgLWfn3VYq7VdZyz74+d5WNu5S/l6q3FzZiwA4F/HK2UezfBwRt71mMgTERERUR9JYX7w8VKhy2jGufo2uYdzcX98EhN5T3TPFUmID/FFla4T/7v/nEOOadsfn+6Z++N7srbOO+ihM/LWRH5sJAvduQoTeSIiIiLqQ62SkBbtHgXvdJ0GnK62jGF6coisY6Hh8fFS47HvpAIAcr8sQnOHYUTHq2jqwJnq1u62c56fyGenhAEAzta0or7VfVo+DkWnwYTyRkvFfc7Iuw4TeSIiIiLqV7qbJPL5pU0QwrJKICrQR9ax0PDdOj0B46MC0NxhwN/2FI/oWNbZ+OlJoQj283LE8GQV5u+NtGhLEpx3rlHm0djnXH0bhACCfDSICPC8FoCeiok8EREREfXLXVrQsX+8MqhVEn62KB0A8I+9JahtGf7Ms7V/vBKW1VvNGmOZlfe05fVFNd2F7qICIEmeW6vA08iayO/Zswc333wz4uLiIEkStm3b1uv7kiT1+/Xiiy8OeMwNGzb0+5jOzk4nPxsiIiIiZbEl8tXyJvJHWOhOMa6fFI3MxBB0GExYt/PssI7RZTRhX3fbOeveciWYNSYcAHDwXL3MI7GPbX98BJfVu5KsiXxbWxsyMzOxbt26fr9/4cKFXl9vvPEGJEnCbbfddtnjBgUF9Xmsjw+XYRERERHZw5rIn6tvQ4feMZXG7WUyCxwtbQLARF4JJEnCL2+wzMpvOliK0vp2u49x6Fwj2vQmRAZqMSnOc9vOXWpW9z75gkoddJ0jqyHgSraK9VEsdOdKGjlPvnjxYixevHjA78fExPT69wcffIAFCxZg7Nixlz2uJEl9HktERERE9okM0CLM3xsNbXqcrWnB1IQQl4/hTHULWruMCNBqbMX3yLNdNS4CV6dG4KuzdXj58zN4+c5pdj3euj9+XlqkopZyxwT7IDncD+fr23H4fCMWeMhqA/aQl4esibw9qqur8fHHH2Pjxo2D3re1tRXJyckwmUyYNm0afve73yErK2vA+3d1daGr6+IeHZ1OBwAwGAwwGIb2aZj1fkO9P7k/xlR5GFNlYTyVhzF1T2lR/jhQosfJiiZMjB76jJuj4nmw2LKEOjMhGGaTEWZ5FgYQHPsaffy68fjqbB225Vfg+1clYULM0D+k+fKUJZG/ZnyY4t4vZiaH4Hx9Ow4U1mHuWOevQBlpTIUQthn55FAfxcXD1ez5+UlCCOHEsQyZJEnYunUrlixZ0u/3X3jhBTz33HOorKy87DL5AwcOoLCwEFOmTIFOp8Of//xnfPLJJzh27BhSU1P7fczq1auxZs2aPrdv2rQJfn5+w3o+RERERErwXokKe6pUmB9rxtIUs8vP/39nVThUp8INCWYsTnT9+cl51p9RIb9ehUmhZqycMLTYNnQBa45ooILAH7JN8POYacmh+aZGwqYiNcYECjw22f0/tWrqAp7ujseLV5igYSn1EWlvb8fy5cvR3NyMoKDLbxvxmER+woQJWLhwIV555RW7jms2mzF9+nRcc801+Mtf/tLvffqbkU9MTERdXd2gP0Arg8GAHTt2YOHChfDy8vwWGMSYKhFjqiyMp/Iwpu7p7UPl+M0HBbhqXBg2rpg55Mc5Kp7XvvQVyho78Mb903H1+IhhH4dGztGv0eLaNty4bh9MZoHND2Rj5hBqIGw6WIanP/oWM5NDsPmBWSMeg7spbWjHdS/vhZdawuFfXwtfb7VTzzfSmH5dVI8VGw5jTLgftj821wkjHF10Oh0iIiKGlMh7xGdYX331FU6fPo233nrL7seqVCpkZ2fj7NmBq2JqtVpotdo+t3t5edn9Cz2cx5B7Y0yVhzFVFsZTeRhT95IRHwIAOFvTNqy4jCSeNS2dKGvsgCQBM8dE8PfCTTjqNZoeF4I7ZiZg88EyvPR5Id5+cPage96/KrS0ZlswIVqRvw9jo4IQE+SDKl0n/lPViqvGuebDq+HGtLTR0hlsXFSgIuPhavb8DD1i8cM//vEPzJgxA5mZmXY/VgiB/Px8xMbGOmFkRERERMqW2l1grralCw1tepee+8j5JgBAenQggnyYJCjRj69LhVajQt65Rltv+IF0GU3YV2RtO6ec/vE9SZLkUf3ki2pYsV4usibyra2tyM/PR35+PgCgpKQE+fn5KC0ttd1Hp9PhnXfewQMPPNDvMe677z6sWrXK9u81a9bgs88+Q3FxMfLz8/GDH/wA+fn5eOihh5z6XIiIiIiUKECrQWKYLwDgVJXOpee29o+fzrZzihUb7IsVV6UAAJ7/9ymYzQPv+s0raUS73oSoQC0yYpXTdu5SHpXIWyvWs4e8y8mayB86dAhZWVm2ivKPP/44srKy8NRTT9nus2XLFgghcPfdd/d7jNLSUly4cMH276amJqxcuRITJ07EokWLUFFRgT179mDWLOXtoSEiIiJyhfRoS9J0uqrFpec9fN6SyM9IYiKvZP89fxwCfTQ4VdWCj45XDng/pbadu9QV3Yn8kdJG6I3uXeCRPeTlI2siP3/+fAgh+nxt2LDBdp+VK1eivb0dwcHB/R5j165dve7/8ssv4/z58+jq6kJNTQ0+++wzzJ4928nPhIiIiEi5rK3BXJnIdxlNOFHeDACYwRl5RQvx88ZD88YBAP60/cyAyeuuM5al9wsmeEZ/9eEaHxWAMH9vdBrM+E9ls9zDGVBblxEXmi175MdyRt7lPGKPPBERERHJJ707kT/lwkT+PxU66E1mhPt7Izmc7YCV7v/NSUFEgBalDe14K6+0z/fLGtpRWNMKtUrCHIV3L5AkCdkplg+v3Hl5fUmdZVl9uL83Qv29ZR7N6MNEnoiIiIguyzojf6a65bJ7mB3pyPmL++OVvIyaLPy8NfjxdeMBAH/+ohDtemOv71tn42ckhSLYV/mFD2eNCQfg3om8dVn92Eguq5cDE3kiIiIiuqyUCH94q1Vo15tQ3tjhknPa9sdzWf2ocVd2EhLDfFHX2oX1X5/r9b3d3fvj509QZrX6S1n3yeeda4DJRR+e2ctWsT6Sy+rlwES+h9zcXGRkZCA7O1vuoRARERG5DS+1CuOiLBfrrqhcL4TA4VIm8qONt0aFny5MBwC8vrsITe2WdoedBhO+LqwHAMxPU/b+eKuJsUEI0GrQ0ml0ebeIoSrqXlrPRF4eTOR7yMnJQUFBAfLy8uQeChEREZFbSY+2XKyfqXb+Pvnyxg7UtnTBSy1hSnz/BY9Jmb6XGYcJMYFo6TTitd1FACyz0h0GE6KDtJgYGyjzCF1DrZIw0833ybOHvLyYyBMRERHRoNJjLC3oXFHwzrqsflJcMHy81E4/H7kPlUrCL26wzMpv+Pocqpo7seu0ZX/8/LSoUVUvwZ37yZvMwlbsjhXr5cFEnoiIiIgG5coWdNwfP7otSI/CzORQdBnN+PMXZ2394+enj4798VZX9EjkhXCvffKVTR3oMprhrVYhIdRX7uGMSkzkiYiIiGhQ1hZ0xXVt6DKanHouJvKjmyRJ+OXiCQCAt/JKUVTbBo1KwpxUZbedu9SU+BBoNSrUt+lRVNsm93B6sVasT4nwg0bNlFIO/KkTERER0aBig30Q6KOBySxQVOO8pKK162JxLybyo1d2ShiunRAFa8H26cmhCPJRftu5nrw1KkxPcs998tYPFljoTj5M5ImIiIhoUJIkXVxeX+28KtrHyppgFkB8iC+ig3ycdh5yfz+/Ph3WLfEL0kdHtfpLXdwnXy/zSHpjD3n5MZEnIiIioiGxLq93ZsE7Lqsnq4mxQVh5zVgkhfnhlmlxcg9HFtZ98t+42T559pCXn0buARARERGRZ7BWrndmwTsm8tTTqsUTsWrxRLmHIZuspFBoVBIuNHeivLEDiWF+cg8JgKVWBsBEXk6ckSciIiKiIUmPtszIn3FSIm82CxwpZSJPZOXrrcbUhGAA7rNPvrnDgNqWLgBcWi8nJvJERERENCTWRL6yuRPNHQaHH7+wthUtnUb4eatt+/GJRrtZY8IBuE8iX9y9Pz4qUIvAUVaA0J0wke8hNzcXGRkZyM7OlnsoRERERG4n2M8LscGWAnRnqh0/K29dVj8tMYQtrYi62frJn3OPRJ4V690D3yF7yMnJQUFBAfLy8uQeChEREZFbcmbBO+6PJ+prRkooJAkoqWtDja5T7uHYZuTHRXFZvZyYyBMRERHRkFkT+dNVjm9Bd6Q7kZ/ORJ7IJsjHCxmxlkKT7jArb209xxl5eTGRJyIiIqIhs/WSd/CMfEOb3lYJe3oiE3mini72k3eHRN7yOh3LRF5WTOSJiIiIaMjSoy0zg6eqWhza19o6G58aFYBgPxbQIurpCjdJ5I0mM87XW/fIc2m9nJjIExEREdGQjYvyh1oloaXTiAvNjtuve5ht54gGlJ1iSeRPVbWgqV0v2zjKGjtgMAn4eKkQF+wr2ziIiTwRERER2UGrUWNMhGUm7rQDK9cfPsf98UQDCQ/QYnyUZSl7XvdrRQ5FNZb98WMjAqBSSbKNg5jIExEREZGd0h28T15vNONYeRMAzsgTDeTiPvl62cZgLXQ3lsvqZcdEnoiIiIjsMiHasYl8wQUduoxmhPh5YWwEEwSi/rjDPnlWrHcfTOSJiIiIyC6O7iVv6x+fFApJ4nJdov5Y98n/p1KH1i6jLGMo7q5YPy6KibzcmMj3kJubi4yMDGRnZ8s9FCIiIiK3NSHGUrm+qKYVBpN5xMdj/3iiwcWF+CIh1Bcms7C9Zlzt4ow8V87IjYl8Dzk5OSgoKEBeXp7cQyEiIiJyWwmhvvDzVkNvMuNcd+/34RJC4NB5y1Jh7o8nujw5+8k3tOnR2G4AAFvBS5IPE3kiIiIisotKJSEt2jHL6yubO1Gt64JaJSEzIcQBoyNSLjn3yVtn4+NDfOHnrXH5+ak3JvJEREREZLcJDqpcb90fPykuCL7e6hGPi0jJZo0JBwDklzWh02By6bmLWbHerTCRJyIiIiK7WWfkR9pL3rY/PonL6okGkxLuh8hALfQmM46VNbn03EXWQnesWO8WmMgTERERkd0cPSPP/fFEg5MkSbZ98kU13YXuWLHeLTCRJyIiIiK7WVvQlTa0o22YrbDa9UYUXNABYCJPNFS2ffLnXJzIWyvWs9CdW2AiT0RERER2Cw/QIiJACwA4M8zl9cfKmmEyC8QG+yAuxNeRwyNSLOuM/OHzjQ5p/zgUXUYTyho7AHBG3l0wkSciIiKiYRnp8vojpewfT2SvtKhABPt6oV1vwslKnUvOWVrfDpNZIECrQVSg1iXnpMtjIk9EREREw2JdXj/cFnS2/fEsdEc0ZCqVhOwU6z75epec07asPtIfkiS55Jx0eUzke8jNzUVGRgays7PlHgoRERGR20sfwYy82SxsM/LcH09kH1f3k7dWrB/LivVug4l8Dzk5OSgoKEBeXp7cQyEiIiJye7al9dUtEELY9djiujY0tRvg46VCRlyQM4ZHpFg9K9ebzfa99oaj54w8uQcm8kREREQ0LKlRgZAkoKFNj9rWLrsea+0fn5kQAi81L0mJ7DEpLgh+3mroOo04Pcxik/ZgD3n3w3dNIiIiIhoWX281ksP8AABnqlrteiz7xxMNn0atsr12nL28XgiBYvaQdztM5ImIiIho2C4WvLOvevZh7o8nGhFX7ZOvbelCS5cRKglIDvdz6rlo6JjIExEREdGwpcdY9rfbU/CuqV2Pwu4ZvixWrCcallljwgEA35Q02F2jwh7WZfWJYX7QatROOw/Zh4k8EREREQ1bz4J3Q3W0tAkAMDbSH2H+3s4YFpHiTU0IhrdGhbrWLpTUtTntPBcL3XFZvTuRNZHfs2cPbr75ZsTFxUGSJGzbtq3X91esWAFJknp9XXnllYMe97333kNGRga0Wi0yMjKwdetWJz0DIiIiotHNurT+THULTEOsns3+8UQj5+OlxrTEEADOXV7PivXuSdZEvq2tDZmZmVi3bt2A97nhhhtw4cIF29cnn3xy2WPu378fd955J+69914cO3YM9957L+644w588803jh4+ERER0aiXEu4PrUaFToMZpQ3tQ3oMC90ROYYr9smzh7x70sh58sWLF2Px4sWXvY9Wq0VMTMyQj7l27VosXLgQq1atAgCsWrUKu3fvxtq1a7F58+YRjZeIiIiIelOrJKRGB+A/FTqcrtJhTMTlZ+2MJjPyy5oAMJEnGilrP/lvnJjIF3NpvVuSNZEfil27diEqKgohISGYN28e/vCHPyAqKmrA++/fvx8/+clPet12/fXXY+3atQM+pqurC11dF3uf6nSWqqsGgwEGg2FI47Teb6j3J/fHmCoPY6osjKfyMKaeKzXSH/+p0KGgohnXpUcAGDieJyt16DCYEOSjQVKIlvH2IHyNup8psQFQqyRUNHXgXK0O8SG+dj1+sJh26E2oaOoAACSF8vXqbPb8fN06kV+8eDFuv/12JCcno6SkBE8++SSuvfZaHD58GFqttt/HVFVVITo6utdt0dHRqKqqGvA8zz77LNasWdPn9u3bt8PPz74WCzt27LDr/uT+GFPlYUyVhfFUHsbU85gbJQBq7Dl2FuM6T/f63qXx3HPBct94Hz3+/e9PXTdIchi+Rt1Lgp8a51sl/P2DXciOHF71+oFiWtEGCKGBn0bgwK7PIUkjGSkNpr19aNuTADdP5O+8807b/0+ePBkzZ85EcnIyPv74Y9x6660DPk665DdMCNHntp5WrVqFxx9/3PZvnU6HxMRELFq0CEFBQUMaq8FgwI4dO7Bw4UJ4eXkN6THk3hhT5WFMlYXxVB7G1HMFnq3DB/97BDpVAG68cS6AgeO54+3jAKpw/Yw03Dh/rEwjpuHga9Q9HVedxj++Pg9DSBJuvHGSXY8dLKYfn6gCjh9HemwIbrrpCkcNmQZgXRk+FG6dyF8qNjYWycnJOHv27ID3iYmJ6TP7XlNT02eWvietVtvvDL+Xl5fdb1LDeQy5N8ZUeRhTZWE8lYcx9TyTEix73c/Vt8MEFXy8LvaavjSeR8uaAVh6YDPOnomvUfcye1wk/vH1eeSdbxp2XAaK6fmGTgDA+KhAxtwF7PkZe1Qf+fr6epSVlSE2NnbA+8yePbvP0pDt27fjqquucvbwiIiIiEalqEAtQvy8YBZAYU3rgPerau5ERVMHVBKQ2d02i4hGJjslDJIEFNe2obala/AH2MHWei6Khe7cjayJfGtrK/Lz85Gfnw8AKCkpQX5+PkpLS9Ha2oqf/exn2L9/P86dO4ddu3bh5ptvRkREBJYuXWo7xn333WerUA8Ajz76KLZv347nn38ep06dwvPPP4/PP/8cjz32mIufHREREdHoIEkS0qMt/eRPVbUMeD9r27mJsUHw13rUwlAitxXs52V7/eWdc2z1+iJWrHdbsibyhw4dQlZWFrKysgAAjz/+OLKysvDUU09BrVbjxIkTuOWWW5CWlob7778faWlp2L9/PwIDA23HKC0txYULF2z/vuqqq7BlyxasX78eU6dOxYYNG/DWW2/hiiu4p4OIiIjIWSbEWK7PTlcNvMeT/eOJnMMZ/eTNZoFiWw/5y7eVJNeT9aPQ+fPnQ4iBKyt+9tlngx5j165dfW5btmwZli1bNpKhEREREZEd0mMsBYIvOyNfykSeyBlmjQnHxv3nHZrIV+k60WEwQaOSkBRmXycvcj6P2iNPRERERO4pPcay9Pb0AIl8p8GEkxWWQnfTk5jIEzlS9hjLa+rbKh2aOxzT6926rD453A9eaqaN7oYRISIiIqIRS+veo1vT0oXGNn2f7x8vb4bRLBAVqEVCqK+rh0ekaFGBPhgb4Q8hgMPnHTMrX1TD/fHujIk8EREREY1YoI8X4kMsCfrp6r6z8j33x0uS5NKxEY0Gs7r3yX/joOX1Rbb98Uzk3RET+R5yc3ORkZGB7OxsuYdCRERE5HEuFry7fCJPRI43y8EF74rrrDPyLHTnjpjI95CTk4OCggLk5eXJPRQiIiIij5Me038LOiEEjnQXupvORJ7IKayJ/InyZrTrjSM+XlGNZUaePeTdExN5IiIiInKI9AFa0J2rb0dDmx7eGhUmxQXJMTQixUsI9UN8iC+MZoGjpU0jOlZrlxFVuk4AwLgIJvLuiIk8ERERETnEhO4WdGeqW3u1GLYuq58aHwytRi3L2IhGA0ftky/urlgfEeCNYD+vEY+LHI+JPBERERE5xJgIf2hUElq7jKho6rTdzv3xRK5xcZ98/YiOY209x0J37ouJPBERERE5hLdGZWtV1bNy/REm8kQuYU3kj5Y2octoGvZxirsr1rP1nPtiIk9EREREDmPdJ3+22jKjp+sw4EyNJalnoTsi5xob4Y+IAG90Gc04Ud487ONYZ+RZsd59MZEnIiIiIoexFbzrTuSPlTdDCCAl3A8RAVo5h0akeJIkOWSfvK1iPWfk3RYTeSIiIiJyGGsv+TPdifyR7urZnI0nco1ZKSPrJ28yC5TUM5F3d0zkiYiIiMhhrDPyxXVtMJqBI2VNALg/nshVZo0JB2ApMmk0me1+fEVjB/RGM7w1KsSH+jp6eOQgTOSJiIiIyGHiQ3wRqNXAaBao6gCOlVn26TKRJ3KN9JhABPlo0NplxLcXWgZ/wCVsFesj/KFWSY4eHjkIE/kecnNzkZGRgezsbLmHQkREROSRJElCWves/JE6Fdr0JgRqNUiNCpR5ZESjg1olITvFuk/e/jZ0F1vPsdCdO2Mi30NOTg4KCgqQl5cn91CIiIiIPFZatCVp/6bGMps3LSmEM3tELnSxn7z9++QvVqzn/nh3xkSeiIiIiBzKWvCu1WhJ3rmsnsi1rIl83rkGmM3CrscWsYe8R2AiT0REREQOZS14Z8VEnsi1JscHw9dLjcZ2Awq7Z9iHqpgz8h6BiTwREREROdSEHom8JAHTEkPkGwzRKOSlVmF6cggA+/rJN7XrUdeqBwCM4R55t8ZEnoiIiIgcKsTPG9GBWgBAelQAAn28ZB4R0egzK8XShs6effLWZfUxQT4I0GqcMi5yDCbyRERERORwadGWZblZSSHyDoRolLpY8K4eQgxtn7xtWX0UZ+PdHRN5IiIiInK422fEI0wrcPuMeLmHQjQqZSWFwEstoVrXhdKG9iE9hoXuPAcTeSIiIiJyuMWTY/D0dBOmxAfLPRSiUcnHS43MhBAAQ98nz9ZznoOJPBERERERkQLZ20/emsiPZaE7t8dEvofc3FxkZGQgOztb7qEQERERERGNiD2JvMFkRmm9ZQk+Z+TdHxP5HnJyclBQUIC8vDy5h0JERERERDQiM5JDoZKA0oZ2XGjuuOx9SxvaYTQL+HmrERPk46IR0nAxkSciIiIiIlKgQB8vTIqz1KkYbFa+qObisnqVSnL62GhkmMgTEREREREp1FCX11sr1o+N4LJ6T8BEnoiIiIiISKGGmsgXs2K9R2EiT0REREREpFDZKZZE/mxNK+pbuwa8n631XBQr1nsCJvJEREREREQKFebvjbRoyyx73rnGfu8jhLAtreeMvGdgIk9ERERERKRggy2vb2jTo7nDAEkCxkRwRt4TMJEnIiIiIiJSsFljwgEAB8/V9/v94jpL//j4EF/4eKldNi4aPibyRERERERECjare598QaUOuk5Dn+8X13FZvadhIt9Dbm4uMjIykJ2dLfdQiIiIiIiIHCIm2AfJ4X4wC+Dw+b775Iu5P97jMJHvIScnBwUFBcjLy5N7KERERERERA5jnZXvb598UfeM/NhI7o/3FEzkiYiIiIiIFO5yBe9KuLTe4zCRJyIiIiIiUrgrugveHS9vQofeZLvdYAbKGzsAsIe8J2EiT0REREREpHCJYb6ICfKBwSRwtOziPvnaTsAsgEAfDSIDtDKOkOzBRJ6IiIiIiEjhJEnqd3l9TYcEABgbGQBJkmQZG9mPiTwREREREdEo0H8ib/nvOBa68yiyJvJ79uzBzTffjLi4OEiShG3bttm+ZzAY8Mtf/hJTpkyBv78/4uLicN9996GysvKyx9ywYQMkSerz1dnZ6eRnQ0RERERE5L6u6E7kj5Q2Qm80AwCqu2fkWejOs8iayLe1tSEzMxPr1q3r87329nYcOXIETz75JI4cOYL3338fZ86cwfe+971BjxsUFIQLFy70+vLx8XHGUyAiIiIiIvII46MCEObvjU6DGScqmgEwkfdUGjlPvnjxYixevLjf7wUHB2PHjh29bnvllVcwa9YslJaWIikpacDjSpKEmJgYh46ViIiIiIjIk0mShOyUUHx2shoHSxowJdafS+s9lKyJvL2am5shSRJCQkIue7/W1lYkJyfDZDJh2rRp+N3vfoesrKwB79/V1YWuri7bv3U6HQDL8n6DwTCksVnvN9T7k/tjTJWHMVUWxlN5GFNlYTyVhzFVhhlJIfjsZDUOFNdh8cQwdJklqCUJsUHejK3M7Pn5S0II4cSxDJkkSdi6dSuWLFnS7/c7Ozsxd+5cTJgwAf/85z8HPM6BAwdQWFiIKVOmQKfT4c9//jM++eQTHDt2DKmpqf0+ZvXq1VizZk2f2zdt2gQ/P79hPR8iIiIiIiJ3U9YK/PGEBj5qgf+XZsZr36oR6SPwRJZp8AeTU7W3t2P58uVobm5GUFDQZe/rEYm8wWDA7bffjtLSUuzatWvQJ9WT2WzG9OnTcc011+Avf/lLv/fpb0Y+MTERdXV1Qz6XwWDAjh07sHDhQnh5eQ15fOS+GFPlYUyVhfFUHsZUWRhP5WFMlcFkFpjxzE60dZmwLCsW7x69gAVp4fife2fIPbRRT6fTISIiYkiJvNsvrTcYDLjjjjtQUlKCnTt32pXEA4BKpUJ2djbOnj074H20Wi20Wm2f2728vOx+kxrOY8i9MabKw5gqC+OpPIypsjCeysOYejYvANkpYdh1uhafnKwBYOkhz5jKz54YuHUfeWsSf/bsWXz++ecIDw+3+xhCCOTn5yM2NtYJIyQiIiIiIvIs1n7y7XrLcnoWuvM8ss7It7a2orCw0PbvkpIS5OfnIywsDHFxcVi2bBmOHDmCf/3rXzCZTKiqqgIAhIWFwdvbGwBw3333IT4+Hs8++ywAYM2aNbjyyiuRmpoKnU6Hv/zlL8jPz0dubq7rnyAREREREZGbsfaTtxobwUTe08iayB86dAgLFiyw/fvxxx8HANx///1YvXo1PvzwQwDAtGnTej3uyy+/xPz58wEApaWlUKkuLixoamrCypUrUVVVheDgYGRlZWHPnj2YNWuWc58MERERERGRB5gSHwKtRoUuoxkAMJYz8h5H1kR+/vz5uFytvaHU4du1a1evf7/88st4+eWXRzo0IiIiIiIiRfLWqDA9KRT7i+vhrxEI9fOWe0hkJ7feI09ERERERESOZ90nH+Ur80BoWNy+aj0RERERERE51p3Zifi6sBZTtPVyD4WGgTPyREREREREo0xciC82PzAL08IH385M7oeJfA+5ubnIyMhAdna23EMhIiIiIiIi6hcT+R5ycnJQUFCAvLw8uYdCRERERERE1C8m8kREREREREQehIk8ERERERERkQdhIk9ERERERETkQZjIExEREREREXkQJvJEREREREREHoSJPBEREREREZEHYSJPRERERERE5EGYyBMRERERERF5ECbyRERERERERB6EiXwPubm5yMjIQHZ2ttxDISIiIiIiIuoXE/kecnJyUFBQgLy8PLmHQkRERERERNQvJvJEREREREREHoSJPBEREREREZEHYSJPRERERERE5EGYyBMRERERERF5ECbyRERERERERB5EI/cA3JEQAgCg0+mG/BiDwYD29nbodDp4eXk5a2jkQoyp8jCmysJ4Kg9jqiyMp/IwpsrDmLoXa/5pzUcvh4l8P1paWgAAiYmJMo+EiIiIiIiIRpOWlhYEBwdf9j6SGEq6P8qYzWZUVlYiMDAQkiQN6TE6nQ6JiYkoKytDUFCQk0d4UXZ2tix97+U4r6vPOZpiOlrOyZgq65yMp/LOy5gq65xyxRMYHT9fOc7J16jyzsuYutc5hRBoaWlBXFwcVKrL74LnjHw/VCoVEhIShvXYoKAgl74I1Gq1y/84ynVeuZ7raIjpaDmnFWOqnHMCjKcSz8uYKuecgOvjCYyen+9oielo+tkypjznYDPxVix25+FycnJGzXnleq6uNlp+tqMlnsDo+fmOlpiOpp8tY8pzeqrR8vMdLTEdTT9bxpTnHCourXcQnU6H4OBgNDc3yzbLSI7FmCoPY6osjKfyMKbKwngqD2OqPIyp5+KMvINotVo8/fTT0Gq1cg+FHIQxVR7GVFkYT+VhTJWF8VQexlR5GFPPxRl5IiIiIiIiIg/CGXkiIiIiIiIiD8JEnoiIiIiIiMiDMJEnIiIiIiIi8iBM5ImIiIiIiIg8CBN5IiIiIiIiIg/CRH4YWOjf83V2dso9BHIwo9Fo+3++RoncT3l5OS5cuACAr1ElYkw9H6+NlIfXRsrG9nOD0Ov1ePnll+Hv748pU6Zg3rx5cg+Jhsn6q/7jH/8YBQUFeOeddxAWFibzqGik9Ho9nnrqKTQ0NCA2Nha/+tWv4OvrK/ewaAQMBgP++c9/IiQkBBMnTsSECRPkHhKNgMFgwCOPPIJPP/0UjzzyCH7xi1/IPSQaIV4bKQevjZSJ10ajA2fkL+PTTz9FXFwctm3bhvXr12Pp0qV44okn+Imlh5IkCU1NTXj33Xfx5Zdf4u2335Z7SDRC27ZtQ3JyMg4ePAgfHx+8+OKLWLlyJYQQ/OTZQ/31r39FdHQ03njjDTz22GO47bbbbK9Vs9ks8+jIXmVlZZgzZw5OnDiBd955B3fffTdfnx6O10bKwmsj5eG10ejBGfnLuOOOOxAWFobXX38djY2N+OKLL/Bf//VfeO655/Dggw/yky0PtHfvXrz++utIS0vDn//8Z+Tn5yMxMVHuYdEwdHV1YenSpcjKysIf/vAHAMAHH3yA5cuXo76+Hj4+PjKPkOxhNBrxyiuvYP369fjVr36F5cuX4/jx4/j73/+Offv24eDBg1Cp+Nmzp/nHP/6BLVu2YPv27ZAkCeXl5YiOjoaXl5fcQ6Nh4rWR8vDaSDl4bTS68KqoB5PJZPv/kpIS7Nu3D1dffTUAIDQ0FMuWLcPKlSvxz3/+E3v37pVrmDRE1nj2/ATSy8sLhYWF+MlPfoLAwEA8++yzcg6R7NTzNXrixAns2rUL1113ne22qqoqrFy5kjO3HqS1tRXt7e22/1+2bBnuuusuAMDUqVMxadIkaDQa1NbWyjlMGqKe8RRC4NChQ8jMzERTUxPuuOMOLFy4ELNmzcLKlStRVVUl82jJXsXFxbw2UhBeGynP8ePHeW00ijCR7/bkk0/iySeftP07JSUFRqMROp0OANDR0QEAePrpp9HW1oZPP/0Ura2tsoyVBtcznpIkQZIkAMChQ4eQmpqKwMBA/P73v8c//vEPHDp0CK+//jqKiorkHDIN4tLX6MyZMxEeHo5169bh008/xc9//nM8/PDD2LlzJ1JTU/Haa6/Zkj8uPHJPP//5zzF79mw0NDRArVbjnnvuwVNPPQWVSmWLWWhoKFpbWxEVFSXzaGkw1njW19cDsLz3njx5EgCwdu1aAMC6devw0EMP4aOPPsLTTz+NiooKAHyNuqvt27fj2LFjtg9Rx4wZA4PBwGsjD2WNpzWh47WR57v0NZqdnY2wsDBeG40Soz6R/+CDDxATE4MdO3YgPj4ejY2NACx7MZcuXYrXX38dAODr6wuDwYDw8HCsWLEC7777bq9KkOQeLhdPq9DQUADAf/3XfyElJQWzZs3Cm2++Kct4aXD9xdT6x+fNN99EbGwsVq9ejW3btmHHjh1455138PDDD+Pll1/Gp59+CuDixQq5h9dffx3BwcHYsmULTp48icLCQkiShLFjxwKwvF6tMfv3v/+NrKwsSJIEg8Eg57BpAJfGs7i42Pa9pUuXYu3atdiyZQt+8Ytf4LrrrsODDz6IZ599Fl9//TWOHj0KgK9Rd7NhwwbExsbiZz/7Ga6++mr8+Mc/RmVlJSRJ4rWRB7o0nj/60Y9sHSSseG3kWfp7jZaXlwPgtdGoIkax1tZWcfPNN4vf/va3/X7/vffeE+np6WLt2rVCCCE6OzuFEELU1tYKX19f8dVXX7lsrDS4weIphBA5OTnitddeE2fOnBGTJk0SoaGhQqVSiX/+858uHCkN1VBiqtfrxaJFi8TGjRt73T5p0iTx61//2tlDJDt89dVXYsyYMSI2NlZs2rRJFBUVienTp4u//e1vfe5rNBqFwWAQ06dPF3/961/7fN9kMrliyHQZA8Xzf/7nf2z3OXr0qMjKyhIpKSmioqKi1+Pj4+PFa6+95uph0yD+/ve/i/Hjx4vNmzeL2tpa8eabbwp/f3+Rn58vhLBcG02YMIHXRh6iv3gGBATY4imEEI888givjTzIYK9RIYQwGAy8NhoFRvWM/K5du3DgwAH85je/QWNjI371q1/h+eeft30Ced1112HRokX405/+hMrKSmi1WgDA0aNHERkZicDAQDmHT5cYKJ6bN2+2LTlSqVR49NFHMWnSJFxzzTU4e/YsfvjDH+Lpp5+2LQcl93G5mFpXWdTW1iIvLw/z588HYNlH39zcDF9fX/j7+8s4errUhx9+iBtvvBElJSW4++67MXbsWNTX19uWV/esgaBWq1FXV4eamhpba6v8/HysWLECAFj4zg30F8+GhgZUVlba7pOWloZ77rkHZWVl+Prrr22319bWIiwsjH9H3YgQAiaTCTt37sTs2bNx1113ISIiAsuXL0d8fLztPXfOnDm8NvIAl4tnXFycbTbWaDRCrVbz2sgDDPYa7YnXRqPDqLwSEt3LcqurqzFnzhx8+eWXmDFjBvLz87Fv3z7cf//9+NGPfgSz2YzHH38cCQkJuOmmm/Dmm2+isLAQb7zxBtLS0pCamirzMyFg8Hjee++9eOyxx9Da2orp06djxYoV2L9/P1599VWEh4fjiSeeQGVlJY4fPy7zMyGroca0oqICUVFRSExMxEMPPYTjx4+jvLwcP/3pT9HW1oZbbrlF5mdCPT333HNYt24dtFqtbfnt/PnzbQWy1Gp1r/t//vnnGDNmDOLi4vCDH/wAs2bNQlNTE8xmM/f2uYH+4jlv3rxeBc/8/PywYsUKLFmyBD/96U+xevVq5OfnY9WqVdBoNLj22mvlGj5dQpIkqNVqFBQUQKvVorq6GoClv7gkSfjwww+xf/9+REdH49FHH+W1kZsbLJ5bt27F/v37odFoMHXqVF4beYDBYrpt2zYcOHAA7e3tCA8P57XRaCDjagCXefvtt8UDDzwg1q5dK44fP267ffPmzSI4OFg8/PDD4qmnnhJ6vV4IIcSGDRvEFVdcIf74xz8KIYSoqqoSN9xwg5g4caKIj48Xc+bMESUlJXI8FRLDi2d2drZtGaDRaOxzzKamJtcMnvo10tfonj17RGRkpEhLSxMJCQliwYIF4uzZs7I8F7IYKKaXLol/8MEHxYIFC0Rzc3OfY9x1111CrVaLwMBAMXPmTPHtt986fdzUv+HE02w2227X6/Xixz/+sZgxY4ZIT08X8+bNE4WFhS4bP/U1UEy3bNkikpOTxaJFi0R4eLiYMGGC+O1vfysWLFggpk6dKp577jkhBK+N3M1w4jl58mTxpz/9SQjBayN3NJyYZmZm2l6jvDZSPkUn8nV1dWLZsmUiJiZGPPTQQ2Lu3LkiLi5ObNiwQQghhNlsFpMnTxaSJIn169fbHmc2m8Vtt90mfvCDH4iuri4hhGUP2IULF8SJEyfkeCokRh7PBx54oN8/VCQfR7xGrTEtLS0VBw8eFAcPHpTjqVC3gWLac5+e2Wy2JYAbNmwQQUFBvV6b1gTw7rvvFikpKeLjjz927ZMgG0fEs2ey39raygReZgPFtOd7bE1NjXjxxRfFvHnzhE6ns93+wx/+UCxdulRUV1cLIYTo6OjgtZHMHBHPuro6GUZOAxlpTJcsWWKL6fnz53ltpGAauVcEONOXX36J0tJSHDp0yLZ3ZMmSJVizZg2Cg4OxZMkSPPzww8jJyUF7ezuMRiM0Gg0kSUJgYCAKCgrg7e0NAPD29kZMTAxiYmLkfEqj2kjjefLkyT5Ld0lejniNWmOamJiIxMREOZ8OYeCYrl69GkFBQViyZAmEELY97gkJCQgODsbu3btty6ytezfXrFnDZboyc0Q8e9Yz8Pf3x7hx41z/RMhmoJj+9re/RXBwMJYuXYrQ0FAcPnwYCxcuRGBgIPR6Pby9vREYGIidO3fa9thqtVpeG8nMEfH09fWV+VlQT46IqY+PDwAgKSkJSUlJcj4dciJF75HftGkTEhISEB8fb+trunTpUpw7dw7r1q1DfX09HnzwQSxcuBCvvPIKdu7cCQCoqqpCZWUlvv/979uOxRYN8nNkPMk9MKbKM1hM6+rqoFKpbIXtwsLCoNfrexW6s2ISLz9HxpPcw+Vimpubi5qaGmg0GtTX1+PQoUMALJMZ1dXVOHPmDO666y5bIs9rI/k5Ip5+fn5yPgW6hCNfo6Rsiknk9+zZg88++6xX/9LU1FScPHkSABAQEAAAOHXqFK699lp0dHTg/fffh0qlwptvvomoqCgsX74cN954I6ZNmwaDwYCbbrpJludCjKcSMabKY29MOzs7sXXrVgAXC9tlZWXBbDb3qmhO8mA8lWc4Md22bRsAYNWqVfj4448xZ84cPPzww5g5cyZ0Oh1Wrlzp8udBFoyn8jCmNCJyr+0fqdraWnHfffcJSZJEZmZmr0IrRUVFIjIyUsybN088//zzYvbs2WLMmDHiiy++EJmZmeKJJ56w7eOrrq4W27dvFy+++KLYunWrPE+GGE8FYkyVZyQxffLJJ4UQF/fB19bWiv/+7/8WO3fulOOpkGA8lWik77tWW7duFb/85S/F8uXLxdtvvy3DMyEhGE8lYkzJETw6kTcYDOLVV18V119/vdiyZYvw8/MTzz77rOjs7LTdZ+/eveKHP/yhmD59unjkkUdEbW2tEEKIe++9V9x2221yDZ36wXgqD2OqPIypsjCeysOYKgvjqTyMKTmKRyfyQghx4MAB8dFHHwkhhFizZo2IjIwUR48e7XM/a/V5ISwze5MnTxa///3vhRB92+eQfBhP5WFMlYcxVRbGU3kYU2VhPJWHMSVH8PhEvmefWiGEiIuLEytXrrS1Yuj5/Y6ODqHX68Wrr74qsrKyevVkJPfAeCoPY6o8jKmyMJ7Kw5gqC+OpPIwpOYLHJ/JW1k+s3n77baHRaMT27dt7fb+8vFy8+uqrYubMmSIsLExs2rRJjmHSEDGeysOYKg9jqiyMp/IwpsrCeCoPY0ojIQkhhNwF9xztqquugr+/v63SdW1tLSIjI7F582ZUVlbipz/9qdxDJDswnsrDmCoPY6osjKfyMKbKwngqD2NK9lJUIm80GqHRaHDy5ElkZmbipZdeQlFREfbu3YuNGzdi8uTJcg+R7MB4Kg9jqjyMqbIwnsrDmCoL46k8jCkNl6IS+Z5mzZqFQ4cOISkpCX/9619x/fXXyz0kGgHGU3kYU+VhTJWF8VQexlRZGE/lYUzJHiq5B+BoRUVFmDJlCk6ePIm//e1vOHfuHF8EHozxVB7GVHkYU2VhPJWHMVUWxlN5GFMaDsUl8mq1Grfddhvq6urwgx/8QO7h0AgxnsrDmCoPY6osjKfyMKbKwngqD2NKw6HYpfVERERERERESqS4GXkiIiIiIiIiJWMiT0RERERERORBmMgTEREREREReRAm8kREREREREQehIk8ERERERERkQdhIk9ERERERETkQZjIExEREREREXkQJvJERERkl9WrV2PatGlyD4OIiGjUkoQQQu5BEBERkXuQJOmy37///vuxbt06dHV1ITw83EWjIiIiop6YyBMREZFNVVWV7f/feustPPXUUzh9+rTtNl9fXwQHB8sxNCIiIurGpfVERERkExMTY/sKDg6GJEl9brt0af2KFSuwZMkSPPPMM4iOjkZISAjWrFkDo9GIn//85wgLC0NCQgLeeOONXueqqKjAnXfeidDQUISHh+OWW27BuXPnXPuEiYiIPBATeSIiIhqxnTt3orKyEnv27MFLL72E1atX47vf/S5CQ0PxzTff4KGHHsJDDz2EsrIyAEB7ezsWLFiAgIAA7NmzB3v37kVAQABuuOEG6PV6mZ8NERGRe2MiT0RERCMWFhaGv/zlL0hPT8f3v/99pKeno729Hb/+9a+RmpqKVatWwdvbG19//TUAYMuWLVCpVPj73/+OKVOmYOLEiVi/fj1KS0uxa9cueZ8MERGRm9PIPQAiIiLyfJMmTYJKdXF+IDo6GpMnT7b9W61WIzw8HDU1NQCAw4cPo7CwEIGBgb2O09nZiaKiItcMmoiIyEMxkSciIqIR8/Ly6vVvSZL6vc1sNgMAzGYzZsyYgTfffLPPsSIjI503UCIiIgVgIk9EREQuN336dLz11luIiopCUFCQ3MMhIiLyKNwjT0RERC53zz33ICIiArfccgu++uorlJSUYPfu3Xj00UdRXl4u9/CIiIjcGhN5IiIicjk/Pz/s2bMHSUlJuPXWWzFx4kR8//vfR0dHB2foiYiIBiEJIYTcgyAiIiIiIiKioeGMPBEREREREZEHYSJPRERERERE5EGYyBMRERERERF5ECbyRERERERERB6EiTwRERERERGRB2EiT0RERERERORBmMgTEREREREReRAm8kREREREREQehIk8ERERERERkQdhIk9ERERERETkQZjIExEREREREXkQJvJEREREREREHuT/AwDrAWZcQs2EAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "cold_nights_mean = cold_nights.mean(dim=['latitude', 'longitude']) # Averaging over the spatial dimensions\n", - "\n", - "# Plotting the time series\n", - "plt.figure(figsize=(12, 6))\n", - "cold_nights_mean.plot()\n", - "plt.title('Number of Days with Daily Minimum Temperature below the 10th Percentile')\n", - "plt.xlabel('Time')\n", - "plt.ylabel('Number of Days')\n", - "plt.grid(True)\n", - "plt.minorticks_on()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xclim/core/utils.py:461: RuntimeWarning: All-NaN slice encountered\n", - " result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n" - ] - } - ], - "source": [ - "from xclim.indices import tn90p\n", - "\n", - "\n", - "tasmin_per_90 = percentile_doy(data['t2m'], per=90, window=5).sel(percentiles=90)\n", - "warm_nights = tn90p(data['t2m'], tasmin_per_90)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "warm_nights_mean = warm_nights.mean(dim=['latitude', 'longitude']) # Averaging over the spatial dimensions\n", - "\n", - "# Plotting the time series\n", - "plt.figure(figsize=(12, 6))\n", - "warm_nights_mean.plot()\n", - "plt.title('Number of Days with Daily Minimum Temperature above the 90th Percentile')\n", - "plt.xlabel('Time')\n", - "plt.ylabel('Number of Days')\n", - "plt.grid(True)\n", - "plt.minorticks_on()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xclim/core/utils.py:461: RuntimeWarning: All-NaN slice encountered\n", - " result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n" - ] - } - ], - "source": [ - "from xclim.indices import warm_spell_duration_index\n", - "\n", - "\n", - "tasmax_per_90 = percentile_doy(data['t2m'], per=90, window=5).sel(percentiles=90)\n", - "warm_spell_index = warm_spell_duration_index(data['t2m'], tasmax_per_90)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "warm_spell_index_mean = warm_spell_index.mean(dim=['latitude', 'longitude']) # Averaging over the spatial dimensions\n", - "\n", - "# Plotting the time series\n", - "plt.figure(figsize=(12, 6))\n", - "warm_spell_index_mean.plot()\n", - "plt.title('Warm Spells')\n", - "plt.xlabel('Time')\n", - "plt.ylabel('Number of Days')\n", - "plt.grid(True)\n", - "plt.minorticks_on()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xclim/core/utils.py:461: RuntimeWarning: All-NaN slice encountered\n", - " result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n" - ] - } - ], - "source": [ - "from xclim.indices import cold_spell_duration_index\n", - "\n", - "\n", - "tasmin_per_10 = percentile_doy(data['t2m'], per=10, window=5).sel(percentiles=10)\n", - "cold_spell_index = cold_spell_duration_index(data['t2m'], tasmin_per_10)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "cold_spell_index_mean = cold_spell_index.mean(dim=['latitude', 'longitude']) # Averaging over the spatial dimensions\n", - "\n", - "# Plotting the time series\n", - "plt.figure(figsize=(12, 6))\n", - "cold_spell_index_mean.plot()\n", - "plt.title('Cold Spells')\n", - "plt.xlabel('Time')\n", - "plt.ylabel('Number of Days')\n", - "plt.grid(True)\n", - "plt.minorticks_on()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from xclim.indices import frost_days\n", - "\n", - "\n", - "frost_days_index = frost_days(data['t2m'], thresh='273.15 K')\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "frost_days_index_mean = frost_days_index.mean(dim=['latitude', 'longitude']) # Averaging over the spatial dimensions\n", - "\n", - "# Plotting the time series\n", - "plt.figure(figsize=(12, 6))\n", - "frost_days_index_mean.plot()\n", - "plt.title('Frost Days')\n", - "plt.xlabel('Time')\n", - "plt.ylabel('Number of Days')\n", - "plt.grid(True)\n", - "plt.minorticks_on()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Pre-Processing of the Data " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Lets try to write a function which will take care of all the pre-processing functions of the dataset input" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def pre_process(datafile, time_range=None, fill_missing=None, resample_freq=None, months=None, season=None, resample_method='mean'):\n", - " try:\n", - " print(\"Loading data...\")\n", - " # 1. Loading Data\n", - " data = xr.open_dataset(datafile)\n", - " print(\"Data loaded successfully.\")\n", - "\n", - " # Check if the time dimension exists\n", - " if 'time' not in data.dims:\n", - " raise ValueError(\"Time dimension not found in the dataset.\")\n", - " print(\"Time axis found.\")\n", - "\n", - " # 2. Time Selection\n", - " if time_range:\n", - " print(f\"Selecting data within time range: {time_range[0]} to {time_range[1]}...\")\n", - " start_time, end_time = time_range\n", - " data = data.sel(time=slice(start_time, end_time))\n", - " print(\"Time selection completed.\")\n", - "\n", - " # 3. Select specific months\n", - " if months:\n", - " print(f\"Selecting data for specific months: {months}...\")\n", - " data = data.sel(time=data['time.month'].isin(months))\n", - " print(\"Month selection completed.\")\n", - "\n", - " # 4. Select specific season\n", - " if season:\n", - " print(f\"Selecting data for specific season: {season}...\")\n", - " data = data.sel(time=data['time.season'] == season)\n", - " print(\"Season selection completed.\")\n", - "\n", - " # 5. Resample or aggregate data\n", - " if resample_freq:\n", - " print(f\"Resampling data with frequency: {resample_freq}, using method: {resample_method}...\")\n", - " resampler = data.resample(time=resample_freq)\n", - " if resample_method in dir(resampler):\n", - " data = getattr(resampler, resample_method)()\n", - " else:\n", - " raise ValueError(f\"Unknown resampling method: {resample_method}.\")\n", - " print(\"Resampling completed.\")\n", - " \n", - " # 6. Handling Missing Values (NaN)\n", - " if fill_missing:\n", - " if isinstance(fill_missing, (int, float)):\n", - " print(f\"Filling missing values with specified value: {fill_missing}...\")\n", - " data = data.fillna(fill_missing)\n", - " elif fill_missing == 'interpolate':\n", - " print(\"Filling missing values using interpolation...\")\n", - " data = data.interpolate_na(dim='time', method='linear')\n", - " else:\n", - " print(f\"Unknown method to fill missing values: {fill_missing}. Skipping this step.\")\n", - " print(\"Missing values handling completed.\")\n", - "\n", - " return data\n", - "\n", - " except Exception as e:\n", - " print(f\"An error occurred while processing the data: {str(e)}\")\n", - " return data # Return the modified dataset up to the point of failure\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading data...\n", - "Data loaded successfully.\n", - "Time axis found.\n" - ] - } - ], - "source": [ - "filepath = '/home/posiden/Documents/Datasets/era5/india.1960.1990.nc'\n", - "\n", - "test = pre_process(filepath)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:    (time: 10957, bnds: 2, longitude: 161, latitude: 141)\n",
-       "Coordinates:\n",
-       "  * time       (time) datetime64[ns] 1961-01-01T11:00:00 ... 1990-12-31T11:00:00\n",
-       "  * longitude  (longitude) float32 60.0 60.25 60.5 60.75 ... 99.5 99.75 100.0\n",
-       "  * latitude   (latitude) float32 40.0 39.75 39.5 39.25 ... 5.75 5.5 5.25 5.0\n",
-       "Dimensions without coordinates: bnds\n",
-       "Data variables:\n",
-       "    time_bnds  (time, bnds) datetime64[ns] ...\n",
-       "    t2m        (time, latitude, longitude) float32 ...\n",
-       "Attributes:\n",
-       "    CDI:          Climate Data Interface version 2.0.4 (https://mpimet.mpg.de...\n",
-       "    Conventions:  CF-1.6\n",
-       "    history:      Thu Aug 10 10:42:11 2023: cdo sellonlatbox,60,100,5,40 land...\n",
-       "    frequency:    day\n",
-       "    CDO:          Climate Data Operators version 2.0.4 (https://mpimet.mpg.de...
" - ], - "text/plain": [ - "\n", - "Dimensions: (time: 10957, bnds: 2, longitude: 161, latitude: 141)\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 1961-01-01T11:00:00 ... 1990-12-31T11:00:00\n", - " * longitude (longitude) float32 60.0 60.25 60.5 60.75 ... 99.5 99.75 100.0\n", - " * latitude (latitude) float32 40.0 39.75 39.5 39.25 ... 5.75 5.5 5.25 5.0\n", - "Dimensions without coordinates: bnds\n", - "Data variables:\n", - " time_bnds (time, bnds) datetime64[ns] ...\n", - " t2m (time, latitude, longitude) float32 ...\n", - "Attributes:\n", - " CDI: Climate Data Interface version 2.0.4 (https://mpimet.mpg.de...\n", - " Conventions: CF-1.6\n", - " history: Thu Aug 10 10:42:11 2023: cdo sellonlatbox,60,100,5,40 land...\n", - " frequency: day\n", - " CDO: Climate Data Operators version 2.0.4 (https://mpimet.mpg.de..." - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "def plot_tx10p(data, title):\n", - " # Take the mean along latitude and longitude\n", - " data_mean = data.mean(dim=['latitude', 'longitude'])\n", - " \n", - " data_mean.plot(figsize=(10, 5))\n", - " plt.title(title)\n", - " plt.xlabel('Time')\n", - " plt.ylabel('tx10p Index')\n", - " plt.grid(True)\n", - " plt.show()\n", - "\n", - "# Path to your data file\n", - "datafile = '/home/posiden/Documents/Datasets/era5/india.1960.1990.nc'\n", - "\n", - "# Test for specific months (e.g., January, February, March)\n", - "processed_data_months = pre_process(datafile, months=[1, 2, 3])\n", - "tasmax_per_months = percentile_doy(processed_data_months['t2m'], per=10, window=5).sel(percentiles=10)\n", - "tx10p_months = tx10p(processed_data_months['t2m'], tasmax_per_months)\n", - "plot_tx10p(tx10p_months, \"tx10p for Specific Months: January, February, March\")\n", - "\n", - "# Test for specific season (e.g., Summer: June, July, August)\n", - "processed_data_season = pre_process(datafile, season='JJA')\n", - "tasmax_per_season = percentile_doy(processed_data_season['t2m'], per=10, window=5).sel(percentiles=10)\n", - "tx10p_season = tx10p(processed_data_season['t2m'], tasmax_per_season)\n", - "plot_tx10p(tx10p_season, \"tx10p for Specific Season: Summer (JJA)\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Class Implementation " - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading data...\n", - "Data loaded successfully.\n", - "Time axis found.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xclim/core/utils.py:461: RuntimeWarning: All-NaN slice encountered\n", - " result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import xarray as xr\n", - "from xclim.indices import tx10p, tx90p, tn10p, tn90p, warm_spell_duration_index, cold_spell_duration_index, frost_days\n", - "from xclim.core.calendar import percentile_doy\n", - "\n", - "class ClimateIndex:\n", - " def __init__(self, datafile):\n", - " self.datafile = datafile\n", - " self.data = None\n", - "\n", - " def pre_process(self, time_range=None, fill_missing=None, resample_freq=None, months=None, season=None, resample_method='mean'):\n", - " try:\n", - " print(\"Loading data...\")\n", - " # 1. Loading Data\n", - " self.data = xr.open_dataset(self.datafile)\n", - " print(\"Data loaded successfully.\")\n", - "\n", - " # Check if the time dimension exists\n", - " if 'time' not in self.data.dims:\n", - " raise ValueError(\"Time dimension not found in the dataset.\")\n", - " print(\"Time axis found.\")\n", - "\n", - " # 2. Time Selection\n", - " if time_range:\n", - " print(f\"Selecting data within time range: {time_range[0]} to {time_range[1]}...\")\n", - " start_time, end_time = time_range\n", - " self.data = self.data.sel(time=slice(start_time, end_time))\n", - " print(\"Time selection completed.\")\n", - "\n", - " # 3. Select specific months\n", - " if months:\n", - " print(f\"Selecting data for specific months: {months}...\")\n", - " self.data = self.data.sel(time=self.data['time.month'].isin(months))\n", - " print(\"Month selection completed.\")\n", - "\n", - " # 4. Select specific season\n", - " if season:\n", - " print(f\"Selecting data for specific season: {season}...\")\n", - " self.data = self.data.sel(time=self.data['time.season'] == season)\n", - " print(\"Season selection completed.\")\n", - "\n", - " # 5. Resample or aggregate data\n", - " if resample_freq:\n", - " print(f\"Resampling data with frequency: {resample_freq}, using method: {resample_method}...\")\n", - " resampler = self.data.resample(time=resample_freq)\n", - " if resample_method in dir(resampler):\n", - " self.data = getattr(resampler, resample_method)()\n", - " else:\n", - " raise ValueError(f\"Unknown resampling method: {resample_method}.\")\n", - " print(\"Resampling completed.\")\n", - " \n", - " # 6. Handling Missing Values (NaN)\n", - " if fill_missing:\n", - " if isinstance(fill_missing, (int, float)):\n", - " print(f\"Filling missing values with specified value: {fill_missing}...\")\n", - " data = data.fillna(fill_missing)\n", - " elif fill_missing == 'interpolate':\n", - " print(\"Filling missing values using interpolation...\")\n", - " data = data.interpolate_na(dim='time', method='linear')\n", - " else:\n", - " print(f\"Unknown method to fill missing values: {fill_missing}. Skipping this step.\")\n", - " print(\"Missing values handling completed.\")\n", - "\n", - " except Exception as e:\n", - " print(f\"An error occurred while processing the data: {str(e)}\")\n", - " # Return the modified dataset up to the point of failure (already updated in self.data)\n", - "\n", - " def calculate_tx10p(self):\n", - " tasmax_per = percentile_doy(self.data['t2m'], per=10, window=5).sel(percentiles=10)\n", - " return tx10p(self.data['t2m'], tasmax_per)\n", - "\n", - " def calculate_tx90p(self):\n", - " tasmax_per = percentile_doy(self.data['t2m'], per=90, window=5).sel(percentiles=90)\n", - " return tx90p(self.data['t2m'], tasmax_per)\n", - "\n", - " def calculate_tn10p(self):\n", - " tasmin_per = percentile_doy(self.data['t2m'], per=10, window=5).sel(percentiles=10)\n", - " return tn10p(self.data['t2m'], tasmin_per)\n", - "\n", - " def calculate_tn90p(self):\n", - " tasmin_per = percentile_doy(self.data['t2m'], per=90, window=5).sel(percentiles=90)\n", - " return tn90p(self.data['t2m'], tasmin_per)\n", - "\n", - " def calculate_frost_days(self):\n", - " return frost_days(self.data['t2m'], thresh='273.15 K')\n", - "\n", - " def calculate_warm_spell(self):\n", - " tasmax_per = percentile_doy(self.data['t2m'], per=90, window=5).sel(percentiles=90)\n", - " return warm_spell_duration_index(self.data['t2m'], tasmax_per)\n", - "\n", - " def calculate_cold_spell(self):\n", - " tasmin_per = percentile_doy(self.data['t2m'], per=10, window=5).sel(percentiles=10)\n", - " return cold_spell_duration_index(self.data['t2m'], tasmin_per)\n", - "\n", - "\n", - "# Example usage:\n", - "climate_index = ClimateIndex(datafile='/home/posiden/Documents/Datasets/era5/india.1960.1990.nc')\n", - "climate_index.pre_process()\n", - "tx10p_index = climate_index.calculate_tx10p()\n", - "\n", - "def plot_tx10p(data, title):\n", - " # Take the mean along latitude and longitude\n", - " data_mean = data.mean(dim=['latitude', 'longitude'])\n", - " \n", - " data_mean.plot(figsize=(10, 5))\n", - " plt.title(title)\n", - " plt.xlabel('Time')\n", - " plt.ylabel('tx10p Index')\n", - " plt.grid(True)\n", - " plt.show()\n", - "\n", - "plot_tx10p(tx10p_index, \"tx10p test\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Adding the precipitation climate indices to the code " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "import xarray as xr\n", - "from xclim.core.calendar import percentile_doy\n", - "\n", - "# Open the precipitation dataset\n", - "pr = xr.open_dataset('/home/posiden/Documents/Datasets/era5/india.tp.1960.1990.nc')['tp']" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray 'tp' (time: 30316, latitude: 129, longitude: 201)>\n",
-       "[786063564 values with dtype=float32]\n",
-       "Coordinates:\n",
-       "  * time       (time) datetime64[ns] 1940-01-01T15:00:00 ... 2022-12-31T11:30:00\n",
-       "  * longitude  (longitude) float32 60.0 60.25 60.5 60.75 ... 109.5 109.8 110.0\n",
-       "  * latitude   (latitude) float32 40.0 39.75 39.5 39.25 ... 8.75 8.5 8.25 8.0\n",
-       "Attributes:\n",
-       "    long_name:     Total precipitation\n",
-       "    units:         m\n",
-       "    cell_methods:  time: sum
" - ], - "text/plain": [ - "\n", - "[786063564 values with dtype=float32]\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 1940-01-01T15:00:00 ... 2022-12-31T11:30:00\n", - " * longitude (longitude) float32 60.0 60.25 60.5 60.75 ... 109.5 109.8 110.0\n", - " * latitude (latitude) float32 40.0 39.75 39.5 39.25 ... 8.75 8.5 8.25 8.0\n", - "Attributes:\n", - " long_name: Total precipitation\n", - " units: m\n", - " cell_methods: time: sum" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pr" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "array([5833.6074, 5759.2524, 5832.7188, 6494.1206, 6440.3076, 5772.3203,\n", - " 7318.976 , 5529.348 , 6215.423 , 7015.5273, 6956.2344, 6685.801 ,\n", - " 7069.6055, 7519.4062, 6421.999 , 6522.053 , 7213.692 , 6957.217 ,\n", - " 7615.8154, 7597.4424, 6733.8555, 6473.2856, 5711.1895, 5848.332 ,\n", - " 6420.326 , 5977.493 , 6028.235 , 6108.2666, 5785.5137, 5686.1104,\n", - " 4597.0405, 4439.096 , 4565.6255, 5701.1626, 4651.7676, 4504.424 ,\n", - " 4499.5874, 4293.6646, 5053.4917, 5766.2227, 4993.686 , 5015.5244,\n", - " 4987.5874, 6367.217 , 5503.7017, 5124.299 , 5108.6016, 5461.966 ,\n", - " 5328.246 , 5113.58 , 4996.259 , 5830.415 , 6558.163 , 6906.4033,\n", - " 5816.5884, 7218.743 , 6334.341 , 6550.215 , 7623.957 , 5905.783 ,\n", - " 5059.743 , 5556.7305, 6225.0747, 5735.426 , 6168.7812, 7138.506 ,\n", - " 5883.5317, 6065.459 , 6546.877 , 5905.8823, 6959.7363, 5716.47 ,\n", - " 5689.373 , 6672.415 , 5951.791 , 7061.704 , 6304.9033, 7233.3013,\n", - " 7085.116 , 6631.043 , 7089.6084, 6226.7344, 6137.1733],\n", - " dtype=float32)\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 1940-12-31 1941-12-31 ... 2022-12-31\n" - ] - } - ], - "source": [ - "import xarray as xr\n", - "import numpy as np\n", - "\n", - "# Open the precipitation dataset\n", - "pr = xr.open_dataset('/home/posiden/Documents/Datasets/era5/india.tp.1960.1990.nc')['tp']\n", - "\n", - "# Exclude leap day (February 29th) if present\n", - "pr = pr.where((pr['time.month'] != 2) | (pr['time.day'] != 29), drop=True)\n", - "\n", - "# Define wet day threshold in millimeters\n", - "wet_day_thresh_mm = 1.0\n", - "\n", - "# Convert the threshold to meters\n", - "wet_day_thresh_meters = wet_day_thresh_mm / 1000.0\n", - "\n", - "# Calculate the 95th percentile for the reference period (e.g., 1961-1990)\n", - "reference_period = pr.sel(time=slice('1961-01-01', '1990-12-31'))\n", - "wet_days_reference = reference_period.where(reference_period >= wet_day_thresh_meters)\n", - "p95_reference = wet_days_reference.groupby('time.dayofyear').reduce(np.nanpercentile, q=95, dim='time')\n", - "\n", - "# Identify wet days\n", - "wet_days = pr.where(pr >= wet_day_thresh_meters)\n", - "\n", - "# Compare each day with the corresponding percentile\n", - "exceeding_days = wet_days.groupby('time.dayofyear') > p95_reference\n", - "\n", - "# Sum the precipitation for those days (r95p index)\n", - "r95p_index_time_series = (exceeding_days * pr).sum(dim=['latitude', 'longitude']).resample(time='Y').sum()\n", - "\n", - "# This will give you a time series of the R95p index\n", - "print(r95p_index_time_series)\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/YAAAIxCAYAAADngiPsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydeZgU5bX/v9X7dM9MzwyzAiOLCzCCooCCRI0LoIiamKjRiJoYk3tD9Br1eq/JvbkmMS7xl6hRkhuNVxN3Y6JRgwi4JQrIiKLCsO8Ms6+9TO/1+6Pqre6e6aWqunqp7vN5njyRnurut7q6633P+z3nezie53kQBEEQBEEQBEEQBKFLDPkeAEEQBEEQBEEQBEEQ6qHAniAIgiAIgiAIgiB0DAX2BEEQBEEQBEEQBKFjKLAnCIIgCIIgCIIgCB1DgT1BEARBEARBEARB6BgK7AmCIAiCIAiCIAhCx1BgTxAEQRAEQRAEQRA6hgJ7giAIgiAIgiAIgtAxFNgTBEEQBEEQBEEQhI6hwJ4gCIIoSZ566ilwHCf9z2QyoampCd/4xjewe/fuMcfzPI/f/OY3mD59OqxWK5qamvCv//qvGBgYGHNs7OvG/u++++7T9Byuv/56lJeXa/qa7HM5cOCApq8rB57n8dxzz+Hcc89FdXU1rFYrpk6dihUrVuDw4cM5H08qkl3j0f977733cP3112Py5Mn5HjJBEARRxJjyPQCCIAiCyCdPPvkkpk+fDp/Phw8//BC/+MUv8O6772LHjh2orq6Wjrv99tvx0EMP4fbbb8f555+PtrY2/OQnP0Frays2bNgAs9kc97pf//rXcdttt8U9dswxx+TknPRIJBLB1VdfjRdffBFXXXUVnnrqKTidTnz++ed44IEH8Nxzz+GNN97AwoUL8z1UAMCGDRvi/v3zn/8c7777Lt555524x1taWtDc3Ix/+7d/y+XwCIIgiBKDAnuCIAiipJk5cybmzp0LAPjyl7+McDiM//mf/8Grr76Kb33rWwCA9vZ2PPzww1ixYgXuv/9+AMCiRYtQX1+Pq6++Gk899RRuvPHGuNdtaGjA/Pnzc3syOub+++/Hiy++iPvuuw//8R//IT3+5S9/GVdeeSVOP/10fO1rX8OOHTtQVVWVs3F5vV7Y7fYxj4++tnV1dTAYDAmveWVlZdbGRxAEQRAApeITBEEQRBwsyO/q6pIe27hxI8LhMJYuXRp37LJlywAAf/nLX1S9F0ul37ZtG8477zw4HA7U1dXhBz/4Abxer6rXnDx5MpYtW4bVq1fj1FNPRVlZGaZPn47/+7//G3Psxo0bsXDhQthsNowfPx533nkngsFgwtd98cUXsWDBAjgcDpSXl2PJkiX49NNPpb9/8MEHMJvNuP322+Oex1L7n3jiiaRjDgQCeOCBBzBjxgzccccdY/7e0NCAe++9F11dXdLr3HLLLXA4HBgeHh5z/JVXXomGhoa4c0k3fiB6Pb744gssXrwYFRUVOO+885KOWy6JUvE5jsMPfvADPPnkk5g2bRrKysowd+5cbNy4ETzP44EHHsCUKVNQXl6Oc889F3v27BnzuuvWrcN5552HyspK2O12LFy4EG+//XbG4yUIgiD0BwX2BEEQBBHD/v37AQAnnHCC9FggEAAAWK3WuGPNZjM4jsPnn38+5nWee+45lJWVwWq1Ys6cOXjyyScTvl8wGMTSpUtx3nnn4dVXX8UPfvAD/P73v8eVV16p+hw+++wz3HbbbfjhD3+Iv/3tbzjppJNwww034B//+Id0TFtbG8477zwMDg7iqaeewv/+7//i008/xd133z3m9e655x5cddVVaGlpwUsvvYSnn34aLpcLZ555Jtra2gAAX/rSl3D33XfjV7/6FV577TUAwLZt27BixQpcc801uOGGG5KOd/PmzRgYGMAll1wCjuMSHnPxxRfDYDBg7dq1AIBvf/vb8Hq9eOmll+KOGxwcxN/+9jdcc801UnmEnPEzAoEALrnkEpx77rn429/+hp/+9KfpPm7VvPHGG/jDH/6A++67D88//zxcLhcuuugi3Hbbbfjwww/x6KOP4rHHHkNbWxu+9rWvged56bnPPPMMFi9ejMrKSvzxj3/ESy+9hJqaGixZsoSCe4IgiFKEJwiCIIgS5Mknn+QB8Bs3buSDwSDvcrn41atX842NjfxZZ53FB4NB6dgtW7bwAPif//znca/x9ttv8wB4i8US9/jVV1/NP/vss/w//vEP/uWXX+YvvPBCHgD/X//1X3HHXXfddTwA/uGHH457/Be/+AUPgP/ggw9SnsN1113HOxyOuMcmTZrE22w2/uDBg9JjIyMjfE1NDf+9731PeuzKK6/ky8rK+M7OTumxUCjET58+nQfA79+/n+d5nj906BBvMpn4m266Ke59XC4X39jYyF9xxRXSY5FIhF+6dClfVVXFb926lW9paeGnT5/Ou93ulOfxwgsv8AD4//3f/015XENDAz9jxgzp36eeeip/xhlnxB3z29/+lgfAf/HFF4rHz67H//3f/6UcRyISXYvYv02aNCnuMQB8Y2Nj3Gfz6quv8gD42bNn85FIRHr8oYce4gHwn3/+Oc/zPO/xePiamhr+4osvjnvNcDjMn3zyyfxpp52mePwEQRCEviHFniAIgihp5s+fD7PZjIqKClxwwQWorq7G3/72N5hMURuak08+GWeddRYeeOAB/PnPf8bg4CDWr1+Pf/mXf4HRaITBED+dPvvss7j66qtx5pln4mtf+xpWrVqFZcuW4b777kNPT8+YMXzzm9+M+/fVV18NAHj33XdVndPs2bPjjPpsNhtOOOEEHDx4UHrs3XffxXnnnYeGhgbpMaPROCZT4K233kIoFMK1116LUCgk/c9ms+Hss8/Ge++9Jx3LcRz+9Kc/oaKiAnPnzsX+/fvx0ksvweFwqDqP0fA8H6fof+tb38L69euxc+dO6bEnn3wS8+bNw8yZMxWPn/G1r31Nk/Gm45xzzon7bGbMmAEAuPDCC+POkz3Ort/69evR39+P6667Lu6cIpEILrjgArS2tsLj8eTkHAiCIIjCgAJ7giAIoqT505/+hNbWVrzzzjv43ve+h+3bt+Oqq64ac9yf//xnLFy4EFdccQWqq6txzjnn4LLLLsPs2bMxYcKEtO9zzTXXIBQK4eOPP4573GQyYdy4cXGPNTY2AgD6+vpUndPo1wOEMoKRkRHp3319fdL7JHpvBvMamDdvHsxmc9z/XnzxRfT29o5570suuQQ+nw8XXHABZs2alXa8bBOClUEkwuPxoLe3F83NzdJj3/zmN2G1WvHUU08BEMoLWltbJdNDNeO32+05M7urqamJ+7fFYkn5uM/nAxA9p69//etjzun+++8Hz/Po7+/P9vAJgiCIAoJc8QmCIIiSZsaMGZJh3jnnnINwOIw//OEPePnll/H1r39dOq6+vh6rVq1Cd3c3Ojs7MWnSJJSVleG3v/1t3HHJ4MX66NHqfigUQl9fX1ww3tnZCSBxgK4V48aNk94nltGP1dbWAgBefvllTJo0Ke3rrl27Fr/73e9w2mmn4ZVXXsFf/vKXtAr4nDlzUF1djddeew333ntvwjr71157DZFIBIsWLZIeq66uxqWXXoo//elPuPvuu/Hkk0/CZrPFbcwoHX+yGv9Cgp3TI488krTzQmwmBkEQBFH8UGBPEARBEDH88pe/xF/+8hf85Cc/wWWXXTYmEK+vr0d9fT0A4De/+Q08Hg9+8IMfpH3dp59+GmazGXPmzBnzt2effRY333yz9O/nnnsOgNDqLVucc845eO2119DV1SUFgeFwGC+++GLccUuWLIHJZMLevXvTBugdHR245pprcPbZZ2Pt2rW47LLLcMMNN+DUU0/FlClTkj7PYrHg3//93/GjH/0IDzzwwBhn/O7ubtx5551oaGjAd77znbi/fetb38JLL72EVatW4ZlnnsFXv/rVuHZ4SsavFxYuXIiqqiq0tbXJ+u4RBEEQxQ8F9gRBEAQRQ3V1Ne68807ccccdeO6553DNNdcAAB5//HEAwLHHHovBwUG8+eabeOKJJ3DPPffg1FNPlZ7/wAMPSI7zEydORHd3N5544gmsWbMGd911l6S2MiwWC371q1/B7XZj3rx5WL9+Pe6++25ceOGF+NKXvpS18/yv//ovvPbaazj33HPxk5/8BHa7HStXrhxTmz158mT87Gc/w49//GPs27dP8iHo6urCpk2b4HA48NOf/hThcBhXXXUVOI7Dc889B6PRiKeeegqzZ8/GlVdeiQ8++EBKKU/Ef/zHf+Czzz6T/v/KK6+E0+nE559/jgceeAAulwtvvPEGnE5n3PMWL16MiRMn4vvf/z46Ozvj0vCVjF9PlJeX45FHHsF1112H/v5+fP3rX0d9fT16enrw2WefoaenB7/73e/yPUyCIAgih1BgTxAEQRCjuOmmm/Doo4/iZz/7Ga666ioYjUbwPI+HHnoIBw8ehMFgwCmnnIJXXnkFl156adxzp0+fjtdeew1///vfMTAwgLKyMsyePRvPP/88vvGNb4x5L7PZjDfeeAM333wz7r77bpSVleHGG2/EAw88kNVznDlzJtatW4fbbrsN1113Haqrq7F8+XJ87Wtfw3e/+924Y++88060tLTg4YcfxvPPPw+/34/GxkbMmzcP//Iv/wIA+J//+R/885//xNq1a6U6/erqarzwwgs466yzcMcdd+Chhx5KOh6DwYDnn38el1xyCR5//HFcd9118Hq9mDBhApYtW4b//M//jDMEjH3etddei3vuuQfNzc0J+87LGb/euOaaa3DMMcfgl7/8Jb73ve/B5XKhvr4es2fPxvXXX5/v4REEQRA5huP5mKaoBEEQBEHkjOuvvx4vv/wy3G53vodCEARBEISOIVd8giAIgiAIgiAIgtAxFNgTBEEQBEEQBEEQhI6hVHyCIAiCIAiCIAiC0DGk2BMEQRAEQRAEQRCEjqHAniAIgiAIgiAIgiB0DAX2BEEQBEEQBEEQBKFjqI+9TCKRCI4ePYqKigpwHJfv4RAEQRAEQRAEQRBFDs/zcLlcGD9+PAyG5Lo8BfYyOXr0KJqbm/M9DIIgCIIgCIIgCKLEOHz4MCZOnJj07xTYy6SiogKA8IFWVlbm/P2DwSDWrFmDxYsXw2w25/z9ieTQtSlc6NoULnRtChe6NoULXZvCha5NYUPXp3Cha5Oe4eFhNDc3S/FoMiiwlwlLv6+srMxbYG+321FZWUlf+gKDrk3hQtemcKFrU7jQtSlc6NoULnRtChu6PoULXRv5pCsHJ/M8giAIgiAIgiAIgtAxFNgTBEEQBEEQBEEQhI6hwJ4gCIIgCIIgCIIgdAwF9gRBEARBEARBEAShYyiwJwiCIAiCIAiCIAgdQ4E9QRAEQRAEQRAEQegYCuwJgiAIgiAIgiAIQsdQYE8QBEEQBEEQBEEQOoYC+zSsXLkSLS0tmDdvXr6HQhAEQRAEQRAEQRBjoMA+DStWrEBbWxtaW1vzPRSCIAiCIAiCIAiCGAMF9gRBEARBEARBEAShYyiwJwiCIAiCIAiCIAgdQ4E9QRAEQRAEQRAEQegYCuwJgiAIgiAIgiAIQsdQYE8QBEEQBEEQBEEQOoYCe4IgCIIgCIIgCILQMRTYEwRBEARBEEQCRgJhDPuC+R4GQRBEWiiwJwhCdwx6A/CHwvkeBkEQBFHE8DyPix75J879f+/BF6Q5hyCIwsaU7wEQBEEoYeO+PnzjsY2wGA2YOaEScyZV49RjqjFnUjXqK235Hh5BEARRJHgDYezr8QAAet1+TKy253lEBEEQyaHAniAIXbF+bx8AIBCO4JNDg/jk0CCA/QCACVVlYqBfhTmTanBsLQX6BEEQhDoGvAHpv70BUuwJgihsKLAnCEJXtA+MAACuP2MyTproxOaDA/jk0CB2dg6jfXAE7YMjeO2zowAAm9mA+bUGLM3ngAmCIAhdMuCJ1tZ7/KE8joQgCCI9FNinYeXKlVi5ciXCYdqpJYhC4MiAFwBwyjFVuHT2BFx26kQAgNsfwmeHB8VAfwCfHBzAsC+E9zs4BMMRmM35HDVBEAShN2IVe4+f1oEEQRQ2FNinYcWKFVixYgWGh4fhdDrzPRyCKHmOiIr9xOqyuMfLrSYsPK4WC4+rBQCEwhFM++/VCEeAfk8Adps152MlCIIg9EtcYB8gxZ4giMKGXPEJgtANoXAEncM+AEhrYmQyGjDOYQEA9LoDKY8lCIIgiNEMeGJr7CmwJwiisKHAniAI3dA57EM4wsNiNKCuPL0CX1suBPY9bn+2h0YQBEEUGf3e2Bp7SsUnCKKwocCeIAjdwNLwx1fZYDBwaY9nwX+PiwJ7giAIQhmDXlLsCYLQDxTYEwShG6L19fJ6CddVsMCeUvEJgiAIZfTHpOK7SbEnCKLAocCeIAjdwBzxRxvnJaOunNXYk2JPEARBKGMwJhXfS+3uCIIocCiwJwhCN7QnccRPRi1T7Mk8jyAIglBIrGLvCZBiTxBEYZPXwH7y5MngOG7M/1asWAEAuP7668f8bf78+XGv4ff7cdNNN6G2thYOhwOXXHIJjhw5EnfMwMAAli9fDqfTCafTieXLl2NwcDBXp0kQBQHP8/keQsYoTsVn5nlUY08QBEEohGrsCYLQE3kN7FtbW9HR0SH9b+3atQCAyy+/XDrmggsuiDtm1apVca9xyy234JVXXsELL7yADz74AG63G8uWLUM4HN1Zvfrqq7FlyxasXr0aq1evxpYtW7B8+fLcnCRBFADfe/pjLP3NBwiEIvkeSkYcGRRS8SfITcWXFHsK7AmCIAhl9Mf2sacae4IgChxTPt+8rq4u7t/33Xcfjj32WJx99tnSY1arFY2NjQmfPzQ0hCeeeAJPP/00zj//fADAM888g+bmZqxbtw5LlizB9u3bsXr1amzcuBGnn346AODxxx/HggULsHPnTkybNi1LZ0cQhcGgN4C3tnUBAA71e3BcfUWeR6SOcIRHxyDrYS+3xl4I7KmPPUEQBKGEkUAYvmB0M5wUe4IgCp28BvaxBAIBPPPMM7j11lvBcdE2Vu+99x7q6+tRVVWFs88+G7/4xS9QX18PANi8eTOCwSAWL14sHT9+/HjMnDkT69evx5IlS7BhwwY4nU4pqAeA+fPnw+l0Yv369UkDe7/fD78/qvINDw8DAILBIILBYMLnZBP2nvl4byI1hX5tth4ZkP67Z3gEk6pteRyNejqGfAhFeJiNHKptRlmft9Mm3Eu8gTAG3CMotxbMLa/kKfTfTSlD16ZwoWuTO3qGfXH/dvtSr//o2hQ2dH0KF7o26ZH72RTMKvfVV1/F4OAgrr/+eumxCy+8EJdffjkmTZqE/fv347//+79x7rnnYvPmzbBarejs7ITFYkF1dXXcazU0NKCzsxMA0NnZKW0ExFJfXy8dk4h7770XP/3pT8c8vmbNGtjt8up7swErVyAKj0K9Nu93cACMAIC3/7kR3dv0WWu/dxgATHCaInhr9Zuyn2c1GOGPcHj5jTWolyf0EzmkUH83BF2bQoauTfY54gFil8ld/UNjykETQdemsKHrU7jQtUmO1+uVdVzBBPZPPPEELrzwQowfP1567Morr5T+e+bMmZg7dy4mTZqEv//977jsssuSvhbP83Gqf+x/JztmNHfeeSduvfVW6d/Dw8Nobm7G4sWLUVlZKfu8tCIYDGLt2rVYtGgRzGZzzt+fSE6hX5t/vrINONAOAJg64yQsnTMhzyNSx6tbjgLbtuL4CeOwdOlcWc8JBoOo+PQd+H3AiXMWYN7k6vRPInJCof9uShm6NoULXZvc8eHePuDzzdK/DZYyLF16VtLj6doUNnR9Che6NulhmePpKIjA/uDBg1i3bh3++te/pjyuqakJkyZNwu7duwEAjY2NCAQCGBgYiFPtu7u7ccYZZ0jHdHV1jXmtnp4eNDQ0JH0vq9UKq9U65nGz2ZzXL12+359ITqFem13dbum/h/3hghyjHDqGhTr55hq7onOoNAO9PmBgRL/nXswU6u+GoGtTyNC1yT4uv1BfX1tuRa/bD29A3hxC16awoetTuNC1SY7cz6Ug+tg/+eSTqK+vx0UXXZTyuL6+Phw+fBhNTU0AgDlz5sBsNselbnR0dGDr1q1SYL9gwQIMDQ1h06ZN0jEfffQRhoaGpGMIolgJhSPY2emS/j3g1a+JXLvCVneMSrNQetDt8qU5kiAIgiAE2HzJzFrJPI8giEIn74F9JBLBk08+ieuuuw4mUzSBwO124/bbb8eGDRtw4MABvPfee7j44otRW1uLr371qwAAp9OJG264AbfddhvefvttfPrpp7jmmmswa9YsySV/xowZuOCCC3DjjTdi48aN2LhxI2688UYsW7aMHPGJoudAnxf+mBZ3gx79GpOwVndyHfEZlUIre+plTxAEQchmQJwvWXvVYJjXfctYgiCKm7yn4q9btw6HDh3Ct7/97bjHjUYjvvjiC/zpT3/C4OAgmpqacM455+DFF19ERUW0XdeDDz4Ik8mEK664AiMjIzjvvPPw1FNPwWg0Ssc8++yzuPnmmyX3/EsuuQSPPvpobk6QIPLI9o74mhw9K/ZHRMV+QpWywL5CVOwpsCcIgiDkIin2MXOOxx+CxWTJ15AIgiBSkvfAfvHixeD5sS7dZWVleOutt9I+32az4ZFHHsEjjzyS9Jiamho888wzGY2TIPTIjk4hsHeWmTE0EsSgV5+KfSTC4+igmIpfozAVX1yDdVNgTxAEQciEBfa15VZYTQb4QxF4AiFUOyiwJwiiMMl7Kj5BENlje4dQXz9/ag0A/Sr23S4/gmEeJgOHhoqxppapqBT9RkixJwiCIOTS7xHmy2qHBeVWQQfzBsL5HBJBEERKKLAniCJmh5iKf8axtQCAAZ0q9kcGhPr6piobTEZlt61Ki5iK76bAniAIgpAHy3CrtpthtwrlnR4/GegRBFG4UGBPEEXKoDeAo0OCE/z8qeOkxxKVvhQ6auvrAaBCVOz73H6EI/o7d4IgCCL3xCr2Dgsp9gRBFD4U2BNEkbJDbHM3oaoMx4h16aEID7cOFQem2CttdQcIgb2BAyI80Och1Z4gCIJIz6BYulZtt8BuERR7Pc6fBEGUDhTYE0SRwhzxZzRVosxihNUk/Nz1aKDXzozzFLa6A4SgvkY0O6I6e4IgCCId/lAYHlGdr7Fb4JBq7CmwJwiicKHAniCKlB2icd6MJqE9ZLVdCG71aKDHUvHVKPaA4GoMUGBPEARBpIdtgBs4oMJmklLxPX5KxScIonChwD4NK1euREtLC+bNm5fvoRCEIrZ3RhV7AKiyC8XmejTQiwb2yhV7AKgrFzY1qOUdQRAEkY6BmDR8g4GTzPNIsScIopChwD4NK1asQFtbG1pbW/M9FIKQTTjCY6dYYz+9MV6xH9SZYh+J8GjPwDwPAOoqSLEnCIIg5MGM89iGOCn2BEHoAQrsCaII2d/rgT8UQZnZiEnjHACAaoeo2Hv0Fdj3uv0IhCMwGjg0OW2qXqOOUvEJgiAImbBUfObPQoo9QRB6gAJ7gihCdohp+Cc0VsBo4AAAVVKNvb5S8Q+Lan1jpfIe9ozaCtE8j3rZEwRBEGmIKvbC3MEUezcp9gRBFDAU2BNEEcIc8VtE4zxAcPYF9JeKH211py4NHwDqmWI/TIE9QRAEkZpoqzsh0421uyPFniCIQoYCe4IoQpgj/vTGSukxvZrnMeO8CRkE9qTYEwRBEHLp9wjzZLWYil9upRp7giAKHwrsCaIIYYo9M84D9NvuLtNWdwDV2BMEQRDyGYxxxQcAO/WxJwhCB1BgTxBFxpA3iKNDPgDA9KaoYi+Z5+kssG8fzKzVHRDtY+/2h2hhRhAEQaSkX5wna6QaeyEV3xMgxZ4giMKFAnuCKDJY//oJVWVwlpmlxyXzPI/eUvEzr7EvtxpRZhYWZqTaEwRBEKlgJWtVUo29qNj7aWOYIIjChQJ7QvfwPI97V23Hcx8dyvdQCoIdYhr+jBjjPECffex5PtrDfmKV+lR8juOolz1BEAQhC9YWlrW7c4jt7jwU2BMEUcBQYE/ongN9Xvz+H/tw75vb8z2UgmB7AuM8IOru6wmEEQhFcj4uNfS4/fCHIjBwQKPKHvYMCuwJgiAIObCSNZbpxhR7SsUnCKKQocCe0D1DI0LKnNsfQiTC53k0+Yf1sJ/RFB/YV9rMEFva60a1b4/pYW8xZXa7qhcD+24K7AmCIIgkBMMRuHyCMl8zyhWfPFoIgihkKLAndA9LjeN5wBcq7d30cITHzi5RsR+Vim8wcFLNvV5a3mnhiM8gxZ4gCIJIx6A4P3IcpDnTLqbiB8O8bjLeCIIoPSiwT8PKlSvR0tKCefPm5XsoRBLYzjoAeEs8Te5Anwe+YAQ2swGTxznG/F1vLe+06GHPoJZ3BEEQRDrY/OgsM8MoprnZRfNVgFR7giAKFwrs07BixQq0tbWhtbU130MhkhBrZuP1l3Zgz/rXT2uokBYksTCHX72k4mvhiM+ok1LxfRm/FkEQBFGcMOM8thEOACajAVaxHMxNBnoEQRQoFNgTuid2kvWU+E76DtE4b3R9PSOq2OsjFV+LHvaM+kpRsXeTYk8QBEEkhin2zHCW4ZDq7EtbQCAIonChwJ7QPbGBfamnyDHFfnpjRcK/V+k0FV+TGvtywVWfUvEJgiCIZLCN71jFHgDsFmp5RxBEYUOBPaF74gP70t5J39GZTrFnqfiFr9jzPJ+VVPxed4C6JxAEQRAJ6Wep+I74wL6cFHuCIAocCuwJ3RO7e+4p4Rr7IW9QSl0f3cOewRYqrIawkOnzBOALRsBxQJMz88B+XLkFHCd0DujXScYCQRAEkVsGk6Tik2JPEEShQ4E9oXvcPkrFB6L96ydUlcE5akHCYOZ5eqixZz3sGyoy72EPAGajATViaiWl4xMEQRCJ6PeIqfijFHuqsScIotChwJ7QPZSKL5Cuvh6AFNjqwRU/Wl+fuVrPoF72BEEQRCqiin3iGntyxSdKFZ7n8f1nN+OWFz6lksYChQJ7QveQeZ5Auvp6QF/meVrW1zOiLe8osCcIgtALPM8jGI7k5L36kwT2DgtT7Et3nUGUNkcGRrDqi068uuUo/vZZe76HQySAAntC91CNvYCk2DclV+yrHbk3z/v8yCA+PTSg+HlMsZ9Aij1BEERJ862nWnHm/e/mpL59UHLFH1Vjb2U19qW7ziBKm74Yf6b/99Yu+IL0Wyg0KLAndI8rZqIfKdGbTDjCY2dXesW+Okaxz0UalT8Uxjcf/whXPrYR3S6foudGe9hn3uqOQYE9QRCE/li/tw+dwz7s6XZn/b1YRltN0hp7UuyJ0qQ3Zu3UPjiCp9YfyN9giIRQYE/onnjFvjQn3AN9HviCEdjMBkwe50h6HDPPi/CAy5f9z6pj0AeXP4RAKIK1bV2KnpuVVPxyMbB3U2BPEAShB/yhMAIhIQ0/25uy4QiPoRFBsa9KkorvKWEvH6K06fMIvz/mN7HynT1Se0iiMKDAPg0rV65ES0sL5s2bl++hEEmId8UvzQl3R4eg1k9rqIDRwCU9zmoySjfkXNTZHxVVdwB4a5v8wF7oYa+9Yl9faQMAdA8ryx4gCIIg8kPsJnRvljdlh0aC4MVktqok7e68JSogEESvW1g3XjizCTOaKuHyh/Cbt3fneVRELBTYp2HFihVoa2tDa2trvodCJCAS4eN2z0s1RS7qiJ88DZ9RnUMDvSMxgf36Pb2SEpKOAW9Q2qRpcto0Gw8p9gRBEPoiNrDPtmLP1McKmwlmY/wSmaXiu6nGnihR2MZafaUVP146AwDwzMaDONDryeewiBgosCd0jWdUIF+yir3Yw35GCuM8BlMhcmGgF6vYhyI83t3RLet5rId9fYUVNrNRs/FQjT1BEIS+cPmic1W2N2UHk9TXAzGKfYkKCATBFPtxDgu+dHwtzj6hDqEIj1++tSPPIyMYFNgTuma0O22p1thvF1Pxp6cwzmPkUrFngX25qHSs3top63nZqK8HooG9yxciN1eCIAgdkA/FfnR9PRCdx6jGnihV+sSNNbaWunPpdBg4YNUXndh8UHn3I0J7KLAndI3bH686l6JiPzQSlBzkZ8hIxWeK/UAOFHs2rsvnTgQAvLerGyMyrlE26usBoNJmgtUk3PZItScIgih8YhX7bNfYs0y2mlH19QBgZ33sS1RAIAj2+xvnEAL76Y2V+PocYX13z6rt4Pnsd1siUkOBPaFrRju7l2Jgv0Osrx/vtMGZYDEyGqbYD+ZEsRdM6ha3NGJCVRl8wQj+sbsn7fOYYq9lD3sA4DhO2mnupsCeIAii4MmpYi/Oi9UJFHuHlaXil946gyAAoE9Mxa+tiP4+bl00DTazAZsPDsjOyiSyBwX2hK5hqfjMCL4Ua992dKbvXx9LtaTYZzew53k+phd9GS6Y2QgAeEvGjT/2eVpDdfYEQRD6IZeBPZsXqxPW2DPzvNJbZxBEKByRNr6YYg8AjU4bvnvmVADA/at3SK0pifxAgT2ha1gq/jjR7Xx0zX0pIDniyzDOA6K1g9lOxe91BxAIRcBxQEOlDUtOFAL7ddu7EAynvvFnKxUfEAz5AKDHRS3vCIIgCp3YwN4TCGd1A3/AwxT7sdlvUcWeAvtYHl63G+f+v/ek+muiOBnwCq0gOW6sueR3zz4WteUWHOjz4rmPDuZphARAgT2hc1jbGRasjQTDiERKq8Znu1LF3sFc8bOr2DPjvPoKKywmA+ZMqkZtuQXDvhA27utL+rz4Hvak2BMEQZQysTX2ANDryt7cxTa8Uyn2wTBPqmQMr25px75eDz45NJjvoRBZhNXX19gtMLI0WZFyqwm3nH8CAODht3dj2Jd9DyciMRTYE7rGLd48WGAPCMF9qRCO8NjZKb+HPRCj2Huye+Nlgf2EKiE4Nxo4LGppAAC8tS15Ov7QSFBKdWTP1ZK6chsA6mVPEAShB0Z76fS4s5dtFVXsE9TYW6KtV0m1j8KU+qERCuaKGam+vtya8O/fmNeMY+scGPAG8bv39uZyaEQMFNgTuoa1naktt4Lj2GOlM+Ee7PPAF4zAajJgSq1D1nNyZZ7H6uTHxwTnLB1/zbaupJkVTK2vLde2hz2DFHuCIAj94BrV/Sab925WY1+VIBXfZDRIXVWo5Z1AIBTBsLjxMkyBfVEjOeKXj930AoTfx50XzgAA/N8H+6U1IJFbKLAndA3bya+wmWEXg0A57dSKBda/flpjxZjUqGRU56jdXfsoxR4Azji2FhVWE7pdfnx6eDDh87KZhg9EszvIFZ8gCKLwGavYZz8Vf3QNMcNhpZZ3sfR7oteCFPvihgX2yRR7ADhvRj1On1IDfyiCX721M1dDI2KgwJ7QNR5xci23mWAXJ9xSMtDbIabhy+lfz2C1gyPBMHxZLFs4mkCxt5gMOHdGPYDk6fis1V22AntS7AmCIPQDU4Trs3zvjkR4KZMtUSo+ANjFdHxyxhfo80SvBQX2xU1vmlR8QGgp/OOLBNX+lS3t2No+lJOxEVEosE/DypUr0dLSgnnz5uV7KEQC2ORabjVKE24p1b4pdcQHgAqrCSZR3R/MomrPetiPrpO/QEzHX721Ezw/Nh0/m474QDSw73X7S85okSAIQm8w87ypdUK5WbYC+2FfEGxKSJSKDwAO0UCPetkL9MVkT5BhWnGTLhWfcdLEKlxy8njwPHDvm9sTrvPUEI7w+Pc/f0b1+2mgwD4NK1asQFtbG1pbW/M9FCIB0cDeLDnWltKEy1Lx5TriA8KOalUOetknqrEHgLOn1cFqMuBQvxc7REf/RM+bkCXFnu02B8M8BklhIAiCKGhYKv7UunIA0QBDa1gavsNihNWU2N/FLra885BiDyA+FZ9q7IsbZpJYl0KxZ/z7kmmwGA34cE8fPjk0oMn7f9E+hD9vPoKH1u3SbLOgGKHAntA1bnHCd1iNkmNtqSj2QyNBKQhWkooPxDrjZyewHwmEpQl/tGJvt5hw1gl1AATVfjTZrrG3mAySzwCl4xMEQRQ2kmJfm13Fns1ZiVrdMcqtpScgpCJ2k4VS8YsbloqfTrEHgOYaO86dLpRdfqpRG8QdYoaqP8awkRgLBfaErmEO+BU2E8osbCe9NCZcdpNrctrgTJI2mIxsG+gdHRKC83KrCZVlpjF/Z+74iersWY19c5YCe4Dq7AmCIPRAMByBLyj0jM92Kn66+nogWmNfSt13UhGv2NNnUmj4gmFs7xjWROHuk2GeFwvLJGWZpZkSm+FJa7fkUGBP6BpJsbeYorVvJdLH/vMjginJrAlOxc+VFPsspeK3D7A0fBs4bqxb//kz6mE0cNjR6cLBPo/0+NBIUEq7nFCVnRp7ICawz2I/ZIIgCCIz3DHK3JRaIRW/x+3PSiquHMVeWmeUiICQjtgae1LsC4//+ds2XPjwP7Fhb19Gr8PzvCLFHoh6PzGT50yJfR0K7JNDgT2ha9xxrvhiKn6J1L5tEdvFndxcpfi5TLHPVi/7RI74sVTZLZg/tQZAvGrPNgTGOSxSBkY2qK+wAQC6h2lyIAiCKFTYRm+Z2Ygmp3DfDoQicGVhnmdmstUpMuDYOoNc8QXIFb+w2dUtqNzbjmYWXLv8IQTCQuaMbMVeLBHd3eVGSHyuWniej1fss+SzUQxQYE/omqh5nikmRa40dtJZYH+KqsCeKfZZSsVP0MN+NLHu+Ixst7pjUCo+QRBE4cOc1itsJtjMRlSINe7ZuHf3y0jFj7riU2APAH0xqfgjwTACocwCOEJb2GZVx1Bm2Ym94u+t3Cr8DuUwsboMDosRgXAE+3s96Z+Qgq5hf1wXp+5hyrZMBgX2hG4JR3jJwKbcGk3FHymBCbfH5Uf74Ag4Dpg1sfBS8Y+kUewBYFGLENh/cmhQuklnu9Udg7m60q4vQRBE4cIU+wqbML9nc1NWXo29MI5SERDSEZuKD1DLu0KDrfE6h0cyeh22gVMrMw0fAAwGDtNZnX2CDkhKGJ3OT2u35FBgT+iWWPMah9VUUhMuU+uPqytHhU2ZcR4Qm4qfP8W+0WnDKcdUAQDeausCkH1HfEZ9pbA4pFR8giCIwsUlKfbCnMXSgLPR8o7V2Nc4ks+pjhIr+UtH/6jOOpSOXziEI7x0PTo1UuzHyUzDZ0xvFOvsOzIrBRjdGpmyLZOT18B+8uTJ4DhuzP9WrFgBQKipuOuuuzB+/HiUlZXhy1/+MrZt2xb3Gn6/HzfddBNqa2vhcDhwySWX4MiRI3HHDAwMYPny5XA6nXA6nVi+fDkGBwdzdZpElmB9ZM1GDlaTQUrFz/WEu7atG4fdOX1LfCYG9rNVpOED2Vfsjw4Kk0i6XvQsHf8tMR2/fdAr63mZQoo9QRBE4ZNLxZ6VplWlSsW3lo6AkA5fMCyVQ7LrQ73sC4fhkSCYx2TGgb0KxR6ApNiPDsyVwjYGst3yshjIa2Df2tqKjo4O6X9r164FAFx++eUAgF/+8pf49a9/jUcffRStra1obGzEokWL4HJFvyC33HILXnnlFbzwwgv44IMP4Ha7sWzZMoTD0Zvu1VdfjS1btmD16tVYvXo1tmzZguXLl+f2ZAnNifawN4HjOMnUJpcT7u4uF77//Bb86gsjfvPOnowNQuTCFPvZouKtlGwq9pEIj46h9Kn4QLTt3cZ9fRj0BnKm2FONPUEQROHDFPtKUbHPRSp+TQpXfElAKIGSv3Qwtd5s5KTyOVLsC4dY4abL5Uc4or6ThFrFfobGiv2Zx9cCoLVbKvIa2NfV1aGxsVH63xtvvIFjjz0WZ599Nniex0MPPYQf//jHuOyyyzBz5kz88Y9/hNfrxXPPPQcAGBoawhNPPIFf/epXOP/883HKKafgmWeewRdffIF169YBALZv347Vq1fjD3/4AxYsWIAFCxbg8ccfxxtvvIGdO3fm8/SJDIk1zgMQU2Ofu8D+QJ+gMPPg8Mi7+/CNxzZKBnDZIhLhJcX+5IlVql6DtfPJhmLf4/YjGOZhNHBoqEg9CUyudWB6YwVCER5vb+/OXY29OK6hkSD8IVJeCIIgChGm2LN5PpuBfb+HKfYpUvHFdYab2t1J9fXjHFY4y4TPhQL7wmEw5lqEI3xG5Sus+4FcR3zGCWJgf3TIp7oLUyAUwd4eIS32zOPrAFBgnwpTvgfACAQCeOaZZ3DrrbeC4zjs27cPnZ2dWLx4sXSM1WrF2WefjfXr1+N73/seNm/ejGAwGHfM+PHjMXPmTKxfvx5LlizBhg0b4HQ6cfrpp0vHzJ8/H06nE+vXr8e0adMSjsfv98Pvj35xhoeF3aZgMIhgMPc3Lvae+XjvQmVQvNE4LEYEg0GIgj3c/txdo/YBwelznJWHjzfh44MDWPrwP/GLr5yIC05syMp77u3xwOUPwWY2YOo4m6pzLTcLveWHRoLw+QMwGsb2mlfLwV5hZ7Whwgo+EkYwknoBdP70OuzodOHPHx+SFgX1DpMm1zDZ78ZuElSGYJhHx4AnpRcAkR3onla40LUpXErt2gx62TxvQDAYRHWZMNF3u3yafgY8z0uBR4X4Xolg6wyPb+w6o9SuTdeQsP6pcZilbgUDHn/Bnn+pXZ/eUYZ5R/rcqClT10aYGRxXlxkVfX5lRmBilQ1HBn3YemQAp0+pSXhcqmuzq9OFYJhHudWEmU1CKn6/NwCvzw+zsXSs4uR+7gUT2L/66qsYHBzE9ddfDwDo7BRqbhsa4oOjhoYGHDx4UDrGYrGgurp6zDHs+Z2dnaivrx/zfvX19dIxibj33nvx05/+dMzja9asgd2eXTUxFaxcgQC29HEAjAh4XVi1ahV2Dgr/7uodxKpVq3IyhvWHDAAMmF7F49zxfvxptxEH3SHc9MJnOKM+gq9OjkDrduybuoXzbLKFsfat1apeQ+hIYwLPA399/U2k8ApSzKe9wvhskRFZ18HuEcaycf8AAMBh4vH+22u0GxAS/27KjUYMhDn87a13MblC07cjFED3tMKFrk3hUirXpm2vMMd2HNqHVav24sCAML/sbe/RdJ4fCQGhiLAk/ugf7ySdtw+6AcCEviF30vcvlWuzqUe4FhHvEIZDQwAMaN2yFdW9X+R7aCkptevD+Pu763FknLp0/N2HjQA4HNq1Dav6tip6bhVnwBEY8Mo7H6GvKfX7J7o2H4vnUWcJYsP7b8MAIyI8h5dfXw2nspJ/XeP1yssGLpjA/oknnsCFF16I8ePHxz3OcfFKIs/zYx4bzehjEh2f7nXuvPNO3HrrrdK/h4eH0dzcjMWLF6OysjLl+2eDYDCItWvXYtGiRTCbNYzCdMzIJ+3Arm1obqzF0qVz0HR4EL/dvglGmx1Ll56ZkzH885VtQHs7nBYeV128CFcZjPjNO3vx+3/ux/puA7r4Cjx0xUmSM6gWbHp9O7D3MM6ZNRlLL0yccSKHn2x5Gx5/GHMXno0poiGJFrR/sB/YvRsnTmnC0qUnpT2e53k8d/gDKQ1/Sr0TS5fO12QsqX43TxzeiIEjwzjhpLk4f8bYzT8iu9A9rXCha1O4lNq1WfPi50B3J049qQVLF0zCMe3DeGzHRgQNNixderZm73Oo3wu0foAyswFfuXhp0uP29njw6y8+BG+0YOnSc+L+VmrX5ugHB4A9uzBt8gSMc1jwUc9BNB4zFUsvUL8uySaldn261h8E9kRLjiccfyKWzj9G1Ws9uOsDAF6cf+bpOG1yYtU9GTste7D1/X0wjjsGS5eemPCYVNdm25pdwJ4DWDCjGcsuasF9295Hl8uPWfO+hJkTch+P5QuWOZ6OggjsDx48iHXr1uGvf/2r9Fhjo2Cq1dnZiaamJunx7u5uScVvbGxEIBDAwMBAnGrf3d2NM844Qzqmq6trzHv29PSMyQaIxWq1wmodW0tiNpvzekPI9/sXEiMhYeevoswCs9kMp90mPB4I5+wz6hFrzJyW6LX5z6UtOPOEevzwxS3Y2+PB137/EX68dAauXTAp7aaUHD5vF37cp06uyeg8axwWePwjcAV4TT+vrmHhM2mucch+3QtnNuLxf+4Xn2fX/Pol+t00VJYBGEafN0S/qTxC97TCha5N4VIq18YteuZU2a0wm81oFP1X+jwBGI0mGDQqI3MFhPVEtd2S8nN1OoR1oTfFOqNUrs2g6H9QW2FDVZlwvp5ApODPvVSuz7Avvgyyxx1Ufd7MT6GxSv66jnHihCoAwM5uT9rnJro2u7qFko+W8VUwm82oq7Siy+XHgK+01m5yz7UgihOefPJJ1NfX46KLLpIemzJlChobG+PSMgKBAN5//30paJ8zZw7MZnPcMR0dHdi6dat0zIIFCzA0NIRNmzZJx3z00UcYGhqSjiH0CWt3Vy6a2TC3Wk8O3Wq7xLoj56jf28LjavHmv52Jc6fXIxCK4H9e24Yb//TxmJ6vSvEFw9guuouqNc5jVIstfdQamiSjXWx1l84RP5YLZjZK/51tR3wGOeMTBEEUNqP72I8TA+tQhI8zB8sUZiRbncIRHwDs4nojEI4gEMpNF5xCRTLPK7egUgzs9W6ex/M83t7ehcP92TVBzgXsO83Wxp1DI6kOT4ovGIZLXG8rNc8DgOlNQsbqrk6XKmf+HR2CbxPLfK2vEEQ8WrslJu+BfSQSwZNPPonrrrsOJlM0gYDjONxyyy2455578Morr2Dr1q24/vrrYbfbcfXVVwMAnE4nbrjhBtx22214++238emnn+Kaa67BrFmzcP755wMAZsyYgQsuuAA33ngjNm7ciI0bN+LGG2/EsmXLkhrnEfqA3WjKbfGBvS8YyaithxK6xRuL0zL2/caVW/HEdXNx18UtsBgNWLe9Gxc/8gGGfeonvm1HhxGK8Kgtt2QcAEd72Ws7EbcPCpOHEkO6U5qrpUA72474DOplTxAEUdgwV/xKcZ63mAxSu1YtF/YD4qZ7dYoe9kB0nQFQyzsmVIxzWOAsksD+i/Yh3PDHj3Hbnz/L91Ayhm18TRMD4g6Vvez7xOtsMRqk36ESJo9zwGoyYCQYFkpeFDDoDaBTFNCYw760dqPAPiF5D+zXrVuHQ4cO4dvf/vaYv91xxx245ZZb8P3vfx9z585Fe3s71qxZg4qKaL3ygw8+iK985Su44oorsHDhQtjtdrz++uswGqM332effRazZs3C4sWLsXjxYpx00kl4+umnc3J+RPZgir2DtbuzRm84I8Hst6Lxh8LSxJbMwIPjOFy/cApeWXEGGittaB8cwbq2saUhcpH61zdXZZzWH+1lr61if5QF9go2HgwGDjefexym1jlwXo7q3esraXIgCIIoZFhgzxR7IDvZVmyDO51ibzYaYDEJS2dPDlvrFiJ94qa40O5OuD6ZCBeFwEGxhXH7gDp1u5Bga7sZTUIdOguQlSJd53KLqnWn0cBJmwtK+9mz/vUTq8tQKd4D2O+/m9ZuCcl7jf3ixYvB84nVVY7jcNddd+Guu+5K+nybzYZHHnkEjzzySNJjampq8Mwzz2Q6VKLAcLMJXwzorSYDOA7gecDrD0l9b7MFW1SYjRzsad7qxPFOfH3ORDz67h6s296Fy06dqOo9t2TYvz4WpkxkWh4Qi9sfknbsm5w2Rc9dvmAyli+YrNlY0sF2fWlyIAiCKEyiqfjRSba23IpdXe6M+nKPJqrYp69jLbea0B8KwOsvbcW+V0zFrym3SOt4vSv2LH1d7+cBAAMe4RxmiEF155BPlgH5aHpjAnu1TG+swOdHhrC904ULZzWlf4II2wiY3hg1yaMyytTkXbEnCLW4/cJuOVPqOY6DQ6x/8+ZgJ53V1zdUWCHnPnl+i2DW+I9dvapr8z5jiv0xVaqeH0uVuIDRMhWfqfWVNlOcwlKIsMmhlyYHgiCIgiMc4SVVPDawz45iLy8VH4j18yltxZ6JArUxiv2QxqV9uYYFw25/CKGwvj0UmGI/XVTs/aEIBlVcH7aBo6a+nsECc7WKfWxnqXoK7FNCgT2hW9x+4QZVHjPh59JAr2tYuKnUV8pTpk+a4ERdhRVufwgf7e9T/H59br9Un3SShoq9lqn4Un19jurkMyF2cZgsa4ggCILIDywrDxiVip8Ff5RoYJ9+Q1oSEEpYsfcGQlLJY6x5nssfQiRHHkfZYCBmPeTy6fv6MtGmocKGcWKJiZo6+96Ykgu1MAM9FqjLZTsL7Juigb20diN/pIRQYE/oFo+o2FdYxwb2uVTs2e5hOgwGDudOE+rH1dTZf35kCAAwtc4h7Y5nQlSx1y6wl+rrq5Sl4ecDNjkEwpGiSLsjCIIoJli9ttUUrWsHgNpsKPYeeTX2AGC3CusMdwkH9swR32oywG4xSvXPPB81NtYjsaWJel4X+IJhaeOlymFGgyhAdamos2fXurYik1R8QbE/1O+V/buJRHjskhR7SsWXCwX2hG5xjzLPA6KtaHIT2IuKvczAHoim46/b3q1YJf40xjhPC6KKvXaTFzOcUdLqLl9YTUZpg4QmCIIgCG040OvBf7z8Ofb1uDN6nahxXryJDVPsNa2xV5CKn8uSv0KFOaXXllvBcRxsZiOs4ubLsI4D4lihQ8+BPVvXGQ0cKqwmyfMoE8W+NgPFvsZhQYNoWLxTpmp/qN+LkWAYVpMBk8dFs0BZYO8NhEt6cy0ZFNgTuoX9oGNN8hziTnouUuS6WY19pfyb3ZeOq4XVZED74Ah2dilLSWLGeadoHNhnR7Ev/MAeoJ1fgiAIrfn9P/bixY8P47mPDmX0OqN72DOyWWNfI0exz2HJX6HS7xE++9jPqxha3hWLYj84IpxHVZkZHMehUQzs1fSy10KxB2Lq7Dvl1dmz445vKIfJGA1X7RaTtO6ntdtYKLBPw8qVK9HS0oJ58+bleyjEKFj9XWxgXybupOfC1KbLFTXPk0uZxYgvHVcLQFk6Ps/zknHeyRoF9rHmeVrVmB8dFD4TPSj2QIwJC9VqEQRBaELrgQEAUVVXLWzzfoxir3Fgz/O8lIpfJdMVHwC8/tJV7JmhWqxTOquz17ViXySB/ejvc6OYiq+m5Z0WNfZATJ19hzxRa0eCNHwGiTLJocA+DStWrEBbWxtaW1vzPRQihnCEl+qHYs3zHOJO+khOzfOU3ezOmxFNx5fLgT4vhkaCsJgMCW9yamC1hIFQRPosM4WZ5+klsJf6oQ7T5EAQBJEp/Z4A9nQLKfiZZoMlS8Vn7tz93oAmzuXeQBgB8XVkueJbSbFnKm6xKfaxXYL0fB6Do0pLGjNKxc/cFR8AZihV7DvGOuIzJANNCuzHQIE9oUti62pY+j0QrbHPiWI/xMzzlBnFnTdDMND77Mggul3ybrJbDgsKyInjK+NMhDLBYTHCbBT69GnR8i4Ujki7wROrdRLYZ8FdmSAIolTZfHBA+u9M5xUpFd8ar6LXOCwwcIJRW3+GWQFA9DUsohFcOqjGPpqKHxvsscCemR7qjZFAOE7k0Ot5ANHfXpUY2Dc5hTVZp8LAPhzhY651hqn4MYq9nCxRtgEwoym5Yi93DV1KUGBP6BKPGNhbjAZYTdGJOFc19h5/SHJ+VWKeBwANlTacNNEJngfe3SFPtf/ssOCIr5VxHgBwHCfd9Ac0WBx1u/wIR3iYjZwUMBc6lM5FEAShHR8f6Jf+O9NWqsNJFHujgcO4crawz/zezYzGqu1CPXI6mIBQysZdTLEfF6PYV4rXSa9K9+gME72eBzC2fWO0xl5ZIDzgDYB1L5TjP5GKqbXlMBs5uPwhKbszGd5ACAfF9s7TEin2tHZLCgX2hC6JOuLH766XSaY22d1JZ4sJu8WIcmv6Hf7RnDddWTq+1o74DHbT18IZn92oG502GAzpF0eFACujoF1fgiCIzNkUE9hnumEcTcUfW/deq2G2Vb8CR3wgtya9hQrzTyimVPzR2R969gqQUvEd8an4Ln9I0YYU28CptpvjDOzUYDEZcGxdOYD0dfa7utzgeeF3nqgEgAL75FBgT+gSyRF/1E5+rlLkuiRHfJusHf7RsHT8D3b3wpemvt0fCmP7USElSevAvkpDZ3y9OeIDQF25MNnR5EAQBJEZI4EwtrYPSf8e9oUyqoGPuuKbxvyNLex7NVHslQX2uSz5K1T6UqXij+hzw6OYFHsm1rBrUm41oUI0fVSi2kut7jTKwmwR0+q3d6Sus9/RwdLwx6r1QExgT2WUY6DAntAlzBGfBfIMVh/nzbKpTZeKVnexnDi+Ek1OG0aCYazf25vy2O0dLgTCEdQ4LDimxp7yWKXUSL3sMw/s9WacB9CuL0EQhFZ8dmQQwTAv3VcBYDCD4CiZeR6grT9KfwL1ORWSYl/C5nn9CczzKotMsdfreQDRGvvYzSo16fiSI36G9fUMqc4+TS/7qCN+6sCejI/HQoE9oUs8SdrgSDvpWW5Dw24mDZXKjPMYHMdJqn26dPwthwQzopMnOlVlB6Si2hFteZcpelTsmT/CgDeIQChzd2WCIIhShdXXnzalRlIKM9k0Zop9ZYJUfC03ZaNGY+lb3QFRQSHb64xChed59HpStLvTqekcKx0pMwsbN3rNPABis1Ci32kpsFfQ8k4rR3wG6+q0PY0zPlP0pyXpAkXGx8mhwJ7QJS6pxn5UKr64kz4SzJViry6wB6Jt797e3pXSIfSzI0Jqo1b962PRMhW/fUB/ir2zzCx1BuilCYIgCEI1rH/9vEnVUkCRyaZxKsWeOXSzwCMTBhQq9lK7uxKtsXf7Q9JGeGxvc73X2LPv6qRxQmakXs8DiK7pqmIVe9bLfii1cV0sfRqn4jPF/kCvByNJSll4nsfOrtSKPfNH6nMLps1EFArsCV3CUvHLrflR7NmOp1JH/FgWTB0Hu8WIrmE/trYn373ckiXjPEBb87yjg8JnoifF3mDgoiZMlI5PEAShinCExydiq7u5k2s06biSyjwvqthnbnyaKAhKRam3u2Mp63aLUTIsBqKZFXoNiNn3YEqtA4B+zwOI6fTgiP52mlT0so/W2GuTil9XbsU4hwURHtjdnTgdv2vYj0FvEEYDh+PqyxMeM85hhYEDIhq1vCwmKLAndAnbKR8b2Oem9i3TVHwAsJmNOPP4WgDAuu1dCY8Z9Aawv9cDIDuBfTbM8/Sk2ANUZ08QBJEpOztdcPlDKLeaML2xIkaxzzwVf7RJLqDtfZsFQTUOman4TLEv0Rp7liUxuu5a7+Z5LECcLAb2w74gIjpUg3mel7wt4mvslfey79M4FZ/juLh+9olgafpTax2wmRN3nTIaONQ4qKtRIiiwJ3SJO21gn2VXfFfmqfhATDr+jsSBPUvDnzzOLltNUEK1Rn3sh0aCUnnE+KrMPpNcw7IutOiHTBAEUYp8fFCorz/lmCqYjIbo3JKlVPw6DTOtWEAnd45lmYHeEq2xj5oNxgd7TjsL7IMpywsLFbYJNVlMxef5aNmnnnD5Q1J6OttsAYBGp3C9lNXYM/M8bQJ7IH2d/U7ROC9R//pYSJRJDAX2hC5xJ62xz36KHM/zGbviM86dXg+OA7a2D6MjQd3TlkODALKj1gPQpA4SiKr1NQ6LtOjRCzQ5EARBZAarrz9tcg2AaP9stYp9JMLDHUgR2Iv37WFfCP5QZvM9Mxqrkd3HXhhPIBwpSdNVqe56lCdBpS36ufiC+vtc+j3COqjRWQarSQiP9NjLflA8jzKzMU7xbqxUrthHzfO0E5ZY3XwyxT7a6i6xcR6jntZuCaHAPg0rV65ES0sL5s2bl++hEDG4k7jiMzfTbJraDPtC0qSVqWJfW27FKWLQ/nYCd/wth4XFUrYCe61S8aNp+PpS64FYd1VK5yIIglAKz/No3S8o9nNZYM/8WzzqAiNPIAQm+iZyxY83Ps1s/upX3Mc+GiwlMwArZvqSmA2WW00wGoRrokdnfJa5WG0369oIcCCBIz4QrbHv8wRkbYbxPK95H3sgGrDv6BxOmNmRrtUdg3rZJ4YC+zSsWLECbW1taG1tzfdQiBg8aRR7fyiSNafMblGtd5aZk9b/KCHWHT8Wnuez6ogPRG/8Ll8IobD6HXaph71TX/X1AFAnbs7Qri9BEIRy2gdH0Dnsg8nASZvQmW4aszR8s5GT1NNYOI7TJB1/JBCWNuqrZdbYm40GWMQxuUuwzr5PqrGPD/Y4jpNUe70FxDzPxwTElhi/AH2dB5DcDLLKbpZ+S3L6v3sCYfhZ9wMNFfvj6sth4IRM0dElkIFQBHu63QCA6WkUe+plnxgK7Ald4krqih8NtLNloNclGedps4O5qEUI7D/c2xc35sP9I+j3BGA2cmgZn/oGp5bY+qvBDCYwFthPqNZhYF9ONfYEQRBq+VhMw585wSm5pFdrFNhX2MzgOC7hMbXiwr43g3s3G5/JwI1ZT6TCwfx8dFiDnSl9HrHuOkF7wEqdKt0jwWgQW+Ow6FqxT+SIDwgbL40KnPHZ78puMWpaYmkzGzG1TnC7Z/3qGft7PQhFeFTYTBjvTJ0BSr3sE0OBPaFLmBvt6InYajJAzATLWp29Fj3sYzm+vhzNNWUIhCL45+5e6fEtRwYBAC1NlbCaMs8MSITJaJB22AczSMfXY6s7BtXYEwRBqKf1gJCGP29ytfRYpv4tzBE/UX09Q4uFvaTSOixJNxASIbXWLcFUfGael0jF1avSzc7JYjLAbjHqOrBP1b6R9bJP5Ok0GraBo2UaPkOqs++Mr7Pf0eWW/p7u98h62dPaLR4K7AldIvWxHzXpcxyX9R6z0R722gT2HMfhvOlj0/GzbZzHiJocZaDYD3gB6K/VHRBvwKJHJ1+CIIh8whR7Vl8PRIMKtRvGqRzxGVpsyg54WFsweWn4DNbyrhQV+94kqfgAdBsQs+9BjV3Y4NFr5gEQXctVlY39TrM6ezkGej2u5Bs4mSLV2Y9S7HdK9fXps1TZxl4mGTvFCAX2hC5xi21mEqXO2a3ZNdDr1sgRPxaWjv/Ojm6pb6pknHdMlWbvk4gqDVreFYNi7w9FdNnahiAIIl8MeYPY2SUsxudOiir2zFht0Kuu9RkzX6uwJg+4azWosR9QaJzHYH4+panYp0jFt+kzIO6PydwA9LtBAQBDKb7TDSywl9HyLhvGeYxkij27l7Be96moo1bFCaHAntAlbr9ws00U2GdbsY/W2GvnAD9vcg0qrCb0ugPYcmQQwXAEW48KO5knT6zS7H0SIbkXq1Tsg+EIulzCJKFHxd5mNkqqEJmwEARByIf1r59a54hTcKvEeSUU4VVtmCpR7Hu1SMVXGthL64zS2gzmeT5lKn6llIqvr89lQHL6F8YvnYce3f2ZYp8gC6WpUr5i35eFVncMZoy3p9sd1zJyZ0wqfjrY79/tD5Xc7zAVFNgTuiMU0yM1UWDPzHs82TLPc2mv2FtMBpw1rQ6AkI6/o8OFQCgCZ5kZU2odmr1PIjI1Oeoc8oHnhXNItIOvB6I7v9TyjiAIQi6sf/28STVxj9vMRqn9rJpssFjzvGRomoqvcO5iRr3uEsvyGvaFEAwLGRij290B+lW6R9elR89Df9c31WZVo9i5SJZ5XhYV+/FOGypsJoQiPPb2CMG8JxgVzk5oSB/Yl1tNsJmFMLbXlVnLy2KCAntCd3j8USV+dLs7ILqTnq3+st1ZUOwBYJHY9m5dW7eUhn9yc5UiQx81VGVociQ54leVwWDI7lizxVRx8+RT0deAIAiCSM/HB1j/+uoxf8vEQE+WeZ4GfayT9fxOB1t7eP2llYrfJ37WFVZTQlPfyjJ9truTFPsxgb2+zgNI7ooPRGvsu2Sk4qfqfpApHMdhRmO0nz0AHPUK68fmmrKUG3qxr8G8rnrcJMowKLAndAfrG2sxRXvJxpLNGvtIhJdUXa0D+y9Pq4PRwGFnlwuvf94BAJg90anpeySiOkOTo6Osh32Vtp9HLjlf3FRZs60zzyMhCILQB75gGJ8fGQIglJONJpNe9nJS8Ws1MM9iY0ukPqfCnuXMwEKljwXASdKznTpNYS+mGvuUrvhiYN/t8iMUjoz5eyxMBWdtJbWG1dHv6BDq6ju84uMyjPMY1Mt+LBTYE7rDnaSHPYNNuNmosR/wBqQ0tDqNb3ZVdotkPrRpv6CCZNs4D4h1xc8wsHfqr76ecd6MBnAc8NmRIVltYAiCIEqdL9qHEAhHUFtuxaRx9jF/jxroKZ9bWIq7HMXeEwir3shn9eKJgqBUsPVHtrx8ChVWd51MxdVrQBx1xRdr7MXvnd7a9gFRxT6RK35tuRVGA4dwhJe6GySjV1LssxTYiwF8W0e8Yi+nvp5BvezHQoE9oTvYhJ88sM/ehMucRGvLLTAbtf/5MOWYkW3jPCDzfsNSKn61fgP7ugor5hwjbKqsbetKczRBEAQR278+UcmYVOblySQVP3lKrsMSreNXa6DHgqCaBGnLqZD62JdYjb2Unp2k7pq54ustIGYbPJJib9fneQTDEWmNnKjG3mjg0CBuiKVzxmeZMHUV2fFOkhR70Rk/GtgrV+ypl30UCuzTsHLlSrS0tGDevHn5Hgohwm5aierrAWGyB7LjVsvSfbTqYT+a82bUS//dXFOWdPLUkkxT8dsH9euIH8viE1k6PgX2BEEQ6UjUvz6WTOaWYRmp+BzHoVYMOtQu7NUq9o4st9UtVPplKvZ6C4hHl2TEZh6oadeYL9hGFcdFnf1HI7W8S5GdGAhFpN9gthT7aaJBXo/Lj163P5qKL6PVHaOeAvsxUGCfhhUrVqCtrQ2tra35HgohwibSiiSBfZm0k669Yt+VhR72sUytK8fUOsHIbXbzWDOibJCped7RGPM8PbO4pREAsHFfH4ZUfhYEQRClQCTCS8Z58xIY5wHRbLD+jGrsUyvpLBVXvWIfb5omF0mxL7VU/BSt7gD9puJLiv0o87xQhNdVuQX7PjvLzDAmMTNmBnqpnPFZZobJwEmfhdY4rCaphGft9m4EIhysJgMmj5PfCYp62Y+FAntCd7Aae7ZjPhqm2I8Etd9Jz0YP+9FcObcZALDkxIY0R2pDrKqidGea53m0DxRHYD+51oFpDRUIRXi8s5NUe4IgiGTs7nZj2BeC3WJES1Pi1NmoeV52XPGBzFJx/aGwFJgr7mNvzV5mYCEjmeclUXGZSuwJhBFMY85WKPA8H+MkL3wPysxGmI1CYJzLTYoelx/hiPoMAfZbS/V9bqwU1mqpetlLXgrllqx2O2LO+K99JhhGH19fnnRDIhGUij8WCuwJ3SHV2CfZybdbs6jYZ8kRP5bvnjUVH/3oPCw7aXzW3iMWNgEEw7zinryD3iBGgsLnzNxW9Qyl4xMEQaSH1defckwVTEn8ZjIxz2OKfWUWA3sWzBkNXNoNhNHYs5gZWMj0Sb3NEweOsdeLXcNCxxMIIyBuQrDMDY7jJL+AXAX2244O4bR71uFHf/1C9WtEHfGTq+xMsU9VY8/M6LKVhs9gafcfHxwEAExrLFf0fArsx0KBPaE7ouZ5iRV7e1Zr7LMf2HMcl9XXH02ZxQir2DZwUKGywozzasutsJkTXw89wdLx39/VA1+wtBZsBEEQcpH6109KXF8PqDfP43k+xhU/dRpwbQau2FJ9fZlZsSpZsoq9O3V7QJPRIBkb6yUdn/Wwt5kNKLNE1zG5LivY1j4Mngc2HxpQ/RpsEy2VYt8gJxXfnd1Wd4zRRnms7l4uzO+q1+1HJINMh2KCAntCd6R3xc9eu7toKn72Te1ySbXKfsPF4Igfy8wJlRjvtMEbCOOD3b35Hg5BEERB0ioa5502JXlgr9Y8zxsIS+nI8lPxlWcFDIzqXa4ER6kq9qzGPoWSy1R7vQT2bINntM9CZY6NAFl7uY7BEdWGfala3TEkxT5FYM88K2pV/DaUMGOUUd50hYo983oIRXjVLZuLDQrsCd2R3hU/e6Y2nTlQ7POBWgO9qHFecXweHMdh8YmCar+mrTPPoyEIgig8jg6OoH1wBEYDh9nNVUmPY4G9UvM8lsJtNHBSO7tkZNLHmmUSVKdIW06G5IpfQop9JCZ4SpaKD+Q+IM6U/iQbPLlW7FnHAU8gLDnSK4Wt4VJ1eWisjKbiJ9tAkEousqzYN1fbJTEOAE5QqNibjQYpe4R62QtQYE/oDmael1ax17gNTSgckXYx64tUsVeqrLDAfryzOBR7AFjcItTZr9venZGJDUEQRDHy8UFBrT9xfGXSDXYAqBJ7w/uCEUWlTbHGeRyXOkWeBR69Kmpso/XIylVJVmPvLSHFfmgkKM2JqbIc9OaMP+BJXF6Q88DeE11/daRoRZeKaCp+8s0qJkwFQpGkYk5vmraGWmEwcJjWKATzlWZe1ftJm3tUZw+AAntCh3jSpeKLj2udit/rDoDnBRUh24YiuabawWohSzsVHwDmTamBs8yMfk8Amw+qr3UjCIIoRuTU1wNCS1qTWLuuJE1WTg97RqxirzR9eSBJCrYcWGZgIBxBIKQP9/dMYS3QnGVmmJMYJgJRxV43gX0SlduZ81T8mMB+MHmafCqkzaoUAbLFZJAyLpJtIEip+OXZX+uyOvvxdnVCChPaKLAXoMCe0B0uyRU/WSp+dkxtWA/7unKronYcekBtW6J2cfIZr/NWd7GYjQacN6MeAPDWNkrHJwiCiGXT/tT96xkcx0XnFgUGelEfnfQp8qzGPhCKKE5flgI6h/JUfHuMee+IjvqcZ0KfTBVXCoh9OgnspQ2e+O9BZVluvQL6PdHA9KhKxT7a7i71d7oxTZ19b0y7u2xz0awmAMDsceoCe7a5R73sBSiwJ3SHJ02NvdTuTuPJlgX2DUXQ1m00bBJQm4qv9x72o2Hu+GvaOlWb2BAEQRQbQyNB7OxyAQDmpAnsAXVzi9we9gBgMxul45QqdmxMahR7s9EAi9hNplTq7CXjvDTBnt5S8Qutxh5Qr9jLccUHYnrZJ2l5l0vF/kvH12L3zxdjQYPKwJ5a3sVBgT2hO6Q2OMkCe9FsJxCKIBTWLkWuS7xpNGTZTCQfVKtQ7H3BsHQjLbbA/qwTamE1GXC4fwQ7Ol35Hg5BEERB8MmhAfA8MHmcXWo1lQo1Bnpye9gz1NbY9ssMgpKRrezAQoUZqiVrdcdg/d/1Yp6XrsZerZGdEnielzZOgMwVe2cKV3wAaHQKv5lEin0kwkv1/rkI7DOFAvt4KLAndEd6xT6aIufVsBd5LnrY54sqFe3u2IRQZjZKrvrFgt1iwlkn1AEA1mzryvNoCIIgCgOpvn5y6vp6hpqOK1HFXt68IhnoKXTFltKWVRqEMQM9d4kY6EUV+9TBnlNMYR8e0ceGBwtiR2/w5FKx9wTC8Md4NahR7Hmex5DM73STaHicqJf9YIxJYrpNnEKAAvt4KLBPw8qVK9HS0oJ58+bleyiEiCuNK77FaJAMe7R0rJVS8YvMER+ITZeUP4FJjvhVtrTOxXqEueNTnT1BEIQA61+frr6eIXVcUWDM6lJgngeoX9gPeNI7iKeCtbzTugNPocJq7NP1Nnfa9ZWKzwSN0UFsLk0AY9PwAXWKvTcQRkDMUk1bYy8KVF0JUvFZZoazzCyVmxQy7Pff7VJXvlBsFP4VyzMrVqxAW1sbWltb8z0UAkAwHJF2NZMF9hzHocyifY/ZzmHW6q74FHu2u6tEsW+XAvviSsNnnDejAQYOaOsYxuF+b76HQxAEkVf8oTA+OzwIQL5iH51blCj2CgN7lb3sB5LUVsuFKfZa+/kUKv1JUtZHw1Lx9RPYM8O5/Cn2rOOA2SiIJB1DyXvMJ4N9ny0mA8rMxpTHNoleUYkU+x6pvr7w1XoAqCfFPg4K7Ald4YnZGU/VP5e1otHSrbaYU/GjfezlT2AssJ9YRK3uYqlxWDBPXLyubaN0fIIgSput7cPwhyKocVgwtdYh6zlqzPOGFabi16noZR8MR6QNBNU19tbSqrFnpQ7pU/H144rP83w0c2NUd4RcblCwbIhj68rBcYJHVJ/C9sODMY746bIoG1K44kvdD3RQXw8AdeXCuQz7QvBpWH6rVyiwJ3QFM86zmgwpU4RYnb1HwxS5UkjFd/tDsnvySqn4zuIM7AFgyYlRd3yCIIhSJtq/vlp2+VUm5nnZVOxZEMRx6Y3GksEEBE+J1NgzxV5uuzs9KPYufwghsZ58jGIvrosCoUjWA0b22TY5bZJhndI6+wEFZpAsFd/tD0meFgy2gVOnk8C+sswkxQNKfTaKEQrsCV0R7W+besK3S2612tyM/aGwlK7VWISKfaXNDNGWAIMj8hZgR4uwh/1oFol19pv290sTL0EQRCkSra+Xl4YP5MY8T02NPQuCnGVmGA3qPGJY1mCpKPZyzfNYbfrwSBCRSGG3i2Vqvd1ihG1U+nq5xSSti7Lt8N8nlTlYMV5U05XW2ct1xAeE7y7rOjG6zr4vhz3stYDjOOplHwMF9oSuYAp8eZqdfFb7plVg3y3W11tMBtW7+4WMwcBJ5yU3HZ+l4k8o0lR8AGiusaOlqRIRHnh7O6XjEwRRumzvGAYAzD6mSvZzWP26sj72yhT7WhXt7qQWZyrT8IGogOAuAfO8cIRPajI3GraWiPDa+hwlonPIh08ODah+fjJHfEBYF+XKQK/fw8ocLFHH+kFlgf2QwvaNjUnq7HPZw14ryBk/CgX2hK5gEz5LgUuGQ2PzPOa22VBpLUoHeCCml70MZZrn+WhgX8SKPQAsPlFQ7ddQnT1BECVKOMJLyp4SXxUl8wpDcR97cVHf5wnIVog/FU0Am6rUZ+BFFfviT8Uf8AbA80LpQjrHdZvZKKVGZzsgvuGPrbjst+uxv9ej6vnpNityVVbAVPIah0X6TiYytktFtH2jPPGpMUnLu17W/YACe11CgT2hK1gtm2zFXqOd9C5RsW+oKL40fEY0ZTL9AqzPE0AgFAHHFaeZYCyszv6fu3s0NWMkCILQC71uP0IRHkYDh3oF8yALAod9IYTC8vxbmAIuNxWfpQzHqsqp4Hkef/74MABg2UnjZb1HIphir6WXT6HCAs9quwUmY/rQIRfGcyOBMNrELJId4v8rpd+Tuu97zgL7GP8C5lt0VHFgL7xGlUzFvom1vEui2OslFR+gwD4WCuwJXeH2CzdX2TX2GhmeMOfQYg5iJWVFRip++4Cg1jdU2HTR5zQTpjdWoLmmDL5gBO/v6sn3cAiCIHIOM0utr7AqqkmPLV0blBEc8Twv1dinm+cZZqNBUlzlGOh9engQe3s8sJkNWHZSk6z3SIRD45K/Qoa1Y0uXhs9wlgmfzfBI9jY99va4wTrCHRlQ3vcdiJaIJMtCyJUzvmRMWB6j2CtMxY91xZeDlIo/usbeo79U/PoKqrFn5H1F3t7ejmuuuQbjxo2D3W7H7NmzsXnzZunv119/PTiOi/vf/Pnz417D7/fjpptuQm1tLRwOBy655BIcOXIk7piBgQEsX74cTqcTTqcTy5cvx+DgYC5OkdAQN1Ps00z4UoqcRm61XWIqfn0ROuIzquzye9l/tL8PADA+gzRGvcBxHBa3kDs+QRClC9vcZv2v5WIyGqSUejl19v5QBMGwEK3JrbEHoj23e13p3+PPHwvrwwtnNsnOCkgEW2eUkmKfzhGfkQule2enS/rvwwNeVa+RqsYeiGndl/VUfLZxYo3W2GdZsW9M0vKO/Yb00sceIMU+lrwG9gMDA1i4cCHMZjPefPNNtLW14Ve/+hWqqqrijrvgggvQ0dEh/W/VqlVxf7/lllvwyiuv4IUXXsAHH3wAt9uNZcuWIRyOBnVXX301tmzZgtWrV2P16tXYsmULli9fnovTJDTEzWrs0wT2ZVrX2LNU/KJW7OWZ5320rw+/XL0TAHDxyerTGPXEYtEd/+3t3bLTSQmCIIoFlhbcpMJThaU5y8kGY73POS69l04s0sLenToY8gXDeOOzowCAy+dMlP36iWB97LNtEFcIxCrKcqjMQUC8qysmsO9XF9inq7GPmudl7xrzPB+fii8KJp3DPoQVdBWQauwzCOw9/hBGxExXPSn2alpeFivy75pZ4P7770dzczOefPJJ6bHJkyePOc5qtaKxsTHhawwNDeGJJ57A008/jfPPPx8A8Mwzz6C5uRnr1q3DkiVLsH37dqxevRobN27E6aefDgB4/PHHsWDBAuzcuRPTpk3T/uSIrMAm0HQ7+cw8T6uaaGYaVIyt7hjS4iuFydGRAS/+9dlPEIrwuPjk8bj+jMk5Gl1+mTu5BjUOC/o9AWw60I8zjq3N95AIgiByBksLHq9QsQeEQONgn1eWgR4zziu3mmBQkPJfJ9MZ/61tnXD5Q5hYXYb5U8fJfv1E2Euojz1TlMc55AV7ktLty01grzYVX1Ls81hj7w2E4Q8JgsG4cgusJiOMBg7hCI8el18KwNMxJCn28rJQWPZNZ0wqPsvMsJkNUkmrHmAbe72k2Oc3sH/ttdewZMkSXH755Xj//fcxYcIEfP/738eNN94Yd9x7772H+vp6VFVV4eyzz8YvfvEL1NfXAwA2b96MYDCIxYsXS8ePHz8eM2fOxPr167FkyRJs2LABTqdTCuoBYP78+XA6nVi/fn3CwN7v98Pvj35BhocFY45gMIhgMLspOYlg75mP95bLo+/uRYTnceOXpkiKudawG5fNxKX8LKwmYUHg8mlzvdiO5ji7aczr6eHayKHCKiTw9Hv8Cc/FGwjhO3/8GP2eAE4cX4FfXDIDoVBhKxVaXptzp9Xh5U/a8eYXHZh3jDPj1yt1iuV3U4zQtSlc8nVt2sVU5/oKi+L3ZvXWvS5f2ucOiIp7hXXsXJuKGjGY6RoaSfm8F1sPAQC+OrsJ4XAI4QxicqtRUFM9/mDc2rAYfzesM1BVmVHW+VWI2Qz97sTrCS2ITcU/MuBFIBBI2bUo0fVhGxZOqyHhOMstwrpowJu98+gaEn5bNrMBZo5HJBxCfYUVHUM+HOpzYZxd3nqaZR+Um1Ovjxm1duF32e8JwO31wWo2onNQ6C5Q67DkdH2X6W+npkz4jLpdvrTfA70i97PJa2C/b98+/O53v8Ott96KH/3oR9i0aRNuvvlmWK1WXHvttQCACy+8EJdffjkmTZqE/fv347//+79x7rnnYvPmzbBarejs7ITFYkF1dXXcazc0NKCzU6iH7ezslDYCYqmvr5eOGc29996Ln/70p2MeX7NmDex2e6anrpq1a9fm7b1TMegHHv5E+Do9v34vvnFsBMc75acQyWX3fgMAAw7v24VVIzuTHre3iwNgxIEjR7Fq1ZGkx8nl6IARAIftn25E/47ExxTqtZHL/j7hM9vX3j2m3IXngad2G7Cjz4ByM4/LGwfw7rq38jNQFWhxbao9wufz+icHMQf7UITzRl7Q+++mmKFrU7jk+tpsPyjMgUf3tGHVwDZFz/X2C/P2xk8+h6Prs5TH7hgU7rN8cGTMPJSK3nbheZ/t3I9Vkb0Jj+n3Axv2CudRPbgLq1btkv36iTjoAgAT+obccWMtxt9N217hGnYc2C3rc+s+Ihz/xY49WBXI7HNOhC8EHB2KhjAjwQhe/NubqJSRhR57fQ53C9+HXV98Cv7Q2DXrIXEtufvAEaxadUiDkY/lgPg9KuPC0vfIFhHGteq9DegYl34tHeGB4RHhOZs3/AO7ZIj2PA+YDUYEIxxefP0t1NqAL/qF8zWGlP3+tELtb0dIeDAhGObx8mtvQmbHP13h9corN8lrYB+JRDB37lzcc889AIBTTjkF27Ztw+9+9zspsL/yyiul42fOnIm5c+di0qRJ+Pvf/47LLrss6WvzPB+3Y5No92b0MbHceeeduPXWW6V/Dw8Po7m5GYsXL0ZlZaWyE9WAYDCItWvXYtGiRTCbC+8b+/HBAeCTVgBAr5/Do21GXH3aRPz74hNkO9vK4ZW+T4C+XsybPQtLU9THRT7vwAv7vkBF1TgsXTovo/f0+EPwbXgHAHD5ssVjzqfQr41cavb148ldH4OzlmPp0oVxf1v53j5s6dsDs5HDH66bhzmTqpO8SmGh5bU5NxjGs/e9h8FAGJNP+RJOHJ/7+0AxUSy/m2KErk3hkq9rc8+29wH4cdE5Z+Dkicoylj5dtQOtvYfQcMyxWLrkhJTHcls7ge2fY0JdNZYuPU32ewS2HMVrh7bC4qzF0qVzEx7z6Lt7wWMvTp9SjeWXZbYuAIDd3W78eut68EYLli49p6h/N08f3QT0D+Ks007BhTMTl8bG0vHhAaxp34XqhglYunSW5uP59PAg0LoJ9RVWGDigc9iP6XPOwOzmqqTPSXR9fvb5ewACuOCcL2FaY8XYJ33RiZf2fQ5bZY2i76MS3tnZA2z9FBNqnVi6VDAHX+P6HPu3dqJp6gwsXTg57Wv0ewLgN74HAPjasgtktSQEgId2f4ADfV5MP3U+Tptcg+HWI8DONhw7oR5Ll56i9pQUo8Vv52efv4OhkRBmLzgLx9eXazzC/MMyx9OR18C+qakJLS0tcY/NmDEDf/nLX1I+Z9KkSdi9ezcAoLGxEYFAAAMDA3GqfXd3N8444wzpmK6urjGv1dPTg4aGhoTvY7VaYbWOrSUym815vWHn+/2T0Sm6aJ7cXIUTx1fiuY8O4blNR/D+rj7ce9ksnHVCnSbv4w0IdUhOuy3l51BpF67dSDCS8ec1MCScm8NiRHV5cuOgQr02cqmtFM5taCQYdx5rtnXiobf3AAB+fulMzD9ubPZLoaPFtTGbzTj7hDq8ubUT7+zqw+xJmdVnEgJ6/90UM3RtCpdcXptQOCLVrh8zrlzx+44rF2p5h33htM8dCQnqZGWZRdH7NFYJmZR97mDC50UiPF7Z0gEAuGLuMZp8dlUO4bw8gfjzKsbfTb9ozFbvtMs6txrxs3H5Q1n5LPb3CTX10xor4A9G0DnsR4criHky3otdn0iEl1ow1iU5r5oK4Tzc/vTfXbUM+USzugqr9B4TaoTvc5cr8fd5NO6g8PussJlQZpNvetfkLMOBPi96PcJ1GhRNAusqUq+xs0Umv526ChuGRtwYHMnetconcs8pr674CxcuxM6d8enUu3btwqRJk5I+p6+vD4cPH0ZTk9B7dM6cOTCbzXHpGx0dHdi6dasU2C9YsABDQ0PYtGmTdMxHH32EoaEh6RgiM470CzfZE+rLcc9XZ+HZ75yO5poytA+O4Nr/24Q7Xv5ME/MRt5+54qeuOZJMbTQwzyuFHvZA1El1cCQIXmwOu7PThR++uAUAcN2CSfjGacfka3gFwWlTagAAe7pdaY4kCIIoDrpdfkR4wGzkVDllR13x5ZvnKWl1B0QdvHuTuGJvOtCPQ/1elFtNuHBWesVZDsy1PxCKIFjk3VKYqZrcFmiVrI+9Lzt12js73QCAExoqMLFGECWUOuO7fCHJdT6Z4VwuzPOYgV+sMz8ztusYkmcKyFpJynXEZ0i97MV1Lvv91Fbop9Udgxlolnov+7wG9j/84Q+xceNG3HPPPdizZw+ee+45PPbYY1ixYgUAwO124/bbb8eGDRtw4MABvPfee7j44otRW1uLr371qwAAp9OJG264AbfddhvefvttfPrpp7jmmmswa9YsySV/xowZuOCCC3DjjTdi48aN2LhxI2688UYsW7aMHPE1ol10zJ1QLdxgFx5Xi9X/dhauP2MyOA546eMjWPzg+1jXNjZzQgkssE836TM3T68G/WW7S6CHPRCd2MIRHsO+EAY8AXznT63wBMJYMHUc/mtZS5pXKH6aRk2CBEEQxQ4LLhoqbYqc6hnSprGsdnfqAnvmit3vDSQMsl/eLHjtXDSrSdr4z5RYk2BvETvjB8MRKbCtkemKX5nlgJg54p/QUI6J1YK6rdQZv5+ZzVlNsJoSi0W5COyjHQdiA3thLX1U5lpjwCOMT64jPmN0y7teqe2e/ta7bI1e6r3s8xrYz5s3D6+88gqef/55zJw5Ez//+c/x0EMP4Zvf/CYAwGg04osvvsCll16KE044Addddx1OOOEEbNiwARUV0VqYBx98EF/5yldwxRVXYOHChbDb7Xj99ddhNEZ/qM8++yxmzZqFxYsXY/HixTjppJPw9NNP5/ycixV2Q2U3WEDoNX/XJSfipe8twNRaB7qG/fjOnz7Gv73wqbRDqRSPX14fe6boe4OZT7al0OoOAGxmo7Qh0uv2Y8Vzn+Bw/wiaa8rw22+eCrPMmq1iplGcbLsosCcIokQ4Oijc78Y7lfewB4BqMdjol6XYCwFKhU1ZgFJtt8Bo4MDzGLO+8PhDWPWFkIZ/+dzMetfHYjEZYBHnxWLuZc/aFBo4oKpM3nXJdkAcDewr0CwKSkcGlCn20VZ3yc+JnYc3EM5aVobUwz4mG4b1smdtJtPBSgqqFCr2TaMDexdT7PUX2FMve4G81tgDwLJly7Bs2bKEfysrK8Nbb6V33rbZbHjkkUfwyCOPJD2mpqYGzzzzjOpxEqlhN9SJ1WMn/nmTa7Dq387Eg+t24fF/7MPfthzF+r19WHXzmdIuu1xc/miP21SwHXktdtG7hoWbRLGn4gPC4sgbGMGP/voFPtrfD7vFiMevnZu0x2upwTZ3ulx+hCM8jCrUK4IgCD3BFHu5/bRHUyUp9ukDe7dKxd5o4FDjsKDH5UePyx83X//9iw54A2FMrXVobvxqtxoR8EbgDYQAR96X1Fmh1x1NFZebsVEpbswMZyGwH/QGpHTr4xsq4AsKAbdSxZ5tWNSkCIZjN5iGRoKqSlHSkTgVX1hL97j9CIQisJhSCyvRVHyFir34O+kQBSy2yVCrwzUfiydIsSeIDIlEeGlHf0JV4h19m9mIOy+cgVe+vxATqsrQ4/Lj7e3K0vIDoQgCQk8LGYG9oDwHwpnXvjHFvr4EAnuWxvXR/n4AwINXzsb0RnJ/Z9RVWGE0cAhHeCl9jiAIophh83tTlbo5kCmig96of0sypBp7Fd10kil2L38spOF/bc5Ezftbszp7TxGn4verSM92imsJfygCnwaZk7Hs6hLq6ydUlaHcakKzWGPfPjCCSER+m2Xm+ZBKuDAaOOm7mI1NCiDqXxCbij/OYYHFaADPR9egqRjIsMa+U9y8i9bY61Cxp8AeAAX2hAb0uP0IhCMwGjgprScZJzdX4expgkN+u8wUI4Ynpl4+XSp+bA2dN0MDvW5JsdffjU4psZPCrYtOwJITtTEZKhaMBk5aPOa6zn4kEMaabZ2CMkQQBJEjWJqu+lR8YV4JRXgp6y4ZLr+6VHwg8cL+QK8Hmw70w8ABXztVuzR8Biv7K+ZU/D6PWAMu0zgPAMotJjBxX+uAeGdMfT0gqM4mA4dAOIIul/x5WW4wnG2/gESKvcHAjTG2S8WAN7Ma+x6XH75gWPLBGKdDxb5e7GDQreA7UIxQYE9kDEt/aqy0yeqdydL12xWmTTHjPKvJkLbe22IywGwUZpVMAyE2UZRCKj67NktnNeKmc4/L82gKE2mHW8YuupY88cE+fPfpzXjsH/ty+r4EQZQ2LBU/3cZ9MmxmI8rMQgA86EkdHKl1xQcSB/bMNO/M4+tUlxKkwl4Cin2fe2zgmQ6DgZM2Z4Z92gbEu1lgL/adNxkNUjaJknT8fvG7mC6wz7ZfANs4GZ3mr8QZX60rfq3DCpOBQ4QHdnQKn6vRwCl+nUKAFHsBCuyJjGH19RMS1NcngqXrK62HkuuIz2ALiUwmXJ7no+3uKoo/sL918Qn49RUn49dXzNY8ZbFYYDVpnTlW7Le2DwMAPjk0mNP3JQiitGHO3OOTlNrJQa6BXjSwV67Ys8CILezDER5/+UQI7LU0zYtFMuotAcVeaX15tgLinWIAekJ91ES7WTRuVtLyTqqxT2GeB2Q3sPcGQpJHwOiNE/Z7Y6UwqVDrim8wcJJotbV9SBqHmu4X+YYF9gPeoFS2W4pQYE9kTNQRX96kLyn2KlPx09XXM1i6/kgGqfjDIyH4xRtEsbe7A4RUpstOnQibOXHrFyJ/iv2BPg8AoO3ocE7flyCI0iUQikh1t5ko3sxAL10v+6grvnrFno33wz296BjyodJmwvkzGhS/nhxKQbFPlCouh2wExDzPS4740xoTBfYKFHsZNfZA9DyyUWPPsiGsJoPkDcVQpNirdMUHor/rbUeFwF6PafiA0LHBJG5IsM2oUoQC+zSsXLkSLS0tmDdvXr6HUrCwAH2izN181hKvc9iHkAJjO5fMVncMdpPMpPaNpeFX2c0U7BIAxvZ9zQU8z+Ngn6BE9Lr9JZ9qRhBEbuga9oHnhfK2TBb8UQO91IG92j72wNhUXJaGf+nsCVmbvx2W4lfsmSu+khp7AKgsY6Zz2n02ve4ABrxBcBxwXH259PhEFS3v5LjiA9HzyIZiL7W6c1jGZEk2KVDs1briA9E1zReiYq+0W1WhYDBw0tiZN1YpQoF9GlasWIG2tja0trbmeygFS6Ie9qmoK7fCYjQgHOEVqZ5KFXup5V0mgf1w6aThE/LIRyp+17AfIzHOwts7SLUnCCL7HB2M1tdnUp4lKfYpauz9obCUQqsuFV94jx63H0MjQby1rRNA9tLwgajQUMyKPesAo3RjJxuKPVPrJ9XY4zZrmmtExV5BYK9Ysfdpv3nTLxkTjg2mxytQ7NW64gNAk7imYSUOelXsAaqzByiwJzSgXWGNvcHAqTI6Yf1t5Qf2bCdd/YTLetiXQho+IQ+2uy2nBY1WsDR8BgX2BEHkArb5rtY4j1Ejo5e9KyZwkjvPx1LPUvFdfrz+2VH4QxFMa6jArAlOxa8lFymwL2LFXmp3VwA19rskR/yKuMejir38NSVzgE9XYiCdh1d7xb43hTEh62WfzhXfFwxLdfpKa+yB6JomGBZaBSr1UigkkrW8LCUosCcygud5xTX2QNRAT4kzPjPPK5eZoscmXG8GO+mSYl8CjviEPJhi3zHkS9uTWSsO9FJgTxCxfH5kEHf+9XOpnprIDiwNWG2rO4Yc8zxXzOa9UYV5V125cG8e9oXw7EeHAAhqfTaNYKWSvzRt/PSMGld8AKi0aV+bniywZ4p9x5C8Es9whJc2mdIFw9k0z+v3jO1hzxgvCmD9ngB8weTrWKbWmwycqg2x0d4ZSjdwCglS7CmwJzKk1x2APxQBx0V3F+WgxkDPnYca+24psNfvjY7QFjYJjgTDWUnNS8R+UbE/Rly8tFFgT5Q4j/1jH57fdBivbTma76EUNVKru6rMNrej5nnJg6NMjPMAoRbaIrbC3d4xDJOBw1dOmaDqteTikEr+ijMV3x8KS/5GtQ5l66Bs9H/f1eUGEG11x6grt8JiEko85fR9Hx4JIiLuy+ezj30qY0JnmVnq7pTqnKKO+GPr9OUwOhunVqGXQiEh1diXcC97CuyJjGCBeUOFDRaT/K/ThCohQFFidMJ2xCtymIrfSYo9MQqb2Sjt8Oeqzv5gr/A7uXBWIwBgb48n5Q4+QRQ7LI02lyUxpQhT7BszVexlmOe5MzDOAwCO4+KCknOm12c9rdhuLW7FngWeJgMnmcjJRWulm+d57GKt7hrK4/5mMHCSgbOcOnuWOVJhM8FsTL12zaZi3+dOXubAcZyk2h9NIYINjsjLPEjG6N+2nlPx60mxp8CeyAwWmCtJwwei9fjZVey1MM8Ta+zJPI+IQTLQy1FQwWrs508Zhyq7GeEIjz3d7py8N0EUIsOiulvKC7hcwBT78RnW2MsxzxvOoIc9I9bR+/I52TPNYxS7Yh+bhq9UDa6UTOe0CYg7h31w+UMwGThMrS0f8/eJYkbbERkt7wYUtPDLpmLP2rIlM6yL9rJPEdiLm5xqHPEBIRiOvbR6DuwpFZ8CeyJD1NTXxx6vrMZemDjl97FnO+nqJ1yWip9J/16i+Ii2vJP//VVLJMJLgf3kWgdmNFYCoHR8orRh9djdJbyAywUsBVhJqV0i5JnnCQGKmjphBlvY15ZbcM70etWvI5diN8/rU2mcB8Qq3dp8Nsy1fXKtI2GGaHO1AsXeI99F3qnxBkWicSTbYIj2sk+Rii95BahLoTcbDXHBvNK2hoWEFNiXsPcKBfZERrDAXK4jPmNCTH/OSESeAZlb4aSfqWIfifDSopFq7IlYoi3vsj95dLv88AUjMBo4TKwuQ8t4MbA/SoE9Ubq4SLHPOr5gWAo8xmdYY88CKDnmeWpT8QHgmBoHAOCrp0xIm2KtBY4iN89T2+oOiAmINVK6d4v19dNGGecxWMtlOc74ch3xgeh5uHwhhGWuV+USTcVPFtgzZ/zsKfbC+0R/37oO7EUDze5hf87MjQsN9XdPgkBsKr68HvaMRqcNBg4IhCPocftl1bAz5V2uK36mNfb93gBCER4cp+/UJEJ7JMV+OPuK/X7REb+5ugxmowEzmoTAnpzxiVKGpW2XsjKTbZiHSJnZKAU3aqkSa+x9wQh8wXBcD3KGS4NU/H/98rGYUmvH5XObVb+GEuxF3sc+2upOebBXKa7VtArsdyZxxGc014iKfb/8Gns5demx332XL6haGU84DskVP/EaM1pjn8o8T30Pe4awBh9Chc0Eq2nsb1MvMMXeH4rA5Q9JnRlKCVLsiYxgNfJMgZeL2WiQdiLl9h11Kayxz7T2jZkyjXNYc7LzT+iHqGKf/Rp7loY/aZygRM1oEhY12zuGS3ZHmiht/KEwAiGhpVW/JyD9N6EtR5kjvtOWccu4CqsJJrGF3UAS1Z5lYVRmoNjXVVixfMHkhBsH2cAhCQjFqdin6rOeDknp9mujdEdb3Y2trweiApOcVHypxl5GMGw2GiShSMs6e28ghBHRBLcmA8WedZrIZMOBKfZ1OhexyixGyWC7VLO5KFohVKO2hz1D6mUv00DP7VeWil+WYYpc9zCl4ROJiSr22Z84WGA/pVYI7I+rL4fJwGHYF8LRHLnyE0Qh4RrVZpIZUBHa0iGqhJm2ugMEh2+mjiYz0NMiFT/XSIp9kZrn9Yu/LTVZi5UxSnemqn0kwkup+KNb3TFYjX3XsB/+UOrrIdXYy9ywYMqvloE9S8O3mAzSBtFomGLfkUKxH1SQfZAMtqbRcxo+o9QN9CiwJ1Qz4A1Kavh4hYo9EK3Ll9vyzqPSPG9EZVuwLmp1RyQhl+Z5B8RU/MnjBDXCajLiuHpBsaA6e6IUGR0klOoCLttIPewzNM5jVKcx0HP5WR97/aTPsoAsEIogGC6+zBGpBlyFYh+rdGdqPHdkYAQjwTAsRgMm1SQu/axxWKT3S2fMzLJG5GYiRP0CtMvMYJsLtSk6DrDfnssfkjJaRjM4knmN/UkTqgAALWKpn56plXrZl+a8QIF9GlauXImWlhbMmzcv30MpONiNs67CqirtTakzPutxK7/GntW+qbsRR3vYk2JPxNNUKXx3B7zBrPeTPyD2sJ8kKvZAdPKlOnuiFBmt2FNgnx2YE3emre4Y6Qz0dKnYW6JjHSlC1b5PQVu4RGjVA56l4R9bXw5TktJIjuOkdWW6Ek8lrvhAdnrZs0yjZGn4gFB6ykpTkjnjZ+qKDwBfOr4W793+Zfz3shbVr1EolHovewrs07BixQq0tbWhtbU130MpONT2sGcoScX3h8IIiLvh5ZbcmOd1San4pNgT8VSWmWAzC7fPriz2so9EeBzsF1Pxx0UDezLQI0qZ0YF9qSoz2UZqdaciIy8RUiq+N3FwpEUf+1xjMRlgEQPNYkzHl/qsq6y91iog3pmmvp7RLLPOXokrPpCdXvZ9kn9B6s82XS/7qCt+Zmn0k2sdSTdN9ASl4hOESqL19coc8RkTZO6sAvGOsyzFPh32DM3zuikVn0gCx3E5MdDrcvngC0ZgMnBxG2gU2BOlzOiU1FJdwGUbFkg0aazYD3pSm+fpSbEHALu1eFveZZKKD0Rr0zNNYd+dxhGf0Sym6R/uT6PYS6n48jaRsqHYRx3xU3+2qXrZRyK8VNqSSSp+MUGBPUGoRK0jPoNtCLQPjKR192YTps1skL2jyDYA1LrVdrkoFZ9ITtRAL3uBPWt1N7G6LO57z5zxD/R54S7CxSRBpIJS8XODpNhrVGPPWt4lU+zdOkzFBzLvwFOojATC0jmpNVXTSunemaaHPWOiDO+mUDgijUdu+npeA3txjd2RQLF3+UJgDQecFNgDiDr7d7tK01yYAntCNZmm4rNdyJFgOOlEz2ALuXKr/BsXU+yDYV5VOySWil9fQYo9MZZcKPYH+4Tf2OSY+npASItkG047O0m1J0qL0UZcpbqAyybeQEgKYrRwxQdkmOeJ87zeek9nWvZXqLA0fIvRINu0eDRaBMShcAR7e0RH/LSBPUvFT67YD/lCYFpSVZm871plmXD+Wgb2UivBNJsmzOMiURccVl9vtxh13X9eS+rFtVmpbvgqDuxHRpL/WDo6OjIaDKEvWAr9BJWBvc1slFJm0jnjewIssJd/47LHtA9RamoTCkfQ66YaeyI5jVJ/2ewFFVFHfMeYv7F0/LYOV9benyAKERYA1ooL4lJdwGWTo2J7rXKrSbNAm/UMT9THPhiOSB1s9KbYR1veFVf2lKQolyd3bU8HC4gzccU/2O9FIBRBmdmYVkiSFPv+5GtK1sPeWWaWnQEqueJn6O4fC2slmD4VP3kv+6gjvv7b1GkFU+zZGr7UUBzYn3LKKfjkk0/GPP7yyy/jpJNO0mRQROHD87zkZt+sMrAH5DvjK3XEB4RWK1FTG2UTbq87AJ4HjAZOdW0ZUdw0iop5Ns3z9o9qdRcL1dkTpQpbXE+tFYy0ekp0AZdNOqU0fO02tpl5Xn+CDD13THmFQ6U6nC/KpRr7IlPs3dHAXi1aKPa7OoXN6+MbymEwpN5gYDX2fZ5A0jLMAYXGeUBsu7tspOKnLvdsStHLfkCDHvbFBhMM+zwBhIqwBWU6FAf2ixYtwhlnnIH77rsPPM/D7Xbj+uuvx3XXXYef/OQn2RgjUYAMj4TgEmt7J1SpM88TnivPGZ/VETtkOuIz7Crr7FnddH2FNe1EQpQmTLHPZo19slR8gFreEaULU+yPrRd+Fz0uf1qfFkIZR1kPe40c8QGg2pE8FZ9d0zKzEWadOXNnatRbqERb3an3GdIksO+Sl4bP3o+1h0tmzDygwmwuGzX28lPxRVf8obF+VFHjPBKgGDUOCwwcwPPR73Apofju+cgjj+DVV1/Fww8/jLPOOgsnn3wyPvvsM7S2tuKmm27KxhiJAuTIoBBwjHNYUGZRX9cj1xmfBfZKU/TsZnW1b0yFrac0fCIJknlellLxIxEeB/rEVncJAnum2O/ocCEcoaCGKB1coxR7XzAibTQT2sDUwSYN50AWSA0kWGwP69QRHwAclsyMerVgzbZOfP/ZzRq3YxMyYWozyFqMuuJnEtjLa3XHkOrsk6TjK211B+TXPI+tNXzBiDR2xoCHmQCSYs8wGjipPePebneeR5N7VG2LLl68GJdddhk+/PBDHD58GPfddx9aWlq0HhtRwERb3WW2mz+xSl5gz1zxlRq4SLVvClPkWKu7RnLEJ5LAzPO6Xf6sBNZdLh/8IaHVXaLOE1NqHbCZDRgJhnFQ3AAgiFKAqbv1lVZUiPd4qrPXlg5JsdcyFV8IYIZ9oTEpsi6dOuIDsTX2+VPsV763F6u+6MTqrdp5XUUV+8xT8bUJ7NMr9gDQXJN6XTmgou+71oH9SCAseUqk+3xtZqMU/B8dVWdPin1i5k2uBgD88KUtaT28ig3Fgf3evXuxYMECvPHGG3jrrbdwxx134NJLL8Udd9yBYFC7nSyisGnPsIc9Q2p5lyYVn036Smvv1O6kd1IPeyINdRVWGA0cwhE+KyYtrL6+ucae0ODHaOCk1j/byUCPKCFig8BS71mcLZgD93iNWt0B8Q7kowOkaA97/SmPjgJwxW8XgxeWtq4F0Rr7DFLx7ZkFxIFQRJoLZQf2aRR7KRVfwYZFZcwGRUSDjXyp44BJXseBZHX2bJOCFPt47vnqLJzQUI6uYT+ufWKTlH1SCigO7GfPno0pU6bgs88+w6JFi3D33XfjnXfewV//+lecdtpp2RgjUYBk6ojPmCCZ56VxxfcrN88DIJUJKJ1wmSPweA3rC4niwmjgJPfVbKTjH+gV6+sTGOcxWsZTnT1ResQGgSyw76bAXlNYz2wtFXuT0SDVP492xtezYs8Eh3yl4o8EwlK99m4NU4/7ZLq2p0JKxfep+2z293oQivCosJpkGzlOTFPi2Z+BYh/htel+IG2aOOR1HEjmjM9c8atIsY+jym7Bn759OiZUlWFfrwffeqpVKuktdhQH9r/97W/xwgsvoKqqSnrsjDPOwKeffopTTz1Vy7EVBCtXrkRLSwvmzZuX76EUFJn2sGewFONhXyhlGxH2gyxXaJ7nsKibcFlGAgX2RCpY7Vs2Wt6x9PpJCVrdMaIt7yiwJ0qHYVLss07UFV/bOZCppAPexIq93nrYA9F1Rr5c8WMzHnd3aZe9FdvuTi2xKexqDC53sjT8xgrZLfeYM/7hJILRgFRiIP+7ZjMbYTEJIZMW6fj9CssckvWyH1RhBFgqNDpt+NMNp6HGYcHnR4bwL09vhj9UXAaXiVAc2C9fvhwAEAgEsHPnToRC4gRbUYEnnnhC29EVACtWrEBbWxtaW1vzPZSCgk0kiWp/leCwmqQbUqqWd26Vir3aGnutzo8oblidfTZa3rH0w0TGeQxqeUeUGjzPJ1TsKbDXDpcvKJkRatnuDogqi6MN9PSs2Ee77+Q/sO8Y8mnWa12TVHwxsA9HeFUeBLsVGucB6c3z1NTYA9rW2Sv1L2DdKTpGla0OUI19So6tK8eT18+D3WLEB3t6cdtLn2lSSlHIKA7sR0ZGcMMNN8But+PEE0/EoUOHAAA333wz7r//fs0HSBQmRzSqsQdi0/HTB/ZKa+yjrvjyFftQOCLV2FNgT6Qim4o9c8RP1OqOMb2xQnr/RC2kCKLY8IciCIaFhVklKfZZgd3PKm0mzXvKs4380e7eajvfFAKSYp+nVPzR5mC7Naiz53lek1R8m9kAs1FQ2tUY6O3sVGacB0QzSYd9oYRBuBpXfEDjwJ51HJC5adKURLEnV/z0nNxchd8vnwOzkcMbn3fgp69vK+r2qIoD+//8z//EZ599hvfeew82W3Qn9/zzz8cLL7yg6eCIwsTlC0o3tkxr7IFo8JzKuZLV2FcodsVXvpPeJbqcm40c6ivIFZ9IDgvstVbsIxE+2sM+RY19hc2MY8S0Q0rHJ0oBpkZynBBQ1Vew7hTZaTtZihwdzF4pWg1T7EdtREbLK/QXoNjzbJ43WhTZ0515Or43EIYvKHQuyCQVn+O4jAJipY74gCAAsc2IROtKNeZ5gDYO/wzFqfhVSWrsSbGXxZnH1+FXV8wGxwF/3HAQj7yzJ99DyhqKA/tXX30Vjz76KL70pS/F1bu0tLRg7969mg6OKExY2leV3ay4/Vwi5Djjq3fFZzX28idctqhpcpbBYJBX00WUJk2SYp+6q4NSOodTt7qLZUaTsOBpO0qBPVH8sLmg3GqCwcCRYp8FOqT6eu27wrBU/P4x5nk67mPPzPPyXGNvEbunaOGMz9ZBDosRdoXeRqOpVBnY+4JhHBTT6ZUE9kBUtT/cHz83hyPRTSSlwTAzfhwe0cA8T2kqvvhb7BzySankgVBEKm+gwD49l5w8Hv+zTGjN/uu1u/DsRwfzPKLsoDiw7+npQX19/ZjHPR6PbGMLQt8c6demhz2DBS6pAnuW4qbWFd+jwA0zapxHre6I1DRINfbaBhUHxPr6Y5K0uoslWmdPLe+I4ocF9sxkjXWmyEbLyVIl6oivvWIvpeJ7Rpvn6Vexz7crPluznD61BkBU5c4ElgE2rVFZQJ0IyRlfYWC/p9sNnhe+M7UKswYmiplsoxV7j3iJOC6qwMtFy1R8yZhQZmDfUGkDxwHBMI9esUSCqfUGTp8bYvng+oVTcNO5xwEA/uvVrXjzi448j0h7FAf28+bNw9///nfp3yyYf/zxx7FgwQLtRkYULFoby01I05oEANwxKo0SpP6yQfk76dHzy9w/gChumHle55BP05qtA2Ia/qQUafgMMtAjSgkWHLCFbH2lENj3eQIIhSN5G1cx0SH1sM+CYu9InIrPFHstsgBzDVtnqDGH0wK2dvryNEF026NByzuWAcZaqmaC2oA4Ng1fqXDIetmPXleywL6qzAyjwozMbNTYyzUmNBsNUmko62XPWt05y8yUXaqAWxedgKtOOwY8D/zbC1uwfm9vvoekKYoD+3vvvRc//vGP8a//+q8IhUJ4+OGHsWjRIjz11FP4xS9+kY0xEgVGtNWdNoHvRAXmeUonfbuUIqdAsZcCe1LsidSwGvuRYFiT9DyGHOM8RosY2O/pdiNIgQ1R5Ix2T6+2W2A0cOD5aHorkRkssG/UuNUdkNw8L5qJob/AXuq+k4fAPhCKoEv0l/jytDoA2jjjM8W+pcmZ2QChPiDeqaK+nhFNxR+l2ItDUFpfD+TXFR8Y28uedZagNHxlcByHu78yExec2IhAOILv/mkztrYP5XtYmqE4sD/jjDPw4Ycfwuv14thjj8WaNWvQ0NCADRs2YM6cOdkYI1FgRB3xtZn0J4rKeJ8ngJEEE6M/FJZckNXW2CuZcFltmRbGgERxYzMbJTfaTg0N9OS0umNMrC5Dhc2EQDiCvT2ZKzUEUciM7nduNHBSOivV2WvDUTFwyIZin8w8T9ep+KJiHwhFkOu9VSFbDLCaDJha65CyyDJxxud5HttExf5EDRT7yjKxNt2nbPObncMJKsoBmmuSKfaCsl2jIhhW6xWQCKWp+EC0PPSoqNiztn3kiK8co4HDQ9+YjflTa+D2h/D/1uzM95A0Q9XW6KxZs/DHP/5R67EQOkHrVPzKMhPKrSa4/SG0D47guPr4fqXumMlAsWIvTriJNgySEa2xp8CeSE9jpQ2D3iA6hkY0qUcEgIOiYj9pXPrAnuM4zGisxKYD/Wg7OozpjZkvxAiiUEnU77yuwopul58Cew3geV5K9c1GjX1V0sBev+Z5seZy/hwH9iyDckJVGTiOw/EN5egc9mF3lwtzJlWres2uYT/6PQEYDZwmc5paN3nW6m6aCsW+mSn2A17wPC+l8rNUfDWKvVaB/UggLBk6K+k4MFqxJ0f8zLCZjXj82rn4f2/txO1LpuV7OJohS7EfHh6W/T+i+NGyhz0gBCYTq5O3vPOITrNlZqPimii7VPsmb6eY53nNNy6I4kbrlnexre6myAjsgagzfjbr7JkTL0Hkk2gAGFWpWO0ptbzLnKGRIEZET5psuOJXO6Kp+MyXJBzhpaw6PQb2FlO0V3uus/GPjMowPL5emAt2Z1Bn39YhpCUfW+eAzWzMcITqUtiZ0AMAJzSUpzl6LEyY8QbCkrINAG7xP9Uo9tIGRYZlDn2i+Z3FaFAkVkm97Mco9hTYq6XCZsZPL52py0yhZMj6RlVVVck2rgiH82MeQuQGbyAkpRBpmao+oaoMOzpdCZ3xXX7RVEfFhK+0Dc3QSFDaSSXFnpBDtOWdNkFFh9jqzmzkZHdmyKYzPs/zuO/NHXhm40E8ft1cnHFsrebvQRByGU6i2AOUiq8FLGiocVg0CepGw9TFUISHyx9Cpc0cl5Wn1wW2w2rCoDeYc8W+fVRpJAuCM3HG39bO6uu1yf5S44q/Wxx/fYVVVeBqMxvRUGlF17Afh/u9Ui07S8Wvcij/nmlVYx/bw16JKSBbkx4dpdhTKj4Ri6xI6d1335X++8CBA/jP//xPXH/99ZIL/oYNG/DHP/4R9957b3ZGSRQMbBKpsJkUtwpJxYQUBnpMsVfjlsva3cltQ8OyEWrLs7OoIYqPaMs7bQL7g2J9fXN1+lZ3DOZcvL1jOC7tMFMiER4/eW0rntl4CADwyiftFNgTeWU4gWJPgb12dA6Lre6yoNYDQsBlMxvgC0Yw6Ami0maWrqnVZIDFpNj6qSBwWITA3pdjbWt0huHxYtp6JjX2knGeBvX1gLqAeFcGxnmMidV2IbAf8OLk5ioAUfO8jBT7DAN7NcZ5QIyIwFzxRcW+mgJ7IgZZkdLZZ58t/ffPfvYz/PrXv8ZVV10lPXbJJZdg1qxZeOyxx3DddddpP8o8snLlSqxcuZIyEUS0TsNnsEkpUcs7N1PsVQT2zDzPGwjLCniOUho+oRBmVqSVYr9fgSM+44SGChg4YcHQ7fJLmw2ZEInw+NErX+CF1sPSYxv29WX8ugSRCYlq7OsrhO97NwX2GcMU+2wF9oCg2ncM+TDgDeCYcXZdG+cxWNlfIJzbtmNSjb0ojjCPos5hwRm/UsVnygL7E8dn7ogPqEth38WM8zII7Jury7D54EDcutKdQY197AZFJhvofW7ROE9BfT0QVey7XT6EwhHJp4JS8YlYFG+NbtiwAXPnzh3z+Ny5c7Fp0yZNBlVIrFixAm1tbWhtbc33UAqCI1kKfNlGQaJUfLeo2DusyhV0u/icUIRHQIZdLXt/SsMn5MJq7Ds1CuwPiIr9ZJn19YCggk2tExZ0bRrU2YcjPO74y+d4ofUwDBzw86/MhMnA4cjAyJj2QQSRSxKZrJFirx3MmKspC63uGCwdv18MTFg7Wz22umOwlncyq/40g61Z2BrKWWbOyBl/2BeUPF40S8XPSLFXXl/PYM74sXOWJ6jeFZ8F9sEwL/lQqKFfrLFX4ogPALXlVpgMHCI80OXyxyj2FNgTURQH9s3Nzfjf//3fMY///ve/R3NzsyaDIgqXaA97bSf9VKn4rP6u3Kp859kek04vxxmfFHtCKVqb5x0QF1WTa5VlxUTr7DML7EPhCG57aQte3nwERgOHB6+cjeXzJ+GkiYJ6Q6o9kU+kfudlCVLx3RTYZ0rUET+Lir1koCcE9np2xGewlne5rLEPR6IdDGLXLMeLwfBuFXX2O0SflvFOmypVOxEZpeJn4Mov9bKPWVdm4opvt0QNnDOps4+m4lsVPc9o4KRsvI7BEUmxp1R8IhbFgf2DDz6I3/72t5g5cya+853v4Dvf+Q5mzpyJ3/72t3jwwQezMUaigNC6hz2DTUpdLh8CofiZ0eNngb1yxd5kjNbsyellT4o9oZSmSuG7MuANwpfBLj5DjWIPRNWVTAz0guEIbnlxC17dchQmA4fffOMUXDp7AgBgwbHjAAAb91JgT+QPKbCPVezLSbHXimgP++zNgVLLO7HguThS8XOv2HcN+xCK8DDFBHxANH19lwrFfttRwRFfq/p6ILoJ5wtG4A+l/4CGvEF0DQu/5ePrM1Dsq1kv+xjFXgzslda3A0IHp2idvTzfpkT0q0zFB2J62Q/5yBWfSIjiwH7p0qXYvXs3LrnkEvT396Ovrw+XXnopdu3ahaVLl2ZjjEQBMdqBVStqyy2wmgzg+WgqIMPFAnuVu/lsJ93rT38jZuenpeM/UdxUlplgMwu30kxV+0iEx0ExbXCKghp7INryrk1cmCklEIrg5uc/xRufd8Bs5LDym6fiopOapL8vmCqY5m3Y1ye1qSKIXJOo3R1T7L2BsJTWTaiDeYVkt8a++BR7JjzkMrBnQkSj0xbXCpgFw7u7lW/yth3V1hEfACqsJrBydDkB8Xu7ugEAzTVlGW32sFT8IwMjiER4BEIR+EQPBLUqtxbO+EyxV5qKD8T0sh8cIVd8IiGq7qITJ07EPffco/VYCB2QLfM8juMwoboM+3o8aB8YwaQYtTKq2Ku7edktJgx4gzIV+7FpbQSRCo7j0OQsw/5eDzqGfHHfXaV0DAsZK2Yjp3hhzRZi+3s98AXDiro6+ENh/OC5T7G2rQsWowG/u+ZUnDejIe6YOZOqYTZy6Bjy4WCfV5G5H0FoAc/zCc3zHFYTHBYjPIEwelx+VUarhPD5RgP77NfYM8VxWCq30+91y0eNfTKhJRNn/KgjvjbGeQBgMHCosJow7AthaCQobcQlgud5PP7PfQCAK+ZkVt7b6LTBwAmb1r1uP4Ih4Xtm4KDKVBBQ5xcwGrWu+EC0RGZ3txuhiLDBTjX2RCyq7qKDg4PYtGkTuru7EYnEp01fe+21mgyMKDx8wTB6xRpGrRV7QAim9/V4JIM+RrTGXl37ObvMlnex50eBPaGEhkor9vd6MlbsWRp+c438VneMugorxjks6PMEsLPTJbX3SYcvGMb3n/0E7+zohsVkwGPL5+DL0+rHHFdmMeKU5mpsOtCPDfv6KLAncs5IMCwtZkcreXUVVnj6vOhx+RVnuxAC/Z6AVArX4FRW/6uE0eZ5xZCKH62xz50rvuSIXxUvtLAa+85hH4ZGgrJbEwdCEam2/UQNU/EBwGk3Y9gXSuuMv3FfP7a2D8NmNuCa+ZMyek+z0YAmZxnaB0dweMALqzilVtnNMBjUXSctFHvJPE9FKj5bm7LMCqvJILV1JghARWD/+uuv45vf/CY8Hg8qKiri2j1wHEeBfRHD0r4cFqOmPewZE6ujaVOxuAOZ7eaznXRvmq10plTYLUZKbSIUIaXHZeiMv18M7KeoUP05jkPL+Er8c3cvtncMywrsfcEwbvzTx/jn7l7YzAb84dp5+NLxyfvUzz92nBDY7+3DVacdo3iMBJEJLAA0cNFAilFfYcMBMbAn1MHuX7XlVlhN2QsWitE8Lx819lIP+1FCS6VNcMbvHPZhT7cbcyZVy3q9Pd1uBMM8KmwmzcUbQSEfSRsQ/0FU678+Z6Im5n0Tq8XAvn8E4+zCNcpE4dYkFZ/V2Cs0zwOia4093UI2Bqn1xGgU19jfdttt+Pa3vw2Xy4XBwUEMDAxI/+vv78/GGIkCITYNX23/zlRMTOKMzxR7h9rAXkxJ9qRR7Nn7jq8qy8r5EcULMy7KtOXdQbGHvdp0fuaML6fl3Z5uF65+fCP+ubsXdosRT15/WsqgHgAWTBUM9KjOnsgHsfX1o+/RLL2326VNd4pS5KhkHpu9+noglXmefgN71o5XRsWfZqQyM1bjjC8Z5zVVar4GiprOJQ+I93S78faObnAccMOXpmryvtE6e68mLvLMtDPVeaTCFwzDK35JalQo9qxEj7VvJhGKGI3iwL69vR0333wz7HZtaqzb29txzTXXYNy4cbDb7Zg9ezY2b94s/Z3nedx1110YP348ysrK8OUvfxnbtm2Lew2/34+bbroJtbW1cDgcuOSSS3DkyJG4YwYGBrB8+XI4nU44nU4sX74cg4ODmpxDqZBtYzmWYtQ+GN8nm9XYq5302YSbrt0dtboj1NJYKQQVmQb2+3uZcZ66+ysz0EvV8s4XDOP/vbUTFz78T3xyaBDlVhP++O3TJNf7VJxyTBUsJgN6XH7s7fGoGiNBqGU4RQBIvewzJxfGeUBUZRyt2Kutey4EJMU+h+3upB72CdYsapzxo/X12qbhA/IC+yc+2A8AOH9Gg2blNMwZ/3D/iOTpkE/FntXXm42C74BSRndsIsWeGI3iwH7JkiX4+OOPNXnzgYEBLFy4EGazGW+++Sba2trwq1/9ClVVVdIxv/zlL/HrX/8ajz76KFpbW9HY2IhFixbB5YruQt5yyy145ZVX8MILL+CDDz6A2+3GsmXLEA5HA7mrr74aW7ZswerVq7F69Wps2bIFy5cv1+Q8SoVs9bBnsNcdk4rvz1CxFyfcdOZ5R6jVHaGSRjE9rjPTGntRsVdbv84U+x0droSK+j929WDJQ//Ao+/uQTDM4/wZ9Vh9y5mYN7lG1uvbzEbMOUZI66R+9kSuSVWLTYF95uTCOA+IKqYs0CoGxZ6VCvpypNjzPJ9SbDmhQbkzPqvbPlFD4zwG27RJFhD3uf346yeCIHfjmdqo9UBsL3uv9H2rcajfQJKzQZEK1uquxmFRlRVRbTfDaoqGbtUZnAtRnCi+i1500UX493//d7S1tWHWrFkwm+O/VJdccons17r//vvR3NyMJ598Unps8uTJ0n/zPI+HHnoIP/7xj3HZZZcBAP74xz+ioaEBzz33HL73ve9haGgITzzxBJ5++mmcf/75AIBnnnkGzc3NWLduHZYsWYLt27dj9erV2LhxI04//XQAwOOPP44FCxZg586dmDZtmtKPoSTJVg97BpucOod8CEd4qX2L259ZjT1T7NO1u8tWKz+i+Gl0Zp6KH47wONQnbJ4p7WHPOLauHBajAS5/CEcGRqQ0xG6XDz9/Yzte/+yoMN5KG+665EQsObFB8eJiwbHjsGFfHzbu7cPyDM2NCEIJqWqxo6n4FNirhbWazbpiL9ZOjwTD8AXDRWGex0x6A+HclPH1ugPwhyLguMQbMcfVK3PG53k+qthr2OqO4bSnDuyf3ngQ/lAEJ090Yt5keZ4AcohteXd8vTCvVpXlT7HvZcZ5KurrAcFLZ3xVmeTH48zgXIjiRHGkdOONNwIAfvazn435G8dxcSp5Ol577TUsWbIEl19+Od5//31MmDAB3//+96X32L9/Pzo7O7F48WLpOVarFWeffTbWr1+P733ve9i8eTOCwWDcMePHj8fMmTOxfv16LFmyBBs2bIDT6ZSCegCYP38+nE4n1q9fnzCw9/v98PujC4ThYeGGFwwGEQyqN81QC3vPfLw3gyn2jRWWrIyj2maEycAhFOHR3u+WFhesxt5qVHf+VqO4QeBLfe3aB4QbZUO5WdH7FMK1IRKTq2tTaxcWdT1uP3z+QFxPYbm0D44gEBZa3dU5TKrHfFy9A20dLnxxeAD1DhOe//gIfrV2N1y+EAwccO38Y/Bv5x2HcqsJoZDynt/zJglqzoZ9vQgEAqprMel3U7gU6rUZELuWlFuMY8ZWUyb8BruHfQU3bi3J5rVpF+f4eoVzoFJsBl6a67uHvNKGTZmp8L5zcmFNe/zh3JzDwV5Bia+vsILjwwgG49feU2rE8rBhH/qGvVKbtmQcHvDC5QvBbOQwqdqq+TmUWwSVedAbGPPavmAYf9pwAABw/YJjVM1LyWisEM776OAIesSMukqbQfX5OVKchxx6xM2zarv631ij2IUHAJy2sfdCPVKoc04hIfezURzYj25vlwn79u3D7373O9x666340Y9+hE2bNuHmm2+G1WrFtddei87OTgBAQ0N8P+WGhgYcPHgQANDZ2QmLxYLq6uoxx7Dnd3Z2or5+bPum+vp66ZjR3HvvvfjpT3865vE1a9Zo5i+ghrVr1+btvfd2GAFwOND2CVYdys57OM1G9Pk5vPzmOzi2EuB5wOUT3rf1w39gt4pNzqOHDAAMaNu9F6tCu5Met/uo8D6HdmzBqqNbFL9PPq8NkZpsX5sIDxhgRDgCvPTam3Cq2ETfOcgBMKLaHMFbq99UPZbykPB9/8OaT3D/6xwOuoXAu9nB48qpYTRjH/7x9j7Vrx+KABaDEf2eIJ74y5sYn+HtkH43hUuhXZvWduE3MtzXhVWrVsX97YgHAExo7xse87diJBvXZl8nm+M/xaojn2r++rHYjEa4IxzeWPMOBtzC+37y0Yc48nlW3zZrHHABgAn+SG5+N5/2Cr8FO+9L+n2vshgxGODw9GtrMaUi9et91ie8XoMtgnVrVms+3kOdwuvv3H8Yq1YdjPvb+i4O/R4jqi08+MPafvciPGDkjAhFgM37ugBwOLpvF1a5d6p6vV1Dwnm09wyous98eFR4vm+oR/V9KuwS5ngA6Di4B6tWJV/X6o1Cm3MKCa/Xm/4gqOxjrxWRSARz587FPffcAwA45ZRTsG3bNvzud7+La5s3WhHieT6tSjT6mETHp3qdO++8E7feeqv07+HhYTQ3N2Px4sWorNQ+TSkdwWAQa9euxaJFi8aUP+QCfyiCWzauAwBccdH5GKdBG5JEPN/Zir79Azhm+mwsnT0e/mAY4Y1vAwAuvnCRqlS9w//YjzXtu1HXNBFLl85MeEwkwuP2TesA8PjaBecoqrPP97UhkpPLa3N/2/voHPajZe5CnDxReY3i4KbDwPbtOHFSHZYuPVX1OLrWH8SmN3fikz5h4ndYjbjt/ONx9WnNqjIJEvHX3s34cG8fLBNnYul8dW3v6HdTuBTqtdmxbjdwaD9mHDsJS5fOiPtbj8uPBz5/H+4QhyUXXKjZd73QyNa1iZ0DL1M4B6rhN3s+hLvHgxNPPR2+LwTD5GVLzkNtuboU5Xyzu8uNB7euhz+MnPxu2j/YD+zejZlTmrB06UkJj/lzz2Z8sKcPdceehKVzJ6Z8vV1v7wF27cPp0yYkXSdlQvjzDry8/wvYneOwdOk86fFIhMfDj6wH4MG/nDsNFy+crPl7P7TrAxzs96J7RLgnfGnebJx/YpOq15p0dBgr2zaCN9mwdOnZip+/bc0u4OABzDx+MpYuna5qDDvX7cGm94XN+QWnnoSlp05Q9TqFRKHOOYUEyxxPh+zA/je/+Y2s426++Wa5L4mmpia0tLTEPTZjxgz85S9/AQA0NjYCEBT3pqboj7C7u1tS8RsbGxEIBDAwMBCn2nd3d+OMM86Qjunq6hrz/j09PWOyARhWqxVW69gJxmw25/VLl6/3bx/ygOcBm9mABmd22t0BwMQaB7B/AJ2uAMxmM4ZiLGadjjJVi7UKsQbJH+KTfnZdwz4Ew0Jd/4SacpiMin0l8/7dIJKTi2vT6CxD57AfvZ6Qqvc6PCCkCU6tq8horKdMihrhXTSrCT+5uEVqx6cVZxxXiw/39mHTgQHccOaxGb0W/W4Kl0K7Nt6AMB847dYx42qoMsHACQrdcCCC+ors1onnG62vTbc4Bxo4YHxNOcwq5kAl1Dgs2NvjQacrAObzWV1eBrPYnlZvOMtZG7Lc/G46hwUTtuYaR9L3mtZYiQ/29GFv70ja8ewUa/FnTajKythrxM/H5Q/Hvf47O7qwr9eDCqsJV8+fnJX3bq6x42C/F8xOtrayTPX7jKsQNryGfEFVrzHgFcoM6jMYw8SaqAdPbYX61ylECm3OKSTkfi6yA/sHH3ww7TEcxykK7BcuXIidO+PTYXbt2oVJkwRDpilTpqCxsRFr167FKaecAgAIBAJ4//33cf/99wMA5syZA7PZjLVr1+KKK64AAHR0dGDr1q345S9/CQBYsGABhoaGsGnTJpx22mkAgI8++ghDQ0NS8E+kJts97BlSL3vRoZ61urNbjKoVGGZqk6qPPXu/xkqbqqCeIBqlXvYjaY5MjOSIPy6z3Pa5k6rxi6/OxKQaR9q+9GqZL/az/2h/PyIRHoYiVUeJwiKVe7rRwKHGYUWv248el7/oA3utYY74dRXWrAf1QLRN16F+Ib3UYjTAptOgHgAc4jojyHMIhSPIdmwip/2wEmf8bUdZqzvtHfEBSDX+o03nHv+H0OLuG6c1Z808sblmVIu4DDJO2Xn4ghH4Q2FYTcq+s/2eqCu+Wpqqovc2csUnRiM7sN+/f7/mb/7DH/4QZ5xxBu655x5cccUV2LRpEx577DE89thjAISNgltuuQX33HMPjj/+eBx//PG45557YLfbcfXVVwMAnE4nbrjhBtx2220YN24campqcPvtt2PWrFmSS/6MGTNwwQUX4MYbb8Tvf/97AMB3v/tdLFu2jBzxZcJ6y2e7xzt7fbaRwBZyah3xgWibPK8/ubEjmyTHV9FikFCH5Iw/rM6V+wBzxM+wfy/Hcfjm6dl1qz9pohN2ixGD3iC2dw5npT0SQYxmOI17el1FNLAnlBF1xM9NV5hoYC+8b7mOW90B0ba6AOANhFGW5aUEWyOlWpMdL/WyTx3Y93sC0sbOjKY0xfgqSeQmv7V9CBv29cFo4HD9wilZeV9AEKRiqU5jJJiKCqsJHCf4Pw2NBFFfoSyw79MgsB8f8xslV3xiNHmVJufNm4dXXnkFzz//PGbOnImf//zneOihh/DNb35TOuaOO+7ALbfcgu9///uYO3cu2tvbsWbNGlRURG8+Dz74IL7yla/giiuuwMKFC2G32/H666/DaIz+4J599lnMmjULixcvxuLFi3HSSSfh6aefzun56plst7pjsN1nFmh7Mmx1BwBl4k66N5hcsT86mH6SJIhURFveKVfstWh1l0vMRgPmTRZS/jfspX72RG4YTtHuDhAcwgFqeaeGo4NCYJerze0qUWlkir2ee9gDgMVkgFnswOMJZLeZPc/zUpbh6KA1luPqBcW+a9ifsj0b618/aZw9a6o5C+zd/hAiESEp/g//FOrEL5rVlNW1V+y61QA+o++awcCh0qa+l32f1O5OG8U+kw0CojjJ+5102bJlWLZsWdK/cxyHu+66C3fddVfSY2w2Gx555BE88sgjSY+pqanBM888k8lQS5r2gfSTiBZMrBJev31wBDzPR3vYZ3AjdlhkKPaDTLGnwJ5QR5Ok2CvvZX9UbHVnMRp08x1ccOw4vL+rBxv39eE7Z07N93CIEiBVKj4Q7WVPir1y8qXYHy6SwB4Qyv6GRkLwZjmwHx4JSWujVAFxpc2MJqcNHUM+7Ol2YU6M/0osbR1DALLTvz52LADrdBSCNxjCG593AABuzPL8wXrZA4DDnNhMWwmVZSYMjQQxNKK8LV+/W1Dsx2VgEllpM+OW84+HPxShwJ4Yg/7vpEROOCKjnksLGp02GDjBhb/H7ZcmL4dF/VdVVo19js6PKF4apBp75YH9QVGtb65RZxCZDxbE1NmHI7xuxk3oF9bvPFlPbgrs1XNUvG+xDcpsU20XriGrOa6w6r9W2G4xiYG9dn3YE3F4QJgvxjksUkZiMo5vqEDHkA+7utzJA3tRsT9xfPYCe4vJgDKzESPBMIZGgnj2o4MIRXicPqUGs1R0kVFCc4wg5dAg6nGWmXEYI4oVe18wLGVzZBqQ33L+CRk9nyheyCWMkMURcSLJdiq+xWSQAqT2gRFNFHsW2MtR7CkVn1BLrGLPM5tnmewXjfOmZFhfn0tOHF+JCqsJLl8I244O5Xs4RAnAFPvKNKn4PW4K7JXSkeOstSp7fGBTDIo9M9DzpFhraEE0DT/9tTpeTMffLbreJyJqnJfdVs4sHf/o0Aie23QIQPbVegCoLbfAZhbCnXIN9o8S+QXIgW1imY1c0nsYQWQKBfZEWoLhiJRenO3AHogG1+2DI5rU2EvmecFw0oCLAnsiU9iGlC8YwbDCFL0DvUJgP0kH9fUMk9GA06ZQnT2RG2JLs1KZ5wFAj0oDy1KGZRo15kixH61YZqu2O5fYremzA7VASYZhOmd8XzCMvT1C0J9tE9TKMmEt9od/7oPLF8LUOgfOnV6f1fcEhNR7VkbqMCnbdE+E2sC+zx01zstmdymitFEV2IfDYbz88sv4+c9/jrvvvhsvv/wyQqHs3siI/NE55EOEF9T0Wof6uiC5sM2DIwMjcGvgis8U+3CEhz8UGfP3YV9QUoL0Ut9MFB42sxFVYnppx7AyA72DrNWdjhR7QKizB4CN+yiwJ7KLNxBGWDTdSlpjX06KvRrCER5dYvnC+JzV2McH8sWh2IsiQpZr7OU44jPSOePv6HQhwgtp/SzjJVuwgHjd9m4AwA1fmpKzVqlsXalFdzjVgb1onFeTg3U0UboovpNu3boVl156KTo7O6VWcbt27UJdXR1ee+01zJo1S/NBEvmF1XNNrCrLyU041hmf9dN1ZBTYx7ehGd0rlzniV9nNGb0PQTRW2jDoDaJzyIfpjfLTGveLiv0UHSn2QLSffeuBAYTCEZhy0P+aKE2YI77RwKEsSb/zejFrhmrsldHt8iEc4WEycFLWQ7YZnYpfDKnJLBWfCQXZgrUflmNmfPwoZ3znKH+Ktpg0/GyryLHvXeOw4GunTszq+8UytbYc7+3sQZUlc8W+MsNU/Ewc8QkiHYpXYd/5zndw4okn4siRI/jkk0/wySef4PDhwzjppJPw3e9+NxtjzCsrV65ES0sL5s2bl++h5I1cG8tNiHHGd/tTtzeSg9HAwWoSvuqJTG2o1R2hFdGWd/IN9MIRHofFXs6TxmW364TWtDRVwllmhtsfwhftVGdPZI9YR/xkAQgLSt3+7BuYFROs1V1DpS1nJphVZaMVe/2n4o8rFwI2lnKdLZSUDlaIzvgAsCdBOr7kiJ/l+nog6owPANfMnzRGZMkm/3L2VNy+6HgsbNAgsFfZ7i42FZ8gsoXiwP6zzz7Dvffei+rqaumx6upq/OIXv8CWLVu0HFtBsGLFCrS1taG1tTXfQ8kbuephz4im4nslExpHGufXdEh19glS5NjGBaXhE5mipuWdHlvdMQwGDqezOntKxyeyiCtND3tAmCeYmk+qvXyire5yU18PCB4dsdeyGFLxc1UKolRsiabjjzXQk4zzstjqjsGUbovJgGsXTMr6+8VSX2nD986aklfzvD6m2JdTYE9kD8WB/bRp09DV1TXm8e7ubhx33HGaDIooLKIOrLlRE2NT8V2SK35md2Op5Z1/rIpzhBR7QiPUtLw7INbXHzPOrsuWcazOngz0iGwyLDniJ58LOI6jlncq6BjMrXEeI1a5LAbFPhffPY8/hAGvEFDKDexPENPxR9fZhyM8dnQIj2XbOA8Ajq0TSs2umDsRtRn0cc836l3xhe8FpeIT2UTxFuk999yDm2++GXfddRfmz58PANi4cSN+9rOf4f7778fw8LB0bGVl9ncAiezDWt3lKvBl7+MJhNEuvncm5nlANLAfSaDYszRECuyJTFGj2DNH/Mk6S8NnsMD+4wMDCIQisJiozp7QnthU/FTUV1hxqN9Lgb0COsSNyFxnDFXZLTjYJ8zxxaDYM/O57iwq9kxoqbSZUm5yxXK86Iy/pztesd/f68FIMAyb2ZCTVqtXzGvGpHEOyZtFr2Ta7o7M84hsovhOumzZMgDAFVdcIdW5sRZiF198sfRvjuMQDmfXGZTIDblOxbeZjagtt6LX7ZdMxTIP7IXnexKm4osbFzk6P6J4UafYC9+/yTozzmOcUF+BGocF/Z4APj8yiLmTa/I9JKIIiabipw5mmGraTYG9bPKRig/EO+OXF0FgXyumWPe4sldjH03Dl78RnMwZv61DEOKmN1bmJFvMajLirBPqsv4+2YYF9kpr7Hupxp7IAYrvpO+++242xkEUKKFwRApSchn4TqguQ6/bD7G7UcaTvkPsL5vYPI8Ue0IbmsRWUaoUe521umMYDBzmT63Bqi86sWFvHwX2RFaQq9hTKr5yjopzfFOOWt0xqmOc8YvBFZ8p9r1uvyRwaY2aDMpkzvjMEf/EHBjnFROZKva1VGNPZBHFd9Kzzz47G+MgCpQul///t3fn8VGV1//AP3fWJJNksm8Q9jWAIhDZtG4ISqkLSlUs6k/FDW2t2kVbrViXWvtVW0FbdwSUuuFSEAF3RCCiIBCUfc2+77M+vz9m7k0CWSaZO3NvJp/369VXJTOZeSZPksm55zznwO0VMBslpMWF72p+34RobD9apfw71hpc87xoc9vN85xuL4prtSlDpMiT4c/YVzW40OQ6ebTiiRxuj9K8qKdm7AFg8qBkX2B/oBx3nDdU6+VQBJKzY52VH6cxsO+ywiq5gWx4M/YJLTL2kXDGXj437vIIVDW4kBiCzOyxqq5XUMZFmZFlj0JBdRP2FtcqF193FYSvI34kkZsA1js9XRrz2lyKz8CeQieow5CVlZXIy8vDsWPH1FoPBel/PxTgna3q7UfLjvHhbOx14ptWrDW4N305Y39i87zimiYI4evSyquoFKz4aBOizL5fq4GU47+04SCKapqQGmfFuP4JIV5d6Mjn7LceroTDzSNYpL6uZuxLagOvmunNnG6v0sU93Bn7pJiWzfN6fsbeYjLAZvKVGYbqKMjxbh6NHOIvx9/rP2cvhGiRsQ9947xI0rK6RG7q2Zkmlwd1/r8/k3nGnkIo4MD+vvvuQ0ODrwTI5XLhpptuQkpKCiZOnIj+/ftj9uzZaGriG6mWfiyqwW//uw13v7Udz3+5P+jHc3u8eH3zYQDhO18vO7Hs3xZkxl4+Y39ixl7uH9AnITokZXPUu0iSFHA5fkFVI575ZB8A4L6ZI5Tv0Z5ocGosUuOscLi9+P5IldbLoQgkn7HvLGOvlOKHeORYpCip9V3cNhulsHfrTvA/n9EgKWMKe7o4/7dnqC4sdWWGfUsndsYvqXWgvN4JgwQM9wf9FBiT0aD0fQq0HF/O1psMEuKje+57PelfwIH9448/jro635W+J554Au+99x7eeustHDt2DO+//z62bNmCJ554ImQLpc4NS4vDdVMGAAAeXf0jHlu9W2ls2FWNTg9uXroV720rgEEC5k0aoN5CA3Dim5YtyKBH7op/YmDf3TdJovakx/sCi84y9o+s3o1Glwe5AxJxydg+4VhayEiSpHQ65tg7CoWAM/axvnJyluIHpth/ATI9PgqGMI/blJvnxUWZIubCerzFn7GvCc33X3Mz465NURkmZ+z9s+zlbP2g1FhEWyLjoko4dfWcfcsy/Ej5Xid9CjiwbxkgvvXWW/jb3/6G2bNnIysrC7NmzcKTTz6JN954IySLpMAYDBL+9PMc3HvhCADAf748gHve+gEuj7dLj1NR78TcFzfhkx9LYDUZ8J95E3DB6IxQLLldLd+0bBZj0H9w2CxtN88r0OhsIUWuQDL2X+8rw6ofCmGQgIUXjY6IN/rJcmB/gIE9qa85sO/kjH283MDMCa+3exe2exM5AJV7E4STXIof6Ni2nsCuZOzVD+ybXB7lglVXmxkP8Y+821viy9jLHfHZOK974rsY2JfzfD2FSZfSoPIfn0ePHsXpp5/e6rbTTz8dhw8fVm9l1G03nzUYybFW/OGdH/DOd8dQ2eDE4rnjAroqe6yyAde8vAUHSuthjzbj5esmYHz/8He5bvmmpcYYnBh/2VS944SMvVKK3zNniJP+dDbyzuXx4i8f7AIAXDN5QMQ0LpLP2W87UhVQ40CirqhRxt11/H7gy4gBHq9ARYNTaWhGbZMD0HA2x5WN65+I6TnpETECTRbvj9tCUTFS6H9PiTYbW40KDMSJnfGVxnmZkfH+E252fzl9oCPvyv1Hg5LZy4lCrEvN81544QX861//gtVqRWVlZavbqqurYbXyDVQvLh/fF8/PG48oswGf/liCq1/chKqGjmer7i6swexnN+JAaT2y7FF459bJmgT1gG9uvVzqZAtyhj3QXIrf6DohY18tz4RlKT6pQ54F3V5g/+rXh7CvpA7JNgt+e/6wcC4tpAYkxyAjPgpOjxdbD1d2/glEXRBoKb7ZaFAywSzH75x8FlyudAinKLMRz18zAb+a1D/szx0qSil+CM7YK6PuErveE0jujA8Ae4tr2TgvSHKVSVdL8dk4j0It4MC+X79+eOGFF/DUU0/BYrHgu+++a3X7Z599huHDh6u+QK0tXrwYOTk5yM3N1XopXXbeyHQsv3Ei4qNM+O5IFeb8+xsU+gPZE32zvxy//Pc3KKl1YHh6HN65bQqGpGnbUEU+9x6nSmDfccaepfikFjljX9hGKX5JTROeXr8HAPCHC0coF68igSRJStae5+xJbc0Z+85/ZjjLPnDFGpbiR6L4EJbid7cjvmyo/5z990eqcKjcd5FgZCYb53VHV8/YsxSfwiXgwP7QoUM4ePCg8r/f/OY3rW6fNGkSnn32WdUXqLUFCxYgPz8feXl5Wi+lW8b3T8Lbt05BRnwU9pbU4bJnN2Kf/4yVbPWOQlz78hbUOtw4fUAS3rx5ctjH3rRFfvNSI2Pf1hl7IYTSPK8vS/FJJRn+rEhxGxn7R1fvRr3Tg7HZCbh8XN9wLy3k5HP2K78/3mmFEFGgvF6hjIoKpKN088g7Bvad0bIUPxLFm30Z+1BcVAq22a9cjv/B9gIAQEZ8FJJ5VKVb5MA+0FL8ijo5Y8/AnkIrqDn2LU2aNAmnnXaaWg9HKhrmz8APSrWhoLoJl//7G3x3xFcqu2TjISx4/Ts4PV5cMCoDr91wOuxdPLsVKnJ5fKwKgb3cX6Blxr683gmH2wtJag7GiIIll+KX1DbB3aJx5eYD5XhvWwEkCXjo4lFh70AdDheMyUDfxGgcr2rEgte/63LjTqK21DvdkPv3BtJojRn7wJX4K4tSNSjFj0ShPGOv9ATqZsZe7oy/47jvfD0b53Vf1zP2vu+HJJ6xpxDrcsT06aefYsOGDSgsLITRaMTAgQNx0UUXYejQoaFYH6mkT0I03r5lCv7fq3nYfrQKV7+wGReMzsDK748DAH41qR8WXjQaRh0FGyMyfG9CWSqMopOz/o2u5sBefpNMi7PCYlLtGhf1cimxVhgNEjxegbI6JzLsUXC3aJh31en9cErfBG0XGSLxUWa8cM0EXPbcRny9rxyPrNqNBy8apfWyqIueXLcX63cZcN50L8w6uM4rn683GyVYA/hdzcA+cKW1LMVXkxzY1zncaHC6lWOAaujuqDvZUH9nfFmkNG7VgpwA62opPs/YU6gFHM2UlJRg4sSJmDZtGh566CE8//zz2LRpE/7xj39g5MiR+P3vfx/KdZIKkmwWvH7jRPxsWCoaXR4lqL9n+jD89WJ9BfUAcOlpvgaAajQYi1Ey9s2l+M2j7rQ/dkCRw2iQlD+S5ZF3yzYdxo9FtUiIMeN30yOvF0lLIzPj8dQVYwEAr248hDe2HNF2QdQlQgi8tukI9tYYsNOf2dNay1F3gTQNk8vKS+sY2HfE5fEqAQdL8dVhNQDRZt+f1mrPsg+2FH9IWuvAnhn77pMrh+TeH51RmucxY08hFnBg/+tf/xpZWVmoqKhAbW0tbr31VowaNQqFhYVYu3YtXn75Zfzzn/8M5VpJBTarCS9eMwFzxvdFrNWExy8bg9vPHarLOdoWkwHTR2Wo0mDM5r9q3uBskbEP8k2SqD3NI+8aUVbnwP+t8zXM+92M4UjsBWfsZozKwN3+C3IPvL8TWw5WaLwiClRNkxv1/t+TxSoHJt0V6Kg7mXLGvo0GltSszH/hw2iQePZXJZIUmh4Pbo9XuVDc3eZ5LTvjA0BOJjvid1eXS/Hr2DyPwiPgwP6jjz7Cww8/jISEBERHR+Pxxx/HG2+8gZqaGpx77rl4+umn8dxzz4VyraQSi8mAJ+aciu1/mY4rcvtpvZywiGnRPE/4D2sqgT1H3ZHKWo68e/yjH1Hb5MboPvG4spf8vAHA7ecOwaxTMuHyCNyybKsyqon0Ta5kAoBinZSy13Y1sPc3BGPGvmNyRjk11hqRPT+0kqYE9updWCqsboLHK2AxGpTv7+6QO+PHWU3dvkBAQHwXAnuH26M0/+QFNAq1gAN7q9XaKqtrMBjg8Xjgdvu+WadMmYJDhw6pvkAKHb2V3odSjP+MvVcADrevoZfSiIYZe1KZnLFfs6sIb209BgB4SIfHXUJJkiQ8cfmpGJUVj4p6J25c8m2rozCkTy1HohbrJOMtl+IH0jgPaJ7JzjP2HVM64rNxnqqUC0sqfv8dV44ORgV1EWaY/5z9yKx4XswJgpKxb+g8sJfL8E0GKeDfYUTdFXBgf8YZZ+CBBx5AfX09XC4X7rvvPgwaNAhJSUkAgNLSUiQmJoZsoUTBiDYblf+Wg4uCagb2FBrylIVNB3wl6HPG98W4fr3v92O0xYgXrpmAlFgrfiyqxV1vboPXK7ReFnWgoKo5mC/STSm+fMa+a6X4tU1uNLVomEqtyRllNs5TVyhK8YPtiC+bOSYTcVYTZp/WR41l9VpyYF/rcHf6niaX4SfaLLyYQiEXcGD/j3/8A9u2bUNCQgJsNhteffXVVqX3u3fvxnXXXReKNRIFzWiQEOVvaCOfs5ffKNk8j9SW2eIcY1yUCX+4cISGq9FWVkI0/jNvPCxGAz7eVYynP9mr9ZKoA61K8XWTsZdL8QPLdsVZTUr3fGbt26eU4rNxnqpS/Q3S1Gyed0ylCsPT+iVix8IZuPL03nMsLBTio30XGYUANh0s7zC4b+6IzzJ8Cr2A53AMGjQIP/zwA77++ms4HA5MmjQJKSkpyu0M6knvbBYTmlxONDg9aHC6UekvoeIZe1KbXIoPAHefPwwpQZyJjATj+yfikUtH43dv/4B/fbIXw9PjMH1kSuefSGFXWK2/jH1tFzP2kiQhNc6KY5WNKKl1IDupe+PBIl0JR92FRGoIztgfr/L1KOnuqDtSl9VkRJLNgop6J+a+sBmZ9ihcODoTM8dkYFy/xFaZ+Qr/DHt2xKdw6NLw7piYGJx//vmYNWtWq6Bedvz4cdUWRqS2GKt/5J3TrWSl4qwmnnki1eVkxSMl1oLTByThV5P6a70cXZgzIRs3njEQAHD3W9uwq6BG4xV1buP+Mvz5vR29qjdAy4x9Sa1DaTaqpZrGrmXsgeZglRn79pXKpfg8Y6+qUHzvcYqP/rx47QRcPDYLNosRhdVNePnrg7j8399gyt8+xYMf7MKWgxXwekWLjvj8OaPQCzhj35GioiI88sgjePHFF9HY2Nj5J/QgixcvxuLFi+Hx8JxeTxdj9n27Nzo9yh+KzNZTKMRHmbHp3vMAACZjl66fRrQ/XjgCe0rq8OWeUtz6+jbcNkTrFXXsn+v3YvPBCkwalIxZp2RpvZywKGjRPM/p9qKywaX5iKbm5nmB/8mSqgRX+jhOoEfNGXuW4qspNRSBvUpn7Ek94/olYly/RDS5PPhyTyk+2lmE9fnFKKppwqsbD+HVjYeQFmdFQozvgiRL8SkcAv6Ls6qqCldffTVSU1ORlZWFf/3rX/B6vXjggQcwaNAgbNq0CS+//HIo16qJBQsWID8/H3l5eVovhYKkZOwdbqVBFK9+U6iYjAYG9ScwGQ145qrTMCjFhsLqJry6x6iLjHB75LORZb0k6+v1ChT5S/El+PalqFr7wLir4+6A0ARXkUY+A85SfHXJ33vl9U64PN6gH8/rFcrfLBxRpz9RZiOmj8rAU1eMxbf3T8OL10zA7HF9EBdlQkmtA3uK6wBwhj2FR8Dvkvfddx++/PJLXHvttVizZg1++9vfYs2aNWhqasJHH32Es846K5TrJAqazeL7dm9wepTzamycRxRe9mgzXrh2AqY/9SX21/rOcfdL0ecfPFUNvsC+IoCRRpGgrM4Bl0fAIAHpUUBho6+BXk5WvKbr6uq4O6A5C81Z9m3zeIXytWEpvroSo80wGSS4vQJldQ5k2oP7O6O0zgGnxwujQUJGPKsr9MxqMmJaTjqm5aTD4fbg631lWL2jCIfL63Hx2N5R9UXaCjiwX7VqFV555RVMmzYNt912G4YMGYJhw4bh6aefDuHyiNQTbfFl7BucnuaMPa9+E4Xd4NRYJMWYUVrnREW9E/102EdPCIEqf0Bf6c/cR7qC6ubxZ4mGRhQ2SijSQWf85uZ5gQf2zNh3rKLeCY9XQJLQ65t7qs1gkJASa0VRTRNKaoIP7OWO+BnxUawC60GsJiPOHZGOc0eka70U6kUC/g1RUFCAnJwcAL4O+VFRUbjxxhtDtjAitdmUwN7NUXdEGpPPHVY16jMbXudww+0fYVTR0DsC+0J/g65MexQS/EUUhT21FD9W/VnikUTu2J4UY4GZwaLq5CoINS4sHav0VRgyEUFEnQn4t7nX64XZ3Hy13Gg0wmazhWRRRKEQY/X9UVjv8LDDLJHGEmJ8kWOVTsvcW66rt2Ts5d+LWfZo2C2+ixrFugjsuzbuDmDGvjPyBY9Unq8PibQ49S4syT+Xffn3ChF1IuB3SSEErrvuOlitvl9WTU1NuOWWW04K7t999111V0ikkhizL2Nf2+RSyksZ2BNpIyHan7HXaTa8ZWBf0UsCezk7n2G3ot6XJNS8FN/jFah1dL0UX86YltU54PWKVnOlCSj1N85L55ntkFBzlj074hNRoAIO7K+99tpW//7Vr36l+mKIQknO2B8sq4fHK2A2SuwGTKSRRH8pfqVeM/aNzcF8pU4vPqitsLq5FL+s3PexYo0D+zp/UA90LWOf7J8Z7fIIVDVqP7JPb+SAk++BoZHqb96oZsaeiQgi6kzA75KvvPJKKNdBFHLyGfu9Jb7RI5n2aGZxiDSS6C/F121g36oU3wUhBCQpsn9fHPc3Fc2yR8PlL8XXOmMvn6+3mAyI8lddBcJiMiAxxozKBhdKax0M7E+gzLBnR/yQUErxa9Q4Y+8vxU+MCfqxiCiysWMK9Rpyxv5opTzqjiWIRFpRmufpNrBvztI7PV7UOz0ariY8WjXP88d7VQ0uNLm0e+3No+4Cz9bLlJF3PGd/kuYZ9nwfDAU5sA923KIQgqX4RBQwBvbUa8hn7IUvEYU+Cbz6TaSV5q74+ixzP/GCQ6Q30HO6vUoQkmm3ItoIRJl9fyJoWY7fnVF3MqWBXp32DQD1hqX4oZXm711QGuTPTmWDC43+C2uZdl6EIaKOMbCnXsNmbV3G2YcZeyLNJEbrO2N/4hGBSG+gV1zTBCF8JexJNgskCUj3Z3O1HHnXnVF3slQVy6EjDUvxQyu1RcZeyNmEbpBH3aXFWbt0FIWIeicG9tRrxFha/2HIsjYi7ST0oOZ5QOQ30CtQRt1FKb0E0v1Bn5YZ+xoVAnuW4rcmhGgO7FmKHxKpsc3NG4P5HccyfCLqCgb2nVi8eDFycnKQm5ur9VIoSDGW1le7s9hhlkgzem+eV31iKX6EB/ZyVj7T3vx7UQ7sizTN2PtL8a1dL8VX65xzpKlpdMPp9gLgHPtQkZs3AsGNvGNHfCLqCgb2nViwYAHy8/ORl5en9VIoSCdl7PlGSaQZOWNf53DD5fFqvJqTyYG81eR7m6yo1+cFCLXIAUTLC57yjHMtO+MrzfOiWYqvFjnQjI8ysbw7hNRo3siO+ETUFQzsqdc48Yw9M/ZE2rFHmyHBd/ZUj+fsqxp9axqYYgMQ+c3z5Bn2LaeFZOiqFL8bzfNimbFvS/P5epbhh5IaF5aOsRSfiLqAgT31GtEtSvFTYi3MVBBpyGiQEO3/EazSYZm7fLFhUKovsK/Q4RrVVFjVVim+P2Ovh1L87oy7i+cZ+7awI354KLPsg/j+kytp+jIRQUQBYGBPvYatRSk+y/CJtOevxtddx3mvVygXG3pLxr65FL85i9vcPE+7wDiocXexvtdS3eiCw+1RdV09WbEyw56BfSilxsuBfRBn7P1d8ZmxJ6JAMLCnXiO6RYaeZfhE2ov1X2vTWwO9WocbXv+EqgHJ/ox9hAf2cvO8lr8bM/wZ++KaJni93R/ZFYyaxu53xY+PNsFi9P2Zw6x9M7k0PJ2l+CEV7Bn76kYXavwXtpiMIKJAMLCnXsNgkJTgnm+SRNqLMcln7PUVNMsd8aPNRqU0PZK74tc73Kj2B9CZ9uZgLyXWN8/e7RUoq9cmMJbn2Md3I7CXJIkj79ogZ5DZET+0gi3F31dSB8D3M2mzdv37n4h6Hwb21KvIDfSYsSfSns1fXa23jL08wz4xxoxE/yIjuSu+3DgvLsrUquTdbDQgxd+Arrhaq8De3xW/G6X4AGfZt4XN88Ij2O+9fSW1AIAhabGqrYmIIhsDe+pV5JF3PK9GpD2bPwmlt4y9fKHBHmNBks3i/5gTQmhTjh5qBf7GeVn2k38vZmg88i6YM/ZAi87kDOwVcqDJM/ahpWTsu/mzs6fYl7Efmhan2pqIKLJpGtg/+OCDkCSp1f8yMjKU26+77rqTbp80aVKrx3A4HLjjjjuQkpICm82Giy66CMeOHWt1n8rKSsybNw92ux12ux3z5s1DVVVVOF4i6czPhqUgJdaK8f0TtV4KUa9n85fi6+38unyhITHGjMQYX2Dv8QrlvGukkTP2mQknZ3Az7FoH9t0/Yw8wY98WOdBkYB9ackVEvdODekfXf3fs9ZfiD01nxp6IAqN5xn7UqFEoLCxU/rdjx45Wt19wwQWtbl+9enWr2++8806sXLkSK1aswIYNG1BXV4dZs2bB42nugDt37lxs27YNa9aswZo1a7Bt2zbMmzcvLK+P9OXhS8Zgy33nKeWlRKQd3Zbi+9eTEGNGlNmIGP+ozEjtjH+86uTGeTKlgZ4GI+/cHi/qnb738u4G9nLwyln2PvUOt/I1ZSl+aMVaTcrvju5cWNpX7CvFH8pSfCIKkObdOEwmU6ss/YmsVmu7t1dXV+Oll17C0qVLMW3aNADAsmXLkJ2djfXr12PGjBnYvXs31qxZg02bNmHixIkAgBdeeAGTJ0/GTz/9hOHDh6v/okjXDAZJ6yUQEfRbii8H9vZoX7Y+McaCBmcjKhqcGACblksLiUJ51J1dXxn7uhZZzmBL8Zmx95GPJMRYjIhlQ7aQS4uz4lB5A0pqHRiQEvjvjtomFwr8F9N4xp6IAqX5b/W9e/ciKysLVqsVEydOxKOPPopBgwYpt3/++edIS0tDQkICzjrrLDzyyCNIS0sDAGzduhUulwvTp09X7p+VlYXRo0dj48aNmDFjBr755hvY7XYlqAeASZMmwW63Y+PGje0G9g6HAw5H8x8CNTU1AACXywWXK/zZJfk5tXhu6hj3Rr+4N/rlcrmUwL6i3qmrPSqv8/1BbY8ywuVyITHGjONVjSitaYTLFXl/ZB+v8s3KTou1tHqPc7lcSPFvUkFVQ9j3qKLOd8HBajJAEh64XF2fRZ8e67sgcKC0TlffY90V7O+0gkpfeXdqrDUivh560tbepMRacKi8AYWV9XD1Dfys/E+F1QCA1FgLbGaJe6UC/j2gX9ybzgX6tdE0sJ84cSJee+01DBs2DMXFxXj44YcxZcoU7Nq1C8nJybjwwgsxZ84c9O/fHwcPHsT999+Pc889F1u3boXVakVRUREsFgsSE1ufl05PT0dRUREAoKioSLkQ0FJaWppyn7Y89thjWLhw4UkfX7t2LWJiYoJ85d23bt06zZ6bOsa90S/ujT7F+N+BSqrqTjpmpaX8fQYABhQe3ofVq/fCXe/795fffIum/ZHXQG/fcSMACUd+3I7VhduUj69btw6HqyQARuwvKA/7Hh2rBwATLJKn289d5/I9xoHSOrzzwWpEa57OUEd3f6d9V+bbT5OrXlc/c5Gk5d6463y/Oz7f8j1wNPDfHZtLfPuUaGziPqmMfw/oF/emfQ0NDQHdT9O3uAsvvFD57zFjxmDy5MkYPHgwlixZgrvuugtXXHGFcvvo0aMxYcIE9O/fH6tWrcLs2bPbfVwhBCSpudy65X+3d58T3XvvvbjrrruUf9fU1CA7OxvTp09HfHx8wK9RLS6XC+vWrcP5558Ps7l7JYkUGtwb/eLe6JfL5cLbq3xv4g0eCRdccKFujsm8u/Q7oKwMk8adgpnj+uCT+h348YdCZA8diZlTB2i9PFUJIfCHbz8B4MUlM85C/6SYVj83wyodeHb3RtR7zZg5c0ZY17b5YAXww7dItdswc+YZ3X6c5/Z/hWOVjcgYNRFTByeruMLwC/Z3WvHGw8DenzC8fwZmzjw1BCvsvdram63iR2wrP4K07CGYOX1owI+14+M9wP5DmDhyAGbOHBGqJfcq/HtAv7g3nZMrxzujq2vXNpsNY8aMwd69e9u8PTMzE/3791duz8jIgNPpRGVlZausfUlJCaZMmaLcp7i4+KTHKi0tRXp6ertrsVqtsFpPbrBmNps1/abT+vmpfdwb/eLe6JNciu8VQJNHgt2qjz2qbvSd7U6OjYLZbEay/5x2dZMn4r6PKuqdaHJ5AQDZybEwm4zKbWazGX2Tfa+3zuGG0yvBFsZz2f5tQFy0Jaiv+2n9EnGsshE7C2px9oj2e/r0JN39nVbu7x+Rbo+OuO9lvWi5Nxn+hpRl9a4ufb0PlPmyc8Mz4rlPKuPfA/rFvWlfoF8Xzbvit+RwOLB7925kZma2eXt5eTmOHj2q3D5+/HiYzeZWpRuFhYXYuXOnEthPnjwZ1dXV2LJli3KfzZs3o7q6WrkPERGFn8mA5o7zOmqgV90od8X3Nc9L8v9/JHbFL/A3zkuJtcLaIqiXxUWZlSZr4W6gJ4+6i+9mR3zZ2OwEAMC2o1VBrqhrHG4PXtpwEMf9X2M9KK2RZ9izI344pPon8JTUdu1nZ28JO+ITUddpGtjfc889+OKLL3Dw4EFs3rwZl19+OWpqanDttdeirq4O99xzD7755hscOnQIn3/+OX7xi18gJSUFl156KQDAbrfjhhtuwN13341PPvkE33//PX71q19hzJgxSpf8kSNH4oILLsD8+fOxadMmbNq0CfPnz8esWbPYEZ+ISGMJ0b6r0HoK7CtbzLEHgESbL7CviMDAvrBaHnXXfqCXHu8LTsI98q62yZey7+6oO9lp/RIA+AJ7IcLXI+GNzUfw1//l4/pX8uDyeMP2vB2Ru+Jzhn14yCMFuzKVocHpxrFK38WgoemBN9wjItI0sD927BiuuuoqDB8+HLNnz4bFYsGmTZvQv39/GI1G7NixAxdffDGGDRuGa6+9FsOGDcM333yDuLjmX3RPPfUULrnkEvzyl7/E1KlTERMTgw8//BBGY3PmYfny5RgzZgymT5+O6dOn45RTTsHSpUu1eMlERNRCgj94rtLJLHuvVygZe7t/bUn+wF5PFx/UImfsM9sYdSeTR94Vhjmwr/HvQ1yQRzRyMuNhNkooq3MqAVM4bDpQAQD4qbgWL284GLbn7Uixv+oinTPsw0K+gFLShcD+QGk9hACSbRbldw8RUSA0PWO/YsWKdm+Ljo7Gxx9/3OljREVF4ZlnnsEzzzzT7n2SkpKwbNmybq2RiIhCJzFGX9nw2iY35KRuQos59oB+1qimgmr/DHv/WeC2yEFg2EvxHepk7KPMRuRkxmP7sWp8f7QK2Umhn2wjhMC3hyuVfz+9fi9mnZqFPh18ncNBydjHM2MfDnJgX1HvhMvjhdnYeT5NLsPn/Hoi6ipdnbEnIqLeRc7Y6yUbLq/DZjHCYvK9RSba5DXqo6pATYVV/lJ8e/sBZ4Y/sC/W6ox9dPDNlJRz9keqgn6sQBypaEBZnQNmo4Rx/RLQ6PLgoQ93heW529Pk8ijVKCzFD4/EGAtM/mkfZXWBZe33FNcBAIamM7Anoq5hYE9ERJpJ1FkpftUJjfOA5uZ5VQ1OeLyRNcdeKcXv4Iy9XIpfFO5SfJXO2APAWOWcfWXHd1TJt4d8zzOmjx2PzT4FJoOEj3cV49MfT57SEy7yOW+LyQC7ChdLqHMGg4QUuYFeTWCB/V45sE/j+Xoi6hoG9kREpBm9Nc+T1yFXEvj+2xfYe0Xzue9I0dw8r/NS/PBn7OXAXo2MvW8k7s6CGjjdoW9kJ5fhTxiQhOEZcbjhjIEAgAfe34VGpyfkz98WuQw/NdYKSZI0WUNvJB97CPSc/T52xCeibmJgT0REmtFb87zqBjlj3xxMWkwGxPlHvlXo5AKEGjxeoZyb76gUX26sp9W4OzUy9gOSY5AQY4bT7cWPRTVBP15nth72Nc4b3993QeHX5w1Flj0KxyobseizvSF//raU+keu8Xx9eDU30Ov856fJ5cGRCt8M+yEsxSeiLmJgT0REmtFbY7rmjH3rbtTyyLtImmVfUtsEj1fAZJCQ2sGZ64wWI7vcYRzbpnTFVyGwlyQJp/ZNABD6efZVDU7lnLQc2NusJvzlolEAgOe/PKBkZcOJo+60kRoX+Mi7A6X18ArAHm1Gaiz3iYi6hoF9JxYvXoycnBzk5uZqvRQiooiTqLPmeXLlQMIJZ5AjcZZ9QVXz6DOjof3S7ORYK4wGCV4BlAbYAEwNcil+vAql+EBzA73vQ9xA77sjvjL8gSk25Xw1AEzPScd5I9Lg8gj8+b2dECK8/RrkM95pcRx1F05dGXm3t0UZPo9LEFFXMbDvxIIFC5Cfn4+8vDytl0JEFHF0V4rvzxInnpCxT9LZBQg1FCqj7joO9IwGSQlOwtlAT+3A/jSlgV6VKo/XHrlx3gR/tl4mSRIevGgUoswGbDpQgfe2HQ/pOk4kl4IzYx9ecjVMIM3z9pWwIz4RdR8DeyIi0kzLcXfhzmC2pa3meUCLUnydXIBQg9wRv6PGebJwN9BzebxodPmazKlRig80Z+wPltWjKoQXaJob5yWedFt2UgzuOHcoAOCRVbuVC0nhwBn22pAvpJQGcMaeHfGJKBgM7ImISDMJ0b6A2eFuDuS0JFcOnDgOTB55F0ln7OVS/MwOGufJ5HP24crY1/mz9QAQq1JgnxBjwcAUG4DQZe2dbi+2+x97fP+kNu8z/8xBGJxqQ1mdE//4+KeQrKMtLMXXRlp84GfslVJ8ZuyJqBsY2BMRkWZirUaYjb6zpHrIhsuZ3BNL8SPxjH2gpfhAi1n2Ac7iDpZchh9tNsJsVO9PFTlrH6rAfmdBNRxuLxJjzBicamvzPhaTAX+9ZDQAYNnmw8qFgFBTxt2xFD+slIx9naPDqiSn24tD5b6O+MzYE1F3MLAnIiLNSJKkdKDXQza8qvHkcXcAkKSU4mu/RrXIGfuORt3J5MA+XKX4NSqOumsp1IH9Vv/5+vH9EztsfjZlcAouPa0PhAD+/N5OeLyhPYbi9nhRXs9SfC3IDRRdHtHhxctD5fXweAXirCakc4+IqBsY2BMRkaYSddRAT764cNK4O52N5VODnLHPDCRjH+ZS/HAE9qHo6fCtf379hAFtl+G3dN/MkYiLMmHH8Wos23RY9bW0VF7vhBC+RojJNgaN4WQxGZTfcR3NspfP1w9JZ0d8IuoeBvZERKQpJWOvcTbc4xWo8ZeAt5+x1/7igxqaXB6U1fm+3oFk7OXmeUVhytjLpfhxKnXEl43MjIfFZEBVg0spe1aLEAJbD7fdEb8tqXFW/H7GcADAPz7+CSUh/NrKlRYpsZYORxtSaMh9DTrqjN9y1B0RUXcwsCciIk0l6SSwr2nRofzEOfZJNt+/IyVjL2feo83Gky5itEU5Y1/dFJbpBcqou2h1A3uLyYBRWfEAgG1HK1V97MPlDSirc8JiNGB0H3tAnzN3Yn+c0teOWocbD6/arep6WmLjPG3Jxx86aqDHjvhEFCwG9kREpKlEf9BcWa9tNly+sBBnNcF0QsM2uRS/utEFt8cb9rWpraBFGX4gZb9yKX6jy6NUNYRSbYhK8YEW5fhHqlR93LxDvjL8MX3tiDIbA/oco0HCI5eMgSQBH2wvwBGVqwhkyqg7Ns7ThDLLvqPA3p+xH8KO+ETUTQzsiYhIU3opxZcb59nbyGDbo82Q49+qMM4eD5XCLjTOA4BoixHx/iA7HA30lIx9CAL70/r5yuTVbqDXlTL8lsb0tWPq4BQAwNvfHVN1TTL5bDcb52mjObBv+2fH5fHiYFk9AJbiE1H3MbAnIiJNNTfP0ziwb2fUHQCYjAbER8mVBT2/HL+gKvBRd7KW5fihJh+LUPuMPQCc5s/Y5xfWoMnlUe1xv5UD+wAa551ozoS+AIB3th6DNwQd8ptH3bEUXwvKGft2MvaHyxvg8gjEWIwBX2wjIjoRA3siItJUc8Ze20y43JW/vTPnSRE0y77AH5xndiGIyPDfNxwN9JTmeVb1M/Z9E6ORbLPA5RHIL6xR5TGrGpzYV+I7Iz2+ixl7AJgxKgNxUSYcr2rExv3lqqyppeYz9szYa0GZZd9O87x9chl+WiwMbG5IRN3EwL4TixcvRk5ODnJzc7VeChFRRNJL87zmwP7kjD3QXFmg9TrV0K2Mvb+MuzgMGftaR+jO2EuSpPo5e7kMf1CqTbkA1BVRZiMuHpsFAHhr61FV1tRSqVyKz8BeE0pgX9d2YK+MumMZPhEFgYF9JxYsWID8/Hzk5eVpvRQiooikNM/TPLD3z7BvpxN7c8Y+As7YV8uBfRcy9v4GeoXhPGOvcld8mRzYf6/SOfu8Q907X9/SnPHZAIA1O4tQrXIfB6V5XjxL8bWgnLFv52dnbwk74hNR8BjYExGRpuQMeZXGAbPcFK+9UvxEnVQWqEFunteVUvx0/xn7cGTsa0I0x142tl8CAPVG3m097OuIP6F/18/Xy07pa8ew9Fg43F58uL1AlXUBgNcrlDFrzNhrQ76gUu/0oN5x8lQJObAfxo74RBQEBvZERKQpOWCudbjh0nCUXGUnpfhyxr6nN8+raXKh1h9cdK0U3988LywZ+9CV4gPAKX0TAABHKxpR3k55dKAcbg+2H6sGAIwf0P2MvSRJ+OUEX9b+ra3qdcevbHDC7W/IlxLLwF4LsVYTYiy+EYgnNtDzeAX2lzJjT0TBY2BPRESaajVKTsMGep2V4ifKpfg9PGMvZ+sTYsyIsQQeOKf7A/twjrsLVWBvjzZjcKoNQPBj73Yer4HT7UWSzYJBKbagHuuS0/rAZJCw/WgV9hTXBvVYMjmQTLJZYDHxzz6tKOfsTwjsj1Y0wOn2IspsQJ9EdsQnou7jb3giItKU0SDBHq39OXv5ooJ85v9ESpO/Hp6xL/Cfr+9KGT7QPO6urM4Jpzu0lRXyuLv4EJXiA8DYbHXm2ctl+OP7J0KSgutonhJrxbkj0gAAb32rThO9Epbh60LzyLvWF8bkMvzBqbEwsiM+EQWBgT0REWkuUQdBc1Wj77nt0e10xVcy9j27eZ7SEd/etUZqSTEWWIy+PxtODE7U5HR74fBfOAhVxh4ATlPO2VcF9ThqNM5raY6/HH/l98dVOZoiN2xj4zxtNTfQa52x3+sfdTeUHfGJKEgM7ImISHMJyig5LUvx/Rn7dufY+9fYwzP2cil+VzriA4DBICFNHnkXwnJ8+Xw94DubHCotR955/WfQu0oIge/8o+4mBHG+vqWzh6ciJdaKsjonPvuxJOjHY8ZeH5TA/oRS/H3+UXdD03m+noiCw8CeiIg0J2fsqzQqxXd7vMq57vbn2GtfVaAGpRS/C43zZMrIuxB2xpf3wWYxwmQM3Z8pIzLiEGU2oNbhxoGyum49xsGyepTXO2ExGTC6j12VdZmNBswe1wcA8Oa3wTfRY0d8fZAvip1Y7bLHn7HnDHsiChYDeyIi0pzWGfuWc8Pj2yn/lrvi1zrcIT9jHkrNpfhdb9Qlj7wrCkNgH6pRdzKT0YAx/mD8+yNV3XqMb/3Z+lP72mE1GdVaGuaM7wsA+OynkpOarXWVXF3BwF5b8hn7lvvp9QrsU2bYM7AnouAwsCciIs0laTwjXr6gEB9lajdLHB9lhkHp3t9zs/Zytr2rpfhAc8Y+HKX4oTxfL1PK8bt5zn6r/3z9+CDm17dlaHocxmYnwOMVeO/740E9llKKzzP2mmqrK/7xqkY0ubywGA3olxSj1dKIKEIwsCciIs0lajwjvtrfOK+9MnzAd8ZcLsfvqSPvvF6hBPaZXWyeB7ScZR9cFrkjNWEN7IPrjJ/n74ivVuO8luZM8GXt3/z2KIToXg8AoLn0mxl7bbV1xl5unDco1RbSYydE1DvwtwgREWlO61L8zhrnyZTO+D30nH15vW9UnSQ1j6/rCvlzikNYil8TplJ8ABjr74z/Y1EtGp2eLn1uRb0TB0rrAfhG3antF6dmwWoyYG9JHbYfq+7WYwghlC7scik4aUO+sFJR3zwucq+/cR7P1xORGhjYd2Lx4sXIyclBbm6u1kshIopYWjfPky8o2DvI2APNgX9lfc8ceVfob5yXFmeFuRsZQjmwLwppKb4vsI+PDn1gn2WPQmqcFR6vwM6CrgXPW/3n6wen2pQLPmqKjzLjwtEZAHxZ++6oaXIrowPl5m2kjcQYC0z+szxldb6LLXuV8/XsiE9EwWNg34kFCxYgPz8feXl5Wi+FiChiNWfstQns5QsKCZ0Ekz29FL+gSi7D7/r5eqBlKX5TUOXhHQnnGXtJkpRz9t8fqezS537rL8PPHaDu+fqWfumfaf/htoIuVxQAQKm/DD8uyoQos3rN/ajrDAZJKceXz9krgX06M/ZEFDwG9kREpDm547zeS/GTNO4FECylI343Rt0BzVlfp9sbsr1q7oof+sAeAE7zl+N39Zx9c+M89cvwZZMGJaNvYjRqHW58vKuoy5/fXIbPbL0etDxnL4TAvmLfGXt2xCciNTCwJyIizbUsxfd6Q5MJ7kiVv3lep6X4PfyMvVyK351RdwBgNRmVixuhGnknZ+zjw3DGHmjRGb8LI++aXB784D/3PiGEGXuDQcJl43xN9N7a2vVyfKUjPs/X60JaXPMs+8LqJtQ7PTAZJAxIsWm8MiKKBAzsiYhIc3Ipvlc0Z2zDqTLQjL3GvQCCVSB3xO/GqDtZeohH3tU0hjdjf0rfBEiS72tTEuBr2nm8Gk6PF8k2CwYkh3ZM2eX+mfYb95fjWGVjlz5X6YjP8/W6kOq/wFJS41DK8Aem2LrV74KI6ET8TUJERJqzmoyIsfjOAGtxzr7aH9gnBNoVX6MjA8FSSvG70RFfluEPEkPVQK/WEb4z9gAQazVhmL952fcBluN/e7i5DF+SpFAtDQCQnRSDKYOTIQSw8vuCLn0uS/H1RZllX+fAXrkMn+friUglDOyJiEgXtGxMVxXAHHsASLLJXfF7Zsa+0N88LyuIjH2Gv4w/dKX4/oy9NTyl+ECLcvxAA3v/+foJA0J3vr4luYneu98fR1dOqsil+HKVBWlLrpwoqXFgX4k86o4d8YlIHQzsiYhIFxL9QbMWZe7y+LqAu+L3wMDe5fEqpdmZ3WyeBzR3xg9VKX44x93J5Hn2gZyzF0LguyNyYB+68/UtzRiVgTirCceqmrCvJvAKAXm/U5mx14XUWLkrfhP2sHEeEamMgT0REemCHDRrMSO+ulEuxe8sYy937+95gX1xTRO8AjAbJaTYuh/oZdh9n1sY4uZ54SrFB5oz9t8ersD8177F0+v3YF1+MQqrG08a63egrB4V9U5YTQaMzrKHZX3RFiN+MTYLALC5pCuBPZvn6Uma/6JYSa2Do+6ISHXhe9ckIiLqgBxUhztodrq9qHP4ssSdNc+Tz9g3OD1ocnl61GxwORDPtEfDYOj+ufCQN88L87g7ABiWHoeBKTYcLKvHuvxirMsvVm5LslkwKiseOVnxGJVlx6GyegDAqX0TYDGFLz8yZ3xfvL75CLaXS6htciHJ3HlFQ6l8xp7N83RBPmMv/ywaJF/zPCIiNTCwJyIiXZCD6qowN6aTs/WSBMR1MmItzmqCySDB7RWobHAis5tj47QgN87LDKJxHgBk+D8/FM3zmlweON1eAJ3vhZqMBgmrf30mth+rwq6CGuwqqEZ+QQ32ltShot6Jr/aW4au9Za0+Z3yYztfLxmYnYEiqDftK6/HUJ/vx10vGdHj/Bqcbtf4LVmyepw8psa33YUCyDVZTz7k4SET6xsCeiIh0QavmefKZfnu0GcZOMtmSJCHRZkFprQMV9T0tsA++cR7QfMa+qsGletVCy1GHsdbw/okSbTFi0qBkTBqUrHysyeXBT0W1SrC/q6AGPxbVwO0RmDk6M6zrkyQJ9104HNe/9h2WbjqC83My8LNhqe3eX+6IH202hv1rSW2zmAxIjDEr4zWH8Hw9EamIv+k7sXjxYixevBgej0frpRARRbTmjH2YA/vGwBrnyZJifIG9Fr0AglFY7R91F0TjPMB3AcRqMsDh9qK4pgn9k9UrJZbP18daTZ1eZAmHKLMRp2Yn4FT/GXwAcHu8cHuFJscwzhyagjPTvfiq2IDfvb0dH9/5s3b7Qijn6+OtIR/JR4FLi4tSAnueryciNbF5XicWLFiA/Px85OXlab0UIqKIJp9fD3fALJf+2ztpnCeTu/drMZYvGM2l+MFl7CVJUsr51R55p3TED+P5+q4yGQ2a9la4qL8XA5NjUFzjwJ9W7jypuZ9M7ojPMnx9adnvYChH3RGRihjYExGRLmjVPE9+vs4a58mUzvg9bORdcyl+8B3S5QZ6ap+zV2bYh/F8fU9jMQL/uHwMTAYJq3YU4v1tBW3eTy7FZ0d8fWk5epCl+ESkJgb2RESkC5o1z2voWil+T51l31yKH3xfgIyQZezDP+quJzqlrx2/Pm8oAOD+93fiuL8aoyW5FJ8z7PVFvtAiScDgVAb2RKQeBvZERKQLLZvntVdeHApyxr6zGfayRI0qC4LR6PQo53rVaPiXEfKMPQP7ztx29mCMzU5AbZMb97y5HV5v658ZpRSfo+50Rb7Qkp0Yg2gLO+ITkXoY2BMRkS7IZ+ydbi8aXeFrWKo0zwuwFF9eZ0/K2Bf4s/U2i1GV8+uhmmVfo2TsWYrfGZPRgKeuGItosxHfHCjHy18fbHV7aS1L8fUoJzMeAJA7IEnjlRBRpGFgT0REumCzGGE2+rp3V4axHF8uxU8MMGOfZNPmyEAw5JL5zIRoVTqkh6oUv4YZ+y4ZmGLD/bNyAAB/X/MTfiqqVW6Tz9inM2OvK5MGJWHtb3+GRy4drfVSiCjCMLAnIiJdkCSpuYFeGLPhzaX4kXvGvlAO7O3qZG+bM/YOVR5PJp+xjw+w3wEBV52ejXNHpMHp8eLO/26Dw+2rdmnuis+MvZ5IkoRh6XGaTlYgosjEwJ6IiHRDiwZ6yri7QOfY23reGXu5ZF4OyIMlXyAormk66Wx3MHjGvuskScLfLhuDJJsFuwtr8NS6vXC6vUrVC8fdERH1DpoG9g8++CAkSWr1v4yMDOV2IQQefPBBZGVlITo6GmeffTZ27drV6jEcDgfuuOMOpKSkwGaz4aKLLsKxY8da3aeyshLz5s2D3W6H3W7HvHnzUFVVFY6XSEREXdCygV64VCnj7rrWPK+iPrxN/oIhd8RXK2OfGmeFJAFur0B5J5ULXq/AvpJa5chDR2p5xr5b0uKi8NjsMQCA/3y5H6t3FAIALEZDwJUoRETUs2mesR81ahQKCwuV/+3YsUO57e9//zuefPJJLFq0CHl5ecjIyMD555+P2trmM2R33nknVq5ciRUrVmDDhg2oq6vDrFmz4PE0N16aO3cutm3bhjVr1mDNmjXYtm0b5s2bF9bXSUREnZOD5qpwBvZdbJ4nZ+wdYW7yF4yiavm8tTqBvdloQEqs1f/YJ5+zP1rRgDe2HMGC5d9h/MPrMO3JLzHhkXW4/tU8rPz+mBLAn0jO2KvR4K+3mTEqA7+c0BdCAH989wcA8gWY4HsqEBGR/mn+zmkymVpl6WVCCDz99NP405/+hNmzZwMAlixZgvT0dLz++uu4+eabUV1djZdeeglLly7FtGnTAADLli1DdnY21q9fjxkzZmD37t1Ys2YNNm3ahIkTJwIAXnjhBUyePBk//fQThg8fHr4XS0REHUr0N6arrA9PKb7D7UGD0xecBzruLsZihMVkgNPtRUW9EzEWzd9KO1VUo27GHvCNvCutdaCopgnZDdHYuL8cG/aV4et9ZThc3tDqvvLX69MfS/DpjyWwmAw4d3gaZp2aifNGpCtjv2o4xz4oD/xiFL45UI6jFb795gx7IqLeQ/N3zr179yIrKwtWqxUTJ07Eo48+ikGDBuHgwYMoKirC9OnTlftarVacddZZ2LhxI26++WZs3boVLper1X2ysrIwevRobNy4ETNmzMA333wDu92uBPUAMGnSJNjtdmzcuLHdwN7hcMDhaG4KVFNTAwBwuVxwucLfCVl+Ti2emzrGvdEv7o1+tbc38Vbf21J5XVNY9q3MPxLMIAFRBhHwcybGmFFc40BpdSPSY/Vf6ixn1ZNjTJ2+xkB/btLifBdC7nv3B5TVO9HyVILJIGFsth1TBiVj6pBkjOkTj8PlDVi9swirdhThQFkD1uwqwppdRYixGHHO8FTMGpOBKn9Zf7RJ4s9tGzrbG6sB+Pvs0Zj7Uh6EAFJjLfw6hgnfb/SN+6Nf3JvOBfq10TSwnzhxIl577TUMGzYMxcXFePjhhzFlyhTs2rULRUVFAID09PRWn5Oeno7Dhw8DAIqKimCxWJCYmHjSfeTPLyoqQlpa2knPnZaWptynLY899hgWLlx40sfXrl2LmJiYrr1QFa1bt06z56aOcW/0i3ujXyfuTVGBBMCIXfsOYfXqAyF//sIGADAh2iiwZs1HAX+eyW0EIOHjL77GkQR9n7N3e4GyOt/b/a68DTgc4HWIzn5u3NUGAAaU1vmC8YxogWF2geEJAkPiBaKMZUBTGYp2AkU7fZ8zBMCvhwAFWcB3ZQZ8Xy6h3OHBqh2+gF+2Le8blOw6+TnJp7O9OT/LgLXHDTDXFWL16oIwrYoAvt/oHfdHv7g37WtoaOj8TtA4sL/wwguV/x4zZgwmT56MwYMHY8mSJZg0aRIAnHQ2TAjR6XmxE+/T1v07e5x7770Xd911l/LvmpoaZGdnY/r06YiPj+/4hYWAy+XCunXrcP7558Ns1n92qDfh3ugX90a/2tubxu+O4/3DuxCTkIqZM8eHfB1bDlUA279Fmt2GmTPPCPjz/lv8LY4fqMCQUWMx89TMEK4weMerGoHNX8FslDDnogs7fQ8N9OdmXE0TXt9yFAOTbZgyOKlb5/eFEPjheA1W7yjCqp1FKK5xINpswJyfnx/wlILeJNC9uVAI7C2pw8AUG8xGzdsp9Qp8v9E37o9+cW86J1eOd0bzUvyWbDYbxowZg7179+KSSy4B4Mu4Z2Y2/9FUUlKiZPEzMjLgdDpRWVnZKmtfUlKCKVOmKPcpLi4+6blKS0tPqgZoyWq1wmo9+Wya2WzW9JtO6+en9nFv9It7o18n7k1KXDQAoLrJHZY9q3P6su0JNkuXni/J3ziupsmj+++tsnpfw9kMexQslsD6CACd/9xkJ5vxhwtzgl7fhIEpmDAwBX+eNQrfH61CrNWElHjtKuN6gkB+p43qmxSm1VBLfL/RN+6PfnFv2hfo10VXl3EdDgd2796NzMxMDBw4EBkZGa3KMpxOJ7744gslaB8/fjzMZnOr+xQWFmLnzp3KfSZPnozq6mps2bJFuc/mzZtRXV2t3IeIiPRBaZ4Xpq74XR11J+tJs+yL/DPsM+OjNV5JxwwGCeP7J2J4RpzWSyEiIupxNM3Y33PPPfjFL36Bfv36oaSkBA8//DBqampw7bXXQpIk3HnnnXj00UcxdOhQDB06FI8++ihiYmIwd+5cAIDdbscNN9yAu+++G8nJyUhKSsI999yDMWPGKF3yR44ciQsuuADz58/Hf/7zHwDATTfdhFmzZrEjPhGRzsid6avC1BW/yj9bPaGLZd8tZ9nrndw4L13FjvhERESkL5oG9seOHcNVV12FsrIypKamYtKkSdi0aRP69+8PAPj973+PxsZG3HbbbaisrMTEiROxdu1axMU1X81/6qmnYDKZ8Mtf/hKNjY0477zz8Oqrr8JoNCr3Wb58OX79618r3fMvuugiLFq0KLwvloiIOpXkD5hrHW64PN6Qnw+ulAP7SM7Y+wN7NUfdERERkb5oGtivWLGiw9slScKDDz6IBx98sN37REVF4ZlnnsEzzzzT7n2SkpKwbNmy7i6TiIjCJD7aDEkChPAFzWlxoQ1Gqxt9gXlCTBcz9raek7Ev9Jfid6e5HREREfUMujpjT0REvZvRICnd0OUy+VBSSvG7GtjHhG+NwWLGnoiIKPIxsCciIl2Rz69XhiEbLpfSd7UUv0eesWfGnoiIKGIxsCciIl2Rs+eV4czYd7F5Xssz9kII1delFq9XoLiGGXsiIqJIx8CeiIh0RW6gF47GdHJg39Vxd/L9XR6BOodb9XWppbzeCbdXQJKA1Dir1sshIiKiEGFgT0REupIQzsC+m83zoi1GRJt901cqwzSarzvkMvzUWGvIJwwQERGRdvgu34nFixcjJycHubm5Wi+FiKhXCFdjuiaXB00uLwDA3sXAHmgux6/Q8ci7In8ZfgbL8ImIiCIaA/tOLFiwAPn5+cjLy9N6KUREvYI8Si7UzfPkCwdGg4Q4a9envyba/L0AdNxAr6i6EQCQwcZ5REREEY2BPRER6Uq4mucpZfjRZkiS1OXP7wmd8ZmxJyIi6h0Y2BMRka6Eq3mefDa+q+frZS074+tVYTUDeyIiot6AgT0REelKuJrnVTd2b4a9rCdk7OVRdyzFJyIiimwM7ImISFfks+uhbp5XqYy6Y8aeiIiIejYG9kREpCtyJryqwQmvV4TseeQLB/bobmbsbfrO2AshlHF3mfZojVdDREREocTAnoiIdEU+8+4VQG2TO2TP090Z9jKlF4BO59jXOtxocHoAsBSfiIgo0jGwJyIiXbGajLBZjABCOyO+qj64Unz5yIBe59gX+7P19mgzov1fTyIiIopMDOyJiEh3wtFAT87Y27vZPE85Y6/TUnzlfD2z9URERBGPgT0REelOcwO90AXNQTfPk3sBNLpC2guguzjDnoiIqPdgYE9ERLqTGIbz69X+wD6hm83z5KoCj1eEtBdAdxUxY09ERNRrMLAnIiLdSQxDKb782N1tnmcxGRBrNQHQ5zl7jrojIiLqPRjYd2Lx4sXIyclBbm6u1kshIuo15PL4UAX2QghUNfoz9t0M7IEWDfR0eM6+mKX4REREvQYD+04sWLAA+fn5yMvL03opRES9RnPzvNCU4je5vHC6va2eqzuaR97pL7Bnxp6IiKj3YGBPRES6I2fsQ9U8T64EMBslZbRedyT6O+PrsRRfydjzjD0REVHEY2BPRES6k2gLbfO8Kn8lgD3aAkmSuv04es3YN7k8yvGATGbsiYiIIh4DeyIi0p1QN8+TKwG6O+pOpteMfUmNAwBgNRlgjw7uNRIREZH+MbAnIiLdCXlgr0LjPABIsukzY19Y3QjAl60PpiKBiIiIegYG9kREpDsJSld8F4QQqj9+y1L8YMgXICpCdGSgu4r85+vTeb6eiIioV2BgT0REuiOXuDvdXjS6PKo/fqVKpfhJttCO5euuIn9HfJ6vJyIi6h0Y2BMRke7YLEaYjb4S8lCMvKtWqRQ/UafN85SMPQN7IiKiXoGBPRER6Y4kSSENmuXHDGaGPdB8xl5vzfOUjD1L8YmIiHoFBvZERKRLoWygp1bzPPnIQHWjCx6v+r0AukvO2GfYozVeCREREYUDA3siItKllg301CaPu0sIsnlegn+UnBDN5f16IGfsM1iKT0RE1CswsCciIl2SM/ZVocjY+y8WBNs8z2RsnhNfoZNz9h6vQEmtb449m+cRERH1DgzsO7F48WLk5OQgNzdX66UQEfUqiXLH+RCMkpNL8e1BBvZA88UBvXTGL6tzwOMVMBokpMRatV4OERERhQED+04sWLAA+fn5yMvL03opRES9SqjO2AshlCqAxCCb5wHN5+z1krEv9Jfhp8VZYTRIGq+GiIiIwoGBPRER6VKoAvsGpwcuj6/RXbDN8wAgSWcj7+Tz9ensiE9ERNRrMLAnIiJdClXzPPlCgcVkQLTZGPTjJeps5F1RdSMAnq8nIiLqTRjYExGRLoWqeZ7cOC8h2gxJCr5UXZ5lr5uMfY2vcR4z9kRERL0HA3siItIlpXmeyoF9tUoz7GVyYP9TcZ0qjxcsZuyJiIh6Hwb2RESkS8oZe5W74ssXChJUaJwHANNGpsNokPDlnlJsPlCuymMGo6iGM+yJiIh6Gwb2RESkS3JgX+dww+n2qva4LUvx1TAkLRZX5mYDAB5dvRter1DlcbtLbp6XwVJ8IiKiXoOBPRER6VJ8tBnyEfiqRvXK8dUcdSe7c9ow2CxGbD9WjQ9/KFDtcbtKCMGMPRERUS/EwJ6IiHTJaJBg92fVq1TsjK9k7FU6Yw8AqXFW3Hr2YADA39f8hCaXR7XH7orqRheaXL7qBjbPIyIi6j0Y2BMRkW6FYka8PD7PrmJgDwA3nDEIGfFROF7ViCUbD6n62IGSs/WJMWZEqTDKj4iIiHoGBvZERKRbzbPs1QvsqxvVL8UHgGiLEffMGA4AWPTZPlRoMP6uUD5fb48O+3MTERGRdhjYd2Lx4sXIyclBbm6u1kshIup1kmOtAID8wlrVHlPt5nktXXpaH+RkxqO2yY1/fbJX9cfvTLHSOM8a9ucmIiIi7TCw78SCBQuQn5+PvLw8rZdCRNTrzDolEwDwytcHUa3SOXu1x921ZDRI+NPPRwIAlm06jINl9ao/R0eYsSciIuqdGNgTEZFu/eKULAxPj0NtkxsvfHVAlcesblS/eV5LU4ek4JzhqXB7BR7/6MeQPEd7iv1n7DPZEZ+IiKhXYWBPRES6ZTBIuGv6MADAy18fRFmdI6jHE0Iopfhqn7Fv6d6ZI2GQgDW7ipB3qCJkz3OiQs6wJyIi6pUY2BMRka5Nz0nHmD52NDg9+Pfn+4N6rLxDlXB7BQxS6DL2ADAsPQ5X5GYDAB5ZtRtCiJA9V0vFnGFPRETUKzGwJyIiXZMkCXf7s/ZLNx1GkT8r3VVNLg/++O4PAIDLx/cN+Ti4304bhhiLEduOVmHVjsKQPpes+Yw9A3siIqLehIE9ERHp3lnDUpE7IBEOtxeLPutet/lnPt2LA6X1SI2z4k8zc1Re4cnS4qNw888GAwAeX/MjHG5PSJ+v0elR+gcwsCciIupdGNgTEZHu+bL2vhnx/807iqMVDV36/F0F1fjPF77me3+9eBTsISzDb2n+zwYiLc6KoxWNWPrN4ZA+V5G/DD/GYkSc1RTS5yIiIiJ9YWBPREQ9wqRByThzaApcHoF/dmFGvNvjxR/e+QFur8CFozNwwejMEK6ytRiLCff4L0j865O9qPKP2guFwupGAL5svSRJIXseIiIi0h/dBPaPPfYYJEnCnXfeqXzsuuuugyRJrf43adKkVp/ncDhwxx13ICUlBTabDRdddBGOHTvW6j6VlZWYN28e7HY77HY75s2bh6qqqjC8KiIiUpOctX/3u2PYX1oX0Oe8uOEgdh6vQXyUCQsvHhXK5bXpsvF9MSIjDjVNbjzz6b6QPY/SOI8d8YmIiHodXQT2eXl5eP7553HKKaecdNsFF1yAwsJC5X+rV69udfudd96JlStXYsWKFdiwYQPq6uowa9YseDzNZxnnzp2Lbdu2Yc2aNVizZg22bduGefPmhfx1ERGRusZmJ2DayHR4BfD0+s6z9gfL6vHUuj0AgPtn5SAtLvxBr9Eg4b6ZIwEAr31zCIfL60PyPGycR0RE1Htpfgivrq4OV199NV544QU8/PDDJ91utVqRkZHR5udWV1fjpZdewtKlSzFt2jQAwLJly5CdnY3169djxowZ2L17N9asWYNNmzZh4sSJAIAXXngBkydPxk8//YThw4eH7sUREZHq7jp/GNbvLsaH2wtw29mDMTIzvs37eb0Cf3znBzjcXpw5NAWXj+8b5pU2+9mwVPxsWCq+3FOKa1/egmHpcYiLMiMuyoT4KBPiosyIjzYpH4uLMqNvYjRSYq0BP0cxZ9gTERH1WpoH9gsWLMDPf/5zTJs2rc3A/vPPP0daWhoSEhJw1lln4ZFHHkFaWhoAYOvWrXC5XJg+fbpy/6ysLIwePRobN27EjBkz8M0338ButytBPQBMmjQJdrsdGzdubDewdzgccDgcyr9ramoAAC6XCy6XS5XX3hXyc2rx3NQx7o1+cW/0K5i9GZoajZ+PzsCqnUX4v49/xHNXn9bm/d7IO4rNBysQbTZg4S9GwO12B7XmYP3+/CHYuK8Mh8obcKi88+Z/JoOElbdOwoiMuIAev6DKd8Y+LdYc1Pc8f270i3ujX9wbfeP+6Bf3pnOBfm00DexXrFiB7777Dnl5eW3efuGFF2LOnDno378/Dh48iPvvvx/nnnsutm7dCqvViqKiIlgsFiQmJrb6vPT0dBQVFQEAioqKlAsBLaWlpSn3actjjz2GhQsXnvTxtWvXIiYmpisvU1Xr1q3T7LmpY9wb/eLe6Fd39+ZUE7AaRqz/sRTP/Xc1+p8Q+1Y5gEe3GwFIuKCPCzu++Rw7gl9u0O4eDRQ2Smh0A00eoNEjockNNHrg/5iERg9Q7QAaPMBjb32NKwZ7A3rsn474Xu+xvbuwunxn0Gvlz41+cW/0i3ujb9wf/eLetK+hIbBJQJoF9kePHsVvfvMbrF27FlFRbZcNXnHFFcp/jx49GhMmTED//v2xatUqzJ49u93HFkK06gjcVnfgE+9zonvvvRd33XWX8u+amhpkZ2dj+vTpiI9vu+wzlFwuF9atW4fzzz8fZnN4xjRRYLg3+sW90S819ma3tBMrvy/AlqZ03HrFeOXjQgjcvPx7ODxlGJttx2P/73QYDT2rS/zmgxX41cvfYnuVGc+edxZsAYyve2TnFwAc+Pk5UzG6T/ffp/hzo1/cG/3i3ugb90e/uDedkyvHO6NZYL9161aUlJRg/PjmP8Y8Hg++/PJLLFq0CA6HA0ajsdXnZGZmon///ti719cwKSMjA06nE5WVla2y9iUlJZgyZYpyn+Li4pOev7S0FOnp6e2uz2q1wmo9+Wyj2WzW9JtO6+en9nFv9It7o1/B7M1d5w/Hh9sLsWFfOb47WoOJg5IBAB9sL8BnP5XBbJTw98tPRZTVouaSw2Lq0DQMTLHhYFk91uSX4srT+3V4f5fHi9I63/GxPsk2Vb7f+XOjX9wb/eLe6Bv3R7+4N+0L9OuiWVf88847Dzt27MC2bduU/02YMAFXX301tm3bdlJQDwDl5eU4evQoMjN9M4jHjx8Ps9ncqnSjsLAQO3fuVAL7yZMno7q6Glu2bFHus3nzZlRXVyv3ISKinic7KQZX5GYDAP5v7R4IIVBR78SDH+wCANx+zlAMSw/sfLreSJKEq073vbY3thzp9P6ltQ4I4TuXn2ILvOEeERERRQbNMvZxcXEYPXp0q4/ZbDYkJydj9OjRqKurw4MPPojLLrsMmZmZOHToEO677z6kpKTg0ksvBQDY7XbccMMNuPvuu5GcnIykpCTcc889GDNmjNIlf+TIkbjgggswf/58/Oc//wEA3HTTTZg1axY74hMR9XB3nDsUb209hi2HKvDV3jK8+90xVNQ7MTw9DreePVjr5QXlsnF98cTHP2H7sWrsKqjGqCx7u/ct8s+wT4+PgqGHHTsgIiKi4Olijn1bjEYjduzYgYsvvhjDhg3Dtddei2HDhuGbb75BXFxzBuapp57CJZdcgl/+8peYOnUqYmJi8OGHH7bK+C9fvhxjxozB9OnTMX36dJxyyilYunSpFi+LiIhUlGGPwrxJ/QEAv3t7O97bVgCDBDx++SmwmHT7FheQ5Fgrpo/yjXtdseVoh/ct4gx7IiKiXk3zcXctff7558p/R0dH4+OPP+70c6KiovDMM8/gmWeeafc+SUlJWLZsmRpLJCIinbn17MF4Y8sRFNf4zphfP3UgxmYnaLsolVyV2w+rfijEe98fx30zRyLacvIxNYCBPRERUW/Xs9MZRETU66XEWvH/pg4AAPRLisFd04dpuyAVTRmcjH5JMah1uPG/HwravZ9cip8Rz8CeiIioN2JgT0REPd4d5w7FfTNH4NX/l4sYi66K0YJiMEhKg8COmugV+jP2mczYExER9UoM7ImIqMeLMhtx088GY1BqrNZLUd2cCX1hMkj47kgVfiqqbfM+xdXNzfOIiIio92FgT0REpGNpcVGYNjIdQPtZ+8KaRgDM2BMREfVWDOyJiIh07kr/TPuV3x9Hk8vT6jYhBIqrfY0DmbEnIiLqnRjYd2Lx4sXIyclBbm6u1kshIqJe6syhqeiTEI3qRhc+2lnY6raKeiecHi8ABvZERES9FQP7TixYsAD5+fnIy8vTeilERNRLGVs10Ws9017uiJ8Sa4HFxLd1IiKi3oh/ARAREfUAv5yQDYMEbDlYgX0ldcrHOcOeiIiIGNgTERH1ABn2KJw7Ig0AsKJFEz3OsCciIiIG9kRERD3EVaf3AwC8890xONy+JnrM2BMREREDeyIioh7irGGpyLRHobLBhY93FQNoEdgzY09ERNRrMbAnIiLqIUxGA+ZM8DXRk8vxlVJ8e7Rm6yIiIiJtMbAnIiLqQa7IzYYkARv3l+NQWT0z9kRERMTAnoiIqCfpkxCNs4alAgBW5B3lGXsiIiJiYE9ERNTTyE30VuQdQa3D1dYU5gAAG5NJREFUDYCBPRERUW/GwJ6IiKiHOXdEGlLjrKhqcAEA4qwmxFpNGq+KiIiItMLAnoiIqIcxGw345YS+yr+ZrSciIurdGNgTERH1QFfm9lP+m4E9ERFR78bAvhOLFy9GTk4OcnNztV4KERGRIjspBmcOTQEApLMjPhERUa/GwL4TCxYsQH5+PvLy8rReChERUSu/nzECp/VLwBW52VovhYiIiDTETjtEREQ91Ji+dqy8barWyyAiIiKNMWNPRERERERE1IMxsCciIiIiIiLqwRjYExEREREREfVgDOyJiIiIiIiIejAG9kREREREREQ9GAN7IiIiIiIioh6MgT0RERERERFRD8bAnoiIiIiIiKgHY2BPRERERERE1IMxsCciIiIiIiLqwRjYd2Lx4sXIyclBbm6u1kshIiIiIiIiOgkD+04sWLAA+fn5yMvL03opRERERERERCdhYE9ERERERETUgzGwJyIiIiIiIurBGNgTERERERER9WAM7ImIiIiIiIh6MAb2RERERERERD0YA3siIiIiIiKiHsyk9QJ6CiEEAKCmpkaT53e5XGhoaEBNTQ3MZrMma6C2cW/0i3ujX9wb/eLe6Bf3Rr+4N/rG/dEv7k3n5PhTjkfbw8A+QLW1tQCA7OxsjVdCREREREREvUltbS3sdnu7t0uis9CfAABerxcFBQWIi4uDJEmtbsvNzUVeXl5In7+mpgbZ2dk4evQo4uPjQ/pc4Xg94XiOcD0P90a/z8O90e/zRNrehOt5uDf6fR7uTe9+Hu6Nvp9n/Pjx2LdvX8j3J5K+ZuF6Hu5N54QQqK2tRVZWFgyG9k/SM2MfIIPBgL59+7Z5m9FoDPkvcVl8fHzInyscrydcXzPujT6fI5zPA3Bv9Po8QOTsTbieh3uj3+fh3vB5AO6NXp/HaDQCCP3+RNLXLFzPw70JTEeZehmb56lgwYIFWi9BVeF4PeH6mnFv9Pkc4XyecOHe6Fckfd24N/p9Hu4NnydcIu1rFo7nmT9/fsifA4isr1m4nod7ox6W4vcQNTU1sNvtqK6uDltGgALDvdEv7o1+cW/0i3ujX9wb/eLe6Bv3R7+4N+phxr6HsFqt+Mtf/gKr1ar1UugE3Bv94t7oF/dGv7g3+sW90S/ujb5xf/SLe6MeZuyJiIiIiIiIejBm7ImIiIiIiIh6MAb2RERERERERD0YA3siIiIiIiKiHoyBPREREREREVEPxsCeiIiIiKgD7DWtX9wb/eLehBcDe53hD4B+cW/0i3ujX9wb/eLe6Bv3Rz9KSkpQW1ur/Jt7ox/cG/3i3oQfx91pyOl04qmnnoLNZsOYMWNw1llnab0k8uPe6Bf3Rr+4N/rFvdE37o8+ud1u3Hzzzfjkk0+QlpaGoUOH4p///CdSUlK0Xlqvx73RL+6Ndpix18hHH32ErKwsvPfee3jllVdw6aWX4s9//jOampq0Xlqvx73RL+6NfnFv9It7o2/cH31yu9247rrrkJ+fjyVLluCqq67CDz/8gNmzZ2P37t1aL69X497oF/dGY4I0MWfOHHHzzTcLIYSoqKgQb731lrBareKpp54SDQ0NGq+ud+Pe6Bf3Rr+4N/rFvdE37o8+HTlyRAwdOlQsXbpU+VhhYaHo06ePuOOOO0RRUZGGq+vduDf6xb3RFjP2Gjh48CA2btyIM888EwCQmJiIyy+/HDfddBOWLVuGDRs2aLzC3kX4T6MIIbg3OuPxeJT/5t7oS11dHRoaGgAABw4c4N7oFPdG3/h7Tb/Ky8tx7NgxTJo0CQDgcDiQkZGBe++9F2vXrsWXX36p8Qp7L+6NfnFvtMXAPgxee+017Nu3T/l3//794Xa7UVNTAwBobGwEAPzlL39BfX09PvroI9TV1Wmy1t7m3nvvxTPPPAMAkCQJAwYM4N7oxP3334/7779f+Tf3Rj9+97vfYfLkySgrKwPAvdGTtWvXYvv27cpFsYEDB8LlcnFvdGL//v2tGkj179+f+6MDjz76KP7yl79gxYoVysdGjhyJtLQ0LFu2DABgMPj+ZF6wYAHi4uLw0UcfweFwaLLe3mT16tUAWjdeGz58ODIyMrg3Gnv++efxwgsvtArWhw4dyr3RkrYFA5HN4/GISy+9VEiSJJ544gnR2NgohBDC6XSKW265RZxyyinKfZ1OpxBCiL/97W8iOztbVFZWarHkXuO5554TsbGx4rTTThP5+fnKx91uN/dGY++9955IT08XEydOFIsWLRIVFRVCCO6NHjz33HMiPj5e9O3bV0iSJD777DMhBH+n6cErr7wiMjIyxJgxY0RcXJy47bbbxPHjx4UQQtx8883cG4299NJLol+/fmL8+PFi4sSJYunSpcLtdgshhLjpppu4PxrZvHmz6Nevnxg3bpy48MILRVxcnLjsssvE/v37hRBC3HPPPWLYsGGiuLhYCCGUv+OWLFkiEhISlH+T+v73v/+JPn36CEmSxNdffy2E8P1dLYQQDQ0N4ve//z33RiOvv/66SEtLE5MnTxZjx44Vqamp4pFHHhFCCFFdXc290RAD+xCRf/ncfvvtIjc3V2RmZorvvvtOuf2dd94RI0aMEE8//bQQQoimpiYhhBClpaUiOjpafPXVV+FfdC+wd+9ecfrpp4v4+HjxxhtvtHmft99+m3ujkbq6OvGLX/xCPPTQQ23e/s4774jhw4dzb8Lsq6++EgMHDhSZmZni9ddfF/v37xfjxo0Tzz//vHIf/k7TzosvviiGDBki3njjDVFaWiqWL18ubDab2LZtmxCCe6O1p59+WtmfDRs2iAceeEBIkiSeffZZ4fV6xYcffiiGDRvG/dHAXXfdJX7+858LIXx/t+3YsUP0799f3HLLLaKqqkps2rRJjBs3Ttx2221CCCG8Xq8QQojPPvtMpKWlie3bt2u29kj21VdfiQsuuEDcfvvt4sILLxQTJkw46T7r168Xubm53JswW758uTj11FPFv//9byGEEMePHxeLFi0SNptNVFdXCyGEWLduHfdGIyzFDxGDwYCysjJs2rQJ69evR3R0NBYtWoTS0lIAwOTJkzF9+nT83//9HwoKCmC1WgEA33//PVJTUxEXF6fl8iNWXl4e9u3bh7/+9a+48sorUVVVheXLl+Orr77Cnj17AABnnHEG90Yjn3/+OTZt2oQ//elPqKysxB//+Ec8/vjjWL58OQDgvPPO495o4IMPPsDMmTNx8OBBXHXVVRg0aBDKy8tRUFCg3OfMM8/EjBkzuDdhJISAx+PBp59+ismTJ+PKK69ESkoK5s6diz59+sDr9QIApk6dyp8bjTQ0NGDVqlW4+uqrceWVV2LKlClYuHAhzjjjDDz66KNYu3Ytzj//fP7shJkQAtXV1diyZQtGjhypfHz06NH4wx/+gM2bN2PFihWYOHEi5s2bh1dffRUrV66Ey+UCAHz99dfIycnBmDFjtHoJEUn4y+3T09Mxffp03HXXXfjrX/+K/Px8vPTSSwB8XdcB3++1uXPnYsmSJdybMJD3xuVyYeLEibjmmmsAAFlZWRg7diz69OmD/Px8AL6/o7k3GtH2ukLkcrvdorGxUfzsZz8THo9H/Pe//xUmk0l8++23QgjfFflDhw6JKVOmiLFjx4ply5aJvXv3iiuvvFJMmzZN1NfXa/wKItfcuXPFrFmzxPz580V2draYNGmSSE1NFZmZmWL9+vVCCCHy8/PF1KlTuTdhIl/Nfemll8Qll1wi1q9fLwYOHChmzJghLrroImE0GsXtt98uKioqxMGDB5XyL+5NeMgVSEII4XK5hBBCXHvttWLatGmt7vfDDz+IM888k3sTZmPHjhU33nij0m34jjvuEMOHDxcPPvig2LhxoxBCiP379/PnRgMOh0MkJSWJ119/XQjRXJJ62WWXiaysLDFv3jxRW1sr9uzZw/ecENu6dauoqqpq9bEJEyYoEwnkSgmn0ylmz54tLrroInH8+HHhdDrF7373OxEXFyfOOussMWfOHBEdHS0WL14shGh+/6Lua2tv5KMqLpdL3H333SI1NVXZI/m2mpoa8fvf/557E0Jbt25tdRyoqqpK+frLtm3bJjIyMpSjk0Jwb7TCwD5Ib775prjxxhvF008/LX744YdWt+3bt08MGDBA+YE455xzRE5OjsjKyhJPPPGEEEKIoqIiccEFF4iRI0eKPn36iKlTp4qDBw+G+VVEpvb25rPPPhODBg0SU6ZMEStXrhQFBQVi37594qqrrhJDhgwRu3fvFkJwb0Kpvb154403hN1uF7fddpt44IEHlLOmr776qpg4caL4xz/+IYTg3oRSe3vTMrgXwndu+5xzzhHV1dWtbuPehE57e7NixQrRv39/MX36dJGcnCxGjBghHnroIXHOOeeIU045Rfztb38TQnBvQq29/bnqqqvEiBEjxLFjx4QQQixbtkycc8454sYbbxRDhgxRylK5P6Hx9ttvi759+4rBgweLfv36iQceeEDZi3/+858iNjZWuXjicDiEEL7jK3379lXOdgshxFtvvSX+8pe/iFtuuUX5O4GC09beFBYWCiF8gZ8c/B04cEBkZ2eLu+++Wwhx8vvRm2++yb1R2Yl7c//997caVddyD5588kkxdepUIUTzz5CMPzfhxcC+m8rKysTll18uMjIyxC233CLOOOMMkZWVJZYsWaLc55NPPhFXX321EMJ3tnvMmDFCkiQxe/bsVle/mpqaRGFhodixY0e4X0ZEam9vXn31VeU+//73v8Wnn37a6vMcDoew2WzihRdeUD7GvVFXZ3vj9XrF6NGjhSRJ4pVXXlE+z+v1issuu0zccMMNypsG90ZdgfxO83q9ypv5q6++KuLj41tduZdv496oq729afkzUlJSIp544glx1llniZqaGuXj8+fPF5deemmrJkbcG3W1tT+ZmZnitddeE0IIsWfPHjFo0CAxaNAgkZWVJWJiYsQ777wjhBDCZDKJVatWKY/Fnx115eXlKf0ltm/fLp599lmRmpoqbr31VlFVVSUOHz4sBg8erGTt5YvJQgiRnJwsXnrpJa2WHvE62pvy8nIhRHNm3uv1imeffVaYTCZx4MABIYTvbzb5TDepK5C98Xg8SgXfpZdeKhYsWKDlksmPgX03vfXWW+L0009XrvoKIcTFF18sBg4cKN5++20hhBAffvihGD58uJg3b54wm83i9ttvF1dccYXIyckRe/bsUT6P5SjqCmRvGhoaWn2O1+sVLpdLDBkyRNx5551hXW9v0tHerFy5UgghxLPPPiskSRKLFy9W3jSEEOK6664TkydPVv7Nnxt1BbI3La/Qr1+/XmRnZ4tPPvkk3EvtdTram3fffVcI4StXvfLKK8XDDz8shGjOmtx1111i8ODBoq6uTgjBn5tQaG9/BgwYoPzsHD16VHz88cdiyZIlSvBYUlIiBg0aJN566y0tlh3R5O/z5557TvTt27dVALho0SJx+umni8cee0wIIcTixYuF0WgUX3zxhXKf/fv3i8GDBysXYEg9ne3NpEmTxF//+teTPq+8vFxMmTJFXHzxxWLr1q1i+vTpYunSpfydpqKu7o3H4xFer1cMHjxY/O9//xNCCPHTTz+JK6+8Uhw5ciS8iychBJvnddvrr7+Ovn37ok+fPsqM2UsvvRSHDh3Cc889h8rKSthsNtTW1qKwsBCffvopnnnmGbz22mvYvXs3XnrpJaWZhCRJWr6UiNPZ3pSVlSE6OrrVTFRJkvDFF1/AbDZj3rx5Wi094nW0N4sWLUJ5eTluvvlmnH/++XjmmWfw6aefAgCKiopQUFCA66+/Xnks/tyoq7O9KSsrg8FgUOajJyUlwel0Kv+m0OlobxYvXoySkhKYTCaUl5fj22+/BQBYLBYUFxdjz549uPLKK2Gz2QDw5yYU2tufw4cPK01z+/bti2nTpuGaa66B2WwGAHz22WewWCw444wztFx+RJK/zw8ePIhhw4bBZDIpt1133XXIzc3F+++/jz179uDWW2/FlVdeiSuuuAIPPfQQtm3bhr///e+IiYnBpEmTtHoJEauzvRk/fjw++ugj7Nq1CwBavefMnz8fH3zwAXJzc2GxWHDZZZfxd5qKuro3BoMBeXl5iImJwbhx43DnnXfilFNOQXl5OdLS0jR5Db0dA/sAfPnll/j444+VTpwAMHToUOUbOzY2FgDw448/4txzz1W64E6ZMgXvv/8+PvjgA5xxxhlwu92wWCx46623cN111ylv7tR9Xd2bpqYmrFy5EoDvF1hhYSH27t2Lf//737j++utx7rnnYvjw4a2Cfuqeru5NY2Mj3n33XRgMBixfvhxpaWmYO3cuZs6cibFjx8LlcuHnP/+5Jq8l0gTzc2M0GgEAp512GrxeL77++uswrz6ydWdv3nvvPQDAvffei1WrVmHq1Km47bbbMGHCBNTU1OCmm24K++uIVMHsj8FgQGlpKX788UcsWrQIv/3tbzF79mykpKTwPSdI69atw69//Wv885//xJYtW5SPT506FRs3bkRRUREAX5Bos9lw8cUXw2AwYNWqVZAkCcuWLcOcOXOwcuVKzJkzB3l5eVi+fDmysrK0ekkRozt7I0kS1q5dC8D3nuN0OvHss8/ihhtuwM9+9jP88MMP+PDDDxEdHa3Ja4oUwe4NAKxevRo7d+7E8OHDsW7dOnz99ddYu3atMt2DwkzjigFdKy0tFddcc42QJEmceuqprZrY7N+/X6SmpoqzzjpLPP7442Ly5Mli4MCB4pNPPhGnnnqq+POf/3zS47FcSD3B7M39998vhPCdNV2yZIkYOnSoGDhwoFi6dKlGryayBPtzI5+pKy4uFmvXrhVPPPGEUs5KwVHj50b+PVZaWipuvfXWk3pVUPeo9X6zcuVK8Yc//EHMnTtXvPnmmxq8ksikxs+OEL4O05dccgnfc1RSUFAgZs2aJdLS0sTVV18txowZI+x2u9i8ebMQwvc+P2LECHHTTTcJIVofJzrzzDPFrbfeqvzb4/GI+vp68eOPP4b3RUSoYPdGnoEuhK+x5G9+85tWPV+o+9Tcm4cfflikpqby2IpOMLBvh8vlEs8++6yYMWOGWLFihYiJiRGPPfaYMmpDCCE2bNgg5s+fL8aNGyduv/12UVpaKoQQYt68eeKyyy7TaukRT829KSkpEe+//37YX0Ok4s+NfnFv9It7o29q7893330X1vVHqvr6enHttdeKK664QmmoJoQQubm54rrrrhNC+Jqvvfbaa8JgMLTqcC+EEFdffbU455xzlH8z+aIetfeG1KPG3px99tnKv0tKSsKzcAoIA/sObNq0SXz44YdCCCEWLlwoUlNTxffff3/S/VqOdiguLhajR49WGhidOJKD1MG90S/ujX5xb/SLe6NvauxPy2agpI6bbrpJfPTRR0KI5q/vwoULxcSJE5X7NDU1iUsvvVSMHDlSfP7558Lr9YrCwkJx+umnixdffFGTdfcG3Bv94t5ELgb2HTjx6m1WVpa46aablFFCLW9vbGwUTqdTPPvss+K00047aaY9qYt7o1/cG/3i3ugX90bfuD/61HI8nbwHv/rVr8T8+fNbfayxsVGcffbZIi0tTUyfPl1kZWWJSZMmsXN3CHFv9It7E7kY2AdAvgL/5ptvCpPJJNauXdvq9mPHjolnn31WTJgwQSQlJYnXX39di2X2Stwb/eLe6Bf3Rr+4N/rG/dG/M888U7zyyitCCF+AIvdtKSoqEmvXrhWPPPKIWL58uYYr7L24N/rFvYkMkhBsxdoVU6ZMgc1mU7p2l5aWIjU1FW+88QYKCgpw9913a73EXot7o1/cG/3i3ugX90bfuD/6c+DAAUyZMgWrVq3C+PHjAQBOpxMWi0XjlRH3Rr+4N5GDgX2A3G43TCYTdu3ahVNPPRVPPvkk9u/fjw0bNmDJkiUYPXq01kvstbg3+sW90S/ujX5xb/SN+6M/QghIkoTXXnsNDz30EPbt2wcAWLhwIYqKirBw4ULO1dYI90a/uDeRh4F9N5x++un49ttv0a9fP/znP//BjBkztF4S+XFv9It7o1/cG/3i3ugb90dfbr/9dthsNkybNg033XQTGhoasHTpUkyfPl3rpfV63Bv94t5EEM0OAfRA+/btE6NHjxYxMTHsCKkz3Bv94t7oF/dGv7g3+sb90Z/GxkYxZMgQIUmSsFqt4m9/+5vWSyI/7o1+cW8ii0nrCws9idFoxGWXXYY//OEPiI6O1no51AL3Rr+4N/rFvdEv7o2+cX/0JyoqCgMGDMD555+PJ598ElFRUVovify4N/rFvYksLMUnIiIioh7P4/HAaDRqvQxqA/dGv7g3kYOBPREREREREVEPZtB6AURERERERETUfQzsiYiIiIiIiHowBvZEREREREREPRgDeyIiIiIiIqIejIE9ERERERERUQ/GwJ6IiIiIiIioB2NgT0REREF78MEHMXbsWK2XQURE1Ctxjj0RERF1SJKkDm+/9tprsWjRIjgcDiQnJ4dpVURERCRjYE9EREQdKioqUv77v//9Lx544AH89NNPyseio6Nht9u1WBoRERGBpfhERETUiYyMDOV/drsdkiSd9LETS/Gvu+46XHLJJXj00UeRnp6OhIQELFy4EG63G7/73e+QlJSEvn374uWXX271XMePH8cVV1yBxMREJCcn4+KLL8ahQ4fC+4KJiIh6GAb2REREFBKffvopCgoK8OWXX+LJJ5/Egw8+iFmzZiExMRGbN2/GLbfcgltuuQVHjx4FADQ0NOCcc85BbGwsvvzyS2zYsAGxsbG44IIL4HQ6NX41RERE+sXAnoiIiEIiKSkJ//rXvzB8+HBcf/31GD58OBoaGnDfffdh6NChuPfee2GxWPD1118DAFasWAGDwYAXX3wRY8aMwciRI/HKK6/gyJEj+Pzzz7V9MURERDpm0noBREREFJlGjRoFg6E5h5Ceno7Ro0cr/zYajUhOTkZJSQkAYOvWrdi3bx/i4uJaPU5TUxP2798fnkUTERH1QAzsiYiIKCTMZnOrf0uS1ObHvF4vAMDr9WL8+PFYvnz5SY+VmpoauoUSERH1cAzsiYiISBfGjRuH//73v0hLS0N8fLzWyyEiIuoxeMaeiIiIdOHqq69GSkoKLr74Ynz11Vc4ePAgvvjiC/zmN7/BsWPHtF4eERGRbjGwJyIiIl2IiYnBl19+iX79+mH27NkYOXIkrr/+ejQ2NjKDT0RE1AFJCCG0XgQRERERERERdQ8z9kREREREREQ9GAN7IiIiIiIioh6MgT0RERERERFRD8bAnoiIiIiIiKgHY2BPRERERERE1IMxsCciIiIiIiLqwRjYExEREREREfVgDOyJiIiIiIiIejAG9kREREREREQ9GAN7IiIiIiIioh6MgT0RERERERFRD8bAnoiIiIiIiKgH+/+5r6+1zSpxLAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# # Plotting the time series\n", - "plt.figure(figsize=(12, 6))\n", - "r95p_index_time_series.plot()\n", - "plt.title('R95p Index Over Time')\n", - "plt.xlabel('Time')\n", - "plt.ylabel('R95p Index')\n", - "plt.grid(True)\n", - "plt.minorticks_on()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1961-01-01T11:00:00.000000000\n", - "1990-12-31T11:30:00.000000000\n" - ] - } - ], - "source": [ - "print(reference_period['time'].min().values)\n", - "print(reference_period['time'].max().values)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "R95p calculator function to be included in the class impelementation of the rest of the indices " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import xarray as xr\n", - "import numpy as np\n", - "\n", - "def calculate_r95p(pr_dataset, wet_day_thresh_mm=1.0, reference_period=('1961-01-01', '1990-12-31'), resample_freq='Y'):\n", - " # Exclude leap day (February 29th) if present\n", - " pr = pr_dataset.where((pr_dataset['time.month'] != 2) | (pr_dataset['time.day'] != 29), drop=True)\n", - "\n", - " # Convert the wet day threshold to meters\n", - " wet_day_thresh_meters = wet_day_thresh_mm / 1000.0\n", - "\n", - " # Calculate the 95th percentile for the reference period\n", - " reference_period_data = pr.sel(time=slice(*reference_period))\n", - " wet_days_reference = reference_period_data.where(reference_period_data >= wet_day_thresh_meters)\n", - " p95_reference = wet_days_reference.groupby('time.dayofyear').reduce(np.nanpercentile, q=95, dim='time')\n", - "\n", - " # Identify wet days\n", - " wet_days = pr.where(pr >= wet_day_thresh_meters)\n", - "\n", - " # Compare each day with the corresponding percentile\n", - " exceeding_days = wet_days.groupby('time.dayofyear') > p95_reference\n", - "\n", - " # Sum the precipitation for those days (r95p index)\n", - " r95p_index_time_series = (exceeding_days * pr).mean(dim=['latitude', 'longitude']).resample(time=resample_freq).sum() * 1000\n", - "\n", - " # Count the number of days exceeding the 95th percentile\n", - " r95p_days_count = exceeding_days.resample(time=resample_freq).sum(dim='time')\n", - "\n", - " return r95p_index_time_series * 1000, r95p_days_count\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "def test_calculate_r95p():\n", - " pr = xr.open_dataset('/home/posiden/Documents/Datasets/era5/india.tp.1960.1990.nc')['tp']\n", - " r95p_index, r95p_days_count = calculate_r95p(pr)\n", - "\n", - " # Plot the R95p index time series\n", - " fig, ax1 = plt.subplots(figsize=(12, 6))\n", - "\n", - " ax1.plot(r95p_index['time'], r95p_index, 'b-', label=\"R95p Index\")\n", - " ax1.set_title('R95p Index and Days Count Over Time')\n", - " ax1.set_xlabel('Year')\n", - " ax1.set_ylabel('R95p Index Value', color='b')\n", - " ax1.tick_params(axis='y', labelcolor='b')\n", - " ax1.legend(loc='upper left')\n", - " ax1.grid(True)\n", - "\n", - " ax2 = ax1.twinx()\n", - " # Take the mean over latitude and longitude for plotting\n", - " r95p_days_count_mean = r95p_days_count.mean(dim=['latitude', 'longitude'])\n", - " ax2.plot(r95p_days_count['time'], r95p_days_count_mean, 'r-', label=\"Days Count\")\n", - " ax2.set_ylabel('Days Exceeding 95th Percentile', color='r')\n", - " ax2.tick_params(axis='y', labelcolor='r')\n", - " ax2.legend(loc='upper right')\n", - "\n", - " plt.minorticks_on()\n", - " plt.show()\n", - "\n", - "test_calculate_r95p()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "RX5day calculations " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import xarray as xr\n", - "import matplotlib.pyplot as plt\n", - "\n", - "def calculate_rx5day(pr_dataset, threshold_mm=50.0, resample_freq='Y'):\n", - " # Calculate the rolling 5-day precipitation total\n", - " rolling_5day_total = pr_dataset.rolling(time=5).sum()\n", - "\n", - " # Find the maximum 5-day total for each time period (e.g., year)\n", - " rx5day_index = rolling_5day_total.resample(time=resample_freq).max(dim=['latitude', 'longitude'])\n", - "\n", - " # Count the number of 5-day heavy precipitation periods\n", - " heavy_precip_periods = rolling_5day_total.where(rolling_5day_total >= threshold_mm / 1000.0)\n", - " heavy_precip_count = heavy_precip_periods.resample(time=resample_freq).count(dim=['time', 'latitude', 'longitude'])\n", - "\n", - " return rx5day_index, heavy_precip_count\n", - "\n", - "\n", - "def test_calculate_rx5day():\n", - " pr = xr.open_dataset('/home/posiden/Documents/Datasets/era5/india.tp.1960.1990.nc')['tp']\n", - " rx5day_index, heavy_precip_count = calculate_rx5day(pr)\n", - "\n", - " # Plot the RX5DAY index time series\n", - " fig, ax1 = plt.subplots(figsize=(12, 6))\n", - "\n", - " ax1.plot(rx5day_index['time'], rx5day_index, 'b-', label=\"RX5DAY Index\")\n", - " ax1.set_title('RX5DAY Index and Heavy Precipitation Count Over Time')\n", - " ax1.set_xlabel('Year')\n", - " ax1.set_ylabel('RX5DAY Index Value', color='b')\n", - " ax1.tick_params(axis='y', labelcolor='b')\n", - " ax1.legend(loc='upper left')\n", - " ax1.grid(True)\n", - "\n", - " ax2 = ax1.twinx()\n", - " ax2.plot(heavy_precip_count['time'], heavy_precip_count, 'r-', label=\"Heavy Precipitation Count\")\n", - " ax2.set_ylabel('Count of 5-Day Heavy Precipitation Periods', color='r')\n", - " ax2.tick_params(axis='y', labelcolor='r')\n", - " ax2.legend(loc='upper right')\n", - "\n", - " plt.minorticks_on()\n", - " plt.show()\n", - "\n", - "test_calculate_rx5day()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAHUCAYAAAAEKdj3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd5wU9f3/n7Plem/cHe3ovakoRREUUbEbu0GxYKLYooktiSXJT6OJUaOINWASTfRrUFERQUSKAlJEwKPDUY47rve2ZX5/zM6Wq7t7e9zu8n4+HvOAnZ3ymdnZvXnP6/1+vRVVVVUEQRAEQRAEQRAEJ4buHoAgCIIgCIIgCEKwIYGSIAiCIAiCIAhCMyRQEgRBEARBEARBaIYESoIgCIIgCIIgCM2QQEkQBEEQBEEQBKEZEigJgiAIgiAIgiA0QwIlQRAEQRAEQRCEZkigJAiCIAiCIAiC0AwJlARBEARBEARBEJohgZIgBBELFy5EURQ2bdrU6vsXX3wxOTk5J3ZQXYB+nPpkMpno1asXt9xyC/n5+Sd8PLNnz/b7vH7zzTcoisI333zjnLdkyRKefPLJTo3pvffe48UXX2z1PUVROr19f2j+uUVFRZGZmcm0adN45plnKCoqOuFj8paOvlv+kJeXh6IoLFy4MGDb9IX169dz9dVXk5WVRUREBJmZmVx11VWsW7euW8bTFlOnTvW4btqannzySefnlJeX193D9qCiooK0tDT++9//Ouc9+eSTHuM3m8306dOHOXPmUFhY2GIbn332GTfddBOjRo3CbDajKEqb+7NYLDz11FPk5OQQGRnJ0KFDefnll7vk2DrDnj17iIiIYMuWLd09FEHoEkzdPQBBEE5eFixYwNChQ6mvr2f16tU888wzrFq1iu3btxMbG3vCxvH73/+e++67z691TznlFNatW8fw4cOd85YsWcK8efM6Fcy899577Nixg/vvv7/Fe+vWraNXr15+b7uz6J+bxWKhqKiItWvX8uyzz/LXv/6V999/n+nTp3fb2E4WXn75Ze6//35OP/10nnvuOfr27cvhw4eZN28eZ555Ji+99BJ33313dw8TgFdffZWqqirn688//5w//elPzutIp1evXkRGRrJu3TqysrK6Y6ht8tRTT5Gdnc21117b4r2lS5eSmJhITU0Ny5Yt4/nnn+e7775j69atmM1m53IfffQR69evZ9y4cURGRrJ58+Y293fXXXfxr3/9iz/+8Y+MHz+eL7/8kvvuu4/q6moee+yxLjlGfxg8eDA33ngjv/rVr1i1alV3D0cQAo8qCELQsGDBAhVQN27c2Or7F110kdq3b98TO6guoK3j/P3vf68C6r///e82162tre3q4XWauXPnqp39eQ3Gz7q96/PQoUNq79691fj4eLWwsLAbRtc+HX23/OHgwYMqoC5YsCBg2/SGtWvXqgaDQb344otVi8Xi8Z7FYlEvvvhi1WAwqGvXrj2h46qrq1PtdnuHy3XFZ9GVlJaWqtHR0eprr73mMf+JJ55QAbW4uNhj/i233KIC6tdff+0x32azOf/f3m/Ejh07VEVR1Kefftpj/pw5c9To6Gi1tLS0M4cTcDZt2qQC6rffftvdQxGEgCOpd4IQ4qiqyquvvsrYsWOJjo4mOTmZq666igMHDngst3z5ci677DJ69epFVFQUAwcO5Be/+AUlJSXOZT7++GMURWHFihUt9jN//nwURWHbtm3861//QlGUVlN8/vCHP2A2mzl27JjPxzJhwgQADh06BGgpcXFxcWzfvp0ZM2YQHx/PueeeC0BTUxN/+tOfGDp0KJGRkaSnp3PLLbdQXFzcYrvvvfceEydOJC4ujri4OMaOHcvbb7/tfL+11DtFUbj77rt5/fXXGTx4MJGRkQwfPtwj9QZapt7Nnj2befPmObehT3oq0bx585gyZQoZGRnExsYyatQonnvuOSwWi3ObU6dO5fPPP+fQoUMe23AfW3O1aseOHVx22WUkJycTFRXF2LFjeeedd1od63/+8x9++9vfkp2dTUJCAtOnT2f37t3tfTQd0qdPH55//nmqq6t5/fXXnfM3bdrEddddR05ODtHR0eTk5HD99dc7P2PQUthMJhPPPPNMi+2uXr0aRVH4v//7PwCKi4u544476N27t/Nznzx5Ml999ZXPY9avr3379jFz5kzi4uLo3bs3Dz74II2NjR7LHjt2jGuuuYb4+HgSExO59tprW02v0o/50ksvJSUlhaioKMaNG8cHH3zgfL+kpITevXszadIkj889NzeX2NhYZs2a1e64n3nmGRRFYf78+ZhMnokhJpOJV199FUVR+POf/wx4/732dvzgSmVctmwZt956K+np6cTExLQ4b77SWurd1KlTGTlyJOvWrWPSpEnO62jBggWAplCdcsopxMTEMGrUKJYuXdpiu3v37uWGG24gIyODyMhIhg0b5vyeejMmq9XaqprUGqeddhoAx48f95hvMHh3y/Xxxx+jqiq33HKLx/xbbrmF+vp6j+Pr7LnR0we3bdvG1VdfTWJiIikpKTzwwANYrVZ2797NBRdcQHx8PDk5OTz33HMtxnvqqacybNgwXnvtNa+OTxBCCQmUBCEIsdlsWK3WFpOqqi2W/cUvfsH999/P9OnT+fjjj3n11Vf56aefmDRpkscf6v379zNx4kTmz5/PsmXLePzxx9mwYQNnnnmm82bt4osvJiMjw/lH1p2FCxdyyimnMHr0aK699loyMzNb3GhYrVZef/11rrjiCrKzs30+7n379gGQnp7unNfU1MSll17KOeecwyeffMJTTz2F3W7nsssu489//jM33HADn3/+OX/+859Zvnw5U6dOpb6+3rn+448/zo033kh2djYLFy7ko48+4uabb/a4UW+LxYsX8/e//50//OEPfPjhh/Tt25frr7+eDz/8sM11fv/733PVVVcBWoqcPumpRPv37+eGG27gX//6F5999hm33XYbf/nLX/jFL37h3Marr77K5MmTyczM9NhGW+zevZtJkybx008/8fe//51FixYxfPhwZs+e3eqNzWOPPcahQ4d46623eOONN9i7dy+XXHIJNputw3PSHjNnzsRoNLJ69WrnvLy8PIYMGcKLL77Il19+ybPPPktBQQHjx493Buk5OTlceumlvPbaay3G8Morr5Cdnc0VV1wBwKxZs/j44495/PHHWbZsGW+99RbTp0+ntLTUrzFbLBYuvfRSzj33XD755BNuvfVWXnjhBZ599lnnMvX19UyfPp1ly5bxzDPP8H//939kZma2euO8cuVKJk+eTEVFBa+99hqffPIJY8eO5dprr3XWMum1Lhs3buThhx8GoK6ujquvvpo+ffq0e8Nps9lYuXIlp512Wpvpl7179+bUU0/l66+/xmazef299nb87tx6662YzWb+9a9/8eGHH3qkmgWSwsJCbrnlFm6//XY++eQTRo0axa233sof/vAHHn30UR566CH+97//ERcXx+WXX+7xoCY3N5fx48ezY8cOnn/+eT777DMuuugi7r33Xp566qkO9/35558zbtw4kpKSvBrrwYMHAS0tzR927NhBeno6mZmZHvP1z2jHjh0e8ztzbnSuueYaxowZw//+9z/mzJnDCy+8wK9+9Ssuv/xyLrroIj766CPOOeccHn74YRYtWtRi/alTp/LFF1+0+jdKEEKa7hW0BEFwR09JaW9yT8dat26dCqjPP/+8x3aOHDmiRkdHqw899FCr+7Hb7arFYlEPHTqkAuonn3zifO+BBx5Qo6Oj1YqKCue83NxcFVBffvll57wnnnhCjYiIUI8fP+6c9/7776uAumrVKq+Oc/369arFYlGrq6vVzz77TE1PT/dI3br55ptVQP3HP/7hsf5//vMfFVD/97//eczfuHGjCqivvvqqqqqqeuDAAdVoNKo33nhju+O5+eabW6S5AWp0dLRHGpnValWHDh2qDhw40Dlv5cqVKqCuXLnSOc/b1DubzaZaLBb1n//8p2o0GtWysjLne+2l3gHqE0884Xx93XXXqZGRkerhw4c9lrvwwgvVmJgY52epj3XmzJkey33wwQcqoK5bt67d8XqTMtWjRw912LBhbb5vtVrVmpoaNTY2Vn3ppZec8/WxffTRR855+fn5qslkUp966innvLi4OPX+++9vd5zejl2/vj744AOPZWfOnKkOGTLE+Xr+/PktvieqqqVC0Sz1bujQoeq4ceNapMRdfPHFalZWlkf61bPPPus85ptvvlmNjo5Wt23b1u5xFBYWqoB63XXXtbvctddeqwLO76e332tvx6+fz5tuuqndcbRGe9eR/t7Bgwed884++2wVUDdt2uScV1paqhqNRjU6OlrNz893zt+6dasKqH//+9+d884//3y1V69eamVlpce+7r77bjUqKsrje9caMTEx6i9/+csW8/XUu8LCQtVisajl5eXqBx98oMbGxqrXX399u9ts7zfivPPO87j+3ImIiFDvuOMO5+vOnhv9GJr/DRk7dqwKqIsWLXLOs1gsanp6unrllVe2GNebb76pAurOnTvbPW5BCDVEURKEIOSf//wnGzdubDGdeeaZHst99tlnKIrCz3/+cw/lKTMzkzFjxng4sRUVFfHLX/6S3r17YzKZMJvN9O3bF4CdO3c6l7v11lupr6/n/fffd85bsGABkZGR3HDDDc55d955JwBvvvmmc94rr7zCqFGjmDJlilfHOWHCBMxmM/Hx8Vx88cVkZmbyxRdf0KNHD4/lfvazn7U47qSkJC655BKP4x47diyZmZnO416+fDk2m425c+d6NZ7mnHvuuR5jMRqNXHvttezbt4+jR4/6tc0ffviBSy+9lNTUVIxGI2azmZtuugmbzcaePXv82ubXX3/NueeeS+/evT3mz549m7q6uhZq1KWXXurxWn9S7Y3K1hFqsyfKNTU1PPzwwwwcOBCTyYTJZCIuLo7a2lqP627q1KmMGTPGQ6V87bXXUBSFO+64wznv9NNPZ+HChfzpT39i/fr1Hqlr/qAoCpdcconHvNGjR3uci5UrVxIfH9/ivLl/H0BTRHft2sWNN94I4HFtzpw5k4KCAo8Ux9/85jdcdNFFXH/99bzzzju8/PLLjBo1qlPHo6N/DnrKpjffa1/HDy2/m11FVlYWp556qvN1SkoKGRkZjB071kO9HjZsGOC6lhsaGlixYgVXXHEFMTExLY6poaGB9evXt7nfiooK6urqyMjIaHOZzMxMzGYzycnJXHPNNZx66qkt0l59pT1HvObv+Xtu3Ln44os9Xg8bNgxFUbjwwgud80wmEwMHDmx1ff38dIdrqSB0JRIoCUIQMmzYME477bQWU2Jiosdyx48fR1VVevTogdls9pjWr1/vTG2y2+3MmDGDRYsW8dBDD7FixQq+//575w2Ce6raiBEjGD9+vDNNx2az8e9//5vLLruMlJQU53I9evTg2muv5fXXX8dms7Ft2zbWrFnjk9OWHhD+8MMPHDt2jG3btjF58mSPZWJiYkhISGhx3BUVFURERLQ47sLCQudx6/VK/jrENU99cZ/nT6rX4cOHOeuss8jPz+ell15izZo1bNy40RkcuH8OvlBaWtqqS5h+k9R8rKmpqR6vIyMjO7V/ndraWkpLSz1uzm644QZeeeUVbr/9dr788ku+//57Nm7cSHp6eov93XvvvaxYsYLdu3djsVh48803ueqqqzw+h/fff5+bb76Zt956i4kTJ5KSksJNN93UZr1QR8TExBAVFeUxLzIykoaGBufr0tLSFsE7tLw+9FTXX//61y2uy7vuugvAoyZQURRmz55NQ0MDmZmZHdYmgZa2FxMT40zvaou8vDxiYmKc31lvvte+jh84Ye507r89OhERES3mR0READg/v9LSUqxWKy+//HKLY5o5cybQ8pjc0a/R5teIO1999RUbN27kyy+/5Gc/+xmrV6/mnnvu8e0A3UhNTW3196W2tpampqYWx+zvuWlvGxEREa1+NyIiIlpdX1+us78hghBsiD24IIQwaWlpKIrCmjVrnDe77ujzduzYwY8//sjChQu5+eabne/rNUHNueWWW7jrrrvYuXMnBw4coKCgoEVhMcB9993Hv/71Lz755BOWLl1KUlKS82m0N+gBYXu09mQ1LS2N1NTUVou2AeLj4wFXrdPRo0dbqC3e0NrNtz6vebDhDR9//DG1tbUsWrTIqeYBbN261edtuZOamkpBQUGL+XotQlpaWqe27y2ff/45NpuNqVOnAlBZWclnn33GE088wSOPPOJcrrGxkbKyshbr33DDDTz88MPMmzePCRMmUFhY2EINTEtL48UXX+TFF1/k8OHDLF68mEceeYSioqI2r4fOkpqayvfff99ifvPrQz/Pjz76KFdeeWWr2xoyZIjz/wUFBcydO5exY8fy008/8etf/5q///3v7Y7FaDQybdo0li5dytGjR1t9CHD06FE2b97MhRdeiNFodM7v6Hvt6/ihfeUjGEhOTsZoNDJr1qw2leV+/fq1ub7+PW/tetUZM2aM89ydd955nH/++bzxxhvcdtttjB8/3ucxjxo1iv/+978UFhZ6BOPbt28HYOTIkT5vs6vRz8+J+q0RhBOFBEqCEMJcfPHF/PnPfyY/P59rrrmmzeX0m5nmwZS7O5k7119/PQ888AALFy7kwIED9OzZkxkzZrRY7tRTT2XSpEk8++yz7NixgzvuuOOE9D+6+OKL+e9//4vNZuOMM85oc7kZM2ZgNBqZP38+EydO9Hk/K1as4Pjx4041wWaz8f777zNgwIB2VSp3hSY6Oto5v7XPQVVVj/RF9214+3T23HPP5aOPPuLYsWMeas4///lPYmJinG6CXcnhw4f59a9/TWJiotOYQlEUVFVtcd299dZbrRpHREVFcccdd/DKK6/w3XffMXbs2BYKozt9+vTh7rvvZsWKFXz77beBPSA3pk2bxgcffMDixYs90u/ee+89j+WGDBnCoEGD+PHHH3n66afb3abNZuP6669HURS++OIL3n33XX79618zderUNoMUnUcffZQvvviCu+66i48++sgjGLLZbNx5552oqsqjjz7qsV5H32tfxh8qxMTEMG3aNH744QdGjx7tVFW8JSIigv79+7N//36vllcUhXnz5jF8+HB+97vf8eWXX/o85ssuu4zf/e53vPPOO06zD9CMN6Kjo7ngggt83mZXc+DAAQwGQ4tAWhBCHQmUBCGEmTx5MnfccQe33HILmzZtYsqUKcTGxlJQUMDatWsZNWoUd955J0OHDmXAgAE88sgjqKpKSkoKn376KcuXL291u0lJSVxxxRUsXLiQiooKfv3rX7dpbXvfffdx7bXXoiiKMz2nq7nuuut49913mTlzJvfddx+nn346ZrOZo0ePsnLlSi677DKuuOIKcnJyeOyxx/jjH/9IfX09119/PYmJieTm5lJSUtKh41VaWhrnnHMOv//974mNjeXVV19l165dLSzCm6PXmTz77LPOp/qjR4/mvPPOIyIiguuvv56HHnqIhoYG5s+fT3l5eavbWLRoEfPnz+fUU0/FYDC0qb498cQTfPbZZ0ybNo3HH3+clJQU3n33XT7//HOee+65FimbnWXHjh3OOo+ioiLWrFnDggULMBqNfPTRR04lLyEhgSlTpvCXv/yFtLQ0cnJyWLVqFW+//XabDmJ33XUXzz33HJs3b+att97yeK+yspJp06Zxww03MHToUOLj49m4cSNLly7tMLjoDDfddBMvvPACN910E//v//0/Bg0axJIlS1q9CX799de58MILOf/885k9ezY9e/akrKyMnTt3smXLFqfN+RNPPMGaNWtYtmwZmZmZPPjgg6xatYrbbruNcePGtatyTJ48mRdffJH777+fM888k7vvvps+ffo4G85u2LCBF198kUmTJnms58332tvxhxIvvfQSZ555JmeddRZ33nknOTk5VFdXs2/fPj799FO+/vrrdtfXHd28ZdCgQdxxxx28+uqrrF271llbeujQITZu3AjgDLx0B82cnBzn93vEiBHcdtttPPHEExiNRsaPH8+yZct44403+NOf/tRqql13s379esaOHUtycnJ3D0UQAks3GkkIgtAMfxvO/uMf/1DPOOMMNTY2Vo2OjlYHDBig3nTTTR5OSLm5uep5552nxsfHq8nJyerVV1+tHj58uIWDms6yZcucTnt79uxpc8yNjY1qZGSkesEFFwTsOHVuvvlmNTY2ttX3LBaL+te//lUdM2aMGhUVpcbFxalDhw5Vf/GLX6h79+71WPaf//ynOn78eOdy48aN83Aqa8v1bu7cueqrr76qDhgwQDWbzerQoUPVd99912O51lzvGhsb1dtvv11NT09XFUXxcPH69NNPnWPu2bOn+pvf/Eb94osvWmyjrKxMveqqq9SkpCTnNtzH1vwz2759u3rJJZeoiYmJakREhDpmzJgWjVD1sf7f//2fx3xvG6c2d2WMiIhQMzIy1LPPPlt9+umn1aKiohbrHD16VP3Zz36mJicnq/Hx8eoFF1yg7tixQ+3bt6968803t7qfqVOnqikpKWpdXZ3H/IaGBvWXv/ylOnr0aDUhIUGNjo5WhwwZoj7xxBMdNiJuy/WutetLdwJr7Tji4uLU+Ph49Wc/+5n63XfftXrefvzxR/Waa65RMzIyVLPZrGZmZqrnnHOOs2HpsmXLVIPB0OIzLC0tVfv06aOOHz9ebWxsbPd4VFVzvbzqqqvUHj16qCaTSc3IyFCvvPJK9bvvvmtzHW++1x2NX1U71zTWH9e7ESNGtFi2b9++6kUXXdRivv7ddefgwYPqrbfeqvbs2VM1m81qenq6OmnSJPVPf/pTh+NdsWKFCqjff/+9x/y2Gs6qqqoeP35cjYuLU6dNm9bi2Fqbmn8Xmpqa1CeeeELt06ePGhERoQ4ePNjDrU6ns+emrWNo67vR2v6qq6vVmJiYFs55ghAOKKoqpveCIPjPp59+yqWXXsrnn3/uLI4OBxRFYe7cubzyyivdPZSTiqKiIvr27cs999zTag8oQegORo8ezeTJk5k/f353DyXoePvtt7nvvvs4cuSIKEpC2CGud4Ig+EVubi5ffPEFDz74IGPHjvWwkRUEXzl69CirV6/mtttuw2AwcN9993X3kATByXPPPcfChQv9bgsQrlitVp599lkeffRRCZKEsEQCJUEQ/OKuu+7i0ksvJTk5mf/85z9B734lBDdvvfUWU6dO5aeffuLdd9+lZ8+e3T0kQXBywQUX8Je//KVDW/aTjSNHjvDzn/+cBx98sLuHIghdgqTeCYIgCIIgCIIgNEMUJUEQBEEQBEEQhGZIoCQIgiAIgiAIgtAMCZQEQRAEQRAEQRCaEfYNZ+12O8eOHSM+Pl6KzQVBEARBEAThJEZVVaqrq8nOzm7RdLs5YR8oHTt2jN69e3f3MARBEARBEARBCBKOHDlCr1692l0m7AOl+Ph4QDsZCQkJ3ToWi8XCsmXLmDFjBmazuVvHIggdIderEErI9SqEEnK9CqFEuF2vVVVV9O7d2xkjtEfYB0p6ul1CQkJQBEoxMTEkJCSExYUmhDdyvQqhhFyvQigh16sQSoTr9epNSY6YOQiCIAiCIAiCIDRDAiVBEARBEARBEIRmSKAkCIIgCIIgCILQjLCvURIEQRAEQRBCB1VVsVqt2Gy27h6KgFajZDKZaGhoCInPxGg0YjKZAtIWSAIlQRAEQRAEIShoamqioKCAurq67h6K4EBVVTIzMzly5EjI9CSNiYkhKyuLiIiITm0nbAOlefPmMW/evJCIfAVBEARBEE527HY7Bw8exGg0kp2dTURERMjcmIczdrudmpoa4uLiOmzQ2t2oqkpTUxPFxcUcPHiQQYMGdWrMYRsozZ07l7lz51JVVUViYmJ3D0cQBEEQBEFoh6amJux2O7179yYmJqa7hyM4sNvtNDU1ERUVFfSBEkB0dDRms5lDhw45x+0vwX+0giAIgiAIwklDKNyMC8FNoK4huRIFQRAEQRAEQRCaIYGSIAiCIAiCIAhCMyRQEgRBEARBEAThhJGXl4eiKGzdurW7h9IuEigJgiAIgiAIQieYPXs2iqKgKAomk4k+ffpw5513Ul5e7rHcG2+8wdSpU0lISEBRFCoqKlpsq7y8nFmzZpGYmEhiYiKzZs1qdbnuYurUqdx///3dPYwTggRKgiAIgiAIgtBJLrjgAgoKCsjLy+Ott97i008/5a677vJYpq6ujgsuuIDHHnusze3ccMMNbN26laVLl7J06VK2bt3KrFmzunr4QitIoCQIQlCz+VA5s97ewK7Cqu4eiiAIgnCCUVWVuibrCZ9UVfV5rJGRkWRmZtKrVy9mzJjBtddey7JlyzyWuf/++3nkkUeYMGFCq9vYuXMnS5cu5a233mLixIlMnDiRN998k88++4zdu3cD8M0336AoCl9++SXjxo0jOjqac845h6KiIr744guGDRtGQkIC119/vUfj3qlTp3LPPfdw//33k5ycTI8ePXjjjTeora3llltuIT4+ngEDBvDFF1/4dNw5OTk8/fTT3HrrrcTHx9OnTx/eeOMNj2W+//57xo0bR1RUFKeddho//PBDi+3k5uYyc+ZM4uLi6NGjB7NmzaKkpMR5zBEREaxZs8a5/PPPP09aWhoFBQU+jdcXwraPkjScFYTw4N0Nh1izt4RFW/J5bGZCdw9HEARBOIHUW2wMf/zLE77f3D+cT0yE/7fJBw4cYOnSpZjNZp/WW7duHYmJiZxxxhnOeRMmTCAxMZHvvvuOIUOGOOc/+eSTvPLKK8TExHDNNddwzTXXEBkZyXvvvUdNTQ1XXHEFL7/8Mg8//LBznXfeeYeHHnqI77//nvfff58777yTjz/+mCuuuILHHnuMF154gVmzZnH48GGfelk9//zz/PGPf+Sxxx7jww8/5M4772TKlCkMHTqU2tpaLr74Ys455xz+/e9/c/DgQe677z6P9QsKCjj77LOZM2cOf/vb36ivr+fhhx/mmmuu4euvv3am+82aNYsff/yRvLw8fvvb3/Kf//yHrKwsn86xL4StojR37lxyc3PZuHFjdw9FEIROcLCkFoD8ivpuHokgCIIgtM1nn31GXFwc0dHRDBgwgNzcXI8gxRsKCwvJyMhoMT8jI4PCwkKPeX/605+YPHky48aN47bbbmPVqlXMnz+fcePGcdZZZ3HVVVexcuVKj3XGjBnD7373OwYNGsSjjz5KdHQ0aWlpzJkzh0GDBvH4449TWlrKtm3bfBr3zJkzueuuuxg4cCAPP/wwaWlpfPPNNwC8++672Gw2/vGPfzBixAguvvhifvOb33isP3/+fE455RSefvpphg4dyrhx4/jHP/7BypUr2bNnj/N4U1JSuOOOO7jxxhuZNWsWV1xxhU/j9JWwVZQEQQgP9ECpQAIlQRCEk45os5HcP5zfLfv1lWnTpjF//nzq6up466232LNnD/fcc4/P21EUpcU8VVVbzB89erTz/z169CAmJob+/ft7zPv+++/bXMdoNJKamsqoUaM81gEoKiryaczu21UUhczMTOc2du7cyZgxYzwUqokTJ3qsv3nzZlauXElcXFyLbe/fv5/BgwcTERHBv//9b0aPHk3fvn158cUXfRqjP0igJAhC0FJR10RFnQWAgsqGbh6NIAiCcKJRFKVTKXAnktjYWAYOHAjA3//+d6ZNm8ZTTz3FH//4R6+3kZmZyfHjx1vMLy4udgYxOu5pfYqitEjzUxQFu93e5jqtracHY83X64j29u1NvZfdbueSSy7h2WefbfGee2rdd999B0BZWRllZWXExsb6NE5fCdvUO0EQQh9dTQI4XtWA1ebbD7cgCIIgdBdPPPEEf/3rXzl27JjX60ycOJHKykoPJWjDhg1UVlYyadKkrhhmlzN8+HB+/PFH6utdmSHr16/3WOaUU07hp59+Iicnh4EDB3pMejC0f/9+fvWrX/Hmm28yYcIEbrrpJp8DOl/p1kDpmWeeYfz48cTHx5ORkcHll1/udPRojV/84hcoinJCpDZBELof90DJrkJRdWM3jkYQBEEQvGfq1KmMGDGCp59+2jmvsLCQrVu3sm/fPgC2b9/O1q1bKSsrA2DYsGFccMEFzJkzh/Xr17N+/XrmzJnDxRdf7GHkEErccMMNGAwGbrvtNnJzc1myZAl//etfPZaZO3cuZWVlXH/99Xz//fccOHCAZcuWceutt2Kz2bDZbMyaNYsZM2Zwyy23sGDBAnbs2MHzzz/fpWPv1kBp1apVzJ07l/Xr17N8+XKsViszZsygtra2xbIff/wxGzZsIDs7uxtGKghCd5BX4vlbUFApdUqCIAhC6PDAAw/w5ptvcuTIEQBee+01xo0bx5w5cwCYMmUK48aNY/Hixc513n33XUaNGsWMGTOYMWMGo0eP5l//+le3jD8QxMXF8emnn5Kbm8u4ceP47W9/2yLFLjs7m2+//Rabzcb555/PyJEjue+++0hMTMRgMPD//t//Iy8vz2k7npmZyVtvvcXvfvc7tm7d2mVjV1R/jOK7iOLiYjIyMli1ahVTpkxxzs/Pz+eMM87gyy+/5KKLLuL+++/3uiNwVVUViYmJVFZWkpDQvdbCFouFJUuWMHPmTJ/tIk9Wth2t4PZ3NvHbi4Zx2die3T2ck4pguF7vfm8Ln21z9Ud4+fpxXDJGHpYILQmG61UQvEWu19ZpaGjg4MGD9OvXj6ioqO4ejuDAbrdTVVVFQkICBkNoVO20dy35EhsEVXVcZWUlACkpKc55drudWbNm8Zvf/IYRI0Z0uI3GxkYaG13pOVVVWpNKi8WCxWIJ8Ih9Q99/d48jlFiy7RhF1Y28unIfM0e0tMsUuo5guF4PltQAEBdpoqbRytGyWvn+CK0SDNerIHiLXK+tY7FYUFUVu93e5bUngvfomor+2YQCdrsdVVWxWCwYjZ4Ohr5874ImUFJVlQceeIAzzzyTkSNHOuc/++yzmEwm7r33Xq+288wzz/DUU0+1mL9s2TKfGmd1JcuXL+/uIYQMm/YaAAO7j9ew8H9LyIju7hGdfHTX9aqqsO+4EVDIiWliR6OBdT/uIrsqt1vGI4QG8vsqhBJyvXpiMpnIzMykpqaGpqam7h6O0Izq6uruHoLXNDU1UV9fz+rVq7FarR7v1dXVeb2doAmU7r77brZt28batWud8zZv3sxLL73Eli1bWvWUb41HH32UBx54wPm6qqqK3r17M2PGjKBIvVu+fDnnnXeeSO1e8u+3N0JJOQBNGcOYeVa/bh7RyUN3X6/F1Y00rl+FQYFLzhjKjqV7iEzOZObMsSd8LELw093XqyD4glyvrdPQ0MCRI0eIi4uT1LsgQlVVqquriY+P9/p+vLtpaGggOjqaKVOmtJp65y1BESjdc889LF68mNWrV9OrVy/n/DVr1lBUVESfPn2c82w2Gw8++CAvvvgieXl5LbYVGRlJZGRki/lmszlofoyCaSzBTmGVq3fOV7uKmXvO4G4czclJd12vRyu1J1fZSdH0z9AechyvbpTvjtAu8vsqhBJyvXpis9lQFAWDwRAytTAnA3q6nf7ZhAIGg8HZI6r5d8yX71y3BkqqqnLPPffw0Ucf8c0339Cvn6daMGvWLKZPn+4x7/zzz2fWrFnccsstJ3KoQjdgt6sUujUZ/eFwBYWVDWQmylOmkwG9PqlfWixZjs/8WIU0nRUEQRAE4cTQrYHS3Llzee+99/jkk0+Ij4+nsLAQgMTERKKjo0lNTSU1NdVjHbPZTGZmZsh6yQveU1LTiMWmYlBgVM9EfjxayfLcQmZNzOnuoQkngIMlWg5xv7RYspO04rSSmkYarTYiTcb2VhUEQRAEQeg03aqfzZ8/n8rKSqZOnUpWVpZzev/997tzWEKQkF+h9czpkRDFRaOzAFj6U2F3Dkk4geg9lPqlxZIcYybSpP1cuauMgiAIgiAIXUW3p975Smt1SUJ4UuC4Ic5KjOL8EZk8vWQX6w+UUVHXRFJMRED3tflQOfO/2U+9xYrFpmK12bHYVCw2O1a76/X0YRk8ddnIjjcodJqDjkApJy0WRVHITormYEktxyoa6Jsa282jEwRBEAQh3AkKMwdBaI1jDkUpOymavqmxDM2MZ1dhNV/tLOKqU3t1sLZvvPL1XlbuLu5wuXfWHeKxi4ZJ6lcXY7er5JU6FCVHUJSVGMXBkloKKuu7c2iCIAiCIJwkSKAkBC164b5en3L+iEx2FVazdEdhwAOlvFKtHubecwcxpEc8JqOC2ahgNhowGQyYjQrXvbEeq12lrLaJrERp6NSVFFQ10Gi1YzIo9ErWzrV+zgsk9U4QBEEQWmXhwoXcf//9VFRUAPDkk0/y8ccfs3XrVgBmz55NRUUFH3/8cbeNMZSQQEkIWnTlINvheHbByExeWrGXNXuLqW20EhsZmMvXZlc5Wq4FSteO703PpNaDoNS4CI5XNVJaI4FSV6PXJ/VJicFk1GqTspN05ztRlARBEITgoaPeQjfffDMLFy48MYPpgJdeesmv0peTlbANlObNm8e8efOw2WzdPRTBT/Qb4ixH4DI0M54+KTEcLqtj1Z5iZo7KCsh+CirrsdhUzEaFzIS2rcdTYyM5XtVISU1jQPYrtM1BNyMHHVGUBEEQhGCkoKDA+f/333+fxx9/nN27dzvnRUd7Ply1WCzd1j8rMTGxW/YbqoRG1yg/mDt3Lrm5uWzcuLG7hyL4yTHHDXG24wZZURQuGJkJwJcBdL87XKapSb2TYzAa2n4qlBqnGUiU1jQFbN9C67gbOehkiaIkCIJw8tJU2/ZkafBh2fqOl/WRzMxM55SYmIiiKM7XDQ0NJCUl8cEHHzB16lSioqL497//DcCCBQsYNmwYUVFRDB06lFdffdW5zby8PBRFYdGiRUybNo2YmBjGjBnDunXrPPa9cOFC+vTpQ0xMDFdccQWlpaXtjnX27NlcfvnlztdTp07l3nvv5aGHHiIlJYXMzEyefPJJj3UqKyu5//77yczMJCEhgXPOOYcff/zR5/MUioStoiSENo1WG8XVmnKjp1wBnD+iB2+sPsDXO4tostqJMHU+1j/sqE/qnRLT7nJpcZEAoiidAPJaCZSyRVESBEE4eXk6u+33Bs2AG//P9fovA8FS1/qyfc+EWz53vX5xFNQ1Cy6erPR/nG3w8MMP8/zzz7NgwQIiIyN58803eeKJJ3jllVcYN24cP/zwA3PmzCE2Npabb77Zud5vf/tb/vrXvzJo0CB++9vfcv3117Nv3z5MJhMbNmzg1ltv5emnn+bKK69k6dKlPPHEEz6P7Z133uGBBx5gw4YNrFu3jtmzZzN58mTOO+88VFXlkksuIT4+ns8++4zk5GRef/11zj33XPbs2UNKSkogT1PQIYGSEJQcr9SCkUiTgZRYlxX4uN7JpMdHUlzdyHf7S5g6JKPT+zrkUJT6prYfKKU6xlFaK4pSV6MrSv3dAyVHwFxZb6GuyUpMhPx8CYIgCKHB/fffz5VXXul8/cc//pHnn3/eOa9fv37k5uby+uuvewRKv/71r7nooosAeOqppxgxYgT79u1j6NChvPTSS5x//vk88sgjAAwePJjvvvuOpUuX+jS20aNHOwOsQYMG8corr7BixQrOO+88Vq5cyfbt29mzZw/p6ekYDAb++te/8vHHH/Phhx9yxx13dOq8BDtypyEEJccqXdbg7kWSBoPC+SN68O/1h/nyp8KABEp66l2fDhSlVFGUTghWm935mbgrSvFRZuIjTVQ3WjlW0cDAjLjuGqIgCIJwonnsWNvvKc1advxmXzvLNstEuX+7/2PygdNOO835/+LiYo4cOcJtt93GnDlznPOtVmuLGqLRo0c7/5+VpdVmFxUVMXToUHbu3MkVV1zhsfzEiRP9CpTcycrKoqioCIDNmzdTU1PDgAEDPJapr69n//79Pu0nFJFASQhKnEYOiS3NFc4fkcm/1x9mee5x/nS52m5dkTfoqXcdB0pSo9ScynoLCVGmDh1/fCG/oh6rXSXSZCCrmblGVlIU1cdrKKisl0BJEAThZCLCh0bjXbVsJ4iNde3HbrcD8Oabb3LGGWd4LGc0egZ97qYP+t9aff1Audc1N5ZQFMW5D7vdTlZWFosXLyYuLg6DwRVoJiUlBWT/wYwESkJQotehZLdi1T2hfyoJUSZKaprYfKic0/t1Lj/WqSh1kHqXpgdKtaIoAWw/Wsnlr37LzRNzePyS4QHb7gG9Pik1FkOzIDgrMZo9x2soqJA6JUEQBCE06dGjBz179uTAgQPceOONfm9n+PDhrF+/3mNe89ed5ZRTTqGwsBCTycTAgQM9AqWTAQmUwpCSmkasNpXMVtSYUEFXlLJbOQaz0cD0YT1Y9EM+S3cUdipQqqyzUFlvATpWlHQzB1GUNH44Uo7NrrL5UFlAt+sycmj5eTh7KVWK850gCIIQujz55JPce++9JCQkcOGFF9LY2MimTZsoLy/ngQce8Gob9957L5MmTeK5557j8ssvZ9myZT6n3XXE9OnTmThxIjfeeCPPPfccw4YN49ixYyxZsoTLL7/cI6UwHDm5wsKTAJtd5aK/r+H8F1fTYAndHlLNeyg153w3m/DOSM+6mpQWF9mhOUCqW6AkzdqgxOFKqLsTBgpXD6WWqXV6LyWxCBcEQRBCmdtvv5233nqLhQsXMmrUKM4++2wWLlxIv379vN7GhAkTeOutt3j55ZcZO3Ysy5Yt43e/+11Ax6koCp999hmTJk3i9ttvZ/DgwVx33XXk5eXRo0ePgO4rGAlbRelkbThbXN3I8SrtxvVwWR2De8R384j8o73UO4Apg9KJMhvIr6jnp2NVjOzpXwO1Q2XaTXlHjnfgcr1rstmpbrSSENU9zeKChWKHslbiCBwDVafkCpRafiZ6zZpYhAuCIAjByOzZs5k9e7bzdU5OTpsPV2+44QZuuOGGVt9rbb2kpKQW82699VZuvfVWj3kPPvig8/9PPvmkR1+khQsXeiz7zTfftNj3xx9/7PE6Pj6eZ599lvnz5590qXdhe7Qna8NZ95Sko+Vt9BAIAfLbSb0DiI4wMnWw5njXmeazuqLUt4O0O4Aos5G4SO3ZgqTfQanD/a/JZqeqwRqw7eaVtq0o6YGzKEqCIAiCIHQ1YRsonay430Dml4fmzWR1g4Vqx413W6l3ABc40u+W7uhEoORls1kdl/OdGDq426QHKv2u0WpzXret1Si5K0qS/igIgiAIQlcigVKY4e4GdjREn7rraVUJUSangtMa04ZmYDIo7C2qYX9xjV/7Ouxls1kdPf1OeilpKXeu/wfmfBwpq8OuQmyEkXRHTZg7eo1SXZONqvrAqViCIAiCIAjNkUApzMgPA0XJ6XjXjpoEkBhtZtLANMD/9LtDXvZQ0nE1nZXUO/fgKFCB0sES7fPolx7bas1TdISR5BitNkyc7wRBEARB6EokUAozCtxuHvNDXFHqKFACOH+E5rjypR/pd01Wu/N8ddRDSSdNms4CUNdkpa7JZZQSqNS7gyWaMpiT2nYDQF1VKpBASRAEISyR1GqhswTqGpJAKcw45pZ6F+qKUpYXfaDOG94DRYEfj1b6fOOcX1GPXYVoc+tpXq2RGuuwCD/Jm86WVHsGioFWlPqntR0oOXspSdNZQRCEsMJs1jIG6upC14xKCA70a0i/pvwlbO3BT1bcg4Wi6kYaLDaizMZuHJHv6DfA3ihKGfFRjMhOYEd+FVsOVXDR6I7X0TnkcFfrkxLjtbV1qihKABQ3C4yaB07+4lSU2gmURFESBEEIT4xGI0lJSRQVFQEQE+P932eh67Db7TQ1NdHQ0BD09uCqqlJXV0dRURFJSUkYjZ27B5ZAKYxosNictTNGg4LNrlJQ2UC/dm46gxFXjVLHihLAyOxEduRXkVtQyUWjs7zez5Ey3xzvQGtMC2Lm0Nz1r3ng5C95DkWpvUBJD6ALRFESBEEIOzIzNUdbPVgSuh9VVamvryc6OjpkAtekpCTntdQZwjZQOhkbzhY6anuizUayk6LYX1xLfnl9yAVKulKgKwcdMSI7AYCfjlX5tB/dyMFbxztwU5RqT25FSQ/IzUYFi00NSOBY12SlsEq7hr1KvRNFSRAEIexQFIWsrCwyMjKwWCzdPRwBsFgsrF69milTpnQ6le1EYDabO60k6YRtoDR37lzmzp1LVVUViYmJ3T2cE4Kzticpip7JMVqgVBFaeb6qqnLMEfD19CL1DmB4tvb5+hoo6dbg3jregUtR6so+St/uK2FQRhwZCd4pat2BHhgNSI9jV2E1JQEwc9DVpKQYM0kxEW0u50q9E0VJEAQhXDEajQG72RU6h9FoxGq1EhUVFRKBUiAJ7kRDwSfcA4xeydrNZKgZOpTWNtFktaMo0MPLQGFYVjyKojmvFVV7f/PsDJR8UZQcfZTK6yxYbXav1/OWlbuLuPGtDTz20Y6AbzuQ6IHSsKwEx+umTjvM5DlqxjpSQN2bztrt4owkCIIgCELXIIFSGOHuFqerMaHWdFavO0mPiyTC5N3lGRNhcqZqeasqqarql6KUFBOBwZGeW1YX+PS7ZY5+ULsKfVPHTjR6oDQ0Mx6AJpu90w1gD5Y4AqV2rMEBMhOjUBTN3v1kT4EUBEEQBKHrkEApjNBre7JDWFHKd6YPeu9eBzDCkX6X62WgVFLTRF2TDUXBea68wWhQSHGoSoFyetNRVZVVu4sBOF4V3GqJfuzZSdHER2kZvMU1nUuF0wOl9owcAMxGg9POXZzvBEEQBEHoKiRQCiPydVvtxGiXohRigZIz2POih5I7wx2GDt4GSrqalJUQRaTJtxzoruqltL+4xpk+GSiDhK6ixHHsaXGRzqCluJOBY16Jd6l34AqkpZeSIAiCIAhdhQRKYURBhUtR6ulQSQqrGrqklqar0Av0vemh5I7L+a7Sq+UPlzl6KPlQn6TTVb2UVu0p8Xh9LIjNCnTzhvT4CNLiA2OZftCHQCnbWacUWg8CBEEQBEEIHSRQChNUVfVwvcuIj8Lk6KV0PACOZCeKfLc6K1/QU+/ySuuobujYTtRpDZ7iu3V6ahf1Ulq1p9jjdWGQBgGNVhtVDVo9Umqsu6Lk//morLc46406Sr0Dcb4TBEEQBKHrkUApTKhqsFLbpPWMyk6MxmhQyHL0mwmlOiVdFfPWGlwnJTbCGVztLKjucHl/HO90dOe7QBoJNFhsbDhQCsCgjDiga9PKSmoaeX7Zbp9cAnV0Jc1kUEiMNpPmUNg6EzjqaXfp8ZHERXbctcDZSynEzEoEQRAEQQgdwjZQmjdvHsOHD2f8+PHdPZQTgn7DmBxjJjpCq7nplaQFAaHUS0kPDnw1cwDf0u8Ol/rueKeTHh/4XkobDpbRaLWTlRjFlMHpQNemlf3xs1xe/nofb6856PO6ekCUGheBwaA4z0enAqVS7xzvdERREgRBEAShqwnbQGnu3Lnk5uaycePG7h7KCcHd8U6nZ4g531lsdqfCoSsGvuBL41l/rMF1nIpSAGuUVjvS7qYMSncqY11Vo1TVYGHpDs2GXE9B9AU9INKb76YFIPXOl/okwKmWFgRQUapptLKzILht2QVBEARBOHGEbaB0sqE73ulP2oGQc747XtWAXQWzUSHN4SznCy5Fqf2b3fomG0WOm/q+fpk5OBSUAKbe6fVJZw9Jdwa7gQwC3Pl8WwGNVs3gwx/VqsQRIOoBkktR8v98eGsNrpPtuM6PVzdiC4CNekVdE5e+vJYLX1rDjnzvDEEEQRAEQQhvJFAKE1y1PS4lxqkohUgdh55GlZkYhUHv6uoDw7O0QGlfUTVN1rad/o6UaypKfJSJxGizz/txud4FJvUuv6KefUU1GBSYPCDNqSgVdpGi9H+bjjj/749q1ZaiFIgapX5p3gWu6fGRTrMSf+qs3LHY7Nz17hYOOMawKa+sU9sTBEEQBCE8kEApTDjWSqPWXkmhlXqnH0N2ou/1SaA1jk2MNmOxqew53rahg9PxLjUGRfE9INPVrpKaRlS182qGnnY3tncSiTFmp6IUKLXEnf3FNWw5XOF8XVLT2G5Q2Rp6s9m0+AjHv507H6qqOoOUfmlxXq1jNCj0SNANHfwPlFRV5fFPfuK7/aXOebuP1/i9PUEQBEEQwoduDZSeeeYZxo8fT3x8PBkZGVx++eXs3r3bY5knn3ySoUOHEhsbS3JyMtOnT2fDhg3dNOLg5Vgr/YfcFaVA3NB3NfoNr689lHQURXGqSu01nu1MfRK4FKUGi506h9NgZ9ADpbMHZwCaQhMotaQ5/9t8FICpQ9KJMBlQVS3l0RecilKsrihp58NiU6ms79iavTlltU1UO+zGfUmF1OvYOmN6seDbPP7z/WEUBa4c1xOg3SBbEARBEISTh24NlFatWsXcuXNZv349y5cvx2q1MmPGDGpra53LDB48mFdeeYXt27ezdu1acnJymDFjBsXFxe1s+eTDpca4Uu+yEqNRFGi02jtVP3KicBlS+G7koOON891hh8NaHz96KAHERBiJMmtfnc4aOlhtdtbu0xrNThmcBgROLWmOza6yaEs+ANec1ttlGuFjaqYzUHIoSpEmIwlRJo/3fEF3vOuZFE2U2ej1ek7nOz/P0crdRfzp81wAfjtzGL84ewAAewqrQ+LBgiAIgiAIXUu3BkpLly5l9uzZjBgxgjFjxrBgwQIOHz7M5s2bncvccMMNTJ8+nf79+zNixAj+9re/UVVVxbZt27px5MGFza46VQF3NSbCZKBHvKOXUgjUKTnTB/1MvQMY0bNjQ4fOKkqKopCqp9/Vdq5OaeuRCqobrCTFmBndK8k5Xw9iAmkRvnZfCYVVDSTFmDl3WIbbPvxUlOJchht6+l2RH853B4p1IwffPg9nnzA/ru3dhdXc894P2FW49rTe3HZmP/qlxWIyKFQ3WsV2XBAEQRAEOu7seAKprNRUgJSUlFbfb2pq4o033iAxMZExY8a0ukxjYyONja6btaoq7YbZYrFgsfieFhRI9P0HehzHqxqw2FQMCiRHGTy2n50URWFVA4dLqhmR6Z+CcqLQa6ky4sx+n6Mh6dox7iyoorGxqVVTiEO6gpEY4fd+UmPN5FfUU1RRhyXLu7qa1li56zgAk/unYrdZsTsy+XokaIFHflltwK6XDzYeBuCSUZkYVDuZjuDmaBv7aOt61QOlpCij87202AgOFNdyvKLO5/EeKNJS3fokR/u0bg9Hyl9+uW/7LK1p5LaF31PTaOX0nGQev2gIVqsVBc1MYm9RLT/ll5MeG1Q/j0IHdNXvqyB0BXK9CqFEuF2vvhxH0NwJqKrKAw88wJlnnsnIkSM93vvss8+47rrrqKurIysri+XLl5OWltbqdp555hmeeuqpFvOXLVtGTIx/CkKgWb58eUC3l1cNYCLBrLLsy6Web9YaAANfrfsB9XBwpxMdLjECCvu3baR+v3/bsKlgVozUNtn450dfkNFMnLKrcKjUsZ8fN1Cxu9XNdIjVcV6/Wb+ZxoP+n9dPt2ljSazPZ8mSo8759aXa9r/7cReZlbl+b1+nzgpf7tD21aPuIEuWHKS2RNvH+m276V2zs8113a9Xmwrltdp2tq5fwwEtVsFSrW1r9catGI7+4NPY1u3W1q0vOsSSJXler3esTAGM7Dp8nCVLlni1jtUOr+QaOVqtkBapcnlaMV8tc31n4mzaWD5dtYm6fcH9fRFaJ9C/r4LQlcj1KoQS4XK91tV530MyaAKlu+++m23btrF27doW702bNo2tW7dSUlLCm2++yTXXXMOGDRvIyMhoseyjjz7KAw884HxdVVVF7969mTFjBgkJCV16DB1hsVhYvnw55513Hmaz77bUbfHFjkLYsY0BmcnMnHm6x3u5pr1sWXOQhKwcZs4cFrB9Bpr6Jhu161YAcM3F55Hgh223zsIj69mWX0XG4FOYOSrT472CygZs61djMihcf9kFmIz+ZZ+uafyJ3C35ZPcfwsyz+/u1jbLaJo6s/waAu66c5qxLAihed4ivj+0mKjmTmTPH+rV9d977/ghWdSeDM+K44+qJKIpCxfdHWJ6/k4ikHsycOa7FOq1dr8XVjajrV6EocPWlF2J0KHab1F38UHqYjN4DmTljkE9jm39wHVDNhWedxjlD0r1er++xKt7avZ56JZKZM6d2uLyqqjy8aAcHqwuIjzLx7zvOYEC6p8p6MOYAP6zYhyG5FzNnjvLpOITupat+X91RVZV1B8oYmhlPiqPxtCD4w4m4XgUhUITb9apnm3lDUARK99xzD4sXL2b16tX06tWrxfuxsbEMHDiQgQMHMmHCBAYNGsTbb7/No48+2mLZyMhIIiNbNis1m81B8+EGeixFNZqEmJ0c02K7vVO1G8GCysagOf7WOFyhpXPFRZpIiY/2y7ZbZ0TPJLblV7GrqJbLmh1zfqX25eiVHE10lO9NbXXSHUFNeb3V7/O6Pq8IVYWhmfH0So33eK9XipbOV1jdFJDP7aOtBQBcM743ERHaDZ5+bRRWtX9tuF+vFQ1aemRKTARRka4bxUxHXVlZncWn8aqq6rRrH9Qjwad1e6dq56ikpgm7YiDS1L4RxKvf7OOjrQUYDQqv3ngKQ7OTWiwzPDsRgL3FtUH9fRHapit/69ftL+XmhZu5YEQmr806tUv2IZxcBNO9iSB0RLhcr74cQ7eaOaiqyt13382iRYv4+uuv6devn9frudchnezoxeytucWFStNZl5FDVKeCJHB3vmv5xOCIw8iht59GDjqpsXrTWf9d71bv0dzuzh7cUkVxWl8H4HPbV1TN1iMVGA0Kl43t6ZzvdI3zwTCiNSMH7XWEx/vecryqkXqLDaNB8fkzSYmNINKk/YQdr2x/v9/tL+G5pVqe5ROXDOesQa0rV0MytYB1b1FNwHtYCaHP4TKtvvFAifTaEgRBOBno1kBp7ty5/Pvf/+a9994jPj6ewsJCCgsLqa/Xbtxqa2t57LHHWL9+PYcOHWLLli3cfvvtHD16lKuvvro7hx5U6PbIrTVq7a0HSkHedFY/hiw/eyi5owdKuccqW9g8H3Lc6PjSr6c19ECh1E/XO1VVWb1Xs7if0kqgpAcxxTWNWGy+NYRtzv85eidNG5JBerwrwNGvl/I6C/Ve9oNqbg2uo5+PYh8DJXdrcLOPaZCKorgsztsJ9lRV5VlHkHTtab25aWJOm8v2To4hymygyWp3mn4Igo7e76uzbQEEQRCE0KBbA6X58+dTWVnJ1KlTycrKck7vv/8+AEajkV27dvGzn/2MwYMHc/HFF1NcXMyaNWsYMWJEdw49qDjm7D/UMsjQ51U3Wv1qBnqi0BWvnp3ooaQzNDMBg6KlZDW3qz5cpu3HX2twHb3pbEm1fzdMOwuqKa5uJNps5LSc5Jbbj40gwuhfQ1h3rDY7Hzl6J111qmdaa0K0idgILV3NW1VJv0FsrijpAZiv50MPRnLS/HNk9EYV+3pXET8eqSDabOTX5w9pd3sGg8LgHpqqJI1nheZUOQKlsromURwFQRBOArq1Rqmjpo5RUVEsWrToBI0mdNGbkmYltgwyYiJMpMRGUFbbxNHyOhKjE0/08LxCv9HtTA8lnegIIwPS49hbVMNPxyo9TBI622xWR++j5K+itGqPpiZNHJDaam2NwaDQIzGSI2X1FFQ20CvZv8Buzd4SiqobSYmN4JyhnuYniqKQlRTNvqIaCiob6J/esc1526l3kc737Xa1VVv21shz1Cfl+Knw6b2U2mrMq6oqf1u+B4CbJvX1UNTaYnCPeLYdrWRXYTUXjMzya1xCeFLdoD1sUlUor2tq8T0QBEEQwotuVZSEztNotTlvXnu2kbamzw/m9Du9wWdrqpg/DHem33nWKXW22ayOXpNTVuvfk+XVjkCptfokHT1oPNaJOqUPHWl3l43NJsLU8uvuTF3zch/FbQRKusJmtas+KZe6otQ31b/ANbsDRWlZ7nF+OlZFbISRX0wZ4NU2h4iiJLRBVb3V+X9JvxMEQQh/JFAKcQodAUaU2UBSTOsuHs5AKYgNHZyGFK2oYv7QmqFDVYOF8jrtJr5PJ2uUkh1mDnYVKup8u2GqbbSy6VAZ0Hp9ko5+LvTP2Fcq6ppYnqs1tG2edufahx5oeLePEmfqnWeNUqTJSKLD0t0XQ4e8Ei1w7Zfm3+ehB9YFrShKdrvKCw41afbkHK/tnAc7DB12F0qgJHiiK0rgv5osCIIghA4SKIU4Lse7ti21ewa5oYOqqi5DigApSiMcNs/ugdJhR5pXamwEcZGdyzo1G12BaWmtb4HSuv2lWGwqfVJi2k05040tvA1imrP4x2M02ewMz0pwno+W+3C463lZo1RS3bqipM3TApHiau9uIDVr8M4pSs7Uu1bO0Rc7CtlVWE18pIk5Z3nf62qoI1DKK62jweKdyYVwcqCbOYAoSoIgCCcDYRsozZs3j+HDhzN+/PjuHkqX0p7jnU6vILcIr6izUO+4Ic0MsKJ0uKyOKsdTYGfaXSfVJB3dItxXS2yX211au1bo2T6mxTVHT7trS03S9qGn93mrKLUdKOn1P94635XUNFHbZMOguK5RX2kr9c5mV3nhK01NuvXMfiTFeN8cNCM+ksRoMza7yoFicb4TXFQ3uilKPn7vBUEQhNAjbAOluXPnkpuby8aNG7t7KF3KsXZ6KOkEe+qd7tqXGhtBlLn9pqHekhQT4TxuvU4pUPVJOk6LcB+fLOtGDlPa6OWjk+ljWpw7uwur2Xa0EpNB4bKx2W0u54uiZLerTvWsuT04uBs6eHc+dDUpOym6w2axbaGPv6LOQl2T62n/Z9uOsa+ohoQoE7ed5V1/Nh1FUaROSWgVjxolH5VkQRAEIfQI20DpZEFPOWrPLS7YU+8CnXanM7xZndIhR+pd34AHSr7U5NRyqLQOk0Fh0sC0dpfVjRZ8aQir8+HmIwCcOyyD1HacuZz22l4oSpX1Fqdxhe76546zl5KXqXcHSxzW4H6m3QEkRJmdaZS6Kma12Xnxq70A3DGlPwlRvncRH5ypOQDulkBJcMO9RsnbBwKCIAhC6CKBUohzzNl/qJ3UuyQtMCitbfJ46h4sHHNagwcm7U5neJYeKFUCcNjRbLZ3gAIl3enNlyfLetrdqX2TO6yT0gPHkpomGq3e18pYbXY++uEYAFed2ruDfWjnvLrR6kxRbAs97S4x2tyqg56zl5KXgaMzcO1kKmTzgPLjrcc4WFJLcoyZ2ZN9U5N0dEVJDB0EHVVVm9UoSeqdIAhCuCOBUojj7D/UTupdQrTJ7al78KlKx7pIURrRzCJcT73z1zigObqq4suTZact+JD20+4AkmPMRDoCkuOV3t+U7SyopqSmkYQoE1M72E9MhMnpVteRquSyBm+93ic9zrdAKa+084oSuJleVDRgsdn5+wpNTfrF2QP8Nu0YLIGS0IwGix2rWysASb0TBEEIfyRQCnG8CTIURXEqTkeDMP3OmzorfxjRU3N621dUQ22j1XmuAlWjpCtK3gYGdrvKhgOaLfhZAzsOlBRFcfU58iH9bmeBFhiO7JmI2djxV9zbfegBYVupfHrdkrepd4FSlLLdxv+/zUc5XFZHWlwEN03s6/c2hzic7/Ir6j3SrYSTl+aKqyhKgiAI4Y8ESiFMVYOFmkYtFaQ91zsIbuc7pyrWwTH4SnZiFEkxZqx2lZW7i7DZVSJNBjLi267Z8QVdWfH2hulIeR3VjVYiTAaGZsV7tU5WBw1VWyPXESgNc6QedkR7vYjc0a3B09sIlNLjtIDFm8BRVVWXopTWSUXJcY4Ol9bx8tf7APjl2QOIifDfAj4pJoIeCdpx7i2q6dT4hPCgecAs9uCCIAjhjwRKIYyuxCTHmImOaN81LJgNHboq9U5RFGf63Rc7CgFNTTIY2rbk9gVdWfE2BUdPARzSI94rpQfc+gR5ad8NLkXJ20DJW9OIkg5S73RFqbSmCbtbilJrlNdZnPUenVX49HP06bZj5FfUkxEfyc8n+K8m6ejpd3sk/U4AqhzXa0KUFoBXN1qlz5YgCEKYI4FSCKMrAN4oMcFqEW6zqxRW6YFSYFPvwNV4duWuIiBwaXfg6qPk7ZNl3X1vuJcBDLiUwkIvLcJVVXULlLxTrfQAtaNgTD/O1noogatmy2pXqahvP11NV5OyEqM6bQmvnyOLTQvO5k4bGBCbeaehgzjfCbiazWYnRWM2ag9byqROSRAEIawJ20DpZGg4m++s7fEiUApSRam4uhGbXcVoUMiI74pASQtK6pq0J7+BajYLLkWpxssny3pK3Iie3gdKvvQ5As0uvqrBismgMDAjzrt9+KootZG6GGEykBRj9li2LfQeSp2tTwJPI5OsxCiuHd++05+3DM6UXkqCiypH8J8YbSbFx4ckgiAIQmgStoHSydBwVr+x9UaJCVYzBz3Yy0yIwhiglDh3mqs3gVSUEqJMRDhS6LxJv9Ntyn1RlJxGC16m3u10qFYDM+K8buKa5WVjW1fqXds1Xs6msx0YOuSVaEYOnXW8A8/6vLvPCYyaBGIRLniiK0rxUWaX42WtGDoIgiCEM2EbKAUrw459gHHRbbDln1CZ36lt+VLboytKx6sbaLLaO7XfQFLQRT2UdPqnxxFldl3mgVAwdBRFcfVS6kBBKalp5HhVI4rife0Q+G7m4Gt9ErgC7WMV9ahq27VFJc7Uu9ZrlMBl9FDstaLU+UApOsLIrZP7cdGoLK7uoG+ULwzqEYeiaMftrbOhEL7oZg4JUSa3770oSoIgCOGM/7ZQgu+oKj3L12M4XgI7P9HmZQyHAefAwOnQdxKYvHdk080cvAky0mIjiTAZaLLaKaxsCGgKWmc45kP6oD8YDQpDMxPYeqQCCKyiBJpFeEFlQ4c3TLqRQ7/UWGJ96O2jqyXldRYaLLYO1ZKdhb7VJwFkOq6fRqud8jqLM63IHVVV3footaMoOdLyOrIIzyvVFaXAfB6PXzI8INtxJybCRJ+UGA6V1rHneHW7xy2EPy5FyYT+OEEswgVBEMIbUZROMJtz7sJ21m+g52mAAkW5sO4V+Nfl8MY0n7al973p6UWQYTAo9NLT7yrqfB12l6GrYu01zO0sep0SQK/kAAdKzqaz7d8w6UYOw7K9V3pAaxYc43A07Cg1DrRms+CbohRpMjpVorYaElc3Wp1KZPupd3pvqfYDx0AqSl2JON8JOnofpYRos8vIRcwcBEEQwhoJlE4kikJ57EDsUx6GOSvgoQNw1T9g7I0Q10NTlHRsFph/Jnz2AOxaAo2eN2p2u+p0QsvyUo0JRkOHAh+CPX/Rne8yEzrvsNYcZwpOBzdMTiMHHwMl96azBR04FtY1WZ1ucr4EStBxnZKumMVGGNu1ok/3QlGqrLNQXqfddAYyFbIrcDnfSS+lkx13RUk3cpGUTEEQhPBGUu+6k5gUGPkzbVJVsLgpPUe+h+PbtWnT22AwQ58JMPBcGDidkuiBWGwqBgV6eNlANRgtwo/5YHHuL2cPSSchysR5w3sEfNvemhf4Y+Sgk5UYzf7iWo51oCjtKqxGVbVgxdc0sazEKLbnV7ZZC9WR451Omhc3kIfKtGAuPT7SpzTE7kCc7wQdvUYpPsrsNJ4Re3BBEITwJrjvUk4mFAUi3NKQssfC9f+FfStg33Ioz4O8Ndr01ZNYxj8KjKJHQhQmL5uXBqPznS/Off7SMymaLb8/z+vz5AvepODUNlo5WKIFB7q65QveKkr+GDnodNRLSQ8EOwrAnGYO7QSOga5P6kqGuKXeqaqKogTemVEIDarq9YazZqIjHG6XYuYgCIIQ1kigFKxExMKQC7UJoHQ/7P8a9n0FB1eTF3cKYNFucH/6GL77OwzQ1CZ6ngrGlh9tsKXeNVhszlqW7C5UlIAuCZIAr1Jw3JWedC/VP3f01MqCqvYVJV8bzXrso4NeSi5r8LYd78CVeteuolQSGvVJAP3SYjEZFKobrRyrbOjSFFEhuKlyKkomEqO1fmFi5iAIghDehG2gNG/ePObNm4fN1nEj0JAgdYA2nT4HrI3s/O4IsFu7wd27HPI3a9Pq5yAqEfpP04KmgedCQjYQfKl3ugoTYXQ1Kg01vLEJznWk3flan6ST7bWipKWH+ZXepwdjbShKxY7jS+1AUdIVp9LaJux2FUMrvbFCSVGKMBnonx7LnuM17CmslkDpJMazRslhWlLbJEqjIAhCGBO2Zg5h3XDWFMmxSu3GtWdSNJzzO7hsHoy4AqKSoKEScj+GxXfD34ZBdSEAvRzW2AWV9djtbffLOVHo6VypcREhe6ORFqsHBm0/WfbXyEHHGcS0U6Nkt6vs6kzqnd7YtkNFqf1ASb+BtNlVyutaDx5DxfFOZ0imdj53S53SSY17jZLudtlktVPTaO3OYQmCIAhdSNgqSuGORw+lhCwY93Ntsts0ZWnfCi1Nz1IP8ZmAZvowz/wSUTRRs+YgCSMvgJT+Wn1UN6AHF6kdpHMFM+6KUltPlnVr8OFZvtcngSstri3rboAj5XXUNtk0BSTN9wBED8aOVzW0qgTpKUbpHXxWZqOB5Bgz5XUWSmqaWlWgdEWpnx/j7A6G9IjjU8Qi/GTGblepdgRECdEmoiOMxEYYqW2yUVrTRHxUaCrigiAIQvtIoBSiuEwQmqUCGYzQ+3RtmvYoWF1P9U32Js41/kAUTbDyB1j5GCTnaCl6A86FfmdBpO/1Lf5SUq2NLZQbeeqBktWuUlVvJbFZCqHFZmeX4wbbb0XJEShVNVipbbS26hSn1ycN7hHnVz1Wj/hIDApYbColNY1kJHiaa+i1ZN58VmlxkY5AqZEheF5P1Q0WpzoVLE2PO2Kw0yJcAqWTldomK6pDhE9wBEWpcZHUltVRWttITogE/YIgCIJvhG3qXbiT76glaREoNcfkpgCYIvld2os8bbme4rQzNMvx8jzY+Bb893p4f5bnumrXpueV6IpSbOgGSpEmI/FRWuBS0kr63YHiWpqsduIiTfRJ8S8wiI8yE+8IjtpKv8vVG81m+heMmYwGMuL19LuW+/DWHhza76V0yKEmpcZGOG84g50hDovwvUU12IIgZVU48ej1SWajQqRJ+7OZ6mVzZUEQBCF0kUApBGm02pw3rh0GSu4oCvb0Ebxhu4QPRrwKD+fB9e/D+DmQ3A8GTHMtW1Ok1Td9dCds/xDqygJ7ELgrSqGbegduBgat3DDp/ZOGZcW3amzgLVlJ7bvSdcYavMU+Wknx89Ye3H2Z1pzv9EAp2BvNutM7OYYos4Emq93Z0Fc4uXAZOZid6bX6Ax6xCBcEQQhfJPUuBCl0PPGPNGn1IL7gtAivqIfIOBhygTYB2NyKkvd/DdUF8ON72oQCPU9xOOlNh+xTWrUg9wW9RimUU+9AU0cOltS2ahWce0w3cvCvPkknKzGaPcdr2nSlC0SglJ0YzQ9UtFCU6pts1DZp7pHeBLX651ncyvnQA42cEDFyADAYFAb3iGfb0Ur2FFYzID2uu4cknGB0a/CEKNdvXpqzPlEswgVBEMIVUZRCEL0paM+kaJ/d4pwW4a31UnIPfEZcATcthkn3QsYIQNVMIlY9C2+fBzv+51rWbvf1EADXk9hQNnMA9xScljdMLiMH/wMYcDN0aEVRqmqwOJsId2Y/bTW21VMKI0wG4lqpj2pO+6l3oeV4pyN1Sic37o53Ok4jl3aaTQuCIAihjShKIYjT8S4pqoMlW9IrWUt56rCXkikS+p+tTTP+CFXHHA1vV8CBbzzT9Na9DD/+V+vZNOBc6DtJW78DvLWcDnZcTWc9b5hUVXVagw/308hBJ8vRkLewlfqhXY76pOzEqBZmEj7tow0bcj2gTY+L9CowT2undsPZQyktdFLvAIY66pT2SKB0UuLeQ0lHT71rr7myIAiCENqEbaAUdg1n3XA63iX63vzSmXpXXu9bo8SEbDcLcjsY3MTIfSugKFebvnsZzDGQc5YWOA2c3qYFeUmYKEppsfqTZc8bpvyKeirrLZgMCoN6dC5dSw+KWzNaCETaHbTdS6m0xrdaMt3woSQcFSWxCD8pqWotUPKi2bQgCIIQ2oRt6l04N5zVHe+yfDFycKCnV9VbbJTXWfwbgKHZZXP1QrjqHzD25xCXCZY62PslfPEQzJ8MVrcbZrsWuNrsKmW1em+e8FCUmt8w6Wl3g3rEE2kydmofelDcmtFCoAIl/Xpq3q+ppNY3G/f0NmqU6pqsHK/S5uWEkJkDuJzv8krraLCE38MXoX2q6vUaJbfUOy+aTQuCIAihTdgqSuGMrij19CP1LspsJD0+kuLqRo6W15ESGwA1JyYFRv5Mm1QVjv+kNbvdvwIi4sHsNs43zoaoJBp6n81QYsilL8mBGEM30taTZZeRQ+cCGHB3vet6RamouhGLzVV35ksPJXDVKJXVNnk0rz1cpqXdJUabSYoJrc88Iz6SxGgzlfUWDhTXdjqVUggt3F3vdERREgRBCH8kUApBnDVKfqTegWboUFzdSH55PaN7JQVwZGgpdpkjtenM+z17MVUdg8LtAMTmrWFJJBSThHnxTEd90zla0BViOGsVmj1ZDpSRA7iUwJpGK1UNFueTbZtddRoMDMvqXLPgtLhIzEYFi03leFUDPeK0fZQ6eyh5F9zowbfNrlJe1+RU3PJKHPVJIaYmASiKwpAe8XyfV8bu41USKJ1kuMwcWqbeldU1YbOrGDth/y8IgiAEJ2GbehfOFHjbbLYNPCzCuxr32qSEbLhnC1z4F8p6nkOdGkk6FZr9+P9ug2W/dy1rt3valQcx6fGtP1nWlZ5AKEoxESYSo7XAxd3Q4WBJLQ0WO9FmY6frfgwGhR4JLZUrZy2Zl42BzUaDM1hyT78L1fokncGZWp3Z7sKabh6JcKJpzcwhxaGKqiqU14mqJAiCEI5IoBRiVDVYqG7U/mhn+5F6B9DLESgdbc0ivKtJHQBn3MHa0+cxtvEN/pjyjMuCfOC5ruUKtsJf+sMHN8OWf0Jl/okfq5foAURlvYUmq5ayVl7b5AxEhwVIfXBahLsFuHowNiQzPiBPtPVaKPd9OGuU4r2vJXM631W7biCdjnchqCgBDOkhzncnK84+StGu1DuT0dXHTtLvBEEQwpNuDZSeeeYZxo8fT3x8PBkZGVx++eXs3r3b+b7FYuHhhx9m1KhRxMbGkp2dzU033cSxY8e6cdTdi64mJcWYiYnwL3OyT4p2o7q/uPuejJdUN9KEmcK0CZr9+F3fab2bdA58Aw2VkPsxLL4HXhgOr06EL38L+1d6GkR0M4nRZmeQoj9Z1m3B+6TEeBSAd4bsVuy7A1Wf5NpHS0XJV9c7bdmW1smhrigNcgRK+4pEUTrZ0BUl94az4GbkIoYOgiAIYUm3BkqrVq1i7ty5rF+/nuXLl2O1WpkxYwa1tdoNVV1dHVu2bOH3v/89W7ZsYdGiRezZs4dLL720O4fdrXS2PglgjKMu6YfDFdjsavsLdxH6jUWau5GDe5repHvhtuVw9iPQ81RA0ezH170C/7ocjm5yLWtt9KyFOsEYDIoz1UwPDAJp5KDTWkNYPVAa3sn6JOc+klq665X64U7YWtPZQyHaQ0knw3FM5dJg9KSjtYazAKmxYuggCIIQznSrmcPSpUs9Xi9YsICMjAw2b97MlClTSExMZPny5R7LvPzyy5x++ukcPnyYPn36tNhmY2MjjY2um7OqKu1G0mKxYLH4aYcdIPT9d2YcR8q0p9lZCZF+b2dAahSxEUZqGq38dLS80yYA/lBUpSkWyTHmto8jc5w2nflrqCtDyVuFYf/XKPkbsWaOA8d6hqWPYti/Anv/aagDzkHteyZEnthjSo0xU1zdyPGKOganx7D9aAUAQ3rEBey6y3AoOkfL65zb1JWrQekxAdmPbuCQ79iH1Q6V9drT9MQog9f7SHGkJB2vqsdisdBosTn7M/VMiOj276I/xJq1QL660UpdQyNmo2QuBxOB+H1tC90ePMakeGxfv86LHNe5IHhLV16vghBowu169eU4gsr1rrKyEoCUlLadzyorK1EUhaSkpFbff+aZZ3jqqadazF+2bBkxMcHxJLt58OcLaw4bAANNFcdZsmSJ39vpGW1gT5OBf36xlrMyT7was/OAdhwFB3ezpG6Xl2tFgvFC6HMhfOk6h+fs/IL4hmMYtyyALQuwK0ZKYwdTlDCKovhRVEX3abXhbSCxN2jH8/V3G6neq/L9XiOgUJe/myVLvD2+9ikqVgAjOw4cZcmSw9Ra4HiV9hU+tG0dx3/q/D7yy7R97DpSxPLly6lx/JYYFJVvV36Ft2VQpfnadn7cdYAltn0U1oGqmog0qqxftaKrP44uQRNftfO96LOlxAcmo1IIMJ35fW2L8hrt+7x5/VoOu4n5NSXa937D1lzSynYEfL9C+NMV16sgdBXhcr3W1dV5vWzQBEqqqvLAAw9w5plnMnLkyFaXaWho4JFHHuGGG24gIaH1lKZHH32UBx54wPm6qqqK3r17M2PGjDbXOVFYLBaWL1/Oeeedh9ns313WZ+9thfwiJo8dyswzc/wey/6o/exZuZ/G+J7MnDna7+34yz+ObIDySs4+41TOG57RuY1Nn4I1by3KgZUY9q/AUJFHes1O0mt2MjxpA9a7NrkCJUsdmAMfMH9Vu4092wrpNXAY55zemwc2fA2ozLpkGpkJ/pluNCflQBnv7tuE1RzHzJlnsu5AKWzaTO/kaK685KyA7COnoIo3d6+njgjOO+9M/vGR9qOYHhfFxRed7fV2Gn7IZ/Hhn4hMSmfmzFNZsasIftzKgIwELrpoYkDG2h08sfVrqhqsnDbpbAakh2atVbgSiN/X1rDZVe5bp30PLr5gujPdDmD/yv2sOb6f5Kw+zJw5PGD7FMKfrrpeBaErCLfrVc8284agCZTuvvtutm3bxtq1a1t932KxcN1112G323n11Vfb3E5kZCSRkS1rKcxmc9B8uP6OxW5X2XioHIDT+6d16nhO758GK/ez5XBlt5yXUkedR4+kmM7v35wMIy7RJoDS/bD/a9j3FUrqQMwRjhsbmxX+Plpz3htwLgycrtU/GTv/NUiP1x4zl9dbOVDagM2ukhobQa+UOJQAySe9UzV76oLKRkwmE3uKtCciw7MTAvYZ9knVUhbLai3YMVBl0caeGhfp0z56JGrBaGmtBbPZzNEKLR22X1pc0HwP/SE5NoKqBis1TfaQPo5wJtC/9XV1bql2cdGYTa6Uy4wEx/e+ziLXg+AXwXRvIggdES7Xqy/HEBSB0j333MPixYtZvXo1vXr1avG+xWLhmmuu4eDBg3z99dfdrgx1F3uKqqmosxBtNjK6V2KntjW2TxIGReulVFBZ3ylzCH/wx0nNa1IHaNPpczznH98ODRWQv1mbVj8HUYnQf5pmTT7wPEjI8m+Xca6ibmej2eyEgAVJAJkOM4d6i43Kegs7C/RGs4H7PiTFmIkyG2iw2CmsanSm3vliDQ4tzRx0I4e+IWoNrpMUbeYQUFEXHnnaQsfo1uBRZgMRJs+6NP33q1QMPgRBEMKSbq1GVlWVu+++m0WLFvH111/Tr1+/FsvoQdLevXv56quvSE1N7YaRBgfr95cCcFpOcqcLyeMiTc4b7E155Z0emy/UNlqpt9gAl430CSF7HDywEy6bp1mRRyV5WpBv+adrWWuTTxbkzhummkZ+OqbV2g0PoOMdQJTZ6HTXO1bREHBrcABFUZy9lAoqG6jWAyUfA1rdIa+sthGbXSXPYQ2eE6LW4DqJjiajFfUSKJ0sVLXheAdu9uA1Yg8uCIIQjnSrojR37lzee+89PvnkE+Lj4yksLAQgMTGR6OhorFYrV111FVu2bOGzzz7DZrM5l0lJSSEiogvUiCBmw8EyACb0D0yweFrfZH46VsXmQ+VcMiY7INv0Bl1NijIbiIkwnrD9ApCQDeN+rk12G+RvgX1fadPA6a7l9nwBH/0Scs5yqE3TIaV/m6YQac5+Kk3Om+gR2Z1T/VojKzGKstomjpTXOfv5DA9goASQlRTFgZJaR6CkHa8v1uAAKbERKIpmgFBe1+QKlNJCO1DSG4xW1ImCcLKg91CKj2r551LswQVBEMKbbg2U5s+fD8DUqVM95i9YsIDZs2dz9OhRFi9eDMDYsWM9llm5cmWL9cIZVVWdgdIZ/dp2BfSF03JSeGfdITYdKgvI9ryl2PH0NTU2MqCpaT5jMELv8do07VHP9w6v14wf9n6pTQBJfbWAaeB0GDANzK50Rf3JclFVI5WOQCnQAQxo/bN+OlbFt/tKaLLZiY800Ss5sGmTWa0qSr4FSiajgZSYCEprmzhWUU9+uWYNnhMGqXcgqXcnE65AqW1FqbrRSoPFRpT5BD/4EQRBELqUbg2U1A6ahObk5HS4zMnC3qIaymqbiDIbGO1oGNtZTstJBmBnQTW1jVZiI0/M5aCnqfha93JCOf9pGHsj7F+hqU2H1kHFIdj0tjbdtw2S+2rL1leQ6lAaCh39oaLNRvp1gXqSnaTVKa3YWQTA0Kz4gAeb2Xpj2yq3QCned/U2LS6S0tomth6pwK5q5yQ9mD9zL0hypN6Vi6J00qD3UEpoRVFKiDJhNipYbCpltU1kJ53YWk9BEAShawkKMwehY9Yf0OqTTu2b3KKg2F+yEqPpmRRNfkU9W49UMHlgWkC22xF64XNabBCnTioKZI7Upsn3QWMN5K2BfSug/KArSAL46Bf0yv+Bv5qHsNo2mjX2keRk9cHobdMhH9DVnvwKTaEJZH2Scx9JbopSk3YM/tSSpcVHsPu4qwaub2pM9yqIASBJT72TGqWThuoGPVBqqSgpikJqbCSFVQ2U1kigJAiCEG5IoBQibDjgqE/qF1gzi1P7JpNfUc/GvLITFiiVOJzQTqiRQ2eJjIMhF2qTO3Yb5G9GqS3mKuNxrjKuxq4q5NcMhZWXwqAZ0Ou0gA0jK9GzJ1OXBEqOfRRWNlCtZR2RGuv7Z6XXNW3K067dUDdyAFegVCmpdycN7dUogeZ4WVjVQEmtGDoIgiCEG93qeteVzJs3j+HDhzN+/PjuHkqn0eqTNEXpjAAZOejo6XebD5045ztdUUrtCmvwE43BCL/6CW5azHumy9lp74NBUeldtxNWPQtfPem5fE1xp3Z3IgIl/al4fkUDtZ1MvQM4VqmlI/ZNC+36JJDUu5OR6saOAiXd+U6uCUEQhHAjbBWluXPnMnfuXKqqqkhMDLz72Ilkf3ENJTVNRJoMjOkd2GM5ta8WKP1wuAKbXe2SdLHm6GYOIaUotYcpEvqfzQfJJh47UkEPyvi/8+rpU7YO+k5yLVdbAn8dBOlDXU56fSaCOartbTfDPbXHoMCQHvGBPBLAFYzVNFoBBUWBlBg/AqVm9UhhoSiFkJmD1WbH1Mk2AoJ7jVLrDQpdzneiKAmCIIQbYRsohRPrHGl3p/RJJtIUWFeloZkJxEWaqGm0squwqkssrZuj31CEhaLkht5rqMSQSsaU88F8h+cCx37Q/i3eqU3rXgFzDOScqQVNQy+CxJYNl93pkRCFooCqalbb0V1grx4fZSY+0uR8kp4cY/brhru5pXioN5sFSNb7KAW5olRc3ciMF1Zx4agsnr5iVHcPJ6TpMPUuVprOCoIghCvyuDEE2OAwcghU/yR3jAaFcX2SgBOXfqenqISNouRAr+MZkB7buk3woPPgoQNw1T80R724TIcF+TL44iE4sMq1bEMVNFa32ESEyeA8b12RdqeTleRSudL8qE+CMFWUHDVKtU02mqz2bh5N2+w4Vkl5nYW1e0u6eyghT3sNZ8GVelciipIgCELYIYFSkKOqKusditIZ/QPTP6k5p/XVtqu7k3U1JeGWeucgI0E7nnZVuZgUGPkzuPxVeHAX/PJbmP6U1th2wDmu5bb8E57tBwsvhrUvQME2TUbClRrXFX2adHR3PXApZb7irihFmAxkJnifYhisxEeZnT2HK4PY+U5XQWocqqDgP96YOQCUiaIkCIIQdkjqXZBzoKSWkppGIkwGxvZO6pJ96IYOujtZV2K12Sl31HeEW+rd1af2Jr+injum9PduBXcL8jPv93yvcDvYLZoled4azRQirgcMOJdfpgznkeN9mDYkI9CH4CTbTVFK8dPG3d0Aom9KDIYTUP/W1RgNConRZirqLFTUNQVtXyjd0rqmQQKlzqIrSgnRrStK+oMEMXMQBEEIPyRQCnL0/knjeid1Wdf3sb2TMBoUjlU2cKyivkt7gehPXQ2Kq94jXOiTGsPfrhkbmI1d+Tqc/ZDWt2n/Cji4GmqOw4/vMdMUxXm/PYA5ypHKVnlUS+MzBu7rHAhFKSUmwllP1TcM0u50kvRAKYgVJT1AarLZabTaAl7beDLRcY2S7nonqXeCIAjhhgRKQY6zf1IX1CfpxEaaGJYVz478KjYdKufSLgyUShxPXVNiI06Iw15IkzpAm864A6yNcHidFjhZ6lxBEsC710DVUeg/TXPTG3AuJPbs1K7dbcj9TZE0GQ2kxkZQUtNEThgYOegkxURAaR3lQZxqVe2mJNU0WImMk0DJX9prOAsuZbyktglVVUO+qbIgCILgQgKlIEarT9L7J3VNfZLOaX1T2JFfxea8Mi4dk91l+wnX+qQuxxQJ/adqkzsNVVCVDw2VkPuxNgFkDNdqnoZeDH0n+rw7d1WxMymSaXGRlNQ00TctjBQlh6FDMCtK+s09aHVKqfJ984smq50Gi2ba0bY9eKRz2ZpGa5umD4IgCELoEbZmDuHQcDavtI6i6kYijAZO6ZPcpfty1il1sfNdaW14WoN3G1EJmpPebV/B2Y9Ar/GAAkW5mv34ln+6lrXboXS/0xSiPTwVJf8/qzMHphFlNjCxCxXRE43eS6kyiHspVbuZOFRLnZLfuAeccW2k3kVHGIl12PRLnZIgCEJ4EbaKUjg0nNXVpLFdWJ+kozvf7SyooqbRSlxk11wa+o1Eqp+W00IrGIzQe7w2TXsU6srgwErY9zUMu9i13PHt8PoUSOqr9W0aOB36nQWRLZvWetQodeKz+t3Fw/nNBUPCqkYmyVFbVx7EvZQ8Uu/E+c5v9PMYG2FsN1U4NS6S2rI6SmsbyQkj9VQQBOFkJ2wDpXDA1T+pa9PuADITo+iZFE1+RT0/HC7nrEHpXbKfYkm963p0C/KRP/OcX7QLDGaoOASb3tYmgxn6TNDS9EZf42x4Gx1hZGhmPAeLq+ib2rmatXAKkiAEU+9EUfIbl5FD++l0qXERHC6rc9ZgCoIgCOFB2KbehTqe/ZNOTNqSyya869LvnIqSpN6deMZcCw/nwfX/hfFzILmfy4J8xVNQdtC1bFUBH9zYn8fH2aTmohm6W2NFECtK7iqSKEr+4zRyiG7/maLL+S54rwlBEATBd0RRClIOl9VRWNWA2ah0eX2Szmk5KXyy9Ribu7BOSTdzSBdFqXuIjIMhF2oTaDVL+7+Gg6ug9xmu5b59kfgNrzMzph+GVT/C4POh56kBtSAPVZyKUjDXKLmpSNUSKPmN3kOpo4cFrl5KYhEuCIIQTshdT5Ci1yeN6ZVEdMSJSV06ra8WkP1wuByrzY7JGHjBURSlIEO3ID99juf8yqMoqCTXHYC1z2tTVKLmujdwOoy54aQNmhKjgz9QqmlmDy74R1UHPZR09N+z0iC2jBcEQRB8R1LvgpQT0T+pOYN7xBMfaaK2ycauwuou2YeuKIldcZBz3btY7tnOD31uxz7sMohKcliQfwKrntMMJHSO/6T1eTpJCIXUO08zh+AN6IIdr2uUHKl3JaIoCYIghBUn5yPhIOdE9k9yx2hQGNc3mdV7itl8qJyRPQPrFqiqqlNR6ozltHCCSMjicOoURs6cicFogPwtsO8riIgBvamm3QYLZoKtCXLO0hreDpwOKf1dy4QZwW7m0GCx0WSzO1+LouQ/VfV6s1kvFSWpURIEQQgrfA6Ujhw5gqIo9OqluWN9//33vPfeewwfPpw77rgj4AM8GTlaXs+xygZMBoVT+56Y+iSd0xyB0sa8Mm6elBPQbVc3Wp03cOJ6F2K4W5C7U3kETFHQUAF7v9QmgOQcGHAujLoK+k460aPtUnR78LomG41WW9C5+jU3b5AaJf/xVlHSf8/0PnGCIAhCeOBz6t0NN9zAypUrASgsLOS8887j+++/57HHHuMPf/hDwAfoL6HccHadQ00a3SuRmIgTK/rpdUpdYehQUq3dRMRFmrq8L5RwgkjOgQd3wS+/hfP+AP2maJbj5Xma/fiBb1zLNtVC4XavGt4GM/GRJvSWOsHYdLZ5g1lpOOs/1U4zB1GUBEEQTkZ8DpR27NjB6aefDsAHH3zAyJEj+e6773jvvfdYuHBhoMfnN3PnziU3N5eNGzd291B8Zr2zf9KJq0/SGdsnCaNBoaCygfyK+oBuWy90FiOHMENRIHMkTL4Pbv7UYUH+vmZBPmSma7n9K+G1M+H5IfDRnbD9Q6gt7bZh+4vBoLgMHYIw/c69hxJI6l1n0IPMDlPvHDVKZXVN2Oyh/SBAEARBcOGzXGGxWIiM1P4ofPXVV1x66aUADB06lIKCgsCO7iRlwwnun+ROTISJEdkJbDtayaa8MnqO7RmwbeuKkqTdhTmRcTDkAm1yp7oAzLFQcxx+fE+bUKDnKVqa3mm3QkJWtwzZV5JjIiivs1AehC5nzQMj6aPkP1XOPkrtp94lO+rWVBXK65rkN04QBCFM8FlRGjFiBK+99hpr1qxh+fLlXHCBdjN07NgxUlNP/I19uHGkrI78inqMBsWZBneiObWL0u9KdEUpVhSlk5LT58DDB+GmxTDpXsgYAaiQvxlWPwfWBteyxXugMr/bhtoRiUFs6KBbWuteGhIo+U+1l/bgJqPBGSyVBWHwLAiCIPiHz4rSs88+yxVXXMFf/vIXbr75ZsaMGQPA4sWLnSl5gv9sOKipSaN6JhIb2T2mhKf1TWHBt3lsygtsoFQq1uCCKRL6n61NM/4IVce0hrcF2yCln2u5r56E3Z9DxnAYcI7mpNdnIpijum3o7gSzRbieepceF0lRdaPUKHWCai8bzoL2u1ZeZ6GkppHBPeK7emiCIAjCCcDnO/GpU6dSUlJCVVUVyckuxeOOO+4gJiYmoIM7GenO+iSd03K0z3VXYRXVDRavbhK8Qe8xki41SoJOQjaM+zmMc5unqmCtB8UARbnatO4VMMdAzpkw+HwYf3u3DRkgKYibzuoKUlZiFEXVjdJHqRN4qyiBppTvQwwdBEEQwgmfU++efPJJjh496hEkAeTk5JCRkRGwgZ2sbDh44vsnNadHQhS9U6Kxq/DN7uKAbVe/gRBFSWgXRYFZH8Fv9sNVC2DszyEuEyx1sHcZbP+f5/IH10Bj1zRIbotgTr3Tb+6zEqMBaLDYsbj1VRK8Q1VVV42SFw+LnBbh0nRWEAQhbPA5UPr0008ZMGAA5557Lu+99x4NDQ0dryR4RX5FPUfKurc+SefKcVqfrLfWHkQNkJ2zrihJobPgFTEpMPJKuHyeZkF+53eaBfn421zL1JXBO5fAs/1g4cWw9gUtja+LLciDOfVOV5QyE11pirVSp+QzjVY7Fpt2HXmlKOkW4VKjJAiCEDb4HCht3ryZLVu2MHr0aH71q1+RlZXFnXfeGZI23MHG+v2amjQyOyFg6W7+MmtiXyJMBn48UsGmAJk6uBQlSb0TfERRoMcIzYJ81FWu+RWHtV5OdgvkrdFqm14/y2VBfnh9lwwnKSZ4U+/0upqU2AgiTQbHPAmUfEVXkxQFYr3oZ6dbhJdI6p0gCELY4HOgBDB69GheeOEF8vPz+cc//kF+fj6TJ09m1KhRvPTSS1RWVgZ6nD4Tig1nnfVJA7rfPTAtLpIrx2nW4G+uPhCQbRaLoiQEmuyxcN9WuGcLzPwrDL5Aq2XSLchL9rqWrT4OhzeArfNBQ5JDUSoPQkWpyq2uRn/gIs53vuOsT4o0YdA7DLeDq+mspN4JgiCEC34FSjp2u52mpiYaGxtRVZWUlBTmz59P7969ef/99wM1Rr8IxYaz6xyB0sRuNHJw5/azNBey5TuPk1dS26ltNVptzhuPNFGUhECTOkCzH7/hfa3h7U2faBbkA6e7lvlpEfxjBvylP3xwE2z5p98W5EFt5uD4nsVFmpwpYxIo+U5VvfeOd+D6XZPUO0EQhPDBr0Bp8+bN3H333WRlZfGrX/2KcePGsXPnTlatWsWuXbt44oknuPfeewM91rDmSFkdR8sd9Uk53Wfk4M7AjHimDUlHVeEf3x7s1Lb03iImg+JVYbQg+I0pEvpP1ezH3RvYWuohKgkaKiH3E1h8D7wwHOZNgC9/C7WlXu9CT72rDEozB9cNfpyjxUDzJrRCx/jieAcukxpRlARBEMIHnwOl0aNHM2HCBA4ePMjbb7/NkSNH+POf/8zAgQOdy9x0000UFwfOLe1kQE+7G90r0XlzEwzMOas/AP+36WinCtdLql31Sd6ksQhCwDnrAXjoANz2FZz9CPQ8DVCgeCd8/4Znj6bDG6BkX5umEMlBnHqn3+AnRJmcvyXVoij5jOs8evdgR2+kLfbggiAI4YPPd+RXX301t956Kz179mxzmfT0dOx2saP1hfUHtEaz3dk/qTUmDkhleFYCuQVVvLvhMHOnDex4pVYoqXU0m42V+iShGzEYofd4bZr2qOaad2AlVB6FiFjXcksehMLtkNRXS98beC70mwKRWiNR3R68wWKnwWIjymzsjqNpFT3NLi7KRFyUKEr+oitzCdG+KUrVjdaguyYEQRAE//BZUfr973/fbpAk+I6qqk5FKVjqk3QURWHOFK1WaeF3eTRabX5tp6TaYeQQL4GSEETEpMDIn2luejrWJohOAYMZKg7BprfhvzfAszmw4CLY+DbxkSaMDmU02OqUXCljZuL11DtpOuszVQ2+1SglRJkwG7VrokzqlARBEMICv3K8jh49yuLFizl8+DBNTZ5/EP72t795vZ1nnnmGRYsWsWvXLqKjo5k0aRLPPvssQ4YMcS6zaNEiXn/9dTZv3kxpaSk//PADY8eO9WfYQcvR8nryK+oxGRRO7eb+Sa1x8ehsnv1iN4VVDSzeeoyrT+vt8zb0Aue0WDFyEIIcUwTcvBgaazTL8X0rYN9XUH4QDq2FxJ4o428jKdpMaW0jth2LYOz5ENv9DzlsdtWpKMWLotQpfK1RUhSF1NhICqsaKK1pIjspuiuHJwiCIJwAfA6UVqxYwaWXXkq/fv3YvXs3I0eOJC8vD1VVOeWUU3za1qpVq5g7dy7jx4/HarXy29/+lhkzZpCbm0tsrJYGU1tby+TJk7n66quZM2eOr8MNCdY5+ieN6Z1EbBDVJ+mYjQZmT87hz1/s4u21B7nq1F4oim91RrqiJD2UhJAhMg6GXKhNAKX7taApYxigpd9l1O2l5/JHYbkCPU+BAedqqXo9TwXjif8u1za5AqK4SKlR6gy+Bkqg/b4VVjU4U40FQRCE0Mbnv+SPPvooDz74IH/4wx+Ij4/nf//7HxkZGdx4441ccMEFPm1r6dKlHq8XLFhARkYGmzdvZsqUKQDMmjULgLy8PF+HGjI4+yf1Dw63u9a4/vQ+vLxiL7sKq1mzt4Qpg9N9Wt+pKEkPJSFUSR2gTQ6SYyIwK7VUJQ4hoXI35G/WptXPQVSi5rw36V7oddoJG6J+cx9hNBBlNoqi1An01DtfXDpdzneSeicIghAO+Bwo7dy5k//85z/ayiYT9fX1xMXF8Yc//IHLLruMO++80+/B6I1qU1L8DxgaGxtpbHQ9zauqqgLAYrFgsXRvnr6+f/dxqKrKd/tLABjfN6nbx9gWMSa46tSevLPuMG+s3s/Efkk+rV9c3QBAUrQxaI9R8KS161VwkRBlZKV9OJ9OeJ9rBhtRDq7EsH8FysFVKA0VkPsJ1rE3o+rnr2QvSvUx1N5ngCmq3W37S0VNPQCxkdr3LMakKb9V9U1h/zkG+nqtdDgaxpgNXm8zxWH8UFRVF/bnW+gc8vsqhBLhdr36chw+B0qxsbHOQCQ7O5v9+/czYsQIAEpKSnzdnBNVVXnggQc488wzGTlypN/beeaZZ3jqqadazF+2bBkxMTF+bzeQLF++3Pn/kgYorDJhVFSKczewZHc3DqwD+jaAgpG1+0p56/+WkB3b8To6B48ZAYWDudtYUvBjl41RCDzu16vgorbMABhY/8N24opUIAmifgZDryC57gAZVdvZ+1M59p1LABhx9F0GFn+JVYmgJH4YRQmjKIofTW1kD/AxlbUtDlQBmDDamliyZAn7ihXASF5+IUuWLAnIPoKdQF2vhxy/Wft2bmdJ8Tav1qks0q6JTdt207NqZ0DGIYQ38vsqhBLhcr3W1dV5vazPgdKECRP49ttvGT58OBdddBEPPvgg27dvZ9GiRUyYMMHXzTm5++672bZtG2vXrvV7G6ClBj7wwAPO11VVVfTu3ZsZM2aQkJDQqW13FovFwvLlyznvvPMwm7V0jg82HYUfchnXJ5nLLzm9W8fnDd83/cjSn46z19iH22d6H9D+vx2rgEYumDaZEdnd+zkI3tHa9Sq42PrFbr4vPkRmnwHMPH9wq8sMcPu/YdU21PqtmGqOk1n1I5lV2gMDNakv9v7nYJ/+FJg79zDnmz3F8NMP9EhNYObMiUTuLOLf+7YSGZ/EzJn+/z6HAoG+Xl87uA6qqpkycTxTBqV5tc7RNQdZWbCXxB49mTlzVKfHIIQv8vsqhBLhdr3q2Wbe4HOg9Le//Y2amhoAnnzySWpqanj//fcZOHAgL7zwgq+bA+Cee+5h8eLFrF69ml69evm1DZ3IyEgiI1vWwZjN5qD5cN3HsvFQBQATB6QFzfja446zB7D0p+N8uq2ARy4cRkZCxylEdrvqrFHKTIoNieMUXATTdyeYSInV++bYvDs/038P5/4Ojv8E+x1OeofWoVQcwrj3S4yXvOBSlnYtgcRekDnKJ7Wp3lGKFB+lfWaJsdr3s9bbMYYBgbpedQOM5Lgor7eXnqA53ZXXW0+a8y10Dvl9FUKJcLlefTkGnwOl/v37O/8fExPDq6++6usmnKiqyj333MNHH33EN998Q79+/fzeViiiqirrgrR/Uluc0ieZU/sms/lQOe+sy+M35w/tcJ3Kegs2uwpAitiDC2FCkuNaLq/zoXBfUSBzpDZNvs9hQb4WGqtcAZHdBp/MhfoyiOvhcNI7F/pP69CCvLpZ7x/dsa1GXO98RjfGSPDB9S7N4eopZg6CIAjhgc+BkqqqbN68mby8PBRFoV+/fowbN85nu2iAuXPn8t577/HJJ58QHx9PYWEhAImJiURHa0/mysrKOHz4MMeOHQNg926tiCczM5PMzEyf9xlM5JXWcbyqkQijgVOCsH9SW8w5qx+bD5Xz7obDzJ02kJiI9i+jUodVbkKUiQiTzz2OBSEoSYrWgpFONZyNjIMhzdxC6yug9+lwcA3UHIcf39MmHBbkp9wMp97c6uaaW1rr9uDieucbqurej8oH17tY3fVO7MEFQRDCAZ/uWleuXMmAAQM444wzuOaaa7j66qsZP348gwYNYvXq1T7vfP78+VRWVjJ16lSysrKc0/vvv+9cZvHixYwbN46LLroIgOuuu45x48bx2muv+by/YEPvnzS2TxJRZmM3j8Z7zhueSd/UGCrqLPxv89EOly+udliDx4s1uBA+JMdo6kFlfYBdgGJT4Yb34eGDcNNizWK8x0hA1ezHKw67lm2sgS3/hMp8wBUQxTsCJN0evLbJ5lR1hY6pcztfvvZRAiipbUJV5XwLgiCEOl7/Bdi3bx8XX3wxZ5xxBi+88AJDhw5FVVVyc3P5+9//zsyZM9m2bZtHal5HePOHZPbs2cyePdvrbYYSrv5JoZF2p2M0KNw6uR9PLP6Jd9Yd4ucT+rarKOqKUlqsBEpC+JAUoykNPqXe+YIpEvqfrU38EaoKYP/XWjNbnbw1sPge7f/pw5iojOUHQw5JEb0Bl6IEWjNaX3oCnczoPZRMBoVoHx5i6YpSk9VOTaPVJzVKEARBCD68DpRefPFFJkyYwIoVKzzmDx06lCuuuILp06fzwgsv8PLLLwd8kOFIKNYnuXPlKT35f5/vZF9RDXuLahjcI77NZUuqHYFSvNQnCeFDYiBS73whIQvG3eg5TzFCr/Ga0lS8k8nsZHIEWDa+AGVTiDz3ccxGBYtNpaZBAiVvcU9h9CWtPDrCSGyEkdomG6U1TRIoCYIghDhep95988033H///a2+pygK999/PytXrgzUuMKeAyW1FFc3EmEyMK5PUncPx2fio8xMGaxZ5i7ZXtDusrrjXaooSkIYkewwc2i02qlvsnXPIAbPgNu/gt/sh6sWsDbuAo6rSZjtDbB3GYo5xqkqWfO+09z0Gqu7Z6whRHNTDF9IjXPUKdVKnZIgCEKo43WgdPjwYUaNarsvxMiRIzl06FBABhUI5s2bx/Dhwxk/fnx3D6VV9PqkU0KsPsmdC0dmAfDF9sJ2lytxFDanxUmgJIQPsRFGTAZNbaio72aXs5gUGHklryTczxmN81h5zicw86+QOsBZpxT/wxvw3+vh2X6w8GJY+wIUbgeppWlBle54F+2z35GzTkmvzRQEQRBCF68DpZqaGmJi2m6GGBMT41On265m7ty55ObmsnHjxu4eSquEan2SO9OH9cBsVNh9vJp9RTVtLlfisMrVbyAEIRxQFIUkh6HDCUu/6wAtZUyBHsPh9DkAxEdqqkh1bF9I7gd2i1bb9NWT8NqZ8PwQzY5cAiYnVQ6DDv3c+ULvZO3v5IGStn8TBUEQhNDAp8dlubm5Tgvv5pSUlARkQCcDqqqy/kAZEJr1STqJMWYmDUhj1Z5ilu4o4O5zBrW6XKlTUZJASQgvkmLMlNQ0dp2hg484La3dTBx0RWn70F/R55rnoHS/Zgqx7ys4uFqzIC/Z69nYdtMCyBiuGUcYfVdVQp3mNuu+MCQzHn6E3YWS4igIghDq+PRX4Nxzz23VqU5RFFRV9auX0snI/uJaSmoaiTQZGBuC9UnuzByVyao9xXyxo7DNQElXlCT1Tgg39F5KlUGlKHnW1uhBU02jY4ypA7Tp9DlgbYTD60G1uzZSXw6fP6DNi0qE/lNh4HSt8W1izxN1KN1Ka+fRW4ZlacY2uwokUBIEQQh1vA6UDh482JXjOKnYkFcOwKl9k4k0hWZ9ks55wzN57KMd/HSsikOltfRNjW2xjK4opUqgJIQZeupdeZAESnofpbiolopSdWtNZ3ULcncaq2H4ZbB/JTRUQO4n2gSQPgwm3wdjr++K4QcNupmDPzVKQzITANhfXEOT1S5NtgVBEEIYr/8K9O3btyvHcVKxwZF2F8r1STopsRFM7J/K2n0lfLGjkF+ePcDj/fomG7UORzBJvRPCDb2XUrebOQANFhtNNk0Zck8Zi3MqSq0ESq2R1AeuXgh2G+Rvgf0rtDS9o5ugeCfY3NzcKo7A7iWa4pTS3zN9L4Sp6oTrXXZiFPFRJqobrOwvrmFYVkKghycIgiCcIE6+5PNuRlVhQ56jPmlA6AdKABeOytQCpe0FLQIl3fEuwmTwaH4pCOFAckzwpN65K0ZxES0VpZrWFKX2MBih93htmvoI1JXBgZXQ90zXMru/gC8e0v6f1FcLmAZOh35nQWTbvdWCHf1cJvhRo6QoCkMz49mYV87uwmoJlARBEEIYyQk4wRTWQ1mthSizgdG9Ert7OAFhxvBMDAr8eLSSo+Wezod6oJQeFyk1bELY4Uq9635FSVeM4iJNGAyu71q8r4pSW8SkwMifQXwP17z4TMg5CwxmqDgEm952WZAvuAjKDnRun91EZ8wcAIY60u92FlYFbEyhzOo9xSz+8VirNc6CIHQt8r3rHBIonWD2VWk3MKf1TQn5+iSd9PhITu+XAsDSHZ6uiKViDS6EMYkOM4dgsAd3NUn1vLnXldzqzgZKrTH8Upj9GTycB9f/F8bPcVmQH9kAsRmuZXM/ge0fQm1p4McRYJw1Sn6k3oHD+Q5xvgM4Wl7HLQs3cu9/fuDu//zQfc2ZBeEk5P2Nhxn02y/4br84U/uLV4/LFi9ezIUXXojZ7N8fje5g3rx5zJs3D5stuH6U91ZqgVK4pN3pzByVxfoDZSzZXsDtZ/V3zte706fGSqAkhB/JQdRHqS0VJM5xs+9z6p0vRMbBkAu1CTQL8uM/afN11vwNCrYCCmSPc6TpnQs9Tws6C/Kqev9d70Cc79z51/pD2OzaE+3PtxVwuLSON286jczEqIDva+uRCrITo8hICPy2BSEUeXfDYax2la93FjFpQFp3Dyck8UpRuuKKK6ioqADAaDRSVFTUlWMKCMHYcNZuV52K0oT+Kd08msBy/ohMFAW2HK6goLLeOV+swYVwJpjMHPRAqXktoM9mDoEgdYCmNumoqmYz3mMkoMKxLbD6OfjH+fBcf/j0vhM3Ni9oS53zlsE9tECpsKqBiiBIy+wu6pqs/Pf7IwDcNXUAyTFmtudXcukra/nxSEVA93WguIbL533LHf/aHNDtCkKoUl7bxPb8SgCONCuLELzHq0ApPT2d9evXA0i/pE6wt6iGWqtCtNnA6F5J3T2cgNIjIYrT+iYDnul3JWINLoQxzkApKBSl1p3a4v01cwgkigLnPQV3fgsP7ITL5sGIKyEqCRorobHGtayqwsqnNXtyS0O3DLezNUrxUWZ6JUcDsOskTr/76Id8Kust9EmJ4cEZQ1h895kM7hFHUXUj17y+jsU/HgvYvvYc166hn45VYrXZO1haEMKfdQdK0cuTjpTVt7+w0CZe/RX45S9/yWWXXYaiKCiKQmZmZpvLBluqWzDh3j/JbAy/8rALR2axMa+cL7YXcsvkfoC7oiSpd0L4keSWetfdD5HaTL3rDkWpPRKyYdzPtUm3IDe5PUgp2gmrntX+b4rWHPT0hrepA7rcgtxuV6lpcrjeRfufbj40M56j5fXsLqwOi1YQvqKqKgu/zQPg5kk5GA0KvVNi+N+dk7j/v1tZsauIe//zA3uPV/Or6YM9DEj84XiVFlRbbCrHKhrokxrT2UMQhJBm7T5XXVJzoy3Be7wKlJ588kmuu+469u3bx6WXXsqCBQtISkrq4qGFH+v1/kn9wivtTueCkZn84bNcNh4qo6i6gYz4KGezWUm9E8KRJMeNdJPNTr3FRkxE99Xa6IFQyxol7bXeGyio0C3IPeaZYOzPtd5NNYWwd5k2gWZBft4fYMTlXTak6kar8ymsv4oSaM53X+0sOmkVpbX7SthbVENshJGrT+vlnB8fZeaNm07juS938fqqA7z89T72Hq/hb9eO6dT3p7DKpT4eKKmRQEk46fnWLVCqarBSWW9xGhAJ3uP1r9LQoUMZOnQoTzzxBFdffTUxMfIj5AuqqrL7uPYH8/R+yd08mq4hOymasb2T2Hqkgi9/Os6sCX3dUu9EURLCj5gIIxFGA002O+V1lm4NlNpMvXNTlLpb9fKK9MFw+TwtBe/4T66Gt4fWaRbk7v2Zjv2gpegNnA6pQwOye/08RpgMnXIm1Z3vdp2kFuELHGrS1af1buEeaDQoPHrhMAZlxPPYou0s/amQw/Pr+Mfs8X6bPByvdAVKeSW1MMTvoQtCyHOkrI5DpXUYDQoxEUaqG6wcKasjsWd4tKU5kfic//XEE08QExNDcXExa9eu5dtvv6W4uLgrxhZWKIrCsvvO5NejrIzMDt8GhDNHaWmZX2wvAFz24KIoCeGIoigkOuuUurdo36koNTdzcKgiqgp1oWTNrCiQORIm3wc3f+qwIH8f+k5yLbPjf7DiKXj9LEwvjWDcoddRfvpfpyzIO9Ns1h3d+W5PYTV2+8nVx+RgSS1f7ypCUbS0u7a46tRe/OeOM0iLiyC3oIrnl+32e5/uitLBklq/t+MNFqmBEoIcXU0a1zuJAema+6ik3/mHz4FSXV0dt956K9nZ2UyZMoWzzjqL7OxsbrvtNurq5ENoD6NBoXccYVmfpHPhyCwA1h8opai6gbI66aMkhDfJjkCpspsNHap017tmN/jRZiN6+UfQ1Cn5Q2QcDLkAzNGueT1PhcEXgjkGpbaIPmXfYvr4F/CXAfDmOVDre++QqvrO9VDSyUmNJcJkoLbJxtHyk6uQ+p3v8gCYNiSDfmmx7S57at8U/nDZSAD2Fde0u2x7HPdIveu6QGnl7iKGP76Uf67L67J9CEJn0euTJg9McxrLnGy/Q4HC5zv2X/3qV6xatYrFixdTUVFBRUUFn3zyCatWreLBBx/sijEKIUTvlBhG9UzErsL73x9BVbUHwykxEigJ4UlStHZtl3dzoOQyc/C8wVcUxdV0tjud77qCEVfADf+Fh/Ow3rCIvRkzUTNGACpU5kOMm4nChjdg8ztQebTdTXbW8U7HZDQw0PEk92RKv6tqsPB/mzRL8NntqEnu9EzSbuQKKvx3OTxe1ej8f15p1wVKL321F4tNZc1eaeApBCd2u8p3+zVV/cxBafRO0UpljpSJmOEPPv8l+N///seHH37I1KlTnfNmzpxJdHQ011xzDfPnzw/k+PwmWBvOngxcOCqT7fmVvPf9YUBrymkKYxVNOLlJDJJeSjWO2prmfZRAC56qGqyhrSi1hykStd8UcnvWkDNzJub6Eig/6HLIs9s1J706x81t+jCt2e3A6dBnIphddTHVja3XevnD0Kx4cguq2FVYzYwRbbvFhhMfbjpKbZONgRlxnDXIuwaXWY66pKLqBqw2u89/L2oaPa/t/PJ6Gq22TtWYtcb2o5VsdfR/Kq5ubH9hQegmcguqKKttIjbCyNjeSex1WOcfEUXJL/xKvevRo0eL+RkZGUGVeheMDWdPFvT0uwJHca1YgwvhTHKQ9FJqr7bGaREebopSWyRkedYy2Rrh9DnQ8zRAgeKdsO4V+Nfl8GwOfPGIc9FAKUqgWYQD7D5JnO9sdpV3HClpsyfleG0ckhYXicmgYFehyI8ApNDxtyY+0kRcpAm72jVPz93T7XSjIkEINvT6pDP6p2I2GuidoqfeBc89eijhc6A0ceJEnnjiCRoaXBJ5fX09Tz31FBMnTgzo4ITQpF9aLMOyXIYVqbFi5CCEL65eSt2rKLWVegeuuqWaxiC0CD8RmKNh6iMwZwU8dACu+odmQR6XCdZ6D0WprqaKP5gWMKFpPTR2LsAZmqn9Du48SVLvVu4q4lBpHQlRJq48pafX6xkMCj0StM+goNL39Du9PqlHYhQ5aVqa0YHiwKbfldc2eTTILa5uRFVPLpMOITRwr08C6JWsp97VyzXrBz4/MnvppZe44IIL6NWrF2PGjEFRFLZu3UpUVBRffvllV4xRCEFmjsxkZ4F2cyBGDkI4kxQkipKeetTczAEI3xolf4hJgZE/0yZVhaJcD8vxlOKNXGNaDoeXw7OPa6l5A87R0vQyR/nU8FZXlPJKammw2IgyBzYVLNhY8N1BAK4/vY/PVvnZSVHkV9RTUFkP+NZCQw+UMhOiSI6NYEd+VcDrlD7YdIRGq51BGXHsLaqh0WqnptEakBRNQQgUDRYbG/O0np1nOgKl7KQoFAXqLTZKa5vEhdhHfFaURo4cyd69e3nmmWcYO3Yso0eP5s9//jN79+5lxIgRXTFGIQS5cFSW8//ypRTCmWAwc7DZ1TYbzrrPC9saJX9RFOgxApL6OGcdU1N5x3oeFVE9wW6FvDVOC3KeH6L1dPKS9PhIUmIjsKs46wTCld2F1Xy7rxSDArMm9vV5/cxELT2o0A9FSbcG75EQRT9Ho9lAWoTb7Cr/3nAIgNvP6ud88CB1SkKwseVwOQ0WO+nxkQzuoZnJRJqMZDoUWzF08B2/krCjo6OZM2dOoMcihBEDM+KcT96kRkkIZ3RFqbIbzRzcA6B2AyVRlDpkn9KHz6y3YD9rOLcMtcP+r7Xg6OBqqDkOSW5BwO6lkL9ZU5t6ngpGz3OvKApDesSz7kApuwqrGNUrfJs9LnSoSTOGZzpTfXwh22HocMwP5zu92WyPhEj6pWt25IFMvVu1p4gjZfUkRpu5dExP5n+zn5pGKyU1TfRPD9huBKHT6PVJZw5M86gR7JUcTUFlA0fL6xnXxzfF9mSn+9rIC2HPgzMG87fle7hgZFbHCwtCiKIHSt2pKOmBUoTR0KrTl9PMQRSlDqlyr/VK7QWpAzQjCGsjHN0IqQNdC//4H8j9GFY/B1GJ0H+qFjQNOBcStRqdoVl6oBS+hg7ltU0s2pIPwC2Tc/zaRqYjUCqs8t2ZS1eUMhOjyEnVAqVApt69852mJl19ai+iI4ykx0eSV1onipIQdKzdp9mC6/VJOr2TY9iYV84RMXTwGQmUhC7jgpFZEiQJYY+eetedNUrVDbqldes/6XGRWjBXLYFSh7R5Lk2RkHOm57zhl2rpe/tXQkMF5H6iTQA9RsKclSeF891/Nh6m0WpneFYCp/dL8WsbWY7UO38UpUJHD6UeCVHOBrfHqxqpbbQS24pdvi/kldSyak8xigI/n6CpiXo6uTjfCcFEZZ2F7UcrAJg8MNXjvV4pLkMHwTckUBIEQegEybGu1DtVVb22RA4kNR1YWsdJ6p3X+GQPrptC2G2Qv0VL0du/Ao5uAlMUmCKcznfn5c+DDVs1tSl1gE+mEMGMxWbnX+s0xeWWyd5bgjdH76XkT41SkZuZQ1JMBMkxZsrrLOSV1jIiu3Ppjv9erx3b2YPTyXEEYenxWqAkipIQTKw7UIJdhQHpsc4HDzq9k8Ui3F/CNlCShrOCIJwIdEXJYlOpbbK12vC1q9Fv7ltzvAOtvwxI6p036IpSgi9uZgYj9B6vTdMehboyrZ4JGNwjngSljhvtn8IXDrUpqa+WojfwXOg3xcN1L9RY9tNxCiobSI2N4JIx2X5vJyvJv6azNrvq7L2kp+/1S4ul/HAFB0s6FyjVN9n4YNMRAG5yM6gQRUkIRta61Sc1R68bPCpNZ33GZ9e7/v37U1pa2mJ+RUUF/fv3D8igAoE0nBUE4UQQZTYQYdJ+Srurl1KVni4W2frNvShK3lNVrzfu7YTtc0wKZAwDIDrCSJ+UaJ6zXktFj4lgMEPFIdj0Nvz3Bq3h7Yo/BmDk3cNXO7WA8OrTenfK/jwtNhKz0fems6U1jdjsKgYFUmO1hxb90jS3r7xOOt99sjWfqgYrvVOiOXtwhnO+KEpCMPJtG/VJgLPpbH55PXa79FLyBZ8Dpby8vFZVmsbGRvLz8wMyKEEQhFBBURSSu7mXUnvW4ODWR0kUpXax2OzUW7S/b16l3nlJr8ws3rBdwocjX4WH8+D6/8L4OZDcT7MgT3BTYsrz4KNfwvYPobblQ8lgY2+RVns1rk9Sp7bj2XTW+6feupFDenykU4Xqpzed7USgpKoq/3SkFM6a0BejwZVSKIqSEGwcLa/jYEktRoPChAGpLd7PTIjCZFBostk5Xu17euvJjNd/CRYvXuz8/5dffkliokvOttlsrFixgpycnIAOThAEIRRIio7geFVjtwVKHaXeORWlxu5tihvsuCtubZ1LfxiaFc/Snwo1Q4fI/jDkQm0CKN0P0W52vXuXa256P/4HUKDnKVpdUxsW5N2J3a6yr0jrDzUoI67T28tKjOJoeT0FPtQp6TVNep8YcClKnemltOVwObkFVUSaDFxzWm+P90RRCk4KKxuY889NzJrQl2vG9+54hTDiO4eaNKZXYqtquMloICspiiNl9Rwtr29RwyS0jde/uJdffjmgPT29+eabPd4zm83k5OTw/PPPB3RwgiAIoYBuEV7RTb2UOqqrcdYoSepdu+gBZ0yEEbOXNTLeoDvftWoRnjrA83WfCTDpXq1/0/EdWp+m/M0uC/KffwS9Tg3Y2DpDfkU9DRY7EUYDfVJ8753UHO3mrZwCH5zvjle7HO90chyKUmdS73Q16dIx2STFePYC1HsDltR0n4GL0JKvd/3/9u48Pq66XPz458yafW2zNem+09KWbgIFytJKCwiCen+ggFdZ1AJK73VBvQJe78UFWa6tClcBNwQVgXqtlUKBUmhLt5TuW9KmbbZmnayznt8fZ86ZyT4zmclM0uf9euWlJJPJN8k30/Oc5/k+Ty37zjbz8s7T512g1N/5JF1JdgqnGzo43dDOwvGRdac8H4UcKPl8PgAmTJjAjh07GDWq71+GEEKcT+I9S0kPgPpqJBHIKHnkwq4fjgHarEdK73x3tKYFr0/tUsbVQ8Fs7Y3/BEeV1kXv+Fta4ORqhVFTAo/d8WtoKNOaQoy9BKxJfT5tLOjZpImjU0NuvtAfvfNdOBmlwLDZoEDJP0upsd1NU7urR6AzkHMtTtbvqwLgzkvG9/i4Xnrn8vpwdHrITB7EeTYRNWebtI5ujXE6KxovPp9qDJrt7XySriQ7BaiXFuFhCvuVrby8PGpB0mOPPcbChQtJT08nLy+Pm266iSNHjnR5jKqqPPLIIxQVFZGcnMzSpUs5cOBAVL6+EEJEg975rjlO/0AP1NJaD6DcXhWnxzdk6xpuAoFSdC98x+akkGw14/T4whuEmlEI8z4Hn34evlEGX9oCSRmBj5f+Abaugd99UmsK8YdPw/ZntHI+NfYHtvXzSZOjUHYHwYFS+GeU9I53AKl2i1GKF0n53UsfVuD2qswbm8WsMT275iVZzcbfmpTfJY6z/o5u8ZxpFw+Hq1uob3ORbDUzb2x2n4/TGzpIi/DwRHTb7K233uKtt96itrbWyDTpnnvuuZCf591332XVqlUsXLgQj8fDd77zHZYvX87BgwdJTdXuCP34xz/miSee4IUXXmDq1Kn84Ac/YNmyZRw5coT09OHbUlUIMXJkpcY3o+QwAqXeL/BTbYGX+pZOz6C6k41kYc1QCoPJpDC1IJ29p5s4Ut3CpNERBBYms9FJz3DJA9qZpuNvQms1HHtDewMonAv3vBPTeU3HavTzSdH5t7jAf24irIySo2dGCbTyu2pHJ+V1bf1ePHbn8fr4w/YKoGtL8O5Gp9tp6fRQ1+qMWqAoBudskx4oufD5VEz9ZW5HED2btHhijtGBtTd6i/DTEiiFJex/DR599FG+//3vs2DBAgoLCwdVwrFhw4Yu//3888+Tl5fHrl27uPzyy1FVlaeeeorvfOc73HzzzQD85je/IT8/nxdffJF777034q8thBDRomeU4tf1Tvu6fTUgMJkU0uwWWp0eWp0e4zC66EoPlAbVGrwP0/O1QOlwlYOVswuj86QX3KS9qSrUHtQCpuNvwqmtkDMhECSpKvzlX6HgQq0pRMHsqARQx/RGDvnRCRSKsiLIKPXSzAG0hg7byhrCzihtPFhDtUObC9Xf72lUmp2yc22SUUog+owgn6plh8MtuRyuQjmfBIGMkpTehSfsQOmXv/wlL7zwArfffnvUF9Pc3AxATo52yKy8vJzq6mqWL19uPMZut3PFFVfwwQcf9BooOZ1OnM7AC5fD4QDA7Xbjdsc3Hat//XivQ4hQyH4NXYZdu4vX2OaMy8/L0aF9zRRL37+vVLuZVqeHptZO3JmJdQFxoNKB1awwJS8t4ptv0divjW3aRXeazRz13+PkPO1u7qEqR2z2SM5UWDQVFn1FO8vU6QD969QdxXrgVTjwKrz1KGpqHurEK/FNugp1wlJI6dlOeCCqqhqld+Ozk6LyPY1K0S5JaluctHc6Q2qooWeUclO6/s7GZmuBU1lta1hr+80H5QB8Zv4YTKoPt7v3UtVR/ixyTXN7RN+7vL5Gl9vrM/YCwDlHO6nWkZ9Rcnp8fFiudbxbPD6r3/1UkK697lc1d4T896Ubafs1nO8j7EDJ5XJxySWXhPtpA1JVldWrV7NkyRJmzZoFQHV1NQD5+fldHpufn8+pU6d6fZ7HHnuMRx99tMf733jjDVJSBt+VJxo2btwY7yUIETLZrwM7Ua8AZsora1m/fv2Qf/3aBjOgsH/PDtqO9/Egt/aYtza/T0Vm4gwcPNMGP/lI+6cow6oyLUtlWqb2lhFBPDeY/br7tPZ7bKytZP36MxE/T2+am7Xn3l1WM4R7pBQAm6eFouI7yHPsY3TrQSxttSj7Xsa072VUFA4WfYbj+deF9cxNTmhzWjChcmjHZo5FoUmgTwWzYsarKry8bgM5AyQ+XV5wdGp7Z++2zRwNuqKpb9B+3nvLq0L+XTa7YFu5BQWVvNZjrF9/rM/HttaZABPb9h5idGPk56bl9TU66jvBpwY2wPo332X8eXA643gzdLgtpFlVju96j7J+YkOfChbFjEdVeOn1DeRG0PtlpOzX9vbQyw/DDpTuuusuXnzxRf7jP/4j3E/t13333cdHH33Eli1benys+x3G/ro2PfTQQ6xevdr4b4fDQUlJCcuXLycjI6PXzxkqbrebjRs3smzZMqxW6ZIjEpvs19Dlljfw3NGdKPY0Vq68dMi//iN73wbcLFt6GVPze786eO70dmrONHPB3PlcMyNvaBfYj7/uOQsfaReaDrfCjnMKO85pH5uWn8aSyblcOimXBeOySbb1fbYqGvt17z+OwJlTzJw6kZUfnxrRc/Sloc3FmoPvUO9UuOLq5aT20aEwdv4FANXjxHNmO0rZ25hOvIVSe5Bpl32SqZOvAUA5vR3Th89o2aaJV3UdhhvkveN1sHs340el8Ynro7fnf3p4M2eaOpk5/xIuGmCI7cn6NvjwfVJsZm6+YVmX64Jp59r41ZH3aXRbWLFieUiZylf3VMKu/cwak8nnPvmx/r/2O2Vsrj5OVn4JK1deENL3FkxeX6Nre3kD7Nlp/PeMuQu5ctroOK5oaDz55nGgjCtnFHL9dRcO+PifHd9CWV07k+cu5uKJoWeSR9p+1avNQhH2K3VnZyfPPvssb775JhdeeGGPH9gTTzwR7lNy//33s27dOjZv3kxxcbHx/oKCAkDLLBUWBmqFa2tre2SZdHa7Hbu9520oq9WaML/cRFqLEAOR/TqwURla7Xdzh3vIf1aqqtLq1M7WZKcl9/n1M/wtjDs8akL9PhvavQDcMKeIWxeWsPlYHVuOn2P/WQdHalo5UtPKr98/RarNzMv3XtxrF7Jgg9mvrS5tLdmp9qj/jPKzrOSl26ltcVLW0MlFYTQYiCqrFaZcrb3xA3BUYUnJAYv/+z3xBhxeh+mwf8j86Bla+/FuLcjL67Uyp6n56VH9WRVlpXCmqZPa1oH/luratN9XQUYSNlvX9OPEvAxMCrS5vDR1+sjLGPj2+QdlDQBcPnX0gF+7IEv7m69vcw3q+5fX1+iobulaSuVw+s6Ln+vWcm3PXjY1L6TvtyQnlbK6dqocke3bkbJfw/kewg6UPvroI+bOnQvA/v37u3ws3NpyVVW5//77efXVV3nnnXeYMGFCl49PmDCBgoICNm7cyLx58wCt9O/dd9/lRz/6UbhLF0KImDCaOXS4h3xOkdPjw+3VSun669amtwjXg6pEoR+GH5OVzCWTR3HJ5FHAdOpbnbx/op4tx86x6XAtda0u1u+rGjBQGoxYdb3TTStIp7bFyZHqlvgFSt1ldGtYMPszYE3RmkKc3QXnDmlvW9eAJRm+8gHkTOS4/3xStBo56PQ239UhdL7rq+MdgM1iojg7hYqGdsrr2gYMlFRVZctx7azHkskDZyL0WUp1refXzJ5EpbcG1zXFcFSDo9PN24drWTYznxTbUGeGu65j7+kmoP/5ScECLcKloUOowv4Nv/3221H74qtWreLFF1/k9ddfJz093TiTlJmZSXJyMoqi8LWvfY3//u//ZsqUKUyZMoX//u//JiUlhdtuuy1q6xBCiMHQB856fVp2J9pzePqjX9wrStc24N3pgZL++ERxrlULlLp34stNs/OJOUV8Yk4RL31Ywbf+uo+dpxpjupZYB0ozCjN471gdh6tCL/sYcgWztLel34L2Bih7G45v0gbf+ryQNR7Qhs1+w/ISK6pS4PCNMOEysA/+UEihv/NdZQid7wKBUu+HmcaPSjUCpcUDlBkdrm6hrtVJstXMReOyBvza+n6VrneJQR82q4vl0Nln3y1jzdvH+daK6Xzpikkx+zoD2VHegE+F8bkpjPFnOAditAhvkBbhoYpfKAz84he/AGDp0qVd3v/888/z+c9/HoBvfOMbdHR08JWvfIXGxkYWL17MG2+8ITOUhBAJI8lqJslqotPto6ndPcSBkr81uM3S79wQfU2Jl1HSLnb7a1m+YLyWfdl7ugmXx9fvrJDB0H+WsWgPDjDNf37scHVLTJ4/6lJyYNYt2puqQksVmExax7tqBz83v8vo8mYofwlMVhj7MZh01aBakBdmhJ5R0ofN5mf2ni2aOCqVzUfPhdQifMuxwCwau2XgOWN6Rqm+zXlezexJVPoMpXG5KZyqb6ehLXbd2fQ5RMf97fHjZcdJ7cbRogk5IX9OiTFLSTJKoQo7ULryyiv7LSvZtGlTyM+lhjA5XFEUHnnkER555JGQn1cIIYZaVrKNancnTe1uSkL/d2vQ9MCnrxlKOv3jrYmWUfLfkR+d1negNGl0GtkpVhrb3RyobA5rgGh/3F4frZ3abClHp9soo4pVoDu9MBAoDXWJ5qApitHYoa7VhaPTzbfM9/DMxU1YTrwJjeVw8j3t7a1HYcLlcOffwv4yhf4745VhlN51n6GkmzBKG1wfSqD0XoizaHS5aVq5rdur0tzhJjs1sVrun2/00rtZRZmcqm+PaeldQ5v23KEE87G046R2Pmnh+DACJWOWkmSUQhV2oKSfT9K53W5KS0vZv38/d955Z7TWJYQQw0pWipVqR2dMSz56E2q5WHqCn1HqL6OkKArzx2Xz5qFadp1qjChQOlzt4HuvH6CuxUmL00NLp5vOPmbkZCTHpthicl4aZpNCc4ebGofTOI8z3ByrbcGHiRNZl2K5/krtnfUn4MQm7WxT+WYonBv4BFc7/O6TWvA0+RoYMx/Mvf+MC40zSgPf8e5r2KxufIiBUqfby/Yy7XzS5VND65Rmt5jJTLbS3OGmrtUpgVIc+XwqlU3aXpg1JpO/76uK6euwPlg8lPLQWOl0e/noTBMQXqCkl97VtjjpdHtJsg6cPT3fhf2vwZNPPtnr+x955BFaW+ObhhRCiHjRzyk1dQztQD69XGygLIieUUqkM0qdbi8O/3r6yygBzB+Xw5uHatl5spG7Lgv/a/36vXI+9HeI6i7ZaiYtyUJ6koXZYzKZmheb0m67xczEUakcq23lcLVj2AZKesnR5LygRg65k7S3RXeDxwnuoDvWpz6A09u0t80/hqRMmLhUC5omXQ2ZY4yHFmZqd7xrW5y4vb5+h2LWOLQgu7/SO4BTDe14fSrmPsrjdp1qxOnxkZ9hZ0pe6M0pRqfbae5wc67FyZQ+2vLH09YT9dz1mx08dsuFfGJO723eR4K6Vicurw+zSTGyto0xLL3TM0pVTZ1xywzvPd2E26syKs3OuNzQZ4Rmp1hJtZlpc3k529TBpNED7/fjtS3c9+IeLs5QWDmYRQ9TUbtt9rnPfY5Fixbx+OOPR+spB2Xt2rWsXbsWr9cb76UIIc4D2SnaHeXmOGWU0gaYyxPoepc4k9Xr/I0cbGbTgFkc/ZzSzlMNYV+caB3NtNKq7994AQvG5ZDuD4xS7ZawJtQP1rSCdH+g1MLSaYkzzyocx2r0QKmP4MBi1950RfPgxrVatunE29DZBAdf194APvEzuOgOAHJTbVjNCm6vSm2Ls89D6j6fSm1L313vAIqykrGZTbg8PiqbOijJ6f2C8j3/+aRLJ48Ka1+NSrNxvDbQkCTRrNt7ljaXl3WllSM6UDrjP59UkJFk3HCJZUZJf+4OtxdHh4fMlKFvl603tlk0ITusPasoCiU5KRyubuF0Q3tIgdJvPjjF4eoWPO1D9zqZSKL2XW/dupWkpMS5O7Zq1SoOHjzIjh074r0UIcR5QM8oNbYPdUYptNI744xSApXeBZfdDfSP/ewxmdjMJupaXZyqD6++/sS5NqqaO7FZTHxmQQkzizIoyUkhK8U2pEESaJ3vAI4Ml4YOvTimtwYPNfuSmgvzPgeffgG+UQZffBOu+BYULwQUKF5kPNR04BV+a3+cO83/pOHUAa2JRC8a2l24vSqKAnl9lG2aTQpj/XfbT9b3XX635bg24fiyKaGdT9KNTteueRK1893BKu33pLdyH6n080ljspKNEsimdndI5+DD1en20u4K3IAfTPldc4cbry+yNernkxaMC/9ArF5+F0qLcFVVeftILQBn20LrLTDShJ1Ruvnmm7v8t6qqVFVVsXPnTv7jP/4jagsTQojhJDM58A/0UNIDn4FK74wzSglUeqdfYI7q53ySLslqZnZxJrtONbLzVKNx/iQUW45pF8ILx2fHvSZf73x3KJFbhA9AL72LaIaSyQwlC7W3Kx/SWpAnB505O/x3Lvbt4mLrLnj1N/D2OK1Eb/LV2hknfwty/XxSbqq932B3wqhUjte2Ul7XxmVTep4/qm91cqBS+12EOotGN8rf0CERZyl5fSpH/cF4RUP7iD6Pol/wj8lOJtt/w8rl9dHu8pI6QKY9XN1f36ubO42bH+HYXdHIzT//gHsvn8hDK2eE9blen8quCDre6Yqz/Q0dGge+4XTiXJvx8+3wKpxu7GBS/vl1Hi/sW2mZmZld3nJycli6dCnr16/n4YcfjsUahRAi4WUbZ5SGuvROP6M0DDNKrQN3vAu2YJx2Qb3rVO9njfqyxehoFtpB/ViaWaRdVB2rbU2o30WoGttcRmAQStnOgFJyurYRv+IbvD76S7zvvQCvYoGmU7Dz1/DSbfDjSdCpBTVGx7vM/veO3vmu7FzvGaX3T9SjqjC9IJ289PCqYvQGJHUJWHp3qr6NDreW+fCpfX//I4E+Q2lMVjLJVrMxPkA/SxRN3Z8z0ozS1hNa85CXd54OO6t0pLqFFqeHVJuZ6QXhn43TS1DPNAy89nf82STdoaqRnZ3sTdih9vPPPx+LdQghxLBmNHOIV+ldiGeUEqmZQygd74LN9wdKO0+GPnjW7fWxrUwLrMItrYqFoqxkxuakUNHQzo6TDVw5zM4pHT+nZZPGZCVH/W49AHkzODjx8zxz+nLumZ/Ht2fUa2ebjr8JyVmQpAWa1Y5O1lj/hxxnOuyrgYlXaiV+3eiBUl+ld3q2MZK9oc9SSsTSu+6zuo7VthhB+khzNiijpCgK2SlWahzOmIxq6H72KdIW4XqWpqndzZ6KRhaE0blOL7u7aFw2lghKh0vCyCi9e1T7+7BZtLN+B6tauH5u2F9yWIv4VW7Xrl0cOnQIRVGYOXMm8+bNi+a6hBBiWMlK0Uvvhjij5Ay1PbgWyDk9vpgObQ1HpIHSsdpWmtpdxs+8P6Wnm2h1eshJtTEzghKZWLhkUi4VDe1sPVE/7AIlvZFDRGV3ISryd76raDHBtGu1NzCySQCNDfV8xrQDa6sXXtkIKDDmIq2L3uSrYcwCMFsYn9t3i3BVVY1Bs0t6KcsbiJ4JTcSMUvfSzngPR40lfdis3vgjO8VGjcMZk4YOPTJKTZEGSoEg5c1DtREFSuG0BQ8W6hmldpeH7f6bTJ+ZP4bfbz/NwWFcMhypsP+lrK2t5aqrrmLhwoU88MAD3HfffcyfP5+rr76ac+fOxWKNQgiR8LKS45tRShvgjFKqPXA+oS1BSr7CDZRy0+xGy+ddp0LLKukdzS6ZlIupj/bQQ+3iSVrm44MTdTH7GrWOTr7+571GIBAtYTdyiIDeNr3K0e0iNCkQ6J5thTvc32Jn8R2QPwtQ4ewurf34cx+HV74IwMTR2n4509iBy9N1blZZXRuVzZ3YzCYWRXDRqe/bRMwo6SVSeuvoozUjs2RKVdUuGSUIdCCNRaCk3wjTq0WrIiy904M7gE2Ha0L+PFVVBx0o6UNnG9pc/f5bsPVEPS6vjzFZyVw3uwCAQ8O4CU2kwg6U7r//fhwOBwcOHKChoYHGxkb279+Pw+HggQceiMUahRAi4RkZpbjNUeo/o2Qxm0j2H+ZOlPK7cM8oQXCb8NACJb20akmYB/VjSQ+UDlQ6YpKB7HR7uft3u/jzrjN87eU9xh6JBqORQ4xmTUEgo1TV1PdFaGWLh62+Cyib8w348vuw+rDWgvyCmyEpC8YvAbSOeJNt9ay3fJ32//uW1p7co+07PYhcMD6bZFv4jQ700rv6Nhe+CLuXxYqeUdLbgh8boRml5g43bf4udEZGKdXfgTQmZ5S0v6UJ/kxlJKV3wcEdwNGaVk43hNbJ80xjBzUOJxaTwtySrLC/NmiNf/RS8f7K7945or12Lp02mukF6Sio1Dic1CdgBjWWwg6UNmzYwC9+8QtmzAh06Zg5cyZr167lH//4R1QXJ4QQw4XRzKF9aC+aWkNsDw5BQ2cTZJZSuBklCLTD3RXCOSVHp5u9Z5oBWJIA55N0eelJTM5LQ1Uxzk9Fi6qqfPe1/ew93QRoHdl++e6JqD2/Xno3aQgySudataGzvdGbORjDZjMK/S3In9dakM+7HdDmxtyYdphppjNklT4Dv7sJfjQe/vBprDufZbxSxZLJPc82hSLX3/XO61NjOrcnXI5Ot5GxuMEfKJ2qb8fpGXlzJfXysVFpNqOrXyCjFP3XOf33PMN/3quyuSPsltnnWp04PT4UBS4amwXAW4dCyyrp2aRZYzIjCu51Jdn9N3QIbgu+dFoeaXYLo/x/audb+V3YgZLP58Nq7VniYbVa8fl6f0GLh7Vr1zJz5kwWLlwY76UIIc4D+tBBnxo4NzQUAs0cBh56mEgtwlVVNQKlvubg9Ga+P6O090xTj1Kq7radqMfrU5kwKtWoy08Ul/izSlujXH73mw9O8pddZzAp8MUlEwD41XvlVPaTnQmVo9NNtT9AmRzDQCk31YbNbEJVAwFRd/o68jN62TsmM1gDHexOFX6cVa4HOFJ4I6QXgrsdjr3BbQ1recf+b1xn3xvROq1mk3GDJJFahB/2l90VZSYxJS+N9CQLXp/Kybrw5o8NB93PJ0EgUIpFtlYPlPTzjp1uH81hVhHo2aSCjCSunaWVtL11uLa/TzHogVIkbcGDDdQiXG8LbjObjNeq4lQtINTb6Z8vwg6UrrrqKr761a9SWVlpvO/s2bM8+OCDXH311VFd3GDIwFkhxFCyW8yk+O/wNQ/hOaVQS+8gsVqEtzg9OP2BzqgwSu8mjkolJ9WG0+Njf2Vzv48NtAVPnGyS7hLjnFJ91J5z64l6/vPvhwD49soZfPe6GSyakIPT4+Pxfx4Z9PPrZXf5GXYykwcOzCNlMink+9t+91ba1On2GmcBCzIGbuldkFfA330f4zd5X4fVh+DLH3B6wbfY4r2ADuyUzA26dtn8ODx/Hbz3BFR91OfAW10inlM6XK1dyE4vzEBRFOM82bEROHi2+/kkCHQgbYjB67DezCE/I4lc/3DbcBs6nAkakHv1jHwAtpc1hPS6vMOfSddHJURKbxF+uo+Mkt4WfOGEbKO75RgJlEKzZs0aWlpaGD9+PJMmTWLy5MlMmDCBlpYWfvazn8VijUIIMSzoDR2GqgzH61ON+vy0UAIle+IESnX+C8t0uyWsEhJFUbhorN4mvP+ytUBHs8QLlBZPyEVRtLMjtS2Rdc4KdqaxnVUv7sbrU/nkvDF8cckEFEXhu9dpZfJ/3XOWfWf6DywHMhTnk3SF/nNKlb0ESrUObe/YLaaQAjajRXhdm3YKP/8C/my/hc+5v8NDk9dhSgm66Dy6AU5tgbcehWcug59Og1e/BPv+Am09g9pRCdj5Tm/kMKNQ+z3pvy+9bHIk0TNKwRnjnNTYZ5RyUq1GiWi1I7xsbWDNyUwclcr43BRcXp9xnrIvDW0u428wnC55vRmoRbjeFjy4K2ex/0d8cIAbVCNN2IFSSUkJu3fv5u9//ztf+9rXeOCBB1i/fj27du2iuLg4FmsUQohhIXOIGzoEBzwhZZQSaJZSJOeTdAvHDzxP6WxTB2V1bZhNitE8IZFkB7UrH+w5pQ6Xl3t+u4uGNhezxmTw2M2zUfxtuS4szuKmudo5lf9afzDs8xTB9Iu0WJbd6Qr1i9BeuopVG8Nmk4zvsz/jR/VsEa5flF48rajrg29+FlY+DlNXgDUVWmtg7x+1Lnpr5oMv6JyPqiZkRklv5DC9QNtfeiv3EZ1R6qX0LhY3rBr9zRyyU2yBYD7sjJJ/QK5/7pOeVXrzUP/ld/qNocl5aUYwGKn+WoQHtwVfOi3QNl/PKJXVtdHuiv+/IUMl4jlKy5YtY9myZdFcixBCDGvBDR2Ggh4o2Swm7JaBszKJVHqnd7wbFUGgpHe+23WqEVVVe71Y1i+E5xRnkjFA6/R4uWRSLgcqHWw9UWd0JwuXqqp845WPOFjlIDfVxjO3LzAOteu+fu10/rG/mm1lDbx5qJZlM/Mj+lrH/C2mYzlDSaffre/tIjRwPmngsjvAaClf1dxJh8uLy+uj1N/sosf8pJyJsGgiLLpb645XsQ1OvAXH34LcSdr5J9BK8p65nHududjNk3E2pAETw/9Go8znUzlSrWeU9EBp5GeUggMlvfROD2qiKZBRslGU5W9jH2aLcD2404OVq6fn8est5bx9uBafT+1zjIHe6TPStuDB9BbhZxrae7yGBrcFnzQ68LeeYYPRaTbOtbo4VNVizLUb6ULOKG3atImZM2ficPSsTWxubuaCCy7gvffei+rihBBiOMlKGdpZSsb5JHto97wSqZnDYDJKs8ZkYrOYqG9zcbK+99KR9wYxSHSoXDJJKwkczDmlZzeX8be9lVhMCj//7EVdLhh1Y7KSjcYOj60/1GcnuYEcG8LSO71FeG9nlGqawwuUslNtxt/myfo2tp6ox6dqM5Z6+3kZLHaYeAUs+77WgvyWXwc+Vn8Cqj9iZuPb/Nj6v9xX+glY+zH453fgxCZwD76cMhKnGtrpcHuxW0yM989Q0s8olde1Rfy7jzWvT+VwtSPsjqFGoJQd+4xSp9tLu7/UOSvFFpj3FWaL8DONgdI70Mro0u0W6ttc7D3T1OfnfViuz08afICiB2ktTk+PZhTBbcG734TSs+DnU+e7kAOlp556irvvvpuMjJ6TzTMzM7n33nt54oknoro4IYQYTvRyiKGaM9ESRmtwSLCMkh4ohdHIQWe3mLlwTCbQ+zkln081go/LEvB8km7hhBzMJoVT9e1GOU443j16jh9tOAzAwzfMZPHEvksMv7x0ErmpNsrq2nhxe0XYX6vd5TEu8GI5bFYXuAjtebde74RX0FvHuz6Mzw2U3205rl0IXhZukw9zUGYyZwLc9RYHpq5it28yPkxw7hBsXQO/+yRs/F7gsao6YFOIaDnsv4CdVpCOxaxd4hVmJpFqM+PxqZyqb+vv0+NiW1k91/3Pe1z71Hv873tlIX9eu8tjNFfoEij5X4fbXV463dFria4HXmaTQkaSJWjeV+iBkqqqPbJgNouJy/0lbm/1UX7X4fKy/6x2NigaGaUkq9m4SRVcfte9LXh3+rm38+mcUsiB0t69e7n22mv7/Pjy5cvZtWtXVBYlhBDD0ei0wPyXoRCYoRRaaZn+uOF+RgkCbcJ7O6d0sMpBQ5uLVJs54qGMQyHNbmFOsRbwbQ0zq3Syro37X9yNT4X/t7CEz31sXL+PT0+y8rVlUwF46s2jOMIcQnuiVrvAHpVmMy5EY8m4CO3lbn24pXcQKL8rr2sLavIxiGyjyQzFC6hb8CA3u77PZzJ+D596HuZ+DtIKYNJVgceeeh+engP/txoO/x2csTsrFDifFMj6KYrC5AQsvzvb1MGqF3fz/57dxmF/uaCeCQ7p8/0X+OlJli7ltRlJFsz+8rVoZveDzycpihLUzCH0QKmx3W1kpYqCsplXT9eCkr7ahO853YjHp1KQkWRkogbLaBEeNOy2t7bgwWb6A6XzqfNdyIFSTU1Nr/OTdBaLhXPn+u/YIYQQI1me/w633pUr1vSL3bQQS+8CXe/iP3BWDyYjDZQW+gfP7jzVM6OktwX/2MRcrOawexYNKb38LpxAyedT+fIfduPo9HDR2CwevfGCkJoa3LqwhMl5aTS2u1n79vGw1qk3Agg+sxBLwUNnu8/Lqglq5hAqvaHDe8fOcbK+HbNJ4WMTB39nfpR/6OzJdjvMuhluWgv/dhimBJ3hPv4WNJ2Cnb+Gl26DH43H/LtPMKX6b1C9L6rZpkPdzifpAi3CwwuUmtpdfP75D3ll15noLBCthO3pN49x9U/f4e8fVWFSMM7N7T3TFHL53ZlezieBFhjGogNpcMc7CATzlU2hD53Vg7vR6fYuZwmXTsvDpGiB7tleZp7pN4QWjM8O6W89FPrQ2eDOd3pb8EUTcoy24MH00rvD1S14ErSMM9pC/hdkzJgx7Nu3r8+Pf/TRRxQWFkZlUdEgA2eFEENNH5xaO0QdsMItvUtPxNK7SDNK/oPEJ8610djW9WIokduCd3dx0DylUC+2Nh6q4VCVg/QkC7/83PyQGnkAWMwmvr1yOgDPbznZ5U7yQIzzSUPQyAG6Dp3t3j49koyS3iJc7zA4ryQr5Exsf/TS0YY2J179Al9RAk0fAC77N7j1ZVh4t9YswufBVPEBM6v+jPXXV0LlnsBjfYO7+Oze8U431f97O1oTXjbr9dJK3jlyjl+8e2JQ6wKtrGv9viqu/um7PPnmUTrdPhZNyOH/7r+Mn3/2IuwWEy2dHsrqQisPPNvtrE8wPesZzUBJL/PL8p+B0md9OT2+kDNXeolt9zXnpNqMsQebeskqRWvQbDC9oUPwLCW9LXhwt7sun5OdTJrdgsvj48S5xCvjjIWQA6WVK1fyve99j87OninGjo4OHn74Ya6//vqoLm4wZOCsEGKo5aVrF27RmIsTCj3gCfWCLy0RmzlEcEYJtAuhSaO1i99dpwLld51uLx/6LyoS+XySbv64bGxmE9WOzi7tq/vzjP+i9faPjSMvjGABtLkol07OxeX18ZMwhtDqJVtD0cgBug6dDS6/U1WVGn/GNpRhszo9UNJdFqUmHzmpNhQFfGrgQroHexpMuxauexwe2AP378a7/IdUZ8xFzRwLhXMDj/3bA/DslbDpv7SOe97Q/1YdnW7jvIl+lkSn/96Oh5lR0jOdFfXtgUAwAkdrWrjtf7fzlT/s5mxTB0WZSay5bR4v3/MxZhZlYDWbmO0/d6h3JBxIbx3vdNkxaKxjZJT8gZLdYjYyipUhdr7rb816m/BNh2q6vN/j9bH7lD5oNnqBUqBFuBa89dUWPJjJpBh768B5ck4p5EDpu9/9Lg0NDUydOpUf//jHvP7666xbt44f/ehHTJs2jYaGBr7zne/Ecq1CCJHQ9NK7ulbXoC4qQmV0vQu1mYM+RynOGSWvT6Xef1GZF2FGCQIXDTuDAqWdp5pweXwUZCQNWZnYYCRZzVw0LgsIrfvdzpMN7K5owmY28flLx4f99RRF4dsrZ6AosG5vZcgXpSfO6YHS0P1MC3s5p9TU7jZK8fLCaebQLVCKVrbRYjYZF84hD53NnYRv4V1sn7Qaz6qdYPJfiqmqVqZXuRs2/xie+zj8eCL86Q7Y9Rto7r/8TW8LXpiZZGQ9dPrsq7JzbSGXTPl8KtvKtT3p8vqo7KUkLBSOTjf/8sxWtpbVY7eYeODqKbz1b0u5/sKiLmVk+nnC0tN9z0cLZsxQ6iWjpH//fQavETDOKAWd0TOajoTY0OFMt9bgwa6eoZ1Tev9EfZc5RYerW2hzeUlPsjCtIHo3KgKld9qa+moL3t0FRVpAe/A8OacUcqCUn5/PBx98wKxZs3jooYf45Cc/yU033cS3v/1tZs2axfvvv09+fmSzGYQQYiTI9d9d9vrUqP4D3ZeIu97FOaPU2K4FkorCoAYnzjfmKQXOKb3vDzaWTBkVtVr+WDPOKZUNHCj98l2tK9gt88cYGcxwXVCUyS0XaQPif/B/Aw+h7XR7jW5pk4eo9A4CQ2ergi7Q9bK7nFRbyCWHoN0k0IPy9KRAE41oGNTQWSXoMkxR4O634Ma1cMHNkJQFzmY4+LqWafr9LV0/t1u26XAvjRx0Y7KSSbaacXl9VIRYcnm4uqVLRibUjGd3hyodNLa7GZVm583VV7B62VSSbT1/d3PHZgGRZJR6Bh168BrNmXbdzyhBUDAfYkOHM/0Ed1Py0ijJScbl8fH+8cBrgd4WfP64bKNJRTQYs5QatVlK/bUFD6afUzpfGjqEdcp13LhxrF+/nrq6OrZv3862bduoq6tj/fr1jB8/PkZLFEKI4cFiNpGbqp9Tin35XWu4Z5Ts2j/w8T6jpF9Q5qbajBbGkdDb5O4904zTn2XQLzCGQ9mdTu8ute1Efb8H2Y/XtvDmoRoUBe66bHDDTf99+TSSrWZ2nmrkLwMc1C+va8OnQmayNeJSyUj0llGK5HySTs8qXTwxd1D7rrtRaXomOQpnEzOKYN7n4NPPwzfK4K63YOlDULwQpiwPPM7dCY9PgT98Grb9EuqOG3f4uzdyAK1kanKYDR22dQvcIw2U9LMsFxRlUJLTM6jR6Rmlw1UtIbX17jejlKo3c4he6Z1+8ys7KFtX1Esw35++ziiBlu29erqWcHgrqPxOb1gTjbbgwQozkzEp0On2ca7V2W9b8GAziwKzlEI9VzmcRfRKkZ2dzcKFC1m0aBHZ2efHZF4hhAjFUDZ0cPgDpTR7iGeU/AFVu8s7JKWBfdEDpVGDvOgen5tCbqoNl8fHgUoHLe5A169Lw52RE0cXFmeRYjNT3+biaG3fh+2f3axlk5bNyB90WWFBZhL3Xz0ZgEfWHeh3vk5g0GzakGbpCnuZpRQYNhv+3vmYf87UDXOKorC6gEFllPrjb0HO0m/BXW9qg291p7dBRwMcewM2fBPWzOerBz7NDyy/Zqm6o9cW5HrZZKjnlPQMZ4o/+xNpoFTmL9scaM+OyUpmVJoNj08d8PyLy+Ojxn8zqvczSv5mDtEsvWvvGSgV9DMYuTd6Fqy4j0HHV/nbhG86XIvPp6KqKh+Wa6WI0Q6UbBaTcc5v89G6ftuCB5uan47VrNDc4e61Q99Ik9h9U4UQYpgxLpqGoEV4uGeUUu2Bcpd4ZpUG2/FOpyiK0f1uV0UjR5u1i/gZhRmDDsKGks1iMi6CPjjee/ldjaOTV/ecBeDeKyZF5evee/kkFo3Poc3l5Wsvl/Z5duW4v1PaUHW80+mBUnUvGaVwGjno7rtyMpv+7YqoB0r6gf6oZJT6ExykTrgCvvS+FjxNuALVbKPAV83nLG+xaPt9sPO5wGO9blBVo2wylM53Xp/Kdn+gdONc7ecVcaDk/7yJo1P7fZyiKEZWaU9FU7+PrW7uRFXBbjEZP/9gejOH2LQHD8ooZWn7MJRmDs0dbqNcurcsGMDiiTmk2szUtjg5UOngVH07da1ObGYTF0axXFRX7M/w/W7bKaDvtuDBbBYTk/POn3lKEigJIUQUBTJKQ1B65w920kIMlOwWMzaLqcvnxsNgZygFW+A/p7T7VBNHmrQLySWT+78jmoguCWoT3pvn3z+J26uycHy2ERwOltmk8MS/zCE9ycKeiiZ+tqn32Up6RmnyEHW80+mld5VBgZLe8S6S0jubxcTEGDT4iFlGqT+KAgWz4NKvwp3rqPjiAb7g+nd+71uOmjMRJl8TeOy+v8DjU7mp/D/5hOkDaqrODvj0h6ocODo9pNkt3HDh4AIlvRHIQIESBDd0aOr3cWeatBK2MdnJvWY5jYxSDAbOZqUEMvh6wB5KRkkvu8tNtZFi6/01224xGx0Z3zxUY7QFv7A4s8vcpWjRGzrs9f+8++p2190FevmdBEpCCCHCYQydHYKLJv3uZEaIgRJAegK0CI9WRglgvr/z3a6KJo74M0pLotT6eSjpDR22l9X3yOy0dLr5g/+O772XRyebpCvOTuEHN80C4GebjnVpjKELBEpDnFHy362vCxo6G8mw2VgLnFGKfQOXvhxq8LLJdxEvj/4qygN7IG9m4IPl70JbLUWnXuN/bGt4selzqM9eCZt+0GcLcv180sLx2cbv/Uxje4/hvwNxerzGvK7JIQSpc0u0mwADBUrG+aQ+SthiOUepa0YpcI5uoPM6/Z2pCqZ3v9t0uNYIlBZEuexO1/2sVKiB0vnU0GHEBkoycFYIEQ/GLKUhKL0Ld44SBLJPetlePAx2hlKwWWMysFtMNLa7aXIpWM0Ki2J0URFLM4syyEiy0OL09Lj4+OOHFbQ4PUzOSzPOMETTjXPH8Ml5Y/Cp8LWXS7vsDbfXx0l/JmEoW4OD1rms+9BZ/c59JKV3sRKXjFI3B6u0cjqj411wluWGp+GOdfgu+SqH1bGYFBWlcjds/onWgrwjKDh2az9ffX7SxZNyGZ1uJ9VmxqcScsc8XUV9Oz5V6zoYyo2RC0u08rIzjR39ljIaZ336CDqM0rsonVHqdHvp8DeYCG4Prt8Yc3p8A3Y6PdPPgNxgV07PQ1Fg39lmY/jsogmx6QcQ3FxjoLbgwQIZpZE/S2nEBkoycFYIEQ966d25GJ9XUFXVuKBNG6CmPFgizFKKZkbJbjEzpzjL+O8F47J7bT2c6MwmhcUTe5bfuTw+nttyEoB7LpuIKYrtgYM9euMFjMlK5nRDB4+sO2i8/1R9Gx6fSqrNbJwZGiomkxKYU+MPkPSMUjgzlGItql3vIqS3Bu+t4x0WO0y8AtPy77M65+cs6lzLgYU/1FqQT1wKaUHB94ufRl27mMvLn2KJaR+XjNUaeOgdA0+GWX4XXHYXSiOQjCSrMUh6bz9ZpQEzSv7SO0enJ+S5Uf3RM1MWk2Jk5UEfOttzMHKva+5n2GywUWl2owSxrtWFosD8sbG5+VMSFLQN1BY82Ax/oFTZ3BnVhhmJaMQGSkIIEQ+B0rvYnlFyeny4vVqpR6jNHCAQKA1Ueuf2+rjhZ1v49C8/6LdldSSieUYJAvOUAC4doGNTIgucU6oz3rdubyXVjk7y0u3cOC+6TQiCZSRZeer/zcWkwCu7z/C3vZUAHKvxl93lp8dlLlVwoOT0eI1BxYmYUWpod0XlojwSh6r9M5QK+z9HNiU/jVqy2Zy6XGtBfsfrgQ+6O+H0hyjnDnOn8n/83vYYF/x+Dvz+U3zevIEJSlXY55T01uDhdGkMpfzOCDr6yM5kJgey7M0dg8+e69mirBRbj7+Dwm7BfF8CrcH7bpGuuzooczwtP53MlNCrBsIRnFEaqC14sIwkK2P9n3uwamSX30mgJIQQURRcehfLGRP6+SRFgdQ+Dgb3Rg+qBmrmsP9sM/vONrPjZCOnwiy3GYieUcqLUqC0YNxICZS0c0o7Tzbi8vjw+VSe3XwCgC8smRDWgNVILByfw6ortZbh33l1H5VNHV1ag8dD8Jwafd/YzKZBDSqOtuwUGyYFVJUhGTTdXUunm9MNWuAwo6CXjFIQ/fd4rLfOd9YkWH2IjRf8kD95rqDJnIvi6YDjG/n0uTX8h+V3lAe3kXcNHDSV+QOliaMGbuSgC2XwrDG4tZdhs6DNtNPPbkbjnJLeyCF42Kwu0J2x/853oWaUAK7yz1OCQMOaWMjPSGLCqFQKM5MGbAvenV5+N1Ar9+Eu9H9dhRBCDEi/u+z0+HB0errc2Ywmo+zOZgmrHCvUjNKuU43G/993tpkJYVzo9Mfp8Rp3eEenRScrsGB8DjmpVqw+FzMHuKOeyKbmp5GbaqO+zcXeM020dLo5WtNKmt3CbYvHDskaHrh6CpuP1bH3dBMPvlxqlBXFK1AqCBo6G1x2F4/sVl/MJoXcNDvnWpzUtjjJG+Js1xH/7LCCjKQu52d6o3cu7HPobEoOf2idzzuesTiWT+euaZ1w/E1q96znraqZlPsDH5pOw//Mg7Efg0lXaV32CmZ3PRtFcOld6PtnXlDnO59P7fH65vOpxmyt/hojZKfacHR6otL5rrcZSjq9oUPlgBkl/xmlnIEDpRmF6YzJSuZsU0fU5ycFM5sU/nb/ErxedcC24N1dUJTBP/ZXj/jOd5JREkKIKEqymo07mediWH6nZ5TCKbuDoGYOA2SUggOl/Wejd8dQ7wxmM5vISI7OvbrMZCv/uP9SHpzljdkZnqGgKAoX6+V3x+v55bvagNnPLh5LRhgNOwbDajbx9L/MJcVmZnt5A//YXwUM/QwlnT6npqq5g+rmyFuDx1o8zynpQ5ZnhHCTYGp+YOhsbyW1bq+PHeVac4eLJ4+C/Avg0q9y5hMv8QfvNYHSu4qt4HPDyffgrUfhmcvg8anw6pe0duTtDaiqGhg2mxf6jZZpBenYLSZaOj1dM1h+tS1O3F4Vs0khv5+sdDSHzvY2Q0lX0Mu8r+5anR6a/AFbKBklRVH4yacu5MtLJ7FydmEkSw5Zmt0SUWnfzKLzo/NdXAOlzZs3c8MNN1BUVISiKLz22mtdPl5TU8PnP/95ioqKSElJ4dprr+XYsWPxWawQQoRIv6Mcy853kXS8A0iza4/vL6Okqio7gzNKZ6IXKAU3cohmViAn1UaU4q640svvXvzwFB+WN2A1K/zrpROGdA3jR6XyyA0XAKBfS08Z4hlKuuA5NYMZNhtr+tDTeHS+O1Sln0/qv+wOYGxOCjaziQ631ygFC7b/bDNtLi+ZydYuZXx66Vy1o5N2lwcu/AzcvxtWPg5TV4A1BdpqYe8f4ZUvQtk71Le5cHR6SFE6GZ8depmt1Wxi9hit+11pL4Nnz/pnKBVkJGEx930ZG82hs8FnlLrTS+8qe/l56vTmE5nJ1pBfsy+ZPIpvXjsdaz/fYzxdUKT9jk6ca6XT3xFwJIrrT7+trY05c+awZs2aHh9TVZWbbrqJsrIyXn/9dfbs2cO4ceO45ppraGuLbOiZEEIMhcDQ2dhdNBmld2FmlAJnlPouRznT2NHlgm//2eaoNXTQn3dUlM4njTT6OQF9sOqNc8fEZWbQpxcUs2JWAQBJVlNId8FjIbisqdYfKCViRkkvuY3HLKV+O951YzGbjMGvx3spv9vqn5+0eEJOl+xsVorNCDxO1vnPLOZOgkV3w20vwTdPwh3rtAG4BbNh4lJO+J//wdSNJD05Bf50B+z+LTQPPPB2Tj+DZ8+EOI8omkNnG40ZSr2dUQqUh/ZFD+4Gag0+nOSl28lNteFT4XB1L2feRoi43n9bsWIFK1as6PVjx44dY9u2bezfv58LLtDubP385z8nLy+PP/7xj9x1111DuVQhhAjZ6PTYd75zRFp6Zx+4mcNO/9DR2WMyOVrTQovTw6mG9qicU4rmDKWRaFxuCkWZScZ5h3sunxiXdSiKwn9/cjatTg/zxmbHraRRDxLrWp3GBXJBZuLtndFxKr3z+VTjInVGQWhZv8l5aRyubuFYbQtXdpvLFTw/qbvxo1JprGjiZH2bUXZl8LcgZ+IVsOz7AJTVVQCw2HIcOpvh4OvaG8DoGTD5au1t/OVg7vo6NrefQMmYoTRA8B7NobN6sNXbGaXCoNI7VVV7zZSfGaCd+XCkKAozizJ471gdByqbjd/ZSJOwhQpOp/Zik5QUuHNkNpux2Wxs2bKlz0DJ6XQanwvgcGh3WtxuN253/AYs6msI/l8hEpns18iN8t91rG7qiNnPr7lde51LtZnD+hopVu0fcUdH36+JH/rvKi8cl4XZBKWnmyk9VU9x5uA7jVU3a3dWc1OtUf3ZjKT9unhiDq/uqeTKaaOYkJMUt+8pzabw3B0XAfH7uWbYtCHCbq/K3tNaOeioKO+daMhJ0S6nappD+5uP1n491dBOu8uLzWKiONMW0vNNHKV1ijtc5ejyeJfHx86T2k2ShWMzezzX+Jxk9lQ0cbzGgXv6qAG/zvEa7frrr9MfZ+bcDpQTm1DKNqFU7kY5dwjOHULd9QKe1ccCNZ7tDZCczaxC7SzVoSoHLe2dJFkDHR9P+88tFWTY+/1+M+za59S3OAf9c673B8CZST1fb3OSzSgKuLw+aprayO3lJlCFf81Fmf2vOVH1tV9nFKTx3rE69p9pwn1R7MYXRFs4v4OEDZSmT5/OuHHjeOihh3jmmWdITU3liSeeoLq6mqqqqj4/77HHHuPRRx/t8f433niDlJSBe9cPhY0bN8Z7CUKETPZr+OoqFcBM6ZFy1qsnYvI1dp/WvkZjTSXr158J+fOONGifd6a6jvXr1/f6mHcPmAEFta6MdJcCmFi3ZS+mM3sGve5dZSbARFN1BevXnxz083U3EvbrLKAm38TlqdV9/o7OJxkWM/VehTNNWpat/MAe1kdhL0bTmXPa39WRU+H9PQ52v+6t175unt3LG//cENLntPg/Z9exs6xfX2G8v7wFOtwWUi0qx3a9x4luiRGn//O27D3KuLbDA36drYe0v/W2mgr+vlcFZkHeLKw5rYxuOUCe4yN8Jisf/TPwM7j6wL+joKKmz+YG6xw2uWfx67/+kwlBybLSY9rzNpw+xvr1R/v8+meq/b+T8tOsX38qlB9Nn05Va6+Jxw7sZX1laY+Pp1vMONwKf1n/FiW99D3ZeVRbc3NVOevXlw1qLfHUfb8667Sf8QeHTrPecjIua4pEe3voIy8SNlCyWq288sorfPGLXyQnJwez2cw111zTZ6me7qGHHmL16tXGfzscDkpKSli+fDkZGQPX78aS2+1m48aNLFu2DKt1aDoYCREp2a+R8+yt4vVT+7Bm5LJy5cKYfI2PNhyBM6eYOXUiKz8+NeTPyylr4FdHdmJJTmPlykt7fLyl083Xtr0NwN03XcW7x+p479UDtCdF53v5vxdLoaaWi+fOZGUUW16PtP16R7wXkED+ULWD+pOB5iI3Ll/KuNzEuPGpyzpRz++O70K1p/f6d9VdtPbr8U3H4WgZi6aOYeXKWSF9ztTaVp4/+gF1LgsrViw3SsV+/k4Z7D/Okqn5XH/d3J6fuK+a9ac/wpOcw8qViwb8Ok8c2QK084mli/nYxL5bXBfr/6elCstHTSheFxPrN/Ez8ybcJjPn6uaSX7IS35SPw+jp/Oz4+0AbH79sEUsm9z37R9lfzZ/LP8KeEdp6+/Ojg5uBTpZfcQlzijN7fPxXFdvYd9bBpNkLuGZGz8Gtvz69DXCw7OL5LJsZ+mDXRNHXfp1+ro3fHHufGqeZj1+7HPMw6TqqV5uFImEDJYD58+dTWlpKc3MzLpeL0aNHs3jxYhYsWNDn59jtduz2nmlPq9WaMP94JtJahBiI7NfwFfonr59rdcXsZ9fm8gGQmWwL62tkpSb5P9/b6+ftL29CVbXuWEU5acwdq32dg5UtmM3hzWzqTb3/UHRBVkpMfjayX0ceraFDIFAqzk3Dao3t8N1wFWRp5/fq28L7mx/sfj1aq5V0XTAmK+TnmVyQicWk0ObyUtfuNRpmfOjvdHnplNG9PtekfO1m88n69gG/ltPj5Yz/LNHUwszQ1pYzFr5RDie3wIm3aProH2R1nqaoaRe8vQtzSyXqdT+lsrkTM14mpvX/sx6VoX1fTR2eQb8m6GeU8jJ6f90qykpm31kH59rcvX680p8NHTsqbVi/PnXfr5MLMkmxmWl3eTnT7DTmdCW6cH4HidlzsJvMzExGjx7NsWPH2LlzJzfeeGO8lySEEH3KS9eCkVi2Ch7sHKW+2oPrbcHnj9OmwU/JS9Nmmjg9nOxlpkm4zrUG2oMLEYrCoAPwmcnWLudVEoW+nxvb3bi9viH7uoeqwmvkAFr7bb0xiz541unxstOftbt4Yu9ZGv1zGtpcNA/QSa6ivh2vTyXVZja6gIbEngbTroWVP2HfLW9zufNJfmq9R2tBPm0lTe1u2l1e5inHGPvrC+HZK2HTf0HFdvB2fU2L1hylDpeXDn/76+xeut5BoPOdHhAF63R7jW6IJdmJlQkdLLNJYbp/743UeUpxDZRaW1spLS2ltLQUgPLyckpLS6mo0Gpm//znP/POO+8YLcKXLVvGTTfdxPLly+O4aiGE6F9ehnZh0NLpidl8iZaI5yj5AyWXp9eW37u7BUoWs8nocLVvkINnVVUN6nqXeC2eRWIqDGqPnogzlACykq1G2VH9ELUIb3V6qGjQzlqEMkMpmD5A+FiNFmjtPd2M0+NjVJqNyXm9DxdOtVuMoKe3QbDBTpzTPj4pLy3ieWkXFmdRoebzs5al1H/iNzDlGqPj3cXJp1FQoXI3bP4xPLccfjIx0IK8vcEIlJo63Khq5OMN9K55FpNivH52p+/Rquaes5T0jndpdkvUhmwnEn2ekgRKMbBz507mzZvHvHnzAFi9ejXz5s3je9/7HgBVVVXcfvvtTJ8+nQceeIDbb7+dP/7xj/FcshBCDCjdbiHJqr28xmro7GDnKKkqtHcL4jxeH3squgZKgDH8cf8gA6VWp4dOt3a3fVT64DvoifODfrceAjchEo3JpAz50Nkj1dqFaX6GnZzU8P6e9BKpYzVaRklvC754Ym6/gY2eVTpZ13+gVFanPe/EQYwUyEy2Msk/82nvmSYgEHS8l/tpWH0IblwLF9wMSVmBFuTr7oeGMrL8c58yfc04WnvOjAqVHihlp9r6/NnoWc/eZimdaQzMUIrmkO1EcYH/RtrBERooxTW0Xbp0ab9R/gMPPMADDzwwhCsSQojBUxSFvPQkKhraqW3pZGwMDp5HWnpnt5iwmBQ8PpXWTk+XO6RHalpoc3lJt1uYmh8o5dEDpY/ODC5Q0i8g0+wWUmwj786qiI3hkFECGJVmp8bhHLJZSkbZXZjZJNBKagGO1WrPsbWsDui77E43cXQq28sbKBsgUDrhPzs1cXTv2alQzS3J5sS5Nkormrhqer4RdIzJToaMIpj3Oe3N54XKPXBsI5zeDkXzSDKZSbGZ+YbvJdKf/hpMuBwmXQ2Tr9GG5YYYtDS2aTelcnqZoaTrL6OkZ8FG0gylYHrFwYHK5j7nSA1n8i+VEELEQF663R8oxeaiST9jlBFm6Z2iKKQlWWhqd9PqdAOBC89d/rK7uWOzunQvml0cKK3w+dSIGzoYZXdyPkmEoUuglJm4gZK+r4cqo3SoSruDP70ggkBJL72rbaXT7WV3RRPQ+6DZYONzw8soTRp0oJTJK7vPsMc/eLbPYbMmMxQv0N6CZKfYmN5+GpOnE469ob0BZI3zD7y9Bqat7DdoavBnlPQMVW/0PVrT7OzxGqlnwYqzR2agNDU/HbNJobHdTVVzp9EcZKQYFs0chBBiuNFLhGodPUsxosEoveujZr4/+ue0dGvooAdKC8Z1beU7eXQaSVYTrYNs6GA0cuhlIKMQfclJtWGzaJcr+QmeUYLAPo+1w9V6Rin8TmMTRqViNim0dHr454FqXB4fo9PtA5bK6aV35f0ESqqqcsLfJGLi6MhL70DLKAHsPd2Ez6dy1h90jAkx6MhOtXKT6/t8eO3/wbLvw4QrwGyDplOw8zl485GuQVLjSa0uOYjeDKK/8sb8jCRj6Gx9t+YRZ41AaWQ1ctAlWc1GQ4e3DtfGeTXRN2IDpbVr1zJz5kwWLozNDBMhhOiPHgzEIqPk9am0ubTzReGW3kFQQwdn10BJ73oVfD4J/A0dCgff0EEySiISiqIYd+yHRaA0BBkln0/lsD+jFEnpnd1iNmZR/XarNoz14gHOJ0HXQKmvoxP1bS4cnR4UJfD4SE0vTMduMeHo1G7ShFvGpjV0UDhjmwCXfhXuXKe1IL/1ZVh0D8y9LfBgjxN+fjH8dBq8+iXY9xdoq+9yRqkvVrPJeM2v7nZOqUu54Ah1y0XaNKzfbz01qMYZiWjEBkqrVq3i4MGD7NixI95LEUKch/L8F3SxCJSCA5xwmzlAILgKzihVN3dytqkDk6KV3nWnn1PaN4hzShIoiUh96YpJXDU9j0v7GTAab/q+HoozSlWOTm0WmlmJOBjRzynpmeSByu4AxuamoCjaa1BdH939yvwd78ZkJQ+6lbvVbGKW/7Wn9HRTIFAKMejI8p8ragjO8gS1IGfJg4H31x0FFGitgb1/hFe+CD+ZxKd238Fqy5+Yqp7q92vpwXxlt3NKRrngSA6U5heTbDVzpKaFD8sb4r2cqBqxgZIQQsSTftEUi0BJL7uzWUzYLeFfiBgZpaBASb9YmlGY0Ws5n36xIhklEQ+3LhrLc59fmNBNQIay611Fvd5JLQWrObJLuSndhoMO1MgBtEyUns3pq/zuxDm97G5w55N0c0uyAHj/eD1N/vlNoWaUcvznipoGmPsEQMFs+GY53LFOyz7lzwJUitsP8YDlNWa2bQ881tkCzWe6fLrenbGqKRAoOT1eavydT0dqMwfQOhTeNK8IgN9t6z+gHG4kUBJCiBjQ543E4oySnlHKiCCbBJDmbwDR4uwZKHUvu9N1b+gQCTmjJEayocwonfbPTyrJifzci97QAbRuguNC7M45UIvwsnODbw0ebI4/UHrjYDWgve6FOj9Ozyjp5XMDsthh4hXaeaYvvw+rD/Nszr/zN+/HcJRcGXjckX/AkxfA2o/BP78DJzZRnKGVLVYFveZX+QfQJlvNYbdwH24+97FxAGzYXx2zs7nxIIGSEELEQF66VoYRi7vLeslcJI0cgj+va0ZJK5foK1AKbugw0LDJvkhGSYxko4fwjJI+aHZsTuRZiuDBshdPGvh8kk4PgPpqEV4WNGw2Gub5AyX9dW9MGE0Rsv0ZpZADpe4yCnmdpdzvfgBz4azA++tPgGKCc4dg6xr43Sf51t4VPG/9EVPK/wAd2o2nM0HNJ0Za2+zuLijKZP64bDw+lZd2nI73cqJGAiUhhIgBvetdfZsLt9cX1efWS+9CvavanX5GSWsPDh0urzFVva9AKbihQ6SDZyVQEiOZvq8dnR6cHu8Ajx6cQKAUeUZp0ug09C7WoZTd6cYbDR16H+Kql95NilJGqTg7mdygbEw4JWx6AwZ9FlIkjK53wXOUrnwIvn4CPvU8zP0cpBdi8XVypXkvn6r9mdYYAjjb1E6JUsPkzJHV4KAvt/uzSi9ur8AT5X/34kUCJSGEiIGcFBsW/1VIfR+HniMV6bBZXfeud3vPNOHxqRRkJPV7ETKYwbNen2q0zZVASYxEmclWrObY/M13F41AKclq5uJJuWQmW1k6bXTInxcovWvv8TGXx8dpfxYlWmeUFEUxzilBeE0RssMtveuFPkcpu/vA2ZQcmHUz3LQWVh/iwI3/4L/dt7LOvAzSCwAto/RfludYc+YWeOF6eO8JqPqoRwvykWLF7AJyU21UOzp581BNvJcTFRIoCSFEDJhMitEuuLYluvXa0Sq9058n+HxSf+Uhs4uzgMgaOjS2u/D6VBSl/3kkQgxXiqIMWYvwaJxRAvj1nQvZ/I0rjS6doTACpfq2HucVKxra8PpUUm1m8jOid0MkXoFSh8tLp1vLjGSn9pPBVxSyJszjWe8N/FvnF4yfS2VDG3lKExbVAyffg7cehWcuC7QgP/h6ROtKVHaLmX9ZWAIE2s4PdxIoCSFEjASGzkb3oimQUYqs9C4tqWtGaaBGDjo9o3QwgoYO+oVjToot4i5dQiQ6PVCKZUOHVqfHyM4ONlBKsprJTA7vdWRMVjJWs4LT4+vSuADgeK12Pmni6LSonskJHlkQTuldlnFGyR3RfB89wLKalQFvTOWl21EUcHtV6tq03//pJifXun7Em8v+CSsfh6krwJoaaEG+6zddn6SyFLyenk8+jNy2eCwmBT44Uc/x2pZ4L2fQRuy/VjJwVggRb3kxahGuny2KtPQuPaiZg8+nhhwoTRqdGnFDBzmfJM4H+v6OZUZJzyZlp1jJiPBmyWBYzCYjQCs/1/V1oKxObw0enfNJugv92WwIb3Crnr12eXx0uMM/N6bPX8pOsQ0Y+FnNJuM1X+92p89QyimZBovuhtte0lqQ3/k3rQV58MBbRyU8ewX8ZCL86Q7Y/VtoPhv2muOtODuFq6bnA/D7bRVxXs3gjdhASQbOCiHibXS6PnQ2NqV3EQdK/ourVqeHsrpWmjvcJFlNzCzK6PfzLGYTFxRFNnhWAiVxPtBnKcUyoxSN80mDpXe+637DxOh4F6XzSbrMZCu3XFTM7DGZTCtIH/gT/FJsZmz+DHZjKLOUumns63xSHwr0WUrNnbi9Pqqaexk2a7HDhMu1FuSzPxV4f/1xSM6GzmatJG/d/fDkzEAL8poDYa8/Xu64WGvq8MquM7Q5h3eGbMQGSkIIEW+xGjo76GYOSYEzSjtPatmkOcVZIZXEzY5w8KzMUBLng6HMKBXHMVDSzyl1zygFhs1GN6ME8NPPzOFv9y8Ja8i2oiiB8ru28M8p6cFVv+eTghRlajfHqpo7qG7uxKdqg8FHpYbwujfhcq2T3l1vwdKHoHhh1xbktYcCj22pgbrjCdsUYsnkUYzPTaHF6eG10uGXFQsmgZIQQsRIYOhsgp1RCup6p5fdLRjff9mdblakgZJklMR5IHBGKXZd7xIho9Rbi3BVVY2M0sRR0c0oDcZgGjoYrcFDbEBT6M8oVTd3GjOUirOSMZlCPK9lMkPxAlj6Lbjrza4tyCcGDbzd8ztYMx+engP/txoO/x2ciXMeyGRSjAG0v9t6KqLzYYlCAiUhhIiRPOPucrRL77S7nJF2vUtP6iVQGpcT0ufqGaUDZ5vDaugggZI4HwxF17vTCRAoBTrfBVqEN7S5aO5woyiBjycCPRsUSemdfkYpK8TSu0J/RqmyuZMzjdrPJpwzVT0EtyBPDZp11dEIZhs0nYKdv4aXboMfjYfnr9NakDt7n3E1lD49v4Qkq4nD1S3s9P87MxxJoCSEEDGit9yNfjOH6MxR8vpUyuq0O8DzgrpK9WfS6FSSrWbaXF7jc0MhgZI4H+j7e6SfUdIDoYqGdmOg9gl/NqkoM5lkW+jlcbFmZJQiKL1rau9l2Gw/CrO01/zq5g6jkUM47cxD9vH/gm+Uw60vw6J7IGci+Dxwagu891MtiNJV7oG2uuivYQCZKVZunDMG0LJKw1Vk/8oKIYQYUF7QeQWfTw29/KIfPp9qlHSMivC8T4rNjKIEytun5KWFfMfUYtaaPuw61cj+s81MzgutxKZOziiJ80CsM0o+n2oMdI1noJSfnkSy1UyH28uZxg4mjEqlLIbnkwYjaxCldw3GGaUwM0pNgdK7cNqZh8WeBtOu1d4AGsrg+FvQ2QSWoPW+chfUn4CieTD5aph8DYxZAObYhwC3XzyOl3ee5h/7qzjXMnNY3iiTjJIQQsSIftHk8amDmgwfrLy+jeYON3aLian5oXd/CqYoXWeCDNQWvDu9/O6jMDrfGc0chuE/lEKESt/fLU4PnRG0ox5IbYsTl8eH2aQYF+XxYDIpjMv1twj3n1PSM8zR7ng3WDn+0rumSLreGWeUQjsPqp9RqnF0Gpm/4uwhCmhzJmotyC//euB9nQ6wJAEqVO6GzT+B5z4OP/a3ID/wWkyXNGtMJvPGZuH2qry8Y3i2CpdASQghYsRmMRmHgKNVfrenognQghWbJfKX8PQoBEr7Q2zo4PR4jYsUCZTESJaRZDHaUcciq6RffI/JSsYS58HNeuaovE5b04laLWCalGAZJb30riGC0rtwzyjlpdsxKdrNMf31cVBnlAYrKQO+/D6sPgw3/hwuuBmSssDpb0Fe9nbgsV4PnNgE7uieqb3d39ThD9sr8PjLNIeTERsoycBZIUQiyItyu+A9Fdqh2FDPFPUlLWkQgVKxv6FDZTPeEBo61LcGpttnJg/9gEwhhoqiKIEW4TE4p5QI55N0E7p1vtMzShMTLKM0mNK7cM8oWcwm8vzz89pdWkYxJmeUwpVRCPM+C59+Hr5RFmhBPvvTgcdU7obffVJrCvH7T8G2X0alBfnK2YXkpNqoau7krcO1g/s+4mDEBkoycFYIkQiiPUtJzyjNGxtecNOdXnqXk2oLu0PVpNFpRkOH4PbAfTEaOaTZB5xuL8Rwl5ehjwWI7p15CARKJQkQKI3P1QOlNlwen7G2kVR619AeXntwgIKgkkirWTECp4QR3IJ8/JLA+1trIa0APB1wfCNs+Ka/BfmFmP7x76R1RjYPKclq5jMLSoDh2dRhxAZKQgiRCPR/JGuj0CK83eXhcLUDgIsGGyj5ZzBdNDY77ODFbFKYWZQBhDZPSTreifNJvv9vvibK89MgMVqD6/TSu5N17VQ0tOH1qaTazORnJNbfeaQZpQ6Xl063VioWajMHgKKsQGBUmJmMOQpNfIbEjOvh3w7Dlz+AZd/XBuCabdBUgXn3C1i9gVbw1B2Dqr3gC62U7rOLx6IoUN/mosMV/bN7sSRd74QQIoYCd5cHf9H00ZlmfKrWWalgkAe5R/n/4V80IbKAa/aYTHadamTfGQefnNf/Y6WRgzif6H+b1THMKCVCoKRnlM42dXCwSht2OmF0asJljSNtD65nk6xmhdQw2p3rDR0gQcruwqEokH+B9nbpV7V5TCe34D3xNk2uiYHHbV0Du16A1LxAJ72JV3ad9RSkJCeFf37tcqbkpSXc/hiIBEpCCBFDo6PYLjhQdpc16Oe676rJjMtN5bbF4yL6fL2hw76zTQM+VjJK4nyi3xypaR7ZgVJOqo2MJAuOTg9v+8+eJFrZHUB2ipY9b3N5cXl8ITfB0QOr7BRbWBf3wd0IY9YafKj4W5D7Jl6Nun590AcUsKZCWy3s/aP2hhJoQX7Ft3q0H4+0S2u8SemdEELEkJFRikLpndHIoWRwZXegHbj+6jVTurQJD0egoYNjwIYOwWeUhBjpCvyDpmui8DcfrMPlNf6WEiFQUhTFON/49hEtUJo4KvECpYwkK3r1W1MY5XeNEZxPgu4Zpfj/nmLihqfgm+Vwxzot85R3AUYL8v1/7RokHX8Lms/Ea6WDJhklIYSIocAZpcFllFRVZc/pJiA6GaXB0hs6tPsbOkzO6/tuoWSUxPlED5Sqo5xROt2oZZMykixkpiRG98gJo1LZe6bZaJSQaMNmQZv5lJVio6HNRUO7i7yM0MqWG4IySuEILouOa2vwWLPYYeIV2tuy74OjSmsvHszj0uY1uVqhYDbc/c6QDLqNJskoCSFEDOntwWsdTtRBtFk929TBuRYnFpPCLH/ZWzyZTQoX+Bs6DDR4Vs4oifOJfiEejXOJwSrq/WV3uYmTpZjQLYOUiKV3AFn+wLKxLfTOd3rwlx3isFldcDOHYXdGaTD0FuTzPht4X2sN5M0AxQT2jGEXJIEESkIIEVN66V2H20ur0xPx8+jnk2YWZZBkDf1gcSzpAds/D1T3GwRKRkmcT/SMQovTQ9sg/ua7S6TzSbrxo7quJdxRA0NFn4MUTuldpBml0Wl24xxUIv2u4iKrBO56E75+Aq5/Kt6riYgESkIIEUMpNotxDmgw5XdGI4eSrCisKjpunFuE2aTwzwM1/HpLea+PUVU16IxSgs0TESIG0uyBv/lodr5LpBlKuuAzSWOykkkOozvcUAq0CA89oxTpGSWL2cRPPnUhj9wwk6Lh3swhWlJyYPTUeK8iIiM2UFq7di0zZ85k4cKF8V6KEOI8F1x+F6k9p/2NHAY5Pyma5o3N5jsrZwDw3+sP8d6xcz0e0+by0uHW5maMSg/vgkOI4crofBfFQCmRZijpgjNKiXg+Sad3vgtnllKkGSWAG+eO4fOXTgj780TiGbGB0qpVqzh48CA7duyI91KEEOc5veRMP6sTLqfHy4Gz2qDZRGjkEOxfLx3Pp+YX41Phvhf3cKq+rcvH9WxSmt1Cim341acLEQmj810MMkqJFCilJ1kZ5e9mmajnkyCQFQpnllKkZ5TEyDJiAyUhhEgUgcPdkV00Hax04PL6yEm1JdRFEmgtgn9w0yzmlGTR3OHmnt/u6nIuQ84nifNRoPNddBo6qKqakIESwET/uaRJCZxRiqT0bjAZJTFySKAkhBAxppfeRTp0dnfQ+aREnGqeZDXz7O3zGZ1u50hNC6v/VIrPP1tJZiiJ81FelDNK51qcOD0+TAoJd+5l1VWTue7CQq67sCjeS+lTJKV3kZ5REiOLBEpCCBFjxhmlCAMlY9BsgpXdBcvPSOKXn5uPzWzinwdq+Nmm4wCc8w/dlPNJ4nxSEOUzSno2qSgrGas5sS7drpg6mrW3XZTQAUUgozQ0Z5TEyBHXv7bNmzdzww03UFRUhKIovPbaa10+3trayn333UdxcTHJycnMmDGDX/ziF/FZrBBCREg/2F3bEtlFk9HxLoEaOfRm/rhsfnDTLACefPMobxyoDsxQkoySOI/k66V3UQ6UEq3sbrjQg7imEEvvOlxenB4fANkJHACK2ItroNTW1sacOXNYs2ZNrx9/8MEH2bBhA7///e85dOgQDz74IPfffz+vv/76EK9UCCEip7fFjqTrXa2jk7NNHSgKXFgc/0GzA/nMwhI+f8l4AB58uZQPyxsAOaMkzi/5mdEdOiuB0uDopXcNITZzaPBnnmxmE6kJ2vJcDI24tiBasWIFK1as6PPjW7du5c4772Tp0qUA3HPPPTzzzDPs3LmTG2+8cYhWKYQQgxPIKIV/0bTndBMA0/LTSU8aHt2XvnPdDI5Ut7C1rJ4dJ7WyQQmUxPkkuOudz6diMg3ubGEizlAaTvTSO0enG69PxTzA70Pvjpedak3Ic6Fi6CR0r9YlS5awbt06vvCFL1BUVMQ777zD0aNHefrpp/v8HKfTidMZuBhxOLSWum63G7c79G4nsaB//XivQ4hQyH6Nnuwk7Y5kc4eb1vZO7NbQ71DuOlkPwJzijGH1u3jqM7O5+ZfbONuklR5lJ1tiun7ZryKRZCWZUBTw+FRqmtuMFtq6cPdrhb/t/phMu+zxCOgdvlUV6hztA56nOufoACAr2So/b0be62s430dCB0r/8z//w913301xcTEWiwWTycSvfvUrlixZ0ufnPPbYYzz66KM93v/GG2+QkpIYd2I2btwY7yUIETLZr4OnqmBRzHhUhT/97Z/kJoX+uZsOmAEFU2MF69efitkaY+G2sfC0w4zLp3By/w7Wn4j915T9KhJFmsVMi1vhr/94i+I+OmeHul+PVWqvAxWHdrP+dPTWeD5JNpvp8Cq8vuFN8gdoHLirTgHM+DocrF+/fkjWNxyMlNfX9vb2kB+b8IHStm3bWLduHePGjWPz5s185StfobCwkGuuuabXz3nooYdYvXq18d8Oh4OSkhKWL19ORkbGUC29V263m40bN7Js2TKs1uFRQiPOX7Jfo+snhzdztqmTWQsuCbl7ncfr41s7NwE+bl95GVPyEnegY1+WLHFwqr6dFbMKYvp1ZL+KRPPsqa0cqGxh8oULuWra6C4fC2e/drq9fHXrWwD8v+uvkS5sEXr88HucbuzgwgUXM39c/41x6rZVwLHDTC4pZOXKOUO0wsQ10l5f9WqzUCRsoNTR0cG3v/1tXn31Va677joALrzwQkpLS3n88cf7DJTsdjt2e89aeKvVmjC/3ERaixADkf0aHXkZSZxt6qShwxPyz/PouWY63D7S7RamF2YN+pxDPMwZm8ucsblD9vVkv4pEUZCRzIHKFurb+v6bD2W/nmrUylfT7RZGZ6TImZkI5aTaON3YQYtLHfBn3tzpBSA33S6vJ0FGyutrON9DYjXjD6KfKTKZui7RbDbj8/nitCohhIhMJLOU9Lbgc8cOzyBJiPOZ3vlusC3Cgxs5SJAUOb3NdyizlJraZYaS0MQ1o9Ta2srx48eN/y4vL6e0tJScnBzGjh3LFVdcwde//nWSk5MZN24c7777Lr/97W954okn4rhqIYQIX166dtF0LoJAaV5JVgxWJISIJaPzXfMgA6V6aQ0eDXrQ0xhCi3AZNit0cQ2Udu7cyZVXXmn8t3626M477+SFF17gpZde4qGHHuKzn/0sDQ0NjBs3jv/6r//iS1/6UryWLIQQETEySmHMVdlzWmutneiDZoUQPeX7xwLURDhoWlfRoHVgG5srgdJgZPlnKTWGMHRWzzoN1B1PjHxxDZSWLl2Kqqp9frygoIDnn39+CFckhBCxEZilFNpFU1O7i7JzWkvguZJREmLYyfdnlKoHm1GSGUpRkePPDjWFUHrX0KYFU9kSKJ33EvaMkhBCjCR66V2oZ5RK/YNmJ4xKlX+shRiG8oOGzg7G6QYpvYuGLP/raEMIpXeBM0rDv3GBGBwJlIQQYgiMDrOZg5xPEmJ4088oNba7cXq8ET2HqqpGRkkCpcHRg56mAUrvVFWVM0rCMGIDpbVr1zJz5kwWLlwY76UIIYRxRqm+1YnX13fJsW6PP6MU6swlIURiyUqxYrNol1nhnE0MVtfqosPtRVFgTNYAU1JFv/TSu4G63nW4vTg9WndlOaMkRmygtGrVKg4ePMiOHTvivRQhhCA3zY5JAZ+qBUv98flUSiukkYMQw5miKEZDh0hbhOvZpMKMJCPoEpHJMgKl/jNK+sdtZhMpNnPM1yUSm/zVCSHEEDCbFHLTQiu/K6trw9HpIclqYlpB+lAsTwgRAwWDPKd0Who5RE12ql565+q3kZjePjw71Spzq4QESkIIMVQCQ2f7v2ja7c8mXTgmC6tZXqaFGK4G2/lOzidFj37eyONTaXF6+nycnE8SweRfYCGEGCKhzlIyGjmMy4rxioQQsTTYzncSKEVPktVMslUrpWtq67v8TmYoiWASKAkhxBAJtUX4Hv18UomcTxJiOAuU3kXWzMEIlGTYbFTone8a+mno0CgZJRFEAiUhhBgioQydbXV6OFrTAkjHOyGGu/xMf+ldhBmlM3JGKar0hg6n6tv6fExDuz5sVmYoCQmUhBBiyOild+f6yCh5vD7WlVbiU7VWwHrZjhBieMo3ym3DD5ScHi9V/s+T0rvomFOSCcBDf93HlmN1vT5GzyjlSEZJAJZ4L0AIIc4Xo3spvfP5VHZVNLKutJL1+6qo9/8jPX+clN0JMdwVBGWUVFUNq4va2cYOVBVSbGZy5bxMVHz3upmcbuhgy/E6vvDCDv7n1rlcO6uwy2P0M0rZ8jMXjOBAae3ataxduxavN7Jp2EIIEW1G6Z3Dyf6zzazbW8n/7a2kMqgjVnaKlZWzC7nvqsnxWqYQIkr0rHCn24ejw0NmSujlXMGNHKRNdXSk2i38+vML+NpLpfxjfzVf+cNuHrt5Nv+ycKzxGCNQkoySYAQHSqtWrWLVqlU4HA4yMzPjvRwhhGC0f47S2aYOrv/ZFuP9aXYLyy/I5xNzirh08ihpCS7ECJFkNZOZbKW5w01NS2dYgZLMUIoNu8XMmtsu4juv7uOlHaf55iv7aGp3c+8VkwBoaNPPKEmgJEZwoCSEEIkmL8NOut1Ci9OD3WLi6hl5fGJOEUun5ZFklQnwQoxEBRlJNHe4qW7uZGp+6AOkpTV47JhNCo/dPJusFBu/fPcEj/3jMI3tbr557TQ5oyS6kEBJCCGGiN1i5nd3LeZsYwdXTBtNml1egoUY6fIy7BypaQm7850ESrGlKArfWjGdrBQrP/zHYX757gmaO1xBZ5Sk652QQEkIIYbU3JIs5pZkxXsZQoghos9SCrfzXUVDByCBUqx96YpJZCVb+far+/jjh6eN98sZJQHSHlwIIYQQImYKIpilpKqqnFEaQv9v0VjW3nYRNv/5UJvFRIpNyqGFZJSEEEIIIWImz59Rqm7ufX5abxrb3bQ6PQAUZyfHZF2iqxWzC0lPsvLlP+xi9phM6TQoAAmUhBBCCCFixii9awk9o6SfTyrISJJGL0NoyZRRfPjta7BZpOBKaCRQEkIIIYSIkQIjoxR+oCTnk4ZespTciSAjNmReu3YtM2fOZOHChfFeihBCCCHOU/n+QdN1rU48Xl9InyPnk4RIDCM2UFq1ahUHDx5kx44d8V6KEEIIIc5TuWl2zCYFnwp1ra6QPudUfRsgGSUh4m3EBkpCCCGEEPFmNimMTtOySqF2vvvoTDMAU/LTYrYuIcTAJFASQgghhIihfH+L8JoQAqWmdhdHaloAWDg+J6brEkL0TwIlIYQQQogYKvCfUwolUNpxshFVhUmjUxmdbo/10oQQ/ZBASQghhBAihvLD6Hz3YXk9AIsm5MZ0TUKIgUmgJIQQQggRQ3qgVOMYeOjs9vIGAD42UcruhIg3CZSEEEIIIWKoICO0M0qtTg/7z2qNHBZNkEBJiHiTQEkIIYQQIoaM0rsBAqWdJxvwqVpb8MLM5KFYmhCiHxIoCSGEEELEUEFmaM0cPvSX3Uk2SYjEMGIDpbVr1zJz5kwWLlwY76UIIYQQ4jymZ5RaOj20uzx9Pk4/n7RYAiUhEsKIDZRWrVrFwYMH2bFjR7yXIoQQQojzWJrdQorNDPTd+a7D5eWjM00ALJaOd0IkhBEbKAkhhBBCJAJFUYIaOvTe+W5PRSNur0phZhIlOXI+SYhEIIGSEEIIIUSM5Q0wdHZbUNmdoihDti4hRN8kUBJCCCGEiLGCATrfyaBZIRJPXAOlzZs3c8MNN1BUVISiKLz22mtdPq4oSq9vP/nJT+KzYCGEEEKICORn9j1LyenxsqeiCYDFMmhWiIQR10Cpra2NOXPmsGbNml4/XlVV1eXtueeeQ1EUbrnlliFeqRBCCCFE5PLT+w6UPjrTjNPjY1SanYmjUod6aUKIPlji+cVXrFjBihUr+vx4QUFBl/9+/fXXufLKK5k4cWKslyaEEEIIETUFmX03c9heppXdyfkkIRJLXAOlcNTU1PD3v/+d3/zmN/0+zul04nQGXoQcDgcAbrcbt9sd0zUORP/68V6HEKGQ/SqGE9mvItGNStEuuaqbO3rs123+QGn+2EzZwyLhjLTX13C+j2ETKP3mN78hPT2dm2++ud/HPfbYYzz66KM93v/GG2+QkpISq+WFZePGjfFeghAhk/0qhhPZryJRNTgBLFQ3d/DPNzZiUrT96vXBh2VmQMF5ej/rG/bHeaVC9G6kvL62t7eH/NhhEyg999xzfPaznyUpKanfxz300EOsXr3a+G+Hw0FJSQnLly8nIyMj1svsl9vtZuPGjSxbtgyr1RrXtQgxENmvYjiR/SoSncvj49Hdb+JVFRZeegW7PniXZcuWcbCmHdf27WQlW/nCLcswmaT0TiSWkfb6qlebhWJYBErvvfceR44c4eWXXx7wsXa7Hbvd3uP9Vqs1YX65ibQWIQYi+1UMJ7JfRaKyWmFUmo26Vhf1HV7/+6zsqmgGYOGEHOx2WzyXKES/Rsrrazjfw7CYo/TrX/+a+fPnM2fOnHgvRQghhBAiInnpPRs6bA8aNCuESCxxDZRaW1spLS2ltLQUgPLyckpLS6moqDAe43A4+POf/8xdd90Vp1UKIYQQQgye3vmutkULlLw+lR0n9UBJBs0KkWjiWnq3c+dOrrzySuO/9bNFd955Jy+88AIAL730Eqqqcuutt8ZjiUIIIYQQUZGfoR0NqHF0kg4crm6hpdNDmt3CjML0+C5OCNFDXAOlpUuXoqpqv4+55557uOeee4ZoRUIIIYQQsZGfESi9m2yDHacaAVgwPhuLeVichhDivCJ/lUIIIYQQQ6BAD5T8pXcflmuB0iI5nyREQpJASQghhBBiCARnlFQVdvozSnI+SYjENGIDpbVr1zJz5kwWLlwY76UIIYQQQgQFSp1Ud0Bju5skq4nZYzLjvDIhRG9GbKC0atUqDh48yI4dO+K9FCGEEEIIo+tdY7ubI83aYNn547KxWUbs5ZgQw5r8ZQohhBBCDIHsFCs2f9OGPXXa/y4aL2V3QiQqCZSEEEII/ZoTZQAAD49JREFUIYaAoijk+VuEn2zVMkqLJ0ojByESlQRKQgghhBBDRO98B2A1K8wtyYrfYoQQ/ZJASQghhBBiiOQHBUpzijNJsprjuBohRH8kUBJCCCGEGCLBgdKi8VJ2J0Qik0BJCCGEEGKI5PvPKAEsHJ8dx5UIIQYigZIQQgghxBDRW4SbFJWLxsr8JCES2YgNlGTgrBBCCCESzewxmVhMCjOzVFJslngvRwjRjxEbKMnAWSGEEEIkmomj09i0+jLumOKL91KEEAMYsYGSEEIIIUQiKsxMwi7N7oRIeBIoCSGEEEIIIUQ3EigJIYQQQgghRDcSKAkhhBBCCCFENxIoCSGEEEIIIUQ3EigJIYQQQgghRDcSKAkhhBBCCCFENyM2UJKBs0IIIYQQQohIjdhASQbOCiGEEEIIISI1YgMlIYQQQgghhIiUBEpCCCGEEEII0Y0ESkIIIYQQQgjRjQRKQgghhBBCCNGNBEpCCCGEEEII0Y0ESkIIIYQQQgjRjSXeC4g1VVUBcDgccV4JuN1u2tvbcTgcWK3WeC9HiH7JfhXDiexXMZzIfhXDyUjbr3pMoMcI/RnxgVJLSwsAJSUlcV6JEEIIIYQQIhG0tLSQmZnZ72MUNZRwahjz+XxUVlaSnp6OoihxXYvD4aCkpITTp0+TkZER17WEYuHChcNmYK+sNfpkv8aOrDX6ZL/Gjqw1+mS/xo6sNfpG2n5VVZWWlhaKioowmfo/hTTiM0omk4ni4uJ4L6OLjIyMYbHRzGbzsFgnyFpjSfZr9MlaY0f2a/TJWmNH9mv0yVpjZyTt14EySTpp5iD6tGrVqngvIWSyVjGcfq6yVjGcfq6yVjGcfq6yVhHNn+uIL71LJA6Hg8zMTJqbm4dFRC7Ob7JfxXAi+1UMJ7JfxXByPu9XySgNIbvdzsMPP4zdbo/3UoQYkOxXMZzIfhXDiexXMZycz/tVMkpCCCGEEEII0Y1klIQQQgghhBCiGwmUhBBCCCGEEKIbCZSEEEIIIYQQohsJlIQQQgghhBCiGwmUwrR582ZuuOEGioqKUBSF1157rcvHa2pq+PznP09RUREpKSlce+21HDt2rNfnUlWVFStW9Po8jY2N3H777WRmZpKZmcntt99OU1NTbL4pMWJFa79u3bqVq666itTUVLKysli6dCkdHR3Gx2W/imiIxn6trq7m9ttvp6CggNTUVC666CL+8pe/dHmM7FcxWI899hgLFy4kPT2dvLw8brrpJo4cOdLlMaqq8sgjj1BUVERycjJLly7lwIEDXR7jdDq5//77GTVqFKmpqXziE5/gzJkzXR4j+1UMVjT2a0NDA/fffz/Tpk0jJSWFsWPH8sADD9Dc3NzleUbafpVAKUxtbW3MmTOHNWvW9PiYqqrcdNNNlJWV8frrr7Nnzx7GjRvHNddcQ1tbW4/HP/XUUyiK0uvXue222ygtLWXDhg1s2LCB0tJSbr/99qh/P2Jki8Z+3bp1K9deey3Lly/nww8/ZMeOHdx3332YTIGXD9mvIhqisV9vv/12jhw5wrp169i3bx8333wz//Iv/8KePXuMx8h+FYP17rvvsmrVKrZt28bGjRvxeDwsX768y1788Y9/zBNPPMGaNWvYsWMHBQUFLFu2jJaWFuMxX/va13j11Vd56aWX2LJlC62trVx//fV4vV7jMbJfxWBFY79WVlZSWVnJ448/zr59+3jhhRfYsGEDX/ziF7t8rRG3X1URMUB99dVXjf8+cuSICqj79+833ufxeNScnBz1f//3f7t8bmlpqVpcXKxWVVX1eJ6DBw+qgLpt2zbjfVu3blUB9fDhwzH7fsTIFul+Xbx4sfrd7363z+eV/SpiIdL9mpqaqv72t7/t8lw5OTnqr371K1VVZb+K2KitrVUB9d1331VVVVV9Pp9aUFCg/vCHPzQe09nZqWZmZqq//OUvVVVV1aamJtVqtaovvfSS8ZizZ8+qJpNJ3bBhg6qqsl9FbESyX3vzpz/9SbXZbKrb7VZVdWTuV8koRZHT6QQgKSnJeJ/ZbMZms7Flyxbjfe3t7dx6662sWbOGgoKCHs+zdetWMjMzWbx4sfG+j33sY2RmZvLBBx/E8DsQ55NQ9mttbS3bt28nLy+PSy65hPz8fK644oou+1n2qxgKob6+LlmyhJdffpmGhgZ8Ph8vvfQSTqeTpUuXArJfRWzo5Uc5OTkAlJeXU11dzfLly43H2O12rrjiCmOf7dq1C7fb3eUxRUVFzJo1y3iM7FcRC5Hs176eJyMjA4vFAozM/SqBUhRNnz6dcePG8dBDD9HY2IjL5eKHP/wh1dXVVFVVGY978MEHueSSS7jxxht7fZ7q6mry8vJ6vD8vL4/q6uqYrV+cX0LZr2VlZQA88sgj3H333WzYsIGLLrqIq6++2jgbIvtVDIVQX19ffvllPB4Pubm52O127r33Xl599VUmTZoEyH4V0aeqKqtXr2bJkiXMmjULwNhL+fn5XR6bn59vfKy6uhqbzUZ2dna/j5H9KqIp0v3aXX19Pf/5n//Jvffea7xvJO5XCZSiyGq18sorr3D06FFycnJISUnhnXfeYcWKFZjNZgDWrVvHpk2beOqpp/p9rt7OLqmq2ueZJiHCFcp+9fl8ANx7773867/+K/PmzePJJ59k2rRpPPfcc8ZzyX4VsRbKfgX47ne/S2NjI2+++SY7d+5k9erVfPrTn2bfvn3GY2S/imi67777+Oijj/jjH//Y42Pd91Qo+6z7Y2S/imiKxn51OBxcd911zJw5k4cffrjf5+jveYYDCZSibP78+ZSWltLU1ERVVRUbNmygvr6eCRMmALBp0yZOnDhBVlYWFovFSFfecsstRmlIQUEBNTU1PZ773LlzPaJ9IQZjoP1aWFgIwMyZM7t83owZM6ioqABkv4qhM9B+PXHiBGvWrOG5557j6quvZs6cOTz88MMsWLCAtWvXArJfRXTdf//9rFu3jrfffpvi4mLj/XpZffe76LW1tcY+KygowOVy0djY2O9jZL+KaBnMftW1tLRw7bXXkpaWxquvvorVau3yPCNtv0qgFCOZmZmMHj2aY8eOsXPnTqPM7lvf+hYfffQRpaWlxhvAk08+yfPPPw/AxRdfTHNzMx9++KHxfNu3b6e5uZlLLrlkyL8XMfL1tV/Hjx9PUVFRjzaiR48eZdy4cYDsVzH0+tqv7e3tAF06MoJ2lknPjsp+FdGgqir33Xcff/3rX9m0aZMRrOsmTJhAQUEBGzduNN7ncrl49913jX02f/58rFZrl8dUVVWxf/9+4zGyX0U0RGO/gpZJWr58OTabjXXr1nU5MwojdL/Gp4fE8NXS0qLu2bNH3bNnjwqoTzzxhLpnzx711KlTqqpqHUDefvtt9cSJE+prr72mjhs3Tr355pv7fU66dXdSVVW99tpr1QsvvFDdunWrunXrVnX27Nnq9ddfH6tvS4xQ0divTz75pJqRkaH++c9/Vo8dO6Z+97vfVZOSktTjx48bj5H9KqJhsPvV5XKpkydPVi+77DJ1+/bt6vHjx9XHH39cVRRF/fvf/248TvarGKwvf/nLamZmpvrOO++oVVVVxlt7e7vxmB/+8IdqZmam+te//lXdt2+feuutt6qFhYWqw+EwHvOlL31JLS4uVt9880119+7d6lVXXaXOmTNH9Xg8xmNkv4rBisZ+dTgc6uLFi9XZs2erx48f7/I8I3m/SqAUprffflsFerzdeeedqqqq6tNPP60WFxerVqtVHTt2rPrd735XdTqd/T5nb4FSfX29+tnPflZNT09X09PT1c9+9rNqY2NjbL4pMWJFa78+9thjanFxsZqSkqJefPHF6nvvvdfl47JfRTREY78ePXpUvfnmm9W8vDw1JSVFvfDCC3u0C5f9Kgart30KqM8//7zxGJ/Ppz788MNqQUGBarfb1csvv1zdt29fl+fp6OhQ77vvPjUnJ0dNTk5Wr7/+erWioqLLY2S/isGKxn7t6/UZUMvLy43HjbT9qqiqqsYyYyWEEEIIIYQQw42cURJCCCGEEEKIbiRQEkIIIYQQQohuJFASQgghhBBCiG4kUBJCCCGEEEKIbiRQEkIIIYQQQohuJFASQgghhBBCiG4kUBJCCCGEEEKIbiRQEkIIIYQQQohuJFASQgghhBBCiG4kUBJCCDGsqKrKNddcw8c//vEeH/v5z39OZmYmFRUVcViZEEKIkUQCJSGEEMOKoig8//zzbN++nWeeecZ4f3l5Od/85jd5+umnGTt2bFS/ptvtjurzCSGESHwSKAkhhBh2SkpKePrpp/n3f/93ysvLUVWVL37xi1x99dUsWrSIlStXkpaWRn5+Prfffjt1dXXG527YsIElS5aQlZVFbm4u119/PSdOnDA+fvLkSRRF4U9/+hNLly4lKSmJ3//+9/H4NoUQQsSRoqqqGu9FCCGEEJG46aabaGpq4pZbbuE///M/2bFjBwsWLODuu+/mjjvuoKOjg29+85t4PB42bdoEwCuvvIKiKMyePZu2tja+973vcfLkSUpLSzGZTJw8eZIJEyYwfvx4fvrTnzJv3jzsdjtFRUVx/m6FEEIMJQmUhBBCDFu1tbXMmjWL+vp6/vKXv7Bnzx62b9/OP//5T+MxZ86coaSkhCNHjjB16tQez3Hu3Dny8vLYt28fs2bNMgKlp556iq9+9atD+e0IIYRIIFJ6J4QQYtjKy8vjnnvuYcaMGXzyk59k165dvP3226SlpRlv06dPBzDK606cOMFtt93GxIkTycjIYMKECQA9GkAsWLBgaL8ZIYQQCcUS7wUIIYQQg2GxWLBYtH/OfD4fN9xwAz/60Y96PK6wsBCAG264gZKSEv73f/+XoqIifD4fs2bNwuVydXl8ampq7BcvhBAiYUmgJIQQYsS46KKLeOWVVxg/frwRPAWrr6/n0KFDPPPMM1x22WUAbNmyZaiXKYQQYhiQ0jshhBAjxqpVq2hoaODWW2/lww8/pKysjDfeeIMvfOELeL1esrOzyc3N5dlnn+X48eNs2rSJ1atXx3vZQgghEpAESkIIIUaMoqIi3n//fbxeLx//+MeZNWsWX/3qV8nMzMRkMmEymXjppZfYtWsXs2bN4sEHH+QnP/lJvJcthBAiAUnXOyGEEEIIIYToRjJKQgghhBBCCNGNBEpCCCGEEEII0Y0ESkIIIYQQQgjRjQRKQgghhBBCCNGNBEpCCCGEEEII0Y0ESkIIIYQQQgjRjQRKQgghhBBCCNGNBEpCCCGEEEII0Y0ESkIIIYQQQgjRjQRKQgghhBBCCNGNBEpCCCGEEEII0c3/B0QGcGY56SgTAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import xarray as xr\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "def calculate_precip_days(pr_dataset, threshold_mm=10.0):\n", - " # Convert the threshold to meters\n", - " threshold_meters = threshold_mm / 1000.0\n", - "\n", - " # Identify days with precipitation exceeding the threshold\n", - " heavy_precip_days = pr_dataset.where(pr_dataset >= threshold_meters)\n", - "\n", - " # Count the number of days exceeding the threshold per year\n", - " precip_days_index = heavy_precip_days.groupby('time.year').count(dim='time')\n", - "\n", - " return precip_days_index.mean(dim=['latitude', 'longitude'])\n", - "\n", - "def plot_index_with_trend(index, label):\n", - " # Plot the index\n", - " index.plot(label=label)\n", - " \n", - " # Fit a linear trendline\n", - " x = np.arange(len(index))\n", - " y = index.values\n", - " z = np.polyfit(x, y, 1)\n", - " trendline = np.poly1d(z)\n", - " plt.plot(index['year'], trendline(x), linestyle='--', label=\"Trendline\")\n", - "\n", - "def test_calculate_precip_days():\n", - " pr = xr.open_dataset('/home/posiden/Documents/Datasets/era5/india.tp.1960.1990.nc')['tp']\n", - " \n", - " # Calculate for 10mm\n", - " r10mm_index = calculate_precip_days(pr, threshold_mm=10.0)\n", - " \n", - " # Plotting R10mm index with trendline\n", - " plt.figure(figsize=(10, 5))\n", - " plot_index_with_trend(r10mm_index, label=\"R10mm Index\")\n", - " plt.title('Heavy Precipitation Days Index Over Time (R10mm)')\n", - " plt.xlabel('Year')\n", - " plt.ylabel('Count of Days')\n", - " plt.legend()\n", - " plt.grid(True)\n", - " plt.minorticks_on()\n", - " plt.show()\n", - "\n", - " # Calculate for 20mm\n", - " r20mm_index = calculate_precip_days(pr, threshold_mm=20.0)\n", - "\n", - " # Plotting R20mm index with trendline\n", - " plt.figure(figsize=(10, 5))\n", - " plot_index_with_trend(r20mm_index, label=\"R20mm Index\")\n", - " plt.title('Very Heavy Precipitation Days Index Over Time (R20mm)')\n", - " plt.xlabel('Year')\n", - " plt.ylabel('Count of Days')\n", - " plt.legend()\n", - " plt.grid(True)\n", - " plt.minorticks_on()\n", - " plt.show()\n", - "\n", - "test_calculate_precip_days()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Final Class Implementation of the index calculator" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading data...\n", - "Data loaded successfully.\n", - "Time axis found.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import xarray as xr\n", - "from xclim.indices import tx10p, tx90p, tn10p, tn90p, warm_spell_duration_index, cold_spell_duration_index, frost_days\n", - "from xclim.core.calendar import percentile_doy\n", - "\n", - "class ClimateIndex:\n", - " def __init__(self, datafile):\n", - " self.datafile = datafile\n", - " self.data = None\n", - "\n", - " def pre_process(self, time_range=None, fill_missing=None, resample_freq=None, months=None, season=None, resample_method='mean'):\n", - " try:\n", - " print(\"Loading data...\")\n", - " # 1. Loading Data\n", - " self.data = xr.open_dataset(self.datafile)\n", - " print(\"Data loaded successfully.\")\n", - "\n", - " # Check if the time dimension exists\n", - " if 'time' not in self.data.dims:\n", - " raise ValueError(\"Time dimension not found in the dataset.\")\n", - " print(\"Time axis found.\")\n", - "\n", - " # 2. Time Selection\n", - " if time_range:\n", - " print(f\"Selecting data within time range: {time_range[0]} to {time_range[1]}...\")\n", - " start_time, end_time = time_range\n", - " self.data = self.data.sel(time=slice(start_time, end_time))\n", - " print(\"Time selection completed.\")\n", - "\n", - " # 3. Select specific months\n", - " if months:\n", - " print(f\"Selecting data for specific months: {months}...\")\n", - " self.data = self.data.sel(time=self.data['time.month'].isin(months))\n", - " print(\"Month selection completed.\")\n", - "\n", - " # 4. Select specific season\n", - " if season:\n", - " print(f\"Selecting data for specific season: {season}...\")\n", - " self.data = self.data.sel(time=self.data['time.season'] == season)\n", - " print(\"Season selection completed.\")\n", - "\n", - " # 5. Resample or aggregate data\n", - " if resample_freq:\n", - " print(f\"Resampling data with frequency: {resample_freq}, using method: {resample_method}...\")\n", - " resampler = self.data.resample(time=resample_freq)\n", - " if resample_method in dir(resampler):\n", - " self.data = getattr(resampler, resample_method)()\n", - " else:\n", - " raise ValueError(f\"Unknown resampling method: {resample_method}.\")\n", - " print(\"Resampling completed.\")\n", - " \n", - " # 6. Handling Missing Values (NaN)\n", - " if fill_missing:\n", - " if isinstance(fill_missing, (int, float)):\n", - " print(f\"Filling missing values with specified value: {fill_missing}...\")\n", - " data = data.fillna(fill_missing)\n", - " elif fill_missing == 'interpolate':\n", - " print(\"Filling missing values using interpolation...\")\n", - " data = data.interpolate_na(dim='time', method='linear')\n", - " else:\n", - " print(f\"Unknown method to fill missing values: {fill_missing}. Skipping this step.\")\n", - " print(\"Missing values handling completed.\")\n", - "\n", - " except Exception as e:\n", - " print(f\"An error occurred while processing the data: {str(e)}\")\n", - " # Return the modified dataset up to the point of failure (already updated in self.data)\n", - "\n", - " def calculate_tx10p(self):\n", - " tasmax_per = percentile_doy(self.data['t2m'], per=10, window=5).sel(percentiles=10)\n", - " return tx10p(self.data['t2m'], tasmax_per)\n", - "\n", - " def calculate_tx90p(self):\n", - " tasmax_per = percentile_doy(self.data['t2m'], per=90, window=5).sel(percentiles=90)\n", - " return tx90p(self.data['t2m'], tasmax_per)\n", - "\n", - " def calculate_tn10p(self):\n", - " tasmin_per = percentile_doy(self.data['t2m'], per=10, window=5).sel(percentiles=10)\n", - " return tn10p(self.data['t2m'], tasmin_per)\n", - "\n", - " def calculate_tn90p(self):\n", - " tasmin_per = percentile_doy(self.data['t2m'], per=90, window=5).sel(percentiles=90)\n", - " return tn90p(self.data['t2m'], tasmin_per)\n", - "\n", - " def calculate_frost_days(self):\n", - " return frost_days(self.data['t2m'], thresh='273.15 K')\n", - "\n", - " def calculate_warm_spell(self):\n", - " tasmax_per = percentile_doy(self.data['t2m'], per=90, window=5).sel(percentiles=90)\n", - " return warm_spell_duration_index(self.data['t2m'], tasmax_per)\n", - "\n", - " def calculate_cold_spell(self):\n", - " tasmin_per = percentile_doy(self.data['t2m'], per=10, window=5).sel(percentiles=10)\n", - " return cold_spell_duration_index(self.data['t2m'], tasmin_per)\n", - " \n", - " def calculate_percentile_p(self, percentile=95, wet_day_thresh_mm=1.0, reference_period=('1961-01-01', '1990-12-31'), resample_freq='Y'):\n", - " pr = self.data['tp'] # Assuming the precipitation data is stored in the 'tp' variable\n", - " # Exclude leap day (February 29th) if present\n", - " pr = pr.where((pr['time.month'] != 2) | (pr['time.day'] != 29), drop=True)\n", - "\n", - " # Convert the wet day threshold to meters\n", - " wet_day_thresh_meters = wet_day_thresh_mm / 1000.0\n", - "\n", - " # Calculate the specified percentile for the reference period\n", - " reference_period_data = pr.sel(time=slice(*reference_period))\n", - " wet_days_reference = reference_period_data.where(reference_period_data >= wet_day_thresh_meters)\n", - " p_reference = wet_days_reference.groupby('time.dayofyear').reduce(np.nanpercentile, q=percentile, dim='time')\n", - "\n", - " # Identify wet days\n", - " wet_days = pr.where(pr >= wet_day_thresh_meters)\n", - "\n", - " # Compare each day with the corresponding percentile\n", - " exceeding_days = wet_days.groupby('time.dayofyear') > p_reference\n", - "\n", - " # Sum the precipitation for those days (rXXp index)\n", - " rXXp_index_time_series = (exceeding_days * pr).mean(dim=['latitude', 'longitude']).resample(time=resample_freq).sum() * 1000\n", - "\n", - " # Count the number of days exceeding the specified percentile\n", - " rXXp_days_count = exceeding_days.resample(time=resample_freq).sum(dim='time')\n", - "\n", - " return rXXp_index_time_series * 1000, rXXp_days_count\n", - " \n", - " def calculate_rxnday(self, n_days=5, threshold_mm=50.0, resample_freq='Y'):\n", - " pr = self.data['tp'] # Assuming the precipitation data is stored in the 'tp' variable\n", - "\n", - " # Calculate the rolling n-day precipitation total\n", - " rolling_nday_total = pr.rolling(time=n_days).sum()\n", - "\n", - " # Find the maximum n-day total for each time period (e.g., year)\n", - " rxnday_index = rolling_nday_total.resample(time=resample_freq).max(dim=['latitude', 'longitude'])\n", - "\n", - " # Count the number of n-day heavy precipitation periods\n", - " heavy_precip_periods = rolling_nday_total.where(rolling_nday_total >= threshold_mm / 1000.0)\n", - " heavy_precip_count = heavy_precip_periods.resample(time=resample_freq).count(dim=['time', 'latitude', 'longitude'])\n", - "\n", - " return rxnday_index * 1000, heavy_precip_count\n", - " \n", - " def calculate_precip_days(self, threshold_mm=10.0):\n", - " # Convert the threshold to meters\n", - " threshold_meters = threshold_mm / 1000.0\n", - "\n", - " # Identify days with precipitation exceeding the threshold\n", - " heavy_precip_days = self.data['tp'].where(self.data['tp'] >= threshold_meters)\n", - "\n", - " # Count the number of days exceeding the threshold per year\n", - " precip_days_index = heavy_precip_days.groupby('time.year').count(dim='time')\n", - "\n", - " return precip_days_index.mean(dim=['latitude', 'longitude'])\n", - "\n", - " \n", - " \n", - "\n", - "\n", - "# # Example usage:\n", - "# climate_index = ClimateIndex(datafile='/home/posiden/Documents/Datasets/era5/india.1960.1990.nc')\n", - "# climate_index.pre_process()\n", - "# tx10p_index = climate_index.calculate_tx10p()\n", - "\n", - "# def plot_tx10p(data, title):\n", - "# # Take the mean along latitude and longitude\n", - "# data_mean = data.mean(dim=['latitude', 'longitude'])\n", - " \n", - "# data_mean.plot(figsize=(10, 5))\n", - "# plt.title(title)\n", - "# plt.xlabel('Time')\n", - "# plt.ylabel('tx10p Index')\n", - "# plt.grid(True)\n", - "# plt.show()\n", - "\n", - "def test_calculate_precip_days_and_percentiles():\n", - " climate_index = ClimateIndex(datafile='/home/posiden/Documents/Datasets/era5/india.tp.1960.1990.nc')\n", - " climate_index.pre_process()\n", - "\n", - " # Calculate R95p and plot\n", - " r95p_index_time_series, _ = climate_index.calculate_percentile_p(percentile=95)\n", - " r95p_index_time_series.plot(label=\"R95p Index\")\n", - " plt.title('R95p Index Over Time')\n", - " plt.xlabel('Year')\n", - " plt.ylabel('Index Value')\n", - " plt.legend()\n", - " plt.grid(True)\n", - " plt.show()\n", - "\n", - " # Calculate R99p and plot\n", - " r99p_index_time_series, _ = climate_index.calculate_percentile_p(percentile=99)\n", - " r99p_index_time_series.plot(label=\"R99p Index\")\n", - " plt.title('R99p Index Over Time')\n", - " plt.xlabel('Year')\n", - " plt.ylabel('Index Value')\n", - " plt.legend()\n", - " plt.grid(True)\n", - " plt.show()\n", - "\n", - " # Calculate r10mm and plot\n", - " r10mm_index = climate_index.calculate_precip_days(threshold_mm=10.0)\n", - " r10mm_index.plot(label=\"r10mm Index\")\n", - " plt.title('r10mm Index Over Time')\n", - " plt.xlabel('Year')\n", - " plt.ylabel('Index Value')\n", - " plt.legend()\n", - " plt.grid(True)\n", - " plt.show()\n", - "\n", - " # Calculate rx5day and plot\n", - " rx5day_index, _ = climate_index.calculate_rxnday(n_days=5)\n", - " rx5day_index.plot(label=\"rx5day Index\")\n", - " plt.title('rx5day Index Over Time')\n", - " plt.xlabel('Year')\n", - " plt.ylabel('Index Value')\n", - " plt.legend()\n", - " plt.grid(True)\n", - " plt.show()\n", - "\n", - " # Add any other precipitation-related calculations and plots here\n", - "\n", - "# Run the test\n", - "test_calculate_precip_days_and_percentiles()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "import xarray as xr\n", - "from xclim.indices import tx10p, tx90p, tn10p, tn90p, warm_spell_duration_index, cold_spell_duration_index, frost_days\n", - "from xclim.core.calendar import percentile_doy\n", - "\n", - "class ClimateIndex:\n", - " def __init__(self, datafile):\n", - " self.datafile = datafile\n", - " self.data = None\n", - "\n", - " def pre_process(self, time_range=None, fill_missing=None, resample_freq=None, months=None, season=None, resample_method='mean'):\n", - " try:\n", - " print(\"Loading data...\")\n", - " self.data = xr.open_dataset(self.datafile)\n", - " print(\"Data loaded successfully.\")\n", - " if 'time' not in self.data.dims:\n", - " raise ValueError(\"Time dimension not found in the dataset.\")\n", - " print(\"Time axis found.\")\n", - " if time_range:\n", - " start_time, end_time = time_range\n", - " self.data = self.data.sel(time=slice(start_time, end_time))\n", - " print(\"Time selection completed.\")\n", - " if months:\n", - " self.data = self.data.sel(time=self.data['time.month'].isin(months))\n", - " print(\"Month selection completed.\")\n", - " if season:\n", - " self.data = self.data.sel(time=self.data['time.season'] == season)\n", - " print(\"Season selection completed.\")\n", - " if resample_freq:\n", - " resampler = self.data.resample(time=resample_freq)\n", - " if resample_method in dir(resampler):\n", - " self.data = getattr(resampler, resample_method)()\n", - " else:\n", - " raise ValueError(f\"Unknown resampling method: {resample_method}.\")\n", - " print(\"Resampling completed.\")\n", - " if fill_missing:\n", - " if isinstance(fill_missing, (int, float)):\n", - " print(f\"Filling missing values with specified value: {fill_missing}...\")\n", - " self.data = self.data.fillna(fill_missing)\n", - " elif fill_missing == 'interpolate':\n", - " print(\"Filling missing values using interpolation...\")\n", - " self.data = self.data.interpolate_na(dim='time', method='linear')\n", - " else:\n", - " print(f\"Unknown method to fill missing values: {fill_missing}. Skipping this step.\")\n", - " print(\"Missing values handling completed.\")\n", - " except Exception as e:\n", - " print(f\"An error occurred while processing the data: {str(e)}\")\n", - "\n", - " def calculate_tx10p(self, temp_var='t2m'):\n", - " tasmax_per = percentile_doy(self.data[temp_var], per=10, window=5).sel(percentiles=10)\n", - " return tx10p(self.data[temp_var], tasmax_per)\n", - "\n", - " def calculate_tx90p(self, temp_var='t2m'):\n", - " tasmax_per = percentile_doy(self.data[temp_var], per=90, window=5).sel(percentiles=90)\n", - " return tx90p(self.data[temp_var], tasmax_per)\n", - "\n", - " def calculate_tn10p(self, temp_var='t2m'):\n", - " tasmin_per = percentile_doy(self.data[temp_var], per=10, window=5).sel(percentiles=10)\n", - " return tn10p(self.data[temp_var], tasmin_per)\n", - "\n", - " def calculate_tn90p(self, temp_var='t2m'):\n", - " tasmin_per = percentile_doy(self.data[temp_var], per=90, window=5).sel(percentiles=90)\n", - " return tn90p(self.data[temp_var], tasmin_per)\n", - "\n", - " def calculate_frost_days(self, temp_var='t2m'):\n", - " return frost_days(self.data[temp_var], thresh='273.15 K')\n", - "\n", - " def calculate_warm_spell(self, temp_var='t2m'):\n", - " tasmax_per = percentile_doy(self.data[temp_var], per=90, window=5).sel(percentiles=90)\n", - " return warm_spell_duration_index(self.data[temp_var], tasmax_per)\n", - "\n", - " def calculate_cold_spell(self, temp_var='t2m'):\n", - " tasmin_per = percentile_doy(self.data[temp_var], per=10, window=5).sel(percentiles=10)\n", - " return cold_spell_duration_index(self.data[temp_var], tasmin_per)\n", - " \n", - "\n", - " def calculate_percentile_p(self, precip_var='tp', percentile=95, wet_day_thresh_mm=1.0, reference_period=('1961-01-01', '1990-12-31'), resample_freq='Y'):\n", - " pr = self.data[precip_var] # Use the user-specified variable name\n", - " # Exclude leap day (February 29th) if present\n", - " pr = pr.where((pr['time.month'] != 2) | (pr['time.day'] != 29), drop=True)\n", - "\n", - " # Convert the wet day threshold to meters\n", - " wet_day_thresh_meters = wet_day_thresh_mm / 1000.0\n", - "\n", - " # Calculate the specified percentile for the reference period\n", - " reference_period_data = pr.sel(time=slice(*reference_period))\n", - " wet_days_reference = reference_period_data.where(reference_period_data >= wet_day_thresh_meters)\n", - " p_reference = wet_days_reference.groupby('time.dayofyear').reduce(np.nanpercentile, q=percentile, dim='time')\n", - "\n", - " # Identify wet days\n", - " wet_days = pr.where(pr >= wet_day_thresh_meters)\n", - "\n", - " # Compare each day with the corresponding percentile\n", - " exceeding_days = wet_days.groupby('time.dayofyear') > p_reference\n", - "\n", - " # Sum the precipitation for those days (rXXp index)\n", - " rXXp_index_time_series = (exceeding_days * pr).resample(time=resample_freq).sum()\n", - "\n", - " # Count the number of days exceeding the specified percentile\n", - " rXXp_days_count = exceeding_days.resample(time=resample_freq).sum(dim='time')\n", - "\n", - " return rXXp_index_time_series * 1000, rXXp_days_count\n", - "\n", - "\n", - "\n", - " def calculate_precip_days(self, precip_var='tp', threshold_mm=10.0):\n", - " # Convert the threshold to meters\n", - " threshold_meters = threshold_mm / 1000.0\n", - "\n", - " # Identify days with precipitation exceeding the threshold\n", - " heavy_precip_days = self.data['tp'].where(self.data['tp'] >= threshold_meters)\n", - "\n", - " # Count the number of days exceeding the threshold per year\n", - " precip_days_index = heavy_precip_days.groupby('time.year').count(dim='time')\n", - "\n", - " return precip_days_index\n", - " \n", - " def calculate_rxnday(self, precip_var='tp', n_days=5, threshold_mm=50.0, resample_freq='Y'):\n", - " pr = self.data[precip_var] # Use the user-specified variable name\n", - "\n", - " # Calculate the rolling n-day precipitation total\n", - " rolling_nday_total = pr.rolling(time=n_days).sum()\n", - "\n", - " # Find the maximum n-day total for each time period (e.g., year)\n", - " rxnday_index = rolling_nday_total.resample(time=resample_freq).max()\n", - "\n", - " # Count the number of n-day heavy precipitation periods\n", - " heavy_precip_periods = rolling_nday_total.where(rolling_nday_total >= threshold_mm / 1000.0)\n", - " heavy_precip_count = heavy_precip_periods.resample(time=resample_freq).count(dim='time')\n", - "\n", - " return rxnday_index * 1000, heavy_precip_count\n", - " \n", - " def test_indices(self, data_type='temperature'):\n", - " # Methods to test for temperature data\n", - " temp_methods_to_test = [\n", - " self.calculate_tx10p,\n", - " self.calculate_tx90p,\n", - " self.calculate_tn10p,\n", - " self.calculate_tn90p,\n", - " self.calculate_frost_days,\n", - " self.calculate_warm_spell,\n", - " self.calculate_cold_spell,\n", - " ]\n", - "\n", - " # Methods to test for precipitation data\n", - " precip_methods_to_test = [\n", - " self.calculate_percentile_p,\n", - " self.calculate_precip_days,\n", - " self.calculate_rxnday\n", - " ]\n", - "\n", - " # Choose the methods to test based on the data type\n", - " if data_type == 'temperature':\n", - " methods_to_test = temp_methods_to_test\n", - " elif data_type == 'precipitation':\n", - " methods_to_test = precip_methods_to_test\n", - " else:\n", - " raise ValueError(\"Invalid data type. Choose 'temperature' or 'precipitation'.\")\n", - "\n", - " # Iterate through the methods and plot the results\n", - " for method in methods_to_test:\n", - " try:\n", - " print(f\"Testing {method.__name__}...\")\n", - " result = method()\n", - " if isinstance(result, tuple): # Handle methods that return multiple results\n", - " result = result[0]\n", - " time_series = result.mean(dim=['latitude', 'longitude'])\n", - " time_series.plot(label=method.__name__)\n", - " except Exception as e:\n", - " print(f\"An error occurred while testing {method.__name__}: {str(e)}\")\n", - " continue\n", - "\n", - " plt.legend()\n", - " plt.show()\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading data...\n", - "Data loaded successfully.\n", - "Time axis found.\n", - "Loading data...\n", - "Data loaded successfully.\n", - "Time axis found.\n", - "Testing calculate_tx10p...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xclim/core/utils.py:461: RuntimeWarning: All-NaN slice encountered\n", - " result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing calculate_tx90p...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xclim/core/utils.py:461: RuntimeWarning: All-NaN slice encountered\n", - " result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing calculate_tn10p...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xclim/core/utils.py:461: RuntimeWarning: All-NaN slice encountered\n", - " result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing calculate_tn90p...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xclim/core/utils.py:461: RuntimeWarning: All-NaN slice encountered\n", - " result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing calculate_frost_days...\n", - "Testing calculate_warm_spell...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xclim/core/utils.py:461: RuntimeWarning: All-NaN slice encountered\n", - " result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing calculate_cold_spell...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xclim/core/utils.py:461: RuntimeWarning: All-NaN slice encountered\n", - " result = np.where(np.isnan(interpolation), np.nanmax(arr, axis=0), interpolation)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/xarray/core/accessor_dt.py:72: FutureWarning: Index.ravel returning ndarray is deprecated; in a future version this will return a view on self.\n", - " values_as_series = pd.Series(values.ravel(), copy=False)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing calculate_percentile_p...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n", - "/home/posiden/anaconda3/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1577: RuntimeWarning: All-NaN slice encountered\n", - " result = np.apply_along_axis(_nanquantile_1d, axis, a, q,\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Testing calculate_precip_days...\n", - "Testing calculate_rxnday...\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Paths to your NetCDF data files\n", - "temp_datafile_path = '/home/posiden/Documents/Datasets/era5/india.1960.1990.nc'\n", - "precip_datafile_path = '/home/posiden/Documents/Datasets/era5/india.tp.1960.1990.nc'\n", - "\n", - "# Create instances of the ClimateIndex class for temperature and precipitation\n", - "temp_climate_index = ClimateIndex(temp_datafile_path)\n", - "precip_climate_index = ClimateIndex(precip_datafile_path)\n", - "\n", - "# # Preprocessing parameters for temperature\n", - "# temp_time_range = ('2000-01-01', '2010-12-31') # Example time range\n", - "# temp_fill_missing = 'interpolate' # Example fill_missing method\n", - "# temp_resample_freq = 'M' # Example resampling frequency\n", - "\n", - "# # Preprocessing parameters for precipitation\n", - "# precip_time_range = ('2000-01-01', '2010-12-31') # Example time range\n", - "# precip_fill_missing = 'interpolate' # Example fill_missing method\n", - "# precip_resample_freq = 'M' # Example resampling frequency\n", - "\n", - "# Apply preprocessing to temperature data\n", - "temp_climate_index.pre_process()\n", - "\n", - "# Apply preprocessing to precipitation data\n", - "precip_climate_index.pre_process()\n", - "\n", - "\n", - "# Test and plot temperature-related indices\n", - "temp_climate_index.test_indices(data_type='temperature')\n", - "\n", - "# Test and plot precipitation-related indices\n", - "precip_climate_index.test_indices(data_type='precipitation')\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.3" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/xclim/tx10p_index.nc b/xclim/tx10p_index.nc deleted file mode 100644 index 7ad39d7ebc9e3ce2d49e743e5c837ef47c140496..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5466715 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­1YP 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

?+&?N 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

  • #e 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

    y`x_^U4Q+zZcoUw-@I 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 BlX?IE