{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import Normalize\n",
    "from matplotlib.patches import ConnectionPatch\n",
    "from netCDF4 import Dataset\n",
    "from wrf import getvar, interplevel, interpline, CoordPair, latlon_coords, to_np, vertcross, ll_to_xy, xy_to_ll, get_cartopy, WrfProj\n",
    "import numpy as np\n",
    "import cartopy.crs as ccrs\n",
    "import cartopy.feature as cfeature\n",
    "from matplotlib.colors import LinearSegmentedColormap, TwoSlopeNorm\n",
    "import matplotlib.colors as mcolors\n",
    "import matplotlib.colors as Normalize\n",
    "from datetime import datetime\n",
    "import os\n",
    "import xarray as xr\n",
    "#from metpy.interpolate import cross_section\n",
    "#import metpy\n",
    "from pyproj import Proj, transform\n",
    "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n",
    "from cartopy.mpl.geoaxes import GeoAxes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hex_to_rgb(value):\n",
    "    '''\n",
    "    Converts hex to rgb colours\n",
    "    value: string of 6 characters representing a hex colour.\n",
    "    Returns: list length 3 of RGB values'''\n",
    "    value = value.strip(\"#\") # removes hash symbol if present\n",
    "    lv = len(value)\n",
    "    return tuple(int(value[i:i + lv // 3], 16) for i in range(0, lv, lv // 3))\n",
    "\n",
    "# Downscaling function\n",
    "def downscale_precip(ds):\n",
    "    \"\"\"\n",
    "    Downscale xarray dataset by coarsening the resolution.\n",
    "    \"\"\"\n",
    "    return ds.coarsen(\n",
    "        south_north=6,  # Downsampling factor of 6 for south_north\n",
    "        west_east=6,    # Downsampling factor of 6 for west_east\n",
    "        boundary=\"trim\"\n",
    "    ).mean()\n",
    "\n",
    "############### Diverging colormap #####################\n",
    "\n",
    "#clevs3 = [-5,-4, -3, -2,-1,-0.5,0.5,1,2,3,4,5] # precip levels\n",
    "clevs3 = [-2,-1.5,-1,-0.5,-0.1,0.1,0.5,1,1.5,2]\n",
    "\n",
    "def create_custom_diverging_colormap(levels):\n",
    "    \"\"\"\n",
    "    Creates a custom diverging colormap with cool colors (blues) on one end and \n",
    "    warm colors (yellows, oranges, reds) on the other end.\n",
    "\n",
    "    Parameters:\n",
    "    - levels (int): The number of intervals or levels in the colormap.\n",
    "\n",
    "    Returns:\n",
    "    - colormap: A matplotlib colormap object.\n",
    "    \"\"\"\n",
    "\n",
    "    # Ensure levels is an odd number for symmetry around the white midpoint\n",
    "    \n",
    "    custom_rgb = [\n",
    "        '#3f3f3f', '#5b5b5b', '#797979', '#999999', '#bababa', '#dcdcdc', '#ffffff', #black\n",
    "        '#dde6f1', '#c7cbe2', '#a692c5', '#9974b6', '#7f3698', # purple\n",
    "    ]\n",
    "    \n",
    "    custom_rgb.reverse()\n",
    "\n",
    "    # Create a colormap with the specified number of levels\n",
    "    cmap = LinearSegmentedColormap.from_list(\"CoolWarmCustom\", custom_rgb, N=levels)\n",
    "\n",
    "\n",
    "    # Set the over and under values\n",
    "    cmap.set_under(np.array(hex_to_rgb('#710089'))/255)  # For values above max level\n",
    "    cmap.set_over(np.array(hex_to_rgb('#070707'))/255)  # For values below min level\n",
    "\n",
    "    return cmap\n",
    "\n",
    "def create_custom_diverging_colormap(levels):\n",
    "    \"\"\"\n",
    "    Creates a custom diverging colormap with cool colors (blues) on one end and \n",
    "    warm colors (yellows, oranges, reds) on the other end.\n",
    "\n",
    "    Parameters:\n",
    "    - levels (int): The number of intervals or levels in the colormap.\n",
    "\n",
    "    Returns:\n",
    "    - colormap: A matplotlib colormap object.\n",
    "    \"\"\"\n",
    "\n",
    "    # Ensure levels is an odd number for symmetry around the white midpoint\n",
    "    \n",
    "    # Define the cool-to-warm color transition\n",
    "    custom_rgb = [\n",
    "        '#37569e', '#5578af', '#719cc1', '#b8e3e7', '#ffffff', \n",
    "        '#ffd784', '#fda75e', '#eb7949', '#d24d37', '#b12122'\n",
    "    ]\n",
    "\n",
    "    # Create a colormap with the specified number of levels\n",
    "    cmap = LinearSegmentedColormap.from_list(\"CoolWarmCustom\", custom_rgb, N=levels)\n",
    "\n",
    "\n",
    "    # Set the over and under values\n",
    "    cmap.set_under(np.array(hex_to_rgb('#0a348c'))/255)  # For values above max level\n",
    "    cmap.set_over(np.array(hex_to_rgb('#840000'))/255)  # For values below min level\n",
    "\n",
    "    return cmap\n",
    "\n",
    "# Create a ListedColormap from the custom RGBA values\n",
    "cmap5 = create_custom_diverging_colormap(levels=len(clevs3))\n",
    "\n",
    "# Create a normalization for the contour levels\n",
    "norm5 = mcolors.BoundaryNorm(clevs3, len(clevs3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "######## Downloading data #############\n",
    "def list_wrf_files_in_time_range(directory, start_time, end_time):\n",
    "    \"\"\"\n",
    "    Lists WRF files in a directory that fall within a specified time range.\n",
    "    \n",
    "    Parameters:\n",
    "        directory (str): Path to the directory containing WRF files.\n",
    "        start_time (datetime): Start time for file selection.\n",
    "        end_time (datetime): End time for file selection.\n",
    "        \n",
    "    Returns:\n",
    "        list: List of WRF file paths within the specified time range.\n",
    "    \"\"\"\n",
    "    wrf_files = []\n",
    "    for filename in os.listdir(directory):\n",
    "        # Check if filename matches the WRF naming pattern\n",
    "        if filename.startswith(\"wrfout_d01_\"):\n",
    "            # Extract timestamp from filename\n",
    "            timestamp_str = filename.split(\"_\")[2] + \"_\" + filename.split(\"_\")[3]\n",
    "            file_time = datetime.strptime(timestamp_str, \"%Y-%m-%d_%H:%M:%S\")\n",
    "            \n",
    "            # Check if file's timestamp is within the desired range\n",
    "            if start_time <= file_time <= end_time:\n",
    "                wrf_files.append(os.path.join(directory, filename))\n",
    "    \n",
    "    # Sort files by timestamp to maintain chronological order\n",
    "    wrf_files.sort()\n",
    "    return wrf_files\n",
    "\n",
    "def download_data(directory, start_time, end_time):\n",
    "    \"\"\"\n",
    "    Generate a cross-section plot from WRF output, including omega and potential temperature.\n",
    "    \n",
    "    Parameters:\n",
    "        directory (str): Directory path containing WRF output files.\n",
    "        start_point (tuple): Starting point (lat, lon) of the cross-section.\n",
    "        end_point (tuple): Ending point (lat, lon) of the cross-section.\n",
    "        start_time (datetime): Start of the time range for mean calculation.\n",
    "        end_time (datetime): End of the time range for mean calculation.\n",
    "    \"\"\"\n",
    "\n",
    "    # Get list of files in the specified time range\n",
    "    wrf_files = list_wrf_files_in_time_range(directory, start_time, end_time)\n",
    "    num_files = len(wrf_files)\n",
    "    \n",
    "    if num_files == 0:\n",
    "        raise ValueError(\"No WRF files found in the specified time range.\")\n",
    "    ds_list=[]\n",
    "    # Loop over each WRF file to accumulate cross-sections\n",
    "    for wrf_file in wrf_files:\n",
    "        ncfile = Dataset(wrf_file)\n",
    "        print(wrf_file)\n",
    "\n",
    "        # Extract required variables\n",
    "        theta = getvar(ncfile, \"theta\")  # Potential temperature\n",
    "        pressure = getvar(ncfile, \"pressure\")  # Pressure levels\n",
    "        omega = getvar(ncfile, \"omega\")  # Vertical velocity\n",
    "        \n",
    "        theta = downscale_precip(theta)\n",
    "        omega = downscale_precip(omega)\n",
    "        pressure = downscale_precip(pressure)\n",
    "\n",
    "        ds = xr.Dataset({\"theta\": theta, \"omega\": omega, \"pressure\": pressure})\n",
    "        ds_list.append(ds)\n",
    "    \n",
    "    ds_o = xr.concat(ds_list, dim='Time')\n",
    "\n",
    "    ds_o['omega'].attrs['projection'] = str(ds_o['omega'].attrs['projection'])\n",
    "    ds_o['theta'].attrs['projection'] = str(ds_o['theta'].attrs['projection'])\n",
    "    ds_o['pressure'].attrs['projection'] = str(ds_o['pressure'].attrs['projection'])\n",
    "\n",
    "    filename='/pscratch/sd/d/dbrooks/vertical_motion/Future_urban/vertical_motion_data_month6.nc'\n",
    "    ds_o.to_netcdf(filename)\n",
    "\n",
    "directory = '/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/future_urban/3hr'\n",
    "start_time = datetime(2017, 6, 1, 0, 0)  # Start time: Year, month, day, hour, minute\n",
    "end_time = datetime(2017, 6, 6, 0, 0)   # End time: Year, month, day, hour, minute\n",
    "\n",
    "#download_data(directory, start_time, end_time)\n",
    "#filename='/pscratch/sd/d/dbrooks/vertical_motion/Future_urban/vertical_motion_data_month6.nc'\n",
    "#fu_ds = xr.open_dataset(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#################### Plot cross-section from downloaded nc files ##########################\n",
    "\n",
    "def plot_cross_section_with_metpy(dataset, start_point, end_point, start_time, end_time):\n",
    "    \"\"\"\n",
    "    Generate a cross-section plot using MetPy and xarray.Dataset.\n",
    "\n",
    "    Parameters:\n",
    "        dataset (xarray.Dataset): Dataset containing theta, omega, and pressure variables.\n",
    "        start_point (tuple): Starting point (lat, lon) of the cross-section.\n",
    "        end_point (tuple): Ending point (lat, lon) of the cross-section.\n",
    "        start_time (datetime): Start of the time range for mean calculation.\n",
    "        end_time (datetime): End of the time range for mean calculation.\n",
    "    \"\"\"\n",
    "    # Rename dimensions to x (west_east) and y (south_north) for MetPy compatibility\n",
    "    dataset = dataset.rename({\"south_north\": \"y\", \"west_east\": \"x\"})\n",
    "\n",
    "    # Define Lambert Conformal Conic projection parameters\n",
    "    lcc_proj = Proj(proj=\"lcc\", \n",
    "                    lat_1=32.5, \n",
    "                    lat_2=42.5, \n",
    "                    lon_0=-97.5, \n",
    "                    lat_0=36.70001)\n",
    "    \n",
    "    # Compute Cartesian coordinates from latitude and longitude\n",
    "    x_coords, y_coords = lcc_proj(dataset[\"XLONG\"].values, dataset[\"XLAT\"].values)\n",
    "\n",
    "\n",
    "    # Compute 1D x and y coordinates (unique values along each axis)\n",
    "    x_1d = x_coords[0, :]  # Unique values along the x-axis (west_east)\n",
    "    y_1d = y_coords[:, 0]  # Unique values along the y-axis (south_north)\n",
    "\n",
    "    # Assign 1D Cartesian coordinates to the dataset\n",
    "    dataset = dataset.assign_coords({\n",
    "        \"x\": x_1d,\n",
    "        \"y\": y_1d,\n",
    "        \"bottom_top\": dataset[\"pressure\"][\"bottom_top\"]\n",
    "    })\n",
    "\n",
    "    dataset = dataset.rename({'XLAT': 'lat', 'XLONG': 'lon'})\n",
    "\n",
    "    # Select data within the time range and compute time mean\n",
    "    time_filtered = dataset.sel(Time=slice(start_time, end_time))\n",
    "\n",
    "    theta_mean = time_filtered[\"theta\"].mean(dim=\"Time\")\n",
    "    omega_mean = time_filtered[\"omega\"].mean(dim=\"Time\")\n",
    "    pressure_mean = time_filtered[\"pressure\"].mean(dim=\"Time\")\n",
    "    \n",
    "    # Combine datasets into one for MetPy\n",
    "    combined_ds = xr.Dataset({\n",
    "        'theta': theta_mean,\n",
    "        'omega': omega_mean,\n",
    "        'pressure': pressure_mean,\n",
    "        \n",
    "    })\n",
    "\n",
    "    # Assign the CRS to the lat/lon coordinates\n",
    "    combined_ds = combined_ds.metpy.assign_crs(grid_mapping_name= \"lambert_conformal_conic\",\n",
    "                                                standard_parallel=(32.5, 42.5),\n",
    "                                                longitude_of_central_meridian=-97.5,\n",
    "                                                latitude_of_projection_origin=36.70001\n",
    "                                               )\n",
    "    #combined_ds = combined_ds.assign_coords(crs=data_crs)\n",
    "\n",
    "    combined_ds = combined_ds.metpy.parse_cf()\n",
    "\n",
    "    print(combined_ds)\n",
    "    # Interpolate the cross-section\n",
    "    cross = cross_section(\n",
    "        combined_ds,\n",
    "        start=start_point,\n",
    "        end=end_point,\n",
    "        steps=50  # Reduce steps for coarse-resolution data\n",
    "    )\n",
    "\n",
    "    cross = cross.set_coords(('lat', 'lon'))  # Ensure lat/lon are retained as coordinates\n",
    "\n",
    "    print(cross)\n",
    "    # Extract data for plotting\n",
    "    theta_cross = cross[\"theta\"]\n",
    "    omega_cross = cross[\"omega\"]\n",
    "    pressure_cross = cross[\"pressure\"]\n",
    "\n",
    "    #print(pressure_cross)\n",
    "\n",
    "    # Combine lat/lon for x-axis labels\n",
    "    cross_coords = [\"{:.2f}°N,\\n{:.2f}°W\".format(lat, lon * -1) for lat, lon in zip(cross['lat'].values, cross['lon'].values)]\n",
    "    coord_interval = len(cross_coords) // 6  # Show roughly 6 coordinate labels\n",
    "\n",
    "    #print(cross_coords)\n",
    "    # Create the plot\n",
    "    fig, ax = plt.subplots(figsize=(12, 6))\n",
    "\n",
    "    cf = ax.contourf(\n",
    "        range(len(cross_coords)),\n",
    "        pressure_cross,\n",
    "        omega_cross,\n",
    "        levels=clevs3,\n",
    "        cmap=cmap5,\n",
    "        norm=norm5,\n",
    "        extend=\"both\"\n",
    "    )\n",
    "    cbar = fig.colorbar(cf, ax=ax, orientation=\"vertical\", pad=0.02, label=\"Omega (Pa/s)\", extend=\"both\")\n",
    "    cbar.set_ticks(clevs3)\n",
    "\n",
    "    # Contour for potential temperature\n",
    "    theta_contours = ax.contour(\n",
    "        range(len(cross_coords)),\n",
    "        pressure_cross,\n",
    "        theta_cross,\n",
    "        levels=np.arange(300, 400, 5),\n",
    "        colors=\"black\",\n",
    "        linestyles=\"--\",\n",
    "        linewidths=1.5,\n",
    "    )\n",
    "    ax.clabel(theta_contours, inline=True, fontsize=8, fmt=\"%d\")\n",
    "\n",
    "    # Add labels for the cross-section\n",
    "    ax.text(5, 950, \"A\", fontsize=14, fontweight=\"bold\", ha=\"center\", va=\"center\", color=\"black\")\n",
    "    ax.text(len(cross_coords)-5, 950, \"B\", fontsize=14, fontweight=\"bold\", ha=\"center\", va=\"center\", color=\"black\")\n",
    "\n",
    "    # Adjust y-axis for pressure\n",
    "    ax.set_yscale(\"log\")\n",
    "    ax.set_ylim(1000, 200)\n",
    "    ax.set_ylabel(\"Pressure (hPa)\")\n",
    "    ax.set_xlabel(\"Latitude, Longitude\")\n",
    "    ax.set_xticks(range(0, len(cross_coords), coord_interval))\n",
    "    ax.set_xticklabels(cross_coords[::coord_interval])\n",
    "    ax.set_title(f\"Cross-Section of Mean Omega and Potential Temperature from {start_time.strftime('%Y-%m-%d %Hz')} to {end_time.strftime('%Y-%m-%d %Hz')}\")\n",
    "\n",
    "    # Add minimap\n",
    "    inset_ax = fig.add_axes([0.566, 0.71, 0.2, 0.2], projection=ccrs.PlateCarree())\n",
    "    inset_ax.add_feature(cfeature.COASTLINE)\n",
    "    inset_ax.add_feature(cfeature.BORDERS, linestyle=\":\")\n",
    "    inset_ax.add_feature(cfeature.STATES, edgecolor=\"gray\")\n",
    "    inset_ax.set_extent([cross[\"lon\"].min()-2, cross[\"lon\"].max()+2, cross[\"lat\"].min()-2, cross[\"lat\"].max()+2], crs=ccrs.PlateCarree())\n",
    "    inset_ax.plot([start_point[1], end_point[1]], [start_point[0], end_point[0]], color=\"blue\", transform=ccrs.PlateCarree(), lw=2)\n",
    "    inset_ax.scatter([start_point[1], end_point[1]], [start_point[0], end_point[0]], color=\"blue\", transform=ccrs.PlateCarree())\n",
    "\n",
    "    inset_ax.text(start_point[1], start_point[0]-1, \"A\", fontsize=10, fontweight=\"bold\", ha=\"right\", color=\"black\", transform=ccrs.PlateCarree())\n",
    "    inset_ax.text(end_point[1], end_point[0]-1, \"B\", fontsize=10, fontweight=\"bold\", ha=\"left\", color=\"black\", transform=ccrs.PlateCarree())\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "start_time = datetime(2017, 6, 1, 0, 0)  # Start time: Year, month, day, hour, minute\n",
    "end_time = datetime(2017, 6, 1, 3, 0)   # End time: Year, month, day, hour, minute\n",
    "start_point = (36,-95.848124)  # Example start point (latitude, longitude)\n",
    "end_point = (36,-86.297920)   # Example end point (latitude, longitude)\n",
    "\n",
    "#plot_cross_section_with_metpy(fu_ds, start_point, end_point, start_time, end_time)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "############# Plotting cross-section, directly from wrf output files #################\n",
    "def downscale_cross_section(data, factor):\n",
    "    \"\"\"\n",
    "    Downscale the horizontal resolution of cross-section data.\n",
    "    \n",
    "    Parameters:\n",
    "        data (numpy.ndarray): The cross-section data (2D array).\n",
    "        factor (int): The downscaling factor (e.g., 6 for 12km resolution from 2km).\n",
    "        \n",
    "    Returns:\n",
    "        numpy.ndarray: Downscaled data.\n",
    "    \"\"\"\n",
    "    # Calculate the new shape after downscaling\n",
    "    new_shape = (data.shape[0], data.shape[1] // factor)\n",
    "    \n",
    "    # Reshape and average along the horizontal axis\n",
    "    downscaled_data = data[:, :new_shape[1] * factor].reshape(new_shape[0], new_shape[1], factor).mean(axis=2)\n",
    "    return downscaled_data\n",
    "\n",
    "def downscale_cross_xarray(cross_section, downscale_factor):\n",
    "    \"\"\"\n",
    "    Downscale the horizontal resolution of an xarray cross-section DataArray.\n",
    "    \n",
    "    Parameters:\n",
    "        cross_section (xarray.DataArray): The cross-section to downscale (e.g., omega_cross or theta_cross).\n",
    "        downscale_factor (int): The factor by which to reduce the resolution (e.g., 6 for 12km from 2km).\n",
    "        \n",
    "    Returns:\n",
    "        xarray.DataArray: The downscaled cross-section.\n",
    "    \"\"\"\n",
    "    # Drop non-numeric coordinates (e.g., xy_loc)\n",
    "    coords_to_keep = {\n",
    "        name: coord\n",
    "        for name, coord in cross_section.coords.items()\n",
    "        if coord.dtype != object  # Keep only numeric coordinates\n",
    "    }\n",
    "\n",
    "    # Apply downscaling\n",
    "    downscaled = (\n",
    "        cross_section.drop_vars(\"xy_loc\", errors=\"ignore\")\n",
    "        .coarsen(cross_line_idx=downscale_factor, boundary=\"trim\")\n",
    "        .mean()\n",
    "    )\n",
    "\n",
    "    # Reassign numeric coordinates\n",
    "    downscaled = downscaled.assign_coords(coords_to_keep)\n",
    "\n",
    "    return downscaled\n",
    "\n",
    "from scipy.ndimage import uniform_filter\n",
    "\n",
    "# Convert to NumPy, apply uniform filter on each level\n",
    "def apply_spatial_filter(data_array, size):\n",
    "    # Apply to each level separately\n",
    "    filtered = np.empty_like(data_array)\n",
    "    for k in range(data_array.shape[0]):\n",
    "        filtered[k] = uniform_filter(data_array[k], size=size, mode='nearest')\n",
    "    return filtered\n",
    "\n",
    "\n",
    "def plot_cross_section(directory, start_point, end_point, start_time, end_time, cpi, sim, downscale_factor=1):\n",
    "    \"\"\"\n",
    "    Generate a cross-section plot from WRF output, including omega and potential temperature.\n",
    "    \n",
    "    Parameters:\n",
    "        directory (str): Directory path containing WRF output files.\n",
    "        start_point (tuple): Starting point (lat, lon) of the cross-section.\n",
    "        end_point (tuple): Ending point (lat, lon) of the cross-section.\n",
    "        start_time (datetime): Start of the time range for mean calculation.\n",
    "        end_time (datetime): End of the time range for mean calculation.\n",
    "    \"\"\"\n",
    "\n",
    "    # Get list of files in the specified time range\n",
    "    wrf_files = list_wrf_files_in_time_range(directory, start_time, end_time)\n",
    "    num_files = len(wrf_files)\n",
    "    \n",
    "    if num_files == 0:\n",
    "        raise ValueError(\"No WRF files found in the specified time range.\")\n",
    "    \n",
    "    # Initialize accumulators for omega and theta\n",
    "    omega_accum = None\n",
    "    theta_accum = None\n",
    "\n",
    "    # Define cross-section points\n",
    "    start = CoordPair(lon=start_point[0], lat=start_point[1])\n",
    "    end = CoordPair(lon=end_point[0], lat=end_point[1])\n",
    "\n",
    "    # Loop over each WRF file to accumulate cross-sections\n",
    "    for wrf_file in wrf_files:\n",
    "        ncfile = Dataset(wrf_file)\n",
    "\n",
    "        # Extract required variables\n",
    "        theta = getvar(ncfile, \"theta\")\n",
    "        #pressure = getvar(ncfile, \"pressure\")\n",
    "        height = getvar(ncfile, \"height_agl\")\n",
    "        #omega = getvar(ncfile, \"omega\")\n",
    "\n",
    "        window=50 # Assume you want a 100kmx100km (50x50 since resolution is 2km) box filter\n",
    "\n",
    "        # Apply spatial smoothing\n",
    "        smoothed_values = apply_spatial_filter(theta.values, size=(window, window))\n",
    "        theta_smoothed = xr.DataArray(\n",
    "            smoothed_values,\n",
    "            dims=theta.dims,\n",
    "            coords=theta.coords,\n",
    "            name=\"theta_smoothed\"\n",
    "        )\n",
    "\n",
    "        # Get theta perturbation (cold pools)\n",
    "        theta_perturbation = theta - theta_smoothed\n",
    "        \n",
    "        # Continue with the cross-section extraction as before\n",
    "        theta_cross = vertcross(theta_perturbation, height, wrfin=ncfile, start_point=start, end_point=end, latlon=True, meta=True)\n",
    "        #omega_cross = vertcross(omega, pressure, wrfin=ncfile, start_point=start, end_point=end, latlon=True, meta=True)\n",
    "\n",
    "        downscale_factor = 1  # Example: from 2km to 12km resolution\n",
    "        #omega_cross_downscaled = downscale_cross_xarray(omega_cross, downscale_factor)\n",
    "        theta_cross_downscaled = downscale_cross_xarray(theta_cross, downscale_factor)\n",
    "\n",
    "        #xy_loc_downscaled = omega_cross.coords[\"xy_loc\"][::downscale_factor]\n",
    "        #xy_loc_downscaled = xy_loc_downscaled[:omega_cross_downscaled.sizes[\"cross_line_idx\"]]\n",
    "        #omega_cross_downscaled = omega_cross_downscaled.assign_coords(xy_loc=xy_loc_downscaled)\n",
    "        \n",
    "        xy_loc_downscaled = theta_cross.coords[\"xy_loc\"][::downscale_factor]\n",
    "        xy_loc_downscaled = xy_loc_downscaled[:theta_cross_downscaled.sizes[\"cross_line_idx\"]]\n",
    "        theta_cross_downscaled = theta_cross_downscaled.assign_coords(xy_loc=xy_loc_downscaled)\n",
    "\n",
    "        #omega_cross = omega_cross_downscaled\n",
    "        theta_cross = theta_cross_downscaled\n",
    "\n",
    "        ########## Winds ###########\n",
    "        dx = end.lon - start.lon\n",
    "        dy = end.lat - start.lat\n",
    "        norm = np.sqrt(dx*dx + dy*dy)\n",
    "        ux = dx / norm\n",
    "        uy = dy / norm\n",
    "\n",
    "        levels = [30, 1000, 1500]\n",
    "        ua = getvar(ncfile, \"ua\")   \n",
    "        #ua = interplevel(ua, pressure, levels)\n",
    "        va = getvar(ncfile, \"va\")   \n",
    "        #va = interplevel(va, pressure, levels)\n",
    "        wa = getvar(ncfile, \"wa\")   \n",
    "        #wa = interplevel(wa, pressure, levels)\n",
    "\n",
    "        u10 = getvar(ncfile, \"U10\")\n",
    "        v10 = getvar(ncfile, \"V10\")\n",
    "\n",
    "        wind_along = ua * ux + va * uy   # dot product projection\n",
    "\n",
    "        wind_along_xs = vertcross(wind_along, height, wrfin=ncfile,\n",
    "                          start_point=start, end_point=end,\n",
    "                          latlon=True, meta=True, levels=levels)\n",
    "\n",
    "        w_xs = vertcross(wa, height, wrfin=ncfile,\n",
    "                        start_point=start, end_point=end,\n",
    "                        latlon=True, meta=True, levels=levels)\n",
    "\n",
    "\n",
    "\n",
    "        #print(omega_cross)\n",
    "\n",
    "        # Accumulate the cross-sections\n",
    "        if omega_accum is None:\n",
    "            #omega_accum = np.zeros_like(to_np(omega_cross))\n",
    "            theta_accum = np.zeros_like(to_np(theta_cross))\n",
    "        \n",
    "        #omega_accum += to_np(omega_cross)\n",
    "        theta_accum += to_np(theta_cross)\n",
    "\n",
    "    # Calculate the mean by dividing the accumulators by the number of files\n",
    "    #omega_mean = omega_accum / num_files\n",
    "    theta_mean = theta_accum / num_files\n",
    "\n",
    "    # Downscale the cross-sections\n",
    "    #downscale_factor = 6  # E.g., from 2km to 12km\n",
    "    #omega_mean = downscale_cross_section(omega_mean, downscale_factor)\n",
    "    #theta_mean = downscale_cross_section(theta_mean, downscale_factor)\n",
    "\n",
    "    #print(theta_cross)\n",
    "\n",
    "    # Extract pressure levels and lat/lon coordinates for plotting\n",
    "    pressure_cross = to_np(theta_cross.coords[\"vertical\"])  # Pressure levels\n",
    "    cross_lats = np.array([point.lat for point in to_np(theta_cross.coords[\"xy_loc\"])])\n",
    "    cross_lons = np.array([point.lon for point in to_np(theta_cross.coords[\"xy_loc\"])])\n",
    "    \n",
    "\n",
    "    # Update horizontal labels to match the downscaled resolution\n",
    "    #cross_lats = cross_lats[:omega_mean.shape[1]]\n",
    "    #cross_lons = cross_lons[:omega_mean.shape[1]]\n",
    "    \n",
    "    # Combine lat/lon for axis labels\n",
    "    cross_coords = [\"{:.2f}°N,\\n{:.2f}°W\".format(lat, lon * -1) for lat, lon in zip(cross_lats, cross_lons)]\n",
    "    coord_interval = len(cross_coords) // 6  # Show roughly 10 coordinate labels\n",
    "    \n",
    "    #cross_coords = cross_coords[:omega_mean.shape[1]]\n",
    "\n",
    "    # Create the cross-section plot\n",
    "    fig, ax = plt.subplots(figsize=(12, 6))\n",
    "\n",
    "    #print(pressure_cross)\n",
    "    '''\n",
    "    cf = ax.contourf(\n",
    "        range(len(cross_coords)),\n",
    "        pressure_cross,\n",
    "        omega_mean,\n",
    "        levels=clevs3,\n",
    "        cmap=cmap5,\n",
    "        norm=norm5,\n",
    "        extend=\"both\"\n",
    "    )\n",
    "\n",
    "    cbar = fig.colorbar(cf, ax=ax, orientation=\"vertical\", pad=0.02, label=\"Omega (Pa/s)\", extend='both')\n",
    "    cbar.set_ticks(clevs3)\n",
    "    '''\n",
    "\n",
    "    cf = ax.contourf(\n",
    "        range(len(cross_coords)),\n",
    "        pressure_cross,\n",
    "        theta_mean,\n",
    "        levels=clevs3,\n",
    "        cmap=cmap5,\n",
    "        norm=norm5,\n",
    "        extend=\"both\"\n",
    "    )\n",
    "\n",
    "    cbar = fig.colorbar(cf, ax=ax, orientation=\"vertical\", pad=0.02, label=\"θ' (K)\", extend='both')\n",
    "    cbar.set_ticks(clevs3)\n",
    "\n",
    "    '''\n",
    "    # Overlay potential temperature contours\n",
    "    theta_contours = ax.contour(\n",
    "        range(len(cross_coords)),\n",
    "        pressure_cross,\n",
    "        theta_mean,\n",
    "        #levels=np.arange(300, 400, 5),\n",
    "        levels=np.arange(-2, 2.1, 0.5),\n",
    "        colors=\"black\",\n",
    "        linestyles='--',\n",
    "        linewidths=1.5,\n",
    "    )\n",
    "    ax.clabel(theta_contours, inline=True, fontsize=8, fmt=\"%d\")\n",
    "    '''\n",
    "\n",
    "    # quiver typically likes X horizontal, Y vertical arrays\n",
    "    X = np.arange(wind_along_xs.shape[1])\n",
    "    Y = levels\n",
    "\n",
    "    skip=4\n",
    "    Q = ax.quiver(\n",
    "        X[::skip],\n",
    "        Y[::skip],\n",
    "        wind_along_xs[::skip, ::skip],\n",
    "        w_xs[::skip, ::skip],\n",
    "        scale=450,          # smaller = longer arrows\n",
    "        scale_units=\"width\",   # consistent scaling\n",
    "        width=0.003,        # thin\n",
    "        headwidth=5,        # optional: smaller arrowheads\n",
    "        headlength=5,       # optional: smaller arrowheads\n",
    "    )\n",
    "\n",
    "\n",
    "    # Add letters A and B to the bottom corners of the plot\n",
    "    ax.text(2, 100, \"A\", fontsize=14, fontweight=\"bold\", ha=\"center\", va=\"center\", color=\"black\")\n",
    "    ax.text(len(cross_coords)-2, 100, \"B\", fontsize=14, fontweight=\"bold\", ha=\"center\", va=\"center\", color=\"black\")\n",
    "    \n",
    "    \n",
    "    # Adjust the y-axis to represent pressure\n",
    "    #ax.set_yscale(\"log\")\n",
    "    #ax.set_ylim(1000, 800)  # Pressure from surface (1000 hPa) to 100 hPa\n",
    "    ax.set_ylim(0, 2500)\n",
    "    #ax.set_ylabel(\"Pressure (hPa)\")\n",
    "    ax.set_ylabel(\"Height AGL (m)\")\n",
    "    ax.set_xlabel(\"Latitude, Longitude\")\n",
    "    ax.set_xticks(range(0, len(cross_coords), coord_interval))\n",
    "    ax.set_xticklabels(cross_coords[::coord_interval])\n",
    "    #ax.set_title(f'Cross-Section of Mean Omega and Potential Temperature from {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}')\n",
    "    ax.set_title(f\"Cross-Section of θ' at {start_time.strftime('%Y-%m-%d %Hz')} ({sim})\")\n",
    "    \n",
    "    # Create inset map anchored to upper-right of ax\n",
    "    inset_ax = inset_axes(\n",
    "        ax,\n",
    "        width=\"30%\",        # relative size of inset\n",
    "        height=\"30%\",       # relative size of inset\n",
    "        loc=\"upper right\",  # anchor\n",
    "        axes_class=GeoAxes,\n",
    "        axes_kwargs=dict(projection=ccrs.PlateCarree())\n",
    "    )\n",
    "    inset_ax.add_feature(cfeature.COASTLINE)\n",
    "    inset_ax.add_feature(cfeature.BORDERS, linestyle=\":\")\n",
    "    inset_ax.add_feature(cfeature.STATES, edgecolor=\"gray\")  # Add state boundaries\n",
    "    inset_ax.set_extent([cross_lons.min()-2, cross_lons.max()+2, cross_lats.min()-2, cross_lats.max()+2], crs=ccrs.PlateCarree())\n",
    "\n",
    "    lons = cpi.XLONG\n",
    "    lats = cpi.XLAT\n",
    "    inset_ax.pcolormesh(lons, lats, cpi[0,:,:], cmap='plasma', transform=ccrs.PlateCarree())\n",
    "    inset_ax.plot([start.lon, end.lon], [start.lat, end.lat], color=\"blue\", transform=ccrs.PlateCarree(), lw=2)\n",
    "    inset_ax.scatter([start.lon, end.lon], [start.lat, end.lat], color=\"blue\", transform=ccrs.PlateCarree())\n",
    "\n",
    "    # Add letters A and B to the minimap\n",
    "    inset_ax.text(start.lon+0.4, start.lat-0.5, \"A\", fontsize=10, fontweight=\"bold\", ha=\"right\", color=\"black\", transform=ccrs.PlateCarree())\n",
    "    inset_ax.text(end.lon+0.2, end.lat-0.5, \"B\", fontsize=10, fontweight=\"bold\", ha=\"left\", color=\"black\", transform=ccrs.PlateCarree())\n",
    "\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "# Inputs for cross section\n",
    "directory = '/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/future/3hr'\n",
    "start_time = datetime(2017, 6, 22, 12, 0)  # Start time: Year, month, day, hour, minute\n",
    "end_time = datetime(2017, 6, 22, 12, 0)   # End time: Year, month, day, hour, minute\n",
    "#start_point = (-94.4,29.5)  # Example start point (latitude, longitude)\n",
    "#end_point = (-95.2,28.1)   # Example end point (latitude, longitude)\n",
    "#start_point = (-94.4,29.8)  # Example start point (latitude, longitude)\n",
    "#end_point = (-95.2,28.4)   # Example end point (latitude, longitude)\n",
    "start_point = (-94.6,30.3)  # Example start point (latitude, longitude)\n",
    "end_point = (-95.2,28.7)   # Example end point (latitude, longitude)\n",
    "\n",
    "# Cold pool intensity data for minimap\n",
    "cpi = xr.open_dataarray('/pscratch/sd/d/dbrooks/acc2017_analysis/TS_Cindy/future_cpi.nc')\n",
    "cpi = cpi.sel(Time=slice(start_time, end_time))\n",
    "\n",
    "plot_cross_section(directory, start_point, end_point, start_time, end_time, cpi, sim='Future')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8EAAAIxCAYAAABtrbqtAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA8VlJREFUeJzs3Qd4U+X3B/BvRgelg1Gg7KGCyFAEFXCAoiAKDhwgw4UoIigiDlzgnj/EPVGUIfwduFARBwiCMhSZIipT2at0t0n+z3lLQpKmbZJm3PH9PM+FNrlNbm7WPfec97wWl8vlAhEREREREZEJWOO9AURERERERESxwiCYiIiIiIiITINBMBEREREREZkGg2AiIiIiIiIyDQbBREREREREZBoMgomIiIiIiMg0GAQTERERERGRaTAIJiIiIiIiItNgEExERERERESmwSCYSIdWrVqF6667Ds2bN0dycjJSU1Nx8skn4+mnn8b+/fuhJ3PnzkXPnj3RoEEDJCUlqf+7d++OJ598Mmr3+eWXX2LChAkBr2vWrBmuvfZaaNlvv/2Gbt26ISMjAxaLBZMmTSp3XZfLhWeffRYtWrRQr5UTTzwRs2bNCvi4y9sn4XjllVcwZcqUoNbNzs7GY489pp73rKws9Xpu164dnnrqKRQUFJRZv7i4GA899JDaZnnNHH/88XjxxRfLrLd27VqMGDECXbp0QfXq1dW+mj9/fpn15DK5rrxl+PDhQT2OYLfL/by88847OPXUU9W2paenq/fwp59+GtH9tWLFCtxyyy3q+rS0NNSrVw/nnnsuvv/++6Ae0+HDh3HXXXep92idOnXU/gj0OnE4HJg4cSLOP/98NGrUCCkpKWjdujXuueceHDx4EJH0999/q/27ZMkSz2Xyni3v+fviiy8i9vmgB/L669OnT8Drli9frvZJsO9NeY21bdsW8fDdd9+p1/a///4bl/snImNjEEykM2+++SY6duyIZcuW4c4778TXX3+N2bNn44orrsBrr72GoUOHQi9ke+WgWQKAl156SQXEciAvB88ffvhh1O5XDnIlWAlE9uUDDzwALbv++uuxY8cOzJw5UwUCAwYMKHfd++67Tx3Qjx49Wu1f2d9XXXUVZsyYEdVtDCUI3rp1qwrkJQh844038Nlnn+Hyyy9X2y0H8xIwepPA9oknnlDBnTymSy+9FLfddhsef/zxMgf8n3zyCWrVqoUePXqUe/9yv7If/Zerr75aXS+3H4xgt0vcfPPNapHtksf7wQcfYODAgcjLy4vo/nr//fexdOlS9ZqRAPutt95SAaTc73vvvVfpfe3bt0/dR2FhIS655JJy18vPz1f337RpU7Vt8h4bNmyY+tvTTz9dXR8pY8eOxXnnnadObnirVq1awOfxjDPOiNjnA8WOvEblJNG9997L3U5EkeciIt1YvHixy2azuc4//3xXQUFBmesLCwtdn376aYW3kZeX59KKJk2auM4666yA1zkcjqjd7y233CJRgkuv7Ha76+abb650vX/++Uet+/LLL/tcPnz4cFfdunXV68WtadOmrvHjx0dsG9u0aePq1q1bUOvm5OSoxd8zzzyjnqeFCxd6LluzZo3LYrG4Hn/8cZ91hw0b5qpWrZpr3759AV9DH3zwgbqtH374IahtcjqdrhYtWqj9EsxrMZTtmj17ttqWWbNmucIRyv7atWtXmfVKSkpc7du3dx1zzDFB7QdZxJ49e9TtB3qdyG3u3bu3zOXu/T516lRXJKxbt07d3tdff+1z+TXXXOOqXr26pj8fcnNzq3wbsl3vvPNOhevIa/bCCy8MeN2yZcuCug33tsp7WN7L8fLhhx+q77ytW7fGbRuIyJiYCSbSEckoSSmbZFckm+MvMTERF110UZmyuI8//hgdOnRQ5bDuDMeaNWtw8cUXo2bNmuryk046Ce+++67P7TmdTjz66KNo1aqVyrLUqFED7du3x/PPP+9ZZ8+ePbjxxhvRuHFjtU1SMimZn2+//TaoLFP9+vUDXme1+n48yfGfZBdlO2VbZLsl+/XPP/+U+VvJjksWQcqF3WWZkqFzl02+/PLL6mfvksnNmzeXWw4tmbfBgwejbt266jHK7f3vf/9T+8dN/l5uR0qPpSxUStWllE+yVT///DOCUdlzIplVuY+SkhK8+uqrnm0vz0cffaTKVGXbvcnvu3fvDrok1pu8fk477TSVXXWX8E6ePNkn+yj7UEqRFyxY4NlGuaw8Ug4siz/JAolt27Z5LpPMrtyXDAfwJr9LtlGe+/JeQ6H44Ycf1GtLbjeY2wllu+T9I/vjyiuvDGvbQtlf8pr1Z7PZVDWJ93rlqew15n2btWvXDmqbpMS2vNLlyqoH5HUvJeCSCQ6Fu+Tdvxze/b51329Fnw/+63rzLxOXn+WyX3/9VX1OyXv6mGOOCfmzLBbkMctn1erVq1XZu5TN+1dOLFy4EJ07d1bb27BhQ1UtI58toX42eH8vyXtC1pHblKEDb7/9dplt69u3r9o2qYAiIooke0RvjYiiRg44JGiRg1cJOIMlB2Hr16/H/fffrwIzOXjesGEDunbtqg6QX3jhBXXwOm3aNHUwtGvXLjUGUMgYYzmYk78966yz1JjHP/74w2eM35AhQ9R9yBjFli1bquvkdwlwKyMBogRqch9SOipjz+RgOpCbbrpJHXzeeuutqmRaxj4//PDD6nH8/vvvaqyjkIMuKcOUMbNSbi2P8c8//1QBppCDt9zcXFVu7T2msLxgXIJ8uY+ioiI88sgj6gBOxhhKSaaMTZSDWW9yAC0HdO5xunJ/F1xwATZt2qSC8vIE85xceOGFaptlv8lB8x133FHp2OEmTZqoEwESOLu5x/itXLlSlUcL90mAysh68lzI7QoJ8EeNGqXG7T344IOeknLZPnm87v0T6KRNZdxBeps2bTyXyfMoJ1okEPImJ2fc10eCvI4k+PUPassT7HbJ8yDPobwm5GSJBMTbt29XZcRSTi3PaTBBZ7D7KxDZBglqKlsvEgJtk7wmZFyzN3mfyIkHOeFWkTlz5qjPovJOTHi/zoXsy/I+UwKp6PNBhiCEql+/fmq4gowrl9sN5bMsluTzTU6gyrbJOG7v/bhz5071GORy2U55DuTk6IEDB9QwllA+G9zkccprXW5THq+U6ctQnmOPPVY9v94ndmW/yH3KfRMRRUy8U9FEFJydO3eqMrYBAwYEvcukLE5KyTZs2OBzudxGUlJSmRKz3r17u1JSUlwHDx5Uv/fp08d10kknVXgfqamprtGjR4f1NP7111+utm3bqscli5SN9ujRw/XSSy+5ioqKPOstWbJEXf+///3P5++3bdum/uauu+5Svx8+fNiVnp7uOuOMMzwlnKGWO8o+k9JKt3vuuUet+8svv/isJ+XIUv7q3rebNm1S67Vr106VhrotXbpUXf7+++9XuC+CfU6E3J48hsqcd955nn0baBkzZoyrKqRMuLi42PXwww+7ateu7bPPQymHDuT3339Xz+2ll15a5jG1atUq4N8kJia6brzxxoDXhVIOfeDAAVdycrKrV69eQW9vsNu1Y8cOtR3yOm3UqJHr3XffdX333XeqRF0uv/fee12R3F+B3Hfffeq+Pvnkk5Duo6Jy6EC2b9/uqlevnqtTp04VlpS7y7jfeOONCm9PSrtlvSeffLLMdfKeDfQaP/3009X18rwHev7d71vv8uDyPh8Crevmv1/kZ7nswQcf9Fkv2M8y7/eX9yJ/O3nyZJ/LvD9vwimHdu+7t99+u8z68h6W6/yH2UiZv9VqdW3ZsiXkzwbZPnl/ef9tfn6+q1atWq6bbrop4OtV7ivQEAAionCxHJrI4CQTJRla/+yMlLv5Z5Ql6yiNedwZEClllDP2kqGSRj/+2Rv3OpLVkMyAnPmXbLE3OT6UrIL34iblgXL7UjYrpXTStVYafo0cOVJlO92dbiXzKhkdKeP1vh3Jukm3Y3eJ4+LFi9U2yvaGm03zJ/vqhBNO8JR1eu8reWz+JcWSrfXOPLkzgVu2bKn0foJ5TkIlmWvZp96Luzw7nH0k2ynPk2R55XEmJCSoLI9k/qXEOhIkoyTlkrIvJEPkr6LtjsTzPn36dPXau+GGG8pc5/9a9i71DGa73CX08jqVZljSfOucc85RZb7SeEqywzk5OZ7qD+/78i6/D2V/eZPrpWpDsnBSeh8tkt2UbLfsH+lGXl7mVhp3SZWDVJtIBUdF/vvvv3JLvIWU1fq/1iWjH0+XXXaZz+/BfpYJyXzK+8t7EZIx9b7MXWYd6W11k/Jo72E2Qpq4yevxxx9/DOuzQUrB3RljIcM/5Hsq0OekPN9yX5KRJiKKFAbBRDqRmZmpylqlrDYUgcp8yxuLK9MTua8X48aNU2NcJWjq3bu3KtGVQE267rrJAe4111yjDq4lcJXxYHJg7z5gkTGtgQ7k3OTgWMrf5GBJutzKgW7//v3V1C7uMWJSDiwH01I2539bsm179+71lC4LmaIlUoLdV27+4yLdZcCVdccN9X6CIeW5coDdqVMnn0VKDt2vqVBIl2EZMyhkjN5PP/2kAg3pQC0i0QFYDoLPPvts2O12NUWKvJ7892+gfSGlplLS6b9+OCRwkn3nHyRKsOn/+pMTOKFsl4z/lCBIxkzKGEtv8h6T4HvdunXqd3mved+XdHgOdX95kymZpFxVxvA/88wziBYpk5Uxu1IGO2/ePDU9VyBS/iwneeTzQoYaVMb9+pKAKRD5LPF/rVdWXh1t/u/pYD/LhDxP/kG9GD9+vM9ln3/+uc99yGvBf7yum/skpP/nsHy3yGsykEDl2e6yf/drPtTPhkDjx+WzMtBniPv5jmSHcSIijgkm0gk5sy4HxV999ZUaQxhsoBcoOyUHIIHGt7kzLe7gSA6mxowZoxYZ6yvNrmS6il69eqlGN3LgJOvK+FdZpIGUBLIyzkvO/EvjE2ls4j54C4aMWZbgW4Jr9zhKuQ95HDKOMdDYUvdlErgI2T+REuy+0uL9SNMZmUZJ5nqVbI6bNK0S0iwtFHJbcvAs2SzvQESaQkWCBHTSNEmCBMmIBXqNy3y3sh1yksV7/K009RFVndNUxlHLIplS/0BBTkj4v5bdQVaw2yXZyuOOOy5gVsudVXZnTV9//XX13Ln5vwaC2V/eAbBktuWElYyVj1SlRKAAWLKBcrJOgnJ3JUSguc4l8y1j94NteuR+/OHMhe5+vcpUT968g85wb6OiE1T++znYzzL36819Esy/ukMC/PJI0Fre3Lruy/0D24peDxK4+3O/ft3BbDQ/G9zPd6Q+a4mIBDPBRDoiwaEc8ErZoGSX/Ekpsn9WIBAJpqV0zR1gucm8oRLY+meohHSGlmZHMgeqHJQEaqQk5W1SyixZIGmO5T5I8s/OuJXXaEYaeQn3AaB77lM5gPO/LVkkABHSQEVK8eQg378jaTjZWfe+ksyc+/F47ys5cJQsXCSE85wEU94oAdXUqVPLZDrlIDjUbZfHKydGvMu9ZR/6335FWZ3yyAkUCejcDeCkUVQgkp2V7fDvZC4l+RJguht9hctdPhtovm1p0uP/2nOfXAhlu+R5kXJoKd/3n59WOuG6m0hJgO19X94dtoPdX+5tkABYSnClYiPaAbB0Of7mm2/KPcki2y5Zb8kQS2M8/5MN5ZHHKPtSGtKFyr3vJPj2Jiftgv18kPeMBHj+tyHzLwcr2M+yqpDnQE4guisKvP3f//2feo1JF+dgyYkY//0k84y7q3hC/WwIlbye5HskHg3DiMi4mAkm0hEpN5axgzLmVbpE33zzzeqAWYJfyV7J1EmScZLsa0WknE7O2EsQJGXIUkIp4yClA6d0hHZ3MZbbkduTgzPJskrmSTK+cjAq2axDhw6p25DxYdIRWQICyZRJBli6olZGtl2CPzkglnFtUgr6yy+/qOmH5IDHHYjIlEtSGiideqUUWw68JGMsQfSiRYvUgaPsCzm4k7+VA345EJSTBXI7f/31lxp77O5k6j7QlM6sct9y4CYZKwly/N1+++0qEJWxvjJGTx677CfpcCv36T/eOlzBPiehHvjfeeedqpO17Ft5zcgBuzweue1Aj7cisg9kzKo83/J8SAZMyuUDZbTcmVHJ6EuwI8FDeQf4UjUgj1ueTwlC5XfvMYSS4XRnOeU1I68L2V/yvJ1yyikq4JLXvoxL9y4HlrHUElgK9zhoKV+W7J+8fuS59yb7SA7u5WSKTIMVilC2S54P2f9XXHGFKgOWxybdiCXQkP0pgV5FQtlfMu5YtkvGYEoptJStepNAtbLO3VJ9ImXd7qy0BFeyvULG/cpJGgl4pEJEPofkM0LKbr2nBpPPD/fYVdnvUlki70d3VYKbrOOu6PAnr9dQphzzJtl5+UyQqdKkJF3ex5Kplunj/FX0+SAnEmSYhmynjOGV/SmvmWAF+1lWFbfddpt6j8tJEqnckduUExTyXpTnTd7D3pUhlZEAVLZJTl7I5528pyR7L5e5x/WG8tkQKnm+pWIgWidviMikwm6pRURxs3LlStXRs0mTJqrzbPXq1V0dOnRQnUh3794dVJfQ1atXu/r27evKyMhQt3HiiSeW6XoqHUy7du3qyszMVOvI/Q0dOtS1efNmdX1BQYHqatu+fXvV7Va6m0qHXOmMmpubW+njeP311139+vVztWjRQnVAlvs45phj1G1Kt1R/0r30tNNOU49X7kvWvfrqq13Lly/3We/LL79UXU1lPbndE044wfXUU095ri8sLHTdcMMNrjp16qgOz/JRKJ1fA3WHFtLFdODAgarLaUJCgnqM0tHWu+Otu3OsXO4v2I66wTwnoXSHFrKNTz/9tKtZs2bqNqUbd2Wdqisiz4E8fulkLc/bE088obrVeu9DIa+Rnj17utLS0tR1sl/L4+7cW97iv++kc7hc5n79t2zZ0vXCCy+UuV33cxJoCbQ906dPL7dLbjCC3S4hXcClI3jNmjXVuvIeCvZ+Q9lf5XVNdi/ez1l5ZF9V9vcV7WtZvN9TFa0X6PXuTV5r0vH+v//+87lcbl/e7xWRztyXX3656kIs77HBgwerzw7/+63o8+HQoUPqOul6Lfcn71d5rZfXHVo6agcS7GeZv2D2kXs2AelgL69Fu92u3ofSNV+6pPuraN/J56h0ep8/f77q8i3v+/r166su5tL9OZzPhvK+l+S+/DvKywwC8vcfffRRpY+ZiCgUFvkn3oE4ERERUWUkWy/ZRxmzfffdd3OHGZzM2yxZbSmBl3JrIqJI4ZhgIiIi0gUpq5fp1KT0Vkq0ybikZP7ll1/G448/zgCYiCKOp9WIiIhIN2TMqQRI0jApEo2kSJukw7g0g5RxxkREkcZyaCIiIiIiIjKNuJZDS5dG6aApXQrr1q2r5gzcsGGDzzrXXnut6gjovfhPFSJz9o0aNUrNISddFi+66KIy84RKZ8QhQ4aoDquyyM9yJpmIiIiIiIjMI65BsExVIXOOSvv7efPmqSkVevbsWWacj8yvKNMHuBf3lBduo0ePxuzZs9V0HDLFQE5OjpqLT+ZPdJNympUrV6qpW2SRnyUQJiIiIiIiIvPQVDn0nj17VEZYgmP3BOySCZaM7SeffBLwb2SeUplTUCZk79+/v7rsv//+Q+PGjVWwLPMWrl+/HieccIIKtt0TxMvPMt/gH3/8gVatWsXwURIREREREVG8aKoxlgS0olatWj6Xz58/XwXHNWrUUBOmP/bYY+p3sWLFChQXF6sMsluDBg3Qtm1bLF68WAXBS5YsUSXQ7gBYSEm1XCbrBAqCpcRaFjen04n9+/erSeM5YTsRERERkblI7vDw4cMq1rBaY1NQKzFIB5sNLQDM1k7uUvfsWnpRjRkzBmeccYYKYN169+6NK664Ak2bNlWdAmXOuHPOOUcFv0lJSdi5cycSExNRs2ZNn9urV6+euk7I/+6g2Ztc5l4n0HhlmYaBiIiIiIjIbdu2bWjUqFFMdsisWbMgHZP+BFRCzj9ZSDoPgkeOHIlVq1apMb3e3CXOQoLjTp06qYB4zpw56NevX4VBtXfGNlD21n8db9KWX4Jy7yx1kyZNMLlxE6RE8MzP2i2bI3ZbRNHSpmkzz8+nXXasz3U122RGdcdb2/veX3mcq/6K7P20vFP99+2/uwKuf27Dej6/l7eeHvg8lj+fiep+jodgX0PREs4+O7B2b6XvL//HVdn9hLQfjrz+wxGJ98J335V9LD16xPd5jIRoPi7/z6QyKnlvR/I1oafPw0r3W2WC3a/l7L9g91Wg105FwnldRf01ZADZOYVofPYzqqlvLEhV6oiBA3EhgFUALqpdG4uYDTZOECydnT/77DP8+OOPlZ5VqV+/vgqCN27cqH7PyspCUVGR6v7snQ3evXs3unbt6lln165dAccgS8Y4EMkyy+JPAuBIBsHJEbsloujxfs2nJSX4XJeekhjVXW9NDe5d4qzidpS5n/R09V/17Lwy6/ZqlFXmskDr6UX6kceqVLK/q7qfY816Ust4b0JY+6zkyPusoveX/2u2svsJ9r1Uesder4kQVfW9MHfun0iqVr3s7cbooDOaovm4fN7HgYTy/Ae+g6BX1dPnYaX7rSJ/PBb8fi3nfoLdV4FeOxUJ53UV9deQgcRqaOQlyckqVjhJhnsCeO3IHNrNmzePyf0bWVy7Q0smVjLAH3/8Mb7//vugntB9+/apEgQJhkXHjh2RkJCguku7SQfpNWvWeIJgaYAlmdylS5d61vnll1/UZe514qVdc6nwJyKtBjDBChQY69Lx98V7C4hMRYJ+IiJ/Uvo8X44vjgRscpTRDsDFLRg76D4IlumRpk2bhhkzZqiyAhmfK0t+fr66XqY6Gjt2rGpstXnzZtUgq2/fvmo+4EsvvVStI82thg4dijvuuAPfffcdfvvtNwwePBjt2rXDueeeq9Zp3bq1mmZp2LBhqiu0LPKzTKPEztBExqCngJnMw7kydgEO3wNEMSRZYDMx2+PVACl9lvrY47wuk8jmDwDLli2L45YZQ1zLoV999VX1f/fu3X0uf+edd9TUSDabDatXr8Z7772npkmS7O/ZZ5+tBoh71+I/99xzsNvtuPLKK1UA3aNHD0yZMkX9vdv06dNx6623erpIX3TRRXjppZdi9liJiIiCsX/VHt3uqLnbd0YtKyrX9erFk116UlRQoGbw0LLs7JTw/jCnINQ7Cnhx7uHDER8PHOzthrQvvB5vYoINyX5DoyiypOT5FwA3+V2eIRWuAK489VT843Ryxhq9BsGVTVFcrVo1zJ07t9LbSU5OxosvvqiW8kgnNck6E5E+aDWrZZiyZzIVrb6fKMZDHWKYzZMA+MYzu5Q7C4f5PBrTe3sliredlZmKTd/ewUA4ii5p0UKVPpcO/vR1FoCJAL744gtVIUs6boxFRERERPrnrgaQDLAEwNLHpbyGS83qTMKpxfVwRrIN9WrnoWaNw9iyPRNrDybi48StSIAVf++5zbP+MXWeh81lxZ97R1VpGwfVmIUUlwVWWFACF+wobXL0+qEryqw7LuMjPHHoMsTKU089pabwvO6666BF2dnZaNy4MYqKHQyCo2T58uVYD2B0OddLo6xzAAy96CL8V1ysqmEpdNxrGiDNsVZv+ifem0FEEcgSV7UcNB5km42Y4Wb2U1/YIMqYJACWJTP5aewtuEtd1iDpf+r/BEs11Ec6/su3om6hHXkHUvDPwTT8lLALBwvH4+TE1zwB9KkJryPBmgKH1Ykume9hbdHIsLfpc+cwXGqbinrORNS1AXsdQLbFETBYdyGlah2kQyTVjVIJGcv7JO2QKtkrTjlFlTxL6XN5TgGwBMBlCQn4lFMm6a8xFhFRJIMXswU9ErgaMXglY4wPjgYGyvo00DoDaa6jU3hJBlZcXtgEeXCiCC7sPJCM3/9Lw8uu/thQdKu6/tei4er/i21TsbT4JhRZHNhVcGeVAmC32Y4heM3VHzscLhTDhZ8Sdgdc7xVXfxh1+h3Snjlz5mD3kZLnikjXI+ly9P2RRsIUOgbBRERBYsAZegDnXig24nkiSI9VEEai5f0/wzkQiS4rmiQ9p353wqUC4UL1P1AdFuwpseBnW+DmUbus+Sp77M4kh+qchLfROvFo35gL7O/iOuv76uc3XQNQ02LBpsLyik+JYqOkpATX9+2rSp2DmZH5BOl5JM1+DTCHejwwCCYi0mHgG9XtisJcwQyEuZ8qYvYMrxkefy1XNTXGt3nSJNhhVUHw14n/qetSrcCLrv74qXhYmb/rbZ+igub/Cu8I+76/L74e64uOjiPu4ErGialOTEydgUcTZyLV5sIIyywYlfcJANKuyxMS4ATQKcj1pV7gfAA/AdixY0eUt854OCaYiDRF7yXNeh0XHAsSCNdqXyfem0FEMTQ64yMsSMyG0+pCTVcyqrvsSHXZ8aftEE4sqY3qLhsec5ZfcvxVybU4KbF0Ss1IecwR+xLneNppzYv3JlAlpKT5OwB9QwzOmhyZR/iiBg2wjGODQ8IgmIiIYsadEWYwTGQOhXCiEA5sLxzjuaxR0kScX9QADW0W/GkpqfDvJQDeYg1cJm1U5Y0Jrpf8DLKc1XEFamFLcWkpdzAOFNwd4S2kSLs4LU2VNkuJc6jOA/ASgHXr1uGEE8K5BXNiObSGOkQTmV0kssDRyiRrqSw6GtsS6+w1y6NjR+vVFaGWApuhdNhIttkKfAJgIb+nw4Jqdifedw6q8O9l+iLbkUZaZtYm8SUkuGzIthRhb7EFm2z56vLTE95Uyw2WmfHeRAqTTCW26Ehpcziv9MwjJdT92rThcxACBsFEFDZDZ/P+eCzeW2B40QyEtR74EZnlM/Ev6yGf32WqJFnqJDpxuLjyw9DlRcPhgMs041pLimVUaKl2iS97fpaO2HLyQPbFjwkHsNdaoLLkf9kOYoPtAN4KMitM2tO3fn1V0iylzeE6G8BmAPPnz4/glhkbg2AiqhCrFLRFSxnpSGBG2Bj7guPgqTy1Xb59bqXD83VFTWG1Bj82V8p5vRtbGdGVtumqi7U9wYpVv+xSnbQPWYpUIzFvaa4E7LXk45ClUP1f35mKhs5UdZ100JaS6UAkW0zaIyXMK4+UNFdF9SPTKg06+2w4nUdPpFD5GAQTkSYYKXNntECV9MVI7yXSv32WgjKBWaIFOFzEQ1DvADjRZVFdrCUT7IILmUe6aUvm15tkhLcW3u6Z0mm/pQA7rbkquy4dtDOd1WL0zFIkSAlzpyMlzVXVVRpsAZg5M7TS+CeeeAKnnHIK0tLSULduXVxyySXYsGFDpX+3YMECdOzYEcnJyWjRogVee+016Ak/gYjIcCIdBGglqC1vO6KyfeVMkxTsvtVzVpNiJ9zxvUYcFxyJx6TVjPyugjs9P0tAnJ7oxC5nZEucJQuaXu1J6EG3hMnonjBZTf/Uyz4F/+cYhGnOgeo6yQQn2i34tWi4aigmIbE8tkCkPFoCYtm/kmGXccPlqeVMitrjofBI6fLmI6XMkZAA4FwAtwwahMLCwqD/bsGCBbjlllvw888/Y968eWq+4p49eyI3N7fcv9m0aRMuuOACnHnmmfjtt99w77334tZbb8VHH30EvWB3aCIiiitOnURkXH/sHVnmMqvFhRxLZEs2Zd7h7Px7wv77c+3v4NuS6xBNTya/jzmOXBy0FCLLmaLmhJWmXxfY38VeSwGWFt+ksnHOrEO4bsgjaOCsq8qeNxTdis4Jb6h1A82l7PafNReJsKoTDZJBlsDY7XPH1eX+nQTic0uujfjjpfJJyfLgs89WJcxSyhwpJwFYDOCS5GR8FeSUSV9//bXP7++8847KCK9YsQJnnSVbWJZkfZs0aYJJk0rL9Vu3bo3ly5fj2WefxWWXXQY9YCZYQzj2ksyK5ZtERMYnmdqbSppgf4ENh60O2GFVzZ9aJb5QpdstbxxsKKIdAIt7Cq5S3Z2ruxJw2FKMv2yHsN52AGts+7HdmoOayU9h5MiRqF+/Ppod68SIN5OwYv/1KsN72FJUYQAsgWwjZ6qaQklKor0D4EDcTbf62N9DoqtsOFDV54Qq9tNPP+HAkRLmSJJnsofcPoDs7GyfJdjs8KFDpc3satWSSZsCW7JkicoWe+vVq5cKhIuLi6EHzAQTEelALEqypZQyXqXfRswGO1car2Q3kiW4Rixppop5Z2qvt8zEFyW3RGSXydRBUjZckdsss/C8K7hGXJEmZc8lcGGPtQDVXDLpkwXFFgeK4UQJnGosr7err74a7777LrZs2YIXXngBidWroyjXpsrH3Q3CJIhdXXR0/x06ElxvtR5GA1d1nJrwusosl0f+Vq1TUv46nRJfU925KfLy8vJQOyEBJzdqHPHbTisqxEf79iEjI8Pn8vHjx2PChAkV/q3L5cKYMWNwxhlnoG3bthVO61SvXj2fy+R3KaXeu3evOpGjdQyCiYiiQIJJrY7PMzo9VhZEawy1HvcFmcPbEZrS5zz7O1JTXKF7rPELgCWQTLDYkK6yv0VYWXRbpX8jjYZuuukmrF27Fh9++CFufqoabrzxRp91dlh9x2v+XHyj6iRdHQmo66yGpADZXe+scV1nEpY6yw+ApQSb9EteQ7t27fK5LCmp8nHhI0eOxKpVq7BokcxcXDGLxVImgA50uVaxHJqI4ipaB+lGOvjXSmMu0g8jvf6JKtLImYxbUB9FFke566yxFqKv7b247EjJpBZaHCpTG6o2bdqgWbNm2LFjhxqf6S1QubN0jJaxxtJdutjiwuW2aT7XS+ZXFhlbnG0pCePRkJ6kp6f7LJUFwaNGjcJnn32GH374AY0aNapw3aysLJUN9rZ7927Y7XbUrl0besBMMBERaYIRS6KJKLrecV6l/h9XwTo1nQnIrSBIjjZpbgULVPlzqK666io8/fTTmD5tjpqOpjK5Fimwdqlu0MV+JeIVlUeTeblcLhUAz549W3Wsbt68eaV/06VLF3z++ec+l33zzTfo1KkTEhKkT7X2MROsMWZtjiWP26yPXU+6DmgV700wnbhmgcuZJomoqjgemGJJOiXH4oD39IQ3y1wmJcp/F96mFpnOKFgy72+jpIlolvYidu1wokZNICdHZoGtmEytlG9xYK+1EPuthRVOm0QkZHqkadOmYcaMGao7uWR4ZcnPz4fbuHHj1Fh1t+HDh6sx6zJ+eP369Xj77bcxefJkjB07FnrBIJg0hcEwGYlZy5g5R7A2sCRaf6I+V7CJTmxNSp/u+fmgtRgfOgZH/D5kWiVvSQEGJ0uJcjik3FnmAZamWX0v7qyydTLGUwJjd3AtP7t/d5NyZ7vLAmm/JfMMry0qO0UVkbdXX31VdYTu3r27amjlXmbNmuVZR0ryt27d6vldssVffvmlyhyfdNJJeOSRR1QTN71MjyRYDk2a5M4Kr970T7w3haKIB+naE88O0YIl0frC5m+kVdKj50rbdOy2FmB+ydCo3IdMqyRTCSUeCX5XF0em27W/aZOXokVroEfbT6TtkAp8ZV5kKXv27ywtJc9Nkp5TP0vmWbZP1pUxyf7rEnk3tKrIlClTylzWrVs3/Prrr9ArZoJJ05gZpqpgkE16mB6JmXOiyPs114r/cwzCGtu+qO5e6aIs0w15T1fk5g5G/clURxWRvzsu6QUV7MrP9Ro6kZBgx+b80iBWgloJcMsLauU6d+m1bJ8EyxmuxLDnU5b5i2WOZyIjYRBMccexwESBmbWcuip44kP7OB64fL16GbertwRgd1hn4QbLTBVURdsOawFOSnwVtZ3JiCV5bA2S/qd+DjQGWMbotnHURH/r0XJtf+6/k/Jq6eTc+fQ2av5VmS4pUMsh/5JofxIIF1mcsLmsYe37AwV3o6WjRsh/R6RlLIcmIjLAfMGcl5gixkTjRuMR5Jr1JECCy4Y6iU5849yvArto6pYwGbuteSpjGuv5biVgFJLB9Q6CJfg9bClGl5K6SIEVqS6rGlMsJdWBbCw8ut1OpxN79+5V8wZfd59FdYyWxlki0WWDw1J51+n9lgI4LC5k59+jfj8z4S2kuRLwZck1QT0u6Wwtj2HJ3qPNkYj0jJlgDWJmlPvEDAyTsfvjsXhvgeGwPJjMyOhZ4GHOhthdaMU+S0HUg+AEl1UFwLFqCuVuUOXOyJ6T8DaOdWaobtGS8ZXfq8Gu5vCd5RykpnV60dW/wpJpb1arFTfddBNSUlLU+M1NmzapxlmySEn0roI7y/1b7zJmdwAsFhbfgP2WwoAdrQOR522vNR/N6kwKan0irWMQTEQULgbAVMXxwERmMb64Pya6+qvg1B20STbzJsvMiN6PBJ0lFqcaBytNoaLJXVosXZyldPm84vqq3DvZZUMNZyJaOFJx2FqCfDiQ6kpAgtdh9xjLLGyxHQ5p2iRpRCSWLl0a9N+4A193htrbHmu+mrn45MTXKr0d2Z9STi3/ExkBy6Eprpj1JsMEwyYqIZUsPgM9YmfoyDFyFlhI8OTOevoHUWvsh9XY3ZVFN0fkviTT6j1dUDRVdx0doSvTEv1ly0W+pQTNHKnYby3CPriw25KHNFcijitJw05rkepY3cFuRYrVil3WvJDu79RTT8X+/fvxyy+/4NNPP8XFF19cpe2XuYuD5W7CVSfpkSrdJ5FWMBNMREREFCNGD3j9NaxbOp2PO9soP7uzwFIWLb+7opRdlOmCokkywG4y9ljG/NZ0JmGXtQA7LLnYaclFicWFTiU1UNNiwR5rgepYPa7wKjzq6O9Tnhysnj17wmKxYOXKlcjOzo7YY5F5h+U5cTf1Ks/fe4IPnIm0jJlgIoo5w4wHNmjTqnjPFaxnzJBTqIweFMv4XHEgwFjgLGd1JLlsSLBEJicjWdZ/rXn4qXgYolX+7F9WLOOA3fP1SkC/z1qIQ5ZClWWVwNIBF145Mv43EmR8sM1mU4GwjBGOlE2Fo33GEddxVlM/F8LhE+y3zKx4eicivWAmWKNYJsx9QjoLuCM8PlgzQWgYZd612tep8t2yORaRMbgDXwkGZZHfJeMoTZ3qOquhuity+ZgSuFQALJ2Pvd1nm1Xl25ZOzv4BsDwOdwAs9lry8WvRcE+ZsQSWg4oboHvCZERSmzZtUFxcjFdeeQXRIBlqeQwS1EsHaZnXWMZXy9zF1QNO0kSkP8wEExGFg02xyIiCPOmhp8oGLTN6FljIPL051tLGShJUyVQ7EghLV+IWzlQctBSr4DUSPnYMVv8ftBT6XP6Yo+qZWP+pjCRb2tyZjt+LRmCwdQb+suXAaT36ODolvqa6Qa9POBDS2NtgXHLJJSgsLMQff/yBrVu3okmTJogG9zRN7RJfhg1W5LuKYWFfLDIIZoIpbpjtJiIjYSk0BcsMwa+3AkuJ5+dii0M1ysp0JqO2y4oGzsSQmmK5OzKXp3PCG1hddAuirZrLhiaOVNUNOt1lw3ZrjqdsWMbVLi8ajrbOJBX0R4OMDRZTpkzBrFlVz3RXpAgO2I+M316+b3hU74soVhgEE1FMmW08MBGRmQPhpftuUqXPkgl2HimJru1KxqeOIZjk6o9altDmDA401Y+3n4tvRKT0sb9X7nUSyH/uuBpvuQZgtf2wz7jZps50nGd/B9/aD4Q0BVIoatasqcqiZd7gP/+M7rRs0vRLQvlE2NAuMzol2ESxxiBYw5gpJdIZlkgTxczcuZyPWS/qJT+jsogSBBdZnD6Z2hpJpZnSyroSx5KMfRUFcAS8XkqhLy1qpH6+1DZVTYvkbUnxMMwruU5lg6Pp8ssvR2pqqmqUFW3FcKh5jiWDT2QEDIJJV3hiIH66DmgVx3vXP800uiIiiqEmdZ5TWVP31Ej+0wLdnX+V+t/dXCoYF9jfRTS5x8L6jwN2k8ewwZanGl6tsx2oNNh9p8HbeCZlRsDrXq45tUrbWlBQAKfTiby80OYcDpWcuJBO0TLlE5ERMAgmIgoVM74xoacO0eGOBw73McZzWEFVmmIxe2tODktkx8Uuse9UnZkDOSnxVUSbdIpOhBWtSqqrzLa/L9o9h5+6TcDnbSep31fvqI478wYGvK1bDgzx/Nwl4U3VMEyW8kinZllPlpKSEhzc7YLD4cBHH32EaCsNhH2z3kR6xe7QFBfM6JqT7sYDS7Ab6hRB4fyNH2aNicgo3BlgKYWOpNOL6we8fIs122c+XylXnu04GmhGggTAeZYSrLEX+cyv65aUVIRvF7fGFOsO9AUwMch5gqWM2k2mJGrhTEc7ZzUUuYCvEnapfVkNCch0Jql1hp77Ilqc7YDTAXzy9EEMiezDJDI0ZoKJKCyRmAuWtItT4JhQFU/ekHZo6f3rnie4pispYhlhCXBzLSUq2JXxuf7XnVpSr8z9R0q3hMn423oIeyz5al7gQM5bfjfGF/cPGCCH0oxqqzUHhS6gfVauuqzA4kA+ivGPLRvbbLlYt9oKObdQUmjBHxssODHxFVWiLfMkH5P0fMTHWTdKmhjR2yOKJwbBGseMKfH1Z8IMtA5wnx7FqZGIyvf3ntI5cndb85DprBb2rvKfGknG60rA6z/GWCy171Ily+LDI3MHhyNQaXU+SlDLVU2VQUugGk0PNbXgeVd/rN1VHbdUq6WC6vVFo7C2aKSaVirXXjrDsi2xtOFYCZw4aClSjbrSXImqS7XM8Rsp0gFbun0TGQGDYNIdnhggzY8H1smY4aDHZzJDSERVsKvgTtR1pnhKo8NR0dRIgbLBEiT3tk/BbZbw59CVuXG9XWN9H21LMrDXmu9pnhVNH/9dU/3/P2d/FJVY8VDCLNxpnYXrrO+rLO+0r86GzDD1249JnpJzGbObi2L1f6rLrqajkqwwEfliEExEFCMc62vs5lhmoKUyW9KXHdZclQ0Ol3+g6y1QNtitGMBNlplh3afV5RsEJ7ss2GzPUxlXd6Y4mlM7zXAOxCjLLLzf/HWMzR2I96w7sdSWg3kJO1Q37Ro1aqj17nykqwp8pUT8sKXYM/56pzUP2ZZiJLtsLGUm8sMgmGKOmVxzYvmstrBLb2SwFJooOHsL7lL/P5ZYfkAqzaDEE0nvhxToluerkmvV/7UkXRqGpcW+pb/JsGCbNQd5lmIV/NZxJoc0tVM4XnT1x29bauCFjGmYUC8FC4qHqrJkMWfOHPV/+/bt1XZsLbxdXZdvKZ3KSMYQs5szUWAMgomIiIgo6hxw4b6iAeVe7x5j6/TLwFZFogTVzuC6M1dGxufKXLlS3n1GSZYKMmPhaWd/3HpoMIZsPdo9etOmTdi/fz8OrUrF7xe+5LO+BMNSrm11QXWxDjSNE5HZMQjWAWZOuU9Ih8IcFxyLkmlmgYkontngitRLfgaHSyIXBE8KcnqiQN6u/7bP75KhbuhMVVng3dYCLCy+AbEk5dfuDs0//fST+n/ca1dj67aj3bD9TypIMy0J3BN4yE/kg0EwEVGwdNLwysxYnhymIJqfcTwwxYJkWd9J3Br0+p0T3ojatmzfm+Lze2aNQvW/lB7PLx4a0m05HMD8+cD775f+L7+HSjpCJ8GGjz76CH///Tdq166NOnXq+GSIB1tnlOmqLWOYpSkZG2QRHcUgmIiijuOBtdscq6KsMIOeijHgJoosd/MrCYSDtcl2KCpPg2SkHywuLd12T7eUm5+AJcXD1Hy8ofj4Y6BZM+Dss4GBA0v/l9/l8lC1L6mF9evXIy0tDSNGjFCXDffqgD3NOVD9/6B9lspcu+dJlmywLERUikEwxRRLu8lUNJg5Zik0EWlVOM2vZJxxZvLTIf1NMOtfVdjE87PT4kIv+xSsP2xTv/9eVBp8BhMMS6B7+eXA9u2+l//7b+nloQTCTqcTx9+6BQ6HA8cffzysVqsqkZbZgq+0TVfrPJMyQwXAD5f0x/eOAlWCLplraZhVYCkJ/s6IDI5BMBGZArPRRETxn/e7oqmOojHOONAURskue4V/IyXE6aXxrpLmLB1R+7prAE5PeBOtE1/0CYbLIyXPt90GuEpnLPLhvmz06OBLo7dv347kGg7Uq1cPPXv2VJfttpROO/V/jkEqUL8zbyCq2Zx4scY0zCu5LuQx2URmwSBYJ5hB5T6Jp64DWsX1/sncWWDOFWwMen39UfyzvZUF1ZINLk+RxVFmLKx7iqHyHCi4W2VS3T51DEGiqzQqPmgpxPqiUUFt28KFZTPA/oHwtm2l6wWjbt26cDqBwsJC2O2lgbyMEc6zODHePgtzS67FqQmvY1uRFaMODkakqJMCET55QRRvDIKJKLofMie1NMYe1mBpM1GscHw4aTmolqC1PN7ZzyZJz4V8+xJcTm3ypgqExdqikUH/7Y4dkV0vOTkZdetmIjs723OZNLxaaz+Ih44E7ZfZ03HgSNnzfbajY4VDcU7C2zjP/g66J0xWv8u44lRnQli3RaRVDIKJiDQSPEezaVaVs3ABSih1f4JDHlOcS0OJKPqK4cRxSS+orGkoHkqYhcMOYPuuVNxpDT2grF8/suvt2LED+/btQ1JSkvr9BstMnFVcF9Mu+AutEl9Ql/1e6MJmW54aF1xUfoK8Qt8XX6/+T3BZVQZYTiQ4LE7VLIzIKBgEU8ywpJtImx2iyeRl3jwRQFHW3zo9ruW0Wwtvx5lFdeGEK6RpgsYX90eBlEcXW9EwtWxTqR+6PI7vTi3/cZ15JtCwYUX34ELdpEPIGV123HIgMjWSGDRokPr/LdcA9GyajS1/N1ZzAovf7ftxWkk6mtfNxTPO8OdILrY41f8nlNRS5dDSsVuWZnUmhX2bRFrCIJiISM9ZZpZpE5HG7bEV4uyiCqPBqPs68V9VOizTBDVKmhj0373i6o8dcCK3oGwW+cCBdOzdl4GPWr0c8G9tNmBoudMJv60Ow3cX1sBFv9+JzZs3V7otubm5amqkhg0bqhML4qpNN6HP6tvxdv23PeXa0mfruv9Ks7l97O8hHHaX1TMFlZRDSyAs3GOjifSOQTDpGrPLFBNaCzRDDH7j0ZCoVvs6Mb9Pig6OB6aqkvJa95jaeGpXUksFwqW9noNXAif+Ky6db9dbYWECtu3MQH5BYrmNr779NvBt2lQQfGQ9uPDuu+9Wuh2pqalqPPC6deswy1maDXa7fkdp0CtedB3NAKc77RhjmYU3601BKGq4EpDhSkDX4iycXlwfiUf2mZRFExkBg2AdYcBHeqP7MaNaC6KZ+dUM50p2OibSA3cGU+bKTXZZUc1lU2OEQ/G+cxC2WgvxRNL7nsuGW2bh9e12Fej+sT094N9JALx4cenPJ5wAfPcd0MD2NU6yvAsnSq9oVb00Qy5BsCvQXEperrzySjU38Ndff+1zuTsL7NbPNg1tEl9Cp8TXUGBxYk7CLoTqQ8dgtZckCyxl5IJjgslIGAQTUcgnXUyV5YtRFrjCccJRDn4ryhQzC2hufP5JzyRoS3MlqvJnmS94fkJpG+bqLrsKEr3Xq8znjquxuciC+V1LP4v7tv8X9R3JKHGUzRALiWcnTDj6+/jxwDnnAMm2DTiEj1X2N8OagWGZV6vrN23ahB9//LHCbahTpw6cTieqVatWbhZY7LMW4qKSOlheNBxnp8k0UU48dHA/QiVTTx22lMAOC4pCPHFApHUMgomItNwcKwLdpXv1YkY+EvvXkHTeFItzD8eQDl8rtiOZ3wSvUt58i0MFhXlHphES0vApGDutxXj152bq5/T0HJUhXugoQrLNhZktXlOXP5wwM2AW+PLLS38+iALsci1RP3dM6IJaRceiQ4cO6vcHLxxX6TbI/MA5OTkVrrOgeCiecPbH9ZaZmJx3WAWzlc2NHMiftoNIdFlRw2VHNZdd7ae/99wW8u2Q9v3444/o27cvGjRoAIvFgk8++aTC9efPn6/W81/++OMP6AWDYCIyDd2VZ5s9QIt2J2XuXyJDK7I4UGJxwQ6rmh5JguJCS4kKCmUJdd5gGdfssJSWBp+58EF83/kJfFlyDea5cjHgn+GY2/FptGhwGM0SJ5XJAluPHHHbnFuQh9LPs04JZyClWiGGDCkdL/2rZbVqflWRunXrIj8/v9JtlaBcWli1cKSp7tjhkH1XYHHgP2shuhVnhdRQjPQlNzcXJ554Il566WiFRDA2bNigpu5yL8cddxz0gkGwzuh1XLBet5uIiIj0Sea3lW7Q0thKGmJluarjzOL6Kihs7ExFXVc1ZCY/HfJYWXG5bRrO+Xkcnkx+H21KUlUX5s1b6+FwbhLOcZ0YMAssY4pb2FZ5buuFnMcxdPMYPPjgg+p3yfB++OGHnusDBem7d+/2zBNckXe2JuNN1wDUdtoRro2Ft+I3+x4UWhyofqQrdMvMF8O+PdKu3r1749FHH0W/fv1C+js5KZOVleVZbNISXScYBBNRhboOaGWOrGu0VZB11M28wQHKIfk8GxfHA1M4tPZ55m7qJEFwLoqw1ZqLdokv46fiYWrMbB2n7/jaUIJhaY51T8FVaJggY2eLcdOeazB8z9WY4WjlkwWun/IMPj7+JTRvvh0rC5d7ritAHnKdBT7lzVOmHO3i3MZR0+c+ly1bhpKSEhV4VOayWsAQ6/sqEK7qiYQcSzGWJezHecX11X6MdtNBNh6MDOkk7r0UFhYi0jp06ID69eujR48e+OGHH6An4Z8eMqnTLjsWq2f/E+/NICKDHCwy0CAiiq4mzjTV5djmsqggznmkpFmsLxoV9u3WPZL02lZswZnWVDyUMAu/ltRDIbqry6vjAN656jM8XicThYVFKHiwOgqvLw1EVq1ahXbt2mHJOQ+iy/cPqzLUUaNGYf78BWrO4GbNmvnMySvTIn355ZdITk7GFVdcUeF2nZrwOpYW34QbERlysuA8+ztYbT+E84vr450I3a7ZpWQkhZ1oqEjG7mwUTF+BjIwMn8vHjx+PCd51+lUgge8bb7yBjh07quB66tSpKhCWscJnnXUW9IBBMBGFxFSdoeOJ41WJqArkBJvWsrLxIFMjiStt02FzlU75EykPl5TOx3vIUoIdcKLI6cQynOC5vhPW4kRXMlbtkox0Cj68/iF1eV1rPRUAyxjiXiseVpddeumluHXUrapr9DktRiPBfg42OG5Vwa9kh6tXr67W69atm5ovWMzr9BTOW353me2SADjSVtn3or4zFSvsB2Xi5KjwzgDLz6w0Cp+cLNm1y3dqrGDK6IPVqlUrtbh16dIF27Ztw7PPPqubIJjl0DrE8bXE1xgRmbHbL1G4/s8xCJkuO9JdNjR3BF8CHWjMcKvEFzDYOsMzzZJ0ic5yJsDmbIp9KC1VTsVBJFv/wpPO/vgmYTe6HbsX31x8vpoL+Jn6j2Ji6gz0WnGX5zYbNmyIazED3exv4WTL5Tj+SCm0zB8sAbBMjSS+k8mG3X/T/L+YvSCkM7QE6HWdyTG7T5ZFV016errPEskgOJDOnTtj48aN0Atmgoko4nj2toLsrl/gwUwNEVFsNEp2IrfY6sngVkaC3PqorsYQix3WXDVGdkPRrT7rvVLrPbzmvBpnnAHgSEOsybNq4Morr8XJia/hnOK6uHxj6X3eYZ0FIA3/c/puw22WWXBZXKjlTFLTEn3oHIiPPvoIKSkpaunVqxdmz56Npk2bev7mhA+eR6yttx2UtHbMMCOsH7/99psqk9YLBsEUdcxcE5mzrFJK56MytRFFHceqkxHdnX9VSOuvLRpZZqytOziWeYY3FY5Wv4/YfzXmzTs6L3Ay9uODAV/hyisH4ZUz/0Xn74ary7slTEYzpOBdp+923GWdhYMWJ6q5rGjisiLRApX5Xbx4MRwOB+6//37873//U+ueoSLt+Pi9aASyEh+LedaXgXD05eTk4K+//vL8vmnTJqxcuRK1atVCkyZNMG7cOPz7779477331PWTJk1S49bbtGmDoqIiTJs2TZ20kUUvWA5NuscgmwwnDuOB584t/wCEiIiOjrWV4DjFZVdTGMnSMHEi+vQ6Wpp8CtahlsuGcdZZ6PzdIyp47p4wGXWcSUh2lY5JXnHBPer/O62zsN/lQm2XFekWoJbdhaed/bFmzRpVwipzAt95553qf+nwK4FHPP25N/xGYlXB0ujoWr58uer0LIsYM2aM+tk9fZfMAbx161bP+hL4jh07Fu3bt8eZZ56JRYsWYc6cOSFPsRRPzATrOPBbvYldqomIYo0HY9oiJ3B69eKUbCGRYRlsvhdWtqy4uBg1a9b0ZInbJj2H+qfb8O38Bur39Or/oXHuVhy0uLDVWowuCW8iAVakuhJwks2O1sfuU+t1/PJJ3GebpSqLG9gsSEt0oKjEivuKSqc0+u+/0qC6QYMGOHDgAOrUqaMywkKyxJKpk0D5n3/+UdcXFBSo8cZ2u12N/ZSfDx8+rNbdvysfTY+ti+bNm+P000/3aWikp89UZoSjp3v37uo1Ux7vqbvEXXfdpRY9YxBMRKbqDC3jlRnEVAEPnonIpB544AHVpEoyZNLN2Wq1osXxW7Dy7zGedXr2/gnDb22ssmMSAC8pHobmSZNwdkk6ckuAyzbc4hkbXOQCXnT1x1PV3sedeQM9tyHrrzt4E77++mvUqFFDZd0aNWqkprfJzc1VY4QTEhLUuhLkSpZY5g8WUj4tl0lAI//bbDbUzkpRQbJ07505cyYOHTqkbuP888+Pa3l1OBgIU6QwCA6DzOm1eOaGiD0JRFoVzvx1bIoVenMsvYvViQUZX2yEEzGaYLDXIFG0SfApAamQDKyUf/77XkPYzzoe2z5poi4//ngHjj9+DX7+ebMKgiUAlk7SqZILtgCPOkqbYb1e5104XMlom1mAJ5Lex7jCq1TwKp2fpbnQ9fcXYeLEiWo8pgSz9erVU5dLoCtBrZRJSwOili1bqnLUatWC63b9999/q3lcJaMttyX39/HHHyMrKwtDhgyJS1MjnpSmeGEQTEQ+OMY6zliiSHHGplhEZUkGWALbhQsXqt8lIM4YlYvJk6/0rDNq1AHs2WP1zON7v20WhiVnIi2lGLUy9mFGszdQUmKFxWJHi/Ri7DmUhP+cJXjhhRewZcsWFdxKubUskmWWJTExUc332qlTJwwcOFDN/xqMtZfdjjYfPedz2THHHKMWIZnhDz/8EL/++qsKil9++WV1mWSG+/btq4JtIiNjEKxjHBdMREREFF3S4Kq63YUChwUHh+1D9YxqOPHEE/HFFwXYvr00C3zCCUBx8fvq5x49euCDY19BmyY2ZOck4699yTjO4sIJx2/BGT+OV2XK33//Pd576iPUOykVBw6kqoyv3OYFF1ygAl83GfMr44KDDX7d/ANgf3J7gwcPVouML54+fboKgn///Xf89NNPahvatWunHouMR9YSlkRTJDAIpqhiVpHI3DhNEpH5yudlSrWP1x+GFvSzTcPHjsFVug1pF1S/Vj6G7rwOtwxbpMbTHn98a7z8cmknXXHzzbuxZctWZO/IwbvtF6OkwT7safMvCu0u1DxkxQmPDELdul0xoteNSG6dioyaGWjQMUMFxOeee65qWBVIixYtEAlv138b1++4PuB10jBLmm7Jtsg45AULFqhy6Q0bNmD9+vWqK7U03MrIyFAl2pHCUmiKJwbBZAjMimsDxwMTEZEWdEp8DcuLhqOhs7SBlL++tvfwuePqMpePt89CSoLTZ07hJ52lY3mloVSdhrVVULhmTZZnXuAWLQqwZ8+rqgw65ZgUWMdtgeRym+LoGFsZfytBZs1OdVSjq7Zt26qyY++sbzSVFwB7k/JryUTLItsqpdIyV7GMh5agWP6XhcgIGAQTEWmlOZaGxwPLOFHJ7hCRQRi807sEwNKduTXSPPPxrrDlwuaywA4L0pCAq6zTUWBxor4zERIqP+/qj3+cTiQUlM7l63aDZSbqWCxo13QfrNdZkZaWjvvvL/ZcP3488Pvv2apB1d6/d8OWYkfdJvV8bkPG+UoWVRpQBVtefK79HXxbch3iQQJiGYcsi5sExtIU7Mknn6zy7TMLTPHGIFjnmAGlWGFXXuPjfKsmUUFpK5tikZFId2a3Z5z9cbltGqq7bHjXeRVus8xCoTS8crngDnnvsc7CcTYLUpOcmJQ+HTZr6bypp9YpQYLdiZLiRBz7dhZmNM/Dtm3uscAuDB6cjKuv/h8mT57smbrIbcfK7bhi5AA1tjZUoQTAUvY96NhD+O7PTMxN3ImxaTVx896jmW55bO6MdlUC42bNmlXpNoi0gkEwEZHeGXDaJSIyHsnMJsKK6i47NtgO4sSS2qjjtKNtRglGHazauN2KpFd7UmWAs2wpyHRVw6W2qUi12JHgssAKoAgu1LRaUM3mgtXiQmGxhMUWWCxAekox0qoXorjYhpy8RNhsTvy14zLPbbewvIWvTt2NH+r/hbROpQFiYWEhCpccwLF/tcH4beMRC1ttOdi1Jw3HpZZgc34NfHTQgZu9rv/cvgdVz99GBrPApAUMgonIg43MKCgGL6Mk/WEVg74yszIe96ziuliUsAcbC2+Nyn21TnwRe6z52FtwF7Lz7ylz/cW2qWru3kSXFcmwYq/TgjSXBSkSDNudap0SpwXZeQkYsf9qzGzxGrJSC5D24khs6Fl6G3Xq7MbJl/2H5VYgDaUB8N4de1FrenvUcrbFzbkDEcvyb/FijWmo4UzADKfvfa8tGhmzbSHSAwbBYeo6oBUWz9wQ2WeDSGOv8VCwKVYVs7c6Dyrl+efZfSIKRqCGVJF0nv0d1LdUR31HdU+DLH+fOoaUuex6y0w4nRZYHVbUql6MpMQSZOcm4snk92GxZKB6Ugle6LMTQGl/hG7dFsAqqWQv9RrVw/2Hj5Zh++uWMFkF3vMiNNa3QdL/0K04C+87B6nfJaM+6kj2O1DwT0Sl/N66pEdazd5pdbsqI2OEyNgYsPsqyDuMnAN74vRs6AsDfaLgnNvQtzFUNEnw6ibNriTA/L74erW4A+Ah1tI5fCvisriQ7XIh1wHszUlAbn4C6tbMQ1q1EqQkObDRVQ8bi7I8WeATTljn8/cF+QVquqGKGl21LKmOrkjBQwmzPJdfaZuOcP1XeIcKgJ9I8n18bUpqw8ifofwspqpiEEzlOgTga/mgieE+2llcjNmHDsY86JbWF5sB/B+AzxA/+wAsg7bszyvC9kP58d4M1ZXy28V/Rem2Xfj0u/UY/fgcxEtRUQm2/hfeaz8cLpcL/25cha8nP443x14OR0mJJpqq7cwpwHOL/8bTCzcGvH7/qsgH63n5RXjj/7T2zos976ZY8vrIy8mJywmZJZ++g9xD8mkYPwX5efh77Zq4bgOV1S7xZZyY+ApOSnxVZXjFOQlvY4etAP2t03Gd9X1Uc9k8QeVg6wzcYikNNqu7rCpAllJsWde9/kDrDBVED7fMQpIqjbbgkMuFfCfUmOBqyUXIKbCjuMSCT/PbebalQ8s5Plngret2wPJ6QwwaNAifnvCCJyPtPR5axkI3slvwUEl/jC8+2qTq/xylWdyqGFd4dEon/6ZgWnQorwivfPNH3O5/wdJNmDjlp7jdP8Ufg2AdyHM6sSSG87JJ8Ps5gIlyhjFGL5I9JSV4ee8ejNi+DbuLo3cw7k9CuyUyhgbAWwBWyTgixJ7s809kegYAhxF/uU4nZq3+FwNmLUe7l75HWquacd2ev7fuw7nXv4PH31gQ0dstLnFi6sK/cdLdn+OSkdORnpqEeFi4cCFO6vcyVv+5K+r3lX/4IFZ8MwvvPXgN/u+pUVi/ZC4yG7VARp2j81nGmsPpwjcbd2PIhytw0kvz8fiCP9GhfkbU77ekxIG3PliO485/Dh/P883oxNvP2/ajoMQR8/uV4Hf5D9/j9ov7YPOG2B2gFubl4OfPp+DtuwdgzaI5SEmvhVgrKS7Gsh++w9O3jcRVHdrjz99XIl7yc3NVIB51Omuot7roFvxeNAIri272ZHgL4UC2pRh5Fge2WQuwzZbvCSp3WQux31KiAmEbABukEZZFrTvLOQgNLVY44EKuxYF8ixOvufqjRWoJmie5kJXiwOjsQdhxawl2Dl+K7zLzsKW49HOyVo0d6Nxjq/o5NycXW/8vD23mnIXHD5SOu7143dFxzhJoSyfqMxzpaOZMxK4S4LHEo5lrs8kvKsGzn6/Bsbd9jO/XHj3xFqvPtx9++Qfdr34L3a+ZDKuc5SDTiuuY4CeeeAIff/wx/vjjDzW3WteuXfHUU0+hVatWPi/Yhx56CG+88QYOHDiA0047DS+//DLatGnjWUe68I0dOxbvv/8+8vPzVRv6V155BY0aNfKsI39766234rPPSvN8F110EV588UXUqFEDWrWpsBBfHc7GgpwcnJOahi7Vq0d1qqRsAD8eyUS6D73KL+qJjP0lJfjw0EHMzc6GO/Q9ITk5yvcKbAewVL5QJRDyulwmNmiJ2Mk9ss9/kQOwI5c1RXwUSTCWk4OFuTn4NT8fxVtKp4bo3jwTzeuWzrMY6/Jih8OJF6f9jHsnzUN+QTH6nXdCRG5XbmvyN3/g2c/XYsveoyeYep1xHGJp3759uPvuu9W0GqJV88yoZdG3rv8VaxZ+jr9+XQhHiferHmh1auhTd0TCtkP5mP77NsxYtR07Dh8diFAzOUG97qJFvlc++Xa9el398U9pZnnYFUfnwoynw4XFeOSHP/Hx+v+wcfS5MQt63MHvtOf+hz9++xVJ1aqhZfsTEW2F+blY+d1H6sSMBMKiefvOsMTo4FTeG+uWLcX8Tz/Bwjmf49D+/ery5JQUdLvoEsTa1o1/4oup7+HneXMxeUHss1SyPyZ/uAKNsjLQ+6xYfhtWrdu0vFqyrcUqyHXChTMT5LS2NKtKQI7FoeYCTnfZVTa4PmxquiTxqKP0/2GWmZ4T/rcfHqSC1ucLSq/bvn07MjJqYLWzl+d+zzl3kcoCFxQU4PYxt6P+M4FPIkZq3K8RFBc78M7sX/Hw8/Pw7/7SEzxdjwu+Sqgq5PPt+5//wUMvf4+FK7Z4Lj/7tGgf5ZKWxTUIXrBgAW655RaccsopKCkpwX333YeePXti3bp1qH4k4Hv66acxceJETJkyBS1btsSjjz6K8847Dxs2bEBaWumB+ejRo/H5559j5syZqF27Nu644w706dMHK1asgM0m5/6AgQMHqg+yr7+WAl/gxhtvVBOWy99pSZHTicV5ufgqOxt/FB49KOxaQQBcVYGCX7dofTwcdDjw8cGDKsgvcpUGW4hyEFx0JNO79EiGOxA5/ZKI6CsAsAjA4iPb5SZfwo1jcP9uEnhvPLJfJOdTvGd3mXWGnHT0ZFIsrf97N4bePxtLVm7zXFYjrWqvjUOHC/DK+79g0nuLsXufb3WFZIFPbdcoZl/IUz9diTueboK9B0oPBhISbGjWMLIn5fbv3o15H8zC1+/PwI4tUvAfgMWClp26B10u26tR6Xi4cBU7nPh6425MXbkN8zftVUMR/PU9PgsJtujUoPy4bBPu/t83+Pn3o68r0fnEWL7zApu7cRfunLtWnRBon5Uek0BQXovffPMNJkyYgJ9//tlzeZtTToXdb77TSCoqyDsS/P4fCnLlW+iohi1PjPpj/mfdWhX4zv90Nvb8V/Yb4ay+FyMlNRWxykAvnvs1vnhvClYtkW8F4NzLr0RCYiy+jY5atno7bnnkcyxb/S9+/WgE9EBKfmW6Ixm2JcFvwpFQtsjixGFLMXItJaqk2e6SQFkCZFvp+Cc/b7oGqOzsg/ZZcB65XgLhWnagzuN1sHp1lmdeYBkL3LzZCvTu3Q+nnnoqYk3Kv0uz18UBG35pjZxY+eDrtXjghW+xcYvvMIcuLetG/b3+7eK/8dAr3+OnX0sz9261MqqhXcvYjVsn7YlrEOwOSN3eeecd1K1bVwWvZ511lnrxTpo0SQXH/fr1U+u8++67qFevHmbMmIGbbroJhw4dUlmUqVOn4txzS8+aT5s2DY0bN8a3336LXr16Yf369eq+5AteMsnizTffRJcuXVQw7Z15jhcZCzv3cDbmHT6Mw07fUbhpVitaRyEwdAe/y72ykN4sR4JiOXSWwrT0CNznYYcDsw8dwpzsQyjwC35FDZsNhxwO7HfIR7xLfRnJWo0TEpB65IRGqGRvfn+k7Lmypld7j5QlyymHlCNL9SPZ2UgUyhYdyfrKfg80yrbWkdJo2e+lX+qlohGa/QZgzpGAvDxJNiuaZMheiC0pU5397ToUFfuelqmZUS2s29u1NwfPvfsTXp25FNk5gV8Fjepl4IO5a5CYYPNZWjbLVFmRSPlz017c/PBn6qy0t2Ob1ILdbvMcNOw/lI+de3LQonFNpFQL/WD4rzWrcc+AK5FTyRh7OTD8+Lmxqvw0Ja0GNi9pgRp16qBG7Uz1/4lduqqsWFVJae8zi/7C+79vx568okrWLS3Hz0xJxDktMiMSDK7+cyfGTZyHOQsCd/Vv0agWtu88hILCErUUFpegWlICTjg2ugdpYnduIe6dtw6frj9aGtisRnTfd/L9Om/ePBX8Llkin46+mh/fWpXkVovwCVgV/H4/W2V+C3Lk064smz1RjVfPbNgCSSmRDUQ3rl6FZ24bia0bA485d2vWqhUK8/NVRjxa9uz4D19Nn4av3p+OA7t9T0Ce2acvYmXfgTzcO+kbvPnBCvW6sFotOL5FbDJ0kTDbq8uzNL+a6jw6NlbG/wo7LEh2WZHmsuIV19GxuG53WmXccOnnjOXIMZEce0jp8sG39mFR/tG/aVj9Czz51OOw+reFjoI+9vdwc5u9uPD3Mer3kxNfw6/Fw3FM0vNIcUXmEF7GWBegBBuKIjtVlbyW5i7aiHufm4ff1u8oc73NakGd9CT8veswikocKCpxqkUuP7l57aqf3PvpL5X59T6R7u3YprWxYNlmdZLE/V0oP9fKSEFbBsemoKkpkiSgFbVqlY4F2rRpE3bu3Kmyw25JSUno1q0bFi9erIJgCZiLi4t91mnQoAHatm2r1pEgWL7gMzIyPAGw6Ny5s7pM1gkUBKuJzr0ysdnZvmeqI+mgowTP7t6NjUWBD84lKH5hzx6MqVvxwViwJdFScLbgSOa3otG38gXgbulwgWSjK71l323xH2P62aGD+OzQIeQFCH69M8S3//dvmcsfysrCSdXCOyiUr6nOR4JLCfwqIoeggUaojKliECz7eQWAH47s/4qCcBkX7E0e9b2IPMm1yCturl9JuLdChxO3zVmN1b2ORSxJMHjvTd3V0uuGKVi+5l8VFIaTCZ49bx0G3vl/KrCpyLq/d2PQnR+UuXzSuAtw29WhvPoDKywqwZNv/ojHX19QJrgXO/YcxilXvKr+37UvByUlpadAfp55E04LI0t5bNt2eG3e93j94fFY+EX5FS8ulxP7/t2kFrFh6Xc+17+7ZGngIDjEuYKT7Tb0OrYuvvt7T6VB8P+t+VctKQk2bBl79LM9HFv+PYDxL32P9z5dqQ6MytPqgkllLuvRuQW+fed6RItsz8zV/+LB7/7AwQLfd+E3f+1WY6Pv7Rb5ktTvvvsODzzwQMDg1+2jN15D/abN0OfqayJynwV5eVj21QysmDsT+eUEv27fvPOE+v+Ku15AowhnhY9r1x7X3X0vXhh3Fw7sKb/J2hsPT0DX8y9AVuPoVAjs2r4N467qj/82l77v/L14z104bdmviCaHw4G33noL9979nPp8dZOTTnc89RVeGX8RtOyZlBm4M893LlzvANh/KibpxpzvAO6xzkKRC0iyAE8cKYuW8uhrrO+r4wW7qzQqKoYFu1AHe6zHeLLAybY9WPH39WWmRYqWL0quVtt94ZF5j++rn6yagv1ddBtOTXgd3RMmY37x0CrdRwmcSIYdxyW9ELE5m5f8thXjnvtGBZkV9YJodbukHXw1yayOTS9eFvZ9y5jfcRO/wS+rZOBb+Zau2o5zrn27zOUyLOrrNyPzuUfappnGWHIwMGbMGJxxxhkqgBUSAAvJ/HqT393Xyf+JiYmoWbNmhetIhtmfXOZeJ9B4ZQmS3Ytklqs6j2p5atjseKpBA9xcO1Nlff3JZc0iWBYlwZzsreiPvD0q2+HA7pKSgNnfYAT7Z+V1iJZcgnykSq/Eioo5pfxbwr0GACT35y4GrGpORl5l0mIlnF6r0WqN4z45cIt86ZSzTmqiDcfXiU1JYHk+f2UwNn59Oy499wTUSA89K3PpeSdg7pvXoGuH8h5lKZvNiqREe5mso2SDq0q+lNtf/BImvPR9wABYHMwuUMH+v7uyPQGw2Lk3/A69mfXr475X38Cj701H/SaBR5vXzGqC0/peg3bdLsKxHc5E/WPaokGz5kg5MtxEMsKRcmqjmvj2uq54uMfxKsAtT8P0ZFSzW1GnetU+96QC4LLb3se7n/xWYQBcnoKi6DXp274vF1fMXIZb56wuEwCLYocLhV6vg0iS77Njjz22wkyWlOLajlQmRIKUVqek10Ritfh+noguvc7H69/NR/eLLw14vdVmQ3rNmqhTP3rN4uo1aoxXv/kOg8eMRWJS2W/jtqfJp3P0yPtBqgCGDx/uEwC7ezHI56HWm2f5B8CVqZNWiDS7S530lRPAe1wujLLMwl3WWbjPNgupLisK4ESuxYmF1tr4PL0lUvrNwe7co2OBR9xWJ2YBsJt0kZYxy2cV18EzO4rR2FFdZYQbOlNQz5Gspl2qirVFI1WzsUgFwHLicewzX1cYAFdEssFVISXO3U9tjuop4X1/sFeWeWgmEzxy5EisWrUKixbJSElf/gel8uFdWXmc/zqB1q/odsaNG6eCcu9McKBAOFJsFgvOT09XY3+nHdiPbw4f9gxbaZiQgH4RbOAlgZ3ktU45Ugr9YzkdiWXP3H4kaK5qCF4/IQG31amL/jVq4qNDB/H94cMBs9CpVismNmioOvbJ94ws8hxVj9C3joQBNx/Jgn8boBS4I4CT/C6TnFVVR8ZJOfONR0rLJQtf3kQ/UnJ+7ZHHbfNaoklCnBukA3PNWph+YL/P83JBy3p4uW/0m+NUJDHRjlqJdsya2B9bd4Q3hdBZpzTHounDMGf+BtUMKVAX5nO7HOM5+ysHgRKsypKUWLVnQBov3f7kl/hzs+T5Kzb2+jPQsG46sjJTkVUnFfXrpKFJ/aq/9zudfQ5e+/YHPD5mgsrGOR0lPu/zrhf7Zjt79SrNPoZaDioN0iqbu9FuteLmU5vjouOzcN+89ZgT4Ln46KpTcUyt6lXujlwvMxXLPrgZXy74E0+99aNPQxR/7z97pSqPk+c7OdGuTohUD6MMPVgNaqbgti7HoF5qMr7YsBN5fidHqiVYcfdZ0WnUJv013nvvPdx///147LHH1BAiKcH3dtlNN6P3wMERDYLbnN4brTufhz9++Ra/zJmKg7sCZ2r63f4s6jQ5DklRDJjTa9bCPS+9gjMuvBAvjrsbh/YdHasolQ//tyr63cLlvTX49jtw7mVX4I2Hx6txwW5D7hgb1fuW79VHHnkE1157rWo8+vabL3n6E4iLzzkeRjNi/9GssJBMamlLrdJSWLu19Od8x7HIbZCHGwd/gH/+ae3JAouJE4HTTweOjNCLGRmz/ELGNLR2ZWBKQTYccKoycMkE51iK0SrxhYiXM4eracOa6vt20YoteOKNH/HVwvK/E7657zzUSUtGot3qWZKqeOI5s2Z1PHlHL9xx3Rl4ZvJCvPz+L8jLL3uiUZpiffzCQJVkcZ8klf8SEjSTH6Qo08QzPWrUKNW1+YcffvDp6JyVVZqz88/W7t6925MdlnWKiopU9+eK1tm1q+yB1p49e8pkmb3LrtPT032WWEi32TAisw6ebdAQLZNKC3C3FhWFlcWojAR2XY6U+kqpjX//X7lHOWyXEWGRao+SlZCAWzLr4LXGTXBBWjoS/E5C5DidKHS5UMduR227HTXtdjVO2H+9qpCPVznHPlrm+fO7rmxbqNITAJG4d8uRTLMEudLKIlCf4+wj95d5JFsvr7rotUTz/SCQEy3PNWyEY7yqDv47XFD530apM7Q/aRx1TJPaVTro63P28fjt41vw3i1noEVd3wPsJSs2ewIByYJUS05ARloykpOq9uqXsXVynxKMDe9/aoXTMF1wVkuMvqYrBlzYHt1PbYFWzeuo7YjUAXfXS4ZiyEPvoPHxJ3suP7jn33LnCI7keEj/uYIbplfDlMtOxvTLO6Kx31jvv/bleEqoq0qe9wu7t8KP04Zh8YwbcUmP1gFPfubmF6FT24Zo1zILxzXLRJMGNVC7ZvTG5cq4yzOb1cbLfdtj7ahz8MKF7XB6k6PTAuUUOfB1lKfMkmBY+mzIDA3SiMk7M7zq59IGTZFmtdlxQtfzcc3D7+L8ofehZr2yJ5f3bv9HjU+32UM7Tz93bsUnYAI5o/eFKit8Vp+jpb95hw8j58jwrFjIatIED771Dh6dOgMNWxyjLtv8R2ympzrmmGPUrBzb59+FaU9fjjM6llaMSH8EI3PPMazGgappk+R70AK7y4bcYzdhyJCfsHNnHj74wDdwlo+O0aPlRGnkt6m3fYrnZwluZR5jcXrCm2oM8LS8XDVlk0wPJVNFCSmFLoYTbRy1VDZbK+Qz9sxOzfDlG1dj5exbMOCCduozz9/h/GK0b1oTxzfMQIt6aWhUuzrqpEemTrFOrep4+s7zsWneHbjjutPLfJdKA7jUlETVa6RWjRS1yGd+emos6yTJtEGwBHaSAZZpkr7//ns0b+7bi1h+lwBWmne4ScArXaVlOiXRsWNHJCQk+KyzY8cOrFmzxrOONMCS8cZLl0pf4FK//PKLusy9jtYcm5SEp+o3wKjMOioA3BvkJ2555cDhBsOBRytVfRskyL0pMxNvNGqMi9IzkOh1ULoqP1DLqMhzl0jf4FUiHSgIjgY51SOFXKOOjM31fiP+jfhpkpiIpxs0xF1nHKvOiv+bXVAmeNE7CXAHndECa/93MV667lRk1SgNwLLzi7Hur/LHCFb1gEACrFcnXIQdP96Nd5+4DGd1alZmvRlf/I5oq5XVBJfdMRHn33A/UtJqwulw4NCesuPwY6XncXWxaNiZuLVLC08m5k+/zt2R0qVDE8x+aRDWfXErhl4m3x1Hg+yvF1XcKCmaUpPsuKp9I3wy6DQsv7kb7j7zWDSrUQ2z1kT4eSmnrPW4447D2Oeex5vzF5YGwzYb/ly5Uo3jjRYJhlt36YmrH3kXvYfdr16Xbts2VNa9IbKk5P/eV1/Hva++gYwjPUl2B+hNEW2dup+txvEPvfd+7Nzm28k22pLaj8egvidh4bRhWPXpSDSomx6Vk+9aIV2VlxbfpLpLy+JwOZFw3BrUv3QZBgzais2b8zBt2sNwuXyrQWSXbNsmc7tHblvaJL6E5kmT8IftaKWTBLdbbXk4z/4ODloKUduZrLY3kK3Wwxh07CF0OeE/NW5Ya048vj7e/19//PnVaNzYo6XK9rrNW1XeXB2RU7d2Kp69qzf++WYMbr+mK5KTSk+u5eQV4dd1ZRt2kXnENQiW6ZGkDEs6Pct0R5LxlUXm+nUfOMr0R48//jhmz56tAlsp3UlJSVFTHgkZrzt06FA1LZI0+/jtt98wePBgtGvXztMtunXr1jj//PMxbNgw1SFaFvlZplHSQmfo8khJ8LlpaXilUWOfIDFavIPhPkeC4XCC4FDUstsxtHZtvNm4CS7LqIFkiwWrCmITBLs1O1IiLScAotf+LDCpQ7jiSFZaJlqwVVAqHU3eJy7sFgvuPPM4fH11F2QkJRj2QCjRbsPNPY/Hn89dgscHdECN6olYvDL6B57S6fnqSzpgwdQbsOHL0bj7hjNV+bP48Ju1qoFWtMlnq5SlXvPoVLTvfjEOlFOWGisyPviB7q3ww/Wno0vjmth4JBMcLZKdf+vRS7H52ztw19AzVXZ+3uK/VVfyeGtaIwVjzzgOS4d3w9jTj4Uzhu+/hs1bqGD4rR8W4uxL+mHDyugHo1arDcefdh6GPDwFF9z4IGo1aKY6Q3uX7MfKWX364vXvFuCMCy7Enn/jc2JIxmJfcfMtuGSodLCID6mGGH/LOTGbqzne5Lix88j1OLN/DdRpkISvv07CzJnPoqSk/ArAHRGMnZo703FSSW1PabZbuisBxRanGrNbDXZcdSQz7O9Awd3YuTsdw/90YX2RnFrXJqnkevWGzvjnhX64s28bpFVLwDcxCILdsuqkYeI9F+Cfb+7AbUO6qCEvC5ZF+yiXtCyuY4JfffVV9X/37t3LTJUkwa646667VFA8YsQIVfIsHZ5lTkP3HMHiueeeg91ux5VXXqnW7dGjh5pX2D1HsJg+fTpuvfVWTxfpiy66CC+99BL0INypgaoSDHc+Mj5WDoHksDDaWyAlz1fXqoVLMzLwQ05OUOO+I8l25ARA+yNl4LH+6pfcgxTjyTsh+rnA4JxYPwOfDzlNnfk28rFQ9eQE3H1xO3WGevW28MYch6tl80w1dumRW8/Flz/+ickfrVBzGkr5biwkV09Dj8Fjyi2HjrXj66Th00Gn4df/YlOKKtmup8b2wr03dcPrs5bhr637Yzo1jFRZ7F8VuPpAPv9OaeTb8DFWQxAaNG+OOyZOKjNOONrBcKtTe6Blp7Px54r5yMs+gNSasa9CqZGZiftee1NNDxVP3scvFB0ybO75559X+1oqCqU0vFu3wXjhhcr/tqo90+olPwOby4r/Cu9Q8xkvKBmKfrZpnuubJD2HVqiBai4bzkx4S12W6bKrRl4vBpji6ZXcQ9hedLSPjZbVr5mCJwd2xD0Xt8Or8zZgT3ZBxEqgg7r/ummYdO+FuOuGM/FzOdMnkTnENQgOJsMkBwLSwVCW8iQnJ+PFF19US3lk2iXJOptBsFMlBRMMx3oa+DSbDRdlZMTt8cdi/G1F5LzzmXHeBu+u5zImM9A4Hj0rr3FTzdQknNU6cI+AaJOy3It7tFaLNOWKtVDGXs7dvhO9GlXUY71q5DO/Y8PINQIMhoz9lgMis5LnNJBYzIPqz2K1otUp58T8fn22wWJBSmr8u1jHXKBpzzTQGVp6ujz55JM46aSTcNVVV6kZQdykS7Iaz+uywAYrCi3SMsqlsqq5KPI0i8rNzfUcc65du1YNoTt8+LBKoEgQLE3ipLJQRp5JaxopBAh0iConhOX6M6v4cZHgsmF7YWnQuqB4KB60z8LHjqON6JJgQ5HFqTpZ13LKbxZUtwB9z1yPMZZZmOgXCEu2WG+k+mrcJe3idv9yErRfzzZxu3+KP810hyZjCGdMMulXrJpimYnP1CRxIg2G3B2i9XqiIxqvzco6XxNpTbRPWkWjNFmGyMkcxr/Mz8OGdS3w7c89UaNGDWzevBn33HMPJkqLZnk/Op34cf9gnFLrHSRaJEwsPYFYDAdsLiA96z/0Oe8GtGqfUaa5aUlJifr7q6++2mdYnCTgn38euPzy0oDXOxB2V0RNmlS6nlQxSo8aNwmoMzMzceaZZ6pmY/59bry5A2C3h0t8g1qZrkjGCtdyJeOgtQgpLhuePBIkf2Ofhb629/Cn7aBmOkIT6RGDYCIiilzmiCJWEk1kZCclvgq7dGZ2lUaXkr1Nbvw3zr4mVQXBPS/OwMtv91QZ4E8//VStI9naTZs2qSm+3Gq02YGDa9sgETaUwIlsFODykf+qwBko231cgl4ZNlenTuBye5n+6MMPgdtuA7Z7tUuQDLAEwP7TI0lmukOHDsjLy8Pq1avxwQcf4PMPFuEyy7M4zmbD98hRmdzjSlLwumtApftFOkH/XXgbziuug2H9fsY1n7dS2WK3h/wCZiIKD4NgIqIYZBGJiDQvBie2ZPofCXhXFktLSqBbwmT1vwSKlu0tkJ39pyrFT01NVVlh6fFSvXp1Txm0dwAszuqZgWUJpVM6dTgzVTVPtdvLDqmQzO+dd96pbrcyEuhefHFpF2hpgiVjgKUEOtBQ7fr166uGqzKl0R7La9jpWoQC7ECmKw8bHSnYa88PqVz51OJMrDh/HH5MaIoTFp6I5UWlPXKIKLIYBBtUpMYFh3qfZCxGmx6JiIjiS6b/8ead5RRz5szB8uXLcfDgQRQUlCArK9PnepneUmYIef/991WZswS93S4sf07vnJwc3HDDDSHPBlJa8lz+9Vt+LJ1Ucc+WXNxmmYWutfKwZP9hdVl1pKOWPRl/O0tCHq/7vnOQ+v/XkP6KiELFIDgCTYQWz9xQ1Zshihsznbwww5hOGf9XXqOjWJAsuhn2s+5KojXQ4IioMpIVtmdtwVk32FQ584H9RzvFZ2dnY+TIkZ6xthIEl0cC5ZYtW+LCCy9E48ZlS6Iry1Q3cpTOH7/HWoS5JYEzsftcpVOq5WEvXsAAYH/p5XbY8VCbvqhzsAD7/j06k4k/GfOrx4ZWREbBIJgMKR6ZcCPw7gxdGZYMU6g4/pVIB+Iw1v/ExFeQ5LIh3ZWI5H9b4NcPVyGlcS6OP60BDmfn4MeXGyPfmYn//e9os6lHH31UdXX2bnpVVFSkLqtWrTSIDccJJamqE/NxmfnYn52EIdb3MdV5lc86wy2zkGW34nBJadB7XGoWHC4HtuTvQaGzBI/+8RlW/v0Yrm7atNwA+HInK62I4olBsIHFMhA0UzaRjI/jgkkrOCTBXJ3NNSUG1QP5+fkYP348GrYpgGP1yWq6I4cVsK3rgKQTflLrpKWn4vThm7HquxLVTCsx81/0GmpR3ZjdAbBke6VEWqbMDFfrxBfR2lETbW0J6NhyF7JzqqGuzYnEw8m4xzoLiVYgLdGBjNQinJBux4+FDqAESEUN3Gh5Epm18rDPshWjtzyKg47DeOONN/DYY4FPJkgGeMHpj4a9rURUdfGfi4OIiDQZTJDxg914ls4TXdXrdtX06rRLasPW7lcUw4USuFBkcaAov3R+olXf7kJSciLOurw2jj33d1x4U4IKgIU0uRo3bhyuv/76KgXApya8jp7FdXGMKwHZDiAxqQg9+i5Eemo+DhfakGZ3IcXuxAnH7UStjFxk1syDVeZh8pJfkIB1W4825CosLKzwPrds0c/UVURGxEwwVRmzwERERAYS5SywjLu1wYGz7q/vuUwC4Z+tv8L5e0fpE41DX52CFVvXokEnq6e8ud1ppetL92jp9FyVwNftStt0XJGUhoRqJUi0O5BbYIfLZUFhfhIKihJhgQtp1UrgdFmQnp6DC38vneP3qbQn1f85OIg3nOOQ0rgu1h1eB+SXbl/fvn0rvN+rt99Q5W0novAxCDa4aJdEMwAmvWCzpshmD6UBF0WWkcdMs7KApOlVssumpkJKcyXAZUnAup//wwmdG+DQocMoKS5BoxOd+GttPlI7rEar06sjLa0GSkpKPDsvKSkJ5513Hjp27BixHdq7XiGaNtmF5GoF2Lu7FvYdSMMFK+9Q132f9Q4SbS7kFtiQWs2BMxc+6Pm7mh2bAAs2oQQlWJ+7DVixDWlpaejSpQvGjBmDbt268UmPIvYloapiEExhYwBsbGYfi8hxwdolgaLZX59EenFtxixUt6SihiXRMwZPAmGb0wLnN6djd7PlKCl24t9/inBKt4ZoNE6mHqrn+Xt36bO44oorcMwxx0Rs295v/jpsVhssFhdq1D6E/XtrIDmpGJ+1eR4Xrb0NNWvkwmp1objEiht3+3aJnj9/fsS2g4hij2OCybAYpIeGnaGNn2FmwyAiirUM2FDdZUWyy4pElxXVXDY4m62Hs+YO2F02pKZVw6HdRdi2pDW+/2q76vDs7/DhwzjxxBMjGgC/Xf9t7D+YgoIiO7b/Wwd5h1OQUeMwiott2LG7Bh5OmIkvN2Tiuv+uLxMAExnNjz/+qEr4GzRoAIvFgk8++aTSv1mwYIGqypBhCS1atMBrr70GPWEQTGFhgGkMfB7NEwBHDeefjaioZLj5HFEcJcGCBM8BpwOF7ZfhxKsTUf28v5BnLURiUiKqpdtQlJiHTqenIzEx0fO3DocDF1xwAZ599llccsklEd0uiwWquZUEvdLUavM/DXH4cHU4nFas2puMrSXAW64BEb1PIq3Kzc1VJ5peeumloNbftGmTem+eeeaZ+O2333Dvvffi1ltvxUcffQS9YDm0CUR6XDADJyLfAJil00REgdnhgM1aAkv3n3DMadI9ubTJlaPYhQbX/Qa7PRPNjstCszEy9jfdk/nt3r07+vTpE7Xd+vuO6pjk6o/7bLPQulE2/thSG/kOC2wWIM/ixDt+cwMTGVnv3r3VEizJ+jZp0gSTJk1Sv7du3RrLly9XJ6wuu+wy6AGDYAoJA2AyU8a2vOA20O0ZMRDmnKtEVFVp9/wNm82GmglHx/mKY9s3KLNuXl4emjdvjrvvvjsinZ8rkmgBxttnodgFbPw3HQ+V9FeXP5c2HelOS1TvmygWsrOzfX6XxnKyRMKSJUvQs2dPn8t69eqFyZMno7i4GAkJUv+hbQyCIzSWcvHMDdBD8BrNTtFEZsAS6MrJyYDy9pNeOyDH8nmP1T7iHMEUK9s37EXztkenQwrk0KFDuO+++1C7du2YbJMEwVYLcMDlwtMlR8uebz88KCb3T2RLskVlCEzGFjsKCgqQkZHhc/n48eMxYcKEiNzHzp07Ua+e74kt+V26ue/duxf161f8ftcCBsEmzuSGGhAzC2xcbIoVmUDIiNlgItK3eE9p9vdH+ah37tHs02+fHUCHi2r6rFO3bl11gB5Ljzr643rLTLzNcb9kQFJJsWvXLp/LIpUFdpMGWt5cLlfAy7WKQbCJ+QfERgxyoz1PMpkHM8BERKE75rJqyM3OV02u9u0+iJrHlXZ/zsvLR0pKNXXAfPPNN8dl14YaANdLfga7Cu6M2vYQRVJ6eukY+2jIyspS2WBvu3fvVlOaxaqao6rYHZoUIwbAFD7Oweob/IYSAJslWGYpbXTxPVi1seykLYW5xWpc8OE9DjRrXVom6XQ6cPHFF+PBBx+EXjAADp9ZvhvNokuXLpg3b57PZd988w06deqki/HAgkEwkUmZ5cQHv3hJrxgIkxH888VhNGheV83/m7untFxSDBo0CCeddFJct42ISuXk5GDlypVqcU+BJD9v3bpV/T5u3DhcffXVR9YGhg8fji1btmDMmDFYv3493n77bdUUa+zYsdALBsFERBHGwJs0g3MEU5yldSzGwf2HcMIJJ6B9j9JGOieffDIDYCINWb58OTp06KAWIcGt/Oyu1NixY4cnIBbSxf3LL7/E/Pnz1Xv5kUcewQsvvKCb6ZEExwQTUdDY9Cl4bJJFRATUqpuhpk5ZtGiR2h3SsbZv377cNUQa0r17d09jq0CmTJlS5rJu3brh119/hV4xE0yGZ5ayXyIiIq3JzMzEjz/+qH6W+UNHjx4d700iImIQTMbH7tAUL6Ypi2bJLRGVo0mTJrBaS3Mu/fr1434iIk1gJpjI5EKZI5goEtjwKf7Y3Zti5ffff/dkhGUsMBGRFjAIjhAGEmQUDFAiyzTZYD8cP64BGsnQx3rKol69Wsb0/vQg3ic9pPPsLbfcEtdtICLyxiCYyITCGSetx6DGrAFoRRggEFGsPfDAA9zpRKQpDIKJiKKMwTiZNQtMdNZZZyE9PZ07giJGjyflSXsYBBMREVWAJzGIwnf66adz9xGR5jAIJkNjZ2jSCiMGUvEeZ2hGzIAQERFVHYNgIqr8g4KlR0T6wVJoCoAnrYiIjmIQHEHsEE1EFH3sYE5ERERVwSCYyMT8T9wYKbjQYvmxFrcpXoz0WtMUjWWBYz09EhFpEyvKSGsYBBOZTDjTIxGRcRi5LJZTgBEZG4NpihQGwUREMWTYbLDGMpCmxOeAiIgoKAyCiYhMJlbZMp6xJ9IWI1cBEBGFgkEwGRanRyKtMmw2mOKHWWAiIqKgMQiOMHaIJgrj4J0H8ESGIg2x2BSLiIi0ikEwESns1kukUxo7icTgl4iItI5BcIhqtsmMzjNBZHYRPJDXQ7mxHrYx2njixViY/dUHjgsmvWKfCYokBsFEJhLO9EhR/dLxD3w1ltEi0vzJCo28Z5j9JSIiPWEQTGRSmh2/rpGD+ljQfIBFpKMAmHMEExFRsBgEE1F8mCjYNXOgXFklAUui9U0rATAREVEoGASTIXF6JJ0zUYDsDnLl/0CL1rNmHF+oL5F8vhgAExGRXjEINlOZKZGemDAQJtILBsD6xpNXpDdsikWRZo/4LRKR7sS8JNVEAa4Rgp2gs8byvP7xWFivv/2r9oS+cRQXDICNEwj3apQV9fvJzs6O+n1Q7PD5JKNgEExE2hVGUMWsKhFR/APhxMREZGVloXHjxnw6DCYrMxWJCbZ4bwZRlTAIDgOzFmSW6ZGIiLwxC2w80QqEk5OTsWnTJhQVFVX5tr79dxei5dyG9Y7+8uczZa53rvqrSrdvbX9s+Ve2vDMqj9fnMQUjwOOuiATAyUkJod0HkcYwCCai2GIpNJEuMQCmcAJhWaqqenZe1HZ+enr60V9Sy26rMyWxSrdvDXCbXncelcfr85iCUdE2EhkUG2MREVFcp0mKxrh0I5bFx7MxjNYDYM4RXDVslBUnYfRQIKLIYBAcJewQHT+cHqlyfH0SEZEeAmGtbpdh6CAQZ2doigYGwUQUOyyFJh0xYjbZiFlgihyzBZyx6I4da0Z8TETRwCCYiDRZfhmrwNnMU/NorYQ05lN1UaUYAJNp6CAjSkSRwyCYiGD2LLCZA2EyD7Nl+Sg8fJ3oF7PARMFjEEyGwvHAoU+PZKTsW6jlq97Br/zMYFj7jPR6JdJyIMxgmIiMjEFwmHggpj0MgCkStBgIx3NsqtZKpkkf1RVkDPEOhs0aiIeT0WUWmCg0DILJEBgAa5zODta1GAhrmc+BajnPdbDjy3mCkUh7zBqMEpFxMQgmMhlOjxRcoMvyaCIi7WSFKQpZYB00A9NEg04yJAbBpPsMMLPA0cEvHnNkhfVU7swsMVH8MRCODZY3U6y98soraN68OZKTk9GxY0csXLiw3HXnz58Pi8VSZvnjjz+gFwyCo4gZt+hh8KsjOiuFJiKi+AfCRgm2q9LTIZhAmMEyRcKsWbMwevRo3Hffffjtt99w5plnonfv3ti6dWuFf7dhwwbs2LHDsxx33HG6eUIYBJPuMPMbOWbNrIWa3WU2mPTOKAEFmeM1ZarXqw5Kksn4Jk6ciKFDh+KGG25A69atMWnSJDRu3BivvvpqhX9Xt25dZGVleRabzQa9YBBMusHsb+SnRyJjCquzqIbKos16coZIbyIZrLrHHJsqAA4CM70UruzsbJ+lsLAw4HpFRUVYsWIFevbs6XO5/L548eIK76NDhw6oX78+evTogR9++EFXT5Y93htAFAxmf3U6Hpil0OT3ugq3NDDWgXE8p6UiMhMGvcEFwoH2U5UCZGag4y85KSr9V6zVdqKgYB4yMjJ8Lh8/fjwmTJhQZv29e/fC4XCgXr16PpfL7zt3Bj4pJYHvG2+8ocYOS3A9depUFQjLWOGzzjoLesAguArkoMzoZZJawAA4cjhOPfzSZvk7o2coJRs8d+6fkTn5wQMsIlOQ4CycYIzBb2QCYaJApLnVrl27fC5LSkqqcGdZLBaf310uV5nL3Fq1aqUWty5dumDbtm149tlndRMEsxyaiIg0WRZNRPoQSnDGkufweZ9sYJk0VSY9Pd1nKS8IzszMVGN5/bO+u3fvLpMdrkjnzp2xceNG3TwxDIJJ05gF1jEDlkKz8oNIe3jiRj+YySTSnsTERFXWPG/ePJ/L5feuXbsGfTvSVVrKpPWC5dCkWQyAKdIYxEavLDrckshghpsYvQxdq4FHRErjyTQq+wxgABwZzABTNIwZMwZDhgxBp06dVGmzjPeV6ZGGDx+urh83bhz+/fdfvPfee+p36R7drFkztGnTRjXWmjZtGj766CO16AWDYCKTKi+wiEaTBjLx+GCKCL4vSc+BMANgjWHPBvLTv39/7Nu3Dw8//LCa77dt27b48ssv0bRpU3W9XOY9Z7AEvmPHjlWBcbVq1VQwPGfOHFxwwQXQCwbBpEnMAuu8KVYcSqFj1c3XDA2yollmWpUO0USkr0CYwS+RfowYMUItgUyZMsXn97vuukstesYgmMjAOEfwUSyFJiKKDQa/FAmsgKFoYmOsKOOUNKFjFpi0jgE1ERFFDMuTiWKOQXAVmaUskogo1iXx8vnKz1gioghiwE2kMAgmTWEW2AClRxqcGikamVtmg4mIiIj0iUEwaQYDYCLSAiM17uLYTCIiorIYBBOZcGy6mUpMmbElIiIiIm8MgkkTmAU2CA2WQkcTA+zwsOMnEVEccDwwkQeDYCKDCnV6JAYmRERERGQGDIIp7pgFJj1jNvgojj/VFj4fREREgTEIprhiAGwgJiuFpiDwNUFEpA0shSbywSA4AszUZIiI4sNIHYuJiIiI4olBMMUNs8BERGFilp2IiChs9lD/YPPmzVi4cKH6Py8vD3Xq1EGHDh3QpUsXJCcnh78lBp+eZvHMDfHeDE1hAKyt6ZGM2hSL43W1S15zzG5HD8cDE+mwXDlaJ7d0WApt1OMS0mEmeMaMGejcuTNatGiBO++8E5988okKht966y2cf/75qFevHkaMGIEtW7YEfec//vgj+vbtiwYNGsBisajb9Hbttdeqy70X2QZvhYWFGDVqFDIzM1G9enVcdNFF2L59u886Bw4cwJAhQ5CRkaEW+fngwYNBbycRVcLkWSkG20REVB6e8CPSaRB88sknY+LEiRg8eLDKAO/cuRMrVqzAokWLsG7dOmRnZ+PTTz+F0+lEp06d8MEHHwR157m5uTjxxBPx0ksvlbuOBNg7duzwLF9++aXP9aNHj8bs2bMxc+ZMtT05OTno06cPHA6HZ52BAwdi5cqV+Prrr9UiP0sgTPHBLDBFGg8wiIiIiCii5dCPPPIILrzwwnKvT0pKQvfu3dXy6KOPYtOmTUHdee/evdVSEbntrKysgNcdOnQIkydPxtSpU3Huueeqy6ZNm4bGjRvj22+/Ra9evbB+/XoV+P7888847bTT1DpvvvmmKt/esGEDWrXyLRX1zjDL4iaBPpFR5wgm4+nVKIslsQYRalkgS6GJSGul0DxZTbrMBFcUAPuTsuRTTjkFkTJ//nzUrVsXLVu2xLBhw7B7927PdZKNLi4uRs+ePT2XSWl127ZtsXjxYvX7kiVLVAm0OwAWUlItl7nXCeSJJ57wlE/LIoE1VR2zwEQmY/JSeSIiIjJAYyw3CUZlkRJob+3bt0ekSJb4iiuuQNOmTVV2+YEHHsA555yjgl/JEEtZdmJiImrWrOnzdzI+Wa4T8r8E0f7kMvc6gYwbNw5jxozxyQQzEK4aBsAGxSCH/LKQkoXWa3MsrW0PERERaSAIlgD0mmuuUWXGLpdLXSYNq+Rn+d97LG5V9e/f3/OzZHdlvLEExHPmzEG/fv3K/Tv3trh5/1zeOv4kyJYlWNJxl81xiMyJc4UTEZHmaKQUmsgQ8wRfd911qjRZSon/+ecflaH1/j+a6tevr4LgjRs3qt9lrHBRUZHq/uxNMtSSDXavs2vXrjK3tWfPHs86FH3MAmsDgzUiY4vkeOBevThFCRERGVPIQbAEu08//bQaY9usWTMVlHov0bRv3z5s27ZNBcOiY8eOSEhIwLx58zzrSAfpNWvWoGvXrup3aYAlDbSWLl3qWeeXX35Rl7nXIYomNqmKD1ZmaAhL5omITJsF5jATMkQQ3KNHD/z+++8RuXOZzkimK5LFHWDLz1u3blXXjR07VjW2kmmZpEGWzCksjbcuvfRStb40rBo6dCjuuOMOfPfdd/jtt9/UNE7t2rXzdItu3bq1mmZJmmpJh2hZ5GeZRqm8ztDR0HVA7O5La5gFjp9gXndVmpBeA8ENv1yJiMgQNBS4EhldyGOC33rrLTUmWLKtMk5XMrHeLrrooqBva/ny5Tj77LM9v7sbUcntv/rqq1i9ejXee+89HDx4UGV/Zd1Zs2YhLS3N8zfPPfcc7HY7rrzySuTn56sgfcqUKbDZbJ51pk+fjltvvdXTRVq2saK5iYmIyLzNsYiIdI3BNFHkg2AZC7xo0SJ89dVXZa4LtTGWzCvsbq4VyNy5cyu9jeTkZLz44otqKU+tWrXU/MFE8SqFlv9jlRFn+bWJD3o0kJknY5FxwXPn8iQFERGZvBxaMqpDhgxRY29leiTvJZKdockYWApNRAoDdF01xSIinWIWmCg6QbA0p7r99tvZWZnI7BnZWAU1/EIPW7AlyURERNHA4S5kmCBY5uf94YcforM1OsfpZ4jMh+/7qqtSczaKOk6VRKQTPGlMFL0xwTJH8Lhx49S4YOnC7N8YS8qlqfxOvYtnbjDN7jFzKbQWs8BGDNbKO8PM6ZGIiIiIKKLdoVNTU7FgwQK1+DfGYhBMREQBO0RLCT0zFSFhlpyIgsLPVqLoBsEyly9RZcycBS5PLDtEE5G5RLspFrtEE2m40z8DYKLojwkmIv2VQkccO/0SERFRBdgUi3QfBD/55JPIy8sL6gZ/+eUXzJkzp6rbRUREJsKyX+1jgywiDWIWmCh6QfC6devQpEkT3Hzzzfjqq6+wZ88ez3UlJSVYtWoVXnnlFXTt2hUDBgxAenp6eFujA9b2x8Z7EzTPzCW/8c4Ce9+/NGIj0hxWERARUQV4UpQ0EwS/9957+P777+F0OjFo0CBkZWUhMTERaWlpSEpKQocOHfD222/j2muvxR9//IEzzzwz+ltORESmHqdqWjyRQESCWWCi6DfGat++PV5//XW89tprKvO7efNm5OfnIzMzEyeddJL6nypntmmSzCSYLLDWmmOFdbZVIwfgZpweSR5zqM+ZdGhmMKpPwT7XsXx+2SCLiIhM2RhLpkE68cQTcfHFF6vS53PPPZcBsMHnYg2FlgI8Osrsr0vT7FdmBQzTlIXlgESk5897PX/+mtUrr7yC5s2bIzk5GR07dsTChQvLXXfHjh0YOHAgWrVqBavVitGjR0Nv2B2aiIhiq5xqAgZ+pfuA+4GI9BwAk/7MmjVLBbL33XcffvvtNzW0tXfv3ti6dWvA9QsLC1GnTh21viRH9YhBMJEBGmIZFr/oI0JKouOFpdjB00vwyy7RRFHG7z6KsYkTJ2Lo0KG44YYb0Lp1a0yaNAmNGzfGq6++GnD9Zs2a4fnnn8fVV1+NjIwMY48JJqqMWUuhGQCTHnBssHbpJfjVqrlz/2RgTobs6aAwIKYwZWdn+/wuzYxl8VdUVIQVK1bgnnvu8bm8Z8+eWLx4sWH3P4NgoiowXQCskaZYFB4GwsYLgOOVaWeDLKIoY/BrfEmZ0TmuKlqFgoK3ymRox48fjwkTJpRZfe/evXA4HKhXr57P5fL7zp3GneUhYuXQ69evR4sW5ggIqnrQYsT5W82YBQ43AI5W4GymgJwNN/RZGu2D44KJiAyJ39HxJ82tDh065LOMGzeu0ubH3lwuV5nLjCRiQbCk0rds2RKpmyPSNDMFnHpi5OmR9BwIc1wwERFRbKWnp/ssgUqhhUxza7PZymR9d+/eXSY7bCRsjEVkwADYiNUGRKQtbJBFRKR/iYmJakqkefPm+Vwuv3ft2hVGxSDYDHOHRpkRSqGDDWz1EABHDccDG+p9rpmyaCIiIoqrMWPG4K233sLbb7+thrjefvvtanqk4cOHq+ullFo6QXtbuXKlWnJycrBnzx7187p166AXbIxFpucObP0DXP/g3tQBMBkSG2VRlV9DvVqq7sxERJHAbvnx0b9/f+zbtw8PP/wwduzYgbZt2+LLL79E06ZN1fVymf+cwR06dPD8LN2lZ8yYodbfvHkzDBUE16xZs8LB0SUlJZHaJqKYqSiwZdBLZhDXQFiqCwJ0QJWDIDM0VjHKwR4DYSJyM8Nnt1GNGDFCLYFMmTKlzGXSOEvPgg6CZdJkIiOJZ5Ar9x2rMnK9l+364xdsJSSoDLF0PRaBsNw+S7CNi4EwEREZMgi+5pprorslJiONixbP3AC90+t4YGZ5dZCF4hyJMcXSaCIiItIiKbFeuHCh+j8vLw916tRR5dhdunRR00HFdEzw4cOHfdLgVqsVqampMAuzlOsR6aUpFqdHqjoGwlSl1w/HBxMRUQTJOOMXXngBS5cuRd26ddGwYUNUq1YN+/fvx99//60C4EGDBuHuu+/2jF+OeHdo6fh14YUXen5v0KCBGifsXmrUqIFly5aF9siIKCKY2Y4to5WYezNSybLmqx2IKG6M9FlHZEQnn3wyJk6ciMGDB6sMsMxjLA24Fi1apLpQZ2dn49NPP4XT6USnTp3wwQcfRCcIfvHFF3HGGWf4XDZ16lR8//33+O677zBw4EAVqRMRkb5F6+Aw4LjjcqoMGMDqE+cOJiKiSHjkkUewfPlyjBw5Ek2aNClzfVJSErp3747XXntNTevUrFmz6JRD//TTT7j22mt9LuvcuTNatChtLiSp6SuvvDKkOzd6psjo5Zl6HQ9shvHmRFXF0mgK+7XDsmgiIqoiqUAuLi5GQkJCheutWbNGTemUmZkZnUzwtm3bfKJwmUfK+87q16+PXbt2hXTnRGbGEmbSOpYLapAOxucTERFFwlVXXVXhVEwSAPfo0SOs2w46CJaU8/bt2z2/33777UhPT/cJklNSUsLaCCKiqohl1YWRxwPHIhCO25zEFFMsiyYyHzaMpUj75ZdfcNNNNwW8bu3atSoAPuuss6IbBEsb6k8++aTc6z/++GO1DhFpP6PM8ZZEREREpGXffPMNZs+ejXvuucfnchkDLAHw6aefjpkzZ0Y3CB4xYgQmTZqEl19+WXXhcnM4HKppliw333wzzMTMgQTHA5sIyy+JNEnrWXVmg4mIqCpat26NL7/8Eq+88gqeeeYZddkff/yBc845B6eddprqCG2z2cK67aAbY1122WUYM2YMRo0ahXvvvVc1xLJYLGqOppycHHXd5ZdfHtZGmLmB0eKZG+K9GaZjprG4ui3d/eMxaJFu92cVsUkWERERxcMpp5yiqpH79OmD3NxcvPnmm2pKpA8//DDsADikTLB46qmnsHjxYtUlWhphZWVlqZ+lc7Q7OiciihaONzJoBpPTJBEREVE5JPM7Y8YMPPbYYzjppJPUMNzKukZHLBPsPS2SLP727dun5g0ePXp0lTaIyGxZaZaWU1Qy6SxjJyIiIh2rWbOmqjz2tnDhQtSrV8/nsv3790c/CPYmLatlwPLkyZPx6aefqm7RDIKNj0Gbdku7zThHsNHn49ZKHwKWRBMREVEsST+qaAkrCN68eTPefvttTJkyBf/++y8GDhyIOXPm4Oyzz478FuqYjB800wE6kZGFOx5YAleWcRMRERGF5pprrkG0BD0muLCwEO+//75qRy2dumRy4okTJ8JqtWLcuHE499xzqzQ4mYhiw8xdzUk7tN7ZmCKDHaKJiCgWpEI5KkFww4YN8eqrr6J///7477//1IBkdoNmQEEGx3Gl5FcSHWs8aUNEpH2RqHji5z15k6SrNMMqKipCRTZu3Kim6ZUGzlEph5b5gGVgsizM+JoXxwMThf6FzpJoIiIiouC9/PLLuPvuu3HLLbegZ8+ealqkBg0aIDk5GQcOHMC6deuwaNEi9f/IkSMxYsSI6ATBO3bswEcffaSaYN12223o3bs3Bg8eXKZjF5GWaXGO4HA7RGvxsRiVWecHjnnVgUbnhyYiIqLYT4u0bNkyNT3vrFmzVFZY+lLl5+cjMzMTHTp0wNVXX63i0Ro1aoR8+0GXQ0vUPWjQIHz//fdYvXq1SlHfeuutKCkpUXM2zZs3T2WLKTRm7OZLsaHbwM2ggZBmy7xC3N+RLInW4rhgzT5PREREJtS1a1c8//zz+O2331QGuKCgANu3b8fnn3+uMsDhBMAhBcHejjnmGDz66KPYsmWL6gotTbP69OlTZs4mIoodM55Q0XL3dV0EU+4A2KAnHoiIiIgiFgR7/thqVWXRH374oYrI77333qrcHGkcxwNTPLN94TbdWDxzQ0Tu3/A0HAhr9YRCzE/CsFFdQOxATUREMQ2CvdWpUwdjxoyJ1M0RkYmCCbOUlWtq/wcKeuWyIILheHSJ1uq+1nI1glYwSCUiIsMGwWZW0cGWbsdlkqbFpCkWs076VlEwW1mgq+GsMBEREVFVMQgmIoowTWV8wxVkVpiIiIhIbxgEU1A4Hji6ON2RNkWjkiPuAXKogW0560elJJrVB0REuhNuzw4iXQXBDz/8MPLy8spcLnM2yXVEWsVAM/biPQWOuykWm2Pp/zUS95MHREREFFPShNlms3n+j+hth/oHDz30EHJycspcLoGxXEdEpLVgOJY0HayxvJmIiIh0YtOmTfjnn388/8c1CHa5XLBYLGUu//3331GrVq1IbRcRhZDRNswcwSYJ0jQdKMe7JJqIiIgIQNOmTX2WSLIHu2LNmjVV8CtLy5YtfQJhh8OhssPDhw/nExYGCWC0XK7J8cDGGMuqu8ArzlPTGK6zu0lOMMTrtWi41wsREZEGLFmyBPPmzVOZYKk8TklJQYsWLdCzZ0907tw5+kHwpEmTVBb4+uuvV2XPGRkZnusSExPRrFkzdOnSBWYlAQYbAxCZswRa8xgAkwbmCp47l81ziIgoOPv27cMVV1yBH3/8EW3btsVxxx2Hzz77DOeddx62b9+Op556SsWes2bNQu3atRG1IPiaa65R/zdv3hxdu3ZFQkJCyHdGRBWXOWsm684uvWEJJduuuxNnEkjH+XWhu31GREREYbnppptgt9uxbds21K9fX12WlpaGF154QWWCpQpZkrNSifzBBx9ELwh269atG5xOJ/7880/s3r1b/eztrLPOCnkjjE7K5KJdukmkNTJeNFLZ4FgHPlosbdVqOXskn2dFAm1mroko1vjZQ6QpX3/9NVasWOEJgP2lpqbiscceQ4cOHcK6/ZCD4J9//hkDBw7Eli1bVHm0NxknLOODiSg6DN0USyPCDYDDCVKjntnUQPbWLCcMYj0umMMNiMhItHqil+JHSpw3btyIVq3KP87dvHlz2I2ZQ+4OLSnnTp06Yc2aNdi/fz8OHDjgWeR3IgqfUecyjlcXYfcJgmifKKjKl7f8Lb/8icIfa0xERMYzbtw4lXi977778NNPP2HXrl0q4Xro0CH89ddfeOedd9Rw3fvvvz82mWCJyD/88EMce+yxYd0hEZlHxEtloyycTF6kAlhdjHeNUmZZXiNGmG4pqtlgE2b0iYjIvIYPH46srCxV8vzEE0+oAFiqkCUZKzp27IhXX30VF198cWwywaeddpqKvimyWNJKRs8GVyqEcaChjLEP9r2lhXHA5WWFqxRox2B8bSwD2Mr2RSROSjAzHx3M2hIR6d+BAwcwZMgQNVOQLPLzwYMHK/ybjz/+GL169UJmZqYKZleuXBnUfV1yySVYtmyZqjaW/6VTtPwvnaOXLl0adgAcdCZ41apVnp9HjRqFO+64Azt37kS7du3KdIlu3749DK3lncB/L8Z7K4hIA6IVLLlvV/OZYRNjs0MiIjKjgQMHqimKpHGVuPHGG1Ug/Pnnn5f7N7m5uTj99NPVlEfDhg0L+T5r1KiBk08+GZEUVBB80kkneVLQbtKS2s19ndkbY+minJEMTwsZzUhmCWPxnopnGXS870OTzbZ03KU11g2yzIyZZSJj0OR3HQW0fv16FfxKo2SpDhZvvvmmmq93w4YN5TaxkiDZ3chKK4IKgjdt2hT9LSGiCucMNm2ZtAbxC5uIiOjodyKTQNqTnZ3t83tSUpJaqmLJkiWqBNodAIvOnTuryxYvXlxhJ2etCSoIbtq0afS3xOCCmStYxi4unrkhZttkJkYNIDmWvOpCzdoxANZuEzQ+N0REpBc5JSVR+d78Z9deFBQUqMDU2/jx4zFhwoQq3fbOnTtRt27dMpfLZXKdnoTcHfqzzz4LeLmUQicnJ6uu0c2bN4/EthGZWqBscLgYHEQG96M2aD3rwJLo6GMpNBFR+SQmkymFvFWUBZ4wYQIeeuihCnepNKRyx3z+3MNiDR0ES5cu//HB/uOCzzjjDHzyySeoWbNmJLeViIjMMi6YDBu8zp2r3RMYRERGkZ6eHvS6I0eOxIABAypcp1mzZqpZsn9wLfbs2YN69epBT0KeImnevHk45ZRT1P8yWbEs8vOpp56KL774QrWulrbVY8eOjc4WE5mIUcu49diVl1lgbdPa88Pu0dHDLDCRcWjts9usMjMzcfzxx1e4SHZZGmBJ7CfTE7n98ssv6rKuXbvC0EHwbbfdhokTJ6JHjx5IS0tTi/z87LPP4s4771TtrydNmqQCY8OKYgaEYzyJjtJKySu/pM2HzzkREZGv1q1b4/zzz1fTHEmHaFnk5z59+vg0xZKgefbs2Z7fZZ5fmRt43bp16nfpJC2/x3MccchB8N9//x0wvS6X/fNP6fjF4447Dnv37o3MFhKR8TPCcZoOJ5imWAyGYjcdlg+WW1Og11gvZo0otvgdQORr+vTpaNeuHXr27KmW9u3bY+rUqT7rSJAr2WHvnlIdOnTAhRdeqH6X0mv5/bXXXoNuxgR37NhRZXzfe+891KlTx1MHftddd6kyabFx40Y0atQo8ltLZELlBcCsGtABdyCn0zlvtTwu2Ls5llYPUiPWIIsnBIiISCNq1aqFadOmVbiOf++oa6+9Vi1aEnImePLkyWreYAlypRO0ZH3lZ5n8+K233lLr5OTk4IEHHoAZVXQwFpGDIaIK8DUWWVUKrhi4EBFpVryndCOi+Ao5Eyz13uvXr8fcuXPx559/qkhf6r7PO+88WK1WTwdpCh/nCybSOf8AWH43YjaYKIYdolkKTUSR6jGi1Qoi0nAQLGQaJBkULQuR1hl+PC1FJWse9hekmTLAAUqiZVwwMyxE4fM+QcDAn4wsWoFoME01tT6chjQSBL/wwgu48cYbVWts+bkit956a6S2jYhMLNCXmOannakoAGY2OOKqfPDC50Q3zBAMBsqOy2VmeOxE8ZpVQtZnIGxOQQXBzz33HAYNGqSCYPm5ogyxaYJgHjwRGVZYX4hmygDHCj9nA2Km3TiCKQtnIEwU3WkVmRU2p6AaY0kjrNq1a3t+Lm9xT5FEVcfOv8TXh44EGwAzUDadiqoXtDIPttYZNRMayrjocMZQE8VSvLOpkfg85WeyuYTcHdqtqKhIzQFVUlIS2S0iInOpYsOoxTM3RHQ8cEhf5BLUxjuwjcL9y4GA91KhCDX80mJ2M94HdUZm1MA2mhgIE0U/eGUgbB4hB8F5eXkYOnQoUlJS0KZNG2zdulVdLmXQTz75ZDS20VA4hQ2RQYQbfMY7aK4k4I3EAYA0x9I8jT0PZK5gOdyAloEwGUWkTjJGI2hlIGwOIQfB48aNw++//4758+erMcJu5557LmbNmhXp7dMlZg8oHox0giXUL6BwssFhv3e1kP11q+J28IueSH8kEGYwTMTvMIpxEPzJJ5/gpZdewhlnnKEaYbmdcMIJ+Pvvv6u4OeSN44KJNCZSwW+kg2itBOXREO3HZuR9R5rEAJao6qJ9EpcniY0v5CB4z549qFu3bpnLc3NzfYJiIqJIivb0SJVmgcMIlqI6zjWGwVusxgVTACYO0o1aCh0pDKbJrBigUlyC4FNOOQVz5szx/O4OfN9880106dIFpmLigxOKH0NVCESwKVawJdFhlY1XIQAuNxA2eDZYF+OCSbMYAAeHgTCZDQNgilsQ/MQTT+C+++7DzTffrDpDP//88zjvvPMwZcoUPPZYaAe0P/74I/r27YsGDRqoYFpKrb25XC5MmDBBXV+tWjV0794da9eu9VmnsLAQo0aNQmZmJqpXr46LLroI27dv91nnwIEDGDJkCDIyMtQiPx88eDDUh0461K55i3hvAulAhVngEINLCXqDzgDHMXA19YGExk4YmJV/oCu/uxejikbQykCYzNI7J9bfW6b+njSBkIPgrl274qefflJdoo855hh88803qFevHpYsWYKOHTuGdFtSQn3iiSeqMcaBPP3005g4caK6ftmyZcjKylIB9+HDhz3rjB49GrNnz8bMmTOxaNEi5OTkoE+fPnA4HJ51Bg4ciJUrV+Lrr79Wi/wsgbAeGCrrR2RgFQW/ES+LjkMQx4MBigYzBL6xwECYiCg0doShXbt2ePfdd1FVvXv3VksgkgWeNGmSyjr369dPXSb3KQH3jBkzcNNNN+HQoUOYPHkypk6dqrpTi2nTpqFx48b49ttv0atXL6xfv14Fvj///DNOO+00n9Jtmee4VavYB5lSjhnt8Y1Eeu1WHutgq6pZ4CoHuHIfkRpTG8nb0hKjPi4ylWgHqnL7PJlQRfysiTq9ZIG971dvx1EU4UxwdnZ2UEukbNq0CTt37kTPnj09lyUlJaFbt25YvHix+n3FihUoLi72WUdKp9u2betZRzLUUgLtDoBF586d1WXudQKRMutoPTYi0v80UiGVPVcWLBuhPJdBKhERVYDBJOkyCK5RowZq1qxZ7uK+PlIkABaS+fUmv7uvk/8TExPL3K//OoG6Wctl7nXKG/vsHkMsi2SXQ8E3evxxPLDGaT1oinVgGuz9RWC7TF3aHGj/GeEkBBHLoinOKjr2rcpxcby/s+J9/xTncugffvjBp1T5ggsuwFtvvYWGDRsimvynXZL7rmwqJv91Aq1f2e2MGzcOY8aM8fwumeBQA+FIjgsOtvNttILJ1Zv+gZ6YLQCOZIZTi7Q2fCCqUx+RpsiBGw+ASE9jdmNRFu1+PCy/pmDoOQAm4wo6CJYyZG82m02VFbdoEZ1gQ5pgCcnW1q9f33P57t27PdlhWaeoqEh1f/bOBss60sDLvc6uXbsCznfsn2X2JqXXslSK40c0x8gBcMwapUmWltmx+Mz9q/UMeZT3rV6mVopEb4dw5qbmCRjSUkDPYJjMUhnJscHGE3J36Fhp3ry5CmDnzZvnuUwC3gULFngCXOlGnZCQ4LPOjh07sGbNGs860gBLGmgtXbrUs84vv/yiLnOvQ8YJLPWynaTPL+eqBiARaaJVESMH0JE4KcMTO2QS0ZqKqbzbreg6MlYwGMvHzCwwaa47dKTIdEZ//fWXTzMsmb6oVq1aaNKkiZr+6PHHH8dxxx2nFvk5JSVFTXkkZKzu0KFDcccdd6B27drq78aOHau6V7u7Rbdu3Rrnn38+hg0bhtdff11dduONN6pplOLRGVrP4lUWXV5g678tDIApYiXj8QyWopwN5kFFbBl9qAJVLl7BYSTLooN9DOxQTUYO+tX357FN4r0ZpIUguLKxuZVZvnw5zj77bM/v7jG411xzDaZMmYK77roL+fn5GDFihCp5lg7PMi9xWlqa52+ee+452O12XHnllWrdHj16qL+Vcm236dOn49Zbb/V0kb7ooovKnZtYq6V08R4XHK9AuKLAlkGvjukwY8kyVIMzeSk6GVMkgtJQg3iWSFMk8IQtaSYIds/V61ZQUIDhw4ejevXqPpd//PHHQd959+7dVYOqioLsCRMmqKU8ycnJePHFF9VSHskQy/zBkfDtv7vQLz3d1A1VYhEIM8A1J62+X2IeAAcKyFjKa64sL59vinMgXNUMtpGywkY9nosGI2aAvTlXHa1gJZOMCfaeLkiWwYMHqzl5/S8nAzRFinOQygCYtNwZmqIravMpV+Fvo3FQF85tshpBf7QyTjaU7eD4Xoo3nnAgTWWC33nnnehuiZ6ZtIwu0hlhBr8aOwli8A7R5QYhWnnMUfhc4YEFkXlVVqYcrWZaWs4GB+xIb9JjOiKz0Wx3aDIXBsCk1bLVSGffwro9rQTmRGS4KY6infnVSjac9IEnaylWGATrjJZKoqsavMrfuhcyEZ5hj07wG4P9qtuDk2D3I082kEnEuuTZ7IGw0cfJEukRg+A4MsrUGaEGswx8I8soryOKbmCm2wDWjBiMG4LZAz9/3B9EpCVxnSeYwqOV6ZICYVaXdI3Bh3bH6RlovB6bYpFZaX2MMMUXT9ZSLDETHO0dzBIYIt1iN14iogh/rjJDTkQawCCYiAw9PVKgcvF4n5xicK3h7H4568f7NUP6wkCPiEjbGARH6gA2xmWUWmuQRQZ9viNddlrB7VW1DIrvifKxxExHWJJPJsC5iMkfv6co1hgEE5EuRXxcPIMP4+FzSqRpzJgTUbwwCNYxZr7Mgc9zfOiqZFnnjaJC3v/BBLcMgIl0QS+BcLhDIjiUgkibGATHGae3IaJoMmWJmYYDYHaGNj69BHVawn1mbqb8nqK4YxAci50cxYYqzBIaG5/fyONZedJsEK3h4J0o2hgIE1EsMQgm0jFdVRLEoWQ36P0Th+BDV+XWehLF55InUIiMFwhrodkpkZ4cOHAAQ4YMQUZGhlrk54MHD1b4N9deey0sFovP0rlzZ8QTg2AijdJMFjhO400jMT1SuBig6kCgg9QQD1z5PBNpDzPC5sJSaP0ZOHAgVq5cia+//lot8rMEwpU5//zzsWPHDs/y5ZdfIp4YBEdSnM4caiZYIiJN0fvBRUhBKjM3pAEM4IjIyNavX68C37feegtdunRRy5tvvokvvvgCGzZUPGtHUlISsrKyPEutWrUQTwyCw8QMAkWT2U5s6D1YiysDdoY2KjbFIgoOTyYQVV12drbPUlhYWOXbXLJkiSqBPu200zyXSVmzXLZ48eIK/3b+/PmoW7cuWrZsiWHDhmH37t2IJ3tc75084xarWvopQVPE500lMkMQwgyi/oXxHFZ6IlNuM5YnGPg6JCKTMfsJ8Jycoqic8NmzbQsKCgpUYOpt/PjxmDBhQpVue+fOnSqQ9SeXyXXl6d27N6644go0bdoUmzZtwgMPPIBzzjkHK1asUBnieGAQTKQxhswCa7kpVhyrPOS+ejXKQjzJCThdNViLcOCoheeAjIHZS/LHZnoUL8nJydi1a5fPZRUFmxMmTMBDDz1U4W0uW7ZM/S9Nrfy5XK6Al7v179/f83Pbtm3RqVMnFRDPmTMH/fr1QzwwCI7hB6HZz3iRzoNYZqp0JZjPm3g2HyMiquykQq9e0Ztiksjo0tPTg1535MiRGDBgQIXrNGvWDKtWrSoTXIs9e/agXr16Qd9f/fr1VRC8ceNGxAuDYANhSbT+GTILTJqn5WxwNDK1Vcn284QmEVHVMTGkLZmZmWqpjDTCOnToEJYuXYpTTz1VXfbLL7+oy7p27Rr0/e3btw/btm1TwXC8sDEWEWmOmTKUemuyxwOXKJRFllNlobfXBpHRsbyZzK5169ZqqiNpbPXzzz+rRX7u06cPWrU6msg5/vjjMXv2bPVzTk4Oxo4dq5pqbd68WTXI6tu3rwq6L7300rg9FgbBRBqh+SywzrsQB3PwYqagw/9Eg5lOPASNQwAoSBwPHB3cr8bEk6n6Nn36dLRr1w49e/ZUS/v27TF16lSfdWS6JMkOC5vNhtWrV+Piiy9WnaGvueYa9b8ExWlpaXF6FCyHjrwwO4pGokO0YEm0eWi1fFVXwbPegxwt71uNMtOJDiIiokirVasWpk2bVuE60ijLrVq1apg7d67mnghmgquAB1NkOhoKurwz5/5ZdN2cIIgSnmXX0We53k/EEBlAND4DqlQ6LZ8L3gsRRRyDYAOOJdF8WS3p+znTUCBM4alK1Uk8xsRp7YRjqPsgnH2mtcdMRHHEoJgo4hgEE5FuA+ZgTx6wmQkJBpYUDRy3atD9q+UMLLPERFXGIJjI4KJSGhtMcBujjHHYWXQtH+DoUZT3Z7QD2HJvP5qPi12hiQypyqXQoa7P7zOikDEI1pBIjmPUVXkt6VNFQW4IAbBWxq+aJUto1i7Q8Xp+WYVAZCwVvafluri955kdJgoJg+BoHFjxjByZhX+wK79zzHB89j3FFINbEiyFNo6qnCiLWPAbqeNHHocSVYpBsIExG6wPhnmeGJRpglYy64YqiQ7zgLjCg2KWQhPp/mRDXDO/lWEgTFQhe8VXU6TJh6WRD1IpNjQ1BZDGgl//fRPwAMWkBwcshY7e/O+aPRAmoojTzfs9iM8uIrNiJtjgwY1hsoxERBoTVMaXiCgY0To5a9KTvkSVYRBMRES6EWrJcrTXDwtLoQ1BqyW6RGUwECYqg0GwCT5wmA0mqvi9qbvO0GGUt0W1FFpDn3e6fl6JKK4nHcp8Zmj0sy0sRnosRBHAIDgCeKBFRGYQStlvND8Xg7ntiN+/zudBpshiFph0GaByTmEiDwbBJsFssDbxeaFIYtO9yASUUQ1ImY0hIiKKOwbBGsymRKvzLwMuInMyU1doZlQp6q8xjgUmItI9BsFEZBiVTo/ELJyhg129BsB63W6iWDPkCQh+LxHFBYNgk32wMRusf5qaI9gA5bsMQPRPnsNIP48Bb6+qn+ka/E6g0BgyCCPz4WcREYNgIiIjd4Y2eim03k9i6H37iYyG70njn/wmEswEm/BDk9lgbeDzYM6gjcz5uUv6xywwRRwzskRxwyDYZM2xyJx45pUHG1Fj4IO4iAbZBt5PRIY+GWHU965RHxdRkBgEmxSzkETGyiTyRIf+DhyN9PozOmaBKeIYhBLFFYPgaOOHHJEmqy3MgKXlRERERGUxCDYxZoPJSDiEILpBM08qRPZkKLPA+sEsMBGR8TAI1jAe1JORxbR81ygVGSF2hiYiIg3SyneSVraDKA4YBJscs8Hc72bFTByF/TrhgaNpMAtsTvx+IDI+BsFx/NBkeSGFitUBpAc8gPTCUmgi/XeIJiLDYRAcCxrPGjAbTGS80nI2xdIAjX/2U8UYaBERGReDYFIYCJOZMFNJUQ9+ywmA+dojMvkJLa2dHNPa9hDFiD1Wd0Thl7+aIaNTWRC+eOaGmG2LkbOFZinB93mcRvmCZ1OsuJHAtVejLN8L5XUV6DkxyuvN5JgFJiIyNmaCKa7ZYLnPYO6XmWqqCMdKk5azv6QvDICJiIyPQTDFJdgMNvj1/xsjMMrjIKLQgl+WQmsfA2AyJZ7AIxNiEBzvJ0CD5anRDNLCCX6JSKPMfuBk9sdPRKHhZwaRZjAIjrByz/RX4YMvHqWekQ5UIxX8MoAmqlyk+who8WRdrFU1i8sssPYzwMwC60u0ny++Z4mMjUEwlStSQWs0AmozMsu411Afp1n2SyjTI4UrEvuSB46kNwx+KSjM4hIZCrtDU6UBZ6idmc0apJI26K0zdJmuw3qhg31L5uYf3PbqVbaigQEwxQw/M4k0hUEw6TKoDSc41wIt7ks9M3sWOBZYCl3JVEmkSYGCWwa8RNr4TolkBRNRuFgOrZODTB7sl8WAMnT84imlu0BGJ3MEsxSa+0ULGOyS5jALTAby2GOPoWvXrkhJSUGNGjWC+huXy4UJEyagQYMGqFatGrp37461a9cinhgExxI/BImCEsxJHyOcGNJdMO7GzzLSKAbA5mK25liyPe5Fz1hhpG9FRUW44oorcPPNNwf9N08//TQmTpyIl156CcuWLUNWVhbOO+88HD58GPHCIFhHjHDQH2nMButXNL4E9TYe2EifL3o/KCP9YwBMUReH75XyAl9+5lK8PPTQQ7j99tvRrl27oLPAkyZNwn333Yd+/fqhbdu2ePfdd5GXl4cZM2YgXhgERwE/mGJLL4GwXrZTD3hCiPTy+c7vg+jj9EZkxMDZCBlfiq/s7GyfpbCwMC7bsWnTJuzcuRM9e/b0XJaUlIRu3bph8eLFiBc2xtIINgogMpdIlEJHe4w3S9ZI65j9JSMKNvjVc7M+HvcCJUUObP9rf8T37cHdh1BQUICMjAyfy8ePH6/G5cbazp2lr+d69er5XC6/b9myBfHCTLDOMAMWGLOs5nmtR+o9oNcDBy1mNZitCIz7JboYABNfB/ycocCSk5Nx6NAhn2XcuHHl7q4JEybAYrFUuCxfvrxKu1tuw79M2v+yWGImmAxDr9MmBYMnP4w1HjiaAfj+VXuidtsUfPaFATARhfNdFM5nh14zwswGR1d6enrQ644cORIDBgyocJ1mzZqFtR3SBMudEa5fv77n8t27d5fJDscSM8GxpvGDczI+PU+TxJMBpAcMgPXfFZio3KBUo8dx/NyhqsjMzMTxxx9f4SLZ5XA0b95cBcLz5s3z6TC9YMECNdVSvDAI1pBgx98xENBfWbRWtyveOOZUG3MEB/2ZwlLoSvFAlIjK+7zU9OeHRoN70p6tW7di5cqV6n+Hw6F+liUnJ8ezjgTNs2fPVj9LyfPo0aPx+OOPq8vWrFmDa6+9Vs0zPHDgwLg9DpZDk+EYrSzazCc95LG7y3uNsh/0UrLGExShYwAcG8wCU9x5B4wROlEZic8PPZZFsyRafx588EE1xZFbhw4d1P8//PADunfvrn7esGGDGofsdtdddyE/Px8jRozAgQMHcNppp+Gbb75BWloa4oVBcJRE+4PIOzggbWMWWLvkPcrAJXxm3nf+n/Fm3hdEWjgx0qtX5Oee12MGVY+BMOnLlClT1FIRaXrlTbLB0nwrHt2py8NyaDIkBp7GISd8KssC66UpViQPTGI+tlvD+zXeGADHcF9zLDAZkNk/Q1h5RPHAIDgeKjiY5AeBsQJhLWwDEUXvwNXsB6+xxACY4vba4/ucyHAYBOuYUcZIxjMIleu1HKjyOSatvsZ4UEhEVHX8LCWKD44JJtMJFPRGo5mWloNrIzXF0Ev1hJ7GaJXZpyyFpjhjFpjI2Nggi2KNmWAyPHe2t7Ksr5mCVj3PFVyhMII1PQWnWsHMBRFpjR5PlETrs5Sf0USVYxAconMb1kO0hZLZYrmsNkUioOZzWznDZ4FDnHqDHePJiPQY3BCRcb/TyRgYBEdRhWfiWF6oSWbKBpN+xTST7/dZxQwDEZlRpD/7+FlKFF8Mgg2AGUNtBcIMpGNz9jeSZ4yjWRKt5XJrfnaQ1jELTERE0cAgWKMHtSwJIQpRFasr5H2t5YA1Vir67GHmgoi0TC8nTfhZWvF3EI+BKRYYBBNFMJsbqSwwM3QVi+YXZCSD4SrdTojjgYmMRi8BDRFFHgNhijYGwWHSWsaIQVPksazZ3Kr6HtfaZwQREZknC2yEbDOzwmTaIHjChAmwWCw+S1bW0QNLl8ul1mnQoAGqVauG7t27Y+3atT63UVhYiFGjRiEzMxPVq1fHRRddhO3bt8OIGAjHNxDWW9CstWmStHjWN9yssGECYK8ScyMcUBERVUVVPwf5OWqc4wPSP00HwaJNmzbYsWOHZ1m9erXnuqeffhoTJ07ESy+9hGXLlqkA+bzzzsPhw4c964wePRqzZ8/GzJkzsWjRIuTk5KBPnz5wOBzQ+hhGvunNiSczoLn3RShBbbQD4EidvODrjLSMpdBE5I3HxBRpdmic3W73yf56Z4EnTZqE++67D/369VOXvfvuu6hXrx5mzJiBm266CYcOHcLkyZMxdepUnHvuuWqdadOmoXHjxvj222/Rq1evKm2bHOxWdlZPro9lVkgObDlXaGTpLcNrSjGYcsz9Po7Jmfw4jQcu7yCD2Qsi0tMJlF69tJc55Odo5L6jtFbJRvqk+Uzwxo0bVblz8+bNMWDAAPzzzz/q8k2bNmHnzp3o2bOnZ92kpCR069YNixcvVr+vWLECxcXFPuvIbbVt29azTnmkjDo7O9tn0QtmeMiotHAmuKKTWoYpgyYiIiIyME0Hwaeddhree+89zJ07F2+++aYKert27Yp9+/apn4Vkfr3J7+7r5P/ExETUrFmz3HXK88QTTyAjI8OzSPY4nIPeeB0UMxDWJ7M/b1oIcokovlgKTUajmyxwDKqqIoHHCmT4ILh379647LLL0K5dO1XOPGfOHE/Zs5s0y/Ivk/a/zF8w64wbN06VU7uXbdu2hbz9kQiAq/JGN3tARUSB8bOBiIx+IiVaJ1N0E9DqbFtDxUCYDB0E+5PuzhIQS4m0e5ywf0Z39+7dnuywrFNUVIQDBw6Uu055pLQ6PT3dZ4lKABzls2482CWjfLGV+4UX4zPXRj6o0GNGgIyFWWCK9OspGq+pUL4HTPOdEQcMhMk0QbCM012/fj3q16+vxghLkDtv3jzP9RLwLliwQJVMi44dOyIhIcFnHekwvWbNGs86keAf8HJcIIWDJyyO4hdbePgaIj1jAEx6em1JcBtMc1SKLh4vkCGD4LFjx6qgVppg/fLLL7j88stVg6prrrlGlTPL9EePP/64mgJJAttrr70WKSkpGDhwoPp7Gcs7dOhQ3HHHHfjuu+/w22+/YfDgwZ7yajMdGPPgmCj69HDAU95nATtDE5GRRTMrrOXP/pC3jVVAZBKaDoK3b9+Oq666Cq1atVLTIEmTq59//hlNmzZV1991110qEB4xYgQ6deqEf//9F9988w3S0tI8t/Hcc8/hkksuwZVXXonTTz9dBcmff/45bDZbRLfVnf2NRhY4Ume5GAxrF09SlMWzu4Fxv5ARMQtMen+t+QfDWg6MjYbfi2S4eYJnzpxZ4fWSDZ4wYYJaypOcnIwXX3xRLdGmlzJod8DF+YRJL7TyBaeHgxrOFU56wwCYjEQP3xNBZYPjNF99VY4TOH8wGSYTTNHFzDDpPvhl2VZIWHFARMQTL0allRPmpA8MgnUimm9sBsPxxcCkYvxSIzIuZoGJYvA+M0J2Okg8ZqBgMQjWAo1ksxiMERnjYIPvZdIDBsBEGqaRY1OiaGEQrCOxOLvFrLC5ghWOn9FXcBstPHNORERGwe80CgaDYNJkcEZEkcX3NGkJs8AUb2Z7DRr5RC5ROBgE60wsz24xK0yaZuRSrXg/tnjfPxERxZ+OvwuYDabKMAimSjGDFB3cr8alhTPufH2RVpktA0dERNrDIFiHZ9vicXaLB9RkZloIaquC718iItL7dxlRJDEIpqDxQDpyuC+JyIyYBSYt4esxCCyJJoNiEEwhYfBGmqDjL+VYCmZcP8dNERERkdkwCNYSjZdEuzEQJiKiUDHrRqRTOj7xzBO9VB4GwRQWBsLh474zB469IiLSPrOdnOF3E1EpBsFao5NssGAwRxQfkXrvx/szhMzDbIEGEWkHv+soEAbBVCUMhLm/iIgqwgCYyAB0XBJNFAiDYJ3TwtktBsJk5C9ilo4REZGRmPF7TQvHy0bx2GOPoWvXrkhJSUGNGjWC+ptrr70WFovFZ+ncuTPiiUGwFunwbBsDYe4j0hceEFAsMAtMesDXKVHwioqKcMUVV+Dmm28O4a+A888/Hzt27PAsX375JeLJHtd7JyIy+Nn2Xo2yoCs6PAlHREQx+n744zHuapN76KGH1P9TpkwJ6e+SkpKQlaWdYyJmgg1AKxkdZoOJiMiN2TUi0hKtHC/HSnZ2ts9SWFgY1+2ZP38+6tati5YtW2LYsGHYvXt3XLeHmWCt4tk2Q+EJAtISsx0IEBGRASqVDKa4yIGt/xyI+O3mHcxGQUEBMjIyfC4fP348JkyYgHjo3bu3KqFu2rQpNm3ahAceeADnnHMOVqxYoTLE8cBMsEFo5aCWwR73SVSxVJdIF5gFJr3ha9Yc38NaOV6OtuTkZBw6dMhnGTduXLnrT5gwoUzjKv9l+fLlYW9P//79ceGFF6Jt27bo27cvvvrqK/z555+YM2cO4oWZYAORN7Zz5Z+aCIT3r9oT783QBJ4UICKzYTBBZHCsVtSF9PT0oNcdOXIkBgwYUOE6/9/eeYBJUWxtuNhdcs455yySoyASBAUBSZKDiki6igiCgIAgIEEJl3hJElSSqGQkSBJQcs5JFEVyZrf/56t7e/6e2Z7dyd09/b3P07DT06GmT3VVnTqh8uTJIwJF1qxZpVX49OnTwiioBJsZNjKWhcovMSt2mQUnhBASRJdoC49RzWI0MhMZMmSQW6i4ceOGuHz5slSGjYLu0GGGWQa4dlYC7fzbCSH2hlZgQmyExV2jiW9cunRJHDhwQP4fHR0t/8Z27949xzFFihQRK1askH9jf9++fcWuXbvEhQsXZIIsuERD6W7SpIkwCirBJGjYURm04m/mbCghhBDCSRxCPGHw4MGiTJkyMtEWFFz8jU0bM3zy5EkZhwwiIyPF4cOHRePGjWVm6A4dOsj/oRSnTJlSGAXdoc2OD+4mdPMwBisqwGbyHjDjjDNcxcIJy8iaWBJagQmxYZZotW+2mGs0x8q+g/WB41sjWFEUx99JkyYV69atE2aDluAwxSyDXasqhp7+Nu1GiOXfcbq2EUJsjh0ncwIy4WvB/sMsY2ViDFSCrYAFGxYt4aIgUum1F+FmBSaEEOIZVIT9GK+qm4UUYSrD9oTu0GGMmVw9rLxsUrgo8Xqw4bcPlDUhhJCgukZrcVWETe4ubaYxMwkNtARbBQvNqrnDim7DVisvCQy0AhNCiL2xozU4qP2f1kps0jEtJ4vtBS3BYY4ZZ7asYBW2g/JrqcbepB2m0UnxzPh+E0JIOCnC9epZqK80o0XY237dYIuxdmzE/jW8oRJMDFUyzagM20EBJvayAltqwoMQQohp+sKgK8NxKccmUYipDIcndIe2Ej5aw8w8ADaTwmlFd21C1KQeZn7PCSHEqtjVLdoUE8MmcZ9mPxue0BJsE8zsNqmneIbKQmxXpddSClMIOz+rW4H9cuNy85xhBbD6c7EqqgWGz58QY7GrW3RI3aMtYiGOKFXAsHuTwEIlOAzjBMOBQCinroq0XRVe4hnhpmhYaqKDSNwNMuMbfIZb3SWEmA9TKMI2GwuT4EIl2EaY2RocDKj06kPliBBzEKgBpfY6VIgJCQ52twYbGiesBxVh4ieMCbYifriHUgEiliJErtBUHEioCdYgEtfVboSQwGH3+GBtn2mKftOOK0eQgEFLsA2xm0WY/D+cBCHEeEKpnDKmO7BcOfOPR8flKJAuwHcmZoEWYZNZhmkRJj5CJdimUBEmpoczvCQMMWKwSEU4uAqvv+dSYbYeVIRNpgyr4wXGCRMvoDu0jRUEWgUJCa4rtGXcUTnhEBKMrA+WqYsmAAqsPwqwr/dz3Yi5oWu0ezdpw1yl2ZcRL6ASbHOoCNsHypoQYWsl1AxlMDNmUz6pEFtDEaYybDKFmIow8RAqwVYmQC86lSNiOpgQi4QRZlI+zVQWM2Em5VcPKsTmhoqw5wpxSJRiKsLEAxgTTCSMEQ5vONFBwgk9Rc4UmUotonQyRtg6ym98ZWY8sfkUYbsvo+QJru11UNpJJswi8UAl2OrwJSckfOH77fEgyYxr5ZpRAXYtm1melRFYUQF2hQqx+aAybCKlmH0oiQMqwcQBrcHEFNAVmvg5EKKCR+ygALtChdjcLtK0EBuUbZqKMHEDY4KJc4V4jm48hNiKMI6dwgDKKGusma3AVixnIAlHBdjsSb7I/yfRYjItzwlYDHEY93PEd2gJDgcCPMtFi3B4wYkNYkUCqZyF2jJsR8XSKthNMcTvZdywdZJp0Vrs5llp2m6f21dahIkLtAQTXag4EUOgK7QpCbVSF6z7GWkZNjN2eSZ2U4BVaBW2DrQWe/CM/JnMpEWYaKAlOFwIwgwXLcKEhDkmHBCEQiELpmXY7/J7046bUH5mxa4KsN4zoGXYOjDJlpvncuUP/yzCIMBjZmI9qASHE3T1IFa26HNATyy+VJDPgzJfB2Pa8/x8f8J52SQqwLGfBxVh67pO02U6QMmzOGa2PVSCwy0THuODCfHoXbM9Jpx0MMItN1BWYZ/KHkhLRAAV4nCByq9nz4YKsbWgQhxgqzAtwraFSrAJ0A6+/HqZgwTdogkhwcbodi/kyyoFc+BFhZgKsB+TBVSKrQMV4v89B7pHEx+gEmxC/FaEGR9MrAYtV7aeqTZaAfZXGfa6/KGUJ+7l4fvlj0u0XqZbI6D117hnSOXZWOy+LjHdo4m3MDu0wbgbcPhtjaBSYXssFQ8cIugK/T/YPgQsk7SZFHi3hPkkigoVYOOfv95GjMGuaxL7nT2a/aNtoCXYxC+q2Wa16BZNCAk0Zlci3ZXPZ48doxRSDy3CVkyQRUXLevKh1Ti02M1tOiAelTaaQLQrVIINwptBhpnihKkIu38ucRFzwF4zsV7BWVfbPm+ztGt2K3u4QOXXunC5JuOwy7JLARk7UxkOaxIoiqIYXQgrcOfOHZE6dWpx+/ZtkSpVKqOLQwghhBBCCLGgPrBu3TrRpEVnUar+CBFoHty6LC7vmSBu3rwZ8GuHE4wJJoQQQgghhBBiG6gEE0IIIYQQQgixDVSCCSGEEEIIIYTYBirBQaZIkSIiQYIEji137tyCYdiEEEIIIYQYx5YtW5zG6OoWFRUl435Lly4tevToIU6dYnLTcIRKcBDZtWuXOHnypNO+S5cuiZ9++imYtyWEEEIIIYT4QHR0tEyAdejQITFlyhRRpkwZsXfvXj7LMINKcBCZO3euV/sJIYQQQgghoadly5Zi7NixYtSoUaJJkyaO/Q8ePBCffso1g8GFCxdEly5dRN68eUXSpElF/vz5xZAhQ8STJ09EXMALdujQoSJbtmzyvJo1a4qjR48KI6ESHCQePXokvvnmG8fnQoX+fz225cuXi7t37wbr1oQQQgghhBAvqF+/vujbt6/o37+/HKuXLFnS8d2JEyf4LMV/n0NMTIyYPn26VGInTJggpk2bJj766KM4n8+YMWPE+PHjxeTJk6VVPUuWLKJOnTqG6kNUgoPEihUrxK1btxyf582bJyIjIx0zSloFmRBCCCGEEGIOd+jdu3eLixcvOvZBaSNCThTMmTNH1K1bV+TLl080atRIThxg0iAuK/DEiRPFwIEDRdOmTUWJEiWkXgR9aNGiRYY9VirBQULr8lyhQgVRqVIlUatWLd3vCSGEEEIIIcbRqVMnR2KsypUry7hgEBERIT744IOA3itx4sTi6eO7Iib6qQg0Tx7eFLfu/TeuWbs9fvxYBIPbt2+LdOnSuf3+/Pnz4o8//pCKs/b3v/DCC2Lnzp3CKKIMu3MYc/XqVbFx40bH59atWztiDdT927dvF2fOnBEFChQwrJyEEEIIIYQQ94wYMUI0bNgwoI+oevXqIjoipTjwy/ciYZaaAbuuosSIx8eXioikmWWGay2I3UVcbiA5e/asmDRpkhg3bpzbY6AAg8yZMzvtx2ettT3U0BIcBObPny/95eUDjogQLVq0kH83a9ZMJEyY0HEcXAEIIYQQQggh5kiM9dlnn4m2bdtKizBAvOuwYcMCei+ESK77bq54em2TUJ49CNh1o/85KJSnd8WNS3ulhVa7DRgwwO15Q4cO1V0uSrvt27fP6Zzff/9dukc3b95cdO3aNd6y4RqubtKu+0IJLcFBQKvcYqYHmdBA2rRppSvAjz/+6FCW8VIZWQEIIYQQQgixO1DoOnbs6PiMzMeffPKJ/Hv48OEyK3LKlCkDdj8khopInlMqwolyvur39ZSYZ+Lp1dXiPzMmijRp0nh1bo8ePUSrVq3iPCZPnjxOCjDCPOE2PmPGjDjPU+OpYRHOmjWrY//169djWYdDCZXgIK8NvHXrVrdKrrpmcO3atQNdDEIIIYQQQoiPIKePyrNnz2RW4xdffDGgz3P/z9+K0mXKiahMVURE4vR+XevZ9e1CRCYR7dq18/rcDBkyyM3TsE8owGXLlpVJsuD1GhdYTgmK8IYNG+SaywBLKkFHGj16tDAKukMHGG8TXjFBFiGEEEIIIeYCSq9r1uhAU6pUKRGZtrR4enWtX9eBSzUsymtXznWsRhMMfv/9d7nGb86cOcXnn38u/vrrL2nhVeN+VYoUKSJXygEwBvbp00eMHDlS7jty5Ii0uCdLlky88cYbwihoCQ7i2sBIHV6+fPlYxx08eNCx3hhSik+dOjWg7hWEEEIIIYQQz1m7dq34+++/pbJ77Ngxp+V7oFhWrFgxKI/zwoEVImfufCL6/mURmTynT9eAAgzXam0G5mCwfv16mdgXW44cOWLF+KrAKxZxyCr9+vUTDx8+FN27dxc3b96UzxLXMlL/SaBoS0zcgtTiyLIGgaZKlUr3mMWLFzvNaCxZskQG2buyevVqpyxzs2bNknEGhBBCCCGEkOCzZcsWp+VL4wKxwYMHD/ZIH/CFhFlri5h7F0Tiwu94nSso5vEN8ejIWHFg/z5RunTpgJUp3KE7dJASYmG9rNdee033uHr16jmSZQG6RBNCCCGEEGIOsI5t7ty5xeuvvy4txFCAg8nfJ5aLmEd/ipjbx70+F67UkemeowLsJXSHDiB4STwBLhUIKieEEEIIIYSEHsS2msUhFtblSRM+E70+GC6SpC4sEiTwLK4XLtTRt46IyxfPBb2M4QYtwQEEQeFY8ujWrVuBvCyxOYFooH/99deAzmKiTHDr/89//iPMwG+//SYXazcbiP3/4osvhNlARsaZM2cG/T6IGVKXlwgFiDNC4o1gJC/xBLjJ4f53794VRnH58mW5xqXZQJvx/fffS/dDo0EZkI/DKDAJPmLEiJDeE8lrcE+zDPgfP34s86GcPXs2aPeIiYkRS5culatwmI1Dhw7JULhQc+HCBTFu3DhhBMiujKVBDxw4IIwCfZIZ+2SVt99+G+sciei/nRNyuQPv89PL34uoTNVjxeeS+KESHECw1hXWysI6WkOGDJEDskAm3SLGgGePVO6hBgN5xJm3b9/e52vs2bNHvPrqq6JcuXLi3r17fpcJDe4PP/wgExogrt3ohG5Q7hs1aiTT9D94ELjF5gOh/LZt21YUL15c/Pnnn8IMQHabN2+WM9/YoqKC5wh0+vRp0aFDB1G4cGFx8eJFEWzQ1qLNRdu7bt26oGbGjEv5xTIQCxYsMOS9gPKLhCNY11JNvGgm5RdtEN5VI9eEVOP/sCVJksQQ5bdnz55SRlCCQqX89u/fX9bN7du3ex1rGCzlt0CBAuLDDz8UuXLlCory++2330rX0ObNmzuFnxnN4cOHpXstyhbKyTIov2+99ZYoWLBgUCce4lJ+ixYtKjMCa9eaDRX4zZ06dZIZi69cuSLMSsKECcXSRdPFk6vrhBL9ON7j4ToNF2q4UhMfQGIsEj+3b9/G9Kn8Py7atm0rj8OWMmVKZeDAgcrff//t9yPevHmzUqdOHeXnn3+muELE/fv3lQkTJijFihVTnj17FrLnjnt99dVXSpEiRWQ9ev/9972+xs6dO5X69es76iK2VatW+VymmJgYeX7ZsmWdrvnnn38qRrB3717llVdecSrL7t27FaM5fvy48sYbbygJEiRwlGvdunWGlgmy27Bhg1K9enWn53X+/PmA3+vEiROyDYyIiHDcZ/78+Uqw+Oeff5TBgwcrqVKlctzv448/VkIF+oNPP/1USZcuneP+3bp1U0LJpUuXlHfeeUdJmDChowxz5sxRjAb17vvvv3dqMzJlyiT3h5otW7YoNWvWdJQD9TO+vjyQXLlyRenRo4eSKFEiRxmmTJkS1Hv+9ddfyocffqgkT57ccc9Ro0YpRvHo0SP5m3PkyOEoz8svvxzQe0RHRyvffPONUrx4ccc9smTJYkidc+XQoUPK66+/7tQG//bbb0G/L9r5N998U4mKinLc9+uvv1ZCwdOnT2X7X7BgQce9n3/+eSWUnDlzRunUqZMSGRnpKMMPP/wQEn3AV1BfI5LnUaKy1lGSlfvc7Za07GglQZJMypdffhmUctgBKsEBrvSzZ892auSwpUiRQunfv7/slHzl4cOHSpIkSeT10Jn/9NNPpmjYw5G7d+8qY8aMkQM2PO/GjRuHrMNYsGCBUqhQIaf6402DjUkSTJa41kEM+m7duuV1mVDHVq5cKTsu12tioBFq9uzZozRs2FD3HXvy5IliJuUXGwYeqE9GANlBAa9SpUqs55UnT56g/H6t8qtuUNICzc2bN5UhQ4YoqVOnjnW/TZs2KUYov+q2ZMkSxSjlN5gTHN7UO7RZ5cqVi1Wu5s2bG6r8qlv58uVDcv/Lly8r7777rpPyq25Hjx4Nyj0xzsB4Q6v8qtuuXbsUMyi/6jZ69OiAKb9Q7LTKr7q1atVKMZLDhw/Leu9arjRp0gR1cl1P+VW3P/74Qwm18qtu7733nmKU8uvPWCiUSjDYsWOHIiISKUlLDXarBCfK/bqSIHEG5fHjx0ErR7jDxFhegjV+kydPLl28sMHtRv0bW9KkSWOdAzdUxGghZhHuan379hWZMmXy6r5w3apatarYtGmTdOnCVq1aNfHxxx+LOnXqBN3FCS5MyJRn1GLl2bNnD7pLE9LdT548WUyYMEHcuHHDsb927dpBdxXCWnSI14IbqRbIVW+tab0YT8Sju4t9gsvZvn37REREhLwmNvVvvX3qNRGzhLXe9IBL07Zt2xzlVM/T/u/ub2/OSZ8+vVycHbGliEPWA263+/fvd3punv4d3/eoexkyZNC9L9xOhw8fLt3W9WLt4HqGGKS4iO/dhetkihQphKegHHAJxvPavXu37jGFChWS36nP2N0G4NINFy09jh8/Ln8/loPT+/0ZM2aULqDYfKkXuC/ur4J8CxMnTpSbdv1BFZyHJSuwvqP6LFyfjTef0dbj+WvdntFGIKbun3/+0X0madOmDZirK+o+6p+r2/OoUaPku/n06dNY56CuopyBKAPujTJ4Ap7dmjVrxNChQ2WbrQeeJWSjfc7q367/q8dDBt6CtgvlcBd/jPrvyfMpVqyYT2EDcLdEn4+4e71QGrzP2I/xhDtQ93F/T8HapqiXGGfcv39f93qJEiWS7rha3MUIo4z58uUT/owZZs+eLeuqO/dTjIPcyUGv7uuFDCHmF23Q0aNHdY/JmTOnU9/grt11/Yz4Sk/rvh5HjhyRfTLcsvVAu6a2U3py8LXuI/wEoRnI14GxhSv4XQjRiS9MB+XzNqxEDeGCPE6dOqV7DGQaXx1EXYXrtC+cO3dOfPrpp3K1Fr3cEHiuly5divP+/tb9QFClShURmbqwePr7epEoz+uxvoer9JPf14mli+fI95r4iNFauFVQZ34CsSVNmlTOhsGVz1NgXdC6/Gm3ihUrKmvWrAnabx8/fry8z/Lly5VQgllruEsF27Jx584daVXCzKze882cOXNQZk4xCzx37lylQIECcdaXtGnTxmkZrVGjRsDqphm3XLlyGXr/SZMmeWz5DcYGrw9PgeW3QoUKAb2/nss73J5btmwZ9N+fIUMGh+V36NChupbfYG6wIqpthDvLbzA3WBE9sfwGa5s6dapHlt/Vq1cHvN5h27Ztm+INW7duVWrVqhWw+9+4ccNrt2d3ll9vN7jxegLCrQYMGCC9YQL57GvXrq0E2vLrzdarV684Lb8YEyFUKVh1f8aMGT79/iNHjigtWrTwu22EJdAbLly4oLz11lsBax+8sZaqIVyuXmy+bqg73nL27Fmlc+fOsSy/vmz16tUz3BIMTp06pYgEUUqS4n1jWYETZqsrXabpEeofTIxlAJiJglUX6dA9BTM9etYYWO4wq621VgQaWIDVWeRQAosKNvzGYCa6wWxryZIl3c46J0uWTJYh0OCamAnHb4yLuH47ZmuRbAYWt3AFlj2zzXSizqRJk8athdQokPSjTJkyAS2XnqU6S5Yssu5504b5c2/V08YoYA2EzI2sh/AGQsIts9U5AIuTntUp1EA+RnksAXiCpUuXLqRlQD+COhGMPsoX0F/hXQnmM0C7AI8HPGuzATkEM+mgO3BPPHOj6gHuH+qEhFpwbzO9B4EAnmRRGSuJJ1d+dNqvPL0jnv6xRfy8fqHhie6sTgJowkYXwgrAvQwDPrgvYVDu6kaqbshAV716dd1rwLUJLlrNmjXz6UWtW7eu2LBhg/wb92rRooXMiOqr24hVgMsQ3JKCnVUUrjPffPONlJHWlWfKlCnSjT1YqG6EkCVclrWgnsA1GwpXXMDlHuUcO3askyu3VjmC+6urC7/6t94+uAzB9XPZsmW6A9zWrVvL77UKSiD/Vv/HwB+udXG5F1auXNnhdqbnaunub0+ORd1zp+ypy9HANVWvXFAUkRnXHZ40v1mzZtUNs4jPJQ4uYXPmzNGV3WuvvSbrizaUw3VTy5c7d263gxu4JGO5ifHjx+u6J+OdxfJV2t8bn7y1f6P+azOJwh0a90PIgjt3aNwPE1eu+/WOjW8fFE/t5NjDhw/lCgCQOZbEc+eKG58bp6egr3Gd4EK2388//1y+e3oZ0aEc7Nq1KyCDI1zL04kONXM83PCRtV0PZClGhlaV+EIREALjbd0HaOtQjrVr1+p+j4z7niwZh7rny8AervKq275eBmC4W2KZGO04wLUtcK37nmRIV++J8YqekoLxi95Ejl5dwXP3JwQJ7c7ChQula6y7bMQIA6pQoYLud6h37sJQtM8MIUDoO3fs2KF7DOSsrXPqeXF9Brg33j9fQagIQpzchcrAEDJ37ly3ckAb4ksGc4QOjR49WkyfPl32m3ru0J4sU+ZL3Vfd0+EGrnX11oL2u0GDBrH2a3877utrBmmMW+CCD1d8vXARGI3chVV5WvdVfQB9kD91xBPQ3mfKmkskzt9RRKYqIPc9ubBUKM/ui2c3Q5NhPqxRbARcdJAQJnHixDLRjzeuVp66P8ycOTOWa0XhwoWVxYsX+5UEAYkG1EQXzZo1k5kGSXDAs543b56SL18++bzh9mlUNlVs2OcpqtsmXKhd66GvidnOnTundOnSJZabUf78+ZVQA5fQ7t27x3I3RIiBkckh3Lmq4plBJkYB2em5iOXMmTOgblRqoiq9kA2UIdDE5R69ceNGJdg8ePBAmThxonRZdb3/woULlVBw/fp1pV+/fkqyZMlilQFJYYxCbcf0EmM1bdo05CE1rlnyQ5mhFu7UgwYNkitFuJYhWH04wqzcvYtGrC6B/hRhP+gvXMszcuTIgNU5vPdVq1Y1PBmbXuhMmzZtYiUNRJ3AswkWV69elS7lGO+6PhN8F0zURGV67upxubkHkosXL8pM/a59MtzUvQlFNNIdWiVh9peViGQ5lKRlx0jXaLhIw1Wa+I9tlGDEj+BlgJJ67NgxpXfv3lKpxIsSrCWSkBkPcRKByACI2M9GjRqFJKU++S/INoz6UqlSpZDGXajLEakZmfv27ev1NVBPhw0b5qQkrFixwq9yIebGNdsisp+aRencvn27IWWJr1zBjNf3FChFHTt2dJJdMJRTvSWLgrlcD5ThTz75xKmeY1m6UKGnDCMjayjRU4ZnzZqlGI2aJRqZmNVypU+fXg6QQ42rMoyBMOpOqNBThoO9rImqDGvfjeHDhytGoacM161bNyjLwWkz4mfMmNEUcZN6yjDGdcEGCi/Gu1pleNGiRUoo0FOGS5UqpYQSjPFd++TvvvvOUkow+pkECVMrifK2USJTF1OiMlUNyX3tgG2UYCTtcF2/EeuwYimBQFV6NLSwsKCRhyUxkLN8wZwxJPEn+jBi4Ib6hMYayS4CYaHr06dPQMp1+vRppUOHDrIzxySPkWhne0eMGKGYBW3Hi7U6zQJk1759eym7YCqnGIBjvV4M+lFXgo2qDCO5HaxBoUarDCM5jBFolWFMxpoFtGM//vijI3HWwYMHDSuLVhn2Z910X0ESK0zSIIkVPLpCgdZrwtdkV8FShlFXg7G0nasyHKzlqPxdSx1LMYYKVRnGUpv+jCkCsX4z3gMj+2R/x0KhVoIB3hkRmUwREYllW08Cgy1ighGrhxgxxAw2adLEsb93794yLgcxXK4glkIbTwHffywzgxhAdzEAOAbxfy1btjRl8hJiTfCK+hvfhxg1LK/VvHnzgJULcV5Y/qdevXrCaPBe7ty5U757ZgLlwnPv2LGjMBNYigvLO7366qtBvQ/q3apVq0L2+9EGY2mQnj17GpKcBjHDiPNr27atjGU3AiyVg7i8bt26CbO1Yxs3bpTJe2rUqGFoWZB7AUvENGzY0JD7473AsmLBzDXhCuLpUTd79epliuRBiBlGDg4sBeNr/KcndW7z5s0yxhN5I8wE+s5ffvlFtGnTJqT3RS6D7777Trz99tsi1CDfCPoDLD9UqlQpYQRYrgs5WN58802fr4GYYCy9hXcq2MkhtfHWiTOUFhGpCoonF1eE5J52wBZKMBIFIMkAEiegwVXBWmpYS0xvHVQkR0JiDUIIIYQQQgjRTnIj0RixLqGfKjcQV2taXBa2AQMGiPfee8/xGTM+yJKKzHOhmvkh5kCd9YvLC4CEJ5S9vaH87Qtlb18oe3sTn/yhOyDruz/Z04k5sIUSjFT3SLnuuqTF9evX3S67A5ctvXXuoABTEbInkDtlb08oe3tD+dsXyt6+UPb2Ji750xgWHhgfGBICsC5e2bJlHWvsquCz1j2aEEIIIYQQQkh4YwtLMIBrc7t27US5cuVkgoQZM2ZI12azJQ8hhBBCCCGEEBI8bKMEI2vsjRs3xLBhw8S1a9dEiRIlxOrVq2WcryfANXrIkCG6LtIkvKHs7Qtlb28of/tC2dsXyt7eUP72wRbZoQkhhBBCCCGEENvEBBNCCCGEEEIIIYBKMCGEEEIIIYQQ20AlmBBCCCGEEEKIbaASTAghhBBCCCHENlhSCf73v/8tSpUq5VjIGkserVmzxvE9cn0NHTpUZMuWTSRNmlTUrFlTHD16NM5rzp07VyRIkCDW9ujRI8cx27ZtE6+++qq8Lr5buXJlrOv88ccf4uWXX5bHdO/eXcTExDi+Qzlw3pIlS5zOmThxosiTJ4+fT8UeBEP2M2fOFNWrVxdp06aV20svvST27Nnj9vhRo0ZJOfbp08dpP2UffPDsy5cvL1KmTCkyZcokXnvtNXHy5EmnY/7880/RsWNHWQeSJUsm6tevL06fPh3ndZ8+fSozx+fPn18kSZJElC5dWqxdu9bpmGfPnolBgwaJvHnzyrqVL18+eY72HWcdsJ7s1XbZdWvYsKHjGLb94Sl7LeiXIXdcO65ysO0PH/ljbNCsWTM5/oJcMRZzhe2++WV/79490aNHD5EjRw7ZNxctWlSOFf3t89nuhz+WVIJR0T/77DOxb98+ub344ouicePGDmVnzJgxYvz48WLy5Mli7969IkuWLKJOnTri7t27cV4XShWWT9JueDlU7t+/L18UXNcdGCTjhYViduHCBbF48WKn73E9HIMXkJhD9lu2bBGtW7cWmzdvFrt27RK5cuUSdevWFVevXo11LK6JNaahiFP2oWfr1q3i3XffFbt37xYbNmyQAxTICu+mOgmCTvLcuXPiu+++E/v375fLoGFiQz1GD7yT06dPF5MmTRLHjh2T64c3adJEnq8yevRoMW3aNFm3jh8/Luva2LFj5Tna6/D9t5bsly9f7tTmHzlyRERGRormzZs7jmHbH56yV7l48aLo27evnAx1B9v+8JP/gwcP5GQmxhQYK+jBdt/csgf/+te/pAL71Vdfyb4Zn3v27Cnrgj99Ptt9G6CECWnTplVmzZqlxMTEKFmyZFE+++wzx3ePHj1SUqdOrUybNs3t+XPmzJHHeAoe3YoVK2Ltb9asmbJkyRIlOjpa6d69uzJlyhTHdy+88ILSqVMnJUOGDE77J0yYoOTOndvje5PAyt6VZ8+eKSlTplTmzZvntP/u3btKwYIFlQ0bNkhZ9u7d2+l7yj70XL9+Xb6LW7dulZ9PnjwpPx85csRJnunSpVNmzpzp9jpZs2ZVJk+e7LSvcePGSps2bRyfGzZsqHTu3NnpmKZNmypt27Z1fGYdsJ7sXUF7jPf/3r17ut+z7Q8v2eO4qlWryj6kQ4cO8r13hW1/+L/7GIPh3XeF7b65ZQ+KFy+uDBs2zOm4559/Xhk0aJBffb4WtvvhiSUtwVqio6OlGxNmbOAae/78eemSiJki7cLXL7zwgti5c2ec14JLBWYPYW185ZVXnGaEPKV///6iV69e8p44v3379rGszR999JF0w/BkhpqERvaus8Ow1KdLl85pP2Yj4SKJ2WU9KPvQc/v2bfm/KqvHjx/L/7UeHLDqJUqUSGzfvt3tdXCe9hwAtyrtOdWqVRObNm0Sp06dkp8PHjwov2/QoIHjGNYB68neldmzZ4tWrVqJ5MmTe1Ueyt6askdfnDFjRtGlSxe3x7Dtt8e7rwfbfXPLXpXRqlWrpPce9FV49aGfrlevnl99view3bc2llWCDx8+LFKkSCGVHLgxrFixQhQrVkwqQSBz5sxOx+Oz+p0eRYoUkXHBeJHgwoyXo2rVql7FFIFy5crJF/Hy5ctS8UIZXUGsMK4Pt11ivOz1GrXs2bM7KbtQtn/77TcZn+IOyj60oLN77733ZAdYokQJx3uMiawBAwaImzdviidPnkhXN8gfrq7uQGeJ9xHvO2J84XYFVyrtOR9++KF0m8c9EiZMKMqUKSPjwrFPhXXAerLXglwAcIfu2rWr12Wi7K0n+x07dshJD+SFcAfbfnu8++5gu29u2YMvv/xSjgFhwMLEB+LBp06dKo/zp8/3BLb71saySnDhwoXFgQMHZJzAO++8Izp06CD9+lWQ5MD15XHdp6VSpUqibdu2MuYXcUHffPONKFSokFO8n6dERUW5jS8BUN4w+4x4wr///tvr69udQMteC+I8MQmCOEF1lhATGr1795bxJq4zh65Q9qEDiTAOHTrkFHcP5XTZsmVyFhgzxUiQgphvJKuDZcAdX3zxhShYsKAcTKETxbU7derkdM7XX38t68CiRYvkhMi8efPE559/Lv/XwjpgLdlrgUKEwVWFChV8Khdlbx3ZI08E+nwowBkyZNA9hm2/fd59d7DdN7fsVSUY40EYsX799Vcxbtw4aWzauHGjX32+p7Ddty6WVYJRaQsUKCBnYWCdg/KKSq0qn66Wv+vXr8eyEMZFRESETHDjrSXYU9D5IiPhiBEjgnL9cCZYsodCM3LkSLF+/XqnxFdoVHGNsmXLysYOG5I1oOHF33DL9gbK3n+Q9AIdHtyeMPurBXLCJMmtW7fkrC4SZty4cUNmdXYH3CGR7R2u9UiSc+LECeltoD3ngw8+kF4CcJUtWbKkaNeunUzAEZd3gDtYB8wje20YBKx+vliBvYGyN4fsz549K5NXYsUHtV2fP3++vD7+xvds++3x7scF231zy/7hw4cyxBBWXbzLGLtBoW3ZsqUc0/nT5wcStvvmxLJKsCuw9sHHHxUYyhBcG1TgGgOlpUqVKl5dDw1q1qxZg1JeKNkYPCONOzpiYqzsYZUfPny47DihXGupXbu2dMFGfVA3HNOmTRv5t7czh5S9f7JGBwdL/U8//RRnh5U6dWrZ0WEiC5nEkUU8PmDphys8MlDCsqA9B0oSZKcFstcukeQprAPmkz28f9COYLASTCh7c8geFiDXdr1Ro0aiVq1a8u+cOXOy7bfJux8XbPfNLXvkb8Hma98cV58fSNjum5MoYUEw6wM3F3RScGnC7D1cX6DAqGv4waIHVwds+BvuMW+88YbjGkhYhYqvWnE++eQT6RKN4+/cuSOtfOgIp0yZ4pQ468yZM47PSMSEY+B+g2V1vAVJlipWrCjTtHtjpbYzwZA9XKA//vhj6eYK67xqScasIDasT6eNPwFImpM+ffpY+z2FsvcNJKiBnBC7A7mossLAB0ktwLfffisHQXgnMciFKzuWz9AmTHOtA7/88ouM5X/uuefk/1hrGh1ov379HOdglvnTTz+V1y1evLhMfIfZ586dO7MOWFj2WldoHIv32hW2/eEnewx+XdvvNGnSyP/V/fA6Ytsfvu8+JsnVUCr8jbYfYzr0+/A2A2z3zS17JJtF8lNY7PEZseEwfMCrQ5t3x5c+n+2+DVAsCJYpQTr7RIkSKRkzZlRq166trF+/3vE9lsoZMmSIXC4nceLESo0aNZTDhw87XQNL3GA5BJU+ffoouXLlclyzbt26ys6dO53O2bx5s0yT7rpprxMXesvq4B64hnaJpPPnz8t9uB8JvuxxPT254jreyJKyDz56csKGJc5UvvjiCyVHjhxKwoQJ5TuNZRIeP34cZx3YsmWLUrRoUVln0qdPr7Rr1065evWq0zl37tyRMsc1kyRJouTLl08ZOHBgrGu7g++/OWWvXWJF25ZoYdsfvrLX4m6JJNdrsO0PD/mrYy3XDcepsN03v+yvXbumdOzYUcmWLZvsmwsXLqyMGzdOjgf96fPZ7oc/CfCP0Yo4cQaWTSzajYXf06ZNy8djIyh7wjpgXyh7+0LZ2xvK375Q9sYRNjHB4QRce+H2SwXYflD2hHXAvlD29oWytzeUv32h7I2DlmBCCCGEEEIIIbaBlmBCCCGEEEIIIbaBSjAhhBBCCCGEENtAJZgQQgghhBBCiG2wrBKMNWKxJizWBMPaYFWqVBF79+7VPfbtt9+Wa8hOnDjR4+tj/Vmcg3XmtGzbtk2uG5ctWzb5/cqVK2Odi3XMsJYtjunevbtjwe7+/fuLokWLOh17/PhxeZ127do57V+wYIFImDChXKeMhEb+c+fOlce5bo8ePdI9HuvNqWsTU/7Wf/dv3bol1yTMmjWrXEMU7+rq1asd3z979kwMGjRI5M2bV943X758YtiwYY73G/Ddt6bscUzhwoXlNbEG+b/+9S+n957tfvjK/+nTp/I9zp8/v3zvS5cuLRPVuIPtvjll37Fjx1h9d6VKleK97rJly0SxYsVE4sSJ5f8rVqxw+j5Pnjy64wL0FSps960n+5kzZ4rq1avLBLTYXnrpJbFnz55Yx02dOlX2+WgbypYtK37++Wen7yl7a2NZJbhr165iw4YNUlnEwuhYEB2VGItea4GSikWxoZB6ysWLF0Xfvn3lC+LK/fv3ZSc5efJkt+djoFy+fHmxZs0aceHCBbF48WK5v1atWuLEiROOxb7V1OgYdG3evNnpGthfoUIFuWg7CZ38sfD6tWvXnDY0fq6gAZ4xY4YoVaoU5R8Gsn/y5ImoU6eOfF+XLl0qTp48KTvJ7NmzO44ZPXq0mDZtmnz3MXk1ZswYMXbsWDFp0iTHMXz3rSf7hQsXygnKIUOGSLnOnj1bfP3112LAgAGOY9juh6/88c5Onz5dvsfHjh0T3bp1k0sU7t+/P9axbPfNLfv69es79d3aSUw9du3aJVq2bCmNEAcPHpT/t2jRQtYdrcy110QZQPPmzR3HsN23nuwxxm7durUce6Me5MqVS15Xe030A1C+Bw4cKNsD6AQwcF26dMlxDGVvcRQL8uDBAyUyMlL54YcfnPaXLl1aGThwoOPzlStXlOzZsytHjhxRcufOrUyYMCHeaz979kypWrWqMmvWLLmwduPGjd0ei8e3YsWKWPubNWumLFmyRImOjla6d++uTJkyRe6/d++eXMh98eLFjmNbtGihfPbZZ0qqVKmU06dPO/bny5fP6beQ4Msfi6+nTp063kd99+5dpWDBgsqGDRvkAuy9e/em/C0u+3//+9/ynXvy5InbYxo2bKh07tzZaV/Tpk2Vtm3bOj7z3bee7N99913lxRdfdNr33nvvKdWqVdM9nu1+eMk/a9asyuTJk532od9v06aN0z62++aWfXzjNT0w/qpfv77Tvnr16imtWrVyew76+/z58ysxMTGOfWz3rSd7vbF/ypQplXnz5jn2VahQQenWrZvTcUWKFFH69+/v+EzZWxtLWoLhlhgdHR3LQgc3ie3bt8u/4aKIWb0PPvhAFC9e3ONrwy0qY8aMokuXLj6XD1aFXr16SfcazB61b99e7k+ePLm0EGutvlu3bhW1a9cWVatWdey/fPmyOHfunLQck9DKH+7ncLnJkSOHeOWVV3StAXCDatiwoZyJpPzDQ/arVq0SlStXlrLNnDmzKFGihBg5cqS8l0q1atXEpk2bxKlTp+RnWA5wzwYNGjiO4btvPdlDrr/++qvDFQ5tL6wIeMe9gbK3pvwfP34c5zVV2O6bW/aqdS9TpkyiUKFC4s033xTXr1+P87qwAML6p6VevXpi586dbj2GvvrqK9G5c2fpcqvCd996snflwYMHMjQiXbp0DlmjX3CtH/isrR+UvcVRLErlypWlFe7q1atyBmfBggVKggQJlEKFCsnvR44cqdSpU8cxW+fJjPD27dvlDPJff/0lP/tqCQZPnz5Vrl27Fmv/Rx995Cjj0aNHpQUY5Yc1+I033pD7MROVOHFiOQNGQif/Xbt2yescOHBA2bZtm5zhS5o0qXLq1CnHMbDilyhRQnn48KH8rGcJpvytJ/vChQvLdw6W3n379kk5p0uXTvnkk08cx+B6mAHGvaKiouT/uJcrfPetJXvw5ZdfSi8dyBXt+jvvvOP2WLb74SX/1q1bK8WKFZPtPLy31q9fL9v9RIkSOY5hu29+2cP7DtbCw4cPK6tWrZKWwuLFiyuPHj1ye0288wsXLnTah89a2Wv5+uuvpVUSZXCF7b61ZO8KvDZh4VfHdrgX2vodO3Y4Hffpp5867qtC2VsXyyrBZ86cUWrUqCErKRql8uXLS/elokWLykFs5syZnRqq+DrDO3fuKHny5FFWr17t2OePEuwOuNDiPJQNbtINGjRwKGDZsmWTf3fq1Em+8CR08tcDAyI0pj179pSfL126pGTKlEkqySrulGDK31qyh3t7zpw5ZQerMm7cOCVLlixOA+EcOXLI/w8dOqTMnz9fKspz5871qNx8980p+82bN8vzZs6cKeW6fPlyWReGDRumezzb/fCS//Xr12U/HxERIa+JAS4GxFCEAdt988tej99//10qucuWLXN7TXy/aNEip31fffWVnBDVo27dusorr7ziVbnZ7ptT9lpGjx6tpE2bVjl48KBjn6oE79y50+nYESNGyElzT6DszY9llWAVxNmiwqvxHVAq0elhlggvi7qhMqOTQ6eox/79+x0vmLrhGup18BIGYjAE6y5mGTHb+Prrr8uXT51JSp48uXLy5EmpjA8dOtSn52E3AiV/d3Tt2tURMwRZu9YRfFbvpVWg3EH5m1P26GBr167ttA8TYjj38ePH8jMUYNfYweHDh3vcIVL25pQ9Yn/79u3rtA+WBihBmAhzhe1+eLb7sAAhnhhW5H79+knrMGC7b37Zu6NAgQLSy84dmOwaP3680z58zpUrV6xjL1y4IOvSypUrvSov231zyl5l7NixMhfM3r17nfaj30cbgklRLb169ZLjBU+g7M2PJWOCtSDOFkua3Lx5U6xbt040btxYxgQdOnRIHDhwwLEhSyTihHCMHkWKFJFZ57TnNGrUSMbl4m9kcA4EiGOoWLGijF/Ashs1a9aU+6OiomTa9/nz58sMtYwHDq389cB4F+fi+gCx2651pFy5cqJNmzby78jISMrforJHTP6ZM2ecljtC7C+unyhRIkfMUESEc5MJmWvPiQu+++aUvTu5/m+SOCDlpezN3+4j5hDZ4BGDiGVzcE3Adt/8stfjxo0bMr+K2n/rgTwQarZnlfXr18uxmCtz5syRMafe5grgu29O2QOs7jB8+HC5JBrGclrQ72NJJNf6gc969UMPyt4CKBZl7dq1ypo1a5Rz587JGB64rSKTm7vsrnpuUe3atXPK8uaKnjs0MkTCaqxajjFriL8vXrzocdkHDx4ss9BhgwVY62aBfbBAeBPLYEeCIX9Y33Hds2fPSpnCLR0xgr/88ovbcnjrDg0of/PJHi6PKVKkUHr06CG9MRBfBNd3vJPa9gA5A/Dd+fPn5QxxhgwZpNXIUyh788l+yJAhst2Fm7t6XcSGwdKgwnY/fOW/e/du6TaJdh+5IJApPG/evMrNmzfdloPtvrlkj/fz/fffl66raJsR4oA4UrTXCHVzJ3vEe8LaB4vh8ePH5f/o81EntMAjBNbhDz/80Keys903n+zhhQmvzKVLl8r8PeqG66kg1hhu1bNnz1aOHTum9OnTR3pswiuAsg8PLKsEI0EBljRBJUbcHpa5uHXrltvj9TpDdGQY2HqjBOMFg/LrusV1HVfUa7im5v/555/lfle3TBIa+aOBQ0eHa2bMmFHG/7jGgwRiMET5+0ew3n3IumLFijIeDNdHAgytizs6VMgadSRJkiSOZcxUd2lPoOzNJ3tMRGICDIov5AoXScSEapUgtvvhK/8tW7bI2EK89+nTp5eDZb3ER67XYLtvHtnD7RT9NfptKC1ooyFjTG7G1+5/++23MqQF52H5G7040nXr1smxGSZIfYHtvvlkj7ZBbyyPSVEtyN2DY3Hv559/Xtm6datXZafszU0C/GO0NZoQQgghhBBCCAkFlo8JJoQQQgghhBBCPIVKMCGEEEIIIYQQ20AlmBBCCCGEEEKIbaASTAghhBBCCCHENlAJJoQQQgghhBBiG6gEE0IIIYQQQgixDVSCCSGEEEIIIYTYBirBhBBCCCGEEEJsA5VgQgghhpAnTx4xceLEoFy7Zs2aok+fPiIcSZAggVi5cqXlZEIIIYSYBSrBhBBC4qRjx47itdde8/kpzZ07V6RJkybW/r1794q33norJMpdIBg6dKh47rnnjC6GuHbtmnj55Zfl3xcuXJDP7cCBA0YXixBCCLEMUUYXgBBCiD3JmDGj0UWwJFmyZDG6CIQQQoiloSWYEEKIX4wfP16ULFlSJE+eXOTMmVN0795d3Lt3T363ZcsW0alTJ3H79m1pscQGi6qr6y3+Bk2aNJHHqJ/1rNBwc4a7s8r9+/dF+/btRYoUKUTWrFnFuHHjYpXxyZMnol+/fiJ79uyynBUrVpRlCySHDx8WL774okiaNKlInz69tHKrz0H7Wz7//HNZThzz7rvviqdPnzpZeRs2bCivkTdvXrFo0aJYLspaizmOAWXKlJH71eei5w6Oe6MMKtevXxevvvqq414LFy6M9ZsgN/yOTJkyiVSpUsnfd/DgwYA+N0IIISTUUAkmhBDiX0cSESG+/PJLceTIETFv3jzx008/SYUTVKlSRSpwUKCg4GHr27evrms0mDNnjjxG/ewJH3zwgdi8ebNYsWKFWL9+vVRuf/31V6djoIjv2LFDLFmyRBw6dEg0b95c1K9fX5w+fTog0n/w4IG8Xtq0aWXZv/32W7Fx40bRo0cPp+NQzrNnz8r/8azgKo5NBcr877//Ln/DsmXLxIwZM6Sy6o49e/bI/3EvPLfly5d7XGYoxHCnhryWLl0qpk6d6nQvRVGkQv7HH3+I1atXy2f6/PPPi9q1a4t//vnHyydECCGEmAe6QxNCCPELrcURFsXhw4eLd955RypViRIlEqlTp5ZWyrjceFXXaMQOe+PuC0vr7Nmzxfz580WdOnXkPiiXOXLkcBwDpXPx4sXiypUrIlu2bHIfFPG1a9dKpXvkyJHCX2BFffjwoSwHLM1g8uTJ0tI6evRokTlzZrkPSjL2R0ZGiiJFikglc9OmTeLNN98UJ06ckMoslOhy5crJ42fNmiUKFiwY73ODVdmb53bq1CmxZs0asXv3bmkVB3iORYsWdRwDRR3WbSjGiRMnlvtgxYYVGkqzNp6bEEIIsRJUggkhhPgFlCUokseOHRN37twRz549E48ePZJuyqpCGCyg4MLVuXLlyo596dKlE4ULF3Z8/u2336RVs1ChQk7nPn78WCqPgeD48eOidOnSTr+3atWqIiYmRpw8edKhBBcvXlwqwCpwi4aiCXBcVFSUtLaqFChQQCrOgQblxb1UZRtAKdcmMIPlF5MMrs8Iyj6eOyGEEGJVqAQTQgjxmYsXL4oGDRqIbt26SQswFNDt27eLLl26OMW6+uNqDQVWi/a6rt/pAUUUiieUOq0CChBHHAhQDli79dDuT5gwYazvUD71Gu6uHazn5q7MAOWCkq4XO62X7ZsQQgixCowJJoQQ4jP79u2Tll8ko6pUqZK0tiKmVQtcoqOjo+O9FhRE1+Pg7otYVy3a5YBgKcV5cOtVuXnzpnT3VUHSKFwXbr04XrsFKtNysWLFZLlg/VZBDDKUUVcLtDtgicWz3L9/v2PfmTNnxK1bt9yeg2cL4ntu+B4x2ypwe8a9ID8VWKK194JFGvHAsBi7PrcMGTJ49JsIIYQQM0IlmBBCSLwgSzCUPO126dIlkT9/fqlMTZo0SZw7d04sWLBATJs2zelcZDeGWy1iX//++2+ZREoPHIdjoHhBkQXIRgxFDbG2SGI1ZMgQJ2UOllxYnZEcC+fiOyR8gvKpAiW0TZs2MukUEkedP39ext0iVhcJn7wBrsCuzwGKKq6fJEkS0aFDB1kGuIj37NlTtGvXzuEK7YkS/NJLL8lYWyS8gjKMv5G92Z3FFlmb8T3im//8808pJ/W5/fjjj3JDrDEydmsVXLiLI5EXYpF/+eUXaSXv2rWrvJYKygI3c2SVXrdunUyitXPnTjFo0CAn5ZkQQgixGlSCCSGExAtcYmFR1W6DBw8Wzz33nFwiCQpliRIlZIKoUaNGOZ2LDNFwl27ZsqW0UI4ZM0b3HrAmb9iwQS6zhOuDevXqiY8//lhmmy5fvry4e/euVGa1jB07VtSoUUM0atRIKm7VqlUTZcuWdToGCbBw3vvvvy8VQBwL5Q/3UoGiqc3UrAcszK7PAcpjsmTJpKKIrMko5+uvvy6zKCMJljdA2YfSjN+D5aKgpKZMmVIq2HrASovM3NOnT5dJvxo3biz3d+7cWSrk+M0vvPCCTFhWq1atWM8Evx/fN23a1LEUkvZ5YJIAZcH1MJnQqlUrqQx7qtgTQgghZiSB4kuwESGEEBJGQLFDFmYk94orG3OoQUZrKKrIGg2lmhBCCCH+w8RYhBBCbA/ciWEJNVoBxpq9cB0vWbKkjOmFBRxu4rDGEkIIISQwUAkmhBBie+CubQaQwfmjjz6S8dVwg4YrOVzMXbNKE0IIIcR36A5NCCGEEEIIIcQ2MDEWIYQQQgghhBDbQCWYEEIIIYQQQohtoBJMCCGEEEIIIcQ2UAkmhBBCCCGEEGIbqAQTQgghhBBCCLENVIIJIYQQQgghhNgGKsGEEEIIIYQQQmwDlWBCCCGEEEIIIcIu/B93iKqSkdBA6AAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1200x600 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# Inputs for cross section\n",
    "directory = '/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/future_urban/3hr'\n",
    "start_time = datetime(2017, 6, 22, 12, 0)  # Start time: Year, month, day, hour, minute\n",
    "end_time = datetime(2017, 6, 22, 12, 0)   # End time: Year, month, day, hour, minute\n",
    "#start_point = (-94.1,29.5)  # Example start point (latitude, longitude)\n",
    "#end_point = (-95.0,28.1)   # Example end point (latitude, longitude)\n",
    "#start_point = (-94.4,29.9)  # Example start point (latitude, longitude)\n",
    "#end_point = (-95.2,28.5)   # Example end point (latitude, longitude)\n",
    "start_point = (-94.4,30.5)  # Example start point (latitude, longitude)\n",
    "end_point = (-95.2,28.9)   # Example end point (latitude, longitude)\n",
    "\n",
    "# Cold pool intensity data for minimap\n",
    "cpi = xr.open_dataarray('/pscratch/sd/d/dbrooks/acc2017_analysis/TS_Cindy/future_urban_cpi.nc')\n",
    "cpi = cpi.sel(Time=slice(start_time, end_time))\n",
    "\n",
    "plot_cross_section(directory, start_point, end_point, start_time, end_time, cpi, sim='Future+Urban')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/future/3hr/wrfout_d01_2017-06-01_00:00:00\n",
      "/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/future_urban/3hr/wrfout_d01_2017-06-01_00:00:00\n",
      "+proj=lcc +a=6370000.0 +b=6370000.0 +nadgrids=@null +lon_0=-97.5 +lat_0=36.700012 +x_0=0.0 +y_0=0.0 +lat_1=32.5 +lat_2=42.5 +no_defs +type=crs\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'LambertConformal' object has no attribute 'map_proj'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[10], line 196\u001b[0m\n\u001b[1;32m    193\u001b[0m start_point \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m95.848124\u001b[39m,\u001b[38;5;241m36\u001b[39m)  \u001b[38;5;66;03m# Example start point (latitude, longitude)\u001b[39;00m\n\u001b[1;32m    194\u001b[0m end_point \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m86.297920\u001b[39m,\u001b[38;5;241m36\u001b[39m)   \u001b[38;5;66;03m# Example end point (latitude, longitude)\u001b[39;00m\n\u001b[0;32m--> 196\u001b[0m omega_diff, theta_diff, future_theta_cross \u001b[38;5;241m=\u001b[39m \u001b[43mplot_diff_cross_section\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfuture_dir\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfuture_urban_dir\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstart_point\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mend_point\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstart_time\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mend_time\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[10], line 86\u001b[0m, in \u001b[0;36mplot_diff_cross_section\u001b[0;34m(future_dir, future_urban_dir, start_point, end_point, start_time, end_time, downscale)\u001b[0m\n\u001b[1;32m     82\u001b[0m \u001b[38;5;28mprint\u001b[39m(proj)\n\u001b[1;32m     83\u001b[0m \u001b[38;5;66;03m#############################################################\u001b[39;00m\n\u001b[1;32m     84\u001b[0m \n\u001b[1;32m     85\u001b[0m \u001b[38;5;66;03m# Interpolate cross-sections\u001b[39;00m\n\u001b[0;32m---> 86\u001b[0m future_theta_cross \u001b[38;5;241m=\u001b[39m \u001b[43mvertcross\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfuture_theta\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfuture_pressure\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwrfin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstart_point\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mend_point\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mend\u001b[49m\u001b[43m,\u001b[49m\u001b[43mll_point\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbot_left\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprojection\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mproj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlatlon\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmeta\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m     87\u001b[0m future_omega_cross \u001b[38;5;241m=\u001b[39m vertcross(future_omega, future_pressure, wrfin\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, start_point\u001b[38;5;241m=\u001b[39mstart, end_point\u001b[38;5;241m=\u001b[39mend, latlon\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, meta\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m     89\u001b[0m urban_theta_cross \u001b[38;5;241m=\u001b[39m vertcross(urban_theta, urban_pressure, wrfin\u001b[38;5;241m=\u001b[39murban_ncfile, start_point\u001b[38;5;241m=\u001b[39mstart, end_point\u001b[38;5;241m=\u001b[39mend, latlon\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, meta\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n",
      "File \u001b[0;32m~/.conda/envs/myenv/lib/python3.11/site-packages/wrf/metadecorators.py:1732\u001b[0m, in \u001b[0;36mset_interp_metadata.<locals>.func_wrapper\u001b[0;34m(wrapped, instance, args, kwargs)\u001b[0m\n\u001b[1;32m   1730\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m _set_horiz_meta(wrapped, instance, args, kwargs)\n\u001b[1;32m   1731\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m interp_type \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcross\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m-> 1732\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_set_cross_meta\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwrapped\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minstance\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1733\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m interp_type \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mline\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m _set_line_meta(wrapped, instance, args, kwargs)\n",
      "File \u001b[0;32m~/.conda/envs/myenv/lib/python3.11/site-packages/wrf/metadecorators.py:976\u001b[0m, in \u001b[0;36m_set_cross_meta\u001b[0;34m(wrapped, instance, args, kwargs)\u001b[0m\n\u001b[1;32m    974\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m start_point \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m end_point \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    975\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m start_point\u001b[38;5;241m.\u001b[39mlat \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m start_point\u001b[38;5;241m.\u001b[39mlon \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 976\u001b[0m         xy_coords \u001b[38;5;241m=\u001b[39m \u001b[43mto_xy_coords\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstart_point\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwrfin\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_timeidx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    977\u001b[0m \u001b[43m                                 \u001b[49m\u001b[43mstagger\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprojection\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mll_point\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    978\u001b[0m         start_point_xy \u001b[38;5;241m=\u001b[39m (xy_coords\u001b[38;5;241m.\u001b[39mx, xy_coords\u001b[38;5;241m.\u001b[39my)\n\u001b[1;32m    979\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n",
      "File \u001b[0;32m~/.conda/envs/myenv/lib/python3.11/site-packages/wrf/interputils.py:396\u001b[0m, in \u001b[0;36mto_xy_coords\u001b[0;34m(pairs, wrfin, timeidx, stagger, projection, ll_point)\u001b[0m\n\u001b[1;32m    391\u001b[0m     xy_vals \u001b[38;5;241m=\u001b[39m _ll_to_xy(lat, lon, wrfin\u001b[38;5;241m=\u001b[39mwrfin, timeidx\u001b[38;5;241m=\u001b[39mtimeidx,\n\u001b[1;32m    392\u001b[0m                         squeeze\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, meta\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, stagger\u001b[38;5;241m=\u001b[39mstagger,\n\u001b[1;32m    393\u001b[0m                         as_int\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m    395\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 396\u001b[0m     map_proj \u001b[38;5;241m=\u001b[39m \u001b[43mprojection\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmap_proj\u001b[49m\n\u001b[1;32m    398\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m map_proj \u001b[38;5;241m==\u001b[39m ProjectionTypes\u001b[38;5;241m.\u001b[39mLAT_LON:\n\u001b[1;32m    399\u001b[0m         pole_lat \u001b[38;5;241m=\u001b[39m projection\u001b[38;5;241m.\u001b[39mpole_lat\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'LambertConformal' object has no attribute 'map_proj'"
     ]
    }
   ],
   "source": [
    "def plot_diff_cross_section(\n",
    "    future_dir, future_urban_dir, start_point, end_point, start_time, end_time, downscale=True\n",
    "):\n",
    "    \"\"\"\n",
    "    Generate a cross-section plot of differences in omega and potential temperature\n",
    "    between two simulations (future_urban - future).\n",
    "    \n",
    "    Parameters:\n",
    "        future_dir (str): Directory containing WRF files for the 'future' simulation.\n",
    "        future_urban_dir (str): Directory containing WRF files for the 'future_urban' simulation.\n",
    "        start_point (tuple): Starting point (lat, lon) of the cross-section.\n",
    "        end_point (tuple): Ending point (lat, lon) of the cross-section.\n",
    "        start_time (datetime): Start of the time range for mean calculation.\n",
    "        end_time (datetime): End of the time range for mean calculation.\n",
    "    \"\"\"\n",
    "    # Get lists of files in the specified time range for both directories\n",
    "    future_files = list_wrf_files_in_time_range(future_dir, start_time, end_time)\n",
    "    future_urban_files = list_wrf_files_in_time_range(future_urban_dir, start_time, end_time)\n",
    "    \n",
    "    num_files = len(future_files)\n",
    "    if num_files == 0 or len(future_urban_files) == 0:\n",
    "        raise ValueError(\"No WRF files found in one or both of the specified directories.\")\n",
    "    if num_files != len(future_urban_files):\n",
    "        raise ValueError(\"The number of files in the two directories must match.\")\n",
    "    \n",
    "    # Initialize accumulators for omega and theta\n",
    "    future_omega_accum = None\n",
    "    future_theta_accum = None\n",
    "    urban_omega_accum = None\n",
    "    urban_theta_accum = None\n",
    "\n",
    "    # Define cross-section points\n",
    "    start = CoordPair(lon=start_point[0], lat=start_point[1])\n",
    "    end = CoordPair(lon=end_point[0], lat=end_point[1])\n",
    "\n",
    "    # Loop over WRF files for both simulations\n",
    "    for future_file, urban_file in zip(future_files, future_urban_files):\n",
    "        # Open files\n",
    "        future_ncfile = Dataset(future_file)\n",
    "        urban_ncfile = Dataset(urban_file)\n",
    "\n",
    "        print(future_file)\n",
    "        print(urban_file)\n",
    "\n",
    "\n",
    "        #print(future_ds)\n",
    "        if downscale:\n",
    "            # Extract variables\n",
    "            future_theta = downscale_precip(getvar(future_ncfile, \"theta\"))\n",
    "            future_pressure = downscale_precip(getvar(future_ncfile, \"pressure\"))\n",
    "            future_omega = downscale_precip(getvar(future_ncfile, \"omega\"))\n",
    "            \n",
    "            urban_theta = downscale_precip(getvar(urban_ncfile, \"theta\"))\n",
    "            urban_pressure = downscale_precip(getvar(urban_ncfile, \"pressure\"))\n",
    "            urban_omega = downscale_precip(getvar(urban_ncfile, \"omega\"))\n",
    "        else:\n",
    "            # Extract variables\n",
    "            future_theta = getvar(future_ncfile, \"theta\")\n",
    "            future_pressure = getvar(future_ncfile, \"pressure\")\n",
    "            future_omega = getvar(future_ncfile, \"omega\")\n",
    "            \n",
    "            urban_theta = getvar(urban_ncfile, \"theta\")\n",
    "            urban_pressure = getvar(urban_ncfile, \"pressure\")\n",
    "            urban_omega = getvar(urban_ncfile, \"omega\")\n",
    "\n",
    "\n",
    "        ############### Downscaling grid coordinates ################\n",
    "        min_lon = future_omega['XLONG'].values.min()\n",
    "        min_lat = future_omega['XLAT'].values.min()\n",
    "        bot_left = CoordPair(lon=min_lon, lat=min_lat)\n",
    "        proj = get_cartopy(future_omega)\n",
    "        print(proj)\n",
    "        #############################################################\n",
    "        \n",
    "        # Interpolate cross-sections\n",
    "        future_theta_cross = vertcross(future_theta, future_pressure, wrfin=None, start_point=start, end_point=end,ll_point=bot_left, projection=proj, latlon=True, meta=True)\n",
    "        future_omega_cross = vertcross(future_omega, future_pressure, wrfin=None, start_point=start, end_point=end, latlon=True, meta=True)\n",
    "        \n",
    "        urban_theta_cross = vertcross(urban_theta, urban_pressure, wrfin=urban_ncfile, start_point=start, end_point=end, latlon=True, meta=True)\n",
    "        urban_omega_cross = vertcross(urban_omega, urban_pressure, wrfin=urban_ncfile, start_point=start, end_point=end, latlon=True, meta=True)\n",
    "        \n",
    "        # Filter omega to include only negative values (upward motion)\n",
    "        future_omega_cross = np.where(to_np(future_omega_cross) < 0, to_np(future_omega_cross), 0)\n",
    "        urban_omega_cross = np.where(to_np(urban_omega_cross) < 0, to_np(urban_omega_cross), 0)\n",
    "        \n",
    "        # Initialize accumulators if None\n",
    "        if future_omega_accum is None:\n",
    "            future_omega_accum = np.zeros_like(future_omega_cross)\n",
    "            future_theta_accum = np.zeros_like(to_np(future_theta_cross))\n",
    "            urban_omega_accum = np.zeros_like(urban_omega_cross)\n",
    "            urban_theta_accum = np.zeros_like(to_np(urban_theta_cross))\n",
    "        \n",
    "        # Accumulate values\n",
    "        future_omega_accum += future_omega_cross\n",
    "        future_theta_accum += to_np(future_theta_cross)\n",
    "        urban_omega_accum += urban_omega_cross\n",
    "        urban_theta_accum += to_np(urban_theta_cross)\n",
    "\n",
    "    print(num_files)\n",
    "\n",
    "    # Calculate means\n",
    "    future_omega_mean = future_omega_accum / num_files\n",
    "    future_theta_mean = future_theta_accum / num_files\n",
    "    urban_omega_mean = urban_omega_accum / num_files\n",
    "    urban_theta_mean = urban_theta_accum / num_files\n",
    "\n",
    "    # Compute differences (future_urban - future)\n",
    "    omega_diff = urban_omega_mean - future_omega_mean\n",
    "    theta_diff = urban_theta_mean - future_theta_mean\n",
    "\n",
    "    # Extract pressure levels and lat/lon coordinates for plotting\n",
    "    pressure_cross = to_np(future_theta_cross.coords[\"vertical\"])\n",
    "    cross_lats = np.array([point.lat for point in to_np(future_theta_cross.coords[\"xy_loc\"])])\n",
    "    cross_lons = np.array([point.lon for point in to_np(future_theta_cross.coords[\"xy_loc\"])])\n",
    "    \n",
    "    # Combine lat/lon for axis labels\n",
    "    cross_coords = [\"{:.2f}°N,\\n{:.2f}°W\".format(lat, lon * -1) for lat, lon in zip(cross_lats, cross_lons)]\n",
    "    coord_interval = len(cross_coords) // 6  # Show roughly 10 coordinate labels\n",
    "\n",
    "    # Create the cross-section plot\n",
    "    fig, ax = plt.subplots(figsize=(12, 6))\n",
    "    \n",
    "    # Plot omega differences\n",
    "    cf = ax.contourf(\n",
    "        range(len(cross_coords)),\n",
    "        pressure_cross,\n",
    "        omega_diff,\n",
    "        levels=clevs3,\n",
    "        cmap=cmap5,\n",
    "        norm=norm5,\n",
    "        extend=\"both\"\n",
    "    )\n",
    "    cbar = fig.colorbar(cf, ax=ax, orientation=\"vertical\", pad=0.02, label=\"Omega Difference (Pa/s)\", extend='both')\n",
    "    cbar.set_ticks(clevs3)\n",
    "    \n",
    "    # Overlay potential temperature differences\n",
    "    theta_contours = ax.contour(\n",
    "        range(len(cross_coords)),\n",
    "        pressure_cross,\n",
    "        theta_diff,\n",
    "        levels=np.arange(-5, 6, 1),\n",
    "        colors=\"black\",\n",
    "        linewidths=0.8,\n",
    "    )\n",
    "    ax.clabel(theta_contours, inline=True, fontsize=8, fmt=\"%.1f\")\n",
    "    \n",
    "    # Adjust the y-axis to represent pressure\n",
    "    ax.set_yscale(\"log\")\n",
    "    ax.set_ylim(1000, 200)  # Pressure from surface (1000 hPa) to 100 hPa\n",
    "    #ax.invert_yaxis()  # Invert to have surface at bottom\n",
    "    ax.set_ylabel(\"Pressure (hPa)\")\n",
    "    ax.set_xlabel(\"Latitude, Longitude\")\n",
    "    ax.set_xticks(range(0, len(cross_coords), coord_interval))\n",
    "    ax.set_xticklabels(cross_coords[::coord_interval])\n",
    "    ax.set_title(f'Difference in Mean Omega and Potential Temperature (Urbanization Effect) from {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}')\n",
    "\n",
    "    # Add letters A and B to the bottom corners of the plot\n",
    "    ax.text(5, 950, \"A\", fontsize=14, fontweight=\"bold\", ha=\"center\", va=\"center\", color=\"black\")\n",
    "    ax.text(len(cross_coords)-5, 950, \"B\", fontsize=14, fontweight=\"bold\", ha=\"center\", va=\"center\", color=\"black\")\n",
    "    \n",
    "    # Add minimap\n",
    "    inset_ax = fig.add_axes([0.566, 0.71, 0.2, 0.2], projection=ccrs.PlateCarree())\n",
    "    inset_ax.add_feature(cfeature.COASTLINE)\n",
    "    inset_ax.add_feature(cfeature.BORDERS, linestyle=\":\")\n",
    "    inset_ax.add_feature(cfeature.STATES, edgecolor=\"gray\")  # Add state boundaries\n",
    "    inset_ax.set_extent([cross_lons.min()-2, cross_lons.max()+2, cross_lats.min()-2, cross_lats.max()+2], crs=ccrs.PlateCarree())\n",
    "    inset_ax.plot([start.lon, end.lon], [start.lat, end.lat], color=\"blue\", transform=ccrs.PlateCarree(), lw=2)\n",
    "    inset_ax.scatter([start.lon, end.lon], [start.lat, end.lat], color=\"blue\", transform=ccrs.PlateCarree())\n",
    "\n",
    "    # Add letters A and B to the minimap\n",
    "    inset_ax.text(start.lon, start.lat-1, \"A\", fontsize=10, fontweight=\"bold\", ha=\"right\", color=\"black\", transform=ccrs.PlateCarree())\n",
    "    inset_ax.text(end.lon, end.lat-1, \"B\", fontsize=10, fontweight=\"bold\", ha=\"left\", color=\"black\", transform=ccrs.PlateCarree())\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "    return omega_diff, theta_diff, future_theta_cross\n",
    "\n",
    "\n",
    "future_dir = '/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/future/3hr'\n",
    "future_urban_dir = '/pscratch/sd/y/yuwei/Climate_Impact/long-term/data/future_urban/3hr'\n",
    "start_time = datetime(2017, 6, 1, 0, 0)  # Start time: Year, month, day, hour, minute\n",
    "end_time = datetime(2017, 6, 6, 0, 0)   # End time: Year, month, day, hour, minute\n",
    "start_point = (-95.848124,36)  # Example start point (latitude, longitude)\n",
    "end_point = (-86.297920,36)   # Example end point (latitude, longitude)\n",
    "\n",
    "omega_diff, theta_diff, future_theta_cross = plot_diff_cross_section(future_dir, future_urban_dir, start_point, end_point, start_time, end_time)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}