diff --git a/README.md b/README.md index db22d81..28a91c4 100644 --- a/README.md +++ b/README.md @@ -7,8 +7,8 @@ * `final_notebooks`: - `final_dashboard.py` Marimo dashboard - `llm_working_tutorial` demonstration of the working flow of LLM --> plotting - - `functions` - - `txt_docs` + - `functions` helper functions of our project + - `txt_docs` example functions that agent can use * `scripts` backend python scripts to control data access, tools available to the model, etc * `data` data will all be cloud accessed. Access can be found in `dataset_track.ipynb` within this folder. diff --git a/final_notebooks/executor.py b/final_notebooks/executor.py index e9f5777..fefb581 100644 --- a/final_notebooks/executor.py +++ b/final_notebooks/executor.py @@ -16,7 +16,7 @@ def load_agent_executor(token: str): tools = [ advisor_tool, - loader_tool, + #loader_tool, repl_tool ] diff --git a/final_notebooks/final_dashboard.py b/final_notebooks/final_dashboard.py index 15118e2..b8eed42 100644 --- a/final_notebooks/final_dashboard.py +++ b/final_notebooks/final_dashboard.py @@ -11,6 +11,8 @@ def _(): import openlayers as ol from shapely.geometry import box import os + + os.chdir(path='/home/jovyan/ohw25_proj_datadashboard_llm/final_notebooks') from langchain_community.vectorstores import Chroma from langchain.prompts import ChatPromptTemplate from langchain.chains import ConversationalRetrievalChain @@ -21,40 +23,13 @@ def _(): from langchain.agents import AgentExecutor, create_tool_calling_agent import json import hf_config + from executor import load_agent_executor current_directory = os.getcwd() print(current_directory) from dotenv import load_dotenv - return ( - AgentExecutor, - ChatOpenAI, - ChatPromptTemplate, - MessagesPlaceholder, - create_tool_calling_agent, - hf_config, - mo, - ol, - ) - - -@app.cell -def _(hf_config): - # Set token once in your notebook - my_token = '' - hf_config.set_hf_token(my_token) - LANGSMITH_TRACING="true" - LANGSMITH_ENDPOINT="https://api.smith.langchain.com" - LANGSMITH_API_KEY='' - LANGSMITH_PROJECT="ohw_llm" - return - - -@app.cell -def _(): - from db_creation import create_db_examples - vector_store_hf = create_db_examples() - return + return hf_config, load_agent_executor, mo, ol, os @app.cell @@ -64,13 +39,17 @@ def _(mo):
Logo - - Data Dashboard with Chatbot + color: black; + line-height: 0.5;"> + SplashBot + 1.0 + Logo +
""" ) @@ -96,9 +75,9 @@ def _(mo): mo.md( r"""
-

+ display: flex; align-items: center; gap: 10px;"> Logo Explore the map by dragging and zooming, or click any location to analyze its data. Use the chatbot for instant insights and comparisons. @@ -152,9 +131,9 @@ def _(mo): mo.md( r"""
-

+ display: flex; align-items: center; gap: 10px;"> Logo Please provide HF token to run the Chatbot. @@ -175,69 +154,123 @@ def _(mo): @app.cell def _(text_area): user_key = text_area.value.strip() - return - - -@app.cell -def _(): - return + return (user_key,) @app.cell -def _( - AgentExecutor, - ChatOpenAI, - ChatPromptTemplate, - MessagesPlaceholder, - create_tool_calling_agent, - hf_config, - mo, - widget, -): - def my_model2(messages, widget): - question = messages[-1].content - my_token = '' - hf_config.set_hf_token(my_token) - - map_frame = widget.value["view_state"]["extent"] - point_selected = widget.value.get("clicked", {}).get("coordinate", [0, 0]) - - from adviser_tool import create_adviser_tool - adviser_tool_llm = create_adviser_tool() - tools = [adviser_tool_llm] - prompt = ChatPromptTemplate.from_messages( - [ - ("system", f"You are an expert in climate data analysis, you have adviser tool, which can help you to asnwer user's questions about variables/datasets. If the question about data, use only information from adviser_tool. If the {map_frame} or {point_selected} is not [0,0], answer questions about the data from this selected area. "), - ("user", "{input}"), - MessagesPlaceholder(variable_name="agent_scratchpad"), - ] - ) - llm = ChatOpenAI( - base_url="https://router.huggingface.co/v1", - api_key=hf_config.get_hf_token(), - model="openai/gpt-oss-120b:fireworks-ai" - ) - - # Define the agent - agent = create_tool_calling_agent( - llm=llm, - tools=tools, - prompt=prompt, - ) - - # Create the executor - agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) - result = agent_executor.invoke({"input": question}) - return result - +def _(hf_config, load_agent_executor, mo, os, user_key, widget): + + import re + from PIL import Image + import glob + + def clear_figures_folder(): + """Delete all PNG files from the figures_temp directory""" + if os.path.exists('figures_temp'): + png_files = glob.glob('figures_temp/*.png') + for file_path in png_files: + try: + os.remove(file_path) + print(f"Deleted: {file_path}") + except Exception as e: + print(f"Error deleting {file_path}: {e}") + print(f"Cleared {len(png_files)} files from figures_temp") + + def my_model2(messages, widget): + question = messages[-1].content + + # Clear all existing figures at the start of each new question + clear_figures_folder() + + my_token = user_key + hf_config.set_hf_token(my_token) + executor = load_agent_executor(my_token) + map_frame = widget.value["view_state"]["extent"] + point_selected = widget.value.get("clicked", {}).get("coordinate", [0, 0]) + + if point_selected != [0,0]: + point_selected = point_selected + [point_selected[0] + 1, point_selected[1] + 1] + + # Create the executor + remark = f'If the {map_frame} or {point_selected} is not [0,0], answer questions about the data from this selected area.' + result = executor.invoke({"input": question + remark}) + + # Extract figure paths from this execution + figure_paths = extract_figure_paths(result) + + # Create response with figures + response_content = [] + + # Add the text response + response_content.append(mo.md(str(result))) + + # Show only the last (most recent) figure generated in this execution + if figure_paths: + last_figure_path = figure_paths[-1] # Get the most recent figure + response_content.append(mo.md("### Generated Figure:")) + if os.path.exists(last_figure_path): + try: + # Display only the last image + img = Image.open(last_figure_path) + response_content.append(mo.image(src=last_figure_path, alt=f"Generated plot: {os.path.basename(last_figure_path)}")) + except Exception as e: + response_content.append(mo.md(f"Error loading image {last_figure_path}: {str(e)}")) + else: + response_content.append(mo.md(f"Figure not found: {last_figure_path}")) + + # Return combined content + return mo.vstack(response_content) if response_content else result + + def extract_figure_paths(result_text): + """Extract figure paths from the executor result and scan directory for new files""" + # Convert result to string if it's not already + result_str = str(result_text) + + # Multiple patterns to catch different ways figures might be mentioned + patterns = [ + r'figures_temp/plot_\d+_\d+_\d+_fig\d+\.png', # Original pattern + r'figures_temp/[^/\s]+\.png', # Any PNG in figures_temp + r'Figure saved to:\s*([^\n\r]+\.png)', # Saved to pattern + r'([^\s]+\.png)', # Any PNG file mentioned + r'saved to:\s*([^\n\r]+)', # General saved to pattern + ] + + found_paths = [] + for pattern in patterns: + matches = re.findall(pattern, result_str) + found_paths.extend(matches) + + # Also scan the figures_temp directory for any new PNG files + if os.path.exists('figures_temp'): + all_pngs = glob.glob('figures_temp/*.png') + found_paths.extend(all_pngs) + + # Clean up paths and filter for existing files with reasonable content + valid_paths = [] + for path in found_paths: + clean_path = path.strip() + + # Ensure it's a proper path + if not clean_path.endswith('.png'): + continue + + if os.path.exists(clean_path): + # Check if the file has reasonable size (not empty plot) + file_size = os.path.getsize(clean_path) + if file_size > 1000: # Lowered threshold - even small plots should be > 1KB + if clean_path not in valid_paths: + valid_paths.append(clean_path) + + # Sort by modification time to get chronological order + if valid_paths: + valid_paths.sort(key=lambda x: os.path.getmtime(x)) + + return valid_paths + + # Create the chat interface mo.ui.chat(lambda messages: my_model2(messages, widget)) return -@app.cell -def _(): - return - - if __name__ == "__main__": app.run() diff --git a/final_notebooks/functions/python_repl_tool.py b/final_notebooks/functions/python_repl_tool.py index c6fba10..5182287 100644 --- a/final_notebooks/functions/python_repl_tool.py +++ b/final_notebooks/functions/python_repl_tool.py @@ -4,10 +4,77 @@ def create_python_repl(): python_repl = PythonREPL() + def enhanced_python_repl(code): + import os + import matplotlib.pyplot as plt + from datetime import datetime + """Enhanced Python REPL that automatically saves plots and returns code + path""" + + # Ensure figures_temp directory exists + os.makedirs('figures_temp', exist_ok=True) + + # Store original plt.show function + original_show = plt.show + saved_paths = [] + + def custom_show(*args, **kwargs): + """Custom show function that saves figures before displaying""" + # Save all current figures before showing + if plt.get_fignums(): + for fig_num in plt.get_fignums(): + fig = plt.figure(fig_num) + + # Generate unique filename with timestamp + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3] # Include milliseconds + filename = f"plot_{timestamp}_fig{fig_num}.png" + filepath = os.path.join('figures_temp', filename) + + # Save the figure before showing + fig.savefig(filepath, dpi=300, bbox_inches='tight', facecolor='white') + saved_paths.append(filepath) + print(f"Figure saved to: {filepath}") + + # Now call the original show function + return original_show(*args, **kwargs) + + # Replace plt.show temporarily + plt.show = custom_show + + try: + # Execute the code + result = python_repl.run(code) + + # If code didn't call plt.show() but figures exist, save them anyway + if plt.get_fignums() and not saved_paths: + for fig_num in plt.get_fignums(): + fig = plt.figure(fig_num) + + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3] + filename = f"plot_{timestamp}_fig{fig_num}.png" + filepath = os.path.join('figures_temp', filename) + + fig.savefig(filepath, dpi=300, bbox_inches='tight', facecolor='white') + saved_paths.append(filepath) + print(f"Figure saved to: {filepath}") + + finally: + # Always restore the original plt.show function + plt.show = original_show + + # Format the output + output = f"Execution Result:\n{result}\n" + if saved_paths: + output += f"\nSaved Plots:\n" + for path in saved_paths: + output += f"- {path}\n" + + output += f"\nExecuted Code:\n{code}\n" + + return output python_repl_tool = Tool( name="python_repl", - func=python_repl.run, + func=enhanced_python_repl, description=""" You receive: - A file path to the downloaded dataset. This path comes from the load_climate_data tool. Do not use any other path. @@ -34,6 +101,234 @@ def create_python_repl(): - Prefer clarity and readability of code over cleverness. - Do not invent dataset fields—only use those provided in the dataset info. - If the user asks for a time range that you might think is too large, warn them and suggest re-execution. - """, + + NOTE: here's an example loader function you might take some ideas from. It tells you how to read some files from the cloud. I also + provide you with a schema: + + def load_climate_data( + store: Union[str, s3fs.S3Map, fsspec.mapping.FSMap], + variable: Optional[Union[str, Dict[str, str]]], + lon_range: Optional[Tuple[float, float]] = None, + lat_range: Optional[Tuple[float, float]] = None, + *, + time_range: Optional[Tuple[str, str]] = None, + resample_to: Optional[str] = None, + chunks: Optional[Dict[str, int]] = None, + storage_options: Optional[Dict[str, Any]] = None, + ): + + Load climate data from cloud storage (S3 or GCS) with consistent processing. + + Parameters + ---------- + store : str or s3fs.S3Map or fsspec.mapping.FSMap + Either a URL string (e.g., "s3://..." or "gs://...") or an existing store object + variable : str or dict + Variable name or CF-style selector (e.g., {"standard_name": "air_temperature"}) + lon_range : tuple of float, optional + (min_longitude, max_longitude) in dataset's native frame. If None, keeps all longitudes. + lat_range : tuple of float, optional + (min_latitude, max_latitude). If None, keeps all latitudes. + time_range : tuple of str, optional + (start_date, end_date) as ISO strings. If None, keeps all times. + resample_to : str, optional + If provided, resample time dimension (e.g., "MS" for month start) + chunks : dict, optional + Dask chunks specification (e.g., {"time": 1024}) + storage_options : dict, optional + Only used if store is a string URL. Additional storage options for cloud access. + + Returns + ------- + xr.Dataset + Processed dataset with consistent dimensions + + + # Open dataset + if isinstance(store, str): + # If store is a URL string, use storage_options + ds = xr.open_dataset( + store, + engine="zarr", + chunks=chunks, + backend_kwargs={"storage_options": storage_options}, + ) + else: + # If store is already an FSMap object, use it directly + ds = xr.open_zarr(store, chunks=chunks) + + # Get coordinate names + lon_name, lat_name = _get_coord_names(ds) + + # Subset space and time + region = {} + if lon_range is not None and lat_range is not None: + region.update({ + lon_name: slice(*lon_range), + lat_name: slice(*lat_range) + }) + + if "time" in ds.coords: + ds["time"] = pd.to_datetime(ds["time"].values).tz_localize("UTC") + + if time_range is not None: + region["time"] = slice(*time_range) + + # Only apply selection if we have regions to subset + if region: + ds = ds.sel(**region) + + # Handle longitude frame and monotonic latitude + if lon_range is not None: + target_frame = _infer_target_lon_frame(*lon_range) + ds = _coerce_longitudes(ds, target_frame) + #ds = _ensure_lat_monotonic(ds) + + # Optional time resampling + if resample_to: + ds = ds.resample(time=resample_to).mean() + + # Ensure consistent dimension order + # Get available dimensions + dims = list(ds.dims) + # Core dims we want first (if they exist) + core_dims = ["time", "latitude", "longitude"] + # Filter out core dims that actually exist + core_dims = [d for d in core_dims if d in dims] + # Add any remaining dims at the end + other_dims = [d for d in dims if d not in core_dims] + # Combine for final ordering + final_dims = core_dims + other_dims + + ds = ds.transpose(*final_dims) + + if variable: + var = _select_variable(ds, variable) + ds = ds[var] + + path = download_to_temp( + ds + ) + + return path + + + class ClimateDataParams(BaseModel): + + A Pydantic model to define and validate parameters for accessing climate data. + It specifies the data store and the exact variable to be retrieved. + + store: Literal[ + "gs://weatherbench2/datasets/era5/1959-2023_01_10-6h-240x121_equiangular_with_poles_conservative.zarr", + "gcs://nmfs_odp_nwfsc/CB/mind_the_chl_gap/IO.zarr" + ] = Field( + ..., + description="The specific cloud storage path (store) where the dataset is located." + ) + + variable: Literal[ + # Variables from ERA5 Atmospheric Surface Analysis + "10m_u_component_of_wind", + "10m_v_component_of_wind", + "2m_dewpoint_temperature", + "2m_temperature", + "angle_of_sub_gridscale_orography", + "anisotropy_of_sub_gridscale_orography", + "boundary_layer_height", + "geopotential", + "geopotential_at_surface", + "high_vegetation_cover", + "lake_cover", + "land_sea_mask", + "leaf_area_index_high_vegetation", + "leaf_area_index_low_vegetation", + "low_vegetation_cover", + "mean_sea_level_pressure", + "mean_surface_latent_heat_flux", + "mean_surface_net_long_wave_radiation_flux", + "mean_surface_net_short_wave_radiation_flux", + "mean_surface_sensible_heat_flux", + "mean_top_downward_short_wave_radiation_flux", + "mean_top_net_long_wave_radiation_flux", + "mean_top_net_short_wave_radiation_flux", + "mean_vertically_integrated_moisture_divergence", + "potential_vorticity", + "sea_ice_cover", + "sea_surface_temperature", + "slope_of_sub_gridscale_orography", + "snow_depth", + "soil_type", + "specific_humidity", + "standard_deviation_of_filtered_subgrid_orography", + "standard_deviation_of_orography", + "surface_pressure", + "temperature", + "total_cloud_cover", + "total_column_water", + "total_column_water_vapour", + "total_precipitation_6hr", + "type_of_high_vegetation", + "type_of_low_vegetation", + "u_component_of_wind", + "v_component_of_wind", + "vertical_velocity", + "volumetric_soil_water_layer_1", + "volumetric_soil_water_layer_2", + "volumetric_soil_water_layer_3", + "volumetric_soil_water_layer_4", + + # Variables from Indian Ocean grid + "adt", + "air_temp", + "mlotst", + "sla", + "so", + "sst", + "topo", + "u_curr", + "v_curr", + "ug_curr", + "vg_curr", + "u_wind", + "v_wind", + "curr_speed", + "curr_dir", + "wind_speed", + "wind_dir", + "CHL_cmes-level3", + "CHL_cmes_flags-level3", + "CHL_cmes_uncertainty-level3", + "CHL_cmes-gapfree", + "CHL_cmes_flags-gapfree", + "CHL_cmes_uncertainty-gapfree", + "CHL_cci", + "CHL_cci_uncertainty", + "CHL_dinoef", + "CHL_dinoef_uncertainty", + "CHL_dinoef_flag" + ] = Field( + ..., + description="The specific variable name to be selected from the chosen data store." + ) + lon_range: Optional[Tuple[float, float]] = Field( + None, description="Longitude range (min_lon, max_lon) in degrees" + ) + lat_range: Optional[Tuple[confloat(ge=-90, le=90), confloat(ge=-90, le=90)]] = Field( + None, description="Latitude range (min_lat, max_lat) in degrees" + ) + time_range: Optional[Tuple[str, str]] = Field( + None, description="Time range as tuple of ISO strings, e.g., ('2000-01-01', '2000-01-31')" + ) + resample_to: Optional[str] = Field( + None, description="Resample frequency string for time dimension, e.g., 'MS' for month start" + ) + chunks: Optional[Dict[str, int]] = Field( + None, description="Dask chunks specification, e.g., {'time': 1024}" + ) + storage_options: Optional[Dict[str, Any]] = Field( + None, description="Extra options for cloud storage access if 'store' is a URL string" + ) + + """, ) return python_repl_tool \ No newline at end of file diff --git a/final_notebooks/functions/utils.py b/final_notebooks/functions/utils.py index 364e8c2..4445420 100644 --- a/final_notebooks/functions/utils.py +++ b/final_notebooks/functions/utils.py @@ -32,24 +32,15 @@ def get_prompt(): **Step 1: Advise** - Use the `advisor_tool` to identify the best dataset and variable(s) for the user's request. - - If the advisor finds no suitable data, you MUST stop and inform the user that their request cannot be fulfilled. - - **Step 2: Load Data** - - Use the `loader_tool` with the exact dataset and variable names from Step 1. - - This tool will return a local `file_path` (e.g., "temp/data.nc"). This path is critical for the next step. + - If the advisor finds no suitable data, you MUST stop and inform the user that their request cannot be fulfilled. DO NOT continue + - **Step 3: Analyze Data** + **Step 2: Analyze Data** + - based on the `advisor_tool`'s suggestion, read the appropriate file. - Use the `python_repl` tool to write and execute code for the analysis. - - Follow the critical rule below. - After the code generates output (like a plot), provide a brief, clear description of the result. --- - [CRITICAL RULE FOR STEP 3: ANALYSIS] - - **When you use the `python_repl` tool, your code MUST use the `file_path` provided by the `loader_tool` from Step 2.** - - - Your Python code should always begin by opening this specific path (e.g., `ds = xarray.open_dataset("temp/data.nc")`). - - **DO NOT** attempt to re-download, re-load, or access data from any other source or path inside the `python_repl` tool. The data is already prepared for you. """ ), ("user", "{input}"), diff --git a/final_notebooks/test_full_passthrough.ipynb b/final_notebooks/test_full_passthrough.ipynb index 384eb16..04baec8 100644 --- a/final_notebooks/test_full_passthrough.ipynb +++ b/final_notebooks/test_full_passthrough.ipynb @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "ca4d3f48-08c5-4af2-928b-fac43d458225", "metadata": {}, "outputs": [ @@ -77,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "id": "678e99bd-6161-4bde-ac3b-2ce3b21e69f5", "metadata": {}, "outputs": [ @@ -89,10 +89,29 @@ "\n", "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n", "\u001b[32;1m\u001b[1;3m\n", - "Invoking: `adviser_tool` with `{'query': 'average chlorophyll for 1 hour at the beginning of January 2020 in the Indian Ocean'}`\n", + "Invoking: `adviser_tool` with `{'query': 'plot a timeseries of chlorophyll for 1 month in the Indian Ocean, single point, January 2020 start'}`\n", "\n", "\n", - "\u001b[0m\u001b[36;1m\u001b[1;3m\n", + "\u001b[0m" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jovyan/ohw25_proj_datadashboard_llm/final_notebooks/functions/adviser_tool.py:45: LangChainDeprecationWarning: The class `Chroma` was deprecated in LangChain 0.2.9 and will be removed in 1.0. An updated version of the class exists in the :class:`~langchain-chroma package and should be used instead. To use it run `pip install -U :class:`~langchain-chroma` and import as `from :class:`~langchain_chroma import Chroma``.\n", + " vector_store_hf = Chroma(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[36;1m\u001b[1;3mdataset: Indian Ocean grid \n", + "variable: CHL_cmes-level3 \n", + "lat,lon boundaries: global \n", + "time range: 2020-01-01 to 2020-01-31 \n", + "suggestions: Indian Ocean \n", "\n", "You can use this code to analyse the data:\n", "\n", @@ -124,192 +143,163 @@ "ax.set_title('Chlorophyll Concentration (log scale)')\n", "\n", "plt.show()\u001b[0m\u001b[32;1m\u001b[1;3m\n", - "Invoking: `load_climate_data` with `{'store': 'gcs://nmfs_odp_nwfsc/CB/mind_the_chl_gap/IO.zarr', 'variable': 'CHL_cmes-gapfree', 'lon_range': [20, 120], 'lat_range': [-45, 30], 'time_range': ['2020-01-01T00:00:00', '2020-01-01T01:00:00']}`\n", - "\n", - "\n", - "\u001b[0mSaving to temp/CHL_cmes-gapfree_20250822_173942.nc (estimated size: 0.00 GB)\n", - "\u001b[33;1m\u001b[1;3mtemp/CHL_cmes-gapfree_20250822_173942.nc\u001b[0m\u001b[32;1m\u001b[1;3m\n", - "Invoking: `python_repl` with `import xarray as xr\n", - "import matplotlib.pyplot as plt\n", - "import cartopy.crs as ccrs\n", - "import cartopy.feature as cfeature\n", - "import numpy as np\n", - "\n", - "# Open the dataset from the provided file path\n", - "file_path = \"temp/CHL_cmes-gapfree_20250822_173942.nc\"\n", - "ds = xr.open_dataset(file_path)\n", - "\n", - "# Select the variable\n", - "chl = ds['CHL_cmes-gapfree']\n", - "# The data may already be a single time slice, but take mean over time just in case\n", - "chl_mean = chl.mean(dim='time')\n", - "\n", - "# Plot using a green colormap (e.g., 'Greens')\n", - "fig, ax = plt.subplots(figsize=(10,6), subplot_kw={'projection': ccrs.PlateCarree()})\n", - "\n", - "# Plot the data\n", - "im = chl_mean.plot(ax=ax,\n", - " transform=ccrs.PlateCarree(),\n", - " cmap='Greens',\n", - " add_colorbar=False,\n", - " vmax=np.nanpercentile(chl_mean, 95))\n", - "\n", - "# Add geographic features\n", - "ax.coastlines()\n", - "ax.add_feature(cfeature.BORDERS, linewidth=0.5)\n", - "ax.set_extent([20, 120, -45, 30], crs=ccrs.PlateCarree()) # Approximate Indian Ocean bounds\n", - "\n", - "# Add colorbar\n", - "cbar = plt.colorbar(im, ax=ax, orientation='vertical', shrink=0.7, pad=0.05)\n", - "cbar.set_label('Chlorophyll Concentration (mg m⁻³)')\n", - "\n", - "# Title\n", - "ax.set_title('Average Chlorophyll Concentration (1‑hour average)\\nJan 1, 2020, Indian Ocean')\n", - "\n", + "Invoking: `python_repl` with `import xarray as xr, matplotlib.pyplot as plt, numpy as np\n", + "import pandas as pd\n", + "import cmocean\n", + "\n", + "# Open dataset from GCS\n", + "store = 'gcs://nmfs_odp_nwfsc/CB/mind_the_chl_gap/IO.zarr'\n", + "# Use fsspec to open\n", + "import fsspec\n", + "fs = fsspec.filesystem('gcs')\n", + "# Open via xarray\n", + "ds = xr.open_zarr(store, consolidated=False, storage_options={'token': 'anon'})\n", + "# Select variable\n", + "chl = ds['CHL_cmes-level3']\n", + "# Subset time for Jan 2020\n", + "chl_jan = chl.sel(time=slice('2020-01-01', '2020-01-31'))\n", + "# Choose point near (0 lat, 80 lon)\n", + "point = chl_jan.sel(latitude=0, longitude=80, method='nearest')\n", + "# Convert to pandas series\n", + "ts = point.to_series()\n", + "# Plot\n", + "ts.plot(marker='o')\n", + "plt.title('Chlorophyll (CHL_cmes-level3) Time Series at lat=%.2f, lon=%.2f (Jan 2020)'\n", + " % (point.latitude.values, point.longitude.values))\n", + "plt.ylabel('Chlorophyll (mg/m^3)')\n", + "plt.xlabel('Date')\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", "plt.show()`\n", "\n", "\n", - "\u001b[0m\u001b[38;5;200m\u001b[1;3mTypeError('No numeric data to plot.')\u001b[0m" + "\u001b[0m" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/home/.pixi/envs/default/lib/python3.12/site-packages/numpy/lib/_nanfunctions_impl.py:1619: RuntimeWarning: Mean of empty slice\n", - " return np.nanmean(a, axis, out=out, keepdims=keepdims)\n" + "Python REPL can execute arbitrary code. Use with caution.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[32;1m\u001b[1;3m\n", - "Invoking: `python_repl` with `import xarray as xr, sys, json\n", - "file_path = \"temp/CHL_cmes-gapfree_20250822_173942.nc\"\n", - "ds = xr.open_dataset(file_path)\n", - "print(ds)\n", - "`\n", - "\n", + "\u001b[33;1m\u001b[1;3mExecution Result:\n", + "KeyError(\"'latitude' is not a valid dimension or coordinate for Dataset with dimensions FrozenMappingWarningOnValuesAccess({'lat': 177, 'lon': 241, 'time': 31})\")\n", "\n", - "\u001b[0m\u001b[38;5;200m\u001b[1;3m Size: 972B\n", - "Dimensions: (time: 1, lat: 0, lon: 241)\n", - "Coordinates:\n", - " * lat (lat) float32 0B \n", - " * lon (lon) float32 964B 42.0 42.25 42.5 ... 101.5 101.8 102.0\n", - " * time (time) datetime64[ns] 8B 2020-01-01\n", - "Data variables:\n", - " CHL_cmes-gapfree (time, lat, lon) float32 0B ...\n", + "Executed Code:\n", + "import xarray as xr, matplotlib.pyplot as plt, numpy as np\n", + "import pandas as pd\n", + "import cmocean\n", + "\n", + "# Open dataset from GCS\n", + "store = 'gcs://nmfs_odp_nwfsc/CB/mind_the_chl_gap/IO.zarr'\n", + "# Use fsspec to open\n", + "import fsspec\n", + "fs = fsspec.filesystem('gcs')\n", + "# Open via xarray\n", + "ds = xr.open_zarr(store, consolidated=False, storage_options={'token': 'anon'})\n", + "# Select variable\n", + "chl = ds['CHL_cmes-level3']\n", + "# Subset time for Jan 2020\n", + "chl_jan = chl.sel(time=slice('2020-01-01', '2020-01-31'))\n", + "# Choose point near (0 lat, 80 lon)\n", + "point = chl_jan.sel(latitude=0, longitude=80, method='nearest')\n", + "# Convert to pandas series\n", + "ts = point.to_series()\n", + "# Plot\n", + "ts.plot(marker='o')\n", + "plt.title('Chlorophyll (CHL_cmes-level3) Time Series at lat=%.2f, lon=%.2f (Jan 2020)'\n", + " % (point.latitude.values, point.longitude.values))\n", + "plt.ylabel('Chlorophyll (mg/m^3)')\n", + "plt.xlabel('Date')\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show()\n", "\u001b[0m\u001b[32;1m\u001b[1;3m\n", - "Invoking: `load_climate_data` with `{'store': 'gcs://nmfs_odp_nwfsc/CB/mind_the_chl_gap/IO.zarr', 'variable': 'CHL_cmes-gapfree', 'time_range': ['2020-01-01T00:00:00', '2020-01-01T01:00:00']}`\n", - "\n", - "\n", - "\u001b[0mSaving to temp/CHL_cmes-gapfree_20250822_173950.nc (estimated size: 0.00 GB)\n", - "\u001b[33;1m\u001b[1;3mtemp/CHL_cmes-gapfree_20250822_173950.nc\u001b[0m\u001b[32;1m\u001b[1;3m\n", - "Invoking: `python_repl` with `import xarray as xr\n", - "file_path = \"temp/CHL_cmes-gapfree_20250822_173950.nc\"\n", - "ds = xr.open_dataset(file_path)\n", + "Invoking: `python_repl` with `import xarray as xr, fsspec\n", + "store='gcs://nmfs_odp_nwfsc/CB/mind_the_chl_gap/IO.zarr'\n", + "ds=xr.open_zarr(store, consolidated=False, storage_options={'token':'anon'})\n", "print(ds)\n", - "print('lat values:', ds['lat'].values)\n", - "print('lon values length:', ds['lon'].size)\n", "`\n", "\n", "\n", - "\u001b[0m\u001b[38;5;200m\u001b[1;3m Size: 172kB\n", - "Dimensions: (time: 1, lat: 177, lon: 241)\n", + "\u001b[0m\u001b[33;1m\u001b[1;3mExecution Result:\n", + " Size: 66GB\n", + "Dimensions: (time: 16071, lat: 177, lon: 241)\n", "Coordinates:\n", - " * lat (lat) float32 708B 32.0 31.75 31.5 ... -11.5 -11.75 -12.0\n", - " * lon (lon) float32 964B 42.0 42.25 42.5 ... 101.5 101.8 102.0\n", - " * time (time) datetime64[ns] 8B 2020-01-01\n", - "Data variables:\n", - " CHL_cmes-gapfree (time, lat, lon) float32 171kB ...\n", - "lat values: [ 32. 31.75 31.5 31.25 31. 30.75 30.5 30.25 30. 29.75\n", - " 29.5 29.25 29. 28.75 28.5 28.25 28. 27.75 27.5 27.25\n", - " 27. 26.75 26.5 26.25 26. 25.75 25.5 25.25 25. 24.75\n", - " 24.5 24.25 24. 23.75 23.5 23.25 23. 22.75 22.5 22.25\n", - " 22. 21.75 21.5 21.25 21. 20.75 20.5 20.25 20. 19.75\n", - " 19.5 19.25 19. 18.75 18.5 18.25 18. 17.75 17.5 17.25\n", - " 17. 16.75 16.5 16.25 16. 15.75 15.5 15.25 15. 14.75\n", - " 14.5 14.25 14. 13.75 13.5 13.25 13. 12.75 12.5 12.25\n", - " 12. 11.75 11.5 11.25 11. 10.75 10.5 10.25 10. 9.75\n", - " 9.5 9.25 9. 8.75 8.5 8.25 8. 7.75 7.5 7.25\n", - " 7. 6.75 6.5 6.25 6. 5.75 5.5 5.25 5. 4.75\n", - " 4.5 4.25 4. 3.75 3.5 3.25 3. 2.75 2.5 2.25\n", - " 2. 1.75 1.5 1.25 1. 0.75 0.5 0.25 0. -0.25\n", - " -0.5 -0.75 -1. -1.25 -1.5 -1.75 -2. -2.25 -2.5 -2.75\n", - " -3. -3.25 -3.5 -3.75 -4. -4.25 -4.5 -4.75 -5. -5.25\n", - " -5.5 -5.75 -6. -6.25 -6.5 -6.75 -7. -7.25 -7.5 -7.75\n", - " -8. -8.25 -8.5 -8.75 -9. -9.25 -9.5 -9.75 -10. -10.25\n", - " -10.5 -10.75 -11. -11.25 -11.5 -11.75 -12. ]\n", - "lon values length: 241\n", - "\u001b[0m" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[32;1m\u001b[1;3m\n", - "Invoking: `python_repl` with `import xarray as xr\n", - "import matplotlib.pyplot as plt\n", - "import cartopy.crs as ccrs\n", - "import cartopy.feature as cfeature\n", - "import numpy as np\n", + " * lon (lon) float32 964B 42.0 42.25 ... 101.8 102.0\n", + " * time (time) datetime64[ns] 129kB 1979-01-01 ... ...\n", + " * lat (lat) float32 708B 32.0 31.75 ... -11.75 -12.0\n", + "Data variables: (12/27)\n", + " CHL_cmes-gapfree (time, lat, lon) float32 3GB dask.array\n", + " CHL_cmes_flags-level3 (time, lat, lon) float32 3GB dask.array\n", + " CHL (time, lat, lon) float32 3GB dask.array\n", + " CHL_cmes_flags-gapfree (time, lat, lon) float32 3GB dask.array\n", + " CHL_cmes-cloud (time, lat, lon) uint8 686MB dask.array\n", + " CHL_cmes-land (lat, lon) uint8 43kB dask.array\n", + " ... ...\n", + " v_curr (time, lat, lon) float32 3GB dask.array\n", + " vg_curr (time, lat, lon) float32 3GB dask.array\n", + " u_curr (time, lat, lon) float32 3GB dask.array\n", + " v_wind (time, lat, lon) float32 3GB dask.array\n", + " wind_dir (time, lat, lon) float32 3GB dask.array\n", + " wind_speed (time, lat, lon) float32 3GB dask.array\n", + "Attributes: (12/92)\n", + " Conventions: CF-1.8, ACDD-1.3\n", + " DPM_reference: GC-UD-ACRI-PUG\n", + " IODD_reference: GC-UD-ACRI-PUG\n", + " acknowledgement: The Licensees will ensure that original ...\n", + " citation: The Licensees will ensure that original ...\n", + " cmems_product_id: OCEANCOLOUR_GLO_BGC_L3_MY_009_103\n", + " ... ...\n", + " time_coverage_end: 2024-04-18T02:58:23Z\n", + " time_coverage_resolution: P1D\n", + " time_coverage_start: 2024-04-16T21:12:05Z\n", + " title: cmems_obs-oc_glo_bgc-plankton_my_l3-mult...\n", + " westernmost_longitude: -180.0\n", + " westernmost_valid_longitude: -180.0\n", + "\n", + "\n", + "Executed Code:\n", + "import xarray as xr, fsspec\n", + "store='gcs://nmfs_odp_nwfsc/CB/mind_the_chl_gap/IO.zarr'\n", + "ds=xr.open_zarr(store, consolidated=False, storage_options={'token':'anon'})\n", + "print(ds)\n", "\n", - "file_path = \"temp/CHL_cmes-gapfree_20250822_173950.nc\"\n", - "ds = xr.open_dataset(file_path)\n", - "# Extract the variable (single time)\n", - "chl = ds['CHL_cmes-gapfree']\n", - "# Remove the time dimension (since it's length 1)\n", - "chl = chl.squeeze('time')\n", - "# Optionally compute mean over time (not needed)\n", - "# Plot with green colormap\n", - "fig, ax = plt.subplots(figsize=(12,6), subplot_kw={'projection': ccrs.PlateCarree()})\n", - "# Set extent for Indian Ocean region\n", - "ax.set_extent([20, 120, -45, 30], crs=ccrs.PlateCarree())\n", + "\u001b[0m\u001b[32;1m\u001b[1;3m\n", + "Invoking: `python_repl` with `import xarray as xr, matplotlib.pyplot as plt\n", + "store='gcs://nmfs_odp_nwfsc/CB/mind_the_chl_gap/IO.zarr'\n", + "ds = xr.open_zarr(store, consolidated=False, storage_options={'token':'anon'})\n", + "chl = ds['CHL_cmes-level3']\n", + "# Subset time for Jan 2020\n", + "chl_jan = chl.sel(time=slice('2020-01-01','2020-01-31'))\n", + "# Choose point near lat=-10, lon=80 (nearest)\n", + "point = chl_jan.sel(lat=-10, lon=80, method='nearest')\n", + "# Convert to pandas Series\n", + "ts = point.to_series()\n", "# Plot\n", - "im = chl.plot(ax=ax,\n", - " transform=ccrs.PlateCarree(),\n", - " cmap='Greens',\n", - " add_colorbar=False,\n", - " vmax=np.nanpercentile(chl, 95))\n", - "# Add features\n", - "ax.coastlines()\n", - "ax.add_feature(cfeature.BORDERS, linewidth=0.5)\n", - "# Colorbar\n", - "cbar = plt.colorbar(im, ax=ax, orientation='vertical', shrink=0.7, pad=0.05)\n", - "cbar.set_label('Chlorophyll (mg m⁻³)')\n", - "# Title\n", - "ax.set_title('Average Chlorophyll Concentration (1‑hour)\\nJan 1, 2020 – Indian Ocean')\n", + "plt.figure(figsize=(8,4))\n", + "ts.plot(marker='o')\n", + "plt.title(f'CHL_cmes-level3 Time Series (Jan 2020) at lat={float(point.lat.values):.2f}, lon={float(point.lon.values):.2f}')\n", + "plt.ylabel('Chlorophyll (mg m⁻³)')\n", + "plt.xlabel('Date')\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", "plt.show()`\n", "\n", "\n", "\u001b[0m" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/.pixi/envs/default/lib/python3.12/site-packages/cartopy/io/__init__.py:242: DownloadWarning: Downloading: https://naturalearth.s3.amazonaws.com/110m_cultural/ne_110m_admin_0_boundary_lines_land.zip\n", - " warnings.warn(f'Downloading: {url}', DownloadWarning)\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAGGCAYAAADmRxfNAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAmUlJREFUeJzs3Xd4U2X7B/BvRtt0l+5BacsulFlWGQIqZW8VcYCCyPJFQNRXfRVBBSciylBkqPwUUJZoRZAps+y9aSnQltKWDrqbPL8/0gRCOpI2aZL2+7muXhecnJzzZDTNfZ77uW+JEEKAiIiIiIioCqSWHgAREREREdk+BhZERERERFRlDCyIiIiIiKjKGFgQEREREVGVMbAgIiIiIqIqY2BBRERERERVxsCCiIiIiIiqjIEFERERERFVGQMLIiIiIiKqMgYWVO1OnTqFF198EWFhYVAoFHBxcUHbtm3x6aefIj09Xbtfjx49EBERUeoxUlNTIZFI8P7772u37dq1CxKJBL/99pu5H4JNiI+Ph0QiwcqVKy09FADQe71u3LiBoUOHon79+nB2doa7uzvatGmDb775BsXFxRUey5CfXbt24YUXXkBoaKh5H5yRbty4gUmTJqFx48ZwdHSEp6cnWrRogXHjxuHGjRsmPdfKlSshkUgQHx9v0uMaYvbs2WjWrBlUKpV2m0QiwSuvvFLtY7l06RJmzJiByMhIeHh4wNPTE126dCnz8yIlJQUvvPACvL294eTkhKioKGzfvl1nn6ysLHz00Ufo0aMH/P394eLighYtWuCTTz5Bfn6+3jGLioowa9YshIaGwsHBAU2bNsXXX3+tt9/zzz+PIUOGmORxP+jnn3/G/PnzDd6/R48e6NGjR6XOtWjRomr77Jk/fz6GDRuGsLAwSCSScsdsyOtanmvXrmHYsGHw8PCAi4sLevXqhWPHjpW67+rVq9G6dWsoFAoEBgZi6tSpuHfvnrEPT6sqr0d12LlzJ3r16gVfX1+4uLigZcuWWLBgAZRKpd6+//zzD6KiouDk5ARvb2+88MILSElJMfhchj639+7dw9SpUxEYGAiFQoHWrVtj9erVVXqcVAFBVI2+++47IZfLRfPmzcXChQvFzp07xdatW8WcOXNEWFiYGDJkiHbf7t27i+bNm5d6nDt37ggAYubMmdptO3fuFADEr7/+au6HYRPi4uIEALFixQpLD0UIIfRer/Pnz4tRo0aJ5cuXi3/++UfExMSIV155RQAQY8eOLfdYBw4c0Pnp16+fcHR01NuemZkprly5Io4dO2bmR2e4GzduCG9vb9GwYUOxePFisWPHDrFhwwbx0UcfiVatWoldu3aZ9HwpKSniwIEDIj8/36THrcitW7eEs7Oz3u8jADF58uRqHYsQQnz99deiadOm4qOPPhJbt24VMTExYvTo0QKAmDVrls6++fn5IiIiQtStW1esWrVKbN26VQwePFjI5XKd1+f06dPC29tbTJs2TWzatEls375dvP/++0KhUIjHHntMqFQqneO+9NJLwsHBQXz66adi586d4r///a+QSCTio48+0tnvypUrQi6Xi+3bt5v0Oejfv78ICQkxeP/u3buL7t27V+pczZs3r/R9jdWkSRPRtm1bMWbMGOHj41PmeQ19XcuSkpIiAgMDRfPmzcW6devEn3/+Kbp27SpcXV3FhQsXdPZdtWqVACBeeuklsWPHDrFkyRLh7u4uevXqVenHWZXXw9y2bdsmpFKp6NGjh9i4caPYtm2b+M9//iMAiClTpujsu2vXLiGXy8XgwYPF1q1bxapVq0RQUJCIiIgw6HPKmOe2V69ewsPDQyxZskTs2LFDvPTSSwKA+L//+z+TPXbSxcCCqs3+/fuFTCYTffr0KfXDo6CgQGzatEn7fwYWVWPtgUVZnnrqKSGXy436Ijx69Gjh7OxchdFVn/fee08AENeuXSv1dqVSaZLz5Obm6n2xrU5vvPGGCAoK0ns8lgos7ty5U+rz0b9/f+Hk5KTzflu4cKEAIPbv36/dVlRUJJo1ayY6dOig3Xbv3j1x7949vWN+9tlnAoD4999/tdvOnDkjJBKJmDNnjs6+48aNE46OjiItLU1n+4ABA6r0JbQ0NTWwePA9Vt55DX1dy/L6668LOzs7ER8fr92WmZkpvL29xVNPPaXdVlxcLAICAkR0dLTO/f/v//5PABAxMTGGPjQd1hxYPPvss8LBwUHv9yE6Olq4ubnpbGvfvr1o1qyZKCoq0m7bt2+fACAWLVpU7nmMeW7//PNPAUD8/PPPOvv26tVLBAYGiuLiYqMeIxmGqVBUbebMmQOJRILvvvsODg4Oerfb29tj0KBBFhiZvi1btuCxxx6Du7s7nJycEB4ejrlz52pvf+GFF+Di4oILFy6gd+/ecHZ2RkBAAD7++GMAwMGDB9G1a1c4OzujcePG+OGHH/TOkZycjPHjx6Nu3bqwt7dHWFgYZs2apZcGtHjxYrRq1QouLi5wdXVF06ZN8fbbb1f6sV2+fBnPPPMMfH194eDggPDwcCxcuFB7+507d2Bvb493331X774XLlyARCLBggULjH4chvLx8YFUKoVMJqvU/R9WWiqUJh1nxYoVaNKkCRwdHdGuXTscPHgQQgh89tlnCAsLg4uLCx599FFcuXJF77j//PMPHnvsMbi5ucHJyQldunQxKKUiLS0NUqkUvr6+pd4ulep+LB85cgSDBg2Cp6cnFAoF2rRpg7Vr1+rso0l32rp1K8aMGQMfHx84OTmhoKCgzFQoQ8Z/584dvPzyywgODoaDgwN8fHzQpUsX/PPPP+U+xsLCQixbtgzPPPOM3uN5WH5+Pl577TW0bt0a7u7u8PT0RFRUFDZt2qS3r+Z1++mnnxAeHg4nJye0atUKf/zxR7nnAABvb29IJBK97R06dEBubq5OGuaGDRvQpEkTREVFabfJ5XI899xziI2Nxa1btwAAzs7OcHZ2LvWYAHTS2jZu3AghBF588UWdfV988UXk5eVhy5YtOtuff/55/PPPP7h69WqFj23hwoV45JFH4OvrC2dnZ7Ro0QKffvopioqKtPv06NEDf/75J65fv66TLmisWbNmoWPHjvD09ISbmxvatm2LZcuWQQih3Sc0NBRnz57F7t27tecxZzpiRe8xDUNf1/Lu/+ijjyIkJES7zc3NDcOGDcPmzZu1n3kHDx5EUlKS3mv95JNPwsXFBRs2bDD0oVUoPT0dkyZNQlBQEOzt7VG/fn288847KCgo0NmvKr87hrCzs4O9vT0cHR11tnt4eEChUGj/f+vWLRw+fBjPP/885HK5dnvnzp3RuHHjCp8bY57bDRs2wMXFBU8++aTOvi+++CISExNx6NAhox8nVYyBBVULpVKJHTt2IDIyEsHBwUbdt7i4WO+ntJxNU1m2bBn69esHlUqFJUuWYPPmzZgyZQpu3ryps19RURGGDRuG/v37Y9OmTejbty/eeustvP322xg9ejTGjBmj/UP2wgsv4OjRo9r7Jicno0OHDvj777/x3nvv4a+//sLYsWMxd+5cjBs3Trvf6tWrMWnSJHTv3h0bNmzAxo0bMW3aNOTk5FTqsZ07dw7t27fHmTNn8MUXX+CPP/5A//79MWXKFMyaNQuA+ov9gAED8MMPP+jkxgPAihUrYG9vj2effdaox1EeIQSKi4tx9+5drFmzBitXrsRrr72m80fHHP744w98//33+Pjjj/HLL78gOzsb/fv3x2uvvYZ9+/bhm2++wXfffYdz585h+PDhOl+cVq1ahejoaLi5ueGHH37A2rVr4enpid69e1cYXERFRUGlUmHYsGH4+++/kZWVVea+O3fuRJcuXZCRkYElS5Zg06ZNaN26NUaMGFFq/vqYMWNgZ2eHn376Cb/99hvs7OxKPa6h43/++eexceNGvPfee9i6dSu+//57PP7440hLSyv3MR46dAhpaWno2bNnufsBQEFBAdLT0zFjxgxs3LgRv/zyC7p27Yphw4bhxx9/1Nv/zz//xDfffIPZs2dj3bp18PT0xNChQ3Ht2rUKz1WanTt3wsfHRyfQO3PmDFq2bKm3r2bb2bNnyz3mjh07AADNmzfXOaaPjw/8/f1LPeaZM2d0tvfo0QNCCMTExFT4GK5evYpnnnkGP/30E/744w+MHTsWn332GcaPH6/dZ9GiRejSpQv8/f1x4MAB7Y+x4uPjMX78eKxduxbr16/HsGHD8J///AcffPCBdp8NGzagfv36aNOmjfY8D37hK+0zvbSfB3/nTKEqr2teXh6uXr1a5v3z8vK070HNa/nwvnZ2dmjatKnea11Z+fn56NmzJ3788UdMnz4df/75J5577jl8+umnGDZsmN7+hvzuaD6PDfl50IQJE1BYWIgpU6YgMTERGRkZ+Omnn7Bhwwa88cYb2v3Kem402yp6box5bs+cOYPw8HC9vyVl/c6RiVhusoRqk+TkZAFAPP300wbfp3v37gJAuT+mToXKzs4Wbm5uomvXruWmkWhys9etW6fdVlRUJHx8fAQAnZz+tLQ0IZPJxPTp07Xbxo8fL1xcXMT169d1jvv5558LAOLs2bNCCCFeeeUV4eHhUanHUloqVO/evUXdunVFZmamzr6vvPKKUCgUIj09XQghxO+//y4AiK1bt2r3KS4uFoGBgWL48OFGPw4hyk6Fmjt3rvb1lEgk4p133jH6sZaXCjV69Gi99A8Awt/fX2fafuPGjQKAaN26tc5rP3/+fAFAnDp1SgghRE5OjvD09BQDBw7UOaZSqRStWrWqMKVCpVKJ8ePHC6lUqn3M4eHhYtq0aSIuLk5n36ZNm4o2bdropAwIoU6TCQgI0KaArFixQgAQo0aN0juf5jbNsY0Zv4uLi5g6dWq5j6c0n3zyiQAgkpOT9W5DBalQxcXFoqioSIwdO1a0adNG775+fn4iKytLuy05OVlIpVIxd+5co8e5dOlSAUB89dVXOtvt7OzE+PHj9fbfv39/qakVDzp58qRwdHQUQ4cO1dneq1cv0aRJk1LvY29vL15++WW97UFBQWLEiBGGPBQtpVIpioqKxI8//ihkMpn2d1oI06dCac41e/Zs4eXlpfN7U15KUkWf65qfyqRxlnfeqryut27dEgBKfZ/9/PPPOilWH330kQAgkpKS9PaNjo4WjRs3NvDR6Hr49ViyZIkAINauXauzn+b378HPb0N/dzR/Rw35efjzat++fSIwMFB7u0wmE59++qnOPpqUpQMHDug9vpdfflnY29uX+xwY89w2atRI9O7dW2+/xMREAUAvLZFMw7yXBImqqEGDBqVWcMjMzMTjjz9u8vPt378fWVlZmDRpUoVpAhKJBP369dP+Xy6Xo2HDhpDL5WjTpo12u6enJ3x9fXH9+nXttj/++AM9e/ZEYGCgzpWfvn37YsaMGdi9ezeaNWuGDh064JtvvsHIkSPx9NNPo0uXLvD29tYZx8NXjmQyWaljz8/Px/bt2zFx4kQ4OTnp3K9fv3745ptvcPDgQfTt2xd9+/aFv78/VqxYgV69egEA/v77byQmJmLMmDFGP47yvPDCC3j88ceRnp6OHTt24LPPPkNmZmap1XJMqWfPnjppLOHh4dqxP/j8abZfv34dLVq0wP79+5Geno7Ro0frPfd9+vTBp59+ipycnFJTZAD1+2bJkiV46623EBMTgyNHjmDPnj348ssv8e233yImJgbdu3fHlStXcOHCBXz++ecAoPd6/fHHH7h48aJ2fAAwfPjwCh+3MePv0KEDVq5cCS8vLzz++OOIjIwscxbkQYmJiZBIJHrv1bL8+uuvmD9/Pk6ePKkzG/dgCoVGz5494erqqv2/n5+f3u+XIf766y9MnjwZTzzxBP7zn//o3V7e739Zt8XHx2PAgAEIDg7G999/X+Vj+vr6VpieAwDHjx/HzJkzsW/fPp2ULkBdDatjx44VHsNQO3bswJw5c3D48GG92baUlBT4+flVeIzDhw8bdK6wsDDtvw39nKtIZV7Xyt6/rH0rM+7S7NixA87OznjiiSd0tr/wwgt48803sX37du3nN2DY705kZKTBr09gYKD230ePHsXQoUPRsWNHfPvtt3B2dsaOHTvwv//9D/n5+XqptVV9bgy9f1VfbzIeAwuqFprSfnFxcUbdT6FQoF27dnrbU1NTTTU0HXfu3AEA1K1bt8J9nZyc9L742Nvbw9PTU29fe3t7nfKTt2/fxubNm8v8kqZ5fM8//zyKi4uxdOlSDB8+HCqVCu3bt8eHH36o/YPx8DFWrFiBF154Qe+YaWlpKC4uxtdff13ml3bNeeVyOZ5//nl8/fXXyMjIgIeHB1auXImAgAD07t3b6MdRHn9/f216SHR0NOrUqYP//ve/GDNmjE6AZmoPv0729vblbte8frdv3wYAvT/mD0pPTy8zsNAICQnBxIkTtf9fu3YtRo4ciddffx2xsbHa88yYMQMzZswo9RgPP78BAQHlntPY8a9ZswYffvghvv/+e7z77rtwcXHB0KFD8emnn+ql9DwoLy8PdnZ2Bq2TWb9+PZ566ik8+eSTeP311+Hv7w+5XI7Fixdj+fLlevt7eXnpbXNwcEBeXl6F59L4+++/MWzYMPTq1Qv/93//p/cFw8vLq9R0L82X9tJ+x69fv46ePXtCLpdj+/btevt4eXnhxIkTevfLyclBYWFhqcdUKBQVPq6EhAR069YNTZo0wVdffYXQ0FAoFArExsZi8uTJRj0vFYmNjUV0dDR69OiBpUuXatdVbdy4ER999JHB52rdurVB+z34/jH0c648lXldNerUqQOJRGLQ/TXv0bS0NL1AKz09vdzzGCMtLQ3+/v56719fX1/I5XK9sRryu+Pi4mLw6/NgitHkyZPh5+eHDRs2aF+3nj17QiqV4v3338ezzz6L+vXr6zw3DzPkuTHmua3K602Vx8CCqoVMJsNjjz2Gv/76Czdv3jToi7sl+Pj4AIDeegpT8/b2RsuWLfHRRx+VevuDV4JefPFFvPjii8jJycGePXswc+ZMDBgwAJcuXUJISIje1aUHr/I9qE6dOpDJZHj++ecxefLkUvd58L4vvvgiPvvsM6xevRojRozA77//jqlTp+r8sTfmcRhKs/D10qVLZg0sKktzFf7rr79Gp06dSt3HkKu2D3vqqacwd+5cbd6v5jxvvfVWqfnSANCkSROd/xtyBc6Y8Xt7e2P+/PmYP38+EhIS8Pvvv+O///0vUlJS9BYbP3yOwsLCcmduNFatWoWwsDCsWbNGZ/wPLz41lb///htDhgxB9+7dsW7dOm3g+KAWLVrg9OnTets12x7ur3P9+nXtmohdu3aV+vnWokULrF69GsnJyTpBWVnHBNRfgCpa9Lxx40bk5ORg/fr1OouKSwtiqmr16tWws7PDH3/8oXNRZePGjUYdx5BZL0A3eDD0c648xr6uD3J0dETDhg3LvL+joyPq16+vPY9m+4MztsXFxbhw4QJGjhxp9NhL4+XlhUOHDkEIofO7k5KSguLiYoNnDB+0e/dug9ZGAUBcXJz2/XnixAmMHDlS72JC+/btoVKpcP78edSvX1/7HJ8+fVpnxl+zrbzXADDuuW3RogV++eUXFBcX6wRBhrzeVHkMLKjaaFI/xo0bh02bNun9QS8qKsKWLVswcOBAC41QXZnC3d0dS5YswdNPP222qdIBAwYgJiYGDRo0QJ06dQy6j7OzM/r27YvCwkIMGTIEZ8+eRUhISKkzOqVxcnJCz549cfz4cbRs2bLUL1QPCg8PR8eOHbFixQoolUoUFBToVeKozOOoyM6dOwEADRs2NMnxTK1Lly7w8PDAuXPnKtXoLSkpqdSZhXv37uHGjRvaYKxJkyZo1KgRTp48iTlz5lR53BqVHX+9evXwyiuvYPv27di3b1+5+zZt2hQAylzs+iCJRAJ7e3ud37Xk5ORSq0JV1datWzFkyBB07doVGzduLLU6HQAMHToUkyZNwqFDh7RpRMXFxVi1ahU6duyoEzAnJCSgR48eUCqV2LVrl86X+wcNHjwY//vf//DDDz/gzTff1G5fuXIlHB0d0adPH539i4uLcePGDb0vXw/TPG8PPhYhBJYuXaq3r7EzO6WdSy6X63x5zMvLw08//WTUuSqTCmXo51x5jHldy7r//PnzcePGDW0RkuzsbKxfvx6DBg3Sfnnt2LEjAgICsHLlSowYMUJ7/99++w337t0r80KBsR577DGsXbsWGzduxNChQ7XbNUUPHnvsMaOPWdlUqMDAQBw5cgRKpVLn/aEpEKAJtoOCgtChQwesWrUKM2bM0O578OBBXLx4EVOnTi33nMY8t0OHDsXSpUuxbt06nX1/+OEHBAYGmjRFkO5jYEHVJioqCosXL8akSZMQGRmJiRMnonnz5igqKsLx48fx3XffISIiosqBxcGDB0vd3r17d+2MRFlcXFzwxRdf4KWXXsLjjz+OcePGwc/PD1euXMHJkyfxzTffVGlsGrNnz8a2bdvQuXNnTJkyBU2aNEF+fj7i4+MRExODJUuWoG7duhg3bhwcHR3RpUsXBAQEIDk5GXPnzoW7uzvat29v9Hm/+uordO3aFd26dcPEiRMRGhqK7OxsXLlyBZs3b9ZWs9EYM2YMxo8fj8TERHTu3FnvCrmhj6M0M2fOxO3bt/HII48gKCgIGRkZ2LJlC5YuXYonn3wSkZGRRj++6uDi4oKvv/4ao0ePRnp6Op544gn4+vrizp07OHnyJO7cuYPFixeXef+PPvoI+/btw4gRI9C6dWs4OjoiLi4O33zzDdLS0vDZZ59p9/3222/Rt29f9O7dGy+88AKCgoKQnp6O8+fP49ixY/j111/NNv7MzEz07NkTzzzzDJo2bQpXV1ccPnwYW7ZsqfCLkaY78MGDB0sNLB4MIgYMGID169dj0qRJeOKJJ3Djxg188MEHCAgIwOXLl41+fGXZu3cvhgwZAn9/f7z99tt6V/SbNWsGNzc3AOr3/cKFC/Hkk0/i448/hq+vLxYtWoSLFy/qlNpNSUlBz549kZSUhGXLliElJUWne3DdunW17//mzZtj7NixmDlzJmQyGdq3b4+tW7fiu+++w4cffqiXlnHq1Cnk5uZWePW4V69esLe3x8iRI/HGG28gPz8fixcvxt27d/X2bdGiBdavX4/FixcjMjISUqnUqC/s/fv3x7x58/DMM8/g5ZdfRlpaGj7//PNSAzTNDM2aNWtQv359KBQK7dVmUwQJDzpy5Ii2nHJWVhaEENqO6u3bt9cGe4a+roD6S/nu3bt11nbMmDEDP/30E/r374/Zs2fDwcEBH3/8MfLz8/H+++9r95PJZPj000/x/PPPY/z48Rg5ciQuX76MN954A7169dILIiUSCbp3745du3YZ9bhHjRqFhQsXYvTo0YiPj0eLFi2wd+9ezJkzB/369avUOkRXV9dKvT7Tpk3DlClTMHDgQIwfPx5OTk7Yvn07vvjiCzz++ONo1aqVdt9PPvkEvXr1wpNPPolJkyYhJSUF//3vfxEREaFz8er69eto0KABRo8ejWXLlgEw7rnt27cvevXqhYkTJyIrKwsNGzbEL7/8gi1btmDVqlUmK2lOD7Hs2nGqjU6cOCFGjx4t6tWrJ+zt7YWzs7No06aNeO+990RKSop2v8o2yCvrZ+fOnQaPMSYmRnTv3l04OzsLJycn0axZM/HJJ59oby+rClFZYw4JCRH9+/fXewxTpkwRYWFhws7OTnh6eorIyEjxzjvvaKsV/fDDD6Jnz57Cz89P2Nvbi8DAQPHUU09pKxSVp6wGeXFxcWLMmDEiKChI2NnZCR8fH9G5c2fx4Ycf6h0jMzNTODo6CgBi6dKlpZ7HkMchhH5VqN9//108/vjjws/PT8jlcuHi4iI6dOggFixYoFcFqSKVqQr1cGUizfP12Wef6Wwvq9rY7t27Rf/+/YWnp6ews7MTQUFBon///hVWJTt48KCYPHmyaNWqlfD09BQymUz4+PiIPn36lNo46+TJk+Kpp54Svr6+ws7OTvj7+4tHH31ULFmyRLuPpvLT4cOH9e7/cFUoQ8efn58vJkyYIFq2bCnc3NyEo6OjaNKkiZg5c6bIyckp9zEKIUS3bt1Ev379dLbl5OQIAOK1117T2f7xxx+L0NBQ4eDgIMLDw8XSpUvFzJkzxcN/okp73YRQ/36NHj263PFojmfo50NycrIYNWqU8PT0FAqFQnTq1Els27ZNZ5+KPnMeroJWWFgoZs6cqf3sa9y4sViwYEGp43333XeFt7e3QY0iN2/eLFq1aiUUCoUICgoSr7/+uvjrr7/0Hld6erp44oknhIeHh5BIJHrP78NKqwq1fPly0aRJE+Hg4CDq168v5s6dK5YtW6b3HouPjxfR0dHC1dVVADCqGpWxNFX6Svt5+PPPkNdViPtVCR925coVMWTIEOHm5iacnJzEY489Jo4ePVrquH7++WfRsmVLYW9vL/z9/cWUKVNEdna2zj7Z2dkGV0ws7fVIS0sTEyZMEAEBAUIul4uQkBDx1ltv6b1vqvK7Y6h169aJrl27Cm9vb+Hs7CyaN28uPvjgg1KbSG7dulV06tRJKBQK4enpKUaNGiVu376ts4/mM7m08Rny3Aqhfn6nTJki/P39hb29vWjZsqX45ZdfTPJ4qXQSIUxcKJqIiGo9TfrB9evXERQUBEBdvaht27ZYuHAhJk2aZOERWi+lUomGDRvimWeeKXP9EtUMMTExGDBgAE6ePKmd0SGyZWyQR0REJjds2DC0b98ec+fOxc2bN/HHH39g0qRJcHJywpAhQyw9PKu2atUq3Lt3D6+//rqlh0JmtnPnTjz99NMMKqjG4IwF1RpKpbLcTq4SiYQ5l0QmdObMGfz+++/Iz8/Hp59+ipYtW2Lu3LmVWlRam6xYsQJBQUGIjo629FCIiIzCwIJqjR49emD37t1l3h4SEqJdAEhERERExmFgQbXGxYsXkZ2dXebtDg4OnI4mIiIiqiQGFkREREREVGVcvE1ERERERFXGBnmVpFKpkJiYCFdXV7N1ZyYiIiIisiQhBLKzsxEYGAiptPw5CQYWlZSYmIjg4GBLD4OIiIiIyOxu3LiBunXrlrsPA4tKcnV1BQDExcXB09PTwqMhIiIiIjK99PR0hIWFab/7loeBRSVp0p9cXV3h5uZm4dEQEREREZleUVERABiU+s/F20REREREVGUMLIiIiIiIqMoYWBARERERUZUxsCAiIiIioirj4m0yGaVKIDYuHSnZ+fB1VaBDmCdkUvb4ICIiIqoNGFiQSWw5k4RZm88hKTNfuy3AXYGZA5uhT0SABUdGRERERNWBqVBUZVvOJGHiqmM6QQUAJGfmY+KqY9hyJslCIyMyD6VK4MDVNGw6cQsHrqZBqRKWHhIREZHFccaCqkSpEpi1+RxK+1olAEgAzNp8Dr2a+TMtimoEzs4RERGVjjMWVCWxcel6MxUPEgCSMvMRG5defYMiMhPOzhEREZWNgQVVSUp22UFFZfYjslYVzc4B6tk5pkUREVFtxcCCqsTXVWHS/YisFWfniIiIysfAgqqkQ5gnAtwVKGv1hATq/PMOYZ7VOSwikypWqrD7UopB+3J2joiIaisu3qYqkUklmDmwGSauOqZ3mybYmDmwGRduk006l5iF9cduYuOJRKTeKzDoPpydIyKi2oqBBVVZn4gALH6uLaavPYncQqV2uz8r5ZANup2Vj00nbmH9sVu4kJyt3V7HyQ4FxSqd9/iDJFC/5zk7R0REtRUDCzKJPhEBWLkvHgfj0vFMh2AMbBXEzttkM3ILi7H17G2sO3YT+66kQrP+2l4mxePNfDGsTV10b+KD7edva2fnSluizdk5IiKqzRhYkMlcuXMPADCifT20Cvaw7GCo1lOqBGLj0pGSnQ9fV4VeoKtSCRy8loZ1x25hy5kk5DwwE9EupA6Gta2L/i0C4O5kp92umZ17uI+Fg1yKr55uzdk5IiKq1RhYkEmk5xQi9V4hAKCRn4uFR0O1XXlN7Br6umD9sVvYePwWEh+4vZ6nE4a1DcLQNkEI8XIu89h9IgLQq5k/YuPScS4pEx/8cR6FxSq0C2UKFBER1W4MLMgkLt1W56IHezrCyZ5vK7IcTRO7h1OVkjLzMeGhIgNuCjn6twzE8LZBiAypA4nEsDQmmVSCqAZeiGrghU0nEnHqZib+Op2E56NCTfMgiIiIbBC/AZJJaAKLxr6uFh6J9akoJYdMp7wmdg96rKkPhkcG49GmvlDYyap0zoEtA3HqZiY2n2JgQUREtRsDCzIJTWDRyI+BxYPKS8lhPr7pVdTETuOlbg0Q1cDLJOfs3zIAH8Wcx+H4dCRl5iHA3dEkxyUiIrI1bJBHJnHptnrhdmOur9DSpOQ8/EU3OTMfE1cdw5YzSRYaWc2VkmVYczpTNrEL9HBEu5A6EAL48xRfUyIiqr0YWFCVCSFwWZMKxRkLAOWn5Gi2zdp8DkpVRUk7ZKikzDws3xdn0L6mbmI3sFUgAOAPBhZERFSLMbCgKku9V4i7uUWQSICGvpyxACpOyRFQLyaOjUuvvkHVUEIIrD1yA9Ff7sHJm5nl7iuBOhXN1E3s+rbwh1QCnLiRgRvpuSY9NhERka1gYEFVppmtCPF0qvJC2JogKTMPy/ZeM2hfU6bk1EbJmfkYs/Iw3vjtFLLzi9E62AMzBzaDBOog4kGa/5ujiZ2vqwKd6qvXbGw+lWjSYxMREdkKLt6mKrvIhdsAgOMJd7F8XzxiTicZnOJk6pSc2kIIgXXHbmHW5rPIzi+GvVyK6b0a46WuYZDLpAhwV+gtmvc386L5ga0Csf9qGv44mYRJPRqa5RxERETWjIEFVVltXrhdpFThrzPJWLEvDscTMrTbO4TWweWUe8jILSqz9Kk5UnJqg9tZ+Xhr/WnsuJACAGhV1x2fP9lKJ7B9sIlddZX57dPcH+9uPINzSVm4knKPaYFERFTrMLCgKquNC7fv5hTil8MJ+HH/dSSXVCKyl0kxqHUgXuwSiuaB7tqqUBKg1OBi6uON2c/CCEIIbDh+C+//fhZZ+cWwl0kxtVcjvNytPuQy/axOTRO76lLH2R5dG3lj18U7+ONUIqY+3rjazk1ERGQNGFhQlQgh7jfHqwWBxeXb2VixPx7rj91EfpEKAODtYo/nOoXg2Y4h8HF10O7bJyIAi59rq5eSYyeToEgpcOBqKka0D672x2CLUrLy8faG0/jnvHqWomXJLIW1vecGtgzErot3sPlkIl59rJHBnbyJiIhqAgYWVCUp2QXIyi+GTCpBfR9nSw+n0srrjq1SCey+fAcr9sVjz6U72vs0C3DDmK5hGNgqAA7y0hetl5aSo7CTYtji/dh4IhFPRAajayPvanmMtkgIgU0nEjHz97PIzCuCnUyCqY83xvhHSp+lsLRezf1gv0GKq3dycCE5G+EBbpYeEhERUbVhYEFVopmtCPFyKvPLtbUrqzv2f/s2RVZ+MVbsi8O1OzkAAIkEiG7mhzFdwtAhzNOgK9KlpeSM6hSCHw5cx7ubzuCvV7uxmlYpUrLz8c6GM9h27jYAoEWQepaiib91zVI8yE1hhx6NfbD13G1sPpnIwIKIiGoVBhZUJReTS9KgfK33y155NOsgHl4DkZSZj1dXn9D+38VBjhHtgzE6KhT1vJyqfN7XejfBX2eSEZeag8W7rmJar9qXj1/WLJEQAr+fVM9SZOSqZymmPNoIE3o0gJ0VzlI8bGCrQHVgcSoRr/duwnQoIiKqNRhYUJVctuGKUOV1x9aQSSV4u19TPNUuGK4KO5Od201hh5kDm2Pyz8eweNdVDGodiAY+tvccVlZZs0RTH2+MHRdu4++z6lmK5oFu+PzJVjZ15f+xcF842slwIz0Pp25molWwh6WHREREVC2s//IfWbVLKbbbw6Ki7tiAOvhoFuBu0qBCo18Lf3Rv7INCpQrvbjwDIQzrfWHrNLNEDz/3SZn5eHPdKfx99jbkUgmmPd4YGyd3samgAgCc7OV4vJkfAGDzSTbLIyKi2oOBBVWaEAJXSmYsrDnvvSyGdr02V3dsiUSCDwZHwEEuxf6radh44pZZzmNNDJklkksl2DCpC159vJFNpD6VZkBLdRO+P04lQWVgs0QiIiJbZ/G/2osWLUJYWBgUCgUiIyPx77//lrv/7t27ERkZCYVCgfr162PJkiU6t/fo0QMSiUTvp3///lU6L+lLysxHdkEx5FIJQr1sryKUoV2vzdkdu56XE6Y81ggA8OEf55GZW2S2c1kDQ2aJilUC9wqKq2lE5tG9sQ9cHeRIzsrHket3LT0cIiKiamHRwGLNmjWYOnUq3nnnHRw/fhzdunVD3759kZCQUOr+cXFx6NevH7p164bjx4/j7bffxpQpU7Bu3TrtPuvXr0dSUpL258yZM5DJZHjyyScrfV4qnaYiVJi3M+zlFo9RjdYhzBMB7gqUtbRWgurpjj2uW3008nVBWk4hPt5ywaznsjRLzxJVF4WdDNHN/QEAf5xiOhQREdUOFv02OG/ePIwdOxYvvfQSwsPDMX/+fAQHB2Px4sWl7r9kyRLUq1cP8+fPR3h4OF566SWMGTMGn3/+uXYfT09P+Pv7a3+2bdsGJycnncDC2PNS6Wy9MZ5MKsHMgc0AQC+40Px/5sBmZu+ObS+X4sMhEQCAX2ITcPR6ulnPZ0nWMEtUXQa0UqdDxZxOQrFSZeHREBERmZ/FAovCwkIcPXoU0dHROtujo6Oxf//+Uu9z4MABvf179+6NI0eOoKio9BSSZcuW4emnn4azs3Olz0ulu1SyvqKRDVaE0tB0x/Z31/0i6++uwOLn2qJPREC1jKNjfS88GVkXAPDOhjMoqqFfRK1llqg6dG3oDQ8nO6TeK8TBazU3WCQiItKwWLnZ1NRUKJVK+Pn56Wz38/NDcnJyqfdJTk4udf/i4mKkpqYiIED3S2BsbCzOnDmDZcuWVem8AFBQUICCggLt/7OysgAARUVFZQY1Nd2lZPVzUN/L0aafg8eaeKNHo244cv0uUrIL4OvqgHYhdSCTSqr1cc3o1RD/nL+NC8nZWLrnCsZ1Dau2c1end/o2wX9Wn9TbLnngdpWyGCpl9Y7LHHo388OaIzfx+4mb6BjqbunhmJ1SJUr9PSIiIttlzHchi/exeLh5lBCi3IZSpe1f2nZAPVsRERGBDh06VPm8c+fOxaxZs/S279y5E05OVW+YZmtUAriQJAMgQfLFY4ipIctTZADSAPx93jLn7xsgwc9XZZi/7RIc75yHp4NlxmFu/YIl+POGbrdxd3uBYaEqKK8fRcx1Cw3MxHxyJQBk+OPETXSUX4cNLkUy2Mk0CdbHS5FReP9z1KPkNW3lxcpYRES2Kjc31+B9LRZYeHt7QyaT6c0SpKSk6M0maPj7+5e6v1wuh5eXl8723NxcrF69GrNnz67yeQHgrbfewvTp07X/z8rKQnBwMHr27Kl37trg5t08FB78F3YyCZ4f0gdyGy0Lam36CoHLy4/gcPxd7Mnxx7dD2tTIzs37N50DbtxE14ZeGNYmsMZe3VaqBNZ8tht37hXCtVF79GziY+khmcXfZ29jxYGTemWEMwslWHFJhq+fboXezcv+fCUiIuuVlpZm8L4WCyzs7e0RGRmJbdu2YejQodrt27Ztw+DBg0u9T1RUFDZv3qyzbevWrWjXrh3s7HQbmK1duxYFBQV47rnnqnxeAHBwcICDg/7lYzs7O71z1wbX0tQ54w18XOCoqKGX1S1k7rAW6PvVv9h5MRU7LqWjT4S/pYdkUvlFSvx1Rh3YT+rREJ0belt4ROZjB6B/y0Cs3B+PLWdTEB0RaOkhmZxSJfDRXxdL7U0ioE5x++ivi+jbMqjGBY5ERLWBMd9zLXqZefr06fj++++xfPlynD9/HtOmTUNCQgImTJgAQD1LMGrUKO3+EyZMwPXr1zF9+nScP38ey5cvx7JlyzBjxgy9Yy9btgxDhgwpdTahovNSxe4v3LbNilDWrKGvK15+pD4AYNbmszbf0+FhOy+kICu/GAHuCnSqX/Nn+waWVIfaeu428otqwMKRh1TUm0RA3fMmNo4L2ImIajqLrrEYMWIE0tLSMHv2bCQlJSEiIgIxMTEICQkBACQlJen0lggLC0NMTAymTZuGhQsXIjAwEAsWLMDw4cN1jnvp0iXs3bsXW7durdR5qWKXNaVmfW23IpQ1+8+jjbD5ZBIS0nPx5bZLeHdAM0sPyWTWHVN3GB/cOgjSWnAFu01wHQS6K5CYmY9dF1OqrdJYdaktvUmIiKhiEqFZ/UxGycrKgru7O1JTU2vlGosBX/+LM7eysOS5yBqXqmMtdl1MwQsrDkMqAX5/pSsigmy/qlB6TiE6fPQPilUCW6c9YrM9UIw1J+Y8vttzDf1bBGDhs20tPRyTOnA1DSOXHqxwv1/GdUJUg9r3WUlEZOvS0tLg7e2NzMxMuLm5lbsvV9xaIaVK4MDVNGw6cQsHrqZBqbKu2E+lEriSok6FauJfO74YWkKPJr7o3zIAKgG8s+G01b0PKmPzyUQUqwQigtxqTVABAANbqtdWbL9wGzk1LLWtNvUmISKi8jGwsDJbziSh6yc7MHLpQby6+gRGLj2Irp/swJYzSZYemtaNu7nIL1LBQS5FPc/aV2q3Os0c0AyuDnKcvJmJnw/Zfg3W9cfVaVDD2tS18EiqV0SQG0K8nJBfpMI/529bejgm9WAH+4dVZwd7IiKyPAYWVmTLmSRMXHVMbyFkcmY+Jq46ZjXBxcVk9fqKBj4u/LJgZr5uCrzepwkA4NMtF5GSZbt56lfv3MPJGxmQSSUY1LrmVUcqj0Qi0c5abD5pHb/HpqTpYO/uqFs5pLo72BMRkWUxsLASSpXArM3nyizZCACzNp+zinSYyyVpUI39uHC7OjzbMQQt67oju6AYH/xpoc59JrChZNH2I4284e1S+0oUD2ylDiz2XLqDzDzb7VRflj4RAXihcygAoFOYJ34Z1wl733yUQQURUS3CwMJK2FLJxkslFaFYarZ6yKQSzBnaAlKJeo3Cnkt3LD0ko6lUAhs0aVBta1calEYTf1c09nNBoVKFrWeTK76DDUou+QyLauCNqAZenNEkIqplGFhYCVsq2ajpYVGbFt9aWkSQO0aXXA3+38YzNtcPITY+Hbcy8uDqIEevZrW3A/MATTrUqZqXDgUAiZl5AIBAD4WFR0JERJbAwMJK+Loa9ofY0P3MRakSuHqnpCIUA4tq9Vp0E/i7KZCQnouFO69YejhG0aRB9WsRAIWdzMKjsZwBLdVpQfuupCI9p9DCozG9xAx1YBHk4WjhkRARkSUwsLASmpKNZbGWko3X03JQWKyCo50Mdevwy0N1cnGQ4/1B6uo7S3ZfxZWUbAuPyDD5RUrEnFZfoR/aNsjCo7Gs+j4uiAhyg1Il8JeVFGMwFSEEEjPUM6qBDCyIiGolBhZWwlZKNmrWVzT0dakVXZOtTe/m/ni0qS+KlALvbDgDW+hvue3cbWQXFCPIwxEdQtnLQJsOdTLRwiMxrYzcIuSVpOj5l3ORhIiIai4GFlakT0QAOpYyI2FNJRs16ysasSKURUgkEswa1BwKOykOxaVjXUmKkTXTLNoe2iaIwSiA/i3Uv8eH4tJx24bLBz/sVkkalLeLfa1OdyMiqs3kxuycmZmJDRs24N9//0V8fDxyc3Ph4+ODNm3aoHfv3ujcubO5xllraP44D2wZgM2nkuDtbI+9bz5q8ZkKDc2MBRduW06wpxNefawxPtlyAXNizqNHYx9cTrmHlOx8+Lqq0+Ws5f1yJ7sAu0uqWNX2NCiNYE8ntK3ngWMJGYg5nYQXu4RZekgmoalqxzQoIqLay6AZi6SkJIwbNw4BAQGYPXs2cnJy0Lp1azz22GOoW7cudu7ciV69eqFZs2ZYs2aNucdcY93KyMPNu3mQSSV4tyTtKTWnEEkllVasweXb7GFhDV7qFoYmfq5IzylEt093Wm2n9s0nE6FUCbQK9kADH75nNDQ9LWpSOpRm4XagOwMLIqLayqAZi1atWmHUqFGIjY1FREREqfvk5eVh48aNmDdvHm7cuIEZM2aYdKC1weGSHhURgW7wdVUgIsgdJ29k4HB8OurWcbLw6IAipQrXUllq1hrYyaQY2CoAF7dma/PaNTSd2q0hfU7bu6INZyse1K9FAGb/cQ7HEjJw826uVfx+V5U2sOCMBRFRrWXQjMXZs2fx+eeflxlUAICjoyNGjhyJQ4cOYfTo0SYbYG1yqCSw0FR+6hBaBwAQG3fXYmN60PW0HBQpBZztZSwnaWFKlcD/HUoo9TZr6dR++XY2Tt/KhFwq0V6hJzU/N4V2PdWfNaSnxa0M9rAoi1IlcOBqGjaduIUDV9Ms+ntJRGROBs1Y+Pj4GHVQY/cntdi4NABAhzAvAED7UE8s/TdOu93SLiarZysa+rlCIrGOHP7ayphO7VENvKpvYA9YXzJb0aOJLzyd7S0yBms2sFUgDl5Lx+ZTiRjfvYGlh1NlnLEo3ZYzSZi1+ZzO72uAuwIzBzaz+IwiEZGpGVwVav369Rg1ahS2bNmCtm3bYt26deYcV62Teq8AV+/kAADal8xUtC8pzXn1Tg7S7hVYbGwa2oXbvsyVtzRr79SuUgls1KRBcdF2qfpGBEAmleDMrSxcK2k6acvYw0LfljNJmLjqmN5FAE26orWshSIiMhWDA4tFixZh8+bNkMlk+PjjjzFr1ixzjqvW0ayvaOrvCg8n9dXdOs722kXSh+Mtnw51OYUVoayFtXdqP3gtDUmZ+XBTyPFoU1+LjMHaeTrbo0tDbwDAHzaeDlWkVGmDWKZCqSlVArM2n0NpSU/Wkq5IRGRqBgcWUqkUzZs3R69evRAdHY06deqYc1y1zsPrKzQ0sxaxJbdbkqaHRWN/BhaWpunUXlZCmqU7tWvSoPq3DGRPg3IMbKlOhfnjlG1Xh7qdlQ+VAOxlUng7O1h6OFbBmHRFIqKawuDAwtvbGz/++KP2/0qlspy9yVixZQQWmv8fjrfsH5/CYhXiU9WpWiw1a3kPdmovK7iwVKf2vEIl/jqtvgLPNKjyRTf3h71Miku37+Ficralh1NpmjSoAA8FmyCWsPZ0RSIiczA4sPj+++9Rv359AEBhYSG+/PJLsw2qtsnKL8L55CwAQIfQ0gOLs4mZyM4vqvaxacSl5qBYJeDqIIe/G1MdrEGfiAAsfq4t/N31X4+hbYIstjB067lk5BQqEezpiHYhnNksj7ujHR5prC52Ycs9LdjDQp+1pysSEZmDwYGFk5O6zrpSqYS9vT3at29vtkHVNkfj70IIIMzbGb4PfWkPcHdE3TqOUAngWEKGZQYI4GLJwu1Gfi6sCGVF+kQEYO+bj+KXcZ3w1dOtMeERdfC/5WwykstJwzCndcfUaVBD29Tle8UAA1vdT4cSwjbz7TWlZgO4vkJLk65YFkunKxIRmYPBgYXGiy++aI5x1Gra9RWhpf+B0aZDWTAX9/JtLty2VjKpBFENvDC4dRDe6NMUbet5ILdQiY9izlf7WFKy8rH38h0AbIpnqMfD/aCwkyI+LRdnbmVZejiVopmxYH+b+2RSCd7uF17m7QKWS1ckIjIXowMLW72iZs3u968oI7CwggXcl7QzFgwsrJlUKsHswRGQSNSpNfuvplbr+TedSIRKAG3reSDU27laz22rnB3keKypHwBgs40u4tYsUmapWV0ZuYUAgNJih3YhddjHgohqHKMDC6Y2mFZeoRKnbmYCKCewKNl+4mYGCoots2j+cklFqCYMLKxeRJA7nu1YDwDw/u9nUaRUVdu5NdWghratW23nrAk06VB/nkqCygbLj7I5nr7cwmIs2HEFgHpmQpOuOHdYBADg+I0M3EjPteQQiYhMzujAgkzreMJdFKsEAt0VqFun9D/KYd7O8HaxR2GxShuEVKf8IiXi01gRypbMiG6COk52uHT7Hn7YH18t5zyflIXzSVmwk0m0ZVTJMD2a+MLFQY5bGXk4fsPyPWuMdUubCsU1Fhor98fjTnYBgj0dMbJDiDZdcWSHEHRr5A2lSmDZ3jhLD5OIyKSYCmVhD/avKGs2SCKRWLSfxbU7OVAJdQUbH1fWqLcFHk72eLNPUwDA/H8uIyXL/Au5N5TMVjza1Ffb5JEMo7CToVezknSok7bVLC8rvwjZ+cUA1MUmCMjMLcKSXVcBANN7NYa9XPdP7fhHGgAAVh9OQHpOYbWPj4jIXIwOLJ5//nlzjKPWut+/wqvc/TTpUJYILC5pF26zIpQteapdMFoFe+BeQTHm/nXBrOdSqgQ2lgQWw5gGVSnadKjTSTbVjTmppIeFu6MdnB3kFh6NdViy5yqy8ovRxM8Vg1rpFzHo0tALzQPdkF+kwk8HrltghERE5mF0YBEdHW2OcdRKhcUqHEtQpz1UVHJQM2Nx9Prdav/SwYXbtkkqlWD2oOaQSNSzCeYMSvddSUVKdgE8nOzQs4mv2c5Tk3Vt6AN3RzvcyS7AoZKCDraA6yt0pWTlY8U+dYrTjN5NSq36JJFIML67etbihwPxyC9iw1mqPkqVwIGradh04hYOXE2zqQsZZP0qdXnp1q1b2LdvH1JSUqBS6S4MnTJlikkGVhucvpWBgmIVvJzt0cCn/Ao64QFucHWQI7ugGOeTshAR5F5NowQulSzcbuzL9RW2plWwB55uH4xfYm/gvU1n8Md/ukIuM/3SKk0a1ICWAXppH2QYe7kUfSP8sfrwDWw+mYTODbwtPSSDJGZyfcWDvt5xBflFKrSt54HHw8sOsvtF+OPTOo64eTcPvx69iec7hVTjKKm22nImCbM2n9NWcgPU/VRmDmzGKmVkEkYHFitWrMCECRNgb28PLy8vndQYiUTCwMIImvUV7UPLXl+hIZNKEBlaB7su3kFsXHq1BhaXU0pSofw5Y2GLXu/dFH+dScaF5GysOngdL3QJM+nxcwqKseVMMgCmQVXVgJaBWH34Bn4/eQvtQ+sgwN0RHcI8rbrXAWcs7rueloNfYhMAAG/0aVru57pcJsVLXcPw/uZzWLrnGp7pUM+qX2eyfVvOJGHiqmN4eH4iOTMfE1cdw+Ln2jK4oCoz+tLie++9h/feew+ZmZmIj49HXFyc9ufatWvmGGONFfvAwm1DaNKhDsdX3zqLvEIlEkpKIrI5nm3ydLbHjOgmAIAvtl3CnewCkx5/y5lk5BUpEebtjDbBHiY9dm2TmVcIqQTIKVBi+tqTGLn0ILp+sgNbzljvgu7EDPaw0Phy2yUUqwQeaeyDTvXLXzcHAE+1D4aHkx0S0nO1wTmROShVArM2n9MLKgBot83afI5pUVRlRgcWubm5ePrppyGVMt2hKpQqgSPxhq2v0HhwAXd1Vee6eucehFB/OfV2YUUoWzWyQz1EBLkhO78Yn2wx7UJuTRrU0DZBXNxfBVvOJOGVn4/j4b/rmquJ1hpc3OKMBQDgQnIWNp1UNzh8o3cTg+7jZC/HqKhQAMB3e66y6iKZTWxcuk7608ME1I0uLdmIl2oGo6ODsWPH4tdffzXHWGqV80lZuFdQDFcHOcID3Ay6T8u67rCXS5GWU4hrqTlmHqHaxeSShdtcX2HTZCUduQHgt6M3cfS6aXolJGXmYV9Jd++hbfSr35BhbPlqojYVyr12r7H4/O+LEALo3zLAqFTV0VEhcJBLcfJmJg5e45c6Mo+UbMNKjhu6H1FZjF5jMXfuXAwYMABbtmxBixYtYGdnp3P7vHnzTDa4mkyzvqJdaB2D82od5DK0DvZAbFw6Dselo4GP+b/sX9Ksr2AalM1rW68OnmpXF2uP3MR7m87g91e6Vjmne9OJRAgBtA+tg2BPJxONtPYx5mpiVIOKU2yqi1IlcDuLqVBHr6fjn/MpkEkleK1XY6Pu6+XigCfb1cWqgwn4ds9Vq3p9qebwdTUs8D9xIwN9IvzhIJeZeURUUxk9YzFnzhz8/fffuH37Nk6fPo3jx49rf06cOGGGIdZMsSXlJCvqX/GwDtXcKO+ypiIUO27XCG/0aQo3hRxnE7Pwc8ki08oSQmD9sZsAuGi7qmz1amLqvQIUKQVkUgl8a2nzTCEEPtlyEQDwZGRd1K/EBZ+XutaHVALsungHF5KzTD1EInQI80SAuwIVXUpasS8ePT7bhVUHr6OwWFXB3kT6jA4s5s2bh+XLl+P8+fPYtWsXdu7cqf3ZsWOH0QNYtGgRwsLCoFAoEBkZiX///bfc/Xfv3o3IyEgoFArUr18fS5Ys0dsnIyMDkydPRkBAABQKBcLDwxETE6O9/f3334dEItH58ff3N3rslSWEMHrhtoZ2nUU1LeC+3xyPMxY1gbeLA14rWcj9+d8Xq9T192xiFi7dvgd7uRT9WrCSSFUYejXR0P2qi2Z9hb+bwixljG3B7kvqSn32cilefbxRpY4R6u2MviXVeL7bwyIoZHoyqQQzBzYDAL3gQlLy83T7YPi5OSApMx//23gGPT/fhV9iE1CkZIBBhjP6L4GDgwO6dOlikpOvWbMGU6dOxTvvvIPjx4+jW7du6Nu3LxISSr+SGhcXh379+qFbt244fvw43n77bUyZMgXr1q3T7lNYWIhevXohPj4ev/32Gy5evIilS5ciKEg3/7t58+ZISkrS/pw+fdokj8kQV1Lu4W5uERR2UrQwsmxs25A6kEqAm3fztLnN5pJTUIybd9XnYGBRczzbsR7CA9yQmVeET6uwkFuzaLtXuB/cHe0q2JvKU9HVRAnUteaNvRBhbvdLzVpXwFNdVCqBz/5Wz1aMjgpBgHvl08FefqQ+AOD3E4lm/2yn2qlPRAAWP9cW/g+th/J3V2Dxc23x8fCW2P16T7w/sBl8XB1wKyMPb60/jUe/2IW1h28wwCCDGB1YvPrqq/j6669NcvJ58+Zh7NixeOmllxAeHo758+cjODgYixcvLnX/JUuWoF69epg/fz7Cw8Px0ksvYcyYMfj888+1+yxfvhzp6enYuHEjunTpgpCQEHTt2hWtWrXSOZZcLoe/v7/2x8fHxySPyRCa9RVt69UxupmYi4MczQPVwYi5y85eSVGnQXm7OKCOs71Zz0XVRy6T4oPBzQEAa47cwIkbGUYfo1ipwqYT6go4XLRddRVdTQSAmQObWV2fA80X4Kp8obZlMWeScDYxCy4Ockzs0bBKx2oV7IFO9T1RrBJYvjfORCMk0tUnIgB733wUv4zrhK+ebo1fxnXC3jcf1favUNjJ8EKXMPz7Rk+8O6AZvF0ccCM9D2+sO4XH5+3Gb0dvopgBBpXD6MAiNjYWP/zwA+rXr4+BAwdi2LBhOj+GKiwsxNGjRxEdHa2zPTo6Gvv37y/1PgcOHNDbv3fv3jhy5AiKiooAAL///juioqIwefJk+Pn5ISIiAnPmzIFSqdS53+XLlxEYGIiwsDA8/fTT1dqDo7JpUBoPlp01p4vaNCiur6hp2oV6YljbIAgBvLfpDFRGVhv690oqUu8VwNPZHt2bVF9QXpOVdTXRx9XBahtX1eYeFkVKFb7YegkAMK5bfXia4OLL+O4NAAC/xCYgM6+oyscjKo1MKkFUAy8Mbh2EqAZepV6wUNjJMLarOsB4p184vJztcT0tFzN+PYleX+7BhuM3rbJKHVme0VWhPDw8jAogypKamgqlUgk/Pz+d7X5+fkhOLr1RUHJycqn7FxcXIzU1FQEBAbh27Rp27NiBZ599FjExMbh8+TImT56M4uJivPfeewCAjh074scff0Tjxo1x+/ZtfPjhh+jcuTPOnj0LL6/SF1MXFBSgoOB+Y7GsLPUCu6KiIm1QYwghBA6VLNyODHY36r4abYPdsAzAoWtplbq/oS4mZQIAGvg4m/U8ZBkzHm+IrWdv49TNTPx8KB4j2hm+AHvdkRsAgP4t/AGVEkUqZQX3IEM81sQbPRp1w5HrdzHjt9NIzirAR4OboUcTb6v8Hbx1V90809/VzirHZ05rjtxEXGoOPJ3tMKpTXZM8/i5hHmjs64JLKffw0/44jH8kzAQjJao8uQR4ISoYT0UGYNWhG/h+bzziUnMwbc1JfL39Cl7pWR/9Ivy1wYlSJXDk+l2kZBfA19UB7UIMr3xJ1suYzzejA4sVK1YYe5dyPdxQSwhRbpOt0vZ/cLtKpYKvry++++47yGQyREZGIjExEZ999pk2sOjbt6/2/i1atEBUVBQaNGiAH374AdOnTy/1vHPnzsWsWbP0tu/cuRNOToaX2UzNB25nySGTCCSfPYiYSqS43ysCADmu3MnBr5ti4Gym9Pb956UApChIiUNMDBcU1kS9AiTYEC/D3D/PQnrrlEHvpfxi4O8zMgAS+ORc43vDTHxkUiRDii17jyD3qnVeGTyfoH4f3LpyFjFpZyw9nGpTqAQ+O6F+7N198rFn+1aTHbuDmwSXUmT4btcl+Gedh13tXBNvEioBXM2SIKsIcLMDGrgJ8Dtu5dUF8N8I4N9kCXbckuJaag6m/3oan/5xCn3qqiCRABvipcgovP8ke9gLDAtVoZWXdX6GkWFyc3MN3tfowMJUvL29IZPJ9GYnUlJS9GYlNPz9/UvdXy6Xa2caAgICYGdnB5nsfg3m8PBwJCcno7CwEPb2+tPVzs7OaNGiBS5fvlzmeN966y2doCMrKwvBwcHo2bNnmbMcpVl37BZw/CxaBdfBkIEdDL7fw5Zf34erd3JQp3E7PB7uW+njlOfjc3sA5GPYo50QGVLHLOcgy4pWqnB20UFcSrmH05JQzO7XrML7/HbsFooOn0V9b2dMeLIzu22bySnpRZzedx3O/mHo16+ppYdTqvdP7gRQhEGPdUVT/9pT4GHZvnhkFl5CoLsCH4zqAgc709X876VU4Z95/yI5qwAF/i0x2IiZRLrv77O3MTfmApKz7mca+Ls54H/9mqJ389K/Y5BhhgHIzi/GjwcTsHxfPJLzirHycum/A5mFEqy4JMPXT7fi827D0tLSDN7XYoGFvb09IiMjsW3bNgwdOlS7fdu2bRg8eHCp94mKisLmzZt1tm3duhXt2rXTNurr0qULfv75Z6hUKkil6ks9ly5dQkBAQKlBBaBOczp//jy6detW5ngdHBzg4KBfp93Ozk6vSWB5jiao04s61vcy6n4P6xDmhat3cnA0IRN9W5p+8Wx2fpG2YVd4UJ0qjZWsl50d8MGQCIz47iBWH7mJZzuFVtg1eNPJJADA8Mi6Zf5OUdU18HUDANy4m2eVv395hUrczVVPj9fzdrXKMZpDVn4Rvt2jXlw9tVdjuDiZtiKWnR3wUrf6+PDP81i2/zpGdgyFlJfZjbLlTBL+s/qkXif721kF+M/qk1a7ZsmWeNrZYWqvJnixa30s23sNX2+/ovd8A+rmnhIAH/11EX1bBlU5LUqpUpfrT8nOh6+rulIeU63Mz5jPd4tOsk6fPh3ff/+9ti/GtGnTkJCQgAkTJgBQzxKMGjVKu/+ECRNw/fp1TJ8+HefPn8fy5cuxbNkyzJgxQ7vPxIkTkZaWhldffRWXLl3Cn3/+iTlz5mDy5MnafWbMmIHdu3cjLi4Ohw4dwhNPPIGsrCyMHj3a7I9Z03+iqmUjO5bc31yVoS6XVITyc3NgKdEarmN9LwxuHQghgHcrWMh9KyMPB6+p33ODWwdW1xBrpVAvdYplfJrhU9DVKTFTXRHK2V4GN4XFrlFVu+/3XMPd3CI08HHGMDNVRHu6Qz24KuS4dicH/5y/bZZz1FRKlcCszefK/JILALM2n+PCYxNxd7RDVH3vUp9vDQEgKTMfT393AB/9eQ4/HojHjgu3cfl2NnILiw0+15YzSej6yQ6MXHoQr64+gZFLD6LrJzuw5UxSlR8HmY5F/xqMGDECaWlpmD17NpKSkhAREYGYmBiEhIQAAJKSknR6WoSFhSEmJgbTpk3DwoULERgYiAULFmD48OHafYKDg7F161ZMmzYNLVu2RFBQEF599VW8+eab2n1u3ryJkSNHIjU1FT4+PujUqRMOHjyoPa+5JGfm43paLqQSVDm1qH1JYHEmMQs5BcVwdjDtS3kpmY3xapO3+4Xjn3O3cTwhA78du4mn2gWXut/Gkt4Vnep7om4dw9cWkfFCvJ0BADfSc1GsVFldA7r7PSwca006XOq9AnxfUgp2RnQTs70mLg5yPN8pBIt2XcW3e64hunn1NXC1dbFx6drZ9tJovuTGxqUjqoHhacxUtpTssp/vBx2Ov4vD8Xf1tnu72KNuHSfUreOIYE8nBD/w70APBRzkMmw5k4SJq47pBTDJmfmYuOoYZ6GsiMUvM02aNAmTJk0q9baVK1fqbevevTuOHTtW7jGjoqJw8ODBMm9fvXq1UWM0Fc1sRbNAN7gpqjYLEOThiCAPR9zKyMOxhLvo1si0JT8v3VbPWDTyZWBRG/i5KfDq440wJ+YCPvnrAno384e7k+57VAiB9cduAgCGtWHet7kFuClgL5eisFiFWxl5CPFytvSQdCTVwlKzC3deQW6hEi3ruqNPhHm/7L/QORTf/xuHo9fv4kh8OtqFWldzRGtl6JdcQ/ejivm6GpYOODoqBDKpFDfv5uLG3TzcTM9FdkExUu8VIvVeYak9lSQSwNfFAem5heWmWs3afA69mvkzLcoKGB1YLFiwoNTtEokECoUCDRs2xCOPPKKzeJrUYkvKzHYINc1Vkg5hnthw/BYOx6WbPLC4nKKesWjizx4WtcWLXcKw9shNXEm5h3nbLmLW4Aid20/fysTVOzlwkEvRtwWvoJqbVCpBiKcTLqfcQ3xartUFFrcemLGoDW7ezcX/HVTPoL/Ru6nZZ2l83RQY1jYIqw/fwJLd1/A9AwuDGPol19D9qGIdwjwR4K5AcmZ+qV/+JVB3935vYHOdL/5CCGTlFePG3Vx1sJGepw06bqTn4ubdPOQVKXE7u6CUo97HWSjrYnRg8eWXX+LOnTvIzc1FnTp1IIRARkYGnJyc4OLigpSUFNSvXx87d+5EcHDp6RS1VVUb4z2sfag6sIg1wzqLSyXN8RoxFarWsJNJMXtQczzz/SH8dPA6RrSvh2aBbtrb1x9Tp0FFN/eHaxVn3Mgwod7OuJxyD9fTcgBYVyNCTSpUkEft+II2/5/LKFSq0LmBF7o28q6Wc457pD7WHLmBf87fxpWUe2joyws9FdF8yS0vHcrPzcFkf4dJ3XBv5sBmmLjqGCSATnChCSNmDmymN5sgkUjg7mQHdyf3UouGCCGQllOInw8lYN62SxWOg7NQ1sHoBNE5c+agffv2uHz5MtLS0pCeno5Lly6hY8eO+Oqrr5CQkAB/f39MmzbNHOO1Wek5hdr0ovahpind2iFMfZzjCRkoKDZdg7LM3CLcLinR14h/yGqVzg290b9lAFQCmPn7GW2fmCKlCptPJgKA2Raskj7NAu641BwLj0SfZvF2bZixuHw7W5sG+HrvJtV23gY+LugVri7RuXQP+8UYQvMltzxCAHcquApOxukTEYDFz7WFv7vuhQZ/d0Wl1z9IJBJ4uzigvYGzdZyFsg5Gz1j873//w7p169CgQQPttoYNG+Lzzz/H8OHDce3aNXz66ac6C6rpfvWmRr4u8HLRL1tbGQ18XODpbI/0nEKcuZWJyBDTXIG5VJIGFeiu4JXpWuh//cOx43wKDsffxbqjNxFUxwk7L9xGWk4hvJzt0K2artaSesYCAK5bYWWoxJI1FgHuNT+w+GLrJagE0Lu5H9rUq96ePuO718fWc7ex4fgtTI9uDD83fnmqSJ+IADQPdMPZxCyd7b6uDihWCqRkF2DEdwfw87hOCKoFgXF16RMRgF7N/E1eDtbQVCvOQlkHo2cskpKSUFysXx6suLhY27wuMDAQ2dnZVR9dDWLqNChAHc1rZj9i4/QrLVQW06BqtwB3R/znsYYAgDfWncLIpQfx3b/qSjh5RSqWv6xGoSXrKuKtbMZCCPFAKlTN/mJ28kYGtpxNhlSirgRV3SJDPNEupA4KlSqs2Bdf7ee3RXmFSlwpKZn+2RMt8dXTrfHLuE448NZj+P0/XRDs6YjrabkY8e0B3Ei3vqDdlsmkEkQ18MLg1kGIauBlksXUD85CPXy08lKtyDKMDix69uyJ8ePH4/jx49ptx48fx8SJE/Hoo48CAE6fPo2wsDDTjbIGMEdgAUA7RahZGG4Kl0tSthr7MQ2qtgouKSX7cKn33EIlJq46xrrh1UQzY3HjrrrkrLVIzylEQbEKEgng526aGVhr9dnfFwEAQ9vUtdjFlvHd1RkC/3foOrLziywyBluy/2oqCopVCPJwxBORdXW+5Nat44Q1L0ch1MsJN+/m4envDpasYSJrZo5UKzIPowOLZcuWwdPTE5GRkdpu1O3atYOnpyeWLVsGAHBxccEXX3xh8sHaquz8IpxNVHfcNnVg0TFMXQHhyPW7Jmv4o5mxYA+L2kmpEpgTc77cfdhgqnpoSs4WKYU29cgaaMbi4+IAB3nNrQC470oq9l5JhZ1MgqmPN7LYOB5r6osGPs7Izi/G6tgbFhuHrdhxIQUA8GhT31KrdwV6OGL1y1Go7+2MWxnq4MIa1zGRrj4RAdj75qP4ZVwn7SzU3jcfZVBhZYwOLPz9/bFt2zacO3cOv/76K9auXYtz585h69at8PNTLzLr2bMnoqOjTT5YW3X0+l2oBFDP08nk+cjhAa5wtpchO78YF5NNk352STtjwcCiNjKmwRSZl6bkLADEW9FV1dpQalYIgU9LZiue7RiCYE/LNYSUSiV4+ZH6AIBle+NQWGw9s1fWRgiBnQ8EFmXxd1dg9cud0NDXBUmZ+Rjx7QFcvXOvuoZJlWSOVCsyrUq3DW3atCkGDRqEwYMHo0mT6s87tSXmSoMCALlMikgTpkOl5xQi9Z66WgZLG9ZObDBlXTT9K6wpsKgN6yv+PnsbJ29kwMlehsk9G1p6OBjSJgg+rg5IzsrH7yUV2kjfheRsJGbmQ2EnrbCnga+bAr+M64Qmfq7qBd3fHsTl21wfSlQVRgcWQgj8+uuvmDRpEp544gkMGzZM54f0mTOwAIAOJQu4D8dXfQG3Jg2qbh1HODtYvDE7WQAbTFkXTcnZ+FTrWWSqCSwC3Gvme0CpEvh8q3q2YmzXMPi4Wn4diYNchjFd1GsXv9tzVVsKmnRp0qC6NPCGwq7iND0fVwf8PK4jmvq7IvVeAZ7+7qDJZv+JaiOjA4tXX30Vzz//POLi4uDi4gJ3d3edH9KVX6TEyZsZAICOZgosNAu4D8WlV/mPzWWur6j1NKX9yppglkD9hZKl/aqHZgG3Nc1YaFLlamoq1Ppj6g70Hk52GFeSgmQNnulYDy4Ocly6fQ+7Lt6x9HCskiYNqmc5aVAP83JxwC/jOqF5oBvScgrx9HcHcO6hUrVEZBijL0mvWrUK69evR79+/cwxnhrneEIGipQCfm4OqGemHN1WwR6wl0mReq8A8Wm5CCv5IlIZmvUVjVgRqtaqbBdVMo9QK0yFqolrLJQqgdi4dCRm5OKTvy4AACZ2bwA3K+rl4+5oh5EdgrH03zgs2X3VqC/PtcHdnEIcS1DP3Bv73NRxtsfPL3XC88sP4dTNTDzz/UGsGtux1I7QRFQ2o2cs3N3dUb++9VzBsXb306C8Sq1OYQoKOxlaBas//A5XcUGtJhWqCWcsajWW9rMeod7qCxI30nOtphJXTVtjseVMErp+sgMjlx7Ea7+eQmpOIaQS60z1GtM1DHKpBIfi0nHiRoalh2NV9ly+A5UAmvq7Vuq96e5kh5/GdkTrYA9k5BbhmaUHcZLPMZFRjA4s3n//fcyaNQt5eXnmGE+NExuvXlBt7rSRB9OhquJyCitCkRpL+1mHAHdH2Ms0JWct/7lbUKxESra6wEOgh/V98TbWljNJmLjqmF4lNJUAXl19wup6tgS4O2Jw6yAA6rUWdN+OSqRBPczd0Q4/je2AyJA6yMovxnPfH9LOghBRxYwOLJ588kncvXsXvr6+aNGiBdq2bavzQ/cVFqtw9Lr6A8lc6ys0NIHL4fjKBxap9wqQnlMIiQRo4MNUKGJpP2sgk0pQz8t6Ss7ezlQHFQ5yKTyd7S08mqpRqgRmbT6H8uaBrLFni6b07F9nkq2uK7ulFCtV2nUn5ZWZNYSrwg4/jOmADqGeyC4oxqhlsThShb+tRLWJ0YHFCy+8gKNHj+K5557D8OHDMXjwYJ0fuu9MYibyi1So42SHhmb+oh4ZUgdSCZCQnovkcnoQlOdSSSWMep5OcLSvuU2viGzN/cpQlv8S+eD6CnOld1YXW+3Z0sTfFT2b+EAIYOm/1yw9HKtw/EYGMvOK4O5ohzbBHlU+nouDHCvHtEdUfS/cKyjGqOWxOHSt6iXdiWo6oxdv//nnn/j777/RtWtXc4ynRtH8MWof6gmpma/0uirsEB7ghrOJWYiNT8egVoFGH0OzvqKRL9OgiKzJ/QXcli85m5SpCSxsPw3Klnu2jO/eADsv3sGvR29iWq/G8HaxfElcS9KkQfVo4gO5rNItunQ42cux/IX2GPfjEey9kooXVhzGstHt0Lmht0mOT1QTGf3bFxwcDDc3N3OMpcYxd/+Kh2nToSp5de2Sdn0F06CIrEmIpuSsFcxYaNZ5BLrb/sJtW+7Z0jHME62CPVBYrMLKfXE4cDUNm07cwoGraVaXulUdDOm2XRmO9jJ8P7odujf2QV6REi+uPIx/L9+BUiVq/XNOVBqjZyy++OILvPHGG1iyZAlCQ0PNMKSaQakS2vUOHcPK7/5pKh1CPbFiX3yl11loelg08eeMBZE1CbWiNRa3MmpODwtNz5bkzPxS11lIoK6EZo09WyQSCSY8Uh8T/+8YFu68im923l/IHeCuwMyBzWpNoYVbGXm4kJwNqQTo3tjH5MdX2Mnw7fORmPR/x7DjQgpeXHEYrgo57uYWafepbc85UVmMnrF47rnnsHPnTjRo0ACurq7w9PTU+SG1C8lZyM4vhouDHOEB1fNFvV1JZagLydnIyC006r5CiPs9LJgKRWRVNKlQN9LzLH5ltCaVmtX0bAGg1xDSFnq2aPqhPvyOSM7Mx8RVx6yuopW5aGYr2tarAw8n8xQUUNjJsPi5tmhZ1x3FKqETVAC17zknKovRMxbz5883wzBqHk0aVGRIHZPle1bEx9UB9X2cce1ODo7E38XjzfwMvu+d7AJk5hVBKgHq+1S+wR4RmV6gh7rkbKFShcSMPASbqdmmITSBRUANWGMB3O/ZMmvzOZ2F3P5WfgVaqRL44M9zpd4moA6MZm0+h17N/K02MDKVynTbrgy5VIqUrIJSb6ttzzlRWYwOLEaPHm2OcdQ41b2+QqNDqCeu3cnB4fh0owKLiyVpUKFezlDYsSIUkTWRSSUI9nTE1Ts5uJ6Wa7HAQoj7vTRqQiqURp+IAPRq5o/YuHSkZOfD11Wd/mTNXw6NqWgV1aB60nEtIb9IiX1XUwGYfn3Fw2Lj0pGcxeecqDwGXUrPyTEur9fY/WsaIYQ2sDB3/4qHVbZRnjYNigu3iaySJh0qzoLrLLLyi5FTqARQMxZvP8jWerbYckUrUzpwNQ35RSoEuCvQ1MzrA/mcE1XMoMCiYcOGmDNnDhITE8vcRwiBbdu2oW/fvliwYIHJBmiLrt7JQVpOIRzkUrSo616t59bMkJy5lYncwmKD76dZuM2O20TWKbSkMtR1C1aG0sxWeDrbs9eNhdlyRStT2vFANShz91Xhc05UMYNSoXbt2oX//e9/mDVrFlq3bo127dohMDAQCoUCd+/exblz53DgwAHY2dnhrbfewssvv2zucVs1zWxFm3oecJBX7x/funUcEeCuQFJmPk4kZBhcb/sSAwsiq2YNlaHup0Hxi5Ol2XJFK1MRQugEFubG55yoYgbNWDRp0gS//vorrl69iqeffhqJiYn47bffsHTpUuzatQtBQUFYunQp4uPjMXHiRMhktftKVmycujtnh2oqM/sgiUSi/VAzNB1KCIHLtzU9LBhYEFkjzYyFJZvk1aQeFrauvIpWgDrf35orWpnC5ZR7uJWRBwe5FJ0bmL9pna1XESOqDkYt3q5bty6mTZuGadOmmWs8Nk8Iof1CX93rKzTah3pi04lEg/tZJGflI7ugGHKpBGHerAhFZI00aywS0nKhVAmLfHmpST0saoKyKloBgIuDHK2D61hoZNVDM1sR1cCr2lLzbLWKGFF1MboqFJXv5t08JGXmQy6VoE09D4uMQTNjcSzhLgqLVbCXlz8xdTG5pCKUt3OF+xKRZQS4K2Ank6BQqUJSZh7q1qn+ylBJmUyFsjYPV7TycLLD3JgLuJCcjf/8cgy/jOtUbSXPq1t1pkE9yBariBFVFwYWJqZZX9Girjuc7C3z9Db0cUEdJzvczS3CmcRMtK1X/lWr+2lQrAhFZK3kMimCPZ1w7U4O4lNzLRJY1MRSszWBpqKVRj1PZwz8ei8Ox9/FZ1sv4q2+4RYcnXlk5hbh6PW7AICeTao3sAD0n3MiUquZlzEsyFL9Kx4klUq0XbgPG7DOQrNwmx23iaybJh3KUgu4E5kKZRPCvJ3x2RMtAQDf7r6Gf87dtvCITG/35TtQqgQa+7lYtGEkEeliYGFisfGWXV+h0aEksIg1JLBIUc9YNDFzDXAiqhpNYHHdAoFFsVKlbQ4WxMDC6vVtEYAXu4QCAF779SRupFtu0b85VFe3bSIyDgMLE0rJykdcag4kEiAyxMKBRUlgc+T6XahUpRXGUxNC4Iq21CxToYisWai3+spsXGr1f0lMyS6AUiVgJ5PAx8Wh2s9PxnurbzhaB3sgM68Ik38+hoJipaWHZBJKlcCuiyXrKyyQBkVEZTNoEcCpU6cMPmDLli0rPRhbp5mtCPd3g7ujnUXH0jzQDU72MmTmFeFSSjaa+ruVut+tjDzkFCphJ5MgxIsVoYismSVnLDTrK/zcFJBykapNsJdLsfDZtui/4F+cupmJOX+ex6zBEZYeVpWduJGBu7lFcFPIERlSsytfEdkagwKL1q1bQyKRQIjSr3xrbpNIJFAqa8YVkcqwhvUVGnKZFG3r1cHeK6mIjUsvM7DQrK+o7+0CuxpaOYSoptAGFum5UKlEtX7BT8zk+gpbFOThiHlPtcKYlUfww4HraBfqiYGtAi09rCrRpEE90tinxla8IrJVBgUWcXFx5h5HjRBr4f4VD+sQ5qkNLEZFhZa6z6WSilCNmAZFZPUCPUpKzharkJSVX61rHTQzFlxfYXsebeqHST0aYNGuq/jvulNoHuiG+j62+5m/3UJlZomoYgaF+iEhIQb/GGvRokUICwuDQqFAZGQk/v3333L33717NyIjI6FQKFC/fn0sWbJEb5+MjAxMnjwZAQEBUCgUCA8PR0xMTJXOW5GM3EJcKOkH0d5KAov2mspQ8ellzjZpZiyasOM2kdWTy6QILikzG59avelQ90vNsoeFLZreqzE6hnkip1CJSf93DHmFtpldkJSZh/NJWZBIgO6NfSw9HCJ6iEEzFr///rvBBxw0aJDB+65ZswZTp07FokWL0KVLF3z77bfo27cvzp07h3r16untHxcXh379+mHcuHFYtWoV9u3bh0mTJsHHxwfDhw8HABQWFqJXr17w9fXFb7/9hrp16+LGjRtwdXWt9HkNcTheXU+7gY8zvK1kYWObeh6wk0lwO6sACem5pa6huKydsWBgQWQLQryccC01B/FpOejS0LvazsseFrZNLpPi65Ft0G/BXlxIzsZ7m87gsydbWXpYRtt54Q4AoE2wB7ys5G8tEd1nUGAxZMgQgw5m7BqLefPmYezYsXjppZcAAPPnz8fff/+NxYsXY+7cuXr7L1myBPXq1cP8+fMBAOHh4Thy5Ag+//xzbWCxfPlypKenY//+/bCzUy+gfngmxdjzGiI2Lg2Adayv0FDYydCyrgeOXr+L2Lh0vcBCpRK4ksLmeES2JNTbGbh4p9pnLG6xh4XN83VTYMHI1nju+0P49ehNtA/zxFPtgi09LKNYqts2ERnGoMBCpVKZ/MSFhYU4evQo/vvf/+psj46Oxv79+0u9z4EDBxAdHa2zrXfv3li2bBmKiopgZ2eH33//HVFRUZg8eTI2bdoEHx8fPPPMM3jzzTchk8kqdV4AKCgoQEFBgfb/WVlZAICioiIUFRXh0DV1YBEZ7I6ioiLDnwgzi6znjqPX7+LQtTQMaeWvc1tCei7yipSwl0sR6GZvVeMmotIFl6Qixd25V62/s0klMxa+znJ+Vtiw9vXc8eqjDfHl9it4b9MZNPNztpkeRgVFSuy7op6x6NbQk+9DompizO+aQYHFg+Li4hAWFmbs3fSkpqZCqVTCz89PZ7ufnx+Sk5NLvU9ycnKp+xcXFyM1NRUBAQG4du0aduzYgWeffRYxMTG4fPkyJk+ejOLiYrz33nuVOi8AzJ07F7NmzdLbvnPnTsgcnHDmlgyABNlxJxCTeMKwJ6E63JUAkGHXuZuIcbiuc9PpdPVtPvZK/L3lL4sMj4iMk5Kh/r09cz1Fb+2YuRQogYw89Z+LM4f+xRWj/3KQNakngHAPKc5nAGOW7cdrLZVQyCw9qoqdz5Agr0gGd3uBuGN7Ec+qx0TVIjfX8N5JRv95aNiwIR555BGMHTsWTzzxBBSKqi3kk0h0Pxk0ZWuN2f/B7SqVCr6+vvjuu+8gk8kQGRmJxMREfPbZZ3jvvfcqfd633noL06dP1/4/KysLwcHB6NmzJ87fBVSxRxHkocBzQx+p4BFXr655RVg6dydS8yVo3+0x+Ljez0lN2H0NuHgFbRsGoF+/2tt/hMiWNE/PxZLze3G3SIY+faKrpeTslZR7QOx+uCrkGDYouuI7kNXr3KMQgxcdQHJWAfbk1sWXT7Uo92+gNTjy5wUACejTsi76929u6eEQ1RppaWkG72t0YHHy5EksX74cr732Gl555RWMGDECY8eORYcOHYw6jre3N2Qymd4sQUpKit5sgoa/v3+p+8vlcnh5eQEAAgICYGdnB5ns/uWX8PBwJCcno7CwsFLnBQAHBwc4OOgvFLOzs8OxG6kAgI5hXtp1HdbCy84OTf3dcD4pC8dvZqN/y/trKa6WdO9tGuBudeMmotKFertCLpWgoFiFtDxltax5SMkpBqAuNcvPiprBz8MOC5+NxIhvD+DPM8no2MCrzLLk1kAIgV2X1GlQj4X7831IVI2M+X0zurNMREQE5s2bh1u3bmHFihVITk5G165d0bx5c8ybNw937twx6Dj29vaIjIzEtm3bdLZv27YNnTt3LvU+UVFRevtv3boV7dq10z7oLl264MqVKzrrQi5duoSAgADY29tX6rwVOWRFjfFKo+mroVlgrqHpYdGYFaGIbIZcJkWwZ/WWnGVFqJopMqQO/tu3KQDggz/O4eSNDMsOqBxX79zDjfQ82Mul1VoNjYiMU+mWlXK5HEOHDsXatWvxySef4OrVq5gxYwbq1q2LUaNGISkpqcJjTJ8+Hd9//z2WL1+O8+fPY9q0aUhISMCECRMAqNOPRo0apd1/woQJuH79OqZPn47z589j+fLlWLZsGWbMmKHdZ+LEiUhLS8Orr76KS5cu4c8//8ScOXMwefJkg89rjIIiJU6UfBhba2Ch6WcRW1ISFwCUKoGrd1gRisgWhXqVBBZphue9VgV7WNRcY7uGoXdzPxQpBSb/fAyZuda5IFpTDapTfS84O3CRD5G1qvRv55EjR7B8+XKsXr0azs7OmDFjBsaOHYvExES89957GDx4MGJjY8s9xogRI5CWlobZs2cjKSkJERERiImJ0ZaHTUpKQkJCgnb/sLAwxMTEYNq0aVi4cCECAwOxYMECbalZAAgODsbWrVsxbdo0tGzZEkFBQXj11Vfx5ptvGnxeY5xNykZhsQreLg4I89bvE2EN2ofVAQBcSM5CZl4R3B3tkJCei4JiFRR29xtuEZFtUJeOvoP4tOqasVCXmg1w54xFTSORSPDpE61wPmkvEtJz8dqvJ7B0VDurW2+hLTPbhE3xiKyZ0YHFvHnzsGLFCly8eBH9+vXDjz/+iH79+kEqVU9+hIWF4dtvv0XTpk0NOt6kSZMwadKkUm9buXKl3rbu3bvj2LFj5R4zKioKBw8erPR5jXHsegYAdbqRtX0Qa/i6KhDm7Yy41BwcvZ6OR5v64WJJl/CGvi7VsviTiExHcxGjulOhgpgKVSO5O9ph0bNtMWzxfvxzPgXf7bmG8d0bWHpYWln5RThSMuP+aNOy10ISkeUZnQq1ePFiPPPMM0hISMDGjRsxYMAAbVChUa9ePSxbtsxkg7Rmx6w8DUqjfah61iI2Tv3hfPm2OrBo7Mv1FUS2JkSbClVNgUUm11jUdBFB7nh/oLrS0qd/X0RsydpBa/DvpVQUqwQa+Dijnhdn2ImsmdGBxeXLl/HWW2/B39+/zH3s7e0xevToKg3MVpy4mQHAFgIL3QXclzQdt22kMRIR3RfqpZ6xuJ6WC5VKmPVcKpVAkrbrNtdY1GQjOwRjSOtAKFUC//nlGFLvFVR8p2qw/cJtAOy2TWQLKrXGIiMjA7GxsUhJSdHryv3gYuvaIK9QBQ93OZpYeWWljmHqcrynb2Uiv0h5f8aCC7eJbE7dOo7akrPJWflmnUlIzSlAoVIFqQTwc2NgUZNJJBJ8NLQFziRm4UrKPUxdfQLLX2iPo9fvIiU7H76uCnQI84SsGtNnVSqB3RfV1SZ7MrAgsnpGBxabN2/Gs88+i5ycHLi6uuqsK5BIJLUusADUsxXWvk4h2NMRfm4OuJ1VgCPxd3HtjjqFohFToYhsjlwmRd06johPy0V8Wo5ZAwvNwm1fVwXsZJUuJEg2wtlBjsXPtsWgb/Zh75VUtP1gG+4VFGtvD3BXYObAZugTEVAt4zl5MwNpOYVwdZBrZ96JyHoZ/Vfitddew5gxY5CdnY2MjAzcvXtX+5Oebj05mdXJ2tOgAHXQp/lQXnvkBgqVKjjZy7gYk8hGhXrfT4cypySWmq11Gvm54ukOdQFAJ6gAgOTMfExcdQxbzlRcUt4UdpZUg3qksQ8DWyIbYPRv6a1btzBlyhQ4OXEBlUZkiPUHFsD9Rnl/lfxBaMSKUEQ2S7POwtyVoW6xOV6to1QJbDlzu9TbNCt6Zm0+B6WZ1/cAwI6L6sCCaVBEtsHowKJ37944cuSIOcZisyb/X/VdvamK9iWBRZFS/cfA3cmuWv4wEJHphVZTZShNKhRnN2uP2Lh0JGXml3m7AJCUmW/2ylEpWfk4cysLEgnQg/0riGyCQWssfv/9d+2/+/fvj9dffx3nzp1DixYtYGdnp7PvoEGDTDtCG3A7Sz01vPi5ttWWd1oZ11JyIMH9K057LqWi6yc7qjVflohMI0Tby8K8qVCJnLGodVKyyw4qKrNfZe0sma1oWdcD3i4OZj0XEZmGQYHFkCFD9LbNnj1bb5tEIoFSqazyoGyNACCBemq4VzP/aq2YYagtZ5Iw+edjeHh+QpMva+1BERHpCtOUnE3PgUolzJbWyB4WtY+vq2HraQzdr7K2n9d022YaFJGtMCgVSqVSGfRTG4MKjeqaGq4MpUpg1uZzekEFUP35skRkGkF1HCGTSpBfpMJtM1451sxYBLhz8XZt0SHMEwHuCpQXqga4K8xauKSgWIm9V1IBsH8FkS1hiQUTM/fUcGVYS74sEZmOXUnJWcB86VD5RUqk3isEwDUWtYlMKsHMgc0AoMzgwtz9LGLj0pFbqISvqwOaB7qZ7TxEZFqVCiy2b9+OAQMGoEGDBmjYsCEGDBiAf/75x9Rjs0nmnhquDGvJlyUi09JWhjLTAu7kkgsSjnYyeDjZVbA31SR9IgKw+Lm28H9opspNoc6g3nQiET8dvG628+8oKTPbs4kvqxcS2RCjG+R98803mDZtGp544gm8+uqrAICDBw+iX79+mDdvHl555RWTD9IWSAD4m3lquLKsJV+WiEwr1MsJu2G+wCLxgR4WDzZDpdqhT0QAejXzR2xcuk7n7fn/XMLXO67gvU1n4O5oh0GtAk1+bk3/CpaZJbItRgcWc+fOxZdffqkTQEyZMgVdunTBRx99VCsDC82f25kDm1nlwm1NvmxyZn6p6yysOSgiorJpm+SZKRWKPSxIJpUgqoGXzrbpvRojI7cIPx28julrTsBVIUdPEy6wvnbnHuLTcmEnk6BrI2+THZeIzM/oVKisrCz06dNHb3t0dDSysrJMMihb4++usOqqSuXly1p7UEREZTN3KhR7WFBpJBIJZg1qjkGtAlGsEpi46iiOxJtujZ4mDapjmBdcHIy+/klEFmR0YDFo0CBs2LBBb/umTZswcOBAkwzKlix9vg32vvmo1QYVGmXly1p7UEREZdPMWMSn5UAI01d1S8rUVIRiYEG6pFIJvniqFXo08UF+kQovrjyMc4mmubi4g2lQRDbL6EsB4eHh+Oijj7Br1y5ERUUBUK+x2LdvH1577TUsWLBAu++UKVNMN1Ir1S6kjs1c6S8rX9ZWxk9Euuo+WHI2q0DvwkFV3XpgjQXRw+xkUix+NhLPLzuEI9fvYtTyWPw2IUob8FZGdn6RtkLhYwwsiGyO0YHFsmXLUKdOHZw7dw7nzp3Tbvfw8MCyZcu0/5dIJLUisLA1peXLEpFt0pScvZ6Wi/i0HJMHFprF20yForI42suw7IX2ePq7gziflIXnlh3CbxM6V/q9uPdyKopVAvW9nasUoBCRZRgdWMTFxZljHEREVAkhXs7qwCI1B53qm+6igRBCu8aCi7epPO6OdvhxTAc8uWQ/4tNyMWr5IawdHwUPJ3ujj8U0KCLbVqUGeUIIs+T1EhGRYUK9nAAA8WmmrQyVkVuEvCIlAJh8JoRqHh9XB/w0tiP83Bxw6fY9vLDiMHIKio06hkolsPPiHQDstk1kqyoVWPz4449o0aIFHB0d4ejoiJYtW+Knn34y9diIiKgC2spQqaatDKVZX+Ht4gCFncykx6aaKdjTCT+N7QgPJzucuJGBCauOoqBYafD9zyRmIvVeAVwc5GgfyvLnRLbI6MBi3rx5mDhxIvr164e1a9dizZo16NOnDyZMmIAvv/zSHGMkIqIyhHprZixMG1gkZWrSoDhbQYZr7OeKFS+0h5O9DP9eTsW0NSegVBmW2bD9vDoNqmtDb9jLq5RQQUQWYvQai6+//hqLFy/GqFGjtNsGDx6M5s2b4/3338e0adNMOkAiIiqbZsbielouhBAm65Ct7brNUrNkpDb16uC759thzMrDiDmdDDfFacwd1qLC9+bOi+rAgmlQRLbL6EsCSUlJ6Ny5s972zp07IykpySSDIiIiw9St4wSpBMgrUiIlu8Bkx01k122qgq6NvPHV060hlQCrD9/Ax1sulLt/SnY+Tt3MBAD0aOpTHUMkIjMwOrBo2LAh1q5dq7d9zZo1aNSokUkGRUREhrGXS1G3Tkk6lAnXWbCHBVVV3xYBmDusBQDg293XsGT31TL33VWyaLtlXXf4uvI9R2SrjE6FmjVrFkaMGIE9e/agS5cukEgk2Lt3L7Zv315qwEFEROYV4uWEhHR1L4uOJio5yx4WZAoj2tdDRm4R5v51AR//dQHujnYY2aGe3n47NWVmmzANisiWGT1jMXz4cMTGxsLb2xsbN27E+vXr4e3tjdjYWAwdOtQcYyQionKElTQSM2XJWfawIFMZ370BJvZoAAB4Z8NpxJzWTZsuLFbh38upALi+gsjWGTVjUVRUhJdffhnvvvsuVq1aZa4xERGREUJMXHK2SKlCSrY6sAhgKhSZwBu9myAjtwi/xCbg1dXH4aqQo3MDb8TGpWPflTu4V1AML2d7tAhyt/RQiagKjAos7OzssGHDBrz77rvmGg8RERkpzNu0TfJuZ+VDJQB7mRTezg4mOSbVbhKJBB8OiUBWXhH+PJ2EsSuPwFUhR1pOoXaf3EIltp5LRp+IAAuOlIiqwuhUqKFDh2Ljxo1mGAoREVVGiLbkbA6EMKxnQHk0aVABHgpIpaYpX0skk0owb0QrhAe4olCp0gkqAHVls4mrjmHLGVaYJLJVRi/ebtiwIT744APs378fkZGRcHZ21rl9ypQpJhscERFVLLik5GxuoRJ3sgvg61a19CX2sCBzkUulSH8ooHjYrM3n0KuZP2QMaolsjtGBxffffw8PDw8cPXoUR48e1blNIpEwsCAiqmb2cimC6jjiRnoe4tNyqxxY3GIPCzKT2Lh03M4qu9+KgLrre2xcOqIamKbCGRFVH6MDi7i4OHOMg4iIqiDUy1kdWKTmoEOYZ5WOlZTJHhZkHpqiAKbaj4isi9FrLB4khDBJPi8REVVNqKYyVFrVK0Ox1CyZi6HN79gkj8g2VSqw+PHHH9GiRQs4OjrC0dERLVu2xE8//VSpASxatAhhYWFQKBSIjIzEv//+W+7+u3fvRmRkJBQKBerXr48lS5bo3L5y5UpIJBK9n/z8+1c/3n//fb3b/f39KzV+IiJrEOKlqQxlisCCqVBkHh3CPBHgrkBZqyckAALcFVWedSMiyzA6sJg3bx4mTpyIfv36Ye3atVizZg369OmDCRMm4MsvvzTqWGvWrMHUqVPxzjvv4Pjx4+jWrRv69u2LhISEUvePi4tDv3790K1bNxw/fhxvv/02pkyZgnXr1uns5+bmhqSkJJ0fhUL36kfz5s11bj99+rRxTwQRkRXRNslLrXrJ2Vvartu8akymJZNKMHNgMwDQCy40/585sBkXbhPZKKPXWHz99ddYvHgxRo0apd02ePBgNG/eHO+//z6mTZtm8LHmzZuHsWPH4qWXXgIAzJ8/H3///TcWL16MuXPn6u2/ZMkS1KtXD/PnzwcAhIeH48iRI/j8888xfPhw7X6GzEDI5XLOUhBRjRHyQCqUEAISSeW+mGXlFyE7vxgAEMCqUGQGfSICsPi5tpi1+RySMu9nE/i7KzBzYDP2sSCyYUYHFklJSejcubPe9s6dOyMpyfDa04WFhTh69Cj++9//6myPjo7G/v37S73PgQMHEB0drbOtd+/eWLZsGYqKimBnZwcAuHfvHkJCQqBUKtG6dWt88MEHaNOmjc79Ll++jMDAQDg4OKBjx46YM2cO6tevb/D4iYisSbCn4/2Ss/cKKp2jnlSyvsLDyQ7ODkb/iSAySJ+IAPRq5o/YuHSkZOfD11Wd/sSZCiLbVqk+FmvXrsXbb7+ts33NmjVo1KiRwcdJTU2FUqmEn5+fznY/Pz8kJyeXep/k5ORS9y8uLkZqaioCAgLQtGlTrFy5Ei1atEBWVha++uordOnSBSdPntSOr2PHjvjxxx/RuHFj3L59Gx9++CE6d+6Ms2fPwsur9PJ2BQUFKCi4XyIvKysLAFBUVISioiKDHzcRkTlIAQS6K3AzIx9XkrNQRyGr1HFupGUDAPzdFPxsI7NrV88NgBsAQKUshkpp2fEQkT5j/hYYHVjMmjULI0aMwJ49e9ClSxdIJBLs3bsX27dvx9q1a409nN50fUVT+KXt/+D2Tp06oVOnTtrbu3TpgrZt2+Lrr7/GggULAAB9+/bV3t6iRQtERUWhQYMG+OGHHzB9+vRSzzt37lzMmjVLb/vOnTvh5ORU3kMkIqoWTkIKQIrNuw7ijm/lKvbtuy0BIIO8IBMxMTEmHR8REdme3FzD1+4ZHVgMHz4chw4dwpdffomNGzdCCIFmzZohNjZWL92oPN7e3pDJZHqzEykpKXqzEhr+/v6l7i+Xy8ucaZBKpWjfvj0uX75c5licnZ3RokWLcvd56623dIKOrKwsBAcHo2fPnmWem4ioOh1SnsOl2JvwCGqIfr0Mn0F+0IVtl4FrcWjdOAT9+oWbeIRERGRr0tLSDN63Ugm0kZGRWLVqVWXuqmVvb4/IyEhs27YNQ4cO1W7ftm0bBg8eXOp9oqKisHnzZp1tW7duRbt27bTrKx4mhMCJEyfQokWLMsdSUFCA8+fPo1u3bmXu4+DgAAcHB73tdnZ2ZZ6biKg61fdxBQAk3M2v9OdScnYhAKCupzM/24iIyKi/BQYFFpr1BIZwc3MzeN/p06fj+eefR7t27RAVFYXvvvsOCQkJmDBhAgD1LMGtW7fw448/AgAmTJiAb775BtOnT8e4ceNw4MABLFu2DL/88ov2mLNmzUKnTp3QqFEjZGVlYcGCBThx4gQWLlyo3WfGjBkYOHAg6tWrh5SUFHz44YfIysrC6NGjDR47EZG1MUWTvFvsYUFERJVkUGDh4eFRYelCzdoIpdLwlVcjRoxAWloaZs+ejaSkJERERCAmJgYhISEA1BWoHuxpERYWhpiYGEybNg0LFy5EYGAgFixYoFNqNiMjAy+//DKSk5Ph7u6ONm3aYM+ePejQoYN2n5s3b2LkyJFITU2Fj48POnXqhIMHD2rPS0Rki0K9S5rkpVa+5Gwie1gQEVElSYRm9XM5du/ebfABu3fvXqUB2YqsrCy4u7sjNTWVayyIyCoUFCvR9N0tEAI4/M7j8HHVT98sj1Il0PTdv1CkFNj/30c5a0FEREhLS4O3tzcyMzMrzEwyaMaitgQLRES2zEEuQ6C7I25l5CE+LcfowCL1XgGKlAIyqQS+Rt6XiIioUou3MzIyEBsbi5SUFKhUKp3bHuzITURE1SvM21kdWKTmoH2op1H31ayv8HdTQC6TmmN4RERUgxkdWGzevBnPPvsscnJy4OrqqpPDK5FIGFgQEVlQiJcT9l6p3ALuRO3Cba6vICIi4xl9Seq1117DmDFjkJ2djYyMDNy9e1f7k56ebo4xEhGRge5XhjK8oZFGIitCERFRFRgdWNy6dQtTpkxht2kiIisU6l0SWKRWZsYiHwADCyIiqhyjA4vevXvjyJEj5hgLERFVUaiX+qLP9bRcGFD0T4d2xsKdqVBERGQ8g9ZY/P7779p/9+/fH6+//jrOnTuHFi1a6HXjGzRokGlHSEREBgv2dIJEAtwrKEZaTiG8XQyv7pSYyVQoIiKqPIMCiyFDhuhtmz17tt42YxvkERGRaSnsHig5m5pjXGDBVCgiIqoCg1KhVCqVQT8MKoiILE/bgduIBdx5hUqk5xQCYGBBRESVw0LlREQ1TIiX8Qu4NWlQLg5yuCkq1eKIiIhqOYMDix07dqBZs2bIysrSuy0zMxPNmzfHnj17TDo4IiIyXpi25KzhgUWSNg1KodOfiIiIyFAGBxbz58/HuHHj4Obmpnebu7s7xo8fjy+//NKkgyMiIuOFeGlSoYyYsSipCBXgzjQoIiKqHIMDi5MnT6JPnz5l3h4dHY2jR4+aZFBERFR5ml4W11MNLzl7i83xiIioigwOLG7fvq1XWvZBcrkcd+7cMcmgiIio8uqVlJzNLik5awjNjEWQB3tYEBFR5RgcWAQFBeH06dNl3n7q1CkEBASYZFBERFR5CjsZAtzUAcJ1A9Oh2MOCiIiqyuDAol+/fnjvvfeQn5+vd1teXh5mzpyJAQMGmHRwRERUOZp0qPhUw0rOsocFERFVlcE1Bf/3v/9h/fr1aNy4MV555RU0adIEEokE58+fx8KFC6FUKvHOO++Yc6xERGSgEC9n7L+aZtACbiGENhUqkIu3iYiokgwOLPz8/LB//35MnDgRb731lnZBoEQiQe/evbFo0SL4+fmZbaBERGS4MCOa5KXnFKKgWAWJBPBzN7xTNxER0YOM6oIUEhKCmJgY3L17F1euXIEQAo0aNUKdOnXMNT4iIqoEY5rkadKgfFwc4CCXmXVcRERUc1WqvWqdOnXQvn17U4+FiIhMJMz7fpM8IUS5Te9YapaIiEzB4MXbRERkO+p5qlOhsvOLkV5Bydn7pWYZWBARUeUxsCAiqoEUdjIEuqtLzla0ziJJW2qWPSyIiKjyGFgQEdVQhq6z0KyxCGBFKCIiqgIGFkRENVRoSWWoiprkcY0FERGZAgMLIqIaKlQzY1FBKhTXWBARkSkwsCAiqqG0qVDlzFgUFCuRkl0AgGssiIioahhYEBHVUJqSs3GpOdqmpg+7nakOKhzkUng621fb2IiIqOZhYEFEVEM9WHL2bm5RqfskZt5Pgyqv1wUREVFFGFgQEdVQjvYyBGhLzpaeDqVZXxHANCgiIqoiBhZERDVYiJd61qKskrOawCKQpWaJiKiKGFgQEdVgmnUWZVWGulXSw4KlZomIqKoYWBAR1WAVNcljqVkiIjIVBhZERDVYqFf5TfIS2RyPiIhMhIEFEVENFlpOKpQQ4oHAgou3iYioahhYEBHVYCGe6sAiM68Id3MKdW7Lyi9GTqESABDAxdtERFRFFg8sFi1ahLCwMCgUCkRGRuLff/8td//du3cjMjISCoUC9evXx5IlS3RuX7lyJSQSid5Pfn5+lc5LRGSLHO1l8HcrveSsZrbC09kejvayah8bERHVLBYNLNasWYOpU6finXfewfHjx9GtWzf07dsXCQkJpe4fFxeHfv36oVu3bjh+/DjefvttTJkyBevWrdPZz83NDUlJSTo/CsX9aX5jz0tEZMu0JWfLCCyYBkVERKZg0cBi3rx5GDt2LF566SWEh4dj/vz5CA4OxuLFi0vdf8mSJahXrx7mz5+P8PBwvPTSSxgzZgw+//xznf0kEgn8/f11fqpyXiIiW6YtOZuqu86CPSyIiMiULBZYFBYW4ujRo4iOjtbZHh0djf3795d6nwMHDujt37t3bxw5cgRFRUXabffu3UNISAjq1q2LAQMG4Pjx41U6LxGRLdOWnH1oxoI9LIiIyJTkljpxamoqlEol/Pz8dLb7+fkhOTm51PskJyeXun9xcTFSU1MREBCApk2bYuXKlWjRogWysrLw1VdfoUuXLjh58iQaNWpUqfMCQEFBAQoKCrT/z8rKAgAUFRXpBDVERNYm2MMBABCXek/n8+rWXXWg4e9mz88xIiIqlTF/HywWWGhIJBKd/wsh9LZVtP+D2zt16oROnTppb+/SpQvatm2Lr7/+GgsWLKj0eefOnYtZs2bpbd+5cyecnJzKvB8RkaXdygEAOa4kZSImJka7/WycDIAEyVfPIybznKWGR0REViw3V79ceVksFlh4e3tDJpPpzRKkpKTozSZo+Pv7l7q/XC6Hl5dXqfeRSqVo3749Ll++XOnzAsBbb72F6dOna/+flZWF4OBg9OzZs8xzExFZg9zCYnx6agdylRJ07tELHk52AIBPzu0BkI9+PaPQJtjDomMkIiLrlJaWZvC+Fgss7O3tERkZiW3btmHo0KHa7du2bcPgwYNLvU9UVBQ2b96ss23r1q1o164d7OzsSr2PEAInTpxAixYtKn1eAHBwcICDg4Pedjs7uzLPTURkDdzt7ODn5oDbWQW4lVUIH3cnFCtVuJ2tTu8M8Xbl5xgREZXKmL8PFq0KNX36dHz//fdYvnw5zp8/j2nTpiEhIQETJkwAoJ4lGDVqlHb/CRMm4Pr165g+fTrOnz+P5cuXY9myZZgxY4Z2n1mzZuHvv//GtWvXcOLECYwdOxYnTpzQHtOQ8xIR1TTaBdyp6nUVKdkFUKoE7GQS+LjoXzQhIiIylkXXWIwYMQJpaWmYPXs2kpKSEBERgZiYGISEhAAAkpKSdHpLhIWFISYmBtOmTcPChQsRGBiIBQsWYPjw4dp9MjIy8PLLLyM5ORnu7u5o06YN9uzZgw4dOhh8XiKimibMyxmxcenaylBJmepSs/7uCkilZa8vIyIiMpREaFY/k1GysrLg7u6O1NRUrrEgIqu3aNcVfLrlIoa0DsT8p9vg95OJmPLLcXQI88Ta8VGWHh4REVmptLQ0eHt7IzMzE25ubuXua9FUKCIiqh5h2l4W6uoemuZ4QexhQUREJsLAgoioFni4SZ6267aHwmJjIiKimoWBBRFRLRDqre63k5FbhIzcwgcCC85YEBGRaTCwICKqBZzs5fB1VVd/ik/Lxa2MfAAMLIiIyHQYWBAR1RKh3up0qOtpOdqqUFxjQUREpsLAgoiolgj1UqdDnUvMQkZuEQAgwJ1rLIiIyDQYWBAR1RKaBdz7r6YBAFwVcrgq2HGbiIhMg4EFEVEtEVaSCnUmMRMA06CIiMi0GFgQEdUSISWpUJq2qFy4TUREpsTAgoiolggtSYXSYA8LIiIyJQYWRES1hLODHN4u9tr/FysFlCphwREREVFNwsCCiKiW2HImCVl5Rdr/rz58A10/2YEtZ5IsOCoiIqopGFgQEdUCW84kYeKqYyhU6s5QJGfmY+KqYwwuiIioyhhYEBHVcEqVwKzN51Ba0pNm26zN55gWRUREVcLAgoiohouNS0dSZn6ZtwsASZn5iI1Lr75BERFRjcPAgoiohkvJLjuoqMx+REREpWFgQURUw/m6GlZW1tD9iIiISsPAgoiohusQ5okAdwUkZdwuARDgrkCHMM/qHBYREdUwDCyIiGo4mVSCmQObAYBecKH5/8yBzSCTlhV6EBERVYyBBRFRLdAnIgCLn2sLf3fddCd/dwUWP9cWfSICLDQyIiKqKeSWHgAREVWPPhEB6NXMH7Fx6UjJzoevqzr9iTMVRERkCgwsiIhqEZlUgqgGXpYeBhER1UBMhSIiIiIioipjYEFERERERFXGwIKIiIiIiKqMgQUREREREVUZF29XkhACAJCdnQ07OzsLj4aIiIiIyPSys7MB3P/uWx4GFpWUlpYGAAgLC7PwSIiIiIiIzCstLQ3u7u7l7sPAopI8PT0BAAkJCRU+yZXVvn17HD58mMeuxuPb6rHNfXxbPba5j2+rxzb38Tn26j+2uY9vq8c29/Ft9djmPj7HXv3HNufxMzMzUa9ePe133/IwsKgkqVS9PMXd3R1ubm5mOYdMJuOxq/n4tnpscx/fVo9t7uPb6rHNfXyOvfqPbe7j2+qxzX18Wz22uY/PsVf/savj+JrvvuXuY7azU5VNnjyZx67m49vqsc19fFs9trmPb6vHNvfxOfbqP7a5j2+rxzb38W312OY+Psde/ceujuMbQiIMWYlBerKysuDu7o7MzEyzRodERERERJZizHdezlhUkoODA2bOnAkHBwdLD4WIiIiIyCyM+c7LGQsiIiIiIqoyzlgQEREREVGVMbAgIiIiIqIqY2BBtdKiRYsQFhYGhUKByMhI/Pvvvzq3nz9/HoMGDYK7uztcXV3RqVMnJCQkWGi0VFPt2bMHAwcORGBgICQSCTZu3Khz+/vvv4+mTZvC2dkZderUweOPP45Dhw5ZZrBUo82dOxft27eHq6srfH19MWTIEFy8eFFnHyEE3n//fQQGBsLR0RE9evTA2bNnLTRiqskMeT9KJJJSfz777DMLjZoABhZUC61ZswZTp07FO++8g+PHj6Nbt27o27evNnC4evUqunbtiqZNm2LXrl04efIk3n33XSgUCguPnGqanJwctGrVCt98802ptzdu3BjffPMNTp8+jb179yI0NBTR0dG4c+dONY+Uarrdu3dj8uTJOHjwILZt24bi4mJER0cjJydHu8+nn36KefPm4ZtvvsHhw4fh7++PXr16ITs724Ijp5rIkPdjUlKSzs/y5cshkUgwfPhwC46cuHibap2OHTuibdu2WLx4sXZbeHg4hgwZgrlz5+Lpp5+GnZ0dfvrpJwuOkmobiUSCDRs2YMiQIWXuoyn5988//+Cxxx6rvsFRrXPnzh34+vpi9+7deOSRRyCEQGBgIKZOnYo333wTAFBQUAA/Pz988sknGD9+vIVHTDXZw+/H0gwZMgTZ2dnYvn17NY+OHsQZC6pVCgsLcfToUURHR+tsj46Oxv79+6FSqfDnn3+icePG6N27N3x9fdGxY0e9FBWi6lZYWIjvvvsO7u7uaNWqlaWHQzVcZmYmAMDT0xMAEBcXh+TkZJ3PTgcHB3Tv3h379++3yBip9nj4/fiw27dv488//8TYsWOrc1hUCgYWVKukpqZCqVTCz89PZ7ufnx+Sk5ORkpKCe/fu4eOPP0afPn2wdetWDB06FMOGDcPu3bstNGqqzf744w+4uLhAoVDgyy+/xLZt2+Dt7W3pYVENJoTA9OnT0bVrV0RERAAAkpOTAaDMz04icynt/fiwH374Aa6urhg2bFg1j44eJrf0AIgsQSKR6PxfCAGJRAKVSgUAGDx4MKZNmwYAaN26Nfbv348lS5age/fu1T5Wqt169uyJEydOIDU1FUuXLsVTTz2FQ4cOwdfX19JDoxrqlVdewalTp7B3716928r67CQyl/LejxrLly/Hs88+y7WQVoAzFlSreHt7QyaT6V1hS0lJgZ+fH7y9vSGXy9GsWTOd28PDw1kViizC2dkZDRs2RKdOnbBs2TLI5XIsW7bM0sOiGuo///kPfv/9d+zcuRN169bVbvf39weAMj87icyhrPfjg/79919cvHgRL730UjWPjkrDwIJqFXt7e0RGRmLbtm0627dt24bOnTvD3t4e7du31ytrd+nSJYSEhFTnUIlKJYRAQUGBpYdBNYwQAq+88grWr1+PHTt2ICwsTOf2sLAw+Pv763x2FhYWYvfu3ejcuXN1D5dquIrejw9atmwZIiMjufbMSjAVimqd6dOn4/nnn0e7du0QFRWF7777DgkJCZgwYQIA4PXXX8eIESPwyCOPoGfPntiyZQs2b96MXbt2WXbgVOPcu3cPV65c0f4/Li4OJ06cgKenJ7y8vPDRRx9h0KBBCAgIQFpaGhYtWoSbN2/iySeftOCoqSaaPHkyfv75Z2zatAmurq7amQl3d3c4OjpCIpFg6tSpmDNnDho1aoRGjRphzpw5cHJywjPPPGPh0VNNU9H7USMrKwu//vorvvjiC0sNlR4miGqhhQsXipCQEGFvby/atm0rdu/erXP7smXLRMOGDYVCoRCtWrUSGzdutNBIqSbbuXOnAKD3M3r0aJGXlyeGDh0qAgMDhb29vQgICBCDBg0SsbGxlh421UClvQ8BiBUrVmj3UalUYubMmcLf3184ODiIRx55RJw+fdpyg6Yay5D3oxBCfPvtt8LR0VFkZGRYZqCkh30siIiIiIioyrjGgoiIiIiIqoyBBRERERERVRkDCyIiIiIiqjIGFkREREREVGUMLIiIiIiIqMoYWBARERERUZUxsCAiIiIioipjYEFERERERFXGwIKIiIiIiKqMgQUREREREVUZAwsiIiIiIqoyBhZERERERFRlDCyIiIiIiKjKGFgQEREREVGVMbAgIiIiIqIqY2BBRERERERVxsCCiIiIiIiqjIEFERERERFVGQMLIiIiIiKqMgYWRERERERUZQwsiIiIiIioyhhYEBERERFRlTGwICIiIiKiKmNgUYYXXngBQ4YMsfQwiIiIiIhsAgMLIiIiIiKqMgYWBtiyZQu6du0KDw8PeHl5YcCAAbh69ar29vj4eEgkEqxfvx49e/aEk5MTWrVqhQMHDlhw1ERERERE1YeBhQFycnIwffp0HD58GNu3b4dUKsXQoUOhUql09nvnnXcwY8YMnDhxAo0bN8bIkSNR/P/t3W9M1eX/x/EnApqiYDr5ZxS0lGaY2VYky8omjPxXW2s1C4a5lZmaprPWnXRuMCxZM9qyVtCNmstNg9Zkc/Fnw8LM5qAgV85yTRA1/kkLAs7vhr8v24nq2/d7kqNfno9b51zXdd7nfd187TrX5wwMhKlrSZIkafREhbuBq8HDDz8c9P6dd94hPj6e5uZmMjIyhse3bNnC0qVLAdi+fTu33HIL33//PTfffPOo9itJkiSNNk8s/oaTJ0+ycuVKbrzxRmJjY0lLSwPg9OnTQetuvfXW4ddJSUkAtLe3j16jkiRJUph4YvE3LF++nJSUFN5++22Sk5MZGhoiIyOD/v7+oHXR0dHDryMiIgBG/FxKkiRJ+l9ksPg3Lly4QEtLC3v27GHhwoUA1NfXh7krSZIk6cpisPg3rr32WqZPn85bb71FUlISp0+f5sUXXwx3W5IkSdIVxTsWf2JoaIioqCjGjRvH3r17OXbsGBkZGWzatIlXXnkl3O1JkiRJV5SIQCAQCHcTV6Lc3FxuuukmSktLw92KJEmSdMXzxOJ3Ojo6+OSTT6itrWXx4sXhbkeSJEm6KnjH4neefPJJjh49yubNm3nwwQfD3Y4kSZJ0VfCnUJIkSZJC5k+hJEmSJIXMYCFJkiQpZGM2WBQVFXHHHXcwZcoU4uPjeeihhzhx4kTQmkAgwLZt20hOTmbixIncd999fPPNN8PzP//8M+vXryc9PZ1JkyZx/fXXs2HDBrq6uoLqdHR0kJeXR1xcHHFxceTl5dHZ2Tka25QkSZJGxZgNFnV1dTz77LM0NDRw6NAhBgYGyMnJobe3d3jNzp07KSkpobS0lKNHj5KYmEh2djY9PT0AnDlzhjNnzvDqq6/S1NREeXk5VVVVrF69Oui7Vq5cyfHjx6mqqqKqqorjx4+Tl5c3qvuVJEmSLicvb/+/c+fOER8fT11dHffccw+BQIDk5GQ2btzICy+8AEBfXx8JCQkUFxfz9NNP/2Gdffv28cQTT9Db20tUVBQtLS3MmTOHhoYGMjMzAWhoaGDBggV8++23pKenj9oeJUmSpMtlzJ5Y/N6/fr40bdo0AE6dOkVbWxs5OTnDayZMmMC9997LZ5999pd1YmNjiYq69CTfzz//nLi4uOFQAXDXXXcRFxf3l3UkSZKkq4nBgkt3KZ5//nnuvvtuMjIyAGhrawMgISEhaG1CQsLw3O9duHCBHTt2BJ1mtLW1ER8fP2JtfHz8n9aRJEmSrjb+QR6wbt06Ghsbqa+vHzEXERER9D4QCIwYA+ju7mbp0qXMmTOHl19++S9r/FUdSZIk6Wo05k8s1q9fT2VlJTU1NVx33XXD44mJiQAjThXa29tHnGL09PSQm5vL5MmTOXDgANHR0UF1zp49O+J7z507N6KOJEmSdLUas8EiEAiwbt069u/fT3V1NWlpaUHzaWlpJCYmcujQoeGx/v5+6urqyMrKGh7r7u4mJyeH8ePHU1lZyTXXXBNUZ8GCBXR1dfHFF18Mjx05coSurq6gOpIkSdLVbMw+FWrt2rV88MEHVFRUBD2ZKS4ujokTJwJQXFxMUVERZWVlzJo1i8LCQmprazlx4gRTpkyhp6eH7OxsfvnlFw4cOEBMTMxwnRkzZhAZGQnAAw88wJkzZ9izZw8ATz31FDfccAMff/zxKO5YkiRJunzGbLD4s/sNZWVlFBQUAJdONbZv386ePXvo6OggMzOTN954Y/iCd21tLYsWLfrDOqdOnSI1NRW49Ed6GzZsoLKyEoAVK1ZQWlrK1KlT/9E9SZIkSeEyZoOFJEmSpH/OmL1jIUmSJOmfY7CQJEmSFDKDhSRJkqSQGSwkSZIkhcxgIUmSJClkBgtJkiRJITNYSJIkSQqZwUKSJElSyAwWkiRJkkJmsJAkjaqCggIiIiKIiIggOjqahIQEsrOzeffddxkaGvrbdcrLy5k6derla1SS9B8xWEiSRl1ubi6tra388MMPHDx4kEWLFvHcc8+xbNkyBgYGwt2eJOm/YLCQJI26CRMmkJiYyMyZM7n99tt56aWXqKio4ODBg5SXlwNQUlLC3LlziYmJISUlhbVr13Lx4kUAamtrWbVqFV1dXcOnH9u2bQOgv7+frVu3MnPmTGJiYsjMzKS2tjY8G5WkMcRgIUm6Itx///3MmzeP/fv3AzBu3Dh2797N119/zXvvvUd1dTVbt24FICsri9dee43Y2FhaW1tpbW1ly5YtAKxatYrDhw+zd+9eGhsbeeSRR8jNzeW7774L294kaSyICAQCgXA3IUkaOwoKCujs7OSjjz4aMffYY4/R2NhIc3PziLl9+/bxzDPPcP78eeDSHYuNGzfS2dk5vObkyZPMmjWLn376ieTk5OHxxYsXc+edd1JYWPiP70eSdElUuBuQJOlfAoEAERERANTU1FBYWEhzczPd3d0MDAzw66+/0tvbS0xMzB9+/quvviIQCDB79uyg8b6+PqZPn37Z+5ekscxgIUm6YrS0tJCWlsaPP/7IkiVLWLNmDTt27GDatGnU19ezevVqfvvttz/9/NDQEJGRkRw7dozIyMigucmTJ1/u9iVpTDNYSJKuCNXV1TQ1NbFp0ya+/PJLBgYG2LVrF+PGXboO+OGHHwatHz9+PIODg0Fj8+fPZ3BwkPb2dhYuXDhqvUuSDBaSpDDo6+ujra2NwcFBzp49S1VVFUVFRSxbtoz8/HyampoYGBjg9ddfZ/ny5Rw+fJg333wzqEZqaioXL17k008/Zd68eUyaNInZs2fz+OOPk5+fz65du5g/fz7nz5+nurqauXPnsmTJkjDtWJL+9/lUKEnSqKuqqiIpKYnU1FRyc3Opqalh9+7dVFRUEBkZyW233UZJSQnFxcVkZGTw/vvvU1RUFFQjKyuLNWvW8OijjzJjxgx27twJQFlZGfn5+WzevJn09HRWrFjBkSNHSElJCcdWJWnM8KlQkiRJkkLmiYUkSZKkkBksJEmSJIXMYCFJkiQpZAYLSZIkSSEzWEiSJEkKmcFCkiRJUsgMFpIkSZJCZrCQJEmSFDKDhSRJkqSQGSwkSZIkhcxgIUmSJClkBgtJkiRJIfs/c/FzZdgdvysAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -319,110 +309,55 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u001b[38;5;200m\u001b[1;3m\u001b[0m\u001b[32;1m\u001b[1;3mI’ve created a map of the average chlorophyll concentration for the one‑hour period at the beginning of January 2020 over the Indian Ocean, using a green colormap.\n", + "\u001b[33;1m\u001b[1;3mExecution Result:\n", + "Figure saved to: figures_temp/plot_20250822_184744_549_fig1.png\n", + "\n", + "\n", + "Saved Plots:\n", + "- figures_temp/plot_20250822_184744_549_fig1.png\n", + "\n", + "Executed Code:\n", + "import xarray as xr, matplotlib.pyplot as plt\n", + "store='gcs://nmfs_odp_nwfsc/CB/mind_the_chl_gap/IO.zarr'\n", + "ds = xr.open_zarr(store, consolidated=False, storage_options={'token':'anon'})\n", + "chl = ds['CHL_cmes-level3']\n", + "# Subset time for Jan 2020\n", + "chl_jan = chl.sel(time=slice('2020-01-01','2020-01-31'))\n", + "# Choose point near lat=-10, lon=80 (nearest)\n", + "point = chl_jan.sel(lat=-10, lon=80, method='nearest')\n", + "# Convert to pandas Series\n", + "ts = point.to_series()\n", + "# Plot\n", + "plt.figure(figsize=(8,4))\n", + "ts.plot(marker='o')\n", + "plt.title(f'CHL_cmes-level3 Time Series (Jan 2020) at lat={float(point.lat.values):.2f}, lon={float(point.lon.values):.2f}')\n", + "plt.ylabel('Chlorophyll (mg m⁻³)')\n", + "plt.xlabel('Date')\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\u001b[0m\u001b[32;1m\u001b[1;3mHere is the time‑series of **chlorophyll (CHL_cmes‑level3)** for a single location in the Indian Ocean during the first month of 2020 (January 1 – January 31, 2020).\n", + "\n", + "**Location chosen (nearest grid point)**\n", + "- Latitude: **‑10.00°**\n", + "- Longitude: ** 80.00°**\n", + "\n", + "**Plot**\n", "\n", - "**What you’re seeing**\n", + "![Chlorophyll time‑series (Jan 2020) at lat=-10°, lon=80°](figures_temp/plot_20250822_184744_549_fig1.png)\n", "\n", - "- The map focuses on longitudes 20° E to 120° E and latitudes ‑45° to 30° N, which roughly bounds the Indian Ocean.\n", - "- Chlorophyll values are shown with the **Greens** colormap, where lighter greens indicate higher concentrations.\n", - "- The color bar on the right quantifies the concentration in mg m⁻³ (the data are from the `CHL_cmes-gapfree` product).\n", - "- Coastlines and country borders are drawn for geographic reference. \n", + "**What you are seeing**\n", "\n", - "The plot represents the spatial distribution of chlorophyll for that specific hour (Jan 1 2020 00:00 UTC) across the region.\u001b[0m\n", + "- The blue circles indicate the chlorophyll concentration (in mg m⁻³) recorded each day throughout January 2020 at the selected grid point.\n", + "- The y‑axis shows the concentration values; the x‑axis shows the dates.\n", + "- The series fluctuates day‑to‑day, reflecting natural variability in surface chlorophyll driven by processes such as phytoplankton growth, advection, and environmental conditions in that part of the Indian Ocean.\u001b[0m\n", "\n", "\u001b[1m> Finished chain.\u001b[0m\n" ] } ], "source": [ - "r = executor.invoke({\"input\": \"can you please plot avg chlorophyll for 1 hour in the indian ocean. do 1 hour at the beginning of january 2020. use a green colormap\"})" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "9813b8f7-d131-4721-a0c3-a2d8ea9dcc71", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/jovyan/ohw25_proj_datadashboard_llm/final_notebooks/functions/db_creation.py:41: LangChainDeprecationWarning: Since Chroma 0.4.x the manual persistence method is no longer supported as docs are automatically persisted.\n", - " vector_store_hf.persist()\n" - ] - } - ], - "source": [ - "chroma = create_db_examples()" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "130abea6-d897-40cc-8844-e5562c7fe4d5", - "metadata": {}, - "outputs": [], - "source": [ - "advisor_tool = create_adviser_tool()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "02ce13f0-4a05-42c2-8670-a2613a9da468", - "metadata": {}, - "outputs": [], - "source": [ - "loader_tool = create_loader_tool()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "8ee82c8c-92c3-4572-b224-6103d4e3155e", - "metadata": {}, - "outputs": [], - "source": [ - "repl_tool = create_python_repl()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "0951cfc1-75f3-457e-a4f8-8d842002034d", - "metadata": {}, - "outputs": [], - "source": [ - "tools = [\n", - " advisor_tool,\n", - " loader_tool,\n", - " repl_tool\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "66b53e83-2ea5-4fba-a787-edf1f8fe3e74", - "metadata": {}, - "outputs": [], - "source": [ - "llm = get_llm()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "79660b73-2a6e-4096-93a6-2157d4b8fa5b", - "metadata": {}, - "outputs": [], - "source": [ - "agent = create_tool_calling_agent(\n", - " llm=llm,\n", - " tools=tools,\n", - " prompt=get_prompt(),\n", - ")" + "r = executor.invoke({\"input\": \"can you please plot a timeseries of chlorophyll for 1 month in the indian ocean. pick a single point. do 1 month at the beginning of january 2020.\"})" ] }, {