{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from netCDF4 import Dataset\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as mcolors\n",
    "import matplotlib.colors as Normalize\n",
    "import cartopy.crs as crs\n",
    "import cartopy.feature as cfeature\n",
    "from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter\n",
    "import matplotlib.ticker as mticker\n",
    "import matplotlib\n",
    "import xarray as xr\n",
    "import netCDF4\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import glob\n",
    "import dask\n",
    "import os\n",
    "import re\n",
    "import warnings\n",
    "import gc\n",
    "from datetime import datetime\n",
    "import seaborn as sns\n",
    "from matplotlib.colors import LinearSegmentedColormap, TwoSlopeNorm\n",
    "import matplotlib.lines as mlines\n",
    "import matplotlib.patheffects as pe\n",
    "\n",
    "\n",
    "import wrf\n",
    "from wrf import (getvar, interplevel, to_np, latlon_coords, get_cartopy,\n",
    "                 cartopy_xlim, cartopy_ylim) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "monlist = ['06'] # months in the simulation\n",
    "sim_list = ['current','future','future_urban']\n",
    "select_subregion = False\n",
    "select_time_window = False\n",
    "\n",
    "if select_subregion == False:\n",
    "    region = 'Full Domain'\n",
    "else:\n",
    "    bounding_box=[-97.926091,26,-83.709230,38.648338] # min_lon,min_lat,max_lon,max_lat (southeast/gulf coast)\n",
    "    region = 'Southeast' # can change based on bounding box\n",
    "\n",
    "if select_time_window == True:\n",
    "    #start_time = '2017-06-20T00:00:00'\n",
    "    end_time = '2017-06-19T06:00:00'\n",
    "    start_time = '2017-06-01T00:00:00'\n",
    "    #end_time = '2017-06-06T00:00:00'\n",
    "else:\n",
    "    start_time = 0\n",
    "    end_time = 0\n",
    "\n",
    "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 downscsale_precip(ds):\n",
    "    # Assuming `ds` is your xarray dataset\n",
    "    ds_downscaled = ds.coarsen(\n",
    "        south_north=6,  # Downsampling factor of 6 for south_north (to get resolution of 12km)\n",
    "        west_east=6,     # Downsampling factor of 6 for west_east\n",
    "        boundary=\"trim\"\n",
    "    ).mean()  \n",
    "\n",
    "    return ds_downscaled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current\n",
      "future\n",
      "future_urban\n",
      "06\n",
      "current\n",
      "future\n",
      "future_urban\n",
      "06\n",
      "current\n",
      "future\n",
      "future_urban\n",
      "06\n"
     ]
    }
   ],
   "source": [
    "############################ Load in data for given month(s) and process it ##############################\n",
    "#precip_current_list=[]\n",
    "##precip_future_list=[]\n",
    "#precip_future_urban_list=[]\n",
    "\n",
    "\n",
    "# Precip\n",
    "for month in monlist:\n",
    "    for sim in sim_list:\n",
    "        if sim == 'current':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/precip_data/{sim}/hourly_precip_data_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            #precip_current_list.append(ds)\n",
    "            precip_current_ds = ds\n",
    "        elif sim == 'future':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/precip_data/{sim}/hourly_precip_data_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            #precip_future_list.append(ds)\n",
    "            precip_future_ds = ds\n",
    "        elif sim == 'future_urban':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/precip_data/{sim}/hourly_precip_data_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            #precip_future_urban_list.append(ds)\n",
    "            precip_future_urban_ds = ds\n",
    "        else:\n",
    "            print('incorrect input simulation name')\n",
    "        print(sim)\n",
    "    print(month)\n",
    "\n",
    "# Adjust first time value in hourly precip data\n",
    "# Extract time values as a pandas Index\n",
    "time_values = precip_current_ds.Time.values\n",
    "\n",
    "# Adjust only the first time value by subtracting 1 hour\n",
    "time_values[0] = pd.Timestamp(time_values[0]) - pd.Timedelta(hours=1)\n",
    "\n",
    "# Reassign the modified time back to the dataset\n",
    "precip_current_ds = precip_current_ds.assign_coords(Time=time_values)\n",
    "precip_future_ds = precip_future_ds.assign_coords(Time=time_values)\n",
    "precip_future_urban_ds = precip_future_urban_ds.assign_coords(Time=time_values)\n",
    "\n",
    "#wind_current_list=[]\n",
    "#wind_future_list=[]\n",
    "#wind_future_urban_list=[]\n",
    "\n",
    "\n",
    "# Wind\n",
    "for month in monlist:\n",
    "    for sim in sim_list:\n",
    "        if sim == 'current':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/Current/wind_speed_data_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            #wind_current_list.append(ds)\n",
    "            wind_current_ds = ds\n",
    "        elif sim == 'future':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/Future/wind_speed_data_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            #wind_future_list.append(ds)\n",
    "            wind_future_ds = ds\n",
    "        elif sim == 'future_urban':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/Future_urban/wind_speed_data_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            #wind_future_urban_list.append(ds)\n",
    "            wind_future_urban_ds = ds\n",
    "        else:\n",
    "            print('incorrect input simulation name')\n",
    "        print(sim)\n",
    "    print(month)\n",
    "\n",
    "'''\n",
    "# Radar\n",
    "for month in monlist:\n",
    "    for sim in sim_list:\n",
    "        if sim == 'current':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/radar_data/current/composite_ref_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            #wind_current_list.append(ds)\n",
    "            ref_current_ds = ds\n",
    "        elif sim == 'future':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/radar_data/future/composite_ref_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            #wind_future_list.append(ds)\n",
    "            ref_future_ds = ds\n",
    "        elif sim == 'future_urban':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/radar_data/future_urban/composite_ref_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            #wind_future_urban_list.append(ds)\n",
    "            ref_future_urban_ds = ds\n",
    "        else:\n",
    "            print('incorrect input simulation name')\n",
    "        print(sim)\n",
    "    print(month)\n",
    "'''\n",
    "# Cloud top temp\n",
    "for month in monlist:\n",
    "    for sim in sim_list:\n",
    "        if sim == 'current':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/current/cloudtoptemp_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            #wind_current_list.append(ds)\n",
    "            ctt_current_ds = ds\n",
    "        elif sim == 'future':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/future/cloudtoptemp_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            #wind_future_list.append(ds)\n",
    "            ctt_future_ds = ds\n",
    "        elif sim == 'future_urban':\n",
    "            filename = f'/pscratch/sd/d/dbrooks/acc2017_analysis/cloud_stuff/future_urban/cloudtoptemp_month{month}.nc'\n",
    "            ds = xr.open_dataset(filename)\n",
    "            #wind_future_urban_list.append(ds)\n",
    "            ctt_future_urban_ds = ds\n",
    "        else:\n",
    "            print('incorrect input simulation name')\n",
    "        print(sim)\n",
    "    print(month)\n",
    "\n",
    "# Remove boundaries\n",
    "def remove_lateral_boundaries(current_ds,future_ds,future_urban_ds):\n",
    "    # Access the latitude and longitude arrays (XLAT, XLONG)\n",
    "    lats = current_ds['XLAT']\n",
    "    lons = current_ds['XLONG']\n",
    "\n",
    "    # Get the shape of the latitude and longitude arrays\n",
    "    n_lat, n_lon = lats.shape\n",
    "    # Exclude 15 grid cells from each side (latitude and longitude)\n",
    "    lat_slice = slice(15, n_lat - 15)\n",
    "    lon_slice = slice(15, n_lon - 15)\n",
    "\n",
    "    # Subset the data using the grid cell indices\n",
    "    current_ds = current_ds.isel(south_north=lat_slice, west_east=lon_slice)\n",
    "    future_ds = future_ds.isel(south_north=lat_slice, west_east=lon_slice)\n",
    "    future_urban_ds = future_urban_ds.isel(south_north=lat_slice, west_east=lon_slice)\n",
    "\n",
    "    return current_ds,future_ds,future_urban_ds\n",
    "\n",
    "#precip_current_ds, precip_future_ds, precip_future_urban_ds = remove_lateral_boundaries(precip_current_ds, precip_future_ds, precip_future_urban_ds)\n",
    "wind_current_ds, wind_future_ds, wind_future_urban_ds = remove_lateral_boundaries(wind_current_ds, wind_future_ds, wind_future_urban_ds)\n",
    "#ref_current_ds, ref_future_ds, ref_future_urban_ds = remove_lateral_boundaries(ref_current_ds, ref_future_ds, ref_future_urban_ds)\n",
    "ctt_current_ds, ctt_future_ds, ctt_future_urban_ds = remove_lateral_boundaries(ctt_current_ds, ctt_future_ds, ctt_future_urban_ds)\n",
    "\n",
    "# Select subregion if desired\n",
    "if select_subregion == True:\n",
    "    def select_region(bounding_box, current_ds, future_ds, future_urban_ds):\n",
    "        min_lon,min_lat,max_lon,max_lat = bounding_box[0], bounding_box[1], bounding_box[2], bounding_box[3]\n",
    "\n",
    "        # Access the latitude and longitude arrays (XLAT, XLONG)\n",
    "        lats = current_ds['XLAT']\n",
    "        lons = current_ds['XLONG']\n",
    "\n",
    "        # Create a boolean mask for the region of interest\n",
    "        region_mask = (lats >= min_lat) & (lats <= max_lat) & (lons >= min_lon) & (lons <= max_lon)\n",
    "\n",
    "        # Subset the data using the bounding box\n",
    "        current_ds = current_ds.where(region_mask, drop=True)\n",
    "        future_ds = future_ds.where(region_mask, drop=True)\n",
    "        future_urban_ds = future_urban_ds.where(region_mask, drop=True)\n",
    "\n",
    "        return current_ds, future_ds, future_urban_ds\n",
    "\n",
    "    precip_current_ds, precip_future_ds, precip_future_urban_ds = select_region(bounding_box, precip_current_ds, precip_future_ds, precip_future_urban_ds)\n",
    "    wind_current_ds, wind_future_ds, wind_future_urban_ds = select_region(bounding_box, wind_current_ds, wind_future_ds, wind_future_urban_ds)  \n",
    "\n",
    "# resample precip to 3 hour timesteps\n",
    "def resample_precip_to_3hr(precip_ds):\n",
    "    \"\"\"\n",
    "    Resamples the precipitation dataset to match the 3-hour timestep of the wind dataset by summing\n",
    "    the precipitation over each 3-hour interval.\n",
    "\n",
    "    Parameters:\n",
    "    precip_ds (xarray.Dataset): The original hourly precipitation dataset.\n",
    "\n",
    "    Returns:\n",
    "    xarray.Dataset: The resampled precipitation dataset at 3-hour intervals.\n",
    "    \"\"\"\n",
    "    # Resample the dataset to 3-hour intervals and sum the precipitation over those intervals\n",
    "    precip_resampled = precip_ds.resample(Time='3h').sum()\n",
    "\n",
    "    return precip_resampled\n",
    "\n",
    "#precip_current_ds = resample_precip_to_3hr(precip_current_ds)\n",
    "#precip_future_ds = resample_precip_to_3hr(precip_future_ds)\n",
    "#precip_future_urban_ds = resample_precip_to_3hr(precip_future_urban_ds) \n",
    "\n",
    "if select_time_window == True:\n",
    "    def subset_time_window(ds, start_time, end_time):\n",
    "        \"\"\"\n",
    "        Subset the dataset based on a specified time window.\n",
    "\n",
    "        Parameters:\n",
    "        ds (xarray.Dataset): The dataset to subset.\n",
    "        start_time (str or datetime): The start time of the window (inclusive).\n",
    "        end_time (str or datetime): The end time of the window (inclusive).\n",
    "\n",
    "        Returns:\n",
    "        xarray.Dataset: The subset of the dataset within the specified time window.\n",
    "        \"\"\"\n",
    "        # Subset the dataset by time\n",
    "        subset_ds = ds.sel(Time=slice(start_time, end_time))\n",
    "        \n",
    "        return subset_ds\n",
    "\n",
    "    precip_current_ds = subset_time_window(precip_current_ds, start_time, end_time)\n",
    "    precip_future_ds = subset_time_window(precip_future_ds, start_time, end_time)\n",
    "    precip_future_urban_ds = subset_time_window(precip_future_urban_ds, start_time, end_time) \n",
    "\n",
    "    wind_current_ds = subset_time_window(wind_current_ds, start_time, end_time)\n",
    "    wind_future_ds = subset_time_window(wind_future_ds, start_time, end_time)\n",
    "    wind_future_urban_ds = subset_time_window(wind_future_urban_ds, start_time, end_time) \n",
    "\n",
    "    ref_current_ds = subset_time_window(ref_current_ds, start_time, end_time)\n",
    "    ref_future_ds = subset_time_window(ref_future_ds, start_time, end_time)\n",
    "    ref_future_urban_ds = subset_time_window(ref_future_urban_ds, start_time, end_time) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filter out non-convective winds (keep points with reflectivity greater than 5 dbz)\n",
    "\n",
    "ctt_cold_current = (ctt_current_ds['ctt']<241).astype(int)\n",
    "ctt_cold_future = (ctt_future_ds['ctt']<241).astype(int)\n",
    "ctt_cold_future_urban = (ctt_future_urban_ds['ctt']<241).astype(int)\n",
    "\n",
    "#ref_gt40_current = ref_current_ds['mdbz']>40\n",
    "#ref_gt40_future = ref_future_ds['mdbz']>40\n",
    "#ref_gt40_future_urban = ref_future_urban_ds['mdbz']>40\n",
    "#print(ref_gt5_current)\n",
    "\n",
    "# convective cores\n",
    "ref_gt40_current = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/masks/current/convective_core_mask_withtimes_month{month}.nc')['__xarray_dataarray_variable__']\n",
    "ref_gt40_future = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/masks/future/convective_core_mask_withtimes_month{month}.nc')['__xarray_dataarray_variable__']\n",
    "ref_gt40_future_urban = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/masks/future_urban/convective_core_mask_withtimes_month{month}.nc')['__xarray_dataarray_variable__']\n",
    "ref_gt40_current, ref_gt40_future, ref_gt40_future_urban = remove_lateral_boundaries(ref_gt40_current, ref_gt40_future, ref_gt40_future_urban)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def plot_contours(dataarray, ds, timestep=0):\n",
    "    \"\"\"Plots contours around all regions where the value is 1 for a given timestep.\"\"\"\n",
    "    \n",
    "    # Extract a single time step\n",
    "    data_slice = dataarray.isel(Time=timestep)\n",
    "    ds_slice = ds['ctt'].isel(Time=timestep)\n",
    "    \n",
    "    # Find coordinates if available\n",
    "    if \"XLAT\" in dataarray.coords and \"XLONG\" in dataarray.coords:\n",
    "        lats = dataarray.XLAT\n",
    "        lons = dataarray.XLONG\n",
    "    else:\n",
    "        lats, lons = np.meshgrid(np.arange(data_slice.sizes[\"south_north\"]), \n",
    "                                 np.arange(data_slice.sizes[\"west_east\"]), \n",
    "                                 indexing=\"ij\")\n",
    "\n",
    "    # Create the figure\n",
    "    fig, ax = plt.subplots(figsize=(10, 6), subplot_kw={'projection': crs.PlateCarree()})\n",
    "\n",
    "    cb = ax.pcolormesh(lons, lats, ds_slice, cmap='Greys', vmin=200)\n",
    "    \n",
    "    # Plot contours where the value is 1\n",
    "    contour = ax.contour(lons, lats, data_slice, levels=[0], colors=\"red\", linewidths=1.5)\n",
    "    \n",
    "    # Add labels and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.set_title(f\"Contour Plot of Masked Regions \\n(Time: {data_slice.Time.values})\")\n",
    "    ax.set_xlabel(\"Longitude\")\n",
    "    ax.set_ylabel(\"Latitude\")\n",
    "    cbar = plt.colorbar(cb, ax=ax, orientation='vertical', fraction=0.05, pad=0.02, shrink=0.9, extend='both')\n",
    "    \n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "# Example usage\n",
    "#plot_contours(ctt_cold_current, ctt_current_ds, timestep=128)  # Replace `ctt` with your DataArray variable\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.ndimage\n",
    "\n",
    "def apply_gaussian_filter(dataarray, sigma=5.0):\n",
    "    \"\"\"Applies a 2D Gaussian filter across the `south_north` and `west_east` dimensions.\"\"\"\n",
    "    return xr.apply_ufunc(\n",
    "        scipy.ndimage.gaussian_filter,  # Function to apply\n",
    "        dataarray,                      # DataArray input\n",
    "        kwargs={\"sigma\": sigma, \"mode\": \"nearest\"},  # Pass `sigma` correctly as a keyword argument\n",
    "        input_core_dims=[[\"south_north\", \"west_east\"]],  # Apply along these dimensions\n",
    "        output_core_dims=[[\"south_north\", \"west_east\"]],\n",
    "        vectorize=True,                 # Apply filter to each Time slice independently\n",
    "        dask=\"parallelized\",             # Support large datasets\n",
    "    )\n",
    "\n",
    "\n",
    "def expand_mask(dataarray, iterations=5):\n",
    "    \"\"\"Expands the regions where the value is 1 using morphological dilation.\"\"\"\n",
    "    return xr.apply_ufunc(\n",
    "        scipy.ndimage.binary_dilation,  # Dilation function\n",
    "        dataarray,  \n",
    "        kwargs={\"iterations\": iterations},  # Number of iterations controls buffer size\n",
    "        input_core_dims=[[\"south_north\", \"west_east\"]],  \n",
    "        output_core_dims=[[\"south_north\", \"west_east\"]],\n",
    "        vectorize=True,  # Do for each timestep\n",
    "        dask=\"parallelized\"  \n",
    "    ).astype(int)  # Convert back to integer mask\n",
    "\n",
    "# Example: Apply Gaussian filter to your mask\n",
    "ctt_cold_current2 = expand_mask(ctt_cold_current, iterations=25) > 0\n",
    "ctt_cold_future2 = expand_mask(ctt_cold_future, iterations=25) > 0 \n",
    "ctt_cold_future_urban2 = expand_mask(ctt_cold_future_urban, iterations=25) > 0\n",
    "\n",
    "ref_gt40_current2 = expand_mask(ref_gt40_current, iterations=15) > 0\n",
    "ref_gt40_future2 = expand_mask(ref_gt40_future, iterations=15) > 0 \n",
    "ref_gt40_future_urban2 = expand_mask(ref_gt40_future_urban, iterations=15) > 0\n",
    "\n",
    "c_storms = (ref_gt40_current2) & (ctt_cold_current2)\n",
    "f_storms = (ref_gt40_future2) & (ctt_cold_future2)\n",
    "fu_storms = (ref_gt40_future_urban2) & (ctt_cold_future_urban2)\n",
    "#print(c_storms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#c_storms.to_netcdf(f'/pscratch/sd/d/dbrooks/acc2017_analysis/masks/current/convective_wind_mask_{monlist[0]}')\n",
    "#f_storms.to_netcdf(f'/pscratch/sd/d/dbrooks/acc2017_analysis/masks/future/convective_wind_mask_{monlist[0]}')\n",
    "#fu_storms.to_netcdf(f'/pscratch/sd/d/dbrooks/acc2017_analysis/masks/future_urban/convective_wind_mask_{monlist[0]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/global/homes/d/dbrooks/.conda/envs/myenv/lib/python3.11/site-packages/cartopy/mpl/geoaxes.py:1600: UserWarning: The following kwargs were not used by contour: 'label'\n",
      "  result = super().contour(*args, **kwargs)\n",
      "/global/homes/d/dbrooks/.conda/envs/myenv/lib/python3.11/site-packages/cartopy/mpl/geoaxes.py:1600: UserWarning: The following kwargs were not used by contour: 'label'\n",
      "  result = super().contour(*args, **kwargs)\n",
      "/tmp/ipykernel_2278299/2068492391.py:43: UserWarning: No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n",
      "  ax.legend(loc='upper right')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_contours(dataarray, dataarray2, dataarray3, ds, wind_ds=wind_current_ds, timestep=0):\n",
    "    \"\"\"Plots contours around all regions where the value is 1 for a given timestep.\"\"\"\n",
    "    \n",
    "    # Extract a single time step\n",
    "    data_slice = dataarray.isel(Time=timestep)\n",
    "    f_slice = f_storms.isel(Time=timestep)\n",
    "    data_slice2 = dataarray2.isel(Time=timestep)\n",
    "    data_slice3 = dataarray3.isel(Time=timestep)\n",
    "    ds_slice = ds['ctt'].isel(Time=timestep)\n",
    "\n",
    "    wind_da = wind_ds['wspd_wdir10'].sel(wspd_wdir='wspd').isel(Time=timestep) > 17\n",
    "    \n",
    "    # Find coordinates if available\n",
    "    if \"XLAT\" in dataarray.coords and \"XLONG\" in dataarray.coords:\n",
    "        lats = dataarray.XLAT\n",
    "        lons = dataarray.XLONG\n",
    "    else:\n",
    "        lats, lons = np.meshgrid(np.arange(data_slice.sizes[\"south_north\"]), \n",
    "                                 np.arange(data_slice.sizes[\"west_east\"]), \n",
    "                                 indexing=\"ij\")\n",
    "\n",
    "    # Create the figure\n",
    "    fig, ax = plt.subplots(figsize=(10, 6), subplot_kw={'projection': crs.PlateCarree()})\n",
    "\n",
    "    #cb = ax.pcolormesh(lons, lats, ds_slice, cmap='Greys')\n",
    "    #cb = ax.pcolormesh(lons, lats, ref_current_ds['mdbz'].isel(Time=timestep), cmap='gist_ncar', vmin=10, vmax=60)\n",
    "    #wind_da = wind_da.where(wind_da == True)\n",
    "    #cb = ax.contourf(lons, lats, wind_da, levels=[0,1], colors='blue')\n",
    "    ax.contour(lons, lats, wind_da, levels=[0,1], colors='blue', linewidths=2)\n",
    "    \n",
    "    # Plot contours where the value is 1\n",
    "    contour = ax.contour(lons, lats, data_slice, levels=[0], colors=\"purple\", linewidths=1.5, label='Conv. Core Mask')\n",
    "    #contour = ax.contour(lons, lats, f_slice, levels=[0], colors=\"orange\", linewidths=1.5, label='Conv. Core Mask')\n",
    "    contour = ax.contour(lons, lats, data_slice2, levels=[0], colors=\"red\", linewidths=2, label ='CTT Mask')\n",
    "    #contour = ax.contour(lons, lats, data_slice3, levels=[0], colors=\"blue\", linewidths=1.5, zorder=1)\n",
    "    \n",
    "    # Add labels and title\n",
    "    ax.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax.set_title(f\"Time: {data_slice.Time.values}\")\n",
    "    ax.set_xlabel(\"Longitude\")\n",
    "    ax.set_ylabel(\"Latitude\")\n",
    "    ax.legend(loc='upper right')\n",
    "    #cbar = plt.colorbar(cb, ax=ax, orientation='vertical', fraction=0.05, pad=0.02, shrink=0.9, extend='both')\n",
    "    \n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "# Example usage\n",
    "plot_contours(c_storms, ctt_cold_current2, ref_gt40_current2, ctt_current_ds, timestep=231)  # Replace `ctt` with your DataArray variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mKeyboardInterrupt\u001b[39m                         Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m wind_current_ds = \u001b[43mxr\u001b[49m\u001b[43m.\u001b[49m\u001b[43mwhere\u001b[49m\u001b[43m(\u001b[49m\u001b[43mc_storms\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwind_current_ds\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mwspd_wdir10\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mfloat\u001b[39;49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mnan\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m      2\u001b[39m wind_current_ds = wind_current_ds.to_dataset(name=\u001b[33m'\u001b[39m\u001b[33mwspd_wdir10\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m      4\u001b[39m wind_future_ds = xr.where(f_storms, wind_future_ds[\u001b[33m'\u001b[39m\u001b[33mwspd_wdir10\u001b[39m\u001b[33m'\u001b[39m], \u001b[38;5;28mfloat\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mnan\u001b[39m\u001b[33m\"\u001b[39m))\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/computation/computation.py:735\u001b[39m, in \u001b[36mwhere\u001b[39m\u001b[34m(cond, x, y, keep_attrs)\u001b[39m\n\u001b[32m    732\u001b[39m \u001b[38;5;66;03m# alignment for three arguments is complicated, so don't support it yet\u001b[39;00m\n\u001b[32m    733\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mxarray\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mcomputation\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mapply_ufunc\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m apply_ufunc\n\u001b[32m--> \u001b[39m\u001b[32m735\u001b[39m result = \u001b[43mapply_ufunc\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    736\u001b[39m \u001b[43m    \u001b[49m\u001b[43mduck_array_ops\u001b[49m\u001b[43m.\u001b[49m\u001b[43mwhere\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    737\u001b[39m \u001b[43m    \u001b[49m\u001b[43mcond\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    738\u001b[39m \u001b[43m    \u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    739\u001b[39m \u001b[43m    \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    740\u001b[39m \u001b[43m    \u001b[49m\u001b[43mjoin\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mexact\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m    741\u001b[39m \u001b[43m    \u001b[49m\u001b[43mdataset_join\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mexact\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m    742\u001b[39m \u001b[43m    \u001b[49m\u001b[43mdask\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mallowed\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m    743\u001b[39m \u001b[43m    \u001b[49m\u001b[43mkeep_attrs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mkeep_attrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    744\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    746\u001b[39m \u001b[38;5;66;03m# keep the attributes of x, the second parameter, by default to\u001b[39;00m\n\u001b[32m    747\u001b[39m \u001b[38;5;66;03m# be consistent with the `where` method of `DataArray` and `Dataset`\u001b[39;00m\n\u001b[32m    748\u001b[39m \u001b[38;5;66;03m# rebuild the attrs from x at each level of the output, which could be\u001b[39;00m\n\u001b[32m    749\u001b[39m \u001b[38;5;66;03m# Dataset, DataArray, or Variable, and also handle coords\u001b[39;00m\n\u001b[32m    750\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m keep_attrs \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(result, \u001b[33m\"\u001b[39m\u001b[33mattrs\u001b[39m\u001b[33m\"\u001b[39m):\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/computation/apply_ufunc.py:1263\u001b[39m, in \u001b[36mapply_ufunc\u001b[39m\u001b[34m(func, input_core_dims, output_core_dims, exclude_dims, vectorize, join, dataset_join, dataset_fill_value, keep_attrs, kwargs, dask, output_dtypes, output_sizes, meta, dask_gufunc_kwargs, on_missing_core_dim, *args)\u001b[39m\n\u001b[32m   1261\u001b[39m \u001b[38;5;66;03m# feed DataArray apply_variable_ufunc through apply_dataarray_vfunc\u001b[39;00m\n\u001b[32m   1262\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(a, DataArray) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m args):\n\u001b[32m-> \u001b[39m\u001b[32m1263\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mapply_dataarray_vfunc\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m   1264\u001b[39m \u001b[43m        \u001b[49m\u001b[43mvariables_vfunc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m   1265\u001b[39m \u001b[43m        \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m   1266\u001b[39m \u001b[43m        \u001b[49m\u001b[43msignature\u001b[49m\u001b[43m=\u001b[49m\u001b[43msignature\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m   1267\u001b[39m \u001b[43m        \u001b[49m\u001b[43mjoin\u001b[49m\u001b[43m=\u001b[49m\u001b[43mjoin\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m   1268\u001b[39m \u001b[43m        \u001b[49m\u001b[43mexclude_dims\u001b[49m\u001b[43m=\u001b[49m\u001b[43mexclude_dims\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m   1269\u001b[39m \u001b[43m        \u001b[49m\u001b[43mkeep_attrs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mkeep_attrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m   1270\u001b[39m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1271\u001b[39m \u001b[38;5;66;03m# feed Variables directly through apply_variable_ufunc\u001b[39;00m\n\u001b[32m   1272\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(a, Variable) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m args):\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/computation/apply_ufunc.py:305\u001b[39m, in \u001b[36mapply_dataarray_vfunc\u001b[39m\u001b[34m(func, signature, join, exclude_dims, keep_attrs, *args)\u001b[39m\n\u001b[32m    300\u001b[39m result_coords, result_indexes = build_output_coords_and_indexes(\n\u001b[32m    301\u001b[39m     args, signature, exclude_dims, combine_attrs=keep_attrs\n\u001b[32m    302\u001b[39m )\n\u001b[32m    304\u001b[39m data_vars = [\u001b[38;5;28mgetattr\u001b[39m(a, \u001b[33m\"\u001b[39m\u001b[33mvariable\u001b[39m\u001b[33m\"\u001b[39m, a) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m args]\n\u001b[32m--> \u001b[39m\u001b[32m305\u001b[39m result_var = \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43mdata_vars\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    307\u001b[39m out: \u001b[38;5;28mtuple\u001b[39m[DataArray, ...] | DataArray\n\u001b[32m    308\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m signature.num_outputs > \u001b[32m1\u001b[39m:\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/computation/apply_ufunc.py:724\u001b[39m, in \u001b[36mapply_variable_ufunc\u001b[39m\u001b[34m(func, signature, exclude_dims, dask, output_dtypes, vectorize, keep_attrs, dask_gufunc_kwargs, *args)\u001b[39m\n\u001b[32m    719\u001b[39m broadcast_dims = \u001b[38;5;28mtuple\u001b[39m(\n\u001b[32m    720\u001b[39m     dim \u001b[38;5;28;01mfor\u001b[39;00m dim \u001b[38;5;129;01min\u001b[39;00m dim_sizes \u001b[38;5;28;01mif\u001b[39;00m dim \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m signature.all_core_dims\n\u001b[32m    721\u001b[39m )\n\u001b[32m    722\u001b[39m output_dims = [broadcast_dims + out \u001b[38;5;28;01mfor\u001b[39;00m out \u001b[38;5;129;01min\u001b[39;00m signature.output_core_dims]\n\u001b[32m--> \u001b[39m\u001b[32m724\u001b[39m input_data = \u001b[43m[\u001b[49m\n\u001b[32m    725\u001b[39m \u001b[43m    \u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    726\u001b[39m \u001b[43m        \u001b[49m\u001b[43mbroadcast_compat_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43marg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbroadcast_dims\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcore_dims\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    727\u001b[39m \u001b[43m        \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43misinstance\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43marg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mVariable\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    728\u001b[39m \u001b[43m        \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43marg\u001b[49m\n\u001b[32m    729\u001b[39m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    730\u001b[39m \u001b[43m    \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43marg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcore_dims\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mzip\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msignature\u001b[49m\u001b[43m.\u001b[49m\u001b[43minput_core_dims\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstrict\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[32m    731\u001b[39m \u001b[43m\u001b[49m\u001b[43m]\u001b[49m\n\u001b[32m    733\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28many\u001b[39m(is_chunked_array(array) \u001b[38;5;28;01mfor\u001b[39;00m array \u001b[38;5;129;01min\u001b[39;00m input_data):\n\u001b[32m    734\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m dask == \u001b[33m\"\u001b[39m\u001b[33mforbidden\u001b[39m\u001b[33m\"\u001b[39m:\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/computation/apply_ufunc.py:726\u001b[39m, in \u001b[36m<listcomp>\u001b[39m\u001b[34m(.0)\u001b[39m\n\u001b[32m    719\u001b[39m broadcast_dims = \u001b[38;5;28mtuple\u001b[39m(\n\u001b[32m    720\u001b[39m     dim \u001b[38;5;28;01mfor\u001b[39;00m dim \u001b[38;5;129;01min\u001b[39;00m dim_sizes \u001b[38;5;28;01mif\u001b[39;00m dim \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m signature.all_core_dims\n\u001b[32m    721\u001b[39m )\n\u001b[32m    722\u001b[39m output_dims = [broadcast_dims + out \u001b[38;5;28;01mfor\u001b[39;00m out \u001b[38;5;129;01min\u001b[39;00m signature.output_core_dims]\n\u001b[32m    724\u001b[39m input_data = [\n\u001b[32m    725\u001b[39m     (\n\u001b[32m--> \u001b[39m\u001b[32m726\u001b[39m         \u001b[43mbroadcast_compat_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43marg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbroadcast_dims\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcore_dims\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    727\u001b[39m         \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(arg, Variable)\n\u001b[32m    728\u001b[39m         \u001b[38;5;28;01melse\u001b[39;00m arg\n\u001b[32m    729\u001b[39m     )\n\u001b[32m    730\u001b[39m     \u001b[38;5;28;01mfor\u001b[39;00m arg, core_dims \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(args, signature.input_core_dims, strict=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m    731\u001b[39m ]\n\u001b[32m    733\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28many\u001b[39m(is_chunked_array(array) \u001b[38;5;28;01mfor\u001b[39;00m array \u001b[38;5;129;01min\u001b[39;00m input_data):\n\u001b[32m    734\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m dask == \u001b[33m\"\u001b[39m\u001b[33mforbidden\u001b[39m\u001b[33m\"\u001b[39m:\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/computation/apply_ufunc.py:647\u001b[39m, in \u001b[36mbroadcast_compat_data\u001b[39m\u001b[34m(variable, broadcast_dims, core_dims)\u001b[39m\n\u001b[32m    642\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mbroadcast_compat_data\u001b[39m(\n\u001b[32m    643\u001b[39m     variable: Variable,\n\u001b[32m    644\u001b[39m     broadcast_dims: \u001b[38;5;28mtuple\u001b[39m[Hashable, ...],\n\u001b[32m    645\u001b[39m     core_dims: \u001b[38;5;28mtuple\u001b[39m[Hashable, ...],\n\u001b[32m    646\u001b[39m ) -> Any:\n\u001b[32m--> \u001b[39m\u001b[32m647\u001b[39m     data = \u001b[43mvariable\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdata\u001b[49m\n\u001b[32m    649\u001b[39m     old_dims = variable.dims\n\u001b[32m    650\u001b[39m     new_dims = broadcast_dims + core_dims\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/core/variable.py:430\u001b[39m, in \u001b[36mVariable.data\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    428\u001b[39m     duck_array = \u001b[38;5;28mself\u001b[39m._data.array\n\u001b[32m    429\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(\u001b[38;5;28mself\u001b[39m._data, indexing.ExplicitlyIndexed):\n\u001b[32m--> \u001b[39m\u001b[32m430\u001b[39m     duck_array = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_data\u001b[49m\u001b[43m.\u001b[49m\u001b[43mget_duck_array\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    431\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m is_duck_array(\u001b[38;5;28mself\u001b[39m._data):\n\u001b[32m    432\u001b[39m     duck_array = \u001b[38;5;28mself\u001b[39m._data\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/core/indexing.py:845\u001b[39m, in \u001b[36mMemoryCachedArray.get_duck_array\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    844\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mget_duck_array\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m--> \u001b[39m\u001b[32m845\u001b[39m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_ensure_cached\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    846\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m.array.get_duck_array()\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/core/indexing.py:842\u001b[39m, in \u001b[36mMemoryCachedArray._ensure_cached\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    841\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_ensure_cached\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m--> \u001b[39m\u001b[32m842\u001b[39m     \u001b[38;5;28mself\u001b[39m.array = as_indexable(\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43marray\u001b[49m\u001b[43m.\u001b[49m\u001b[43mget_duck_array\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/core/indexing.py:799\u001b[39m, in \u001b[36mCopyOnWriteArray.get_duck_array\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    798\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mget_duck_array\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m--> \u001b[39m\u001b[32m799\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43marray\u001b[49m\u001b[43m.\u001b[49m\u001b[43mget_duck_array\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/core/indexing.py:654\u001b[39m, in \u001b[36mLazilyIndexedArray.get_duck_array\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    650\u001b[39m     array = apply_indexer(\u001b[38;5;28mself\u001b[39m.array, \u001b[38;5;28mself\u001b[39m.key)\n\u001b[32m    651\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m    652\u001b[39m     \u001b[38;5;66;03m# If the array is not an ExplicitlyIndexedNDArrayMixin,\u001b[39;00m\n\u001b[32m    653\u001b[39m     \u001b[38;5;66;03m# it may wrap a BackendArray so use its __getitem__\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m654\u001b[39m     array = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43marray\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m]\u001b[49m\n\u001b[32m    656\u001b[39m \u001b[38;5;66;03m# self.array[self.key] is now a numpy array when\u001b[39;00m\n\u001b[32m    657\u001b[39m \u001b[38;5;66;03m# self.array is a BackendArray subclass\u001b[39;00m\n\u001b[32m    658\u001b[39m \u001b[38;5;66;03m# and self.key is BasicIndexer((slice(None, None, None),))\u001b[39;00m\n\u001b[32m    659\u001b[39m \u001b[38;5;66;03m# so we need the explicit check for ExplicitlyIndexed\u001b[39;00m\n\u001b[32m    660\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(array, ExplicitlyIndexed):\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:103\u001b[39m, in \u001b[36mNetCDF4ArrayWrapper.__getitem__\u001b[39m\u001b[34m(self, key)\u001b[39m\n\u001b[32m    102\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__getitem__\u001b[39m(\u001b[38;5;28mself\u001b[39m, key):\n\u001b[32m--> \u001b[39m\u001b[32m103\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mindexing\u001b[49m\u001b[43m.\u001b[49m\u001b[43mexplicit_indexing_adapter\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    104\u001b[39m \u001b[43m        \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindexing\u001b[49m\u001b[43m.\u001b[49m\u001b[43mIndexingSupport\u001b[49m\u001b[43m.\u001b[49m\u001b[43mOUTER\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_getitem\u001b[49m\n\u001b[32m    105\u001b[39m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/core/indexing.py:1023\u001b[39m, in \u001b[36mexplicit_indexing_adapter\u001b[39m\u001b[34m(key, shape, indexing_support, raw_indexing_method)\u001b[39m\n\u001b[32m   1001\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"Support explicit indexing by delegating to a raw indexing method.\u001b[39;00m\n\u001b[32m   1002\u001b[39m \n\u001b[32m   1003\u001b[39m \u001b[33;03mOuter and/or vectorized indexers are supported by indexing a second time\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m   1020\u001b[39m \u001b[33;03mIndexing result, in the form of a duck numpy-array.\u001b[39;00m\n\u001b[32m   1021\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m   1022\u001b[39m raw_key, numpy_indices = decompose_indexer(key, shape, indexing_support)\n\u001b[32m-> \u001b[39m\u001b[32m1023\u001b[39m result = \u001b[43mraw_indexing_method\u001b[49m\u001b[43m(\u001b[49m\u001b[43mraw_key\u001b[49m\u001b[43m.\u001b[49m\u001b[43mtuple\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1024\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m numpy_indices.tuple:\n\u001b[32m   1025\u001b[39m     \u001b[38;5;66;03m# index the loaded duck array\u001b[39;00m\n\u001b[32m   1026\u001b[39m     indexable = as_indexable(result)\n",
      "\u001b[36mFile \u001b[39m\u001b[32m~/.conda/envs/myenv/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:116\u001b[39m, in \u001b[36mNetCDF4ArrayWrapper._getitem\u001b[39m\u001b[34m(self, key)\u001b[39m\n\u001b[32m    114\u001b[39m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m.datastore.lock:\n\u001b[32m    115\u001b[39m         original_array = \u001b[38;5;28mself\u001b[39m.get_array(needs_lock=\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[32m--> \u001b[39m\u001b[32m116\u001b[39m         array = getitem(original_array, key)\n\u001b[32m    117\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mIndexError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[32m    118\u001b[39m     \u001b[38;5;66;03m# Catch IndexError in netCDF4 and return a more informative\u001b[39;00m\n\u001b[32m    119\u001b[39m     \u001b[38;5;66;03m# error message.  This is most often called when an unsorted\u001b[39;00m\n\u001b[32m    120\u001b[39m     \u001b[38;5;66;03m# indexer is used before the data is loaded from disk.\u001b[39;00m\n\u001b[32m    121\u001b[39m     msg = (\n\u001b[32m    122\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33mThe indexing operation you are attempting to perform \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    123\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33mis not valid on netCDF4.Variable object. Try loading \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    124\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33myour data into memory first by calling .load().\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    125\u001b[39m     )\n",
      "\u001b[31mKeyboardInterrupt\u001b[39m: "
     ]
    }
   ],
   "source": [
    "\n",
    "wind_current_ds = xr.where(c_storms, wind_current_ds['wspd_wdir10'], float(\"nan\"))\n",
    "wind_current_ds = wind_current_ds.to_dataset(name='wspd_wdir10')\n",
    "\n",
    "wind_future_ds = xr.where(f_storms, wind_future_ds['wspd_wdir10'], float(\"nan\"))\n",
    "wind_future_ds = wind_future_ds.to_dataset(name='wspd_wdir10')\n",
    "\n",
    "wind_future_urban_ds = xr.where(fu_storms, wind_future_urban_ds['wspd_wdir10'], float(\"nan\"))\n",
    "wind_future_urban_ds = wind_future_urban_ds.to_dataset(name='wspd_wdir10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#wind_current_ds.to_netcdf(f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/Current/convective_winds_month{monlist[0]}.nc')\n",
    "#wind_future_ds.to_netcdf(f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/Future/convective_winds_month{monlist[0]}.nc')\n",
    "#wind_future_urban_ds.to_netcdf(f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/Future_urban/convective_winds_month{monlist[0]}.nc')\n",
    "\n",
    "wind_current_ds = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/Current/convective_winds_month{monlist[0]}.nc')\n",
    "wind_future_ds = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/Future/convective_winds_month{monlist[0]}.nc')\n",
    "wind_future_urban_ds = xr.open_dataset(f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/Future_urban/convective_winds_month{monlist[0]}.nc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         date  c_count  f_count  fu_count\n",
      "0  2017-05-31       12      526       512\n",
      "1  2017-06-01      133      355       323\n",
      "2  2017-06-02      390      931       651\n",
      "3  2017-06-03      515      329       600\n",
      "4  2017-06-04       61      106        73\n",
      "5  2017-06-05       75      135       149\n",
      "6  2017-06-06      488     2301      1288\n",
      "7  2017-06-07      596      450       574\n",
      "8  2017-06-08     1059      207       276\n",
      "9  2017-06-09       31      197       103\n",
      "10 2017-06-10       88        0         0\n",
      "11 2017-06-11       85       77        36\n",
      "12 2017-06-12      909      579       502\n",
      "13 2017-06-13     2117     1049       792\n",
      "14 2017-06-14     1310     2113      1672\n",
      "15 2017-06-15     1645     1679      1159\n",
      "16 2017-06-16      424      487       505\n",
      "17 2017-06-17      292      382      1118\n",
      "18 2017-06-18        1       29       171\n",
      "19 2017-06-19    12531    19075     20979\n",
      "20 2017-06-20    67909   104126    113134\n",
      "21 2017-06-21    31645    77319     85005\n",
      "22 2017-06-22    11355    18559     20035\n",
      "23 2017-06-23     1481     4878      7171\n",
      "24 2017-06-24     1127     1510      1011\n",
      "25 2017-06-25      618     1140      1013\n",
      "26 2017-06-26      848      531       735\n",
      "27 2017-06-27      379     1002      1259\n",
      "28 2017-06-28      861     1964      4018\n",
      "29 2017-06-29     2113     1209      1338\n",
      "30 2017-06-30       49      151        84\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def get_windy_day_counts(ds: xr.Dataset, threshold: float) -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Returns a DataFrame of dates and counts of how many grid cells exceeded the threshold\n",
    "    across all time steps per UTC day (00Z to 00Z).\n",
    "    \n",
    "    Parameters:\n",
    "    - ds: xarray.Dataset with 'wspd_wdir10' and 'wspd_wdir'\n",
    "    - threshold: float, wind speed threshold\n",
    "    \n",
    "    Returns:\n",
    "    - pd.DataFrame with columns: 'date' and 'count'\n",
    "    \"\"\"\n",
    "    # Extract wind speed\n",
    "    wspd = ds['wspd_wdir10'].sel(wspd_wdir='wspd')\n",
    "    \n",
    "    # Sum number of grid points above threshold for each time step\n",
    "    exceeds_counts = (wspd >= threshold).sum(dim=['south_north', 'west_east'])  # shape: (Time,)\n",
    "    #print(exceeds_counts)\n",
    "    \n",
    "    # Get corresponding timestamps\n",
    "    time_values = pd.to_datetime(ds['Time'].values)\n",
    "\n",
    "    #print(time_values)\n",
    "    \n",
    "    # Normalize to UTC day \n",
    "    #utc_dates = time_values.normalize() # normalizes day to 00z to 00z\n",
    "    shifted_dates = (time_values - pd.Timedelta(hours=12)).normalize() # normalizes day to 12z to 12z\n",
    "\n",
    "\n",
    "    #print(shifted_dates)\n",
    "    \n",
    "    # Create a DataFrame of counts per timestep\n",
    "    df = pd.DataFrame({\n",
    "        'date': shifted_dates,\n",
    "        'count': exceeds_counts.values\n",
    "    })\n",
    "    \n",
    "    # Group by date and sum counts\n",
    "    result = df.groupby('date', as_index=False).sum()\n",
    "\n",
    "    return result\n",
    "\n",
    "\n",
    "def merge_wind_dfs(labels=('c_count', 'f_count', 'fu_count')):\n",
    "    \"\"\"\n",
    "    Merge three wind DataFrames on 'date', renaming counts for clarity.\n",
    "\n",
    "    Parameters:\n",
    "    - df1, df2, df3: DataFrames with 'date' and 'count' columns\n",
    "    - labels: tuple of column names for the count columns in the merged DataFrame\n",
    "\n",
    "    Returns:\n",
    "    - Merged DataFrame with one 'date' column and three count columns\n",
    "    \"\"\"\n",
    "    df1 = get_windy_day_counts(wind_current_ds, threshold=17)\n",
    "    df2 = get_windy_day_counts(wind_future_ds, threshold=17)\n",
    "    df3 = get_windy_day_counts(wind_future_urban_ds, threshold=17)\n",
    "\n",
    "    # Rename count columns before merging\n",
    "    df1 = df1.rename(columns={'count': labels[0]})\n",
    "    df2 = df2.rename(columns={'count': labels[1]})\n",
    "    df3 = df3.rename(columns={'count': labels[2]})\n",
    "    \n",
    "    # Merge on date\n",
    "    merged = pd.merge(df1, df2, on='date', how='outer')\n",
    "    merged = pd.merge(merged, df3, on='date', how='outer')\n",
    "\n",
    "    # Sort by date and fill NaNs with 0 if desired\n",
    "    merged = merged.sort_values('date').reset_index(drop=True)\n",
    "    \n",
    "    return merged\n",
    "\n",
    "df = merge_wind_dfs()\n",
    "print(df)\n",
    "df.to_csv(f'/pscratch/sd/d/dbrooks/acc2017_analysis/wind_data/damaging_wind_days_csv/damaging_wind_days{monlist[0]}.csv', index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_max_wind_speed_time_series(current_ds, future_ds, future_urban_ds, start_time=start_time, end_time=end_time):\n",
    "    \"\"\"\n",
    "    Plots a time series of the maximum surface wind speed for each time step in each simulation.\n",
    "\n",
    "    Parameters:\n",
    "    -----------\n",
    "    current_ds, future_ds, future_urban_ds : xarray.Dataset\n",
    "        Datasets containing surface wind speed data for the current, future, and future-urban simulations.\n",
    "    \"\"\"\n",
    "    # List to store maximum wind speed for each simulation\n",
    "    max_wind_speeds = {\"Current\": [], \"Future\": [], \"Future-Urban\": []}\n",
    "    \n",
    "    # Extract max wind speed across the grid for each time step in each dataset\n",
    "    for label, ds in zip([\"Current\", \"Future\", \"Future-Urban\"], [current_ds, future_ds, future_urban_ds]):\n",
    "        # Select the wind speed (assuming `wspd` is the first index in `wspd_wdir`)\n",
    "        wspd_data = ds['wspd_wdir10'].sel(wspd_wdir='wspd')\n",
    "        \n",
    "        # Calculate the maximum wind speed at each time step and store\n",
    "        max_wind_speeds[label] = wspd_data.max(dim=['south_north', 'west_east']).values\n",
    "    \n",
    "    # Plotting the time series of maximum wind speed\n",
    "    plt.figure(figsize=(12, 6))\n",
    "    \n",
    "    # Plot each simulation with a different color\n",
    "    colors = {\"Current\": \"black\", \"Future\": \"blue\", \"Future-Urban\": \"red\"}\n",
    "    for label, color in colors.items():\n",
    "        plt.plot(current_ds['Time'], max_wind_speeds[label], label=f\"{label}\", color=color)\n",
    "\n",
    "    #landfall_time = '2017-06-22 09:00z'\n",
    "    #plt.axvline(pd.to_datetime(landfall_time), color='green', linestyle='--', label=f\"Landfall: {landfall_time}\")\n",
    "\n",
    "    start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "    end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "    \n",
    "    # Add labels and title\n",
    "    plt.xlabel(\"Time\")\n",
    "    plt.ylabel(\"Maximum Wind Speed (m/s)\")\n",
    "    plt.title(f'Time Series of Maximum 10m Wind Speed for Each Simulation From {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}\\n')\n",
    "    plt.legend()\n",
    "    plt.grid(True, alpha=0.5, linestyle='--')\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "def plot_wind_speed_freq_time_series(current_ds, future_ds, future_urban_ds, threshold, start_time=start_time, end_time=end_time):\n",
    "    \"\"\"\n",
    "    Plots a time series of the maximum surface wind speed for each time step in each simulation.\n",
    "\n",
    "    Parameters:\n",
    "    -----------\n",
    "    current_ds, future_ds, future_urban_ds : xarray.Dataset\n",
    "        Datasets containing surface wind speed data for the current, future, and future-urban simulations.\n",
    "    \"\"\"\n",
    "    # List to store maximum wind speed for each simulation\n",
    "    max_wind_speeds = {\"Current\": [], \"Future\": [], \"Future-Urban\": []}\n",
    "    \n",
    "    # Extract max wind speed across the grid for each time step in each dataset\n",
    "    for label, ds in zip([\"Current\", \"Future\", \"Future-Urban\"], [current_ds, future_ds, future_urban_ds]):\n",
    "        # Select the wind speed (assuming `wspd` is the first index in `wspd_wdir`)\n",
    "        wspd_data = ds['wspd_wdir10'].sel(wspd_wdir='wspd')\n",
    "        \n",
    "        # Count occurrences exceeding the threshold\n",
    "        var_greater_than = wspd_data.where(wspd_data >= threshold, drop=False) # use when doing hourly values\n",
    "\n",
    "        # Group by time and count occurrences\n",
    "        max_wind_speeds[label] = var_greater_than.groupby('Time').count(dim=['south_north', 'west_east'])\n",
    "    \n",
    "    # Plotting the time series of maximum wind speed\n",
    "    plt.figure(figsize=(10, 4))\n",
    "    \n",
    "    # Plot each simulation with a different color\n",
    "    colors = {\"Current\": \"black\", \"Future\": \"blue\", \"Future-Urban\": \"red\"}\n",
    "    for label, color in colors.items():\n",
    "        plt.plot(current_ds['Time'], max_wind_speeds[label], label=f\"{label}\", color=color)\n",
    "\n",
    "    landfall_time = '2017-06-22 09:00z'\n",
    "    plt.axvline(pd.to_datetime(landfall_time), color='green', linestyle='--', label=f\"Landfall: {landfall_time}\")\n",
    "\n",
    "    #start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "    #end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "    \n",
    "    # Add labels and title\n",
    "    plt.xlabel(\"Time\")\n",
    "    plt.ylabel(\"Frequency (# of Occurrences)\")\n",
    "    #plt.title(f'Time Series of 3-Hour Frequency of >={threshold} m/s Wind Speeds for Each Simulation From {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}\\n')\n",
    "    plt.title(f'Time Series of 3-Hour Frequency of >={threshold} m/s Wind Speeds for Each Simulation for June')\n",
    "    plt.legend()\n",
    "    plt.grid(True, alpha=0.5, linestyle='--')\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "\n",
    "#plot_max_wind_speed_time_series(wind_current_ds, wind_future_ds, wind_future_urban_ds)\n",
    "\n",
    "#plot_wind_speed_freq_time_series(wind_current_ds, wind_future_ds, wind_future_urban_ds, threshold=17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_precip_freq_time_series(current_ds, future_ds, future_urban_ds, start_time=start_time, end_time=end_time):\n",
    "    \"\"\"\n",
    "    Plots a time series of the total grid precip at each time\n",
    "\n",
    "    Parameters:\n",
    "    -----------\n",
    "    current_ds, future_ds, future_urban_ds : xarray.Dataset\n",
    "        Datasets containing surface wind speed data for the current, future, and future-urban simulations.\n",
    "    \"\"\"\n",
    "    # List to store maximum wind speed for each simulation\n",
    "    max_wind_speeds = {\"Current\": [], \"Future\": [], \"Future-Urban\": []}\n",
    "    \n",
    "    # Extract max wind speed across the grid for each time step in each dataset\n",
    "    for label, ds in zip([\"Current\", \"Future\", \"Future-Urban\"], [current_ds, future_ds, future_urban_ds]):\n",
    "        # Select the wind speed (assuming wspd is the first index in wspd_wdir)\n",
    "        wspd_data = ds['RAINNC']\n",
    "  \n",
    "        # Group by time and count occurrences\n",
    "        max_wind_speeds[label] = wspd_data.groupby('Time').sum(dim=['south_north', 'west_east'])\n",
    "    \n",
    "    # Plotting the time series of precip accum\n",
    "    plt.figure(figsize=(10, 4))\n",
    "\n",
    "    # Plot each simulation with a different color\n",
    "    colors = {\"Current\": \"black\", \"Future\": \"blue\", \"Future-Urban\": \"red\"}\n",
    "    for label, color in colors.items():\n",
    "        plt.plot(current_ds['Time'], max_wind_speeds[label], label=f\"{label}\", color=color)\n",
    "        #print(max_wind_speeds[label])\n",
    "\n",
    "    landfall_time = '2017-06-22 09:00z'\n",
    "    plt.axvline(pd.to_datetime(landfall_time), color='green', linestyle='--', label=f\"Landfall: {landfall_time}\")\n",
    "\n",
    "    start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "    end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "    \n",
    "    # Add labels and title\n",
    "    plt.xlabel(\"Time\")\n",
    "    plt.ylabel(\"Total Accumulated Precip (mm)\")\n",
    "    plt.title(f'Time Series Total Grid Accumulated Precipitation From {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}\\n')\n",
    "    #plt.title(f'Time Series of 3-Hour Frequency of >={threshold} m/s Wind Speeds for Each Simulation for June')\n",
    "    plt.legend(loc='lower left', fontsize='x-small')\n",
    "    plt.grid(True, alpha=0.5, linestyle='--')\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "#plot_precip_freq_time_series(precip_current_ds, precip_future_ds, precip_future_urban_ds)\n",
    "\n",
    "def plot_precip_accum_time_series(current_ds, future_ds, future_urban_ds, start_time=start_time, end_time=end_time):\n",
    "    \"\"\"\n",
    "    Plots a time series of accumulated precipitation over time for each simulation.\n",
    "\n",
    "    Parameters:\n",
    "    -----------\n",
    "    current_ds, future_ds, future_urban_ds : xarray.Dataset\n",
    "        Datasets containing precipitation data (`RAINNC`) for the current, future, and future-urban simulations.\n",
    "    start_time, end_time : str\n",
    "        Start and end time for the simulation in ISO format.\n",
    "    \"\"\"\n",
    "    # Dictionary to store accumulated precipitation for each simulation\n",
    "    accumulated_precip = {\"Current\": [],\n",
    "        \"Future\": [],\n",
    "        \"Future-Urban\": []\n",
    "    }\n",
    "\n",
    "    # Loop through each dataset and calculate cumulative precipitation\n",
    "    for label, ds in zip([\"Current\", \"Future\", \"Future-Urban\"], [current_ds, future_ds, future_urban_ds]):\n",
    "        # Extract hourly precipitation data\n",
    "        precip_data = ds['RAINNC']\n",
    "\n",
    "        # Total precipitation over the grid at each time step\n",
    "        total_precip = precip_data.groupby('Time').sum(dim=['south_north', 'west_east'])\n",
    "\n",
    "        # Calculate cumulative sum to get accumulation over time\n",
    "        accumulated_precip[label] = total_precip.cumsum(dim='Time')\n",
    "\n",
    "    # Plotting the cumulative precipitation time series\n",
    "    plt.figure(figsize=(10, 4))\n",
    "\n",
    "    # Plot each simulation with a different color\n",
    "    colors = {\"Current\": \"black\", \"Future\": \"blue\", \"Future-Urban\": \"red\"}\n",
    "    for label, color in colors.items():\n",
    "        plt.plot(ds['Time'], accumulated_precip[label], label=f\"{label}\", color=color)\n",
    "\n",
    "    # Optional: Add a vertical line for landfall time\n",
    "    landfall_time = '2017-06-22 09:00:00'\n",
    "    plt.axvline(pd.to_datetime(landfall_time), color='green', linestyle='--', label=f\"Landfall: {landfall_time}\")\n",
    "\n",
    "    # Add labels and title\n",
    "    plt.xlabel(\"Time\")\n",
    "    plt.ylabel(\"Cumulative Precipitation (mm)\")\n",
    "    plt.title(f'Cumulative Precipitation Time Series\\nFrom {start_time} to {end_time}')\n",
    "    plt.legend(loc='upper left', fontsize='small')\n",
    "    plt.grid(True, linestyle='--', alpha=0.5)\n",
    "\n",
    "    # Display the plot\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "#plot_precip_accum_time_series(precip_current_ds, precip_future_ds, precip_future_urban_ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "################# Time Series ladder plot with RH and Shear ####################\n",
    "\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot_ladder(csv_files, labels):\n",
    "    \"\"\"\n",
    "    Reads in CSV files and creates a ladder plot with time series of variables.\n",
    "    \n",
    "    Parameters:\n",
    "        csv_files (list of str): List of file paths for the CSV files.\n",
    "        labels (list of str): List of labels for each simulation.\n",
    "        output_plot (str): File name to save the plot.\n",
    "    \"\"\"\n",
    "    # Colors for each simulation\n",
    "    colors = {\"Current\": \"black\", \"Future\": \"blue\", \"Future-Urban\": \"red\"}\n",
    "    \n",
    "    # Read the CSV files into a dictionary\n",
    "    dataframes = {label: pd.read_csv(file, parse_dates=[\"Time\"]) for file, label in zip(csv_files, labels)}\n",
    "\n",
    "    # Variables to plot (exclude Time)\n",
    "    variables = [\"Min_Pressure\", \"Mean_Shear\", \"Mean_2mRH\"]\n",
    "    plot_titles = {'Min_Pressure': 'Minimum Central Pressure', 'Mean_Shear': 'Mean 200mb-850mb Wind Shear Magnitude (Radius=200km)', 'Mean_2mRH': 'Mean 2m Relative Humidity (Radius=200km)'}\n",
    "    y_labels = {'Min_Pressure': 'hPa', 'Mean_Shear': 'm/s', 'Mean_2mRH': '%'}\n",
    "    \n",
    "    # Set up the plot\n",
    "    fig, axes = plt.subplots(len(variables), 1, figsize=(10, 6), sharex=True)\n",
    "    fig.subplots_adjust(hspace=0.4)\n",
    "    \n",
    "    # Loop through each variable and plot for each simulation\n",
    "    for i, var in enumerate(variables):\n",
    "        ax = axes[i]\n",
    "        for label in labels:\n",
    "            df = dataframes[label]\n",
    "            ax.plot(df[\"Time\"], df[var], label=label, color=colors[label], lw=1.5)\n",
    "\n",
    "        # Customize each subplot\n",
    "        ax.set_title(plot_titles[var], fontsize=12)\n",
    "        ax.set_ylabel(y_labels[var], fontsize=10)\n",
    "        ax.grid(True, linestyle=\"--\", alpha=0.5)\n",
    "\n",
    "        landfall_time = '2017-06-22 09:00z'\n",
    "        ax.axvline(pd.to_datetime(landfall_time), color='green', linestyle='--', label=f\"Landfall: {landfall_time}\")\n",
    "\n",
    "    # Customize x-axis for the last subplot\n",
    "    axes[-1].set_xlabel(\"Time\", fontsize=10)\n",
    "    \n",
    "    # Add legend to the first subplot\n",
    "    axes[0].legend(labels, loc=\"lower right\", fontsize=8)\n",
    "\n",
    "    # Save and show the plot\n",
    "    #plt.savefig(output_plot, dpi=300, bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "\n",
    "# Example usage\n",
    "csv_files = [\n",
    "    \"/pscratch/sd/d/dbrooks/csv_files/TS_Cindy/Current_data.csv\",\n",
    "    \"/pscratch/sd/d/dbrooks/csv_files/TS_Cindy/Future_data.csv\",\n",
    "    \"/pscratch/sd/d/dbrooks/csv_files/TS_Cindy/Future_Urban_data.csv\"\n",
    "]\n",
    "labels = [\"Current\", \"Future\", \"Future-Urban\"]\n",
    "\n",
    "#plot_ladder(csv_files, labels)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def plot_ladder_timeseries_and_relative_change(current_wind_ds, future_wind_ds, future_urban_wind_ds,\n",
    "                                               current_precip_ds, future_precip_ds, future_urban_precip_ds,\n",
    "                                               wind_threshold, precip_threshold, start_time, end_time):\n",
    "\n",
    "    # Step 1: Helper function to calculate hourly counts of wind/precip\n",
    "    def calculate_hourly_counts(ds, var_name, threshold):\n",
    "        if var_name == 'wspd_wdir10':\n",
    "            # Extract variable (e.g., wind speed or precipitation)\n",
    "            var_data = ds[var_name].sel(wspd_wdir='wspd')\n",
    "        else:\n",
    "            var_data = ds[var_name]\n",
    "        # Count occurrences exceeding the threshold\n",
    "        #var_greater_than = var_data.where(var_data >= threshold, drop=False) # use when doing hourly values\n",
    "\n",
    "        # Group by time and count occurrences\n",
    "        #hourly_counts = var_greater_than.groupby('Time').count(dim=['south_north', 'west_east'])\n",
    "\n",
    "        # Find where wind speeds are between the thresholds (boolean mask)\n",
    "        var_greater_than = (var_data >= threshold) # use when doing 24 hr totals\n",
    "\n",
    "\n",
    "        # Group by day (from 00 UTC to 00 UTC) and count occurrences\n",
    "        daily_frequency = var_greater_than.resample(Time='1D').sum(dim='Time')\n",
    "        daily_frequency = daily_frequency.sum(dim=['south_north', 'west_east'])\n",
    "        \n",
    "        #return hourly_counts\n",
    "        return daily_frequency\n",
    "\n",
    "   # Step 2: Calculate relative change \n",
    "    def calculate_relative_change(future, current):\n",
    "        # Avoid division by zero and only compute where the current values are non-zero\n",
    "        return ((future / current) - 1) * 100\n",
    "    \n",
    "    def calculate_relative_change_urbanization(future, current, future_urban):\n",
    "        # Avoid division by zero and only compute where the current values are non-zero\n",
    "        f = ((future / current) - 1) * 100\n",
    "        fu = ((future_urban / current) - 1) * 100\n",
    "        urban_effect = fu - f\n",
    "        return urban_effect\n",
    "\n",
    "    # Step 3: Calculate hourly counts for wind and precipitation for all simulations\n",
    "    hourly_wind_counts_current = calculate_hourly_counts(current_wind_ds, 'wspd_wdir10', wind_threshold)\n",
    "    hourly_wind_counts_future = calculate_hourly_counts(future_wind_ds, 'wspd_wdir10', wind_threshold)\n",
    "    hourly_wind_counts_future_urban = calculate_hourly_counts(future_urban_wind_ds, 'wspd_wdir10', wind_threshold)\n",
    "\n",
    "    hourly_precip_counts_current = calculate_hourly_counts(current_precip_ds, 'RAINNC', precip_threshold)\n",
    "    hourly_precip_counts_future = calculate_hourly_counts(future_precip_ds, 'RAINNC', precip_threshold)\n",
    "    hourly_precip_counts_future_urban = calculate_hourly_counts(future_urban_precip_ds, 'RAINNC', precip_threshold)\n",
    "\n",
    "    # Step 4: Calculate relative change for wind and precipitation\n",
    "    relative_change_wind_future_vs_current = calculate_relative_change(hourly_wind_counts_future, hourly_wind_counts_current)\n",
    "    relative_change_wind_future_urban_vs_current = calculate_relative_change(hourly_wind_counts_future_urban, hourly_wind_counts_current)\n",
    "    relative_change_wind_future_urban_vs_future = calculate_relative_change_urbanization(hourly_wind_counts_future, hourly_wind_counts_current, hourly_wind_counts_future_urban)\n",
    "\n",
    "    relative_change_precip_future_vs_current = calculate_relative_change(hourly_precip_counts_future, hourly_precip_counts_current)\n",
    "    relative_change_precip_future_urban_vs_current = calculate_relative_change(hourly_precip_counts_future_urban, hourly_precip_counts_current)\n",
    "    relative_change_precip_future_urban_vs_future = calculate_relative_change_urbanization(hourly_precip_counts_future, hourly_precip_counts_current, hourly_precip_counts_future_urban)\n",
    "\n",
    "    # Step 5: Prepare the figure with 4 subplots (ladder plot)\n",
    "    fig, axs = plt.subplots(4, 1, figsize=(18, 13), sharex=True)\n",
    "\n",
    "    # Step 6: Plot time series of wind occurrences\n",
    "    axs[0].plot(hourly_wind_counts_current['Time'], hourly_wind_counts_current.values, label='Current', color='black')\n",
    "    axs[0].plot(hourly_wind_counts_future['Time'], hourly_wind_counts_future.values, label='Future', color='orangered', linestyle='dashed')\n",
    "    axs[0].plot(hourly_wind_counts_future_urban['Time'], hourly_wind_counts_future_urban.values, label='Future Urban', color='blue', linestyle='dashed')\n",
    "    axs[0].set_ylabel('Wind Speed Occurrences')\n",
    "    axs[0].set_title('Wind Speed Occurrences (Threshold: {}+ m/s)'.format(wind_threshold), loc='left')\n",
    "    axs[0].legend()\n",
    "    axs[0].grid(True, alpha=0.8, zorder=0)\n",
    "\n",
    "    # Step 7: Plot time series of precipitation occurrences\n",
    "    axs[1].plot(hourly_precip_counts_current['Time'], hourly_precip_counts_current.values, label='Current', color='black')\n",
    "    axs[1].plot(hourly_precip_counts_future['Time'], hourly_precip_counts_future.values, label='Future', color='orangered', linestyle='dashed')\n",
    "    axs[1].plot(hourly_precip_counts_future_urban['Time'], hourly_precip_counts_future_urban.values, label='Future Urban', color='blue', linestyle='dashed')\n",
    "    axs[1].set_ylabel('Precipitation Occurrences')\n",
    "    axs[1].set_title('Precipitation Occurrences (Threshold: {}+ mm/hr)'.format(precip_threshold), loc='left')\n",
    "    axs[1].legend()\n",
    "    axs[1].grid(True, alpha=0.8, zorder=0)\n",
    "\n",
    "    # Step 8: Plot relative change for wind\n",
    "    #axs[2].plot(hourly_wind_counts_current['Time'], relative_change_wind_future_vs_current, label='Future vs Current', color='red')\n",
    "    #axs[2].plot(hourly_wind_counts_current['Time'], relative_change_wind_future_urban_vs_current, label='Future Urban vs Current', color='blue')\n",
    "    for sim_name, rel_change, ax in [\n",
    "        ('Future Urban vs Future', relative_change_wind_future_urban_vs_future, axs[2])\n",
    "    ]:\n",
    "        time_values = hourly_wind_counts_current['Time']\n",
    "        # Fill the area below zero with red and above zero with blue\n",
    "        ax.fill_between(time_values, rel_change, 0, where=(rel_change < 0), color='orangered', alpha=0.5, interpolate=True, zorder=2)\n",
    "        ax.fill_between(time_values, rel_change, 0, where=(rel_change > 0), color='blue', alpha=0.5, interpolate=True, zorder=2)\n",
    "        # Plot the relative change line\n",
    "        ax.plot(time_values, rel_change, label=sim_name, color='green', zorder=2)\n",
    "\n",
    "    axs[2].set_ylabel('Relative Change (%)')\n",
    "    axs[2].set_title('Relative Change in Wind Speed Occurrences', loc='left')\n",
    "    axs[2].legend(loc=0)\n",
    "    axs[2].grid(True, alpha=0.8, zorder=0)\n",
    "    #axs[2].set_yscale('symlog')\n",
    "    axs[2].set_ylim(-300,300)\n",
    "\n",
    "    # Step 9: Plot relative change for precipitation\n",
    "    #axs[3].plot(hourly_precip_counts_current['Time'], relative_change_precip_future_vs_current, label='Future vs Current', color='red')\n",
    "    #axs[3].plot(hourly_precip_counts_current['Time'], relative_change_precip_future_urban_vs_current, label='Future Urban vs Current', color='blue')\n",
    "    for sim_name, rel_change, ax in [\n",
    "        ('Future Urban vs Future', relative_change_precip_future_urban_vs_future, axs[3])\n",
    "    ]:\n",
    "        time_values = hourly_precip_counts_current['Time']\n",
    "        # Fill the area below zero with red and above zero with blue\n",
    "        ax.fill_between(time_values, rel_change, 0, where=(rel_change < 0), color='orangered', alpha=0.5, interpolate=True, zorder=2)\n",
    "        ax.fill_between(time_values, rel_change, 0, where=(rel_change > 0), color='blue', alpha=0.5, interpolate=True, zorder=2)\n",
    "        # Plot the relative change line\n",
    "        ax.plot(time_values, rel_change, label=sim_name, color='green', zorder=2)\n",
    "\n",
    "    axs[3].set_ylabel('Relative Change (%)')\n",
    "    axs[3].set_title('Relative Change in Precipitation Occurrences', loc='left')\n",
    "    axs[3].legend(loc=0)\n",
    "    axs[3].grid(True, alpha=0.8, zorder=0)\n",
    "    #axs[3].set_yscale('symlog')\n",
    "    axs[3].set_ylim(-300,300)\n",
    "    \n",
    "\n",
    "    # Step 10: Customize the x-axis\n",
    "    axs[3].set_xlabel('Time')\n",
    "    \n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "    \n",
    "    if select_time_window == True:\n",
    "        start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        fig.suptitle(f'24hr (00z-00z) Frequency Differences in Wind Speeds and Hourly Precipitation Across {region} from {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")} \\n', fontsize=16)\n",
    "    else:\n",
    "        fig.suptitle(f'24hr (00z-00z) Frequency Differences in Wind Speeds and Hourly Precipitation Across {region} in {month} \\n', fontsize=16)\n",
    "    # Step 11: Adjust layout and show the plot\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "# Example usage:\n",
    "#plot_ladder_timeseries_and_relative_change(wind_current_ds, wind_future_ds, wind_future_urban_ds, precip_current_ds, precip_future_ds, precip_future_urban_ds, wind_threshold=17, precip_threshold=10, start_time=start_time, end_time=end_time)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "############################ Precip colormap ########################\n",
    "nws_precip_colors = [\n",
    "\"#405FF7\",  \n",
    "\"#2DF0EB\",  \n",
    "\"#118E00\",\n",
    "\"#5AD810\", \n",
    "\"#FAE322\",  \n",
    "\"#F5A42A\",  \n",
    "\"#DE0404\",  \n",
    "\"#A804BA\",  \n",
    "\"#FFB0FC\", \n",
    "\"#FFEAFF\" \n",
    "]\n",
    "precip_cmap = mcolors.ListedColormap(nws_precip_colors)\n",
    "\n",
    "#p_clevs=[100,200,300,400,500,600,800,900,1000]\n",
    "p_clevs=[50,100,150,200,250,300,400,500,600]\n",
    "p_cmap = mcolors.ListedColormap(precip_cmap(np.linspace(0,0.89,len(p_clevs))))\n",
    "p_norm = mcolors.BoundaryNorm(p_clevs, len(p_clevs))\n",
    "#norm = mcolors.BoundaryNorm(clevs, cmap.N)\n",
    "p_cmap.set_over(precip_cmap(np.linspace(0.99,1,1)))\n",
    "p_cmap.set_under('white')\n",
    "\n",
    "############### Diverging colormap #####################\n",
    "\n",
    "#clevs3 = [-400,-300,-200, -100, -50, 50, 100, 200, 300,400] # precip levels\n",
    "clevs3 = [-200,-100,-50, -25, -10, 10, 25, 50,100,200] # precip levels\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",
    "    '''\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",
    "    import colormaps\n",
    "    diff_cmap1 = colormaps.rdbu_11_r\n",
    "    cmap = diff_cmap1[1:10]\n",
    "    #cmap = mcolors.ListedColormap([diff_cmap1(i / (len(clevs) - 1)) for i in range(len(clevs) - 1)])\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap1(i / (len(levels) - 1)) for i in range(len(levels))]\n",
    "\n",
    "    cmap.set_over(colors[-1])   # Upper bound color\n",
    "    cmap.set_under(colors[0])  # Lower bound color\n",
    "\n",
    "    return cmap\n",
    "    \n",
    "\n",
    "# Create a ListedColormap from the custom RGBA values\n",
    "cmap5 = create_custom_diverging_colormap(levels=clevs3)\n",
    "\n",
    "# Create a normalization for the contour levels\n",
    "norm5 = mcolors.BoundaryNorm(clevs3, cmap5.N)\n",
    "#######################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x300 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "############ Plotting total precip ##################\n",
    "def calculate_relative_change(sim, current):\n",
    "    \"\"\"Calculate the relative difference (percent change) between two simulations.\"\"\"\n",
    "    sim = sim.where(sim > 50)  # Apply threshold (mm)\n",
    "    current = current.where(current > 50)\n",
    "    return ((sim/current) - 1) * 100\n",
    "\n",
    "def calculate_relative_change_urbanization(future, current, future_urban):\n",
    "    future = future.where(future > 50)  # Apply threshold (mm)\n",
    "    current = current.where(current > 50)\n",
    "    future_urban = future_urban.where(future_urban > 50)\n",
    "    f = ((future / current) - 1) * 100\n",
    "    fu = ((future_urban / current) - 1) * 100\n",
    "    return fu - f\n",
    "\n",
    "def plot_total_precip_differences(start_time,end_time):\n",
    "    \n",
    "    precip_datasets = {\n",
    "        'Current': downscsale_precip(precip_current_ds),\n",
    "        'Future': downscsale_precip(precip_future_ds),\n",
    "        'Future-Urban': downscsale_precip(precip_future_urban_ds)\n",
    "    }\n",
    "\n",
    "    # Create a 1x3 subplot (1 row, 3 columns for comparisons)\n",
    "    fig, axs = plt.subplots(1, 3, figsize=(12, 3), subplot_kw={'projection': crs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on the list provided\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Total Precipitation for Current Simulation ##############################################################\n",
    "    precip_current_total = precip_datasets['Current']['RAINNC'].sum(dim='Time')\n",
    "    lats = precip_datasets['Current']['XLAT']\n",
    "    lons = precip_datasets['Current']['XLONG']\n",
    "\n",
    "    # Calculate spatial mean and max\n",
    "    current_spatial_mean = precip_current_total.mean(dim=['south_north', 'west_east']).values\n",
    "    curreent_spatial_max = precip_current_total.max(dim=['south_north', 'west_east']).values\n",
    "    \n",
    "    ax_precip = axs[0]\n",
    "    pb = ax_precip.pcolormesh(lons, lats, precip_current_total, cmap=p_cmap, norm=p_norm, transform=crs.PlateCarree(), zorder=1)\n",
    "    #pb = ax_precip.contourf(lons, lats, precip_current_total, levels=p_clevs, cmap=p_cmap, norm=p_norm, transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_precip.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    ax_precip.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    gl = ax_precip.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    ax_precip.set_title(f'Total Precipitation (mm)', loc='left', fontsize=10)\n",
    "    ax_precip.set_title(f'(Current)', loc='right', fontsize=10)\n",
    "    \n",
    "    # Colorbar for the left plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_precip, orientation='vertical', fraction=0.05, pad=0.02, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('mm')\n",
    "\n",
    "    text_str = (\n",
    "        f\"Mean: {current_spatial_mean:.2f} mm\\n\"\n",
    "        f\"Max: {curreent_spatial_max:.2f} mm\"\n",
    "    )\n",
    "    ax_precip.text(\n",
    "        -112.2, 27.2, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=crs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "\n",
    "    ##### Middle Plot: Future - Current Precipitation Difference ##############################################################\n",
    "    precip_future_total = precip_datasets['Future']['RAINNC'].sum(dim='Time')\n",
    "    precip_future_mean = precip_future_total.mean(dim=['south_north', 'west_east']).values\n",
    "    #precip_diff_future_current = precip_future_total - precip_current_total\n",
    "    precip_diff_future_current = calculate_relative_change(precip_future_total, precip_current_total)\n",
    "    \n",
    "    mean_diff = ((precip_future_mean / current_spatial_mean) - 1) * 100 # difference change between spatial means\n",
    "    #mean_diff = precip_diff_future_current.mean(dim=['south_north', 'west_east']).values\n",
    "    #min_diff = precip_diff_future_current.min(dim=['south_north', 'west_east']).values\n",
    "    max_diff = precip_future_total.max(dim=['south_north', 'west_east']).values\n",
    "\n",
    "    ax_precip = axs[1]\n",
    "    pb = ax_precip.pcolormesh(lons, lats, precip_diff_future_current, cmap=cmap5, norm=norm5, transform=crs.PlateCarree(), zorder=1)\n",
    "\n",
    "    # add hatched region to show where precip values <50mm are masked\n",
    "    hatched_mask = precip_current_total < 50\n",
    "    #print(hatched_mask)\n",
    "    #ax_precip.contour(lons, lats, hatched_mask, colors=\"lightgray\", linewidths=1, transform=crs.PlateCarree(), zorder=1)\n",
    "    # **Contourf plot for stippling (hatching only where mask == True)**\n",
    "    ax_precip.contourf(lons, lats, hatched_mask, colors=\"lightgray\", hatches=[\"...\"], alpha=0.7, transform=crs.PlateCarree(),zorder=0)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_precip.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    ax_precip.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    gl = ax_precip.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax_precip.set_title(r'Relative Difference (%)', loc='left', fontsize=10)\n",
    "    ax_precip.set_title(f'(ACC Effect)', loc='right', fontsize=10)\n",
    "    \n",
    "    # Colorbar for the middle plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_precip, orientation='vertical', fraction=0.05, pad=0.02, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('%')\n",
    "    cbar.set_ticks(clevs3)  # Set explicit tick positions\n",
    "    cbar.set_ticklabels([f\"{t}\" for t in clevs3]) \n",
    "\n",
    "    # add text on plot\n",
    "    text_str = (\n",
    "        f\"Mean Difference: {mean_diff:.2f} %\"\n",
    "    )\n",
    "    \n",
    "    ax_precip.text(\n",
    "        -112.2, 44.8, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=crs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "    \n",
    "    text_str = (\n",
    "    f\"Mean: {precip_future_mean:.2f} mm\\n\"\n",
    "    f\"Max: {max_diff:.2f} mm\"\n",
    "    )\n",
    "    ax_precip.text(\n",
    "        -112.2, 27.2, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=crs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future Precipitation Difference ##############################################################\n",
    "    precip_future_urban_total = precip_datasets['Future-Urban']['RAINNC'].sum(dim='Time')\n",
    "    precip_future_urban_mean = precip_future_urban_total.mean(dim=['south_north', 'west_east']).values\n",
    "    #precip_diff_future_urban_future = precip_future_urban_total - precip_future_total\n",
    "\n",
    "    precip_diff_future_urban_future = calculate_relative_change_urbanization(precip_future_total, precip_current_total, precip_future_urban_total)\n",
    "    \n",
    "    mean_diff = (((precip_future_urban_mean / current_spatial_mean) - 1) * 100) - (((precip_future_mean / current_spatial_mean) - 1) * 100) # difference change between spatial means\n",
    "    #mean_diff = precip_diff_future_urban_future.mean(dim=['south_north', 'west_east']).values\n",
    "    #min_diff = precip_diff_future_urban_future.min(dim=['south_north', 'west_east']).values\n",
    "    max_diff = precip_future_urban_total.max(dim=['south_north', 'west_east']).values\n",
    "    \n",
    "    ax_precip = axs[2]\n",
    "    pb = ax_precip.pcolormesh(lons, lats, precip_diff_future_urban_future, cmap=cmap5, norm=norm5, transform=crs.PlateCarree(), zorder=1)\n",
    "    #pb = ax_precip.contourf(lons, lats, precip_diff_future_urban_future, levels=clevs3, cmap=cmap5, norm=norm5, transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "\n",
    "    # add hatched region to show where precip values <50mm are masked\n",
    "    ax_precip.contourf(lons, lats, hatched_mask, colors=\"lightgray\", hatches=[\"...\"], alpha=0.7, transform=crs.PlateCarree(),zorder=0)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_precip.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    ax_precip.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    gl = ax_precip.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax_precip.set_title(fr'Relative Difference (%)', loc='left', fontsize=10)\n",
    "    ax_precip.set_title(f'(Urbanization Effect)', loc='right', fontsize=10)\n",
    "    \n",
    "    # Colorbar for the right plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_precip, orientation='vertical', fraction=0.05, pad=0.02, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('%')\n",
    "    cbar.set_ticks(clevs3)  # Set explicit tick positions\n",
    "    cbar.set_ticklabels([f\"{t}\" for t in clevs3]) \n",
    "\n",
    "    # add text on plot\n",
    "    text_str = (\n",
    "        f\"Mean Difference: {mean_diff:.2f} %\"\n",
    "    )\n",
    "    \n",
    "    ax_precip.text(\n",
    "        -112.2, 44.8, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=crs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "    \n",
    "    text_str = (\n",
    "    f\"Mean: {precip_future_urban_mean:.2f} mm\\n\"\n",
    "    f\"Max: {max_diff:.2f} mm\"\n",
    "    )\n",
    "    ax_precip.text(\n",
    "        -112.2, 27.2, text_str,  # Adjust coordinates as needed\n",
    "        fontsize=8, color=\"black\", weight='bold',transform=crs.PlateCarree(),\n",
    "        bbox=dict(facecolor=\"white\", alpha=0.9, boxstyle=\"round,pad=0.5\")\n",
    "    )\n",
    "\n",
    "    # Set a main title for the figure\n",
    "    if select_time_window == True:\n",
    "        start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        fig.suptitle(f'Total Precipitation and Differences from {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}\\n', fontsize=16)\n",
    "    else:\n",
    "        fig.suptitle(f'Total Precipitation and Differences Between Simulations in {month}', fontsize=12)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "plot_total_precip_differences(start_time,end_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "object of type 'int' has no len()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[53], line 14\u001b[0m\n\u001b[1;32m     12\u001b[0m clevs3 \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m90\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m70\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m50\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m30\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m10\u001b[39m, \u001b[38;5;241m10\u001b[39m,\u001b[38;5;241m30\u001b[39m,\u001b[38;5;241m50\u001b[39m,\u001b[38;5;241m70\u001b[39m,\u001b[38;5;241m90\u001b[39m] \u001b[38;5;66;03m# precip levels\u001b[39;00m\n\u001b[1;32m     13\u001b[0m \u001b[38;5;66;03m# Create a ListedColormap from the custom RGBA values\u001b[39;00m\n\u001b[0;32m---> 14\u001b[0m cmap5 \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_custom_diverging_colormap\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlevels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mclevs3\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     16\u001b[0m \u001b[38;5;66;03m# Create a normalization for the contour levels\u001b[39;00m\n\u001b[1;32m     17\u001b[0m norm5 \u001b[38;5;241m=\u001b[39m mcolors\u001b[38;5;241m.\u001b[39mBoundaryNorm(clevs3, \u001b[38;5;28mlen\u001b[39m(clevs3))\n",
      "Cell \u001b[0;32mIn[51], line 64\u001b[0m, in \u001b[0;36mcreate_custom_diverging_colormap\u001b[0;34m(levels)\u001b[0m\n\u001b[1;32m     60\u001b[0m cmap \u001b[38;5;241m=\u001b[39m diff_cmap1[\u001b[38;5;241m1\u001b[39m:\u001b[38;5;241m10\u001b[39m]\n\u001b[1;32m     61\u001b[0m \u001b[38;5;66;03m#cmap = mcolors.ListedColormap([diff_cmap1(i / (len(clevs) - 1)) for i in range(len(clevs) - 1)])\u001b[39;00m\n\u001b[1;32m     62\u001b[0m \n\u001b[1;32m     63\u001b[0m \u001b[38;5;66;03m# Extract individual colors from the base colormap\u001b[39;00m\n\u001b[0;32m---> 64\u001b[0m colors \u001b[38;5;241m=\u001b[39m [diff_cmap1(i \u001b[38;5;241m/\u001b[39m (\u001b[38;5;28mlen\u001b[39m(levels) \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m)) \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mlevels\u001b[49m\u001b[43m)\u001b[49m)]\n\u001b[1;32m     66\u001b[0m cmap\u001b[38;5;241m.\u001b[39mset_over(colors[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])   \u001b[38;5;66;03m# Upper bound color\u001b[39;00m\n\u001b[1;32m     67\u001b[0m cmap\u001b[38;5;241m.\u001b[39mset_under(colors[\u001b[38;5;241m0\u001b[39m])  \u001b[38;5;66;03m# Lower bound color\u001b[39;00m\n",
      "\u001b[0;31mTypeError\u001b[0m: object of type 'int' has no len()"
     ]
    }
   ],
   "source": [
    "###################### Plotting max precip intensity ######################\n",
    "precip_cmap = matplotlib.colormaps['plasma']\n",
    "\n",
    "p_clevs=[0.25,2.5,10,40]\n",
    "p_cmap = mcolors.ListedColormap(precip_cmap(np.linspace(0,0.7,len(p_clevs))))\n",
    "p_norm = mcolors.BoundaryNorm(p_clevs, len(p_clevs))\n",
    "#norm = mcolors.BoundaryNorm(clevs, cmap.N)\n",
    "p_cmap.set_over(precip_cmap(np.linspace(0.99,1,1)))\n",
    "p_cmap.set_under('white')\n",
    "\n",
    "############### Diverging colormap ################\n",
    "clevs3 = [-90,-70,-50,-30, -10, 10,30,50,70,90] # precip levels\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))\n",
    "\n",
    "def plot_max_precip_intensity_differences(start_time,end_time):\n",
    "    \n",
    "    precip_datasets = {\n",
    "        'Current': precip_current_ds,\n",
    "        'Future': precip_future_ds,\n",
    "        'Future-Urban': precip_future_urban_ds\n",
    "    }\n",
    "\n",
    "    # Create a 1x3 subplot (1 row, 3 columns for comparisons)\n",
    "    fig, axs = plt.subplots(1, 3, figsize=(17, 5), subplot_kw={'projection': crs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on the list provided\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Total Precipitation for Current Simulation #####\n",
    "    precip_current_total = precip_datasets['Current']['RAINNC'].max(dim='Time')\n",
    "    lats = precip_datasets['Current']['XLAT']\n",
    "    lons = precip_datasets['Current']['XLONG']\n",
    "    \n",
    "    ax_precip = axs[0]\n",
    "    pb = ax_precip.pcolormesh(lons, lats, precip_current_total, cmap=p_cmap, norm=p_norm, transform=crs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_precip.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    ax_precip.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    gl = ax_precip.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    ax_precip.set_title(f'Max Precip Intensity (mm/hr)', loc='left', fontsize=12)\n",
    "    ax_precip.set_title(f'(Current)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar for the left plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_precip, orientation='vertical', fraction=0.05, pad=0.05, shrink=0.8, extend='both')\n",
    "    cbar.set_label('mm/hr')\n",
    "\n",
    "    ##### Middle Plot: Future - Current Precipitation Difference #####\n",
    "    precip_future_total = precip_datasets['Future']['RAINNC'].max(dim='Time')\n",
    "    precip_diff_future_current = precip_future_total - precip_current_total\n",
    "    \n",
    "    ax_precip = axs[1]\n",
    "    pb = ax_precip.pcolormesh(lons, lats, precip_diff_future_current, cmap=cmap5, norm=norm5, transform=crs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_precip.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    ax_precip.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    gl = ax_precip.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax_precip.set_title(r'$\\Delta$Max Precip Intensity', loc='left', fontsize=12)\n",
    "    ax_precip.set_title(f'(ACC Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar for the middle plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_precip, orientation='vertical', fraction=0.05, pad=0.05, shrink=0.8, extend='both')\n",
    "    cbar.set_label('mm/hr')\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future Precipitation Difference #####\n",
    "    precip_future_urban_total = precip_datasets['Future-Urban']['RAINNC'].max(dim='Time')\n",
    "    precip_diff_future_urban_future = precip_future_urban_total - precip_future_total\n",
    "    \n",
    "    ax_precip = axs[2]\n",
    "    pb = ax_precip.pcolormesh(lons, lats, precip_diff_future_urban_future, cmap=cmap5, norm=norm5, transform=crs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_precip.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    ax_precip.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    gl = ax_precip.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax_precip.set_title(r'$\\Delta$Max Precip Intensity', loc='left', fontsize=12)\n",
    "    ax_precip.set_title(f'(Urbanization Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar for the right plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_precip, orientation='vertical', fraction=0.05, pad=0.05, shrink=0.8, extend='both')\n",
    "    cbar.set_label('mm/hr')\n",
    "\n",
    "    # Set a main title for the figure\n",
    "    if select_time_window == True:\n",
    "        start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        fig.suptitle(f'Maximum Precip. Intensity (mm/hr) and Differences from {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}\\n', fontsize=16)\n",
    "    else:\n",
    "        fig.suptitle(f'Maximum Precip. Intensity (mm/hr) and Differences Between Simulations in {month}', fontsize=16)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "#plot_max_precip_intensity_differences(start_time,end_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "########## Plot contours from simulations onto one plot #############\n",
    "def plot_mean_height_alt(current_ds,future_ds,future_urban_ds, threshold):\n",
    "    # Define the simulation types and corresponding datasets\n",
    "    simulations = ['Current', 'Future', 'Future-Urban']\n",
    "    #datasets = [current_ds,future_ds,future_urban_ds]\n",
    "    datasets = [downscsale_precip(current_ds),downscsale_precip(future_ds),downscsale_precip(future_urban_ds)]\n",
    "\n",
    "    # Create a 3x3 subplot for 3 simulation types and 3 months\n",
    "    fig, axs = plt.subplots(1, 1, figsize=(6, 5), subplot_kw={'projection': crs.PlateCarree()})\n",
    "\n",
    "    # Define the months we're interested in (April, May, June)\n",
    "    months = [6]\n",
    "\n",
    "    # Contour levels every 3 decameters\n",
    "    #contour_levels = np.arange(550, 600, 4)\n",
    "    contour_levels=[threshold]\n",
    "\n",
    "    colors = {'Current': 'limegreen',\n",
    "              'Future': 'blue',\n",
    "              'Future-Urban': 'red'}\n",
    "\n",
    "    # Iterate over the simulations and datasets\n",
    "    for row, (simulation, ds) in enumerate(zip(simulations, datasets)):\n",
    "\n",
    "        # Extract the height data\n",
    "        #max_precip = ds['RAINNC']\n",
    "        max_precip = ds['wspd_wdir10'].sel(wspd_wdir='wspd')\n",
    "\n",
    "\n",
    "        # Group the data by month using the 'Time' dimension\n",
    "        grouped_by_month = max_precip.groupby('Time.month')\n",
    "\n",
    "        # Loop over the months\n",
    "        for col, month in enumerate(months):\n",
    "            # Compute the mean for the current month\n",
    "            max_precip_threshold = grouped_by_month.max(dim='Time').sel(month=month)\n",
    "\n",
    "            #print(max_precip_threshold)\n",
    "            max_precip_threshold = max_precip_threshold >= threshold\n",
    "            #print(max_precip_threshold)\n",
    "            # Extract latitude and longitude coordinates\n",
    "            lats = ds['XLAT']\n",
    "            lons = ds['XLONG']\n",
    "            \n",
    "            # Select the correct subplot\n",
    "            #ax = axs[col]\n",
    "            ax=axs\n",
    "\n",
    "            # Plot the contours for the current month\n",
    "            contours = ax.contour(lons, lats, max_precip_threshold, colors=colors[simulation], linewidths=1, transform=crs.PlateCarree(), zorder=2)\n",
    "\n",
    "            # Add geographic features\n",
    "            ax.add_feature(cfeature.STATES, edgecolor=\"gray\", zorder=1, alpha=0.35, linewidths=0.35)\n",
    "            ax.add_feature(cfeature.COASTLINE, edgecolor=\"gray\", zorder=1, alpha=0.35, linewidths=0.35)\n",
    "\n",
    "            # Gridlines and labels\n",
    "            gl = ax.gridlines(draw_labels=True, crs=crs.PlateCarree(), linewidth=0.5, color='gray', alpha=0.35, linestyle=':', zorder=2)\n",
    "            gl.top_labels = False\n",
    "            gl.right_labels = False \n",
    "            gl.left_labels = col == 0  # Only enable left labels on the leftmost plot\n",
    "            gl.bottom_labels = row == 0  # Enable bottom labels on the bottom \n",
    "            \n",
    "            if month == 4:\n",
    "                month1 = 'April'\n",
    "            elif month == 5:\n",
    "                month1 = 'May'\n",
    "            elif month == 6:\n",
    "                month1 = 'June'\n",
    "\n",
    "            # Set title for each subplot\n",
    "            #ax.set_title(f'{month1}', loc='right')\n",
    "            ax.set_title(f\"During Cindy's Lifetime\", loc='right')\n",
    "            #ax.set_title(f'{threshold}+ mm/hr', loc='left')\n",
    "            ax.set_title(f'{threshold}+ m/s', loc='left')\n",
    "            \n",
    "            # Create legend with custom lines for each simulation\n",
    "            legend_handles = [\n",
    "                mlines.Line2D([], [], color=colors[sim], label=sim, linewidth=1.5) for sim in simulations\n",
    "            ]\n",
    "            ax.legend(handles=legend_handles, loc='upper left')\n",
    "\n",
    "\n",
    "    # Set a main title for the figure\n",
    "    #fig.suptitle(f'Contours Where Max Precip Intensity Was {threshold}+ mm/hr', fontsize=16)\n",
    "    fig.suptitle(f'Contours Where Max 10m Wind Speed Was {threshold}+ m/s', fontsize=16)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "#plot_mean_height_alt(precip_current_ds, precip_future_ds, precip_future_urban_ds, threshold=40)\n",
    "#plot_mean_height_alt(wind_current_ds, wind_future_ds, wind_future_urban_ds, threshold=25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3.22635597 13.25916894 17.31030149 67.40935834]\n",
      "[ 0.29254468 -0.38566688 -1.93322002 -9.37957987]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "############## precip intensity AREA and FREQUENCY histogram ###############\n",
    "\n",
    "# Constants\n",
    "PRECIP_BINS = [(0.25, 2.5), (2.5, 10), (10, 50),(50, np.inf)]\n",
    "BIN_LABELS = ['0.25-2.5', '2.5-10', '10-50','≥50']\n",
    "GRID_CELL_AREA = 4  # Placeholder for grid cell area in km^2, adjust as needed (2km resolution, equals 4km squared)\n",
    "\n",
    "# Functions to calculate relative changes\n",
    "def calculate_relative_change(future, current):\n",
    "    return ((future / current) - 1) * 100\n",
    "\n",
    "def calculate_relative_change_urbanization(future, current, future_urban):\n",
    "    f = ((future / current) - 1) * 100\n",
    "    fu = ((future_urban / current) - 1) * 100\n",
    "    return fu - f\n",
    "\n",
    "# Function to calculate the fraction of total area per bin\n",
    "def calculate_area_fraction_per_bin(precip_data, bins):\n",
    "    total_area = precip_data.sizes['south_north'] * precip_data.sizes['west_east']  # Total grid cells in domain\n",
    "    bin_fractions = []\n",
    "\n",
    "    for lower, upper in bins:\n",
    "        bin_mask = (precip_data >= lower) & (precip_data < upper)\n",
    "        bin_count_per_time = bin_mask.sum(dim=['south_north', 'west_east']) / total_area  # Fraction per timestep\n",
    "        mean_bin_fraction = bin_count_per_time.mean(dim='Time').item()  # Average fraction over time\n",
    "        bin_fractions.append(mean_bin_fraction)\n",
    "\n",
    "    return bin_fractions\n",
    "\n",
    "def plot_precip_intensity_area_fraction_bar(start_time=start_time, end_time=start_time):\n",
    "    # Step 1: Extract max hourly precipitation data for each simulation\n",
    "    max_precip_current = precip_current_ds['RAINNC']\n",
    "    max_precip_future = precip_future_ds['RAINNC']\n",
    "    max_precip_future_urban = precip_future_urban_ds['RAINNC']\n",
    "\n",
    "    # Step 2: Compute area fraction per bin\n",
    "    area_frac_current = calculate_area_fraction_per_bin(max_precip_current, PRECIP_BINS)\n",
    "    area_frac_future = calculate_area_fraction_per_bin(max_precip_future, PRECIP_BINS)\n",
    "    area_frac_future_urban = calculate_area_fraction_per_bin(max_precip_future_urban, PRECIP_BINS)\n",
    "\n",
    "    # Step 3: Compute relative changes\n",
    "    relative_change_future = calculate_relative_change(np.array(area_frac_future), np.array(area_frac_current))\n",
    "    relative_change_urban = calculate_relative_change_urbanization(\n",
    "        np.array(area_frac_future), np.array(area_frac_current), np.array(area_frac_future_urban)\n",
    "    )\n",
    "\n",
    "    # Step 4: Plotting\n",
    "    fig, ax1 = plt.subplots(figsize=(5, 4))\n",
    "\n",
    "    # Bar width and positions\n",
    "    bar_width = 0.2\n",
    "    x = np.arange(len(PRECIP_BINS))\n",
    "\n",
    "    # Plot bars for each simulation as a fraction of the domain area\n",
    "    ax1.bar(x - bar_width, area_frac_current, width=bar_width, color='black', label='Current')\n",
    "    ax1.bar(x, area_frac_future, width=bar_width, color='#1E88E5', label='Future')\n",
    "    ax1.bar(x + bar_width, area_frac_future_urban, width=bar_width, color='#D81B60', label='Future+Urban')\n",
    "\n",
    "    # Primary Y-axis (left)\n",
    "    ax1.set_xlabel('Precipitation rate (mm hr$^{-1}$)')\n",
    "    ax1.set_ylabel('Mean Fraction of Total Area')\n",
    "    ax1.set_yscale('log')\n",
    "    ax1.set_xticks(x)\n",
    "    ax1.set_xticklabels(BIN_LABELS)\n",
    "    ax1.set_ylim(0, 0.5)  # Since it's a fraction\n",
    "\n",
    "    ax1.legend(loc='upper left')\n",
    "\n",
    "    # Secondary Y-axis (right) for relative changes\n",
    "    ax2 = ax1.twinx()\n",
    "    ax2.plot(x, relative_change_future, color='black', marker='o', linestyle='--', label='ACC Impact', linewidth=2)\n",
    "    ax2.plot(x, relative_change_urban, color='black', marker='s', linestyle=':', label='Urbanization', linewidth=2)\n",
    "    ax2.set_ylabel('Relative change (%)', color='black')\n",
    "    ax2.set_ylim(-20, 100)  # Adjust based on expected range of relative changes\n",
    "    ax2.grid(True, axis='y', alpha=0.5)\n",
    "\n",
    "    # Add legend for secondary y-axis lines\n",
    "    ax2.legend(loc='upper right')\n",
    "\n",
    "    # Determine the month name\n",
    "    month = {'04': 'April', '05': 'May', '06': 'June'}.get(monlist[0], \"Unknown\")\n",
    "\n",
    "    # Title and layout adjustments\n",
    "    if select_time_window:\n",
    "        start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        ax1.set_title(f'Fraction of Total Area by Maximum Precip Intensity from {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}\\n(Subregion)', fontsize=16)\n",
    "    else:\n",
    "        ax1.set_title(f'Mean Fraction of Total Area by Precip Intensity\\n{month}')\n",
    "\n",
    "    fig.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "# Precipitation intensity bins and labels (same as before)\n",
    "PRECIP_BINS = [(0.25, 2.5), (2.5, 10), (10, 50),(50, np.inf)]\n",
    "BIN_LABELS = ['0.25-2.5', '2.5-10', '10-50','≥50']\n",
    "\n",
    "# Function to calculate frequency (number of occurrences) per intensity bin\n",
    "def calculate_frequency_per_bin(precip_data, bins):\n",
    "    bin_frequencies = []\n",
    "    for lower, upper in bins:\n",
    "        # Count occurrences within each bin across all time steps and grid points\n",
    "        bin_mask = (precip_data >= lower) & (precip_data < upper)\n",
    "        bin_frequency = bin_mask.sum().item()  # Total occurrences in this bin\n",
    "        bin_frequencies.append(bin_frequency)\n",
    "    return bin_frequencies\n",
    "\n",
    "def plot_precip_intensity_frequency_bar(start_time,end_time):\n",
    "    # Step 1: Use all occurrences of precipitation values for each simulation across all time steps and grid cells\n",
    "    all_precip_current = precip_current_ds['RAINNC']\n",
    "    all_precip_future = precip_future_ds['RAINNC']\n",
    "    all_precip_future_urban = precip_future_urban_ds['RAINNC']\n",
    "\n",
    "    # Step 2: Calculate frequency for each bin for each simulation\n",
    "    freq_current = calculate_frequency_per_bin(all_precip_current, PRECIP_BINS)\n",
    "    freq_future = calculate_frequency_per_bin(all_precip_future, PRECIP_BINS)\n",
    "    freq_future_urban = calculate_frequency_per_bin(all_precip_future_urban, PRECIP_BINS)\n",
    "\n",
    "    # Step 3: Calculate relative change between simulations\n",
    "    relative_change_future = calculate_relative_change(np.array(freq_future), np.array(freq_current))\n",
    "    relative_change_urban = calculate_relative_change_urbanization(\n",
    "        np.array(freq_future), np.array(freq_current), np.array(freq_future_urban)\n",
    "    )\n",
    "    print(relative_change_future)\n",
    "    print(relative_change_urban)\n",
    "    # Step 4: Plotting\n",
    "    fig, ax1 = plt.subplots(figsize=(5, 4))\n",
    "\n",
    "    # Bar width and positions\n",
    "    bar_width = 0.2\n",
    "    x = np.arange(len(PRECIP_BINS))\n",
    "\n",
    "    # Plot bars for each simulation\n",
    "    ax1.bar(x - bar_width, freq_current, width=bar_width, color='black', label='Current',zorder=2)\n",
    "    ax1.bar(x, freq_future, width=bar_width, color='#1E88E5', label='Future',zorder=2)\n",
    "    ax1.bar(x + bar_width, freq_future_urban, width=bar_width, color='#D81B60', label='Future-Urban',zorder=2)\n",
    "\n",
    "    # Primary Y-axis (left)\n",
    "    ax1.set_xlabel('Precipitation rate (mm hr$^{-1}$)')\n",
    "    ax1.set_ylabel('Frequency (# of Occurrences)')\n",
    "    ax1.set_yscale('log')\n",
    "    ax1.set_xticks(x)\n",
    "    ax1.set_xticklabels(BIN_LABELS)\n",
    "    ax1.set_ylim(10e3, 10e8)\n",
    "\n",
    "    # Secondary Y-axis (right) for relative changes\n",
    "    ax2 = ax1.twinx()\n",
    "    ax2.plot(x, relative_change_future, color='black', marker='o', linestyle='--', label='ACC Impact', linewidth=2)\n",
    "    ax2.plot(x, relative_change_urban, color='black', marker='s', linestyle=':', label='Urbanization', linewidth=2)\n",
    "    ax2.set_ylabel('Relative change (%)', color='black')\n",
    "    ax2.set_ylim(-20, 100)  # Adjust based on expected range of relative changes\n",
    "    ax2.grid(True, axis='y', alpha=0.5)\n",
    "\n",
    "    # Add legend for secondary y-axis lines\n",
    "    ax2.legend(loc='upper right')\n",
    "    ax1.legend(loc='upper left')\n",
    "\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    # Title and layout adjustments\n",
    "    # Title and layout adjustments\n",
    "    if select_time_window == True:\n",
    "        start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        ax1.set_title(f'Frequency of Precipitation Intensity from {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}\\n(Subregion)', fontsize=16)\n",
    "    else:\n",
    "        ax1.set_title(f'Frequency of Precipitation Intensity in {month}\\n(Full Domain)')\n",
    "    fig.tight_layout()\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "# Call the function to plot\n",
    "#plot_precip_intensity_frequency_bar(start_time,end_time)\n",
    "\n",
    "\n",
    "# Call the function to plot\n",
    "#plot_precip_intensity_area_fraction_bar(start_time,end_time)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done1\n",
      "done2\n",
      "Dataset sizes - Current: 34,830,965, Future: 34,401,361, Future+Urban: 34,359,296\n",
      "\n",
      "Raw frequencies:\n",
      "  Current: [22938073, 8592491, 3150446, 149955]\n",
      "  Future: [21408506, 8972749, 3778686, 241420]\n",
      "  Future+Urban: [21408865, 8923921, 3782980, 243530]\n",
      "\n",
      "============================================================\n",
      "BOOTSTRAP MODE: Raw counts (scaled)\n",
      "============================================================\n",
      "Running 100 iterations in 10 chunks of 10 with 4 workers...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Bootstrapping (chunked): 100%|██████████| 10/10 [00:04<00:00,  2.14it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running 100 iterations in 10 chunks of 10 with 4 workers...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Bootstrapping (chunked): 100%|██████████| 10/10 [00:04<00:00,  2.14it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running 100 iterations in 10 chunks of 10 with 4 workers...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Bootstrapping (chunked): 100%|██████████| 10/10 [00:04<00:00,  2.16it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Bootstrap Confidence Intervals (95%):\n",
      "  ACC:       Lower=[-6.8557448387146, 3.875175714492798, 19.130369186401367, 54.90231704711914], Upper=[-6.427149772644043, 4.9504852294921875, 20.710792541503906, 66.89945983886719]\n",
      "  ACC+Urb:   Lower=[-6.857858180999756, 3.3809406757354736, 18.842058181762695, 57.660247802734375], Upper=[-6.476715087890625, 4.292219161987305, 21.004934310913086, 67.92801666259766]\n",
      "  Urban:     Lower=[-0.19729462265968323, -1.036682367324829, -0.6130304932594299, -1.8201433420181274], Upper=[0.18617387115955353, -0.1031600758433342, 0.7338989973068237, 4.039036750793457]\n",
      "ACC+Urb: [-6.66668033  3.85720509 20.07760171 62.40205395]\n",
      "ACC: [-6.66824541  4.4254687  19.94130355 60.99496516]\n",
      "Urb: [ 0.0016769  -0.54418105  0.11363739  0.87399553]\n",
      "\n",
      "============================================================\n",
      "VERIFICATION: Do raw values fall within confidence intervals?\n",
      "============================================================\n",
      "Bin 0.25-2.5:\n",
      "  Warming:       -6.67% [-6.86, -6.43]\n",
      "  Combined:   -6.67% [-6.86, -6.48]\n",
      "  Urbanization:     0.00% [-0.20, 0.19]\n",
      "Bin 2.5-10:\n",
      "  Warming:       4.43% [3.88, 4.95]\n",
      "  Combined:   3.86% [3.38, 4.29]\n",
      "  Urbanization:     -0.54% [-1.04, -0.10]\n",
      "Bin 10-50:\n",
      "  Warming:       19.94% [19.13, 20.71]\n",
      "  Combined:   20.08% [18.84, 21.00]\n",
      "  Urbanization:     0.11% [-0.61, 0.73]\n",
      "Bin ≥50:\n",
      "  Warming:       60.99% [54.90, 66.90]\n",
      "  Combined:   62.40% [57.66, 67.93]\n",
      "  Urbanization:     0.87% [-1.82, 4.04]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n",
      "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n",
      "\u001b[1;31mClick <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. \n",
      "\u001b[1;31mView Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "########### Bootstrapping Test ##############\n",
    "from joblib import Parallel, delayed\n",
    "from scipy.stats import mannwhitneyu\n",
    "from tqdm import tqdm\n",
    "\n",
    "# Sample precipitation bins and labels\n",
    "PRECIP_BINS = [(0.25, 2.5), (2.5, 10), (10, 50), (50, np.inf)]\n",
    "BIN_LABELS = ['0.25-2.5', '2.5-10', '10-50', '≥50']\n",
    "\n",
    "\n",
    "# Functions to calculate relative changes\n",
    "def calculate_relative_change(future, current):\n",
    "    return ((future / current) - 1) * 100\n",
    "\n",
    "def calculate_relative_change_urbanization(future, current, future_urban):\n",
    "    #f = ((future / current) - 1) * 100\n",
    "    #fu = ((future_urban / current) - 1) * 100\n",
    "    #return fu - f\n",
    "    return ((future_urban - future) / future) * 100\n",
    "\n",
    "# Function to calculate frequency (number of occurrences) per intensity bin for wind speeds\n",
    "def calculate_frequency_per_bin(wind_data, bins):\n",
    "    bin_frequencies = []\n",
    "    for lower, upper in bins:\n",
    "        # Count occurrences within each bin across all time steps and grid points\n",
    "        bin_mask = (wind_data >= lower) & (wind_data < upper)\n",
    "        bin_frequency = bin_mask.sum().item()  # Total occurrences in this bin\n",
    "        bin_frequencies.append(bin_frequency)\n",
    "    return bin_frequencies\n",
    "\n",
    "\n",
    "# Normalized frequency\n",
    "def calculate_percentage_per_bin(precip_data, bins):\n",
    "    #print(type(precip_data))\n",
    "    if type(precip_data) == np.ndarray: \n",
    "        total_occurrences = len(precip_data)\n",
    "    else:\n",
    "        total_occurrences = precip_data.count().item() # Total number of grid points across all time steps\n",
    "    bin_percentages = []\n",
    "\n",
    "    for lower, upper in bins:\n",
    "        bin_mask = (precip_data >= lower) & (precip_data < upper)\n",
    "        bin_frequency = bin_mask.sum().item()  # Count occurrences in this bin\n",
    "        bin_percentage = (bin_frequency / total_occurrences) * 100  # Normalize to percentage\n",
    "        bin_percentages.append(bin_percentage)\n",
    "\n",
    "    return bin_percentages\n",
    "\n",
    "\n",
    "def bootstrap_chunk(current, future, future_urban, bins, n_iterations, urban, c_fu, normalize=False):\n",
    "    \"\"\"Run a small batch of bootstrap iterations serially inside one worker.\"\"\"\n",
    "    rel_changes = []\n",
    "    p_vals = []\n",
    "    \n",
    "    # Use consistent sample size across all scenarios to match raw calculation approach\n",
    "    # Sample the same proportion from each dataset to avoid bias\n",
    "    max_sample = 1000000\n",
    "    sample_size_cur = min(max_sample, len(current))\n",
    "    sample_size_fut = min(max_sample, len(future))\n",
    "    sample_size_fut_urb = min(max_sample, len(future_urban))\n",
    "\n",
    "    for _ in range(n_iterations):\n",
    "        # Bootstrap sampling WITH REPLACEMENT to estimate the distribution\n",
    "        cur_sample = np.random.choice(current, size=sample_size_cur, replace=True)\n",
    "        fut_sample = np.random.choice(future, size=sample_size_fut, replace=True)\n",
    "        fut_urb_sample = np.random.choice(future_urban, size=sample_size_fut_urb, replace=True)\n",
    "\n",
    "        # Calculate frequencies per bin\n",
    "        if normalize:\n",
    "            # For normalized mode, calculate percentages instead of raw counts\n",
    "            cur_freq = np.array(calculate_percentage_per_bin(cur_sample, bins), dtype=np.float32)\n",
    "            fut_freq = np.array(calculate_percentage_per_bin(fut_sample, bins), dtype=np.float32)\n",
    "            fut_urb_freq = np.array(calculate_percentage_per_bin(fut_urb_sample, bins), dtype=np.float32)\n",
    "        else:\n",
    "            # For raw count mode, scale frequencies by dataset size to match raw calculation\n",
    "            # This ensures the bootstrap represents the same proportion as the full dataset\n",
    "            cur_freq_counts = np.array(calculate_frequency_per_bin(cur_sample, bins), dtype=np.float32)\n",
    "            fut_freq_counts = np.array(calculate_frequency_per_bin(fut_sample, bins), dtype=np.float32)\n",
    "            fut_urb_freq_counts = np.array(calculate_frequency_per_bin(fut_urb_sample, bins), dtype=np.float32)\n",
    "            \n",
    "            # Scale to full dataset size (extrapolate from sample)\n",
    "            cur_freq = cur_freq_counts * (len(current) / sample_size_cur)\n",
    "            fut_freq = fut_freq_counts * (len(future) / sample_size_fut)\n",
    "            fut_urb_freq = fut_urb_freq_counts * (len(future_urban) / sample_size_fut_urb)\n",
    "\n",
    "        if urban == False:\n",
    "            # For current vs future_urban\n",
    "            if c_fu == True:\n",
    "                with np.errstate(divide='ignore', invalid='ignore'):\n",
    "                    rel = ((fut_urb_freq / cur_freq) - 1) * 100\n",
    "                    rel[cur_freq == 0] = np.nan\n",
    "            # For current vs future\n",
    "            elif c_fu == False:\n",
    "                with np.errstate(divide='ignore', invalid='ignore'):\n",
    "                    rel = ((fut_freq / cur_freq) - 1) * 100\n",
    "                    rel[cur_freq == 0] = np.nan\n",
    "        elif urban == True:\n",
    "            with np.errstate(divide='ignore', invalid='ignore'):\n",
    "                #f = ((fut_freq / cur_freq) - 1) * 100\n",
    "                #fu = ((fut_urb_freq / cur_freq) - 1) * 100\n",
    "                rel = ((fut_urb_freq - fut_freq) / fut_freq) * 100\n",
    "                rel[cur_freq == 0] = np.nan\n",
    "\n",
    "        try:\n",
    "            _, p = mannwhitneyu(cur_sample, fut_sample, alternative='two-sided')\n",
    "        except ValueError:\n",
    "            p = np.nan\n",
    "\n",
    "        rel_changes.append(rel)\n",
    "        p_vals.append(p)\n",
    "\n",
    "    return rel_changes, p_vals\n",
    "\n",
    "def bootstrap_relative_change_chunked(current, future, future_urban, bins, n_iterations=1000, batch_size=10, n_jobs=-1, urban=False, c_fu=False, normalize=False):\n",
    "    n_chunks = n_iterations // batch_size\n",
    "    remaining = n_iterations % batch_size\n",
    "\n",
    "    print(f\"Running {n_iterations} iterations in {n_chunks} chunks of {batch_size} with {n_jobs} workers...\")\n",
    "\n",
    "    # Create task list\n",
    "    tasks = [batch_size] * n_chunks\n",
    "    if remaining > 0:\n",
    "        tasks.append(remaining)\n",
    "\n",
    "    # Run in parallel over batches\n",
    "    results = Parallel(n_jobs=n_jobs)(\n",
    "        delayed(bootstrap_chunk)(current, future, future_urban, bins, n_iter, urban, c_fu, normalize)\n",
    "        for n_iter in tqdm(tasks, desc=\"Bootstrapping (chunked)\")\n",
    "    )\n",
    "\n",
    "    # Flatten results\n",
    "    rel_changes = np.concatenate([np.array(r[0]) for r in results], axis=0)\n",
    "    p_values = np.concatenate([np.array(r[1]) for r in results], axis=0)\n",
    "\n",
    "    rel_changes = np.stack(rel_changes)  # shape: (n_iterations, n_bins)\n",
    "\n",
    "    ci_lower = np.nanpercentile(rel_changes, 2.5, axis=0)\n",
    "    ci_upper = np.nanpercentile(rel_changes, 97.5, axis=0)\n",
    "    p_sig_fraction = np.mean(p_values < 0.05) # fraction of p values below 0.05\n",
    "\n",
    "    return ci_lower.tolist(), ci_upper.tolist(), p_sig_fraction\n",
    "\n",
    "\n",
    "def plot_precip_pdf_withbootstrap(normalize=False):\n",
    "    all_precip_current = precip_current_ds['RAINNC']\n",
    "    all_precip_future = precip_future_ds['RAINNC']\n",
    "    all_precip_future_urban = precip_future_urban_ds['RAINNC']\n",
    "\n",
    "    all_precip_current =  all_precip_current.where(all_precip_current >= 0.25)\n",
    "    all_precip_future = all_precip_future.where(all_precip_future >= 0.25)\n",
    "    all_precip_future_urban = all_precip_future_urban.where(all_precip_future_urban >= 0.25)\n",
    "\n",
    "    # Step 2: Calculate frequency for each bin for each simulation\n",
    "    if normalize == True:\n",
    "        freq_current = calculate_percentage_per_bin(all_precip_current, PRECIP_BINS)\n",
    "        freq_future = calculate_percentage_per_bin(all_precip_future, PRECIP_BINS)\n",
    "        freq_future_urban = calculate_percentage_per_bin(all_precip_future_urban, PRECIP_BINS)\n",
    "    elif normalize == False:\n",
    "        freq_current = calculate_frequency_per_bin(all_precip_current, PRECIP_BINS)\n",
    "        freq_future = calculate_frequency_per_bin(all_precip_future, PRECIP_BINS)\n",
    "        freq_future_urban = calculate_frequency_per_bin(all_precip_future_urban, PRECIP_BINS)\n",
    "\n",
    "    print('done1')\n",
    "\n",
    "    # Relative changes\n",
    "    rel_change_future = calculate_relative_change(np.array(freq_future), np.array(freq_current))\n",
    "    rel_change_c_vs_fu = calculate_relative_change(np.array(freq_future_urban), np.array(freq_current))\n",
    "    rel_change_urban = calculate_relative_change_urbanization(\n",
    "        np.array(freq_future), np.array(freq_current), np.array(freq_future_urban)\n",
    "    )\n",
    "\n",
    "    print('done2')\n",
    "\n",
    "    f_array = all_precip_future.values.flatten()\n",
    "    c_array = all_precip_current.values.flatten()\n",
    "    fu_array = all_precip_future_urban.values.flatten()\n",
    "\n",
    "    f_array = f_array[~np.isnan(f_array)]\n",
    "    c_array = c_array[~np.isnan(c_array)]\n",
    "    fu_array = fu_array[~np.isnan(fu_array)]\n",
    "    \n",
    "    print(f\"Dataset sizes - Current: {len(c_array):,}, Future: {len(f_array):,}, Future+Urban: {len(fu_array):,}\")\n",
    "    \n",
    "    # Print raw frequencies for debugging\n",
    "    print(f\"\\nRaw frequencies:\")\n",
    "    print(f\"  Current: {freq_current}\")\n",
    "    print(f\"  Future: {freq_future}\")\n",
    "    print(f\"  Future+Urban: {freq_future_urban}\")\n",
    "    \n",
    "    print(f\"\\n{'='*60}\")\n",
    "    print(f\"BOOTSTRAP MODE: {'Normalized (percentages)' if normalize else 'Raw counts (scaled)'}\")\n",
    "    print(f\"{'='*60}\")\n",
    "\n",
    "    # Run bootstrapping\n",
    "    acc_ci_lower, acc_ci_upper, acc_sig = bootstrap_relative_change_chunked(\n",
    "    c_array, f_array, fu_array, PRECIP_BINS, n_iterations=100, batch_size=10, n_jobs=4, normalize=normalize) # ACC Effect\n",
    "\n",
    "    accurb_ci_lower, accurb_ci_upper, accurb_urban_sig = bootstrap_relative_change_chunked(\n",
    "    c_array, f_array, fu_array, PRECIP_BINS, n_iterations=100, batch_size=10, n_jobs=4, c_fu=True, normalize=normalize) # ACC+Urban Effect\n",
    "\n",
    "    urb_ci_lower, urb_ci_upper, urb_sig = bootstrap_relative_change_chunked( \n",
    "    c_array, f_array, fu_array, PRECIP_BINS, n_iterations=100, batch_size=10, n_jobs=4, urban=True, normalize=normalize) # Urban Effect\n",
    "    \n",
    "    print(f\"\\nBootstrap Confidence Intervals (95%):\")\n",
    "    print(f\"  ACC:       Lower={acc_ci_lower}, Upper={acc_ci_upper}\")\n",
    "    print(f\"  ACC+Urb:   Lower={accurb_ci_lower}, Upper={accurb_ci_upper}\")\n",
    "    print(f\"  Urban:     Lower={urb_ci_lower}, Upper={urb_ci_upper}\")\n",
    "\n",
    "\n",
    "    # Plotting\n",
    "    x = np.arange(len(PRECIP_BINS))\n",
    "    bar_width = 0.2\n",
    "    fig, ax1 = plt.subplots(figsize=(5, 4))\n",
    "\n",
    "    # Bar plots\n",
    "    ax1.bar(x - bar_width, freq_current, width=bar_width, color='black', label='Current', zorder=2)\n",
    "    ax1.bar(x, freq_future, width=bar_width, color='#1E88E5', label='Warming', zorder=2)\n",
    "    ax1.bar(x + bar_width, freq_future_urban, width=bar_width, color='#D81B60', label='Warming+Urban', zorder=2)\n",
    "\n",
    "    # Primary Y-axis (left)\n",
    "    if normalize == True:\n",
    "        ax1.set_xlabel('Precipitation rate (mm hr$^{-1}$)')\n",
    "        ax1.set_ylabel('Percentage of Total Occurrences (%)')\n",
    "        ax1.set_yscale('log')\n",
    "        ax1.set_xticks(x)\n",
    "        ax1.set_xticklabels(BIN_LABELS)\n",
    "        ax1.set_ylim(0, 500)  # Since we're dealing with percentages\n",
    "    else:\n",
    "        ax1.set_xlabel('Precipitation rate (mm hr$^{-1}$)')\n",
    "        ax1.set_ylabel('Frequency (# of Occurrences)')\n",
    "        ax1.set_yscale('log')\n",
    "        ax1.set_xticks(x)\n",
    "        ax1.set_xticklabels(BIN_LABELS)\n",
    "        ax1.set_ylim(1e3, 1e9)\n",
    "\n",
    "    # Relative change lines and error bars\n",
    "    ax2 = ax1.twinx()\n",
    "    ax2.plot(x, rel_change_c_vs_fu, color=\"#FFB507\", marker='^', linestyle='-', label='Combined', linewidth=2)\n",
    "    ax2.plot(x, rel_change_future, color='black', marker='o', linestyle='--', label='Warming', linewidth=2)\n",
    "    ax2.plot(x, rel_change_urban, color='black', marker='s', linestyle=':', label='Urban', linewidth=2)\n",
    "\n",
    "    print('ACC+Urb:', rel_change_c_vs_fu)\n",
    "    print('ACC:', rel_change_future)\n",
    "    print('Urb:', rel_change_urban)\n",
    "    \n",
    "    # Verify raw values fall within confidence intervals\n",
    "    print(f\"\\n{'='*60}\")\n",
    "    print(\"VERIFICATION: Do raw values fall within confidence intervals?\")\n",
    "    print(f\"{'='*60}\")\n",
    "    for i, bin_label in enumerate(BIN_LABELS):\n",
    "        acc_in_ci = acc_ci_lower[i] <= rel_change_future[i] <= acc_ci_upper[i]\n",
    "        cfu_in_ci = accurb_ci_lower[i] <= rel_change_c_vs_fu[i] <= accurb_ci_upper[i]\n",
    "        urb_in_ci = urb_ci_lower[i] <= rel_change_urban[i] <= urb_ci_upper[i]\n",
    "        \n",
    "        print(f\"Bin {bin_label}:\")\n",
    "        print(f\"  Warming:       {rel_change_future[i]:.2f}% [{acc_ci_lower[i]:.2f}, {acc_ci_upper[i]:.2f}]\")\n",
    "        print(f\"  Combined:   {rel_change_c_vs_fu[i]:.2f}% [{accurb_ci_lower[i]:.2f}, {accurb_ci_upper[i]:.2f}]\")\n",
    "        print(f\"  Urbanization:     {rel_change_urban[i]:.2f}% [{urb_ci_lower[i]:.2f}, {urb_ci_upper[i]:.2f}]\")\n",
    "\n",
    "    # Convert to NumPy arrays for fill_between\n",
    "    x = np.array(x)\n",
    "    acc_lower = np.array(acc_ci_lower)\n",
    "    acc_upper = np.array(acc_ci_upper)\n",
    "\n",
    "    urb_lower = np.array(urb_ci_lower)\n",
    "    urb_upper = np.array(urb_ci_upper)\n",
    "\n",
    "    accurb_lower = np.array(accurb_ci_lower)\n",
    "    accurb_upper = np.array(accurb_ci_upper)\n",
    "\n",
    "    # Fill between CI bounds\n",
    "    ax2.fill_between(x, accurb_lower, accurb_upper, color=\"#FFB507\", alpha=0.3, zorder=1)\n",
    "    ax2.fill_between(x, acc_lower, acc_upper, color='blue', alpha=0.2, zorder=1)\n",
    "    ax2.fill_between(x, urb_lower, urb_upper, color='green', alpha=0.2, zorder=1)\n",
    "\n",
    "    ax2.set_ylabel('Relative change (%)')\n",
    "    \n",
    "    # Dynamically set y-axis limits based on data and confidence intervals\n",
    "    all_values = np.concatenate([\n",
    "        rel_change_c_vs_fu, rel_change_future, rel_change_urban,\n",
    "        acc_lower, acc_upper, urb_lower, urb_upper, accurb_lower, accurb_upper\n",
    "    ])\n",
    "    # Filter out NaN values\n",
    "    all_values = all_values[~np.isnan(all_values)]\n",
    "    \n",
    "    if len(all_values) > 0:\n",
    "        y_min = np.min(all_values)\n",
    "        y_max = np.max(all_values)\n",
    "        # Add 15% padding on each side\n",
    "        y_range = y_max - y_min\n",
    "        padding = max(y_range * 0.15, 5)  # At least 5% padding\n",
    "        ax2.set_ylim(y_min - padding, y_max + padding)\n",
    "    else:\n",
    "        # Fallback to default if no valid data\n",
    "        ax2.set_ylim(-20, 100)\n",
    "    \n",
    "    ax2.grid(True, axis='y', alpha=0.5)\n",
    "\n",
    "    # Legends\n",
    "    #ax1.legend(loc='upper left', fontsize=8)\n",
    "    #ax2.legend(loc='upper right', fontsize=8)\n",
    "\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    plt.title(f'{month}')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "plot_precip_pdf_withbootstrap(normalize=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.9389194250106812, 4.919344902038574, 19.31595230102539, 69.86393737792969]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1053702/235782611.py:49: UserWarning: Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n",
      "  ax1.set_ylim(0, 200)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "################# Mean precip intensity ###################\n",
    "\n",
    "def calculate_mean_per_bin(precip_data, bins):\n",
    "    bin_frequencies = []\n",
    "    for lower, upper in bins:\n",
    "        # Count occurrences within each bin across all time steps and grid points\n",
    "        bin_mask = precip_data.where((precip_data >= lower) & (precip_data < upper))\n",
    "        #print(bin_mask)\n",
    "        bin_frequency = bin_mask.mean().item()  # Total occurrences in this bin\n",
    "        bin_frequencies.append(bin_frequency)\n",
    "    return bin_frequencies\n",
    "\n",
    "def plot_precip_intensity_mean(start_time,end_time):\n",
    "    # Step 1: Use all occurrences of precipitation values for each simulation across all time steps and grid cells\n",
    "    all_precip_current = precip_current_ds['RAINNC']\n",
    "    all_precip_future = precip_future_ds['RAINNC']\n",
    "    all_precip_future_urban = precip_future_urban_ds['RAINNC']\n",
    "\n",
    "    # Step 2: Calculate frequency for each bin for each simulation\n",
    "    freq_current = calculate_mean_per_bin(all_precip_current, PRECIP_BINS)\n",
    "    freq_future = calculate_mean_per_bin(all_precip_future, PRECIP_BINS)\n",
    "    freq_future_urban = calculate_mean_per_bin(all_precip_future_urban, PRECIP_BINS)\n",
    "\n",
    "    # Step 3: Calculate relative change between simulations\n",
    "    relative_change_future = calculate_relative_change(np.array(freq_future), np.array(freq_current))\n",
    "    relative_change_urban = calculate_relative_change_urbanization(\n",
    "        np.array(freq_future), np.array(freq_current), np.array(freq_future_urban)\n",
    "    )\n",
    "    print(freq_current)\n",
    "    #print(relative_change_urban)\n",
    "    # Step 4: Plotting\n",
    "    fig, ax1 = plt.subplots(figsize=(5, 4))\n",
    "\n",
    "    # Bar width and positions\n",
    "    bar_width = 0.2\n",
    "    x = np.arange(len(PRECIP_BINS))\n",
    "\n",
    "    # Plot bars for each simulation\n",
    "    ax1.bar(x - bar_width, freq_current, width=bar_width, color='black', label='Current',zorder=2)\n",
    "    ax1.bar(x, freq_future, width=bar_width, color='#1E88E5', label='Future',zorder=2)\n",
    "    ax1.bar(x + bar_width, freq_future_urban, width=bar_width, color='#D81B60', label='Future-Urban',zorder=2)\n",
    "\n",
    "    # Primary Y-axis (left)\n",
    "    ax1.set_xlabel('Precipitation rate (mm hr$^{-1}$)')\n",
    "    ax1.set_ylabel('Mean Intensity (mm hr$^{-1}$)')\n",
    "    ax1.set_yscale('log')\n",
    "    ax1.set_xticks(x)\n",
    "    ax1.set_xticklabels(BIN_LABELS)\n",
    "    ax1.set_ylim(0, 200)\n",
    "\n",
    "    # Secondary Y-axis (right) for relative changes\n",
    "    ax2 = ax1.twinx()\n",
    "    ax2.plot(x, relative_change_future, color='black', marker='o', linestyle='--', label='ACC Impact', linewidth=2)\n",
    "    ax2.plot(x, relative_change_urban, color='black', marker='s', linestyle=':', label='Urbanization', linewidth=2)\n",
    "    ax2.set_ylabel('Relative change (%)', color='black')\n",
    "    ax2.set_ylim(-10, 10)  # Adjust based on expected range of relative changes\n",
    "    ax2.grid(True, axis='y', alpha=0.5)\n",
    "\n",
    "    # Add legend for secondary y-axis lines\n",
    "    ax2.legend(loc='upper right')\n",
    "    ax1.legend(loc='upper left')\n",
    "\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    # Title and layout adjustments\n",
    "    if select_time_window == True:\n",
    "        start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        ax1.set_title(f'Frequency of Precipitation Intensity from {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}\\n(Subregion)', fontsize=16)\n",
    "    else:\n",
    "        ax1.set_title(f'Mean Precipitation Intensity in {month}\\n(Full Domain)')\n",
    "    fig.tight_layout()\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "plot_precip_intensity_mean(start_time,end_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKIAAAE3CAYAAACZ9+ndAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd8FNX6/z/bs5vee+8JhCSQUATpTXpTsCG2e62oV0TuvQpiw3b1qvci+lWwxIogqHRFpBNKAiSU9N77ZrPZdn5/5Ldzs9ndZLZlN3Der1desDOnPHNm5jMzzznnORxCCAGFQqFQKBQKhUKhUCgUCoViY7j2NoBCoVAoFAqFQqFQKBQKhXJzQB1RFAqFQqFQKBQKhUKhUCiUQYE6oigUCoVCoVAoFAqFQqFQKIMCdURRKBQKhUKhUCgUCoVCoVAGBeqIolAoFAqFQqFQKBQKhUKhDArUEUWhUCgUCoVCoVAoFAqFQhkUqCOKQqFQKBQKhUKhUCgUCoUyKFBHFIVCoVAoFAqFQqFQKBQKZVCgjigKhUKhUCgUCoVCoVAoFMqgQB1RFAqFQqFQKBQKhUKhUCiUQYE6oigUCoVCobBi8+bNSE9Ph0AgwIYNG+xtDoVCoVAoFAplCEIdURQKhUKhUFgRGBiIDRs2YMmSJfY2hUKhUCgUCoUyRKGOKAqFQrnJyM7Oxrhx4+Ds7AwOh4OcnBx7m0Qxkw0bNoDD4aCxsXFQ6lu4cCHmz58PDw+PQanPVLTtYW22bdsGDoeD0tJSne3G7iV6j1EcCWPX71Cu397H1B+ObJsp9D2OG+W4KBSKY0AdURQKxSZoX1gM/T3//PP2Nu+mRalUYtmyZWhubsa7776LL7/8EuHh4UbT9z2PTk5OiIuLw+OPP466ujqj6fh8PoKDg3HfffehqqrKZsfzxx9/GL3OTp06pZe+u7sba9euRVBQEMRiMUaPHo2DBw/azD6KY2Loug4KCsLMmTPx/vvvo6OjY8AyjN1Lpt5jFMPPCz8/P0yePBl79+41q8wTJ05gw4YNaG1tta6xDsalS5ewdOlShIeHw8nJCcHBwZg+fTo++OADe5tmFW6W82gK//3vf8HhcDB69Gh7m0KhUChmw7e3ARQK5cZm48aNiIyM1Nk2bNgwO1lDKSoqQllZGT755BM8+OCDrPNpz6NcLsexY8ewefNm7NmzB5cvX4ZEIjGY7tSpU9i2bRuOHTuGy5cvw8nJyRaHBAB48sknkZGRobMtJiZGL919992H7du346mnnkJsbCy2bduG2267DYcPH8b48eNtZh/FMdFer0qlErW1tfjjjz/w1FNP4V//+hd2796NlJQUAMA999yD5cuXQyQSMXmN3UtXr1416x6j/O98EEJQV1fH3J8///wz5s6da1JZJ06cwEsvvYT77rvPYUfwWcqJEycwefJkhIWF4aGHHkJAQAAqKipw6tQp/Pvf/8YTTzwBwPD1O1Qwdh4d+ZhsbVtWVhYiIiJw5swZFBYWGnzWWQNHbmMKhTL0oY4oCoViU2bPno1Ro0axTt/Z2QlnZ2cbWnRzU19fDwAmf5j1Po8PPvggvL298a9//Qu7du3CihUrjKbz8fHBG2+8gd27d+P222+3zkEYYMKECVi6dGm/ac6cOYNvv/0Wb731Fp599lkAwL333othw4bhueeew4kTJ2xmn6Oivd/Gjx+P48ePG0zzj3/8A6+88sogWzY49NWndevW4ffff8fcuXMxf/58XLlyBWKxGDweDzweTyevsXvJ3HusP24WXex7Ph544AH4+/vjm2++MdkRdTPw6quvwt3dHdnZ2UavQwAGr9+hjiMfky1tKykpwYkTJ7Bjxw785S9/QVZWFtavX2/VOrR648htTKFQhj50ah6FQrEb2ngu+fn5uPPOO+Hp6akzKqWqqgr3338//P39IRKJkJycjM8++0yvnGPHjiEjIwNOTk6Ijo7Gli1bDMaKue+++xAREWHUjt6wqVubr7CwkOmtdXd3x6pVqyCTyfTqqaqqwgMPPICgoCCIRCJERkbikUcegUKhwOHDh8HhcLBz5069fF9//TU4HA5OnjzZb3teuHABs2fPhpubG1xcXDB16lSd6Wn33XcfJk6cCABYtmwZOBwOJk2a1G+ZxpgyZQqAnpfi/pgwYQKAntEj/XHmzBksW7YM27Zt05nyZwodHR1QqVRG92/fvh08Hg8PP/wws83JyQkPPPAATp48iYqKin7L157v69ev4+6774a7uzt8fX3xwgsvgBCCiooKLFiwAG5ubggICMA777xj1fz90draOuA12N/9duzYMRBCDP5Z6oQqKyvDo48+ivj4eIjFYnh7e2PZsmV6cUZMvZ8M3ffWYMqUKXjhhRdQVlaGr776CoB+bBRj99JA95gpumKJLprSlv3pUt90A9Xb0dGBp556ChERERCJRPDz88P06dNx/vx5E89CDx4eHhCLxeDzdftNB7Jlw4YNWLNmDQAgMjKSme5XWlqKixcvgsPhYPfu3Uz6c+fOgcPhID09Xaee2bNn601/YvtcssUzpC9FRUVITk426PT08/Nj/m8oto+lemTK87QvpmiCsfNoLF7RQM/B3jYO1O7mXs/9tbe551pLVlYWPD09MWfOHCxduhRZWVl6abR1Xb16Fbfffjvc3Nzg7e2N1atXQy6XG0xrSG9oTCgKhWJL6IgoCoViU9ra2vQCKfv4+Oj8XrZsGWJjY/Haa6+BEAIAqKurw5gxY8DhcPD444/D19cXe/fuxQMPPID29nY89dRTAHriY8yYMQO+vr7YsGEDVCoV1q9fD39/f7NtZlu3lttvvx2RkZF4/fXXcf78efzf//0f/Pz88MYbbzBpqqurkZmZidbWVjz88MNISEhAVVUVtm/fDplMhkmTJiE0NBRZWVlYtGiRTvlZWVmIjo7G2LFjjdqcl5eHCRMmwM3NDc899xwEAgG2bNmCSZMm4ciRIxg9ejT+8pe/IDg4GK+99hozlc3cdtI6lry9vftNp32B9fT07Dedh4cHysvLcf/99wMARo0ahTlz5mDOnDkYOXLkgB82q1atglQqBY/Hw4QJE/DWW2/pjcS7cOEC4uLi4ObmprM9MzMTAJCTk4PQ0NB+6wGAO+64A4mJidi0aRN+/fVXvPLKK/Dy8sKWLVswZcoUvPHGG8jKysKzzz6LjIwM3HrrrVbNbwg216AWQ/cbW1QqFVQqFdRqNVQqFeRyOQQCQb+95tnZ2Thx4gSWL1+OkJAQlJaWYvPmzZg0aRLy8/N1pnayPRZb3Pe9ueeee/D3v/8dBw4cwEMPPaS339i95OLiYvQeM1VXLNFFtm05kC4JhUKT6v3rX/+K7du34/HHH0dSUhKamppw7NgxXLlyRc/JYwjt84IQgvr6enzwwQeQSqW4++67mTRsbFm8eDGuX7+Ob775Bu+++y7zzPH19UVYWBg8PDzw559/Yv78+QCAo0ePgsvlIjc3F+3t7XBzc4NGo8GJEyd0HNds28EWzxBDhIeH4+TJk7h8+bLZU95toUcDwVYT+juPhmDzHOzNQO1u6fVsCHPPtZasrCwsXrwYQqEQK1aswObNm5Gdna03NV1bV0REBF5//XWcOnUK77//PlpaWvDFF1/opbXkuUChUChmQSgUCsUGbN26lQAw+Kdl/fr1BABZsWKFXv4HHniABAYGksbGRp3ty5cvJ+7u7kQmkxFCCFm4cCFxcnIiZWVlTJr8/HzC4/FIX4lbuXIlCQ8P16tLa4epdWvz3X///TrpFi1aRLy9vXW23XvvvYTL5ZLs7Gy9+jUaDSGEkHXr1hGRSERaW1uZffX19YTP55P169fr5evNwoULiVAoJEVFRcy26upq4urqSm699VZm2+HDhwkA8sMPP/RbnhbteTx06BBpaGggFRUV5NtvvyXe3t5ELBaTyspKo+m2b99OfH19iUgkIhUVFazqq6urI1u3biVLly4lbm5uBADx9/cnq1atItu3bydtbW066Y8fP06WLFlCPv30U7Jr1y7y+uuvE29vb+Lk5ETOnz+vkzY5OZlMmTJFr868vDwCgHz00Uf92qY93w8//DCzTaVSkZCQEMLhcMimTZuY7S0tLUQsFpOVK1daLX9/NrG5Bvu739iiLaP339atW/vNo71fenPy5EkCgHzxxRdmHYsp970htNeroftRi7u7O0lLS9NJX1JSwuw3di8Z226qrliii2zbko0umVKvu7s7eeyxx/TKGghjzwuRSES2bdtmVhu89dZbeudMy5w5c0hmZibze/HixWTx4sWEx+ORvXv3EkIIOX/+PAFAdu3aZXLdtniGGOLAgQOEx+MRHo9Hxo4dS5577jmyf/9+olAodNIZun4t1SO2z1ND9bPVBEKMn0dDx8T2Oci23S29ng21t7nnmhBCzp49SwCQgwcPEkJ67tGQkBCyevVqnXTauubPn6+z/dFHHyUASG5url5aQ3rT9zgMHReFQqGYC52aR6FQbMp//vMfHDx4UOevL3/96191fhNC8OOPP2LevHkghKCxsZH5mzlzJtra2nD+/Hmo1Wrs378fCxcuRFhYGJM/MTERM2fONMtetnX3Z/+ECRPQ1NSE9vZ2AIBGo8FPP/2EefPmGYyXpR3tc++996K7uxvbt29n9n333XdQqVQ6IwL6olarceDAASxcuBBRUVHM9sDAQNx55504duwYY4u5TJs2Db6+vggNDcXy5cvh4uKCnTt3Ijg42Gi6pUuXwtnZGbt370ZISAirevz8/HDffffhhx9+QGNjI3777Tfcdddd+PXXX7F06VL4+PiguLiYST9u3Dhs374d999/P+bPn4/nn38ep06dAofDwbp163TK7urqMhh0VRtEvauri5WNvQNQ83g8jBo1CoQQPPDAA8x2Dw8PxMfH69hqrfyGGOga7C+tKWzYsEFv6t59993Xbx6xWMz8X6lUoqmpCTExMfDw8DA4xWWgY7HFfW8IFxcXVqvnscEaumJtbWKrS6bU6+HhgdOnT6O6utqsdur9vPjqq68wefJkPPjgg9ixY4fZbWCICRMm4Pz58+js7ATQM83ztttuQ2pqKo4ePQqgZ5QUh8NhpimxrdsWzxBjTJ8+HSdPnsT8+fORm5uLN998EzNnzkRwcLDO1MP+sIUeDYSpmsAGc56DA7W7pdezIcw910DPaCh/f39MnjwZQM89escdd+Dbb7+FWq3WS//YY4/p/NYGr9+zZ8+AdlEoFIqtoVPzKBSKTcnMzBwwWHnfVfUaGhrQ2tqKjz/+GB9//LHBPPX19WhoaEBXVxdiY2P19sfHxxt82RoItnX3pvfHMPC/aWgtLS1wc3NDQ0MD2tvbB5w6kZCQgIyMDGRlZTEfAVlZWRgzZky/q+I0NDRAJpMhPj5eb19iYiI0Gg0qKiqQnJzcb/398Z///AdxcXHg8/nw9/dHfHw8uFz9vgxtura2Nnz22Wf4888/zVpxR6VS4cSJE9i3bx/27duH+vp68Hg8jBkzZsCgzTExMViwYAF27NgBtVrNTBsTi8Xo7u7WS6+NmdH746g/+p5vd3d3ODk56U05dXd3R1NTk9Xzs7Gp7zXYm773m63p6urC66+/jq1bt6Kqqkpn2kdbW5teejb3k7Xve0NIpVKdODuWYI6umKuLvemvLbu6uljpkin1vvnmm1i5ciVCQ0MxcuRI3Hbbbbj33nt1HAP90fd5sWLFCqSlpeHxxx/H3Llz0draanIbGGLChAlQqVQ4efIkQkNDUV9fjwkTJiAvL0/HEZWUlAQvLy+T2sEWz5D+yMjIwI4dO6BQKJCbm4udO3fi3XffxdKlS5GTk4OkpKR+89tCjwbCVE1ggznPwYHa3dLr2RDmnmu1Wo1vv/0WkydP1onNOHr0aLzzzjv47bffMGPGDJ08fTUyOjoaXC7XYMynwX4uUCgUCnVEUSgUu9PXAaDRaAAAd999N1auXGkwT0pKCpOOLcbiDPXuSWRbd2+Mxcfp/XLNlnvvvRerV69GZWUluru7cerUKXz44Ycml2Nt2DgU+6ZbuHAhxo8fjzvvvBPXrl2Di4tLv3kbGhqwd+9e/Prrr9i/fz/a2trg4+ODWbNm4YUXXsDMmTMHjDWlJTQ0FAqFAp2dnczLfWBgIKqqqvTS1tTUAACCgoJYlW3ofJtyDVian61NxvKzdbhZiyeeeAJbt27FU089hbFjx8Ld3R0cDgfLly83eA9b834yl8rKSrS1tVltWXRzdMVcXeyNNdrSlHpvv/12TJgwATt37sSBAwfw1ltv4Y033sCOHTswe/Zs1nVq4XK5mDx5Mv7973+joKCAiUlnShsYYtSoUXBycsKff/6JsLAw+Pn5IS4uDhMmTMB///tfdHd34+jRozrx+kx9Lg32eRIKhcjIyEBGRgbi4uKwatUq/PDDDwOuqGauHrF5nhrDVE2wFQMdp7WvZzZ1GuP3339HTU0Nvv32W3z77bd6+7OysvQcUX3pL9biYD8XKBQKhTqiKBSKw+Hr6wtXV1eo1WpMmzbNaDq1Wg2xWIyCggK9fdeuXdPb5unpidbWVr3tZWVlJtdtCr6+vnBzc8Ply5cHTLt8+XI888wz+Oabb9DV1QWBQIA77rhjwPIlEonBY7569Sq4XC6rINzWhsfj4fXXX8fkyZPx4Ycf4vnnnzea9uTJkxg/fjw0Gg1SUlLw2GOPYc6cORgzZozBkVcDUVxcDCcnJx3nV2pqKg4fPswEI9Zy+vRpZj/F+mzfvh0rV67UWXVLLpcbvBfZ4Ovra9J9bw5ffvklAFhtqp81dMXa2sRWl0ytNzAwEI8++igeffRR1NfXIz09Ha+++qrZH+7alTClUikSEhJY29LfR7dQKERmZiaOHj2KsLAwZnXPCRMmoLu7G1lZWairq9MJzG3Kc8nazxBT0XYGaJ3stoDN89QYpmjCQAtVaLHVc9Da17O5ZGVlwc/PD//5z3/09u3YsQM7d+7ERx99pONQKigo0BnpVFhYCI1GY3C1QwqFQhlsaIwoCoXicPB4PCxZsgQ//vijwY+khoYGJt3MmTPx008/oby8nNl/5coV7N+/Xy9fdHQ02tracPHiRWZbTU0Ndu7caXLdpsDlcrFw4UL8/PPPOHv2rN7+3j2hPj4+mD17Nr766itkZWVh1qxZelMk+sLj8TBjxgzs2rVLZ8h9XV0dvv76a4wfP37A6R22YtKkScjMzMR7772nt2x0b3x8fPCf//wHFRUVyM3Nxauvvopx48YN6IQydD5yc3Oxe/duzJgxQyf/0qVLoVardabLdHd3Y+vWrRg9erRdnHU3AzweT6+3/4MPPmA1csJYeabc96by+++/4+WXX0ZkZCTuuusui8sDrKMr1tYmtrrEtl61Wq03rcrPzw9BQUEGp8SyQalU4sCBAxAKhUhMTDSpDbRTeI05PCdMmIDTp0/j8OHDjCPKx8cHiYmJzApm2u2Aac8laz9DjHH48GGDI2m001MNTVOzFmyep8YwRRMGOo+9y7Tmc9AW17O5dHV1YceOHZg7dy6WLl2q9/f444+jo6NDLy5YX6fVBx98AACD7kSjUCgUQ9ARURQKxSHZtGkTDh8+jNGjR+Ohhx5CUlISmpubcf78eRw6dAjNzc0AgJdeegn79u3DhAkT8Oijj0KlUuGDDz5AcnKyzgsy0DPaaO3atVi0aBGefPJJyGQybN68GXFxcToBUtnWbQqvvfYaDhw4gIkTJ+Lhhx9GYmIiampq8MMPP+DYsWPw8PBg0t57771YunQpAODll19mVf4rr7yCgwcPYvz48Xj00UfB5/OxZcsWdHd348033zTZXmuyZs0aLFu2DNu2bTMaEFX7sfHLL78MWN7y5cuZ9rrjjjsgFosxbtw4+Pn5IT8/Hx9//DEkEgk2bdqkk2/06NFYtmwZ1q1bh/r6esTExODzzz9HaWkpPv30U8sOkmKUuXPn4ssvv4S7uzuSkpJw8uRJHDp0iJlmZQ6m3Pf9sXfvXly9ehUqlQp1dXX4/fffcfDgQYSHh2P37t1MIHtrYA1dsbY2sdUlNvV2dHQgJCQES5cuxYgRI+Di4oJDhw4hOztbZ+RLf2jPB9ATR+nrr79GQUEBnn/+ecaJwLYNRo4cCQD4xz/+geXLl0MgEGDevHmM1kyYMAGvvvoqKioqdBxOt956K7Zs2YKIiAi9RRbY1m2LZ4ghnnjiCchkMixatAgJCQlQKBQ4ceIEvvvuO0RERGDVqlVWqccQbJ+nhjBFE4ydR0NY8zlojevZWuzevRsdHR2YP3++wf1jxoyBr68vsrKydEZQl5SUYP78+Zg1axZOnjyJr776CnfeeSdGjBgxWKZTKBSKUagjikKhOCT+/v44c+YMNm7ciB07duC///0vvL29kZyczPRWAz2xNvbv349nnnkGL774IkJCQvDSSy+hpqZG74PU29sbO3fuxDPPPIPnnnsOkZGReP3111FQUKDz4sy2blMIDg7G6dOn8cILLyArKwvt7e0IDg7G7NmzIZFIdNLOmzcPnp6e0Gg0Rl88+5KcnIyjR49i3bp1eP3116HRaDB69Gh89dVXGD16tFk2W4vFixcjOjoab7/9Nh566CGDMTKuX7+ORx55hFV5kyZNYj6QFy5ciKysLPzrX/9Ce3s7fH19sXjxYqxfv95gfJ8vvvgCL7zwAr788ku0tLQgJSUFv/zyi84UHIp1+fe//w0ej4esrCzI5XLccsstOHTokEXT3ky57/vjxRdfBNAzVcvLywvDhw/He++9h1WrVsHV1dVs+wxhDV2xtjax1SU29UokEjz66KM4cOAAduzYAY1Gg5iYGPz3v/9lfW9rzwfQs5plQkICNm/ejL/85S8mt0FGRgZefvllfPTRR9i3bx80Gg1KSkoYR9S4cePA4/EgkUh0PswnTJiALVu26DinTK3bFs8QQ7z99tv44YcfsGfPHnz88cdQKBQICwvDo48+in/+8586HRzWhu3z1BCmaIKx82gIaz4HrXE9W4usrCw4OTlh+vTpBvdzuVzMmTMHWVlZOgHlv/vuO7z44ot4/vnnwefz8fjjj+Ott94aLLMpFAqlXzhkMKN/UigUyiCxYcMGvPTSS4Ma4NhaqFQqBAUFYd68eXSkDoVCoVAoFNZo338aGhoGnNpPoVAo9oLGiKJQKBQH46effkJDQwPuvfdee5tCoVAoFAqFQqFQKFaFTs2jUCgUB+H06dO4ePEiXn75ZaSlpWHixIn2NolCoVAoFAqFQqFQrAodEUWhUCgOwubNm/HII4/Az88PX3zxhb3NoVAoFAqFQqFQKBSrQ2NEUSgUCoVCoVAoFAqFQqFQBgU6IopCoVAoFAqFQqFQKBQKhTIoUEcUhUKhUCgUCoVCoVAoFAplUKCOKAqFQqFQKBQKhUKhUCgUyqBAHVEUCoVCoVAoFAqFQqFQKJRBgTqiKBQKhUKhUCgUCoVCoVAogwJ1RFEoFAqFQqFQKBQKhUKhUAYF6oiiUCgUCoVCoVAoFAqFQqEMCtQRRaFQKBQKhUKhUCgUCoVCGRSoI4pCoVAoFAqFQqFQKBQKhTIoUEcUhUKhUCgUCoVCoVAoFAplUKCOKAqFQqFQKBQKhUKhUCgUyqBAHVEUCoVCoVAoFAqFQqFQKJRBgTqiKBQKhUKhUCgUCoVCoVAogwJ1RFEoFAqFQqFQKBQKhUKhUAYF6oiiUCgUCoVCoVAoFAqFQqEMCtQRRaFQAACLFi2Cp6cnli5dam9TKBQKhUKhUCgUCoVyg0IdURQKBQCwevVqfPHFF/Y2g0KhUCgUCoVCoVAoNzDUEUVhDSEEDz/8MLy8vMDhcJCTk2Nvk246Jk2ahKeeespmZbu6utqkbAqFQqFQKBQKhUKhUIAb2BF13333gcPh6P0VFhba27Qhy759+7Bt2zb88ssvqKmpwbBhwwym6932QqEQMTEx2LhxI1Qqld5+gUCAyMhIPPfcc5DL5Va1d8OGDXrnPyEhQS/df/7zH0RERMDJyQmjR4/GmTNnrGoHhUKhUCgUCoVCoVAolB5uWEcUAMyaNQs1NTU6f5GRkXrpFAqFHawbehQVFSEwMBDjxo1DQEAA+Hy+0bTati8oKMDf/vY3bNiwAW+99Zbe/uLiYrz77rvYsmUL1q9f32/9MpnMZJuTk5N1zv+xY8d09n/33Xd45plnsH79epw/fx4jRozAzJkzUV9fb3Jdjor2+k5NTcWwYcP0/qqrq+1s4eDR1NQEPz8/lJaW2tsUq6NQKBAREYGzZ8/a2xS7cvLkSXA4HMyZM2fAtLTDgkJxHIayPv/000+IiYkBj8djRi0b2mYLli9fjnfeecdm5Ts6VPMpNwrW1sBt27bBw8PDKmX1R2lp6aDMlLHlrBBT+fjjjxEaGgoul4v33nvP6DZbMGbMGPz44482K39QITcoK1euJAsWLDC4b+LEieSxxx4jq1evJt7e3mTSpEmEEELUajV57bXXSEREBHFyciIpKSnkhx9+0MkrlUrJPffcQ5ydnUlAQAB5++23ycSJE8nq1auZNOHh4eTdd9/VyTdixAiyfv161vVMnDiRPPHEE2TNmjXE09OT+Pv7M/m1qNVq8sYbb5Do6GgiFApJaGgoeeWVV8jnn39OvLy8iFwu10m/YMECcvfddxttM7lcTp544gni6+tLRCIRueWWW8iZM2eY9gTA/IWHhxstx1DbT58+nYwZM8bo/sWLF5O0tDSjZRJCyNq1a0lMTAx58sknyb59+/SOry/r168nI0aM6DdNZmYmeeyxx5jfarWaBAUFkddff91onokTJ5LHH3+crF69mnh4eBA/Pz/y8ccfE6lUSu677z7i4uJCoqOjyZ49eyzKY6zuga4LY9c3Gw4fPkyWLFnCOv1Q4+mnnyYPPvigzrbt27eTiRMnEjc3N+Ls7EyGDx9OXnrpJdLU1GQnKwfG2LX9wQcfkClTpgy+QQ7EAw88QFasWEFEIhGpqqrqN+3KlSvJrFmzSE1Njc6fSqUymL67u9sWJlMoFGJYn7XMmDGDcLlc5p2kL+fPnydLly4lfn5+RCQSkZiYGPLggw+Sa9eu6aQzR+97v/v0/vvmm2+YNH5+fmTt2rWkqqqKtLe3G91mCYcPHyYASEtLi872S5cuEU9PT9La2mpxHUMRqvmUG4W+GmjsnifE8LdmX7Zu3Urc3d2ta6QBVCoVqampIUql0irlGTvupqYmq2hpf5SUlBjV/JMnTxJCCGlrayMCgYB88MEHpLq6mnR2dhrcZinGzt/PP/9MYmJiiFqttrgOe3NDj4jqj88//xxCoRDHjx/HRx99BAB4/fXX8cUXX+Cjjz5CXl4enn76adx99904cuQIk2/NmjU4cuQIdu3ahQMHDuCPP/7A+fPnTaqbTT1aG52dnXH69Gm8+eab2LhxIw4ePMjsX7duHTZt2oQXXngB+fn5+Prrr+Hv749ly5ZBrVZj9+7dTNr6+nr8+uuvuP/++43a9dxzz+HHH3/E559/jvPnzyMmJgYzZ85Ec3Mz/v3vf2Pjxo0ICQlBTU0NsrOzTTpmsVhsdOTZ5cuXceLECQiFwn7LWLt2LTZu3Iimpibcdddd8PLywvz58/HRRx+hvLzcYJ6CggIEBQUhKioKd911l046hUKBc+fOYdq0acw2LpeLadOm4eTJk/3a8vnnn8PHxwdnzpzBE088gUceeQTLli3DuHHjcP78ecyYMQP33HOPziguc/IYq7u/60Kbpu/1fbMjk8nw6aef4oEHHmC2/eMf/8Add9yBjIwM7N27F5cvX8Y777yD3NxcfPnll2bXZehaJ4Qw01NtxV133YVjx44hLy/PpvU4KlKpFN999x2eeuopTJ48Gdu2bRswj0gkQkBAgM4fj8cD0NP79vjjj+Opp56Cj48PZs6cCQDQaDR4/fXXERkZCbFYjBEjRmD79u065XZ2duLee++Fi4sLAgMD8c477+j05kVEROj1mKWmpmLDhg3Mbzb1TJo0CU8++SSee+45eHl5ISAgQKcMbTlvvvkmYmJiIBKJEBYWhldffRVffPEFvL290d3drZN+4cKFuOeeewZsOwrFWhjSZy3l5eU4ceIEHn/8cXz22Wd6+3/55ReMGTMG3d3dyMrKwpUrV/DVV1/B3d0dL7zwApPOEr3funWr3gj7hQsXAujRnfr6esycORNBQUFwdXU1uM1WDBs2DNHR0fjqq69sVoejQjWfav6NQn8aaA5KpdIq5bCBx+MNOFPGGnh5eQ1aLNtDhw7paf7IkSMB9DyTlEol5syZg8DAQEgkEoPbbMXs2bPR0dGBvXv32qyOQcPenjBbsXLlSsLj8YizszPzt3TpUkJIz4iRvqNv5HI5kUgk5MSJEzrbtT0thBDS0dFBhEIh+f7775n9TU1NRCwWsx4RxaYerY3jx4/XSZORkUHWrl1LCCGkvb2diEQi8sknnxg8/kceeYTMnj2b+f3OO++QqKgootFoDKaXSqVEIBCQrKwsZptCoSBBQUHkzTffJIQQ8u677/Y7EkpL7xFPGo2GHDx4kIhEIvLss88y+7XnRiQSEQCEy+WS7du3D1i2FrVaTY4fP07+/ve/k5SUFAKAJCcn6/SG7dmzh3z//fckNzeX7Nu3j4wdO5aEhYUx3vSqqioCQO9crFmzhmRmZhqtu++5UalUxNnZmdxzzz3MtpqaGh3vuTl52NRNiO51oU0z0OgyQ0ydOpX4+PgQsVhMgoOD9dplqPPDDz8QX19f5vfp06cJAPLee+8ZTK/tiTE0gm/16tVk4sSJzG9Do9C0PTp79uwh6enpRCAQkMOHDw84IlKb79ChQ2TkyJFELBaTsWPHkqtXrxJCenpI0KeXZuvWrUz+yZMnk3/+85+WNdYQ5dNPPyUxMTGEEEK+/PJLEh0dbVTzCOl/5CwhPefVxcWFrFmzhly9epU5B6+88gpJSEgg+/btI0VFRWTr1q1EJBKRP/74g8n7yCOPkLCwMHLo0CFy8eJFMnfuXOLq6so8KwYaOcu2Hu3ojg0bNpDr16+Tzz//nHA4HHLgwAEmzXPPPUc8PT3Jtm3bSGFhITl69Cj55JNPiEwmI+7u7jrPtLq6OsLn88nvv/9utF0oFGvTV597s2HDBrJ8+XJy5coV4u7uTmQyGbOvs7OT+Pj4kIULFxrMq9VxtnpvCABk586dBvdp9br3n7FthBBy9OhRMn78eOLk5ERCQkLIE088QaRSKVOeXC4nzz33HAkJCSFCoZBER0eT//u//zPYS79y5Uom30svvaT3bnAzQDWfav6NgiENZDsiSqsP3377Lbn11luJSCQiW7duZUbU7Ny5k8TExBCRSERmzJhBysvLmXIKCwvJ/PnziZ+fH3F2diajRo0iBw8e1Kvr1VdfJatWrSIuLi4kNDSUbNmyhdmvrf/ChQuEEP1ZNH118IsvviAjR44kLi4uxN/fn6xYsYLU1dXplGVI6/rOQGpubib33HMP8fDwIGKxmMyaNYtcv36d2a89/n379pGEhATi7OxMZs6cSaqrq42eh77H0hdj7+B9t5WUlBBCCPnpp59IWloaEYlEJDIykmzYsEFn5FhLSwt5+OGHmdG8ycnJ5Oeffzb4HOmtFatWrep3ltNQ4YZ2RE2bNo0UFBQwf9oLb+LEiXrDvy9fvkwA6DiunJ2diUAgYJwSOTk5BAApKyvTyZuamsraEcWmHq2Njz76qE4Z8+fPJ6tWrSKE/O+lqri42ODxnz9/nvB4PFJZWUkIIWT48OFk48aNRtsrNzeXACClpaU62xcuXMjUaYojSutoEgqFhM/nk3vvvZd52ep9bnJycsjKlSvJAw88MGC5vWltbSU//PADWbVqFQkMDCRisZjcdtttpL6+3mielpYW4ubmRv7v//6PEGKZI6rvuQkLC2McdoT0OOAAkF27dpmdh23dva8LbRpj0xtuZp588kkya9Ysnd8uLi5EoVD0m4+tI6rvy6v2IZKSkkIOHDhACgsLSVNT04Avmtp8o0ePJn/88QfJy8sjEyZMIOPGjSOEECKTycjf/vY3kpyczEwr6P1htnbtWh3bbibGjRvHPKg7OjqIRCJhXnwM0V+HBSG27bQY6KPEUTstKBRb0FeftWg0GhIeHk5++eUXQgghI0eOJF988QWzf8eOHQaf44bKZ6P3hujPEdXd3U2uXbtGAJAff/yR1NTUGN1WWFhInJ2dybvvvkuuX79Ojh8/TtLS0sh9993HlHf77beT0NBQsmPHDlJUVEQOHTpEvv32W6JSqciPP/5IAJBr166Rmpoanal4e/fuJUKhcMCQBTcaVPN7oJo/9DGkgaY6oiIiIsiPP/5IiouLSXV1Ndm6dSsRCARk1KhR5MSJE+Ts2bMkMzOTeZ8kpOfb9qOPPiKXLl0i169fJ//85z+Jk5OTzrdueHg48fLyIv/5z39IQUEBef311wmXy2UctX2dN62trTpTX1evXk38/PxITU0NIaTHgbxnzx5SVFRETp48ScaOHctck/1pXV9H1Pz580liYiL5888/SU5ODpk5cyaJiYlhdF57/NOmTSPZ2dnk3LlzJDExkdx5551Gz8NAjiiZTEYOHTpEAJAzZ86QmpoaIpVK9bapVCry559/Ejc3N7Jt2zZSVFREDhw4QCIiIsiGDRsIIT2DKsaMGUOSk5PJgQMHSFFREfn555/Jnj17SHd3N3nvvfeIm5sb044dHR2MHZs3b2b1Te7o2HYMnZ1xdnZGTEyM0X29kUqlAIBff/0VwcHBOvtEIpFJ9XK5XBBCdLZph0iaUo9AIND5zeFwoNFoAPRMdeuPtLQ0jBgxAl988QVmzJiBvLw8/PrrryYdhyVMnjwZmzdvhlAoRFBQkN5wzd7n5rPPPsOIESMGHJJaUlKC77//Hnv27MGJEycQHh6O2bNn49NPP8XkyZPh5OTUr00eHh6Ii4tjglL6+PiAx+Ohrq5OJ11dXR0CAgL6LcvQuem9jcPhAABzvszNw7buvnn6Xt8UoKysDEFBQczvgoICREVF6bWnucTGxuLNN99kftfU1AAANm7ciOnTpwMAuru78dprr+HQoUMYO3YsACAqKgrHjh3Dli1bMHHiRCb/q6++yvx+/vnnMWfOHMjlcojFYri4uIDP5xu8ToOCglBWVmaVYxpKXLt2DSdOnGCmZri4uGDBggX49NNPMWnSJKP5tFqlpe+9ox2KraWwsBAymYw5p1oUCgXS0tIA9CzsoFAoMHr0aGa/l5cX4uPjWR8Pm3q0pKSk6PwODAxkFly4cuUKuru7MXXqVIP1PPTQQ8jIyEBVVRWCg4Oxbds2JqAvhTJY9NVnLYcOHYJMJmOmSN1999349NNPmWlEBQUFAGBwRdzeWKr3K1asYKZvacnPz0dYWBj8/PwAgJkmBcDgttdffx133XUXM1UrNjYW77//PiZOnIjNmzejvLwc33//PQ4ePMiEDIiKimLq8/LyYsruG4A4KCgICoUCtbW1CA8PN+sYhxpU8/8H1fyhjzENNIWnnnoKixcv1tmmVCrx4YcfMtfm559/jsTERJw5cwaZmZkYMWIERowYwaR/+eWXsXPnTuzevRuPP/44s/22227Do48+CqAnVMq7776Lw4cPG7zG3d3d4e7uDgDYsWMHtmzZgkOHDjFa2DtMTFRUFN5//31kZGRAKpXCxcWlX63TUlBQgN27d+P48eMYN24cACArKwuhoaH46aefsGzZMub4P/roI0RHRwMAHn/8cWzcuHHAthw3bhy4XN0IRlKpFGKxGN7e3gAAX19f5pgMbXvppZfw/PPPY+XKlcyxvvzyy3juueewfv16HDp0CGfOnMGVK1cQFxfHpOndjhwOx+i7fkVFBTQajZ6dQ4kb2hFlCklJSRCJRCgvL9f5GOxNdHQ0BAIBTp8+jbCwMABAS0sLrl+/rpPH19eX+QgFgPb2dpSUlLCuhw2xsbEQi8X47bff8OCDDxpM8+CDD+K9995DVVUVpk2bhtDQUKPlRUdHMzGFtC8xSqUS2dnZZq1Q0J8TsC9cLhd///vf8cwzz+DOO+806mTbtm0bjh8/jgULFmDLli0Dvnj2RSqVoqioiHmBFQqFGDlyJH777Tcm1oNGo8Fvv/2mI76UG4Ouri4dZ2VfZ7Gl9H151TJq1Cjm/+a+aAYGBgLoifWm1R5jiMVis1aYHOp8+umnyMjIQGxsLLPtrrvuwrJly/Dhhx8yL0V9GUirbNVp0V+Hhan1DOVOCwoF0NdnLZ999hnuuOMOpjNrxYoVWLNmDYqKihAdHc1axy3V+3fffVcnniQAkz8ac3NzcfHiRWRlZenYpdFoUFJSgkuXLoHH45n1bqi9z28m7aea/z+o5g99jGmgKfR+39TC5/ORkZHB/E5ISICHhweuXLmCzMxMSKVSbNiwAb/++itqamqgUqnQ1dWlF3u39zup1jky0ArjFy5cwD333IMPP/wQt9xyC7P93Llz2LBhA3Jzc9HS0sJcu+Xl5UhKSmJ1rFeuXAGfz9dx/np7eyM+Ph5XrlxhtkkkEsYJBeg6bfvju+++Q2JiIitbjJGbm4vjx4/j1VdfZbap1WrI5XLIZDLk5OQgJCSEcUKZglgshkajQXd394D3vCNDHVH/H1dXVzz77LN4+umnodFoMH78eLS1teH48eNwc3PDypUr4eLiggceeABr1qyBt7c3/Pz88I9//EPPEzllyhRs27YN8+bNg4eHB1588UWmJ41NPWxwcnLC2rVr8dxzz0EoFOKWW25BQ0MD8vLymFFFd955J5599ll88skn+OKLL/otz9nZGY888gjWrFkDLy8vhIWF4c0334RMJrNa4Lz+WLZsGdasWYP//Oc/ePbZZw2mefzxx7FixQrm99WrV/XSREVFMUHPn332WcybNw/h4eGorq7G+vXrwePxdMp45plnsHLlSowaNQqZmZl477330NnZiVWrVln5CCn2xsfHBy0tLczvuLg4HDt2DEqlst9e8oFeHrUYG4XWe7u5L5psR8sBQHNzM3x9fQdMdyOhUqnwxRdf4Pnnn9fZPmPGDEgkEnzzzTf461//apW6rNVp0V+HBdt62GDtTgsKxRb01WegR8t27twJpVKpM4JFrVbjs88+w6uvvsq8wF+9epUZZWoItnpvjICAANada8aQSqX4y1/+gieffFJvX1hYGDNa2xyam5sB4KbRfqr5xqGaPzQxpIFubm4AgLa2Nr2RQa2trXrOVnNmQzz77LM4ePAg3n77bcTExEAsFmPp0qV6i+6wmY3Rm9raWsyfPx8PPvigzndkZ2cnZs6ciZkzZyIrKwu+vr4oLy/HzJkzjS5qZQmG7GbTMREaGmoVzX/ppZf0RqkBPd/xljiQmpub4ezsPKSdUAB1ROnw8ssvw9fXF6+//jqKi4vh4eGB9PR0/P3vf2fSvPXWW5BKpZg3bx5cXV3xt7/9DW1tbTrlrFu3DiUlJZg7dy7c3d3x8ssv6zxs2NTDhhdeeAF8Ph8vvvgiqqurERgYqPPgdXd3x5IlS/Drr78yI376Y9OmTdBoNLjnnnvQ0dGBUaNGYf/+/fD09DTJLnPg8/l4/PHH8eabb+KRRx4xKKbvvPMO3njjjX7LuXLlCjNSqrKyEitWrEBTUxN8fX0xfvx4nDp1SudF7Y477kBDQwNefPFF1NbWIjU1Ffv27YO/v791D5Bid9LS0nRWFbrzzjvx/vvv47///S9Wr16tl761tRUeHh7w9fXF5cuXdfbl5OSY9TFjrRdNoVAItVptcN/ly5f1Rlfd6Pzyyy+oq6vDsGHD9M7Vrbfeik8//dRqHyXW6rTor8OCbT1ssHanBYViC/rqM9AzzSIkJAQ//fSTzvYDBw7gnXfewcaNGzFjxgz4+PjgzTffxM6dO/XK1eo4W723Jenp6cjPzzf6cTN8+HBoNBocOXJEb/QVAKaTzZD2X758GSEhIfDx8bGu0Q4K1XzjUM0fmhjSwNjYWHC5XJw7d05nym1xcTHa2tpYjaRRqVQ4e/YsMjMzAfRMaW1tbWVG+xw/fhz33XcfFi1aBKDHeVJaWmrRscjlcixYsAAJCQn417/+pbPv6tWraGpqwqZNmxgH6NmzZ3XS9Kd1WhITE6FSqXD69Glmal5TUxOuXbvGelSVrUlPT8e1a9eMan5KSgoqKytx/fp1g+fypnjXt1t0qhuIvsHTHIkpU6aQJ554wt5mUCh25+LFi4TP55Pm5mZm23PPPUd4PB5Zs2YNOXHiBCktLSWHDh0iS5cuZVZX2rdvH+FwOOTzzz8n169fJy+++CJxc3PTC1beVwOMBZn8xz/+Qby9vZnVbM6dO0fef/99sm3bNqP5Lly4oLMKR1ZWFnF2diYXLlwgDQ0NOgFqw8PDdYL53gzMnTvX4Aotvf9yc3P18rFZQcmQtms0GvLee++R+Ph4IhAIiK+vL5k5cyY5cuQIk6ajo4PcfffdRCKREH9/f/Lmm2/qlNfW1kbuuOMO4ubmRkJDQ8m2bdv0VlBiU48hGxcsWKCzopZarSavvPIKCQ8PJwKBgISFhZHXXntNJ88999xDvLy8brpgxxTHwJA+jxgxQmdFWC2tra1EKBQyAcx/+uknIhAIyLx588jBgwdJSUkJyc7OJmvWrCF33HEHk4+N3hsC/39VpN7Bd7UBagnpWQgFvVaEMrYtNzeXiMVi8thjj5ELFy6Q69evk59++ok89thjTJr77ruPhIaGkp07d5Li4mJy+PBh8t133xFCCKmsrCQcDods27aN1NfX6wSuXblyJbn//vtZtvbQh2q+ro1U84c+hjSQEEIefvhhEhERQXbt2kWKi4vJkSNHyJgxY8iYMWOYAPPGAmxrg3VnZmaSU6dOkbNnzzJ5tSxatIikpqaSCxcukJycHDJv3jyd1R4JGTjQft/67733XhIYGEjy8/N1NLO7u5vU19cToVBI1qxZQ4qKisiuXbtIXFycTn5jWtf32l+wYAFJSkoiR48eJTk5OWTWrFl6wcrd3d117N65cyfpz/2hPZZDhw7paX5XVxchRP+d3Ni2ffv2ET6fTzZs2EAuX75M8vPzyTfffEP+8Y9/MGkmTZpEhg0bRg4cOECKi4vJnj17yN69ewkhhBw/fpyxpaGhgXR2djL5Jk6c2O8iZEMF6oiyAo7oiGpubiY7duzQWdWAQrnZyczMJB999JHOtu+++47ceuutxNXVlTg7O5OUlBSyceNGHUfQiy++SPz9/Ym7uzt5+umnyeOPP262I2qgF002jii5XE6WLFlCPDw8mI8kQgg5ceIE8fDw0FlFj+I4OOKzQgvttKDYm976fPbsWWYFIkPMnj2bLFq0iPmdnZ1NFi9eTHx9fYlIJCIxMTHk4YcfJgUFBTr52Oh9X4w5Ol5//XVCCHtHFCGEnDlzhkyfPp24uLgw9b/66qvM/q6uLvL000+TwMBAIhQKSUxMDPnss8+Y/Rs3biQBAQGEw+Ewjoeuri7i7u5OTp48afQYKPaBaj7FFAy9o3Z1dZH169eThIQEIhaLSWRkJHn44YdJQ0MDk6Y/R5S7uzv58ccfSVRUFBGJRGTatGk6K+KVlJSQyZMnE7FYTEJDQ8mHH36od92a6ogKDw83qJlaPfz6669JREQEEYlEZOzYsWT37t169hvSur52NTc3k3vuuYe4u7sTsVhMZs6cSa5fv653/L1h64gy9PfNN98QQtg7ogjpcUaNGzeOiMVi4ubmRjIzM8nHH3/M7G9qaiKrVq0i3t7exMnJiQwbNozpZCGEkL/+9a/E29ubAGDau7KykggEAlJRUWH0OIYKHEKsHLH3JmTSpElITU3Fe++9Z29TGCIiItDS0oIXXnjBaMwlCuVm49dff8WaNWtw+fLlIb3KhDHuuOMOjBgxwuRpvpTBwRGfFS0tLfjjjz+wdOlS5Ofnm7TKE4ViTW50fbYVmzdvxs6dO3HgwAF7m0LpA9V8iilQDaSwYe3atWhpacHHH39sb1MshsaIsgJ//PGHvU3Qw9L5vRTKjcicOXNQUFCAqqqqGy44p0KhwPDhw/H000/b2xTKECItLQ0tLS1444036AcJxa7cyPpsSwQCAT744AN7m0EZIlDNd1yoBlLY4Ofnh2eeecbeZlgFOiKKQqFQKBQKhUKhUCgUCoUyKNBxfxQKhUKhUCgUCoVCoVAolEGBOqIoFAqFQqFQKBQKhUKhUCiDAnVEUSgUCoVCoVAoFAqFQqFQBoUbLli5XC6HQqGwtxkUCoXiEAiFQjg5OdnbDJtBNZ9CoVD+B9V8CoVCuXkYypp/Qzmi5HI5IiMjUVtba29TKBQKxSEICAhASUnJkH1I9QfVfAqFQtGFaj6FQqHcPAxlzb+hHFEKhQK1tbWoqKiAm5ubvc3pl9bWVgCAh4eHXe0wF7b2//zzz5g3b57tDTIRe7X/r7/+itmzZ4PLNX9WrCNdOxqNBtevX4dEIkFYWBirPObYr1arUV1dDZlMhtjYWHC5XDQ1NaGyshLh4eGD2ha97Ver1bh48SLS0tIGrX5TaG9vR2hoKBQKxZB8QA0E1fzBg2q+edxomk8IwfXr1+Hk5ITw8HBWeczV/JqaGkilUsTFxTmM5ms0GuTm5lLNtxNU8wcPqvnmsW/fPkyZMgVCodDsMhzp2iGEoKCgAAKBAJGRkazymKv5tbW16OjoYDS/ubkZFRUVCAsLg6enpxnWmwfV/MHjhnJEaXFzc3P4B5RYLAYACAQCO1tiHmztd3FxcchzYa/29/DwgFAohEQiMbsMR7l2WlpaUFJSgqSkJLi4uLDOZ4r9arUa169fh1QqRWFhITIyMtDU1ARCCAQCASZMmGC2/ebS2/7Lly9j5MiRJh2/o9HU1AQPDw/weDx7m2I2VPNtD9V88/Dx8QGXy7WoTRzl2mltbUVxcTESEhLg6urKOp+pml9QUACpVIqCggKMHj0aDQ0N4PF44HA4GD9+PDgcjtnHYA697c/Lyxvymt/c3Ax3d3eq+TbGUe5bc2Frv0QicchzYU/N5/P5N5Tmx8XFmXQ8ptiv7dDu7OzE9evXMXbsWNTV1UEkEkGj0dhd8/Pz85Genm7SM8/RaG5uhpubG/h8x3P70GDldkImk0Emk9nbDLNha79GoxkEa0zHXu3v7Oxscb32vnaUSiXy8vLQ3NyMtLS0AV/Iy8rK0NbWxvxma79UKkVOTg4iIiKQkZGBlJQUZGdno6amBgKBgHVvvLXR2t/Z2QkejzekP0jOnj0LHx8fvL15rL1NueGx931rKVTzzUMikdwwmt/U1IS0tLQBX8jLy8uZHmWAvf2dnZ3IyclBWFgYRo0ahdTUVJw+fRq1tbXgcrmIjIwc9A8S4H/2y2QycDicIa35OTk58Pb2xq18X3ubcsNj7/vWUqj95uHs7AypVGpRGfZue5VKhfz8fDQ2NiItLW1AJ1RFRQVaWlqY32ztl8lkuHDhAkJDQzFy5Eikp6fj5MmTqK+vByEEUVFRdtX8rq4uEEKGtBPq0qVL8PH2xgSBn71NMYjjucZuEuxxY1kTtvZbMh3Bltir/X19fVFSUgIfHx+zy7CX7RqNBsXFxejq6kJsbKzBIaB1dXVoaGiAt7c3XF1dce3aNXh7ezO9C0D/9mt7w5VKJSQSCUaMGMF48JOTk1FTU4OEhAQAQGFhITw8PCCRSCAWiwetXbT1dHV1obu7G1VVVVAqlfD399c5TkeHEIIn/zYHmeN88fbLl/Doyo4h/bB1dG4WzXdU7GW/j48PSkpKEBAQYHYZ9rKdEILi4mJ0dnYiNjbWoL7V19ejvr4eXl5ecHd3x9WrV03SfI1Gg4KCAnR3d+tpfmJiIqqrq5GQkAAul2t3zZfL5eju7kZlZSVUKtWQ1Py5aWMRABHOow2tra0OMfXnRoVqpn2xp+aXlZUhJCTE7DLsqfklJSWQSqVGNb+hoQF1dXXw9PSEp6cnrly5Ai8vL52ZHqZofkpKCjNyKj4+HlVVVYiPjwefz0dBQQE8PT3tqvkKhYLRfD8/P4tmtNiDOSmZ8P//mt/c3AwvLy97m6QDdUTZiaE4j7M3bO131N5xe7V/YmIifvzxR2RkZJhdhj1sr6qqQkNDA6KionR6RgghOiOe/Pz8kJSUhFOnTkGtVqOjowPp6ek6Dw+t/RqNBg0NDWhvb4dCoQAhBIQQREZGGu1x9vX1RXl5Ofz8/BAcHIy2tjbU1taiq6uLeUgEBgbasCX+Z7+bmxu8vLxQV1eHtrY2FBUVYerUqTat25r88ssvuJbfhlNX5uPeRX9g/evj8K/XLtnbrBuWm0XzHRV72R8fH4/t27dbVIY9bK+urkZdXR2ioqIQHR3NbCeE6Ix48vX1ZTSfEIKWlhakpaXpdEJZovk+Pj6orKyEj4+PQc339fVFUFCQ7Rqil/1CoRCenp6ora1Fc3MzCgsLMW3aNJvWbU3279+PRiiwAkE4gEZM9gzHBdI2cEaKWVDNtC/2sj86OhoXLlywqAx72F5TU4Pa2lpERkYiKiqK2U4I0Rnx5OPjw2h+eXk5Ghoa+tX8xsZGtLW16Wh+RESE0Y5PHx8fVFVVwdvbGyEhIXqar30W2JLemu/h4cFofkFBAaZPn27Tuq3Jb7/9hrr/r/m/oRGTvSOQS9rtbZYO1BFlJ7RDFi0JZmdP2NrvqCOi7NX+KpUKIpHIojIG03aNRoOff/4ZQUFBGDVqFBQKBerq6tDa2gqFQgEOh4Pg4GBEREQweQoLCyGXy+Hu7o5x48bp9WC0t7ejrKwMQqEQ/v7+CAsLg1AoZNXTERQUBGdnZ6ZHom9vTVlZGSoqKhAaGmrW8arVaqhUKnC5XAgEAmg0GnR2dqKurg5yuRxAzxDktLQ0BAQEgMvlQqPRQKlUYuzYoTO9TaVS4W9r7sbf/jkcbu5CvPhGOpZMP4S/PVZl8wf8zcrNovmOir3s12g0Fsf5GGzN/+WXXxAQEICMjAwdzVcqlQB6dLj31Oji4mLI5XK4ubkZDMze3t6O8vJyCAQC+Pn5maT5wcHBkEgkRjW/vLwcZWVlZk/VNqT5MpkMdXV16OrqAgBUVlZixIgRCAwMZGzu7u7GuHHjzKrTHqjVatw1ez7S4Q4ReBgDD+xGHcrLy1kvNEIxDaqZ9sWe9lsaf22wbf/555/h5+eHjIwMKJVK1NfXo6WlBQqFAkCP5vfWidLSUsjlcri6umLOnDl6mt/R0YGysjKzND8oKAhisRjOzs4A9DW/oqICpaWlOt8dpsBW81NSUhAUFAQOhwMOhwO5XD6kNF+j0WD5tNuQBjc4gYcx8MRO1KKkpIR10PnB4IZ0RH333XdYsmSJww0/683N0tNAR0Tpwufz0d3dbVEZg2W7XC7HN998gylTpkAikSA/Px9CoRDu7u6Iiooy+HGlUqlQWloKd3d3pvfb398fCoWCebBp532bswKGr2//cS3Cw8NRVFTE+sNELpejrKwM3d3d4HK54PP54PF4jHOJy+VCIpEgODiYeRgqlUqd6QxeXl64dOnSkBrG/t4nt0CtJrj3oVgAQHqGD6bfFow1/5yIr7cW2tk60/nuu++waNEii6a82pqbRfMdFXvZz+VyoVKpLCpjsGxXKBTIysrCpEmT4Orqykrz1Wo1iouL+9V8jUaDyMhIszR/oHs6LCwMxcXFrD9Muru7UVpaOqDmBwYGMs4vpVKpY7unpydyc3NNPhZ7MpXvDyUIktEzCsEXIkRAgunhSbhGLItnYw9++OEHzJs3D35+jhn3BKCaaW/sab+l3z6DZbtKpUJWVhbGjx8PDw8PXLlyBQKBAB4eHoiMjDToCFOr1cw0aY1Gg/r6egQEBEChUKChoQEtLS1Qq9WIiIgw6zt8IM0PDQ1FaWkpa4dKd3c3ysrKIJfLweVywePxwOfzdTRfLBbraX5v27WaP5Te87OysiCHGsPQM4vFG0JEQ4IZUcNQQDrtbN3/uCEdUYO5xKO5WPpiam+o/eZDCLEo/2DZLpfLERYWxjh0BnICAT3zqpOSkuDn5wc+n4+6ujqcPXsWhw4dQnp6OqZPn27zAIzR0dEoLi7G1atX4erqCrVaDalUiqioKKZHpru7m1mONiIiwqSHfkdHB2QyGZycnEAIQV1dHRITE5mRYJWVlRg9erTNp4uYi1QqxZsvXcSm9zMgEPyvF+sfr6RiYuqvuPTMJQwfPtykMquqqrB27Vrs3bsXMpkMMTEx2Lp1K0aNGmVt8w3iyJ0OWm4WzXTUUbBU8wdGoVAgJCSEebln49jVar6vry8EAgHq6upw/vx5HDhwAKmpqZg5c6bNNT8qKgqlpaW4cuUK3NzcoNFo0NHRgcjISIhEIos1XyqV6mh+fX09EhISUFJSAplMhsrKSmRmZjrsaFKZTIZstGIsPMHD/z6kMuGB71GNnJwcpKamml3+pk2bsG7dOqxevRrvvfee5QazgL7n2x5qv/0YTM338/Njpl97e3sPmKev5tfX1yMnJwf79+/H8OHDMWvWLGZkka2IiIhAeXk58vPzmU6Qjo4ORts5HA4UCgUKCgrA4/EQERFhUjw/Q5ofFxeHkpISdHV1oaKiAhkZGRbFAbMlXV1dePTeVciAB/i9ND8DHvgO1Th79qxF7+fW1Pwb0hHV1dXl8B8mQ1kgAWq/JYSGhiIvLw/Jyclm5XfktufxeDoOGH9/f/j7+yMjIwN5eXn47bffLIqPxZaoqChIpVKmtyMwMBBFRUVQq9VQq9XgcrlITEw0aynTwMBAlJaWorq6GkCPw66qqor5GPLz80NNTY3DOqI2vDEOEVEuuG2h7vTF8ChX3PtwLFavmYnf91WzLq+lpQW33HILJk+ejL1798LX15cJMDlYdHZ2OvRoKMCx71s2sLXfUUfB2rP9w8PDcfHiRaSkpJiV35GvHS6Xa1DzR44ciWvXruHgwYMYPXq0ze2IiIhAZ2cnFAoFo/mFhYU6mp+QkGDWNMmAgABG87VTNCorKxEZGYmysjL4+PigpqbGYR1Rk5yD4QweoqEbZNcVfCTDFXPTxqJCIzOrtz87Oxtbtmwx+9o2F6lU6tCjoQDHvm/ZQO03n8jISIscvI7c9n0138/PD35+fkhLS0NBQQEOHDgwKKEqwsLCGM3ncDh6ms/hcMzW/L7v+d3d3aiurkZYWBjKysrg5eWF2tpah3VETZYEwQk8xMJZZ7sL+BgGV8zPGI8qTZdDaP4N6YgaChHth/LyvwC13xJGjx6N77//HqGhoQMuiWqIodr2ycnJqK6uxuHDhxEQEIDo6Gibvkj2bSftanuWoh0t0NuJpe1ZCAwMxIEDB+Di4oK2tjYEBgbC398fTk5Og7rihzFqamqw+d0r+G7PFIO2PLVuGMYk7MKhQ4dYB+F94403EBoaiq1btzLbBnv+OdV820PtN5+MjAxs374dYWFhZq1SNlTbPj4+HpWVlYzmR0ZGWrR64EA4OzszcUUA22r+yJEjAQAhISHYv38/xGIx2tvbERAQgICAAIhEIkgkErtrfn19PXLQhlnwAwf6tqTBHd+gCvv378esWbNMKlsqleKuu+7CJ598gldeecVaJrNiKEwbG6r3rRZqv/mkp6fjxx9/RERExE2l+bGxsaioqBjymq+d5m1I88PDw7F37160tbU5pOY3NjbiAtowA74GNT8V7vgWVfjll18wb948k8q2hebfkI6owe6ZMQeptGdO/lBdOpet/Y46TcPe7T9+/Hjk5OTg1ltvNTnvYNpubUGdPn06mpqaUFtbi6tXr+L48ePMPl9fX4SFhSEkJMRhrxug//bXTgPh8XhITk5GUVERFAoFXF1dIZVKweVyweFwmIenRCKBRqNBV1cXNBoNvL29oVQqmTyWBrzsy9oXb8XkGYHIGGt4mqWXtwhPrk3GM2tuR865RlbnYffu3Zg5cyaWLVuGI0eOIDg4GI8++igeeughq9reH+aOLhxM7K05lkLtt4xbb70V58+fx5QpU0zOO1i222I029SpU9Hc3Iyamhpcv34dJ0+eZPbdCJqvjaHC5/ORnJyM4uJidHd3w93dXUfzJRIJXFxcGM2Xy+VQq9U6mu/i4mLWKN3+mOIfgyA4IQiGHTcicJEOd9w1ez7qVV0mPXMee+wxzJkzB9OmTRt0RxTVfNtD7beMyZMn49y5c2atpmxv2y1hypQpaG5uRm1tLQoLC294zS8pKYFcLoenpyc6OjrsrvmTfaPgDxGCYXgqoghcjIQ77p2/BA1KmUn120Lzb0hHFJtYNvZmqK5CoYWt/Y46TcPe7R8UFKQjzqYwWLbb6tyJxWJERkbqvEhqNBrU1tairKwMFy5cgFKphI+PD8aNG2fXc9Xe3o6GhgYIBAJ4enrC1dW1X3uEQiEyMzNRUFCAqqoq8Pl8hIWFob29HfHx8RCJRCCEoLOzE52dnaivrwePx2PmtBcVFUEoFEIoFKKiokLPEejp6QlCCLNaoanHkvVZEY7kzOk33YOPJ+Cj967iwIEDeiuEiEQivVUfi4uLsXnzZjzzzDP4+9//juzsbDz55JMQCoVYuXKlSTaaS2Bg4KDUYwn21hxLofZbhp+fH7P8takMdc13cnIyqPn19fUoKSnR0fwxY8bYdbSLJZpfUVEBHo+H8PBwdHR0IC4ujokxIpPJIJVKUV9fzwTHZaP5Hh4e4HA4IISYPA1EJpPhCjqwGP3rYzJckYt27N27V69zzJDmA8C3336L8+fPIzs72ySbrIWjToPsjb01x1Ko/Zbh5eWF1tZWs/IOpubbwiHk5OSEiIgIJCUl6Wzv+57v5eWFcePG2VXzOzo6UF9fzwRpd3Nz67f9+Xw+MjMzUVRUhPLyciYG1UCa7+TkBC6Xa1PN7+7uRj46sBD9j0JL/P+a/8svv+h1jg225t+QjiipVDokvciUmwtH7Q1ob2/HsWPHIJVKzeq9NwftnPPe884rKyuxd+9enY8jHo8Hf39/REZGWnVan0ajASEEPB4PMpkMMpkMDQ0N4PF4CA0NhUKhQFNTE0pKSqDRaBAREQGJRILS0lK0trbCxcUFHA4HIpEIHh4eGDlyJK5fvw61Wo2KigoIhUJcvnwZ0dHRUCgU8PHxgUQiAZfLRVdXF1QqFVxdXeHv7w+g52Hi7e3NBFfs7OyEWCxGcXExGhsb0dzcDOB/U9LkcvmAzhilUgmNhmDEiRaIz7b3mzZAyMMXX3yB2bNn62xfv349NmzYoNd2o0aNwmuvvQYASEtLw+XLl/HRRx8NmiOqvb2dar6DYO9h6Y6MI2v+8ePH0d7ejsmTJw9KnVwul5nSoKW6uhr79+/X03xfX1+rT+U2pPmNjY3gcDgICwuDUqlkNF+tViMyMhISiQRlZWVoaWmBs7MzOBwOnJyc4OHhgVGjRuHatWtQqVRMJ0R+fj6ioqLQ3d0NX19fiMVicLlcyOVyKJVKVppfUlKCpqYm1NfXM73sHA4HMplswDiEKpUKGgBL/dwh4fY/0ulwowBfffWV3lQNQ5pfUVGB1atX4+DBg3b7gKSa7zg4qq45Ao7aNlKpFEePHkV7ezsmTpw4aPWaovnWntZnTPOBnul2SqUSLS0tKCsrg0qlYjS/vLwcLS0tjPb2fs+/evUqlEolqqqqwOPxkJ+fj8jISCgUCqOar32OGdP80tJSNDU1MTEJtfV2dnYO6IBXq9XQAFjs5w43bv8unj+bhPj666+xaNEine2Drfk3pCPq6NGjWLFihb3N6BeFQgFgaMQ2MQRb+4uLi/HTTz8BcKwPFK39lvQ6WNp7XFlZaVY+W107UqkU+/fvh0gkYpZytQVs7Q8JCdHrDVCpVKiurkZ+fj5+++033HLLLQgLCxuwzpKSEoSGhoLP54MQgra2NmaljUuXLjGr6SkUCojFYri5uSEqKorpFRCLxXB3dwfQE3PjypUrCAsLQ3NzM9LT09HW1gahUIju7m50dXVBJpPBy8sLXC4XCoUCKpUKQqEQZ8+ehYeHB3Jzc+Hk5AR3d3eIRCI0NjYiMzMTbW1tKCkpgZubG7q7u8Hn8yGXy+Hh4YGmpiakpqZCKBTC29sbEokEnZ2dUKvV6OjoQFNTE9O+YWFhFgfvvv322/HRRx/pbDPUSxIYGKjX65WYmIgff/zRovpN4ejRo7jrrrsGrT5zuFk0v6SkhGq+ERxN82UyGfbv3w+BQOAQmh8UFIQFCxbobOur+ePGjWNWcu2P0tJSBAcHQyAQ6Gg+IQSXLl2CQCDQ0/zeq+lptwE9mn/16lWEhISgqanJqOZ7enqCx+Ohu7sbarUaAoEAZ8+ehaenJy5evGhQ8zs6OlBUVARXV1coFAqjmu/h4QGJRAKZTAaVSoWOjg6mQ8Jamr906VJ8/PHHOtsMaf65c+dQX1+P9PR0Zptarcaff/6JDz/8EN3d3VafVt6XI0eO4J577rFpHZZCNd++OILmV1RUmJXP1prP4/Fw6623OrTmX716FYcPH8aYMWNYxR0tKytDYGAghEKhQc3n8/nMO7lWi41pfkNDA65evYrg4GA0NjYO+J7f3d0NjUYDgUCAc+fOwdvbm3nP9/DwYDQ/IyMDnZ2dKCwshKurK5RKJXg8np7mCwQCuLu762i+VCplRlVrV7i1tHNm0aJF+L//+z+dbYOt+TekI2ooxIgaqoHotLC1Pzo6GgsXLrStMWagXZHC2nNz2ZKXl2e2p99W187PP/+MefPm2fzatKR87VS3sLAwpidlypQp/X6YyOVynD17FhEREcjJyQGPx0NtbS1SUlJQWVmJxMREow9LmUymF2Tc3d0dMTExqKmpAY/HQ0tLC65cuQI/Pz/ExMT0+2APCgqCSqXCiBEjUFVVhY6ODsjlcgiFQuzduxc8Hg8BAQGIj48HADQ3N8PZ2RkikQhKpRLZ2dloaGjApEmT4O7ubnRluosXL1o8tFsgELAKpn/LLbfg2rVrOtuuX7/O6mPRWowYMWLQ6jKXm0XzIyIiqOYb4Nq1a2aHDbCl5s+ePdusRTNMwVqaX19fj59//hlTpkzp98Oku7sb2dnZCAsLQ25uLrhcLurq6jBs2DBUVVUhISFBJ8Btb4xpfnR0NGpra8HlctHa2or8/HxWmh8cHAyFQoGUlBRUVVVBKpXqaD6fz4evry8TZFfb8y4SiaBWq3HmzBk0NjZi4sSJ8PDwMKr52g4VS2Cr+VOnTsWlS5d0tq1atQoJCQlYu3atzZ1QQM/IW0eHar59sbfmFxUVwdvb26y8trp2fvnlF8yaNWvIaH5jYyN++uknTJ06tV/NVygUOH36NJYuXaqj+cnJyaipqUFsbCxcXV0N5u3q6mLCY2hxc3NDdHQ06urqwOFw0NbWhry8PPj6+iI2NrZfzQ8JCUF3dzfzvNFqvkgkwr59+8Dn8+Hj46Oj+WKxGE5OTtBoNDh9+jSam5sxfvx4eHp6GtX8y5cvM3FpzcURNP+GdESFhv5vWXKFQoHs7GyMHTvWoYZIDuVAdAB7+wkhg2CN6dir/TUaDfbv3w8ul4uZM2eaVYYtbN+zZw/GjBkzKC9O1rI/KCgId9xxB3Jzc3Hs2DEsWbJEb8ioRqPBlStXkJaWhnPnzjEPFhcXF7S3t2PEiBFGX1K6urpw9OhRjBw5UqenOS8vDwqFAlFRUdBoNCgtLUVLSwvUajVCQkL6Hbba+6VEuyoH0HOfdHV1oba2FlKpFPn5+fD29oafnx/zkPHw8EB5eTliYmIGfLEaPnw4zp8/j6ioqH7TWYOnn34a48aNw2uvvYbbb78dZ86cwccff6zXs25Leo+KUygUOHPmDMaMGWO3F1BD3Cya76jYU/MPHjwIAA6l+Xv37sWoUaNs/kECWM9+Pz8/rFixApcuXcKJEyewaNEivU4EjUaD/Px8pKWlMRpYX18PZ2fnATVfLpfj6NGjSE9P13EaXrlyBV1dXYyeajVfpVIhODiYmVphCC8vL+b/hjS/rq4OHR0dyM/Ph5eXF/z9/XU0v7i4mJXmDxs2bNA039XVFcOGDdPZ5uzsDG9vb73ttqK35qtUKpw6dYpqvpWh7/nmodFo8Ntvv0GlUumFN2CLLWzfv38/0tLShpTm+/j44M477+xX8wkhyM/PR3p6Os6fP4/IyEg0NjbCxcUFHR0dSElJMaoL3d3dOHr0KEaMGMFMkwZ6NL+zsxMxMTEAekb9tba2QqlUIiQkpF/N7+046qv5SUlJqK+vR3t7u1HNLywsRGxsLAQCQb9tM2zYMJw7d25QVqm2peY7jmLbgLKyMhw9ehQpKSn45ptvMHXqVJsuI2kKjvSwNAdqv3ns2bMHycnJFgmHLWxvaGjAqFGjrF6uIaxpv0QiwdixY8Hn81FRUYHY2Fid/ZcvX0ZsbKyOg62zsxNCoXDAF/aWlhZmxQsttbW1EIvFiIuLY8oMCAhAUlIS2traUFFRga6uLgwfPtykXgrtPHCtTWq1Go2Njbh48SKcnZ1RUFCA1tZWBAYGwsPDw2hvfu/ykpKScOrUKdY2mEtGRgZ27tyJdevWYePGjYiMjMR7771nl6ly5eXlOHr0KIYPH47vvvsOkydPHjCOymBBNdO+2Mv+/fv3IyYmRk+bTMFWmq9djtrWWFvzR48eDYFAgIqKCmb0qJa8vDzExMTo9H53dXVBIBAgOjq637JbW1v1lgOvq6uDSCRCTEwMo/n+/v5ITExEW1sbqqqq0NnZiZSUFLM0X/su0FfzCwsL0dLSgsDAQLi7uw/YSTSYmu9I9NX8iRMnmhzg11bcLJrpSJ38vbFX+x88eBARERF62mQKtrC9rq5u0EaP20LztTHz+q6YefnyZURFRek42LRTxbSOJGO0trZCIpHoaL52sYoRI0boaH5SUhJaW1sZzR8+fLhJ175W87XOKY1Gw2i+RCJh4gEGBATAxcXF6Aiu3iQnJ5u98JWjYNGVsmnTJqxbtw6rV6/Ge++9BwCYNGkSjhw5opPuL3/5i06skd27d+PZZ58Fh8PBO++8g7lz5wLo6WWKjIyEr68vM2deS2pqKhYuXKgXQMsQP/zwAyQSCUJDQ7F8+XLw+XyEhITg9OnTZnunrc3N8oByVOxl//jx47F3716Eh4eb/fC2he1LlizBn3/+iYCAAJ05wLbAVg/Yvg/9srIy+Pv7673As31J7Rs8Hej5oHF3d9c7BpFIBD8/P/j5+aGtrQ0XL14Ej8eDn58ffH19TR46qw3K7u/vj/b2diZIbmlpKeuPR7FYjOHDh5tUr7nMnTuX0XF7oNX84OBg3HHHHczQ7hMnTlBHlJWg9pvHLbfcgp9//hmRkZFm22AL2xcvXoyjR4/C19fX5p0QtrC/trZWb1XPiooK+Pr66r3As11hrW8gXaBnlJSrq2u/mt/e3s5ovq+vr85IVrYY0vzy8nKUlJSwnoY2mJrflz/++GNQ69NqfmBgIJYtWwahUIiIiAj88ccf1BFlJdja76irY9tT83ft2oXo6GiH0vylS5fi6NGjqKioQEZGhtXL740t7K+pqdF7/62srIS3t7feKC+2731aze2NXC6Hm5ub3jEIhUJG8zs6OnDp0iWLNJ/L5eqU5+zsjMrKShQVFbHWfCcnpyGv+WZfKdnZ2diyZYvBeEwPPfQQNm7cyPzuPaKgu7sbjz32GLZu3QpCCO6//37MmDFDZ257R0cH3n77bbz00ktm2bZs2TK4uLjofOh7eXmho6PDZktVmopcLgcAuy5ZaQnUfvPw8PDA5MmTsX37dri4uGDGjBkmC7YtbHdxccFtt92G7du329wRZQv7q6qqkJOTg8DAQMTGxqK1tRVdXV1MnCKpVIqTJ09izJgxrHoZDNHS0gKlUskM/TXWTu7u7kyvU3V1NS5fvgyg59wHBQWZPJfazc0Nbm5u8PPzw/Dhw02aPmnv5YsHC0Oa7+HhwQR5dIQPgptFMx3h+WoIe7W/m5sbpk6dih07djic5s+ePRvbt2+3uSPKFvZXVlbi4sWL8Pf3R3x8PNra2iCVSpGYmAigJ9bT8ePHMXr0aLOnorS2tqK7uxuXLl1CeHi40XZyc3NjNL+mpobRfHd3dwQHB5ut+f7+/hg2bBjVfAMY0nw3NzdmcRCq+ZZDNd88XFxcMHPmTPz000+QSCSYNm2ayfelLWyXSCSYOXMmtm/fbnNHlC3sLysrY6aDJSYmor29He3t7cxiOV1dXTh27BgyMzOZxYVMpbW1FXK5HJcuXUJISAgyMzMNpnN1dbWq5ru6ujKrqCYmJpr0nTLUNd8spZZKpbjrrrvwySef4JVXXtHbL5FIjE6B0w6XS01N7TGAz0d3d7dOQz7xxBP417/+hccee8zsiPCGhHHEiBE4ceIExo8fb1aZ1mSorqKhhdpvPgEBAbj99tuZwKt9l84cCFvZfvLkyUHxrNvC/jlz5qCqqgo1NTUIDAxEWVkZ4ySvq6tDeXk5YmNjzapboVDg8uXL8PHxQXh4OMLDw1n3fPQeVdXS0oKcnBwkJSX1O7/cGHw+Hy4uLqivr4dCoQCPxwOfz4enp6dDvHTbG2Oaf+zYMUyaNGnwDeoD1Uz74gia39jYiF27dmHJkiUm5beV7adPn2YcN7bEFvbPnTsXVVVVqKqqQkhICEpKSpgPg/r6epSVlSEmJsasupVKJS5fvgxvb2+TNT8wMBCBgYEAej5qcnJy+l0Qoz94PJ6e5vN4PHh6eg4YP+RmwJDmp6Wl4c8//8SUKVPsYJEuVDPtiz3t9/HxwdKlS9Hc3Izdu3dj6dKlJuW3le3Z2dlMkGxbYivNr66uRnV1NcLDw1FUVMT4Eurr61FaWmqx5nt5eTGB0s3V/NzcXMTHxw8YQsMQPB4Prq6uaGhoYPwlN7rmm+XGfuyxxzBnzhxMmzbN4P6srCz4+Phg2LBhWLduHWQyGbPPzc0Nq1atQmBgIIKCgvDII4/oef5WrFiBmJgYnVFV1iA+Ph7d3d24cuWKVcs1B7lczniMhyLUfssx18lqK9tra2stmtPOFlvYHxISgvb2dgQFBaGwsJCJ11FQUICysjIoFApERET020vR1tamo1VXr17FlStX0NTUxDyYRCIRuru7zbLf09MTcXFxKCwsNOsYgZ44Inl5eejq6oJIJEJlZSVaW1vNLu9GJzY2FhqNhumtsieOoDmWQO23HB8fH7NGD9jK9urqar14G7bAFvYHBQWhvb0dwcHBuH79OqP5hYWFKCsrQ3d394DTIftq/vXr15GXl4fm5maEhIRYrPkeHh6Ij4+3SPO1wddlMhlEIhFqamqYJbwp+minQ128eNHepjiE5lgCtd9yvLy8zHIg2Mr2ysrKQVlQwFaaL5VKERgYiGvXrmHEiBHgcDgoKipCeXk55HI5IiMj+23v9vZ2dHZ2Mr8LCgpw+fJltLS0ICgoCOHh4RZrfkJCgsWan5eXh87OTohEItTW1qKpqcns8hwdk7vRv/32W5w/fx7Z2dkG9995550IDw9HUFAQLl68iLVr1+LatWvYsWMHk2b9+vV46qmnwOVyDQ4/43A42LRpE+bNm4enn356wACTfeno6IBIJEJXVxckEgnkcjkIIZBIJBg5ciT+/PNPSKVSJoixVCqFQCAAl8tFd3c3XFxc0NnZCS6XC6FQiK6uLojFYigUCqjVaiaPSCSCRqOBUqlktvH5fPD5fMjlcjg7O0Mmk4HD4cDJyYlZFlihUKCtrQ0SiQStra3MaDCFQmGwHO0xAD0xADo7O+Hk5ASVSgWVSsXkMVQOj8djjqFvW2jLUavVOsfQty36liMWi5lpjhKJxGhbCAQCqFQqJgCosbbo3aYDtYWhcti2Re9yVCqVwbboW85AbWGoTY21hbac3segVqvR2tpq0vXV1dUFhUIBsVhslbbQHkNHRweUSqVVry9Dx9DV1QUulwuNRmP0+mLTFgKBADwej7ku0tPTsXv3bixZsgRtbW1oa2sDl8tlVrgb6F4rLS0Fh8NBREQESkpKwOfzweVyQQhBW1sbMyKpra0NAoEAfD7f5HuttbUVhYWFiIiIgFqtZnWvKRQKaDQaODs7QyqVYsyYMSgsLERjYyPi4uKQn58PsVhs8PpSKBQmaedQpT/NT09Px/Hjx9HZ2Yn4+Hiq+VTzqebfIJqfmpqK3bt3Y+HChcw0DUIIlEolIiIiBrzXysrKQAhBZGQkSktLwefzweFwQAhBa2srBAKBVTS/uLgY4eHhIISYpfmjR49GUVER6uvrERsbi8uXL8PZ2ZlqvhHNT0lJwcmTJ9HZ2YnExESq+TbWfIVCQTWfav6gaP6IESOwa9cuzJs3D+3t7ZBKpcwxsNH88vJyKJVKREdHo6ysDDwej9H8trY2iEQiizW/ubkZpaWlzKgqczW/uLgYdXV1iImJweXLl+Hq6npDar5JjqiKigqsXr0aBw8eNDrv8+GHH2b+P3z4cAQGBmLq1KkoKirScSgNNH9z5syZGD9+PF544QV8/fXXppg5INOnT8fOnTstWsWmP7744gtmuoxKpQLQM9xOrVaDx+NBo9FArVaDz+frxKzSaDRMHg6HAy6Xy+RRq9UAwOzXlkMIYbaZU472Q7t3OVr6K0elUoEQAqFQaLRupVJp994IY4jFYpMDyzkKEonE5PnHbBisYZ9ap4k1A1x2dHQww3SdnJxQW1uL5uZmuLm5wdvbG35+fsxyssYICwtDQ0MD8vLy4OnpCQ6Hg/LycjQ1NemMFBOLxWa3VWVlJdLT03XuRXOIiorC9evXUVFRAYFAgPz8fEgkEri4uJg1HPhGZ8qUKdi5c6fNRvx9+eWX8PDwuOk1X6VSDXif2Quq+frcKJrv7OyMuro6NDY2wsPDA56enggICBjwWgwNDUVjYyPy8vKY+7e0tBTNzc2Ii4vTsd/ctqqoqEBaWhr4fD6USqVZZQBAZGQkM8JXJBIxmt93lT9KD5MmTcLOnTttNvWUan5PHq2TxRGhmq/PUNd87YwHV1dX1NfXo66uDt7e3nB1dWVGTPVHcHAwmpqakJeXB3d3dwiFQhQXF6OlpcWqmp+amgqhUGiR5kdERKCgoAClpaVwcnJCXl4eXFxcIBaLbyjNN8kRde7cOdTX1+sE6VWr1fjzzz/x4YcfMvMZezN69GgAQGFhockjmzZt2oSxY8dizZo1JuVzdXWFSCSCSCQCoBvIy8PDAxqNhhFiPp8PDw8PZr82dktvR5m2HO2/2nL6oi3b398fCxYs6NdGrXAbKmcowMb+xsZGXL58mUnTu02158RYm2rn+PbepnV+GiqnN2zKaW1tBY/HY8oydj61aK+L3tuMXV9sytHWy+PxmP1sri+gp+35fD4EAoFV2kKb18nJCQKBYMBjMFSOKW3R2toKjUbD7DdUDtu2AHoerLm5uRg1ahTzcVJaWoq4uDi0tLQgLS1Np52NHYN2CVjtwyg3NxeNjY2IjY2Fr68vk47P5zM9IKa2RWpqKvLz8xEeHq4zj72/68tYW6SlpSE3NxfDhg1DbW0trl69iltvvVXnumhvb9druxsRe2o+0DPNlmp+T5pz585Rzaear7PN2povFAqRk5ODUaNGQSqVori4GGVlZYiOjkZzczNrzc/Ly0NkZCTTKanV/OjoaJ2p89bS/N6Yo/mpqanIzc1FUlIS6uvrceXKFYwfP55qPgy3vUqlYpwm1tZ8Hx+fAeN73gya39HRgVOnTlHNp5qvs80Wmn/hwgUdzS8vL0dERAQaGxuRmpqqd58bOob8/HyEhYUhJiYGAHDx4kU0NTXB3d3dapqflpaGvLw8vThT5mr+xYsXkZCQgIaGBly9ehXjxo27oTTfJEfU1KlTcenSJZ1tq1atQkJCAtauXWvQe5uTkwMATCAvU8jMzMTixYvx/PPPm5y3P7hcLm6//Xb8/vvv6OrqgpubG6ZPn252eeXl5aiqqmKcbmwYqqtoaGFjv7W94dZkKLe/rWwfrOGd1rY/Pz8fiYmJaGtrQ3V1NeLi4hAZGYnjx49j4sSJA/YqqVQq1NTUwM3NDV5eXsx2Pz8/1NbW6q0Maon9YrEY3t7e6OjoMHv1vt7ExsaipKQESqUSXC4X58+fR3p6OpRK5Q0b2NAc+mq+dlUbc6msrERZWRnGjh3LWueGsuYA1H57QjVfl/z8fCQkJKC9vR2VlZWIj49HZGQkjh49ikmTJrHWfBcXF4Oarw16bg37xWIxfH190dbWZvZKTr2Ji4tDSUkJNBoNOBwOcnNzkZqayoxiofyP5cuX49ChQ8w0mtmzZ5tdVnV1NUpKShjNZ8NQ1hyAnf0cDoe+59sAqvm6aDW/o6MD5eXlSEhIYDR/4sSJAy7Yo1arUVNTA4lEAh8fH2a7n58fampqmKDn1rDfyckJfn5+aGtrs4oTOj4+HsXFxczIxosXLyIlJQWEkBtC802Kmunq6ophw4bp/GmXUhw2bBiKiorw8ssv49y5cygtLcXu3btx77334tZbb9X7mGPLq6++it9//x3Xrl0zK78xnJyccNttt2HJkiVwcXExu3y5XI7jx4/Dx8cHP//8M+t82mkMQxVqv/2wle0pKSn45ptvUFZWZvWye2NN+5ubm+Hu7o6Ojg6UlpYiKSkJAoEADQ0NSE5OZrWa3LVr1yCRSPSm6gYGBmLmzJl6PVCW2m9NB61AIIBGo0FSUhKmTJkCLpeLS5cuoa6uDpcuXXLYqbH2oLfme3h4mL1ohUKhwJEjRxAQEIBdu3axzjeUNQdgZ78jdz4M5fa3le2pqalDTvNbWlqY+D4lJSVITk6GQCBAY2Mja82/fv06xGKxzlQM4H+a37t32hr220LzExISMHXqVEbztUuIU83/H0KhkNF8X19fsxetUCgUOHz4MAICArBz507W+Yay5gDU/sFEU3hK57etNb+kpMTqZffGmva3tbXB2dkZXV1dKCoqwrBhwyAQCNDU1ITExERWna7Xr1+HSCTSC88QEBAwZDQ/Li4O06ZNA5/PR15eHqP5XV1dVqnHXlh1zW+hUIhDhw7hvffeQ2dnJ0JDQ7FkyRL885//NLvMuLg43H///fj444+taKkuaWlp+OWXX5gLVDsXmsvlQiaT4eDBg8wFpb24tP+2trYiKSkJsbGxaGtrw/79+1nFfhkq4mgMar/9sJXtiYmJiI2NxenTp3H27FmIxWLMmjXLrFWe+sOa9iuVStTX18Pf3x9paWnMttbWVgwfPpxVGU5OTpBIJKxjCVhqf0dHB0JCQiwqQ8v169cRGhrK/E5KSoKzszMTwNARVg5yRNLS0vDTTz8x8UN6a75cLsf+/fv1XiK0mt/e3o6YmBhER0ejra0Ne/fuZfXCMZQ1B6D22xNb2R4fH4/o6GhkZ2fj7NmzEIlEuO222/Q0/4MTPR8tT4yLNKsea2t+Y2MjuFwuUlNTweFwoFKp0NTUxLrDc7A1X7uiqzW4fv26zvMjMTFRR/P7zlqg9JCamoodO3YwK4aZovmdnZ0ICwtDdHQ0Ojs7sWfPHqr5/x9rvx9ak6HU/tyYMTq/B0Pzz58/D4FAgLlz5zr0e75CoUBTUxO4XC7S0tKYAPANDQ16o1eNIRaLTYoZZo33fH9/f4vK0HLt2jWd50dCQgITg0upVA7593yLHVF//PEH8//Q0FAcOXLE7LIiIiJACNHbvmXLFmzZssXscgfCyckJnp6eOH78OJqamhgbtNH7Z82aBTc3N508vYMPahk1ahQqKipw9OjRAet0cXGx3gHYATb2a4cROiJDuf1taTufz8ctt9wCoGfK6fbt2+Hk5IRx48bpDGe1BGva7+/vryf2ZWVliIqKYl2GXC43aRiupfYTQix+6KvVahQWFsLDw0NHm3rbJhQK9Xr8KT0IhUL4+Pjg2LFjaG1tZToPNBoNFAoFZs+ezUrz09PTUV1djd9//33AOoey5gDUfntia80fO3YsgJ4pp9u3b4dIJMLYsWN1YmZYgjXt9/Pz07OrvLwckZHsnWRdXV2DqvmGtMOcMgoLC+Hq6tqv5ttqEZ6hDp/Ph5+fH44dO4b29nYmiLBW82fOnKk3jcbQeUtJSYGPjw/V/F446ijYodz+g6X51dXVDq/5vr6+OnFagZ6A4KZovnYFR7ZYar9KpWI1Orc/NBoNioqK4OzsrKNNvQOVCwSCIa/5Vh0RNZTRruzn5eXFapUNYy8VwcHBrKLZayP7D9UghtR++zFYtoeFhSEsLIzpLQwICDApDpoxbG2/dplXNhBCmNVi2GKJ/QqFwuI5+oQQ5OTkIC4uzipxpm5WpkyZgpKSEnh7e1uk+UFBQVTz/z+OPDVvKLf/YNkeEhKC22+/HXK5HAcOHICvry/zwWLuaCjA9vbLZDKTtLD3CmBscBTNj42NpZpvAZMmTUJJSQk8PT2RnJw8YPr+NJ/NeRjKmgNQ++3JYNkeFBSE22+/HQqFAgcOHICnpyfTGW0JtrZfKpUiIiKCdXqlUmlSPCVL7Fcqleju7jY5X19ycnIQExOj1yl6o0EdUb0wdVU/SxjqgYSp/fZjsG13cnLCggULcPLkSWRnZyMjI8Oi8mxtvykfwkVFRTpT29hgrv2FhYVoa2tjPWXQGA0NDaxfhCn9Y0qPmqUMZc0BqP32xB6aP3/+fJw+fRonT57EE+PGWlSeo2m+qVOjLdH81tZWs2OkamlsbIS/vz/VfCtANZ89bOx35Kl5Q7n9B9t2oVCIuXPnIjs7G8ePH7fYGeVIml9cXGzy1Ghz7S8uLkZzc7PF7/lNTU3w9fW94Z1QgInByinWQzs3fajCxn5H7h0fyu1vL9vHjh2L7u5ubN++HUVFRWaXY0v7GxoaWA+HLSsrA5/P11k1iQ3m2E8IgUwmw8iRIw0uv8uW7u5uVFdXm7UKKcW+DGXNAaj99sReto8ePRoajQbff/89CgoKzC7HlvY3NTWx7ukuLy8Hl8uFt7e3SXVYovmjRo2yWPMrKysRHBxsdhkU68Pm3XYoaw7A3n5HDcExlNvfXrZnZGSAy+Xi+++/t2iRMFva39zczLrsiooKANCb2jcQ5tovlUoxatQoveDnpqBQKFBWVma1WLKODh0RZSe0w/ZMmbPqSFD77Yc9bR8/fjxUKhUuXLiAc+fOwc/PD7feeqtJgm0r+5VKJaqrq1kFLySEoL6+3qzRXabY393djaamJlRXV+vM4+7o6EBdXR06OzvB5XLB5/MRFxc34AdVfX29ScORKY7DUNYcgJ39jtz5MJTb356233LLLVCpVMjJycH3338PHx8fTJo0ySE0X6VSoaKiQm/pbUMQQlBbW4vMzEyT6zHFfm1g3erqap1R9lKpFHV1dZBKpeByueDxeIiPjx9Q8xsbGxEeHm6yzRT7M5Q1B2Cv+Y7KUG5/e9o+duxYZGRkOKTmq9VqlJeXs9J8AKipqRlUze8dn9aQ5sfFxQ3YWd7U1ISwsDCTQoYMZagjyk4M5SB6APtg5Y7KUG5/e9vO5/ORkZGBjIwMlJWVYdeuXVi0aBHr/Layv6ysjHXQPg6HA1dXV3R3d5vcc8HWfpVKhUuXLiEyMhLp6engcrlQqVQ4ceIEgoKCEBwczDzkZDIZcnNzkZ6e3m+ZIpHIKnPPKYOPve9bS6H22w97287n8zFq1CiMGjUK5eXlDqX5MTExrNJyOBy4u7ubvDgFwN5+tVqNixcvIjIyEmlpaeByuVCr1Th+/DgCAwMRHBwMiUQCoCdgem5uLrMKlDFEIpHFMaYo9sHe962lUPvth71t76v5O3fuxJIlS1jnt5X95eXlJoXR8fT0RFdXl8kOMXM0PzU1FTwez6jmy+VyXLx4kZXmy+Vyk+wdyjiup+AGRyqVMsHQhiJs7XfU3vGh3P6OZLu2p9aUpU5tZb9cLjfpYePq6orOzk6T62Frv3b0kre3N+OUbW1tRXBwMGJiYnRslUgkCAkJQU1NTb9l3iw9JDcijnTfmgO13344ku1hYWGMU50tttR8tgtTAICbm5tZdrC1v6GhAWFhYXqaHxQUhNjYWOaDBOjpaQ8NDUV1dXW/ZXI4HIed+kTpH0e6b82BvufbD0eyPSwsDAKBwCSHuK3sl8lkJmt+R0eHyfWwtb+pqQmhoaHw9vZmRre2tbUhMDBQT/OdnJwQHh6OysrKfsu82d7zqSPKTvB4PJMi+Dsa1H774Wi2+/r6orGxkXV6W9kvkUhYP3C00zTc3d1Nroet/UqlklkimhCCq1evor6+3mhvDpt2vNkeUEMFNqM/He2+NRU29nO5XIf9aB7K7e9otvv5+aG2tpZ1elvZ7+zsjLa2NlZpCSGoqamBp6enyfWYq/nXrl1DbW2t0VFbvr6+aG5u7rdMR9X8zZs3IyUlBW5ubnBzc8PYsWOxd+9ee5vlUDjafWsqbDXfURnK7d+f7ZrCU4NsDeDv7+8Qmu/i4mKS5ldVVZkcBxawTPP7huLojbe3N1pbWwcs1xHfo2yl+XRqnp2wJHilI8DGfkd+QA3l9nc02z09PdHU1ISAgABW6W1hPyEEbW1tOvOz+6O9vR2enp5mPSjZ2q/t+bh06RLUajWioqL6XQGDzQcHl8ul0zSGKI5235oK1Xz74Wi2e3l5obm5mXUwVVtpfktLC+uYeVKpFG5ubjbV/NDQUEbzNRoNIiIizOrs6I12ep+jERISgk2bNiE2NhaEEHz++edYsGABLly4gOTkZHubZ3PYaJ2j3bemwtZ+Rx0RNZTbvz/buTFjBtGSHnx8fNDc3IywsDBW6W2l+c3Nzaxj5nV2dsLV1ZX1Aka9YWt/cHAwqqqqGM0PDw+Hh4eHyfX1Rju9z9GwleZTR5Sd6OrqAgCLIuvbE7b2O+oDyt7tL5PJsH//fly7dg27du3S299fu2kdEYaE0pQPQbbnZqAy29raEBAQwFqIbNH29fX1Jq0q5O7ujpKSErPqMsX+kJAQk1a+cHZ2hkwm0xnO2xuBQGDWMGOK/bG35lgKtd8ybgTN12g04HK56OjogLe3N1JSUliVZ4u2b2hoMGn1UFdXV7NXe7Wl5ru4uEAqlRqNScLn802aBjlYzJs3T+f3q6++is2bN+PUqVM3hSOKDfbWHEuh9luGXC7H3r17ja4+NxQ0X4tUKoW7uzvrIOG2aPumpib4+/uzTu/i4mJW+A3ANPuDg4NN+v5wc3NDe3u70Y7pm03zqSPKThj70BwqUPstQygUQqlU4vnnnzc5b38PKHugUqnw3XffMR8pA2GLtq+trcXw4cNNyuPr64u6ujqTHmyAba8dHx8fNDQ0GO3xqa+vh5+fn83qp5gHm5c9e2uOpbC131E7H+zd/k5OTlAoFDeE5ms0GnzzzTd21fyamhoMGzbMpDza6SVsR+9qseW1o52SbcwR1dDQAG9vb5vV3xulUon29nadbSKRaMCPMbVajR9++AGdnZ0YO3asLU0cUthbcyyFjf2OPB3b3u0vFAohl8tvGM3/+uuv7ar51dXVJjs8AgMDUV1djaCgIJPy2Vrza2trjTqi6uvrzZpOaA6OoPnUEWUntBHxHUVkTIWN/Y48TcPe7c/n880eemlv2/vC5/MxYcIE7NixA0uXLh0wvbXt1wYvNPV6Cw4OxoULF+Dn52dSHA5btr+rqyvKysr0thNCUFlZCaVSCVdXV6vXS7E9jnbfmgrVfMvgcrlmO+nsbXtfuFwuJkyYgO3bt+P2228fML217e/q6oJEIjF5ml1gYCAuXLgAf39/h9F8FxcXo6NzKysrIZfL+53SzYZbX10MN0n/KwW6/mMztm/fjmXLlulsX79+PTZs2GAwz6VLlzB27FjI5XK4uLhg586dSEpKssjWGwlHu29NhdpvGZY8D+1te1+4XC4mTZpkN83XrnZqqub7+/vjwoULCAwMdBjNl0gkRkdqVVVVQSaTsZ5ybowJGxfB27V/Z5r7ix9j586duPPOO3W2D7bmO+5b4w0OIcRhexHYwNZ+Rz1GR2h/Hx8fZGdnm5zPEWzvi5OTE+sgsNa2X6VSmf2wiIiIQHl5uUl5bNn+hh6ULS0tyMnJgZOTExISEmxSL8X2OOJ9awps7XfUEVGO0P4+Pj44ffq0yfkcwfa+SCSSIan5kZGRKC0tNSnPYLd/a2srLly4AKFQiMTExEGrd+nSpWhra9P5W7dundH08fHxyMnJwenTp/HII49g5cqVyM/PHzR77QkbnXPE+9YU2NjvyJ0PjtD+fn5+OHnypMn5HMH2vri4uLDuCLW2/Wq1GgKBwKy8UVFRJofiGOz2b2trw4ULF8Dn8wfVmb9o0SK7az4dEWVl2IqyvYeMWgrbIbuOiiO0/4QJE7B3715kZGSYlM8RbO9LbW0t67gY1rZfKBQy87lNxdPTE+Xl5ayDHwK2b3+JRIK2tjYoFArU1tbCyckJaWlpNq2TYnsc8b41BWq/5UycOBE///wzRo8ebVI+R7C9L0NV8z08PAyOOu0PW7e/i4sLWltboVKpUFNTA5FIZBfNFwgEJo2+EgqFzIqAI0eORHZ2Nv79739jy5YttjJxSOGI960pUPstZ8KECfj5559NzucItvelpqYGoaGhrNI6kua7u7ub3Plg6/Z3c3NDS0sL1Go1amtrIRAIkJqaOuirpDqC5lNHlJ3QDsuzNLq+vWBjPyEEFy9eRHd39yBZxR5L5l9rV0BLT0+3yIbc3FzWgf9644jXjru7O+rr61mltbb9PB7PomvM2dkZXV1dEIvFrNLbuv3Dw8PxzTffYNq0aUhOTnZohy6lBzbnyBHvW1NgYz+Hw0FeXp5DrvhiqeZHRERg1KhRFtlw8eLFG0bz3dzcUFVVxSqto2m+q6srOjs74ezszCq9rds/NDQUX3/9NaZPnz6kNV+j0Tjk+569cMT71hTY2p+Xl+eQI2Et1fzw8HCTO4r7kp+fb3IsO8Axrx1TFvmxtv1cLhdKpdLs/O7u7ujo6GA9osvW7R8SEoKvvvoK06dPR2JiolmruToC1tB86oiyE0N1FQotbOzncDgYNmwY5s6dOwgWmYbWs87W+dCXvLw8fPPNN4iIiMDw4cPR3NyMa9euQSqV6qTjcrkYOXKkwZ7j4uJisx5yjnjthIaGIjs7m9XxWNt+gUDAxF8x5wXe09MTra2trK8FW7d/SUkJkpOTTVoRiuL4OOJ9awpsNT8pKQkLFiwYBItMw1qaHxYWhhEjRqC1tRVXrlwxqPlpaWkGl7kuKirSi8HDBke8dkJCQnDmzBlWaa1tP5/PB4/Hs1jz2TqibN3+FRUVSExMHFKav27dOsyePRthYWHo6OjA119/jT/++AP79++3t2kOgyPet6bA1v7k5OQbUvOvXLnCWvNTU1MNjqy/du3aDaP5QUFBOHHiBKu01rafx+MxsXXNcdpoNZ+tI8rW7V9ZWYmEhASTg6jbE1tpPnVE2QlH7D0wBTb2WxKc1dZYaldycjKSk5NRVlaGo0ePwtnZGaNHj9Yb4qhSqXDkyBGcOnUKAQEBGDZsGDw8PHD27FkMHz7crJdoR2xTLpcLHx8fHD9+HGPHju33uGxhf2hoKMrKyhAZGWlyXu0HDVts3f4FBQWYNGmSTeugDD6OeN+aws1uf1/NF4vFyMjI0OsxValU+PPPP3Hq1CkEBQUxmn/+/HnEx8ffcJp/7NgxjBs3btA1PywsDCUlJYiOjjY5r6nvJrZu/6tXr2LChAk2rcPa1NfX495770VNTQ3c3d2RkpKC/fv3Y/r06fY2zWFwxPvWFG52+xMTE5GYmIjy8vIBNf/YsWPIzs6Gn58fhg0bBi8vL1y8eBHR0dE3jOYDQEBAAP7880+MHz9+0DU/PDwcJSUlzNQwU3BEzR9qK4zaSvOpI8pOWDLE0BGg9vcQHh7eb3whPp+PqVOnAuhZejQ7OxvNzc0ICwtDcXGxWUN2HbXtJ02ahGvXrmHXrl1Qq9WYNGkSfHx89NLZwn6FQmF2r5dcLjep98MW9tfU1KChoQEuLi6QSqWs5qcrFAo0NDRAKpVCpVKBEAI+nw+JRAIvLy+jy4FT7IOj3rdsYWO/I08pGkzNnzJlCgB9zS8tLTVrap6jXjuTJk1CQUEBo/m33nor/Pz89NLZwn6lUml2HI/u7m6H0XxXV1d0dHSw0mtjmi8Wi+Hl5TWoK6p++umng1aXI8JG6xz1vmULtb+HsLAwgyNctfD5fKbzsLq6GufOndPRfHOmdDtq248fPx5FRUWM5o8fPx4BAQF66Wyl+Za85zs59b9yaN+6rE1tbS3q6+vh6uqK1tZWVrGZbgbNt8gRtWnTJqxbtw6rV6/Ge++9h+bmZqxfvx4HDhxAeXk5fH19sXDhQrz88stwd3dn8u3evRvPPvssOBwO3nnnHWbqVmlpKSIjI+Hr64uioiKdBk5NTcXChQuNLik41BjqH4nUftMJCgpihmHu3LkTSqUSFy9eREpKiknlOHLbx8fHIz4+HgqFAt9++y1zb2tf2nr3SmiHN/fe1/v/hv41RldXl9lzuVtbW03qVbd2+6vVapSWliIjIwNvvfUWVq1aNWD669evgxCCwMBA+Pv7g8/vkXKVSgWZTIaGhgaUlpaitbXVqrYaY8OGDXjppZd0tsXHx+Pq1auDUv9QwJHvWzawtd9Re3Ltrfm7du0CIQTnz583Ob6gI187sbGxiI2NhUqlwjfffIM5c+YAGBzNN7ddWlpaTBo9awvNLysrw6hRo/D222/jnnvuGTB9QUEBNBoNAgMD4efnx6wgpdX8pqYmlJWVoa2tzaq2UszHke9bNlD7Taev5gNgHbaiN47c9tHR0YiOjoZKpcLXX389aO/5MpnM7M6H1tZW1oHWAeu3v0aj0XnPv/vuuwdMf/36dVaa397eblVbBxuzHVHZ2dnYsmWLzkd0dXU1qqur8fbbbyMpKQllZWX461//iurqamzfvh1AT0/UY489hq1bt4IQgvvvvx8zZszQCSbX0dGBt99+W+/D5kZCe3M6UiA6U2BjvyP3jtu7/RctWoTLly/jxIkTCAkJgZeXF+u89radDUKhECkpKdi8eTNGjx4NLpcLQgg0Gg3kcjmTBvjfh6t2qVTt777btRiKC9LR0WF2jAKFQmHSsrDWbv/a2lrEx8eDz+fjwQcfRFNTE5qbmw0u4drY2IjKykrExcUZfCDz+Xy4ubkxPS2D+YBKTk7GoUOHdGy5WWDjfBkK921/UPstY8GCBcjPz8fx48cRFhZmcLSoMextOxv4fD5GjBiB//73vxgzZsygaP68efPMsrW7u9ukAMbWbv+6ujrExMSAz+fjgQceQFNTE/Lz8w1qflNTE8rLyxEXF2cwppU9NZ/SP0Phvu0PtvY7aueDvdu/t+aHh4cbHC1qDHvbzgY+n4+RI0fiv//9L0aPHg0ej2c1ze+LRqNBZ2cnbrvtNrNs7erqMmlElLXbv76+HtHR0eDxeHjwwQfR2NiIvLw8JCcn66Vtbm5GWVkZYmNjDTrEbjTNN+tLQSqV4q677sInn3yCV155hdk+bNgw/Pjjj8zv6OhovPrqq7j77ruhUqnA5/PR3d0NHo/HDE/Xbuv9UvDEE0/gX//6Fx577DGTbtyhhCkfvo4IW/sHEhd74QjtP2zYMERFReGPP/4wSVwdwXY2pKamwsfHB3/88QcWL17MOE60q1GwDRTLhtLSUrOWPW1paTFp6VLAeu2v0WiQk5PDOKJkMhmEQiGcnJwMDgtuampCXV2dWVN7BgM+n29wiDalh6Fy3xqD2m85SUlJiIqKwqFDh0xaxMPWtmsKT4EbM8biclJSUuDj44Pff/8dCxcuZF6ibaH5ZWVlZnV2tbW1mTydwdz279uuGo0GF37+EnUCX8THx0Mul0MoFEIsFhtceai5uRnV1dVIS0szq36KfXEEzbEEar/lJCUlISYmBvv27cP8+fNZ57O17R+cKMET40yPqdqX5ORkeHp64vfff8f8+fOZ92lbaH5FRYVZgcrb29tNtsPc9u/brhqNBuu+2IOJflzExcUx/g6xWMw463rT0tKCysrKm0rzzRqy8thjj2HOnDmYNm3agGnb2trg5ubG9I67ublh1apVCAwMRFBQEB555BG9l4IVK1YgJiYGGzduNMe8IUHv4YlDEWq/dZBIJJDJZCblcRTb2RASEoJZs2Zhz549UKlUAGxjv0gkMnkJUUIISkpK+o33Yghr2X/kyBFwOBxMnDgRgYGBzEebp6cnYmNjAQANDQ24fPkyLl68iD///BPx8fEW18sWpVKJ9vZ2nb/+2rigoABBQUGIiorCXXfdhfLy8kGzdSgwlO5bQ1D7rYOTk5PBF9D+sLXt1nBCaQkKCsJtt902KJpvajsSQlBUVDRomt+3Xf/85iOoNRpMCBEjKCiI0XwPDw/ExcUB6Bn1qtX8I0eOICEhweR6KbaH7YI9jqA55kLttw5CoRAKhcKkPLa23RpOKC1BQUGYO3cu9u7d63Dv+QBQWFho8kJG5trft12f2bIdapUK+aJwBAcH62i+9n1eq/mXLl3C4cOHkZiYaHK9QxmTR0R9++23OH/+PLKzswdM29jYiJdffhkPP/ywzvb169fjqaeeApfLNdgzxeFwsGnTJsybNw9PP/20WauiODram8ncwGv2ho39jvAAMIYjtb+npyfKy8v7DYbYG0eynQ0+Pj4YN24cfvjhB2RmZsLb2xuAde339vbGlStX4OXlxXpk1NWrVxEdHW3ySCprtL9cLkdnZycmT57MbOs91a66uhr19fXw8/NDcnIyOByOybHEjJF/Lg1OA0yb65bl4/vvv8eiRYt0tq9fv95gnL7Ro0dj27ZtiI+PR01NDV566SVMmDABly9fHtRgio7MULtv+0Lttx5eXl4oKytj7RBxJNvZ4OXlhfHjx+OHH35Aeno6/P39AVhf8/Py8uDj48Naw69du4aoqCiT302s0f7d3d2Quodh4pw5jL29y6upqUFdXR18fX2RlJQELpdrNc2n2Iehdt/2hdpvPXx8fFBUVMT6e9aRbGeDh4cHJk6ciB9//BEpKSkIDAwEYF37vby8cOnSJfj6+pqk+ZGRkXbRfIVCgakhYsyZM4epv3d5tbW1qK2thY+PD6P5w4cPN7u+oYpJjqiKigqsXr0aBw8eHHCuZXt7O+bMmYOkpCSDHy69g5cbYubMmRg/fjxeeOEFfP3116aYiYsXL8LDwwMKhYJZmp0QwnhTBQIBNBoN1Go10zvJ4/HA5XKhVCqZbVwuF3w+HwqFAkKhECqVChqNhtnP5/NBCNErRy6Xo7W1Fc7OzpDJZOBwOHBycoJMJoNYLIZCoYBKpYKzszNaW1uZaYkKhYJZNYvP54PP50Mul0MikTA9f2KxGJ2dnXBycoJKpYJKpWLyGCqHx+NBKBSiq6uLKYcQAolEwpSjVquhVCqZPAKBAFwuF93d3QbLEYvF0Gg00Gg0UKlUkEqlEIlE0Gg0euWoVKoB20KtVvd7DL3bwlA5bNuidzkCgQByuRxtbW06bdG3nIHawlCbGmsLbTl9jyEtLQ379u3DhAkT4OrqyuQxVA6fzwePx0N3dzeUSqVV2sLYdWGN60t7DBKJBMuWLcN3333HiHJra6vR66vvdWGsTbX3m7OzMzw8PHDp0iUkJCQMeH3V1tZCJBKBEMK0h7acrq4uADDapiqVCgKBADKZzOR7TVtOQ0MDfHx8kJ2dDW9vb2g0GnR1dTH64+TkhIiICIjFYkilUmg0Gjg7O/fbFoaur4aGBpO0sze33347PvroI51txlaamj17NvP/lJQUjB49GuHh4fj+++/xwAMPmG0DW6jmU80fSpqfmpqK/fv3A+h5F6Kab57ma5dIT0xMHPD6qqurY0bm20Pzm5qa4O3tjbNnz8LLywuEEEbzxWIxhEIho/mdnZ1ma35jY6PN9dYRsLfmy2QyqvlU81lrfkpKCg4ePAgulwtPT88bUvOdnJywZMkSm2q+t7c3cnNzkZSUNOD1VV9fDy6XCw6HYxfNb25uho+PD86dO8fEAe7q6mKuDz6fbxXNb2pqGgzJtRkmuQjPnTuH+vp6pKenMxf4kSNH8P7774PP50OtVgPoCSI5a9YsuLq6YufOnWbPtdy0aRO+++47XLhwwaR8SqWS+Tt27BhzUahUKp19/f2xSWusTDZDdru6ukyekuVIdHV1MTdyfzhqEEO29g8GXC4X8+bNw8mTJ1mll8lkDmO7qXC5XJu1vYeHB6tylUolqqurWY9A64ul9tfW1kImkyEhIQGJiYkQiUTgcDiIi4tDQEAAqqurERwcbFbZarUalZWVuHr1Kq5evaoTPNxUBAIBExBR+8d2yXPtVJPCwkKz6zcFe2s+m1h4N4vmOyqOZD+Xy8XcuXOp5luIu7s7q+l5SqUSVVVViIiIMKseS+2vq6uDVCpFYmIiEhMTIRaLdTS/srISISEhZpWtVqtRVVXFaP6BAwfMtnMoQTXf9jiSZpqDI9mv1fzTp0+zSk813zDu7u6spuepVCpUVlbaTfPr6+vR3t6uo/kAEBMTg6CgIFRUVJi0il9v+mq+tlNrqGLSiKipU6fi0qVLOttWrVqFhIQErF27FjweD+3t7Zg5cyZEIhF2795tUpT6vmRmZmLx4sV4/vnnTco3cuRIJmBabW2tyctmWkpFRQUTab/3yC+tl1Y7EgOATqBk7dSc3lH6te3XO5i7oSj+vbcZKkf7AWlKOdobx1A52uk2fD6/33J67zfWFmyPQdsWhsoxdgzGymlvb4dQKGTa35K2MKdNDR2D1pM+UJtqNBqIxWIIBAKrtIWpx2Du9XXt2jUEBgYyQQMNtb22HGPXhaFtva+LkJAQtLe3MytS9S2nsbER5eXlyMzM1GtnbTm9HeeG2lTb5hKJxOS2aGpqAp/P14n7oZ0z3tHRAYFAwMTeY9sWrq6uqK6uRktLC/h8PgIDAxEREQEOh4OioiK99IOBVCpFUVHRgMuSW4veml9TUzPoml9VVUU1//9vEwqFVPNZar625/VG1fyCggL4+/vbVPNDQ0PR2trKLGzjaJrf3NwMLpeLESNGMPu0mq/tpZ8+fbpJbeHq6oqamho0Nzczmh8eHg4Oh4OCggK99DcivTW/urqavueDav5Q0Hw3NzfI5XJ4eHjckJpfVFQEPz8/m2p+eHg4mpubmcVx+pbT3NyM0tJSZGRkQCAQDLrmt7a2AoDOwkK9F+7gcrkma76bmxuqq6vR3NwMHo93Q2m+SY4oV1dXDBs2TGebdqjcsGHD0N7ejhkzZkAmk+Grr75iAtwCgK+vr1nR7l999VUkJyffcEuBW+KgcwSo/dYnPT0dBQUFAy7r7Yi2D0R1dTXy8/OxaNEik4M2mkJQUBB2796NSZMmMQ8SQggqKytRVVWF3Nxc+Pv7o6KigsnTd9Re37nkffdrXy7Ly8uRkpICpVLJDHvvnV5bTu/8crkc6enpkMvleuexqakJGo0Gvr6+rI5VLpejuLgYGo0GwcHBZveuWINnn30W8+bNQ3h4OKqrq7F+/XrweDysWLFi0G0xZ/XEwWAo3re9YWu/o46CdcT2HzVqFK5evYrx48f3m84RbR+I2tpaXLx4EYsWLWIC2NqCoKAg7Nq1CxMnTmRe4LWaX11djfPnzyMwMNAqml9WVoYRI0boab42jyHN7+rq6lfzlUol69WhtZqvVqsRHBxs9igqiuWwiTkzFO/b3lDNtz6ZmZm4fPnygCsMO6LtA9HY2IgLFy5g8eLFNtX8gIAAg5pfVVWF6upqnDt3zmqab+w9v3ceLperp/lpaWnMFMTeNDc3Qy6XM3ETB6K7uxvFxcVQqVQ3rOZb1btz/vx5ZthhTEyMzr6SkhKzhsjFxcXh/vvvx8cff2wNEx0G7XBdQ57YoQC13/r0fpHtD0e0vT8UCgUOHTqE5cuXA7Ct/RwOByqVCvX19ToPoaCgIIwZMwZjxli+OpS2t+PAgQPMNGWhUAg+n8/q/CkUChQVFUGpVCIkJASenp7o6upirY/alZ8UCgViYmIc4jqorKzEihUr0NTUBF9fX4wfPx6nTp1i7VS7GRhq921fqP3WR6VSsXKcOqLt/aFSqXDo0CEsXboUXC7X5var1Wo0NjaisrKS2RYYGIjRo0dj9OjRFpev1fyDBw+arfnFxcVQKBQIDg6Gl5cXurq6WAerJ4SguLgYcrkcsbGxQ+Y6GCwcdWGcoXbf9oWt/bT92aMdATsQjmh7f6hUKuzbtw+LFy8eFM3XaDR6mh8QEIDMzExkZmZaXL5W83/77TekpaVBIBCYpPlKpZJ5Tw8KCoKPjw9kMhnrDmPtqt5dXV2IiYlhHRZjKGKxI+qPP/5g/j9p0iRW86aNERERYTD/li1bsGXLFrPKdFRP/VBZCcEY1H7rExAQgH379iE2NpYJbGcIR7TdEJWVlbh06RI6Oztx2223MQ8kW9vP5XIRGxtrs/K19otEIoNDaAdCKBQyy7MWFBTgzJkzaGlpgZ+fHyZOnMi8pKjVajQ3N6O1tVVnFJlSqURERIRZdduKb7/91t4m2BU2z5mhct8ag9pvfQICArBnzx7Ex8f3OxLWEW03hFbztXFCtb36trafw+HodX5aE639vacgmYJQKGSmYxcWFiI7OxstLS3w8fHB5MmTWWl+eHg4PD09LT8YyqAxVO5bY1D7rY+fnx9++eUXJCQk3BCaX11djdzcXHR0dGDGjBnMNLbBeM8fDM3n8/lm6a5AIGA0v6ioCOfOnUNzczO8vLwwdepUVpofFhaGqKgoKxyNY3NjzXcbQmgvuKHq5aT2Wx+hUIjly5dj3759uP32242mc0TbgR67fvvtNyZ4rJ+fH2655Rad+AjadIDj2c8Wrf3WcHIrlUpIJBKEh4eDx+PhypUrjDOez+fD29sbYWFhOr1Kjjr1zFFw1M6HG+W6p/ZbDz6fjzvvvBN79uwZkpqvUqlw8OBBHc0fO3asnrPGUe1ni7U1XywWIywsDHw+X0/zvby8qObfINwo1z2133pwuVwsX74cv/76K+644w6j6RzRdqBH83/77TdmxJOvr69dNN/W73nW1HyVSgUnJyeMGDFCT/N5PB68vb0RGhqq01Y3k+ZTR5QNYDNsT7vC4FCF2m8b3NzcmJVWtD0LfXFU248ePYrhw4cPOIfZ1vbbepi41n5r1JOUlGRxGZShgaPet2yh9tsGFxcXyOVySKVSJqBpXxzV9j///BPJyckDrkBKNf9/aFdRotz4OOp9yxZqv21wcXGBUqlEe3u7XketFke1/cSJ/8fem4c3cd1tw7dGiy3vG94wXsC7wRgDjm3WAIawQ0IgW7OWpq1Dt7x5GtpmafP0bd6nzfO1TWiakL2BhITEIQkQ4rCDMRgbs28GGzDYFsbImyRrGX1/yGc8MxqtlizJ6L4uLqxZztxzdHTPnN/5LVXIzs62GVbsrfzthSs1PysrC1lZWYNuZ7jCb4jyECy9cPoK/Pzdh8jISPT09Fg0RHkrd5FIxEnkZwneyt9e+Dp/PzwDXx83fv7uQ0xMjFVDlND216saOZ/XlKa5hZs1UBRlVyltb+57e+Dr/Ic7vNUL1tfHjb38/f3vOKL6bkJ5fA/Cpi0R3O+t3Nn5n6zBW/nbC1fwpxuqQaUPPi/tcId3ZphzIbw1iV5PTw96eno8TcNp2MvfW90Lvbn/Z82ahWPHjlnc763cZ82aherqapvVMtzN390vRd7a/354N3x93Pj5uw8zZ850WvPXlKZZNEK9XtVoZrByJWbOnImjR4/arIQ6XDTfWyfcfgw97BkL3qw59sD/nu8e0A3VmPXwz3Cq27IviLdynzp1Kk6ePMmEY1uCt/K3F67QfL8Ryj74PaLcgI6ODmzZssXqMWSybqt6Qmtrq80yn56AvfyvXLlisy/s/aGTnEOugLfFXbMREhJidcXBm7mTlX1rCV3dzd/dxmfC3z8p8U54YvFBqVT6Nb8fV69e9Wu+gwgKCrL6Yi/E3R4PqKHwkoqNjUVXV5fVxLvDRfP98IOgq6vLr/n9cKXmk6q7roC3/m6p9GIEAlYjCKxxpxuqmXY8gZiYGCiVSqtj1lv73l74On9fgt8Q5QY88cQTNo/p7e0FAAQHB1s9bsuWLVi6dKlLeLkS9vJ3JWw96ByBLxsRvJW7Xq9HR0eHzapC7ubv6+374Xvwa7574Nd8E7yVO03TUCgUVo1Q5Dh38/Dl9n0Nf/nLX/Dll1/i3LlzkMvlKC0txf/7f//vjsqD8thjj9k8xl7NrKio8Gt+PyoqKlzWlrf/bq3xs7TP00YomqbR1taGWbNm2TzOl+Hr/F0Nd2q+d8atuRDeOph0Op1d+XS8FZ7g78rv0pv739Z9eiv37777DjNmzLB5nLfytxe+zt8Pz8DXx42fv/tA07RV3fdW7t6i+e72iPLW/vcU9u7di/LyclRXV6OyshI6nQ5z585lDBd+mODr48YT/F35Wx4q/nRDNWMgsvucQWi+J0O+duzYYZeX8nDRfG9N7zPUcKfm+z2iPAR/IjfPwpv50zRtNUxjsNzZDz/+w5D92dL/MpmMk0hdpVLhhx9+QFJSkl3u5d7c9/bAV/hrtVp0dXV5moYf/fCVcWMJfv7uhTdrvkQi4XBQqVTYtWsX4uPjkZiYaPP63t73tjAY/iRH11CESWq12iHJy/Ldd99xPn/wwQeIjY1FbW0tpk+f7vbr8+Gtk8U7edx7A4aKv7OGIY1GA5qmBcevJe72XsvVmq/RaLBr1y6MGDHCZpVUa/x9BYS/tzqzEAwHzfcbojwEMnBshTF5K/z83QeJRIKCggL86U9/wrhx4zj7KIpiJiwymcyp9slDTyQSMX+zt7E/C+1vbm7GlClTMGbMGJw/fx7Hjx/H9OnT7c5x4M19bw98IQGjRqPBRx995LVJRN0Jb31xGC7jfij5u/K79Ob+pygKkyZNwh//+Efk5+eb7bOl+RRFWe0rV2h+SUkJMjIycOnSJRw9ehTTpk2zywgFuL/vhyJZuTNwZ6J4PrRaLT744AMYjUan2yAl5dkICAiwmS+ls7MTABAVFeX0tYcjvFlz7IGfv/tAURTuuusu/OlPf8L48eM52wF4/D3/xo0bmDx5MrKystDY2Ijq6mrMmDFj2Go+v8KdL7zn6/V6vP/++zAYDE634Q2a7zdEeQi2kv95O/z83YucnBzk5eVh4cKFZg8iIpCeWnGgaRo7d+7E9evX0dPTgyVLliAwMNDu893d9+5eHSX8vXUVFgACAwMRERExqAeUH66Ft2uOLfj5uxdZWVnIz8/H/PnzIWuu5+xTxY8F4FnN3717N65fvw61Wo2FCxc6xMXb+54Ndg4WMjlxVvOHwguKQCaTWdR8+cRZkIdaz/NDBW/A5s2bcf/993O2v/TSS3j55ZctnkfTNH71q19hypQpGDt2rFPchyt8adwLwc/fvUhPT8eECRNQVlaGd+vbOPueyB8BwLOav2fPHly/fh0GgwELFy5EWFiY3ed7e9+z8XpVI8pjB/5eU5rmE/wlEgkiIyMFQyDlhTMhjwy3ej4VsgkVFRV46KGHONuHWvO9dyblInjrZFEikfjEQLcET/B35XfpC/2fnZ2NEydOmG33NHeKolBWVgaxWIwLFy44vGLjbv7uXh0n/L3V84ZALBZ7Pcc7CZ7+3Q4Wfv7uA/Gcyc7OxsmTJ5ntVHoxYwjxtObPnj0bcrkcZ8+edWjhAfDuvhcCWRkn//uS5g8GK1asQGdnJ+ff2rVrrZ5TXl6OU6dO4dNPPx3UtYcjfG3c8+EJ/q78jflC/+fm5uL48ePM5zWlaYwhxNOaP2vWLISFheH48eOcdBz2wNP8HQXRerJ44Cv8B6v5y5cv97jme6eV5g6ARqOxmhPC2+Hn737k5eXh9u3b2LZtG2e7t3DX6XRYuXKlwwZCb+HvLAh/bzVyAwNll/3wHtg77r11sjtcfrfeCPLym5OTA6VSiW3n2jlhAt7CXafTYcWKFQ6/oHsLf3sglIPFF/jTNA2j0Tgo/ZBKpQgLC+P8sxai8cwzz+Dbb7/F7t27kZSU5PR1Bwu/ZroHfv6Ow9Gk5RkZGVCpVEhpP8nxoPSWvtfpdLj//vuHteavKU1jEs6T788X+BPNH8xcxBs033tnUsMcwcHBQ1oS1dXw8x8alJWVITY2FmfPnmW2eQv3zs5Ou+PF2fAW/s7CF/jX1NSgoKDA0zT8YMEXxo01eIK/K429vtL/ZWVlSEpKwoltG5iXYm/hfvPmTbsS1fLhbv6uGCfWKl95S/9bQ21trVlOSXfBaDTimWeeQUVFBXbt2oW0tKELQfQl+MK4sQY/f8fhTOLy2bNnIzU1Fc9/tJ3xjvWWvm9tbUVKSorD53mz5hOd5xuf2PCW/reGuro65OXlDYkh3p2a7/1+Z8MUKpUKABAebj2G01vhCf49PT24ceOGy9oCfKOyw4gRI1BRUYG0tDQEBgZ6zdgRi8XQarUOh+Z5C39nQfh76yosTdO4evUqSkpKcOTIEU/TGXJ4q6facBn3fs13PyI6m/DVwaMYnZSAEHjP2AkICIBKpXI4TMPd/O3VYn5CWlvbCQh/b0ZDQwMefPBBHD161O3XKi8vx8aNG7FlyxaEhoaitbUVgOn7lcvlbr++r8BbfrfOwhP8VSrVHan5FZe6cKG2CtGJowB4z9gJDAxET0+Pw33oLZqv0WjMQslJ/j/2Zz58QfMvXryIBx98EHV1dW6/ljs1f9gborx1sujr1aw8wf/27du4cuWKS9oiLpeO5rrwFHJzc/Hll18iOTkZY8eO9YrQq9TUVFy4cMHhZHXDZex7q8GjtraWqbzlrfp3J2K4jPuhRFdX152p+bI45M6Yj29Ot2Gkch/y8/O9QvPT0tLQ0NBgVtnPFrxl7FsyNtnyYvAW/pZQV1fHfCdD8Vx68803AQAzZ87kbH///ffx+OOPu/36vgJvHze24An+nZ2dPqv5dPMpAACV5HgC57nxYpQsnIZbN09iz552FBQUuEzz2QUYHEV6ejouXLiAwsJCh87z5NhnG5lkACBw3/Zqvre+5584cQJ5eXlDdj13av6wN0R5K3ziZdgKPMF/1KhRKCkpcUlbWq0WgPOlUT2FS5cuobKyEgaDAbm5uQ5PCFyJ7OxsfPXVVw4botw9dtz94CD8vdXI09jYiJUrV3qahh88+DXfcSQmJt6xmk83VIOaOxeNjY2orKyE0WhEenq6wxMCVyIrKwtffvmlw88d/9h3LxoaGhjNH6owDW+Ct04WvX3c2IIn+CckJPiw5g+O9+tVjVjD0/zRo0dj0qRJTrVny+vHHowZMwZffvmlw88dd48duuW8RU9WZ++VDW//7Z47d47R/KHQP3dqvneq9x0AlUrlE65/luDn7xmMGTMGZWVlCAsLQ1tbm+0T3AiJRILY2FiH3UJ9te8JvJl/e3s7oqOjmc+dnZ0eZOMHG948buyBJ/i7clLtDv6OJqa1t012u2lpaYzm37x50+XXcwQURSE+Pt7h8C93jx1rL+KOfkdCOUO8+berVCoRGRnJfPZrvvfAm8eNPfDzNwfJ4eTqNtntEs2PiIjArVu3nGrTFUYowKStCQkJOHz4sEPnDYXmW7ovR78jfv8DA/y9ccG5q6sLoaGhzGdf13y/IcpDCAwM9HqLqzV4gr8rBcGX+//EiROIi4tDWVmZp6lg+vTpUKlU2Llzp93nuLvv3f3g8Oaxc+TIEWRkZDCfH3nkEQ+y8Qy88cUB8O5xYw/8/M3BfxEWeqEdbJsAcOrUKURHR2PevHmDatsVmDp1Kvr6+lBZWWn3OZ7WfGuJyPnHAebfAeHvjZ43hw4dQmZmJvP5TtR8b4VfMz0Ld/BnV7ZzZ5tnzpxBaGioU5rP1jFXeAdNmTIFNE1jx44ddp8z2L63qdlxGZb3wf5nMTmG/x3Y4u+ORSh7cejQIWRnZzOfH3roIY9xcQUceqq++eabyM/PZ0r8lZSUYPv27cz+S5cuYfny5RgxYgTCwsKwcuVKM6+NQ4cOoaCgAKmpqXj33Xc5+0QiEQIDA83ig5ctWzbs4s71er1X5HxwFn7+noNCoXCqWp27MHXqVCQmJmLTpk12rYD4ct8DA/y9aVLS1dWFzz77DMnJyU5VtfLD/Rgu495XMRT815SmuWSiwp9AtLa2epXmT5kyBcnJyV6r+exJDOlHWxMya3lUvHHs9/T04LPPPsPIkSOdqmo1nOCtiw/eOG4cgZ+/c3DGSMF/drS0tDj1LjeYfFDWUFJSgvT0dHzyySdMEnhrGOq+ZxueSD/aehZbMkIB5vz5hjFX96896OnpwebNm5GQkDCsKpU6lCMqKSkJr776KjIyMmA0GvHhhx9i6dKlOHbsGFJTUzF37lyMHz8eu3btAgC88MILWLx4Maqrq5lJ21NPPYVXXnkFCQkJePTRRzF37lyMGjWKuYZIJMKLL76IDz/80CU36E2TRTZ8WdwBP39PYsqUKaisrMQ999yD2NhYT9MBAOTk5GDkyJHYsmULSktLrb4Yu7vv3f1SSvh78uWXpmmcOXMGiYmJOHbsGLq6urBo0SKHq1n5MXTwZc0B/Pw9iWnTpmHHjh2YO3cu4uPjPU0HgClfFNH84uJiqy/Gruh7axMsvhaTY0gOEXsmDdaO8QbNB4DTp08jISEB9fX1uH37NhYsWOATFcHuVPiy5gB+/s7CFUaK6dOnY/v27ZgzZ45DixDuNJCMGTMGcXFx+Oabb1BUVIQxY8ZYPHawfU+lF5sMRYpGuxZ3yDGvVzXavSBk7Rg+f08YngBzzb/nnnuGneY7ZKVZvHgxFixYgIyMDGRmZuLPf/4zQkJCUF1djYMHD6KpqQkffPABxo0bh3HjxuHDDz/E0aNHGcMUAPT29qKwsBDjx49HZGQkuru7Odd45pln8PHHH+PUqVOuuUMvRUhIiE8PJj9/z2HEiBFYuXKlQ+FwQ4GwsDA8+OCDqKmpsVp+1519f/r0aU6+DHeA8PeUkVuhUGDz5s1Qq9U4duwYcnJysHz5cr8Rysvhy5oD+Pl7EtHR0V6p+SEhIUz56ObmZqvHDabvrRmhzp49i4iICIvnuCKEwtOa397ejs2bN0OlUuHYsWPIzMzEfffd57Pj+U6BL2sO4Bn+rvyN+XL/R0ZG4oEHHsDu3bs9TYUDovknTpzA1atXrR43mL63FlZ38eJFwfddco4r8nh5euy0t7fjiy++QE9Pz7DXfKd/8QaDAZ9++il6e3tRUlKCvr4+iEQiBAQEMMeQmPoDBw4w21588UXk5OQgPDwcxcXFyM3N5bQ7ZcoULFq0CM8//7yz1HwCPT09drk3eiv8/D2Hnp4eaDQaFBQUoKKiwuuSSd57773YvXs3urq6BPe7s+8bGhpQVFTklrYJCH9PVA5SKBTYs2cP5syZg8mTJ2P27NleFbLjDfBWL1hf1hzAz9+TIJo/adIk5uXUm7B8+XLs378fSqVScP9g+96aV9OlS5cwceJEzjZXh1B4UvPb29uxc+dOzJo1i9H8pKSkIefhh+PwZc0BPMPflV6Hvtz/PT09UKlUKCoq8krNX7p0KQ4ePOg2zSdeTUJeSxcvXsTkyZM524jxqTy2DeWxgy/k5Mmx09HRgcrKSsyYMQN33XXXsNd8h0LzAODkyZMoKSmBRqNBSEgIKioqkJubixEjRiA4OBi//e1v8X//7/+F0WjE888/D4PBgJaWFub8p556Cg888AC0Wq1Fz4W//OUvyM/Px/79+zFt2jTn786L4SslpC3Bz99zINxzcnIQFxeHzZs3Y8GCBYiJifEwMxMoisLixYtx4MABLFiwwGy/O/u+r6/P7Z5BMpkMNE3j9OnT6Ovrg1wuh8FgQEpKiltLq9M0je+++w4rV6706QSidyp8WXMAz/B3pVHRl/ufcM/KysKIESPw1VdfYe7cuYKh2ZZKWrsTRPP37NmDRYsWme13pu/tvQ+VSsVZJe7d+ArkRaZCHq7qB6L5Z86c4Wj+qFGjnC6tbg+I5t97771+j1cfhL3j3lsXT/ya7zkQ7hkZGYiOjsZXX32FWbNmCS48knC0oQRFUVi6dCl++OEHLFmyxGy/M31v732oVCqEhYVxznOF8YkNwv/s2bPQarWM5iclJZkZwVyNbdu2YdmyZcPS+0kIDhuisrKyUF9fj87OTmzevBmPPfYY9u7di9zcXHz++ef42c9+hn/+85+gKAoPPvggCgsLzYQlODgYwcHBFq+Rm5uLRx99FM8//zwOHjzo8E11d3cjICAAarUaOp0OXV1dMBqNCAoKQm9vLwICAkDTNHQ6HUJCQtDT0wOpVAqKotDX14eQkBD09vaCoijIZDKo1WrI5XJotVoYDAbmHKF2JBIJJBIJNBoNgoODoVKpmCTsKpWKaaenpwfBwcFQKpXMgNdqtWbtaLVaaLVaaDQaAIBcLkdvby8CAwOZZGrkHKF2xGIxcw9BQUHQaDScvggMDITBYLDaF/x25HI5enp6YDAYIJPJLPYFux1rfcHuU1t9odPpzNqxty/Y3w1gMlrodDpOX/DbsdUXQn3qqr6wNL60Wi36+voglUohFosxatQodHd3QyKRONUXlsbFYMfX7du3oVQqodPpIJVKmXNIom9L7djbF+T+2b+18ePH44cffkBRUZHD44u0o1arAcDi+Ors7IRGo8G4ceMwffp0yGQyaLVanDlzBtu3b0dJSYndfWrPb+3cuXM4deoU5s2bB7FYDKPRiN7eXrvGl1ardVg/fRFszTcYDH7NHyaar9Fo/JovoPnJycno7u6GTCYzv4eYbMj6vWSHWvO7urrQ0dEBg8EAsViMsLAwhzU/qO00etRaBEjFgIDO8TV/woQJJs2PD4A8QAr9uOnoislGSEgIumz81uzV/Lf2nUGfpg/XpCPw83nzGM0/d+4ctm7diilTprhU8y9cuIDjx4/jnnvuAWDKnerXfC78mu/X/DtB88VXj0GcMBYpKSno6emBUqk0u4cf5UYykRFDrfk9PT2D1vyPTraD1qohkkgFdU5I87///nuUlpbioxNteCyyFcoeGiHyAPSo+yCTikGpVIN+z9dqtcjOzsasWbMYzb9w4QK+/fZbTJ061aWa39DQgGPHjuGee+4BTdMQi8V3jOY7bIiSyWRIT08HAEycOBE1NTX4xz/+gbfeegtz587FpUuX0N7eDolEgoiICMTHx2P06NEOE/vjH/+IzMxMfPXVVw6f6wvQ6XTQarWQSBz+CrwCWq12yBN3unKlhPS/L3qW6HQ66HQ6T9OwiRkzZmDbtm0IDg6GRqMBRVEYMWIEMjMzQVGUW/o+ISEBx48fd3m7bOh0OvT19aG1tRUAmAfUuHHjsG/fPly/fh0ZGdZLy9qLtrY2nD9/HtOmTcPHH3+M0tJSl7Trx9DDr/mOw9c1n758FBg5btDtCGm+J8LEbGHmzJn47rvvOJofHR2N7OxsuzSfbjoGyE0TIWr0ZJvjjW6qwwiRCHUNdUB8CajRk0H1T25ciftyY7HhaCO62hUABjQ/Ly8PBw4cwLVr15CVleWSa928eROnT5/GzJkz8Z///Mev+XbAWz2K/JrvWXhC898+cgWPjR98QQmi+dSYIsDL0m+wMXPmTOzYsYMxylAUhcjISOTm5lrVfPpyDWidHh/cjAYlkwMAflKUYtd4+/aKBiePNaK0tBSrR9yEVg9QqRNAhYQAp/aDSnPMS5VuOgZkl3C2kf5vazN5WhHNz8nJwe3bt3HlyhXk5OQ4dB1LuHXrFk6cOIFZs2bhP//5D0pKSmyfNIwgMg7ybWbWrFlITk7GBx98YLZv165dmDNnDs6ePWvXQ1okEqGiogLLli0DADz33HPYunUrxowZg+joaMFrsNHV1YXw8HB0dnYybnsVFRVYvny5o7fldpCM/LYeUFu2bMHSpUuHgpJDsJe/K+HKvvAEf1eBz/3w4cMYOXKkT8QQf/zxx1i5ciUoinJb37v6N0/TNFQqFYKCgkBRFNrb2xmv0Pvuu49zrF6vx86dO5nVi3Hjxg2qzOpnn32Ge++91+m+YmuiTqdDTEwMqlc/g0Ab7d2/6WP8fx99gIULFzp13aGCkOb7umb6+jPLlXBlXwwnza+pqUFsbKzV6qTegg0bNuD++++3qPn8ZOKOhtPRDdWo+H4P7vv54PKKshOi8zX/1e11uNFwFtMTArBixQrueTSNyspKRvPz8vKsVpOyBVdqPgCEh4fjdt0PCAu1HIUAAJOXPY4X//z/vFI72RiOmu/r/F0Jv+abwOdeV1eHyMjIQb1PDhU2bNiA++67j/FCYoOt9+sUcQCsV6/jg5z/ee0VrFq1alA8OSF9o4s4mt/R0YH6+nq0t7dj5cqVXA40jZ07d6Krq8vrNF8ikSA4OBiKI98hOjLc6nmlK36M//OHl82eaUMNh+567dq1mD9/PuMWvnHjRuzZswc7duwAALz//vvIycnBiBEjcOjQIfzyl7/Er3/9a6dXitauXYv169ejsbFx0APO20CSoAlVe2HDW1cj7OXvrfBl/kLcvXWcsNHe3o4RI0YwLsTu6Pv29naXr45++eWXCA0NRVtbG6RSKYKDg5GTkyPo9SSRSDBv3jwAptXE2tpaHDlyBFFRUejq6oJcLkdRURG0Wi1Onz7NGIgmTZok2J5YLPa5l6hXX30Va9euxS9/+Uv8/e9/H/Lre+tvwZc1B/DzHywGk0Db09ydRUdHByIjI+3SfEf6hJ0/ShmVCSqhxcYZjqGiogIhISH4+OBpUBSF0NBQrFk0VfBdlqIoM80/evQoo/kBAQEoLi6GXq/H6dOncfv2bRgMBhQUFAi2J5VKfU7z/RCGr/5uCfz8Bwd29TZHczj56nu+UqlEZGQkExrJ73sqvRgajQbr61oc7hPyDO2KyYa4ffeg8iHSDdUojzUZw9aUpqGiogJBQUFob28HAISGhiIrKwuzZs0yO5eiKJSVmfIQ6vV65j0/JibGoubTNI28vDzk5eWZtXena75Dd65QKPDoo4+ipaUF4eHhyM/Px44dO5gv5Pz581i7di06OjqQmpqK3//+9/j1r3/tNLmoqCj89re/xe9+9zun2/BW+Pqg8wR/V4qwL/e/r3Lfu3cvFi9e7NZ45qqqKkaPXAWappmJBjDwgmALMpkMJSUlGD9+PFQqFfOQqqmpQUBAACZMmICYmBjQNI1PPvkEI0aM4Dy0Dx48yEnI6AuoqanBW2+9hfz8fE9T8Tr46u+WwM/fdWB739gDPneRSDRkkxJHubKxe/duLFy4kFndd6RdIcMdexuZhLhK89k8DAYDLoRmouieTNO1+tQYOXKkzTaI5k+YMAE9PT1mmj9+/HgzzY+KimLOP3TokD8puRPw1gm6N2mOM/Dzdx2IUcpe4wuf+1CGnzrKlY3du3ejbEwk6GvHQaVxq5my2xVqW8hwx9Z8bVIBZM31OLD5XcwpneySYhTkOjqdzqn3fIlEgrvuugvjx49nNL+npwdHjhyBTCbDuHHjmKIiGzZsQFxcHKew1KFDh3wyRYwr4dCv9N1337W6/9VXX8Wrr77qNBmhKMG1a9di7dq1TrfprbHj3iSQzsDP33PwRe6tra0ICwtjqg+5Azt37kRwcLDLXuQ1Gg22bNmCsWPHcrY72v9BQUEMp7CwMMyePZuzn6Io3H///fjmm28gk8kwbdo0XL9+He3t7V7prm8JPT09ePjhh7F+/Xr893//t6fpeB188XfLhp+/a+HIS7RHFn54IXOOor29HSEhIQgMDGRWx9ng37+liklCRiiybdeuXZDL5S6rLqTValFRUYG8vDy0dZm2rSlNE+RvDYGBgczkwprmb926FRKJBFOmTEFbWxsUCoVPab4f1uFtmuMoPMHflXM2T+mmJW13xLDjCe5sQ5Az6OjoQGBgIELyZwpqpr33v6Y0TfD5I2uux57qOgSk5CNiwhyHuPG/F/K3VqvFV199hezsbM7xjvY/W/NDQkIEPamI5lMUhWnTpuHmzZtobW31ylQMQwnfVkkfBvmR+qol1M/fc/BF7ocPH2ZWG9zBv66uDtHR0SgoKHBZm99++y3mz59v5pXkDv4ymQz33Xcf3nrrLdTU1CA6OhqLFy92WfvOgFQcZSMgIAABAQGCx5eXl2PhwoWYM2eO3xAlAF/83bLh5z84CBlU7MVQch9sziaCqqoqzEoNA91QDVWPqUKRLETOaZc/8eGX4SbX7t34CgAg+KEXmH319fUICwvDpEmOJaa1hm+++Qbz5s1DREQE2MsPlvp/MJ4DMpkMy5cvx9tvv43a2lpERkZ6XPP9cC08rTmDhZ+/42DrfHmssM7Zg6HkzucnpGf2eMZWVVXhbGAKGqoaYVCbPIrE8oFFAks6yfeEItciYXPEiHRi2wYEZ0zEXXfdZeedDcAS72+++QZz5szheKYC7nvPX758Od555x1G8/0LD35DlMfg6+7Xfv6eA587RVFeWUGJjb6+PkbQXd33mzZtQlRUFCc8Q5o+CbqGo061d/bsWZw4cQIFBQWCoXHuHDvx8fG4++673boa9n1bEqRimdVjuvVSfPbZZ2YrNS+99BJefvlls+M//fRT1NXVoaamxpVUnYK3esH6suYAnuHvyu/SW/rfGcOOu7kLGccGE/ZAN1Sj84cNEBWPBYrKEBQo5exfp4gDFOaTM74Rim6ohvpIJQCuEeqzzz5DZGQkR/MteVTZg/Pnz6O+vh75+fmC+WQs9b+z12MjPj4eM2bMYMqm+zF84C2a4yz8/F0DZ3RCiLsrowmEjGO2ePKfCfzE48eONWH83TlYXZiAt2uu2tU24UG0n24w/a9NKkA56kE3tIFKL8bmzZsRGhqDeU4YoYRw6dIlHDlyBPn5+WZGKMC9YycxMRFTpkzxmvHpafgNUR4Csbb66suHn7/n4IvcJ06ciIqKCixdutSl/PV6PTQajZkRyh50dHRgy5YtyM7OZsql0jSNEydOWC2O4M7+12g0XuPOv3LlSvz73//mbBPyhrp27Rp++ctforKy0mdXTocCvvi7ZcMT/F354u3L/c/nTlGUS/rGkgFqMGF5xHtpwuhEfKeUYilNQ5toyhm3/tQti+exjVCEm/pIJeRFZZwJEE3TUKvVWLlypcOeBkqlEhUVFcjMzMSUKVOY7fX19R7TfLVa7ZNjct++ffjrX/+K2tpatLS0cCpe+2GCL2sO4Nf8wWCw+Ys0Gg3opjrI8mea2nPRoowlAxTZbim00JoRiuD/hF3GmeOf4S2sxBPj4wHAYp7TgfPjsLowAWg26T9TSS89ECDeZTSN3t5ep6q7KZVKbNmyBWPGjMHUqVOZ7UeOHMGDDz5o8Tx3jp3u7m6fNEK5S/O9c+nYhfDWJIZGo9HrvViswRP8Xbk67sv974vcx4wZg4kTJ+KTTz7BrVu3kDZ1gUvaraqqQm5urlPnfvvtt1i6dCmUSiVqampA0zT27duHwsJCq+e5s/+TkpJw9KhznlyuhlQqRVhYGOefkCGqtrYWCoUChYWFTLnevXv34p///CckEgkMBoMH2HsffPF3y4Zf8z0HV3OnG6rNci6Rf+Szo+jd+ApjhNr17CbkLlqFSWNzsKmmEbdu3cJ7R81XyMkquaXVcr4RCjAld83MzHQq3OXbb7/F4sWL0dPTg8OHD4OmaRw4cMBmcQV3jp3k5GSv8CR1FL29vRg/fjzWrVvnaSpeC1/WHMDPfzDga6yjMBqNEKVM4LY5iPns61WNZiFw5bFteLLpY/RufAVPNn1sky/Zz/eEWqcwGZOyF67EmZEzEHOlGu3t7YJ9T/qF6Hp5bBtkzfVMW4QbGzU1NUhPT3f8pgFs3boV8+bNg1qtxqFDh0DTNA4ePOhRzR89ejQOHz7slrbdCXdpvncsvd+B8EVrKBue4O9Ko6Iv9z+fu0gk8hATx5CcnIz7778f33//PXputUGcmg9D04lBtalQKLBs2TI0NzcjJiYGbW1t+OJ/X0RAQACuXLmClJQUAKZwu9OnTwMAsrOzERUVhaSkJERFRWH+/Pk4e/YstmzZglGjRiEjI8PqNd05dqZMmYLNmzcjMzPTZyrmzZ49GydPnuRse+KJJ5CdnY3f/va3EIvFQ8rHWxcffFlzAL/mDwaDySUECIdjOwpLk4zBhuCxsevZTZj12ios3P8OqPRipKQDCVotfvXGBvT19CAlfyL+MJbqP9cUcmGpTyzxamlpwbJly1D57RGERkTjvtFy1NfX92s+Jaj5mZmZiI+PZyoWzZs3D+fPn8eWLVuQlJSEnJwcwWuRcD93jp2SkhJ88cUXyMjI8FiZeWcwf/58zJ8/39M0APjDsd0FP3/nwM6n5GzVUVdwFzLWl8e2QX2kEnQst9KovMj0meN9KvDMYOdvIu0BABWYBqQX48V0QK8vwg8//AClUompU6ei4qqOcyy/bUsGKIJr164x7/mxsbFQKBSora1FYGAgMjMzkZZmOu/8+fM4efIk6JYLyJ6xCImJiYjS3kRsTxPKyspw8eJFbNmyBYmJicjLy7PWdW4dO5MnT0ZFRQU6OjoEwwK9Fe7SfL8hykPo7e0FAJ968WDDE/xd+bLhy/0vxN1bJ998yGQyTJ06FTdOVOPIkSPYvn07FpX/HobLdQ63RdM0WlpaUFtbi8uXLyM4OBhnzpzBgw8+iMjISJw8eRJVVVWIiIhAQEAA49Z7+PBhXL58GQsWDHhl5eTkWJyM8OHusbNo0SJUVFRYdRv2JoSGhppVFgwODkZ0dLTZ9jsZvqw5gJ+/o2C/aJfHml622QYpR4xTg+XuTA4oWxModv4mglmvrWK8mNiToMzxk2AwGHDp9HFsa2/HPdNLIMksZfabjo0bmNT0n8/vm38cuARcv476+npcqj+CgKBgbKy+hVWrViE6OprR/KioKFAUxWh+TU0NDh06xHmJzsrKQlZWltU+IHD32Fm4cKFXaL6jBSr8sA6/ZnoWQ81/IN+R6fOgQpwHyZ1vhCqPNRn+ezd+zGwj+k2MUCR3Hz9Mmg1iNCJtEhAvJ7qhGpL0YhTFB8A4uQx1dXU4ffwa/rkoE2yTA3mu2PMcvH79Ok6cOIFTu79GREYhzpw5g/vvvx8jRozA6dOnUV1djQiNicu904qBgiTUnqzFwcZGzH/458BV0/wiIyPD5kIzwVBo/ueff46HH37YLe3bC2/QfL8hykPw9VwqnuDvSmOLL/e/L3MHBvjPnz8f4tR8QN2Nnp4eh0twd3R0QCKRQK1W4/7774dEIsGSJUuY/VOmTEFJSQmuXbvGrJIDcKrihhB/dyEwMBCFhYXYuXOnWdlvP3wXw+V366sYav78lWW28cnRsDIh7vY+D12ViJwfysc3QgmF0RGIJDJIJMC/fv0Y/vRVFTZ9XI1192oQVjCLZ5wzHb8mfWBiotFoIGuuxzpFHNQ9Xai91oVxXV1Y/8AkyLKncq7D1vxRuhZmcjR58mSH75dwAmyPncEkSiftT5o0CZWVlZx8h66CduQ4aG142BplQdi8eTPuv/9+znZLBSr8sA2/ZnoWruDviEfTgAakuUQT2HBkIZ79fCEeUOomQM47jq3Z5D6fbPrYdGzRgA6R6nVC7Qq1AQCBMgmo4GCUlZUhL+8GPtu1Czdi8/Ffc7khcUJ9xH4mKJVKSKVS3D5dhQcWzoEseyrznk83VKOkpAR33XUXruzfgpSRCUwbk5c/MdCgg887uqEaMq0O1Gjnnhv2QCaTobi4GDt27GAqirsS2sSx0EZHWz2GlgWhoqICDz30EGf7UGv+sDdEeavLrl6v9zSFQcHP33PwZe4Alz8lkaGz8TS++eYbq8liAW4Scl3DUdTU1OBHP/qRVQMWRVEcI5QrMBT9n5WVha6uLlRUVGD+/Pk+90K4Z88eT1PwOtg7bvzPLPdgKPkLJXxll/N2FM5yZyf8BsyNY0JhGPYkpe3d+AoThic0EWGvmpt2GPDU5GQAQGRsAt5cUYitZ9ugUHFXw9mTEtKWjNXe1bMnsP4PaxDWfs7iPQ9ovut0X6j/Ld6rk8jIyEBnZye++OILLFy40COav2LFCrz99tucbX5vKOfh10zPwhX87S3eIGR4GkxItqDm2LH4wDcWEZBngFnxh/57Ux+pxOp7n4OhyXQM2/hUHtsGuqENqwsLIGuuHzBs9R9HvKjYXk50XzSeSjbdQ2JiItoSJ2JUWz0Ay7mZhCro1VTVYGVRJqIiwgWfnYR/ysiEQSeIJ6DSi0H39IDmfQeDDbHnY8yYMYzmz58/3yOhpMuXL8c777zD2TbUmj/sDVHeCr/Aexa+zJ/P3VUVlIYKbP66BlNibolEApqmzSbhxPikazjKHEsgk8lw8+ZNhz2pBouhGjuTJ09GRkYGvvjiC1y5cgW/+93vhuS6frgHvqw5gJ+/I7CWZ8NSVSJr0Ov1oJuOgQ6Rm5KK26n5xGvJVhUkdphdcHoxeje+wlkR5xuahIxQpgmLOYfVhQn498GL0DbUgA6R9x8TiMrLtzFupEnz2ZM44gHFvu6adNO1d8d0o62mEhFl95tfyI1gjx3y/bG5uQqTJk1Ceno6vvrqK1y6dAm///3vXde4HSAFKvxwDfya6ThcuRDjCv72htexjRN8j1dnvKP0ej0+qL0GsTzE4XP5oXVCWk54Ec2WF5UBzfVYl/oIoBi4H9KW+kglcKQSKCrjGrN4oXzk3o20Ae8cboRYbno/lwUGIjAwEHq9XrAytCUv4W+7Y7HnAoU/P2R5gcTR56k9z2D22CHfn6sMUGwUFhYiPT0dX3/9NRoaGvCHP/zB5dewBm/QfL8hykMY6smzq+Hn7zn4Gne+J5MQ//z8fNTW1nJCKKZN+gDFEc+gWvkGs62jowNVVVXo6+tDXFwck6RwKDGU/X/27FkEBgYiNzcXCoUCsbECMz0WNBoNtm/fjrCwMNy+fRu3b98eIqZ+2IKv/W758PPnwt6QDVes0ga1nQHk9q9SEm7MyraNY9m5QuiGamaiYWkS1vTFNwjmTbxICW6zHCLNbfh5Eg3AxJ/sH5mei6bT9Rg9rpDTDjtPFNCv+V++D02fFrHRUcjiGaEsTUicMfhZAhk7g8n5Yi/Onz8PiUSCsWPHorW1FfHx8VaP92u+98KvmZ6FK/gTHaQbqjkJuq1piysMFh+dagcVMBBMZ6soEZsfgSUPIqL35UVlHI9ZITD3LGDMIgYausE8pxQVIMdPRyggEfcy51y5QqG6uhpTpw6EVPN5l8e2QdnVhd/tasYceRuMxlT8+SEuP7Y3Kt8AaE/f2/NcIGPHmeqsjoJo/vjx49Hc3IykpCSrx2u1WmzduhXh4eHo6Ojwec0f9oYob/UU6enpAeC7SQD9/D0HPndPhPKwPZVsHcOHUN93dnYiKCiIcw4xQrGvsWXLFtx///0efUEairHT2tqK3bt3Iz8/HyUlJdBoNNi8eTOmTJnCGN8UCgV2796NSZMmITg4GI2Njbh27RrGjRuHuLg4REVFoaurCz/5yU/cxtMb4a2hbb6sOYBn+Lvyu2TzH2z+DgJribythREI5dSwFhLXo+4DlTrBat+zk8USWAsb4ycbFzI+sScp7Jf/1YUJTB+SF/X1dS0AhK+nissFYOp74kFUX98JiSQKu/vzpLKNUGxs2bIF9z/wtJnm88MO2RwB8z4ejFGKGTsuMmwJQaFQYOfOnRg3bhxWrFgBrVaLzz77jKP57e3t2LVrFyZMmIDQ0FA0Njbi+vXryMnJYSoCDpXm9/T0oKGhgfnc2NiI+vp6REVFITk52e3X9wX4Nd+zcAV/btEJ8+TcBJaeKfxwLrZhw1IoX3lsGx4JUdvUfK4GsyvPCT/b+JpP/mbneipHNbRJBYxnKim0IaSfhL/QvkdCrqFHDUSEDBjTuru7OUZ9Kr2Y84wiRq0tP+zH/8y9GyEhuVhh5sFl+g7IeUKGIleE0JGx4w4vKIL29nbs3LkTOTk5HM0vKSnBmDFjmGN27dqF8ePHIzIyEpcuXcL169eRnZ2N+Pj4YaH5w94Q5a2QyWSepjAo+Pl7Dt7KXcg4JWSoEuKv0WgYbx9dw1FotVqcOXMGwDucEqfBwcEeX6VzZ/9fvXoVNTU1CAsLw3333cdcKzAwEA888AAOHz6MmpoaAEB4eDiWLl2KY8eOQafTYfTo0Rg/frzPl1wervDW3629GE78+S+Xjrj580OzhNphwhgwEBaxddqPMes1Ux488mpu7VrsfYEqlVVO/Osz5yssG9zURyqx69lNAICF+99hrsc2RhGPqnJwV61J/iKhykzAwEo13WDykHoqkTt2Xq9qxOUTDQgfEYfohGAAgF6rxYlzDdAb9Bg9bQlIUWu+5vdufIXhRu7D2oq+K7yi3Dn2m5ubcfjwYYSEhHA0XyaT4YEHHkBNTQ1H85csWYJjx46hpaXFo5p/9OhR3H333czn3/zmNwCAxx57DB988MGQ8/FGDCfNHCq40nnAGn9rBiHAfu9HdjvWvGfsMY6wDV0yiRgUj79Q3wjdh5Dxna3p2qSBXE8AEPzQCyajVv8iQWBgIKcNa+HHc944gKWFIxnuJNRPpREzxxAevb29iImJYbbp9XpcbziHFeFtSE6IZzyrggIDERQUyPG8Wl2YgNWFCVhnpcC2UK5BZ+HOsX/jxg0cOnQIISEhWL58uZnm19bWora2FoCpKvWSJUtw/PjxYav5fkOUHz4Db/V0cAbS9ElWvYkchTs9//ihddaOsWWEsoTi4mJ8+umnaKn+Dh0dHdi2bRsmTpwImUyG2tpadHV1gaIo3Lp1C1qt1udf8ISwfft2BAcHY/HixYL3J5FIMGXKFLPtJSUlQ0HPDz+GHO72aCa5kPhlrK3BHsMGvx1tUgHH2ENe8p0NHxN6FrINSOsUcZzKcwRsrylihCLGMb5HFXuVne9ZZckApU0qQGBgIJPTyRLWlKZBXzQKT/zpn3hmRg7QVIvvLt9EwMSJCJXJcOzYMSiVSkbzVSoVjF+9xpzPT7w7mHwhjsKVCWt37NiBgIAAq5pfUlJipvHeoPkzZ86E0Wj0NA0//HAI9oZasXVFyIOVfCaGF0vep3xPKGveuGztouxYfGB7pLLbFPLUUh+pxHupjwAAylEPABDf+xwCAwM5fcLhYEVLyTk/PGMKszMLzxMBVNokUCyDyeTJk7Fx40aEh4dj/dFrSL51Bo9NLoTkRi+On7uIzm6TF1JHZxc0ifl4n8XL5HFrft/8e/d22KP5d911l1l178FW+3YF3KX5w94Q1d3dja+++or5bCvOdqig1WpB0zRnIJKXS/bLd11dnVcaYLRaLQDXWI37+vpA0zTkcn5xUS7OnbNcKcdRuJK/M9j82gvYsmWLU+fyuTc3N2PWrFku48aGpfA6XcNRuwxUQiD82RZ9iUSCOXPm4MMPP4RYLMbYsWORk5MDAIyLKgCoVCqPG6GE+AP2hStaQmVlJSIiIrxiguHr6OrqEtR8oWT4Qwl7Nb++vn6oqdkFV2qmVquFXq+3uap34cIFp3VS6JoAj39wPugf9gEIQN+FegR0BQA/7AOVkCXYBt1yXnAf3XKe87nvQj1OvXcAADDx1WcA7AMAUKfbOMdTCVnAadv3x+d+/fp1TJs2zew4Kr3YZtgh3/hFjDmvVzUCigHjkxBWFyZA1lxvcWK2vq7FLFxjTTqgVCoBcDXzzSPXkFs8Ax999BEkEgkyMzMtan7gjRNQAxar//G3uRJ0QzWUB79H4PhpeFeVymznT4QcNVDt3LkTISEhgosLfjiG3t5eVFRUMFrv6vd8Z58d9mr+sWPHBk/SDRiOmp8M4NuzrZzjVu8DFuVwc7ERjd6mDMeinDbBfQT66DScuHRckMOWm6Z2T/Rfc1FOPLZsOeEw97a2NhQVFZkdZ0vrVxcWMHn/oOB6XRHPVr5hBxA2ZpG/CUxtpQkuOmh1BlBaLef7pigK99xzDz766COESKWIGD3apPk5ORjDakOTmI9367l9LpQM3l0GqNerGmFQm4xiv5o9jvOMGUzuwV27diE4OJiTI8uPO8AQFRoaimXLlnmahhlIRn6h6gF8LF261N10HIYj/G3h/Pnz0Ol0GDt2rNXjXNkPruQ/1OBzP3HihEvvw5rxydpne2EptC4+Ph7PPvssaJq2+CLiDWFnfP6W+ssetLa2Yt++fRg3bhwzCfNjcPB1zacoathr/qVLl9Dd3Y2CggKrxw215tt6ybTo5ZNnMt6wDTSLJ5Hfcx+CH3rBccIs8LmfOnUKYvFA6AP7xdyel3O6oRoL9w+UbBbyElhdmGC2Cs2+f35fkPwidIN5Il8hzWdymSyYCP2FKmw52WJ2DNCv+enFCLaSQ2uwRiihvFhsj4jYh3+Hf1U34SeTBvqE9A+ZjA3ck3W0trbiwIEDyMnJQV5e3qB4+2FCcHCwT2vmnaD5jY2NuHXrFiZNsv6+NBSaz76ELcN9c1UjrvI3jsgHYNIAYsxpNTPQcHXJ0dvicz979qzdHsLsEPH3FHGwtrhAYCk8ke3ppdFomGPZnrPlseYh0mFjp3HaIX0RpWzAb37zG/zjwCVo2uoFuQQFBXEMZuwQPWt8HYHQM48Y5Mpj20CnmsapRqMBMWOy79mR6ysUCuzbtw+ZmZnIz88fFO/hCN+bhQ8T+JMAeha+zH8oubsyfJDAl/seGOA/YtIcs3329pdGo8HevXsBAEuWLGFeZvwYvhgu434483fUoMEP6eMbZ+wJ9bMHQtw/PtaMF9LSbGoH32NIyJupPHag2p09SXVdwZ8PRz1O7P2ubN0HCc8k4H9nVHoxupRKPBJyDcBANSOSyNda22xoNBrs378fNE1jwYIFXrGo4od7cSdopjfDHv7OahvxDn1dICSPX83NGbii74kXFD93lLMgmte78eOB9nkgBnw2f6FwP4qiBrwDeYsKlhYZBtunxCBmT3hm16n9AIANqlQAcZxnpL3QarXYu3cv9Hq9X/OtwG+I8hDYq5m+CD9/z8Fd3EneKncYn9iwxf/MmTOc0AxLoGka//nPfxAREYHExESMHDkSNE3DYDCApmno9Xrmf6PRCJqmzT6LxWLIZDLmf/K3RCKBTCbj/E9WpsRiMZJL72F42Ntf58+fx+XLl6FSqSCVSlFYWGizTKsfwwe+rDmAnz9gbsSxZmgSCiNzFnzu9NXjAGI5oXCOlK0m/LVJBYyHj7XQB76nmKPV6dj8hapNzQoPR0qKuUHNLEeLDc0n+k40/uO6a1gZcRMGgwGf3orEoRs7IRGLETBmIqP5kpJHIJVKTRrffBwSsRgyqQSScwcgyzaFUHx47DoeHjeO8YAiVaRsrYyfP38eTU1N6Onp8Wv+HQi/ZnoWruAvZJgHrFcJdUXIGJ/7x8ea8dD4RJvncfIElqZhTTq7Gt/AcbaeSyZtMxW8KI9tQ+/Gj80M9mzDDN+LlO+xy/cSmxutRZeUq4UDRiKuIe/DDz9EREQE4uPjMWrUKEHNZ2/bUHcNNG3AynEJ+LT+Gh6I6ezX/FDILl7EogQJo/kf1LeAosQQS6TQnjuA8lgJqPRiiE/u5XCz17jI1/yCggJ/FVEb8BuiPARP57kZLFzN391Jafnw5f53F3d3G6AIhPg3NjZCoVDg2rVrEIlEuO+++2y2Q1EUQkJCsHjxYpw/fx5XrlxhVllEIhEkEgkoioJYLIZYLEZAQAAoioJEImFySBgMBiZ3gVqtRmdnJ3Q6HbPdYDBAp9NBr9fDYDAw56x/6dfMg5aEEbLzSPD/Pnv2LCQSCZKSkiCXy2EwGDjVkMj9EPB/D+QzRVE4d+4csrOz7eprlZ3VtoYTvCUPIB++rDmAn78t2KreZg228hyxuZNjH5mQhJwc20YoKr3YVGnuSCWCH3pBcFWcfz5/9Ze/Sm0P2AYna5qfcOMazrVY1nz2Cvaa0jS7Nf+TEy2QBgQgNDgIEokYv4gWARiB99oi8VBAAHSXa6EeORZarRZ9jcdgMNDoOVkNccYE6PQ6GAw09LtMeb4SaCPWHgqHUUShIlyJ450RWL1PBKPRiIo2Vj9RFKPV586dg1gsxsiRIxEUFOTX/DsQfs30LLyZv608RzKZDPTlGiBnIJ+Q8epxwIFwXrahnB/qJrQgwOaypjQNGo0G5bFtzLONMcYcqWSqsrLbJWF6hD8bVHoxGhsb0V5TgytXrgAA7r33XmYfG/w+IZp/8eJFu97zA4KDQVFibGvuwy+yxNAbwkDL5Xj/yGU8MC4BWq0WG2qvYHl4O5oVIVgcdgsV7SF45qgBtMGA+eF7YIxNB916EYnUIWzvjMDC7Dhs2XLC6nv++fPnIRKJkJSUxGg+uwIeMPCMYD8r2CD77iTNd8gQ9eabb+LNN99EU1MTACAvLw8vvvgi5s+fzxxz6NAh/P73v8fhw4chFotRUFCAHTt2MImoDx06hJ/97GdQKpV44YUX8NRTTzHnikQiBAQE4Pz580hJSWG2L1u2DBEREcOqJKxarQYABAQEWD3OGxOVA/bztwenT59GV1cXLl265JL7tceopVKpsHDhQpfwH2rw+16r1aKqqgqnTp3yJC27YDAYMGeOKaSN8KdpGv/zP/+D1NRUZGZmAoDVZJX875eiqCHNr0QS7zriMr18+XKXXPvGjRuIjo7G9OnT7Tq+q6vLJdf1Y/BwpWZ6Aq7kf+rUKXR0dKCxsXHINL+3txeLFi1yCX9nDDP2tGkJ7L6n0oth7JVj9+7dFgt4bD3XhoXZcczfsxVnAACB8grQLeexvTMCALAwuwVJAL7416YBHv3J2JPQgoqKegDmyXk5vPm5nU5WcP7maz65z7/+9a9ISUlhNL/i3//DuT6D01uQeP0sqIQsVFTUw2g0gqIo/HA7EGtKS0wTOtMaAdZMGpjA/Jk1YWN/Vy8lAsBtUPMfGrhGf94aetJ4Ewfe96vsUePGrRiI5SG4rzQNNxgPA/NcMK6GQqFAeHi43QVJ/JrvPfBr/gBOnz6Nmzdv4tq1a0Om+d3d3ViyZIlL+Asl9HZFm5agVqtB9+lASjg9mJ+A3Z/vwEWN5aJO7CIYx8/VAwAq2uIQq9Wior5xQFtPVmDruTagv3rewuw4JAGM3gPo3w/MD1dCe/EMZEopjndG4Md7gYXZY4GKCtM59QPXjNn3D1RkjIdeb0DZI5mgKAoBAQHMfb722msYOXIkY2B5+n/WA+Amik8GsGXLCXxzpoV5hhkMBlAUhaws4SIifPwpI4P5rkb1ezgBwP/NyDD1U0M1CmePBDASJjPfGMxjLXjcAPBwUBOQHo2IEDmWwzxPlTsr9XV0dCAsLAyzZ8+263hf13yHDFFJSUl49dVXkZGRAaPRiA8//BBLly7FsWPHkJeXh0OHDuGee+7B2rVr8frrr0MikeD48eMc0XnqqafwyiuvICEhAY8++ijmzp2LUaNGMftFIhFefPFFfPjhh667Sy+Er8eKupK/WCzG448/7rL27MHmzZt99jvg805NTUVPTw9mzpzpGUIO4NKlS6itreVUfLpx4wbuuecer0zWKYTE4nkoCn8aew4/OaTXbW1txQ8//IC5c+cO6XX9cA18VW8IXM3/iSeecGl7tuBqzecbH/jJtAfTFsBdoebzHjVqFLKysgRfVF+vasT4OGB5f0LZpeMSoD5yEwAgH5cAjEvADQthBpaStTsaisdGY2MjampqMGPGDGZb88FvMG/ePI7mCyU/HwD32fB6VSNWFyYw5dPZYRNCXC1V+eODeIE9eeQVZpu8qAxBAVJQ0qE3JhDNd1dVXD/cC7/mD0Cn03lM811V9cyVxgdbbQUFBQG5AxU1k5OTkT11HsrKuF63/HsjGja+31FzKWMsX8U5jyyNvl7ViOUCXJr7DS7LY9ugjtBBXjQTN/rbZh9P+pNuqIZanQt50Uxckybg6NGjmDlzJsPvz6eB2bNncxZlyTVIMnh2n1iaDrzOWgRgG4eIFy9ZHCiPJbpvfm9CYeam/+OY3F9v3BiJnxanghpirzqFQoHKykrBqrjDFQ4ZohYvXsz5/Oc//xlvvvkmqqurkZeXh1//+tf4xS9+geeff545hm/B7O3tRWFhIWJjYxEZGYnu7m7O/meeeQb/+7//i+eee85mFTV74K0eRaT6gDe7jlqDr/OnadpUDcEH+fP7PiYmBrdv3/YkJbshlUqhUqk4fb9t2zYsWrTI/jb6c1l5CqUxqwEMbSjpqVOn0NTUhHvuuQexsbG2T/DD6+Drmunr/D2h+YOZ9LDb0MTmAhjo+6ioKIuroI5Mltj8mJwgAmB7CFkz5vBXi1+vasTSJDE0Gg2n77/bV417fvQzDgdL/cQ3eJFryJrrOXlQbBmZLBnOuEnbTf+rmwb2r1PEgdaoAOjwi+mZnPsTmuS4CqdPn8alS5cwd+5cv+b7KOzVzKFOTWEvfE3zzXLZ9Wt+GC9Ztr1GdGfgaEU1S208NjYawEDfh4WFMQnA2TBLBK4Q9tpiJ+rmh+AJge0Bxs8HxW5TCGKxGGq1mtP35z/4Kx5dvZK5P2sVXi15HbFzTXGvH8cxQrH3C+V2ep3n0QqYdJ4YoQDg8YJ4wfcFd3pCnT17FhcuXMDs2bMRHx9v+4RhAqetNAaDAZ9++il6e3tRUlIChUKBw4cPIzY2FqWlpYiLi8OMGTNw4MABznkvvvgicnJyEB4ejuLiYuTm5nL2T5kyBYsWLeIYsxxFXV0dI+ydnZ1Ot+NOGI1GGI1GT9NwGq7k74mHsC/3v69yP3z4ME6cOIGpU6cy/PV6PUJDQ5GYaDsJo7fgi63344ut97v9OqdPn8auXbtw5coVnDt3DosWLfJPSCzAr/nuh1/z7YcrwvbYJbIHw51U9uO3zQZ5MbcVeuJI1aDXqxrRdOY46uvrzTRfnpzLJO0WMgzx+0+bVMBsZ09gSB/Z09+WjF1C2+RFZcw/ADAaaTw+0f1Jxs+ePcto/tmzZ7FkyRK/5ltAbW2tX/PdjOHK35rh2xrsMcIPFqQdNndnnyd8wwyBPZpJeFDpxWa6zzbk8fuxTilBbW0tpk+fPsCfpjE/J5FJuSP0/OH3HzGEsbeT+1EfqeQ818pj2yyGSQsZjtaUpmF1YQLzmdwfKdxBpRcP2dgnmn/16lWcPHkSS5cuvaOMUIATycpPnjyJkpISaDQahISEoKKiArm5uaiuNg3Ml19+GX/7299QUFCAjz76CLNnz8apU6eQ0R+b+dRTT+GBBx6AVqtFZGSk4DX+8pe/ID8/H/v373faPW3jxo2Qy+XIz89HV1cXjEYjgoKC0Nvbi4CAANA0DZ1Oh5CQECa7PUVR6OvrQ0hICHp7e0FRFGQyGdRqNeRyOZO8mJwj1A6prqXRaBAcHAyVSgWRSITAwECoVCqmHZ1Oh+DgYCiVSsbiqtVqzdrRarXQarXMyoRcLkdvby8CAwOZ6jDkHKF2SGUYtVqNoKAgaDQaTl8EBgYyCZkt9QW/HZJsmVQrsNQX7Has9QVJFm3pHmz1qb19wW5HIpFAr9ejs7OT0xf8dmz1hVCfDqYv7BlfpB2dTse0Q9M0lEqlU31haVxYaie5ZB561H1oPfK93X1RW1sLkUiEqVNNEdkikQhKpRJqtRoymQzd3d12/9bU56qhVCohlUohFott/tbY7dgzvkheBEvjS6fTMZ5djv7WrI0vhUKB5uZmZGdnY+fOnRgzZgzS09Nx+vRp3H333U791rRarVP66WugKAobNmxASEgIxo4d69d8L9d8ch/DVvNjsiHt7QU1cjz6lEq79Knr1H7Is4qZdoLazqBH3QdZ+mRQRiPUFw6jL1gOVZ8W4rSJHM3XXjwMvYFG2NhpTF/Ql49CqzdATBvRawAkIkCk1aE7OhPh5w5AozVVlgvR6WBQ90AkkeGpiSPR1taGSOUlqOJymT7VXDiMEHkADOoe9MblQdJ8HOo+HUJyp0DD+q39KDcSHx5vRW9vL8brr2FcegQKCgoADGi+RqNBQECARc0PMhjQo9ZCrlaDpmmsvxIMqrUZj4SoIZVQEJ/ZD23iOASnTETn8d2mPpVKoEkYa96nFn5rHx67gadLRg9ofmwu6KY6BMok6Di8CxGT74beQOM9RRSoAAOMBgPeP3oVIrEEjxUkDInmz5gxw6/5ViCVSrFhwwaEhoYiNzfXr/lervlD8p4fkw1Jf1sajQYURblW80fkIEinExxfP8qNRG9vL348IR5KOzX/jb1n8XRpOtPOR6faQfep8eO70mA0GtHV1WW6h141xF1doGkaHfW7EZRdAu3Fw1DHZiM6Opqj+Q8HGfBxzyjQfWq0V32PkEl34+2WCPx0ZCe6FAoYNL0wpEw09YVGA71ej3cON4IKkOPRsTFMnxrUPaAC5FAqlXh8XAzeP3YDtE6LnyZ2okulh4jVpwEBAdBr+nAydTY0XV1MGDbRfK1Wa/U932gwgNaqTXmxaBo/yo2E9nwVDOpQiMRi/GPveTw2Pg5yvQGqPi0+ir8XIokUj8bEQi6XQ3OhGsZR4wc0PzF/YFz0jzn++NJcqIYGAJVaiJWhaki/fwuSghlQ9tAI0+vd9p7f3t6OpqYmjB07FpWVlUhLS0NmZiZOnjx5x77nO2yIysrKQn19PTo7O7F582Y89thj2Lt3L7My8fTTTzNxwBMmTMDOnTvx3nvv4S9/+QvTRnBwMIKDgy1eIzc3F48++iief/55HDx40FGKyMjIwLhx46BUKjFq1ChG3L0JJMs9KQnva1CpVKBp2qGEzd4ErVYLlUqFsLAwT1NxGCqVCn19fQgPD2e2SSQS6HQ6BAaal8B2NRr2fsMIo71QKpXQ6XTYsWMH9Ho9RCIRxGIxGhsbsWzZMrvbSZ+xGK21u51g7TqoVCpIpVJO/w8G586dw/HjxzF69Gio1WocOHAAS5YsgdFohFwuR2RkpNe67nsLxowZg7y8PL/muxG+rvl6vd6lmv/+0ason54NuukYaKkESC20efyTk1OsHsMGNaYIOLUfQL/mj8hEZEICKDKObjWir6+P0XwqdYJ5G6kTEDx2Goz9L+K4egzSljNAoLR/P5fzuzVX8aPINkAegA9qr+HHcbdBjZ7E7H984ijQTXWARCx4PQD4SVEK3j7ciIu1F3F3agQqKyuh1WoZzW9qarIaik2NuQtU/7PlnZqrA9tTJ4CSSkGJxUD/75tKLYRIJAIVGAi4qHJQ4PhpoEZPBi4eZrbdlx3FaL4rXvrPnz+P+vp6pKWZKlPt27ePSX3h13z7kJaWhpycHHR0dCAlJcWv+W6Ar2g+3XQMtDwAiONG2Dii+fTlGmBkvt3Xe7szAT+eNMr2wQ7g58WpeGPvWQCmvjcYDCYjVr9O72zsxF0JcgQB0CbkAf2VnIXa6Tq1H/rrwPqbsQBMmiVrPYMnJgrr9pMF8dDr9Vh/5ApWF3GfU+/1G+EfnzgKaBH2PqTSJuHWrl3QarVmmn/lyhXcc889lu+7JNVsPkGNKcLjcT3MgrPq3CEgUAYqtRBPpA0Y9wDTc8BgoS9s4YPjrXgk9DoAQHNsL2RLfgHA9e/5Fy9eRF1dHdLS0qDX67Fnzx6O5k+dOvXO1XzjIDF79mzjT37yE+Ply5eNAIz/+c9/OPtXrlxpfOihh+xqC4CxoqLCaDQajVevXjUGBgYaKyoqjEuXLjU+9thjNs/v7Ow0AjB2dnY6ehtDDpVKZVSpVDaP++qrr4aAjeOwl789+PLLL13SjiP47LPPXMZ/qCHU90eOHDE2NTV5iJFjIPx1Op3xX//6l1GtVtt9rmTMRDcysw+uHPu9vb3GTz/91CVtCYGtie3t7UYAxj8tedX4l+X/a/VffFiC8dtvv3UbL1fBr/lDB1eOe0/c4+bNm92i+YaLh4yGi4dsHvfPg5ftbo+PnlP7jD2n9g183vAnY81X7xsbGhosnsPfRniS7ey//3nwsvGfBy8b1Wq12THWOPLv3dLxZOwYDAbjv/71L2Nvb6/wzQvA3n5zFLa+M9In/zx42fj3PWddNnbUarVx48aNLmlLCGxNJH+3tbUZ1Wq11X8TJkzwWu1hYzhqvifege2Br2u+u97ziS64sj0+/r7nrPHve85yjqnd8qHxzI5PLZ7D3ka0Wa1WG/958DLzWeg8/rPAGkdnNb+7u1vwOEdg77PWEoT6x1K7rhz7Q6n5vb29RgDG5uZmm5o/efJk4+eff+42XvZi0GZ6mqbR19eH1NRUJCYm4vx5bpnfCxcuYP78+Q63O2rUKDzzzDP43e9+hzFjxgyWptfB1y2fvs4f8N17EOKdkJCAK1euMDHY3gyapnHlyhUcP34cy5cvt8uLiyQo92SScgJXjJuzZ8/ixIkTkMvlmDdvngtY+eHt8FW9IXAlf0/liLL3uuy8FLaSk9qba8RWO9aSadNGGlTagGeSvKgMSSGpaGhowJgxY2zmPuJXkmN/Zt+rrLl+IKFtOnc/m78QR6sJx2ka165dw7Fjx7B06VK7qnHZSmhrDYNNRsz//nt7ewc9Ztma78w7sR++B7/mu6ctT1/XVQmrrSXlhpHGj3ketEnxsTh14TJyLHAQ2ra+rqU/l555vihHdJKds1CbVID1/YnDrWl+c3Mz6urqsHjxYoSEhNi8hi1Y42mpL9kJ7Mtj20A3tDHPKpIrS7BSrAvGDfF89b/nW4dDhqi1a9di/vz5SE5ORnd3NzZu3Ig9e/Zgx44dEIlEeO655/DSSy9h/PjxKCgowIcffohz585h8+bNTpFbu3Yt1q9fj8bGRqxatcr2CT4EnU7naQqDgq/zJ7G3vggh3omJiaitrXX7taXppsnQYAxCOp0O9fX1eOihhxy6prfA2XFD0zTq6upw+fJlpKSkDDtN88M6fFVvCGzxt/Qi6C0gOVLsAfseHK18xzf6DBZUejEMSiUMLO5UejFiaRp/eP8rHKNGWuxzoaTfMh6/cgyU/CZ82ZMOS+2yDU+2Et/qdDrU1dXhgQcesKuSsasS/1rDOkUcylHNMcyx75+NwWh+fX09GhoaMGrUKL/m32EY7prv7XD2Pd/Ryne2Fi4cfYasKU1j0llw203D7aOv2skljjmP6BupIGfp/qzprkajgaXaiUL3p9PpUFtba5fmu6K6rCXwqwqSRRbTvZpX1CMYjOafOHECFy5c8Gu+nXDIEKVQKPDoo4+ipaUF4eHhyM/Px44dO1BWZqos8qtf/QoajQa//vWv0dHRgfHjx6OystJpj6aoqCj89re/xe9+9zunzvdmuMI67Em4kr89L6auhkQi8dnvQIg3RVFDsuLkCo+kkJAQiESiIb+uq+DIuNm3bx9u3rzJjPHs7GysXLnSXdT88GLYO268dRXdFn9vNUAROKv59r4g840xzrxYWzrHkuYDAxMNvgeUWVlvAIEA2KOLzZm9WmwN7HMGymNbP4doviPP+sGMJ4ur9Kx+WVOaBo0mAYFWjidwZNwcOHAAbW1tzL1mZmb6Nf8Oha++YxLYw9/VhndXwlnNt1d7hCq9CcFav1g6h82b08cJWcy12efyP/O9lchiA5sz2Ua8Xy3h9apGpsrcOkUc1qQHWvSyYvO3V/NdMW4s9SO/X9gVV63BkXFz8OBBtLa2+jXfSThkiHr33XdtHvP888/j+eefd4qMUaBU4tq1a7F27Vqn2vNmkMRs3p4E0BJ8nT+pTOCL/H2970mlTVuYNukDAN5lhALs63+9Xo/PP/8cRUVFmD59+hAx88Ob4eu/W1fy98Tiw2A1n0wG1EcqIS8qEwx9I/ucgbWXcUt9vzCb68nEb8tayB7fCCV0HJm0ECMVG69XNaI81iJlDr766itkZWXZPG6oversLe7xxt6zeHziKKtjh6ZpfP755ygsLGSqw/pxZ+NO0Xx7DAm+qPnWDE2u8Nq0ZvwnfR/Wfk7wXP4CBN/AQvSa6Dzfy9W0P86sTQL2/a0uTICsud6Mg7XnzJYtW+zSfG+FPWOfaH5BQQGmTJkyRMyGH4ZeGfwAYCo9K5VKPU3DabiSvyc8ACiK8tn+d9fYkaZPYsLg2H+7Ejdu3EB4eDjS020swfRj/9HHXc5hsLCn/w8cOIDS0tJhmd/OD+fg1/wBeJPm2worE2zLwsSLGKhc5RlAuA3V2CEr5ADXKMS/Jyq9mNluCwqFAiEhIWaTkterGjmTnaEwQjn7vawuHm2z/6uqqlBUVISMjAynruHr+PLLLzF37lxER0dDJBKhvr7e05Q8jjtB8+32GPUizXfGiDRg4Kk2e2bYymVn6Rkj9Kwg3Ph9zz/WVug0/xi6oRrqI5Vmx1rizb4nw5d/hfpIJdRHKgVzMPHR3t4OuVzuFYYoZ58n9oz9Q4cOobCw0Cvu0xNwleb7Zk3RYQBPrA64Er7OH/DdexgK3u7yQtLpdAgKCjK7B5KMnP3ZhMfdwmMwsNb/27dvh0ajQWxsrNOJ43t6enD06FFIJBIEBAQwD0SZTIaAgADIZDLmX2BgoM+Whr7T4Kt6QzAc+Avdg70TKXJcsECibrYnlFCYnK3rWMqRwaw4u7Dv+aEK6xRxgh5RQsfbSvAqlHtEc74agYFhPj1+7NH8ESNGIC3NuUkPW/OlUimj+76k+b29vZg6dSpWrlyJ1atXe5qOV8CXxzzgWv6e6AtLmm+vccLacWzNfL1KOOG4tVx7lvI0MVpLUaAvHwWVN03wfGvPEyq9GL0bXzHzzpUXlTF6z150sIY1pWnobeJuY+u/EI83Dzago7kTd99NCZ7jC7A2Xnfs2AGVSoXo6GinFx56enpQV1fHGEvZmi+k+zKZpQxdnoOrNN/7nmZ3CPr6+gAAcrncw0ycg6/zJ9UefZG/O/vekgHKFUnKtVotqqqqUFJSYtb3fCOUt4XjsWGt/zUaDZYvX+5wm1euXEFDQwNu376N4OBgjB8/HhRFQavVQqfTQaPRoLe3F0qlElqtFn19fdDpdNDpdDAYDKBpGl1dXRg1ahRmzpzp8y/AwxG+rpnewt/Zimh6vd5tmh/80AuDOp9fyY5/b4Pte3af8cPsTMlrucfzk+9aW323NlnT6/U42NyLgoIMwb4niXMdhaPJhJ0B20PLHZp/9epVXLx4EUqlEnK5HAUFBQ5rvlKpRHJyMu6++26Pa/6PfvQjAEBTU5NHeXgT7P3devq7swRXav5gPKKc9ZZ09Xs+MabwjSr8HEtsTbP0nOJrH//e+vr6gJHj7OLEB5VejPdSH0E5BnSeb3iy1ZfssGx7w83phmro9XpkXtmLSQsfgPp8NQJC5Jz9ghXqBlnl1B2wNvZVKtWgNP/27dsICgpyWPMBoKOjY9hpvt8Q5SHcCUkMvRnDLVm5K+BO4w9N03jhhRcwduxYnDhxAsDAyxdFUVj81C/xzbv/wOKnfgkAECdk4Jt3/yHYlkgkAk3T2L17N0pLSx1OfG4LFEVBJBJBpVIhNDSUw5P8TZIwsv8ZjUZcu3YNBw4cAGCahNE0zSkbT9M0s+369euIiooCACQlJWHcuHGIjbUz6YoASGnwLVu2OPWQ9MO98FW9IfAV/pZeat2l+ZZCK9gv+oN9wXaUt7XVZxKewfbgKo9le0Y5b+DhT25eeOEFZGdn4+LFi/j7NwexODcegElLT59pxU+rdnOOX5Ibj23bzpq1KxKJYDQa8bePvkTa+IkQQYSKNvtW9O2BkOan92+vrGxgOPA1HzAtIghpPjCg92Rbc3MzoqOjAZgq3bpC84ODg1FRUYH77rtvED1ggk6nQ1dXF2dbQEAAAgICBt32nQhf0UxL8KWiRELGaVdrPtsLiO9xxNfbwRjK6YZqhKTaTo1hbYHAkpcr2U76y5pRn90G2+vX2vPspX+sR3ZaCo4dOwaZTAaK6jWdQ77/C9u493BjQO+pCx2gb5wFlZjDvNdXbv4PphSOA5WYbfGapH1Lxk665bzpmIQszvFE80NCQiAWi5nt1t7zAZPhxV7NZ7/nJyYmIi8vD/Hx8VbvxRqI5n/55ZdYsWKF0+0QeIPm+w1RHoK9SQC9tYKSrydhvFOTlTvqbeQKTygAqKurw6xZszB79mx0dnYCAMLDw5nxrb5ymvM/H0K/g6ysLFy8eBHz588fFDeha9E0jaqqKiQlJSExMZHzcFEqlQBML2ns7TRNIzU1FVKp1Ozhxf9XU1OD9PR03H333S7jnZ+fD8D0kOzo6GAefn54B3xdM72Fvy2jjqX97tR8vvGJn4TWnrAEZ5KVE7Db5+cF0SYVIJDlcUUmE8QgFfzQC/2JxwcmKAR8YxrbyMf34OJPiuq7ZJg2bRrmjA5D94gcTJnC1fzzQY0oL03DOrLyzs89IqD52dnZOHPmDBYtWiTYD86C6PeRI0cQFxeHkSNH2q35KSkpdml+XV0dAgICMHv2bJfxZmt+e3s7YmJiBI/74Hgr5MG9Vtu6qdJh8+bNuP/++znbX3rpJbz88ssu4XunwVs001m4kv9g5jL2GHXYnptEC92l+Za8V9lGHaKpjlTMY7cr1Pd0QzVjVOGHhPPB3sf3hlIfqcSaft3nX5d9T6SNdYo4lPf/D8XAs4793Hu9qhHTggIxddFKzJgxg/EoYms+AKyramS0nm6oBlInM9c0HTeLc79ZP1qBk+cvYekgFleFnr9Ev48ePYrIyEikpKTY1Hz9pRogZQKSk5P7jWzWNZ8Y4+bMmeM0dz6I5l+7dg2tra0WjVr/OdGG4HCt1bYUvTpUVFTgoYce4mwfas33G6I8BGJ99VUMB/6+eg+D4e2oQckVXlLffvstUlNTMW/ePABgYp1JngtnQ/GioqLcYrUnD5HMzEw0NDRg9OjRnP1kpSY0NNSp9g8dOgSZzDRJcwdGjx6NXbt2QSwWQ6VSueUafLz55pt48803GRfdvLw8vPjiiy43EvoyfFVvCLydvy33fpFIZPMe2C/3znoxsctaO5MIXQiiq/Wg0iZyeK5TxOH4uTYsFUhMy/4sa65HL/GCEmjbdNzAREVolZw/MbEGKr0Y27ZtQ1JSEhYsWAC6oRoymQx0Yy2o24FMhZyfFRdAcrUOv55pfz/HxMS4XfNPnTplVmRCSPMdyXly+PBhiEQilxqh2Bg9ejT27NkzaM1fsWIF3n77bc42of7esGEDnn76aebz9u3b3fY882V4u2bagrfztxWyZzQabd6DtfA4wLKRn/+MIO3YE5ZnC1R6MT7cdRpPTk7mtE+qlL5e1YjVhQV4TxEHKAY8l4jBqRzVjAGJfW+Em7yojPGEFbo2OZ6Otb8C7JizX4EeEY2FSx6FRqOB0WjEezVXQQVyvW0krHxHNCvvESWTmWvq2JmI7emBrPEdu3kIQTD/Ikvzjx07ZpZwnK/5dEM1MCIaVGKiXdesqakBTdMuNUKxkZaWhn379kEqlQ5K85cvX4533uH271Brvt8Q5SF4Y+IxR+Dr/AHfvQdf4r1v3z6MGDECY8eOZbbx+Ttr7GpraxtUWIMtxMfH49ChQ2bbB9v/Fy9exIIFCwbVhjWMGTOGmUjxXW7dhaSkJLz66qvIyMiA0WjEhx9+iKVLl+LYsWPIy8tz+/W91XOUDV/63QrBlfxdHaZhj8GHoiib90ClFyOYlZCbbLMFshrPzr3Eb9cS2C/fbM8ktpeRTCoBmo+DlnJf2eaHK5m/2RWRgh96gTmXH4pHwP/MTFoUwiEb1io/sf8/cOAAIiMjmZVbAJA0HwdY3E0r6y1YU8pN6m6pn8i+trY2jBgxQvAYVyAmJga3b9822y6TyUBfrgFypjJ8HMH58+fdqvlpaWlMovTBaL5UKkVYWJjN45YsWYK77rqL+Txy5Einr+ks/Jrvfngzf6Hccnz9sEfz2R5MlgxbRH/4XqF8Duwk4Na8uPjaOnDd/jYVjRBJpHj/WAtEknaUx7YxRiMSXra+rsVi0nH+toG8gHEDxqp+by1bWsZui1yPcCf/H9j0FsJCglCQm8lwM+p1EEm4Vecs9QmbB9/rtu3adcREhFvl6Aj4z5moqCjG+4kNovnkmct8r/YV/Mb58+cxd+7cQfO1hJSUFKYgkq9r/rA0RO3ZswdLlizxNA2rUKvVAIQtj74AX+ev0+lQU1OD0tJSjyd8cxTu7HtXJwq/deuWWb6ikUVz0LD3m0Hzv3XrFtLT7XwqOAmhl93B9v8DDzyAH374AVKpFGVl9q84eTMWL17M+fznP/8Zb775Jqqrq4fEELVnzx4sW7bM7dcZDHxdM72dvy2DkU6nw+HDhzF16lSbmu/MSvZgVr+BgckIvx31kUr05ZoMIPJ+QwhgeiH+on7gGDZ6N75i9VrsyYc2qaDfKGQ9eS7A9QKwNIm5efMmo/lk5V597hA+uhUDsTzE1K7CPC8Jf2LHNsiRayoUCqcr09kLi5qfMJbjUebI9000XywWM57BvozQ0FCnPYJdhV27duHee+/1KAdb8HbNtAVX8nfHe7atkD2DwWC35lvyhiJeoEKV4swNVm1YU5oGjUbDSWwOcL1JiQGe7ON+Nhk8VmWF45NTCvxqeiZngWPruTa8s9yk1cQ4Yq0CHttDFwBWFyZA1lwveKyZIS+9GFBwF0fKUQ12HkG6oRptt27jvp8/z7nm33eexOMTR1kNJ7fmYUv6RnHrNhJjXbP4YO8CAt1Qjd4e09gnz9xyOFb1b+XKldi5cycoikJZWZnPzTP5cKfm+3bPWMCtW7eg0Wg8TcMq5HK5x6sPDQa+zn/ZsmUICQnBJ598go6ODmZ7c3Mz9Hq9B5nZhjv73pVGKJqmmUoP0vRJTL4pdZ/WJfxv3brlVo8owBQ+yB8Pg+1/mUyGBQsWYPTo0diwYQN27do1ZCF0joAkMWT/I3H/1mAwGPDpp5+it7cXJSUlQ8AUUCqVXtmHbPi6ZrqSv6u9GYRCJPhYtmwZIiIi8Mknn6C9vZ3ZPtSab61KHN8DifFmCpBCHiDl7LPnpXrXs5tM57Ne9tkGLyq9mFlZJ9e3NiEjfMj1+RMgtuaT66yva8HHXSNBSQPMVtIt9YGl/UOh+VKp1KbmO2p0JJqfmZnJaD7JATNc0NHRgfr6epw5cwaAySOgvr4era2tbrleV1eXX/PdDHdqvr0aZgn25I1asmQJoqKisHHjRigUCmb7jRs37NJ8voEf4P72yT3w8/IRQw8/lM8a+H0RGBgISso1ABK9NYXVCXvfssE+hhSjINzWKeI43kd8Tevd+ArnOusUcRzjF8ObpmGI4aavAICfTc20OHYshZEL4XZQIhKKB5/iwZKHM91QjYCAAGjO7OMcJw+QIjin1CY/S5DJZJg/fz6ys7PxySefYOfOnX7Nt4Bh6RFVVlaGr7/+GomJiZg6dartEzwArdaURMxXV0pcyd8TlmK9Xo8xY8YgNzcX27dvh16vB0VRUKlUMBqNWLJkiV3uip6Aq/reVYnIhdDY2Ijq6mpMmTKFuQ5Ba80P0Gq1g+ZP07Tbx05iYiKuXbvGWYV3Vf+TEDqFQoFvv/0WK1euHFR79mL7tUiIKevu6l06MT777DMzbzZrSQxPnjyJkpISaDQahISEoKKiArm5ua6ibRVz5szBtm3bEBsbi+nTpw/JNR2FvePGW1fOHB331qrxeAJ6vR5paWnIzs7Gd999B51Ox9H8RYsWOZ3U1pF8QQNhEuCEOQDmOU/I5KVbZVpYC2Ctru96dhO0D4yDOkLHmeRYmjyRkA/ymYC/Yi7Eg8DaZOrKlSuoqqpCaWmpmbHtiQkJgufwJwflsW14vQr9fw8cQzwLdM1nIJG419s90diBK1euYMyYMQw/bZzJq5OMfWfLjZMQuvb2dmzbtm3INH8o8PXXX+OJJ55gPj/wwAMA3Jf4du7cudi2bRtiYmIwc+ZMl7fvCvjf861jsNVEbUGv1yMlJQXZ2dnYtm2bmeYvWLDAalEXdoizkKEGsG1gYnt6EqOOLUPM6sIEvFV1CQA3NxTADccGYObJyt5OdH3Ak0mYHx/fJIzFrNdWccIMyfns46/s24IDtcdRuuxHZm2wxw77/kwGMdPftvpunSIOx4/XY8GCwYWIWns+U+nFOFC1HWNkLciSsTyFdXpQ/fMU9vPT0XcaEkLX3t6OrVu3YtWqVYO6F2+CqzR/WBqiwsLCsHLlSnz88cfIzc31yupRZNXQV+FK/p6I9Sf8ZTIZli5dytmn0Wiwfft2s0m4O+GIUShtqinXRPvx/YO6pjsMUIDpAXTw4EE88fLfAbyGV/IfBgC8cGIDAN8a+2PGjEF9fT3HEOVq/rGxsRg5ciROnz49JGFs9mLlypX497//zdlm7YU0KysL9fX16OzsxObNm/HYY49h7969Q2KMCgsLw4oVKxhvF0vVozwJXxr3QrCXv60Eso7CESOPteuyNZ8fuq/VavHNN9/gvvvuc4gXwMrBBOEKSkKrqSQk4cmmj9HbZHohL48VnhSoj1TCkDuV85kNvhGKXRVv1mur8F7qI4CNkDv2/fBX/MlnEpZHjmOvjGu1Wvzh3S9QdM9yfH3d/HkuNHb4oRmkXaGVfoYbq/y2u5A+YxlqamowZswY5t4NvBwig51Ax8TEICUlBadOneLkT/RlPP7443j88ceH7HohISFYsWIFNm3aZLV6lCdxp2i+M7D2G3LVIgbhL5FInNZ8onl8D9DV9z4HWXO9WbizWe4ohbAHLNvIw39GrK9rgdFo0lGih9qkApSjHpsuHgfmzmTO5xu5iOcTkMbpY7P+VjQyVfD4nrizXltl0mUFd+GEfZ906iTsberEI4vnghIIlxYaO+sUcVhdmAA0C3tzDXAf6J+F2ZbDDu2FrRyNv8sPwMFjLcgancIca1QqOfcw2PEYExOD0aNHo76+HgUFBYNqy1vgKs0floaorq4ubN26FRMmTPBKIxRgeoj6MlzJ3xMeANb4BwYGIj4+HhUVFYyRLD4+HhqNBllZWUhKSsLZs2dBURT0er3LjAf2GoZaa3cjJLfUrmOFcj65Og8UG1qtFvKkTCAoApSEKy/kmr409qOiosyS17qD/5QpU/DJJ58gIyPDaxKE2pvEkEAmkzE5uyZOnIiamhr84x//wFtvveUuigx6enqwfft2jBs3ziuNUIBvjXsh2MvfHV5QZPU5+KEXnG7DGn+ZTIakpCSO5sfFxaGvr29A8783hbkZDAaMnT9Q7phvoCETg9WFJi8gfg4oAEDqI6aXfJYRiW/kKY8d8Hyat8dU0ppthFq4/x1UfL+Hcx9soxTzd39EirXvhf+izp4c8Vf+ifGIJLv9//ZdRF3l18ibMgt8kGuyw2CEKk+5qrqgK4ygERERZiEUQW2nQY25y8IZzuGuu+7Cpk2bkJ6ejsDAQJe2fSegp6cH3333HXJycrzSCAXcOZrvDrjit2xL85OTkwU1PyMjA8nJyfjDJzsBACvDW5GbnsZJDh4YGIjXFXFYk27u0WSJM/H2ZB9HPJ7YurpOEQdKJsdPY9sAmKr+8fM6sQ322qQCaNHvdaposdonAAntM9d9U5/H4UkM5A6k0ouh0Wg419fr9fh040YsWLAAlIX3LXbfsw1MplBwCO7jG6HcDfK9hRXMgurSbU5/fHSyHT8vSXXp9SZPnozPPvsMmZmZCAoKcmnbvgzvjAEYJLZv346lS5d6lXcBHz09PT4dL+pK/p7wiLLFv6SkBMuXL8d9992H5cuXIy0tDRMmTMDp06fxySefoLe3F319fbhw4QIaGy3n/LAHjhqGenp60Hrke7uOdZfByRI6OjqQGboEpTG/Yra9cGIDnv/y18xnV4wdrVbrsdLC7vrtzps3D1u3bnV5u54CTdN25ZRyBbZu3YrFixd7tXfBnaL57OpDroA93if8ijtCsKbCWxIAANNMSURBVMX/rrvu4mj+6NGjMWHCBJw9exaffPIJurp7oYvPwcUrzXhh0y4mrwY7gS37vtfXcScEa0pNExn+JGWdYqCSEZVezHkJJzme2qt3oketZbYTo5D24nEAAwYqSy/wxChmCeQ7Iyv/vRtf4Ri92F5L/HxT6i4lAoKCERwWwWmTPVHi9z3JN2XtuzXL5ZE6iaP5Qt+1tfxStmB17Ki1fs33MmzduhULFizgVGf0Ntwpmu9q2PMbJlpr7Vlji//kyZMFNf/8+fP45JNPoO7pxMq8EWjSh+KiIRJUejFHY8j//GcBO28U0VX28UJt7Hp2E7ZO+zHDjdaq8a/mMI62C4VdE81fX9fCyfdny7jPXiDhP7PlRWXM84tuqMb6uhbOs6UrJhvBwcGIiYnhnMf+u+vUfvT09DB5ptjV+sj1hTyg2MeUF6dwHBVc9V5hT1VcWqt2y9i/5557sG3bNpe368sYloao+fPne721MSAgwGfjxoE7iz9FUUhMTERUVBTmzZuHBx98EJMmTUJ+fj4WL16M9NK5ECflQKPRoKKigrPCwkZdXR1jtLInUaJGo0F9fT2TeL+1tRXbt2+HRqMZVN+7yzglTsrFyPGliAjNBgAURzwjeD1XjB2FQuHWMt5sSKVSJt4dcN/Yj4qKwogRI7BlyxavT5jPx9q1a7Fv3z40NTXh5MmTWLt2Lfbs2YOHH354SK4/b948v+a7GY7wtzaRcMb7JfihFzj5OvggXjXEGCT0wuqs5peVleHBBx/E5PG5Js3/8W9w68Y1PPvOV9BqtdiyZQu++OILM81fU5qG+vp6XLpkyvVBftPm+TIGjFNarRZT2vfjiZArUB+pxNgXF0L0yhNQqdXYu+w32PXsJsiLyiyG55XHtnH2aZMKrFZJYsNa8lt2m+yJ0Y1L53C+tgrpEyx7C71e1YiAgABIr58QTN5rLYks2U6lF6O9vZ3j4e7K/DL8cRUQEMApeCPPKnbLbzciIgLx8fE+qfmeRllZmdd7HN1Jmm8NjhoQiPHCUv4jYMCbyNqzZrCan5o3Afn5+Vi0aBGam5tx6NAhRvM3b94s+J5fX1+Pi43XAAxoPtvIwr8nzZl9qD9zAZr+tto7lDhdtRtqtQoiialAhTapAOWxbZAXlUGWMd7krQSTFpME5OWxbVY1nO/hCsBiUS/SPmCus2cuXsa2D9/AjJSB357QMzdAKsaHxweSVq8uTOCEGQp9d/x+6ujoQGRkJGebq8BeAAKAoKAgqFQqxkj1dGm6W367YWFhGDlyJCoqKvya349hGZrnrUmm2fCEF5Ar4edvgkQiAeSh+PjPz2Hr1q2YPXs2Ojs78cknnyA2NpYJ60pJSUFPTw/a2tpQV1eHrq4uREdHY8mSJYyh5uLFizh16hRTeSggIABjxozB119/DalUCqlUiqlTp2Lv3r3Q6/VYvHixQ2Fc7grJY5KRUxTGRf0IEonJIFCtfEPweFf0fXt7u9urJxEkJyejsbERWVmm/CTuHPtTp05Fa2srPv3000ElTx5qKBQKPProo2hpaUF4eDjy8/OxY8cOlJVZT0bpKvhCP90pmmk5LIHkshj4TMK7BK8nkBvKHg8aizmQBtn/pH2JRIKcu6bjaOXX+PrrrzFr1iz09PTgk08+QXa/5hsMBhwWK9DV1YW2tjbU19ejq6sLYeo2LJ87k5mM3KOuxZYfLoM+fh0GgwFSqRRjAsTYuucg6MYzEFMU5jw8G5WfbsDJvl5MoE2vbO+lPoI16WmQZewBMBDWsU4Rh/L+cDcAWM+EtwjnfSJgJ7b9ecYDWBgfglmvrTIzePE/BwSF4Km7J6CoKMfMA2xdf9jKmtI0dJ/aJ9injhgl3bn4wO8PRvOlnQAAOmGc6X8H85XZgylTpjCabyt5sh8D8IV+Gs6az//t2vpdEM8Wa8Yj/j66oZqjXXzYMkwMtv8ZjyeKQllZGTZt2oTr169j1qxZUKlU2LRpE2JiYhjNT09PR/upg6BEFE51Ueg5eB7113tRMHOg6tuLn+9By6Xz+KIlBkajESJFAzJSR4H+/cPQSsTYf60XaeMm4srJo9Br+yBaMs1sIYF8JsZ8tmeR0PdAwv/MqvvB9DxmG57W17XA8OVfsfre57C+roVjYFqniMPSvEQcuxqATm0m1vD6iQ3aCMBoZDit5yVdZ4PvyUvuoa2tDdHR0cInDQJUejHWpHO3JScn4/Lly8jtj5LWX6oBlTbRLUVXSkpKoFAo8Omnn+Kee+7x2nQSQ4VhaYjyBeh0Ok9TGBRcyd8TOaJcyd9wuY7zOSIiAikpKVAoFIiNjcWGDRvQ1NRkVi3h9OnT2Lx5M4KDg9HV1YXk5GQsXrzYZNxigR9uNGPGDCiVSnzxxRdISEjA1KlTzc4RgquMUPwqeMURz0CrVeJo9z9wUvINKB1l9Xqu6PubN29i9GjzkrHuwOjRo3Ho0CHGEOXu3258fDxWrlyJzz//HIsXL/YJw/q7777raQpejztJ8y1N2E0vdGnY+vm/MT5uwFghdD77f4LBGAEG0/98r501pWl4HUvQAtOEeMO5Tqx5+GFG8z/55BNcvnwZqyaT0I15AICzZ8/iy/rTCLqwDbVHL2FClgwLZ5ZClj2Vc69jM8cAmM18Lnvocdy1ZAUOHa3HvmYNno6/DiANVEKWqQ/7vcXYhj1LngTsnExUejGzQk7CAPkgHljECPVef36r7o52XDpeg9CZ8zC1uR7lseYTCnKd7to9CBw/jdOmo7h58yYmTpzo8HnOIFmvwIHDx5E1owTAwNgJdlOVL6L5X3zxBebPn+8ThnU/bMNezfFWg5U1/vwk3dYm7GtK07BlywnmbyGwQ+3YBovBGH8Ho/lCOarY7/BRUVF48MEHGc3ftGkTzu/fhoeWzOO0U2yIxMmTtdi27Sy6u7vRfVuM3NJZuG96huleC5IAEM03GYXW17Ugc0IRNKpebPmhErHRkTiRMg+/np4B6qR5DiiykGCpsh/JRahNKoBc4F7JIkJ5bBuebDItaqi//CvK+xc3SB+0t7dj6/v/xCvzZuH9ngFDIbuyKfFKNqgjAeiZvrRUhIL/zGC/E9y8eXPI0i1810bhYt0h5JXejfLYNuj0BlA6ndsq/8bGxuKBBx7A559/jnnz5vmEYd1d8BuiPAR7XYq9tZS3K12iPfEQHgqXbuKxY6lcZ15eHvLy8tDY2IhRo0bZZUwCTNxDQkLw4IMP4urVq/jmm29gNBqhUChcxp2PaZM+ACDs5VStfAOjDROB4Egzo5wQXNH3PT09Q2agCQsLg0qlYj4PxdiRyWRYvnw5vvzySyxbtszrQxD8sA1f/w4d4W/JCEVeSOeHK7HcijcU31jiCgym/63dD3sCRV5a77//ftNBTVxjfPKxzcgqKsM1aQLeHh0GiURi0euLHUIRMnE2QuQBWLWoDM0tCmzdcw44exNtbW0oHydc1QiIM9vG7lf1kUqgPxk6G69teAoAOCGA4v4KUdqkAqyGaeJyvrYK+dPL8OysPOb+Cdg5QQAgpniOWf85iq6uriEz0IQVzEJfYyfzXYToByZU7pqYkAq+mzdvxr333uvzeuHHnaH5jHGet6DANiC9XtWI42dacHWEdWMV0RB2Nc3B6P9g+t/e3zl5z7/vvvtA0zTWHb3OnE83VCMlJQXf35JhyUgKCeprUHSMtNo2yfOkN9DQjsxHUA5wo+0muk5WoOJWBm6cqALGcSv9CS3crFOYko6zwfasIl5U6iOV2NJxN76/Z2D+QXRffaQSSH2E0b1du3ahbfwKvN8TCsC8SizxuiqPBd5ojem/DjdpOQC7EqoDwO3bt91uoCHj9NlZOajoPIfl/YtlYUMQNieRSLB8+XJ89tlnWLZsmU8sOrsDDlk53nzzTeTn5yMsLAxhYWEoKSnB9u3bmf1PP/00xowZA7lcjhEjRmDp0qU4d+4cp42vv/4amZmZyMrKwrfffstsb2pqgkgkQmxsLLq7uznnFBQU4OWXX3bi9rwX/iSGA/CEsW0o+18ikVg1MqWlpdlthAK43JOTk7F8+XLce++9mDFjBj7++GMmT1VlpXliQ0cgTZ+EaZM+YIxQbBRHPMP8A4CG3h1m59rD31fANpYOFf+goCAsW7YM27Ztw9mzZ91+PT/cC18c92y4gj871MEW2MlfXQFH+LMNTOzEpuz9BEKTColEAoplhOK3kZKSAln2VIthFGwjlLyoDD3qPvSoTYn/kxJisfyn/4Xly5djxuhIfLzlO1R8vwcV3+9B5SVTKBk/MSxgmlSQdkk1PrYRanHLKcx6zbRoIr73OaxTxEF873MATJMjbVIBZM31zOr5THk7JBKZxYpRnGTl/fz5yd3Z/4QMj64Og3MEntL8e++9F9u2bcPp06fdfj0/3Is7WfPJb5p4atoDUtDBVXCWvzMFNyQSCSRX61Ae24bVhQlmhvlRuhZIJBLO88JSjqR1ijj8qzkU2oYaAEBi3AgsnTMdS8clYFbJJI7mf7f3kGAS8yebPjZbZFiniDNV2OvPOUWwJWo304a8qIwxAvI9V785eQ2/mJ5pxp3oNHvxge5T45GQa0yuL37+J3alPGt94u75IfsZw9f8rlP7BZ//rkRgYCBWrFiB77//HqdOnXLbdbwZDnlEJSUl4dVXX0VGRgaMRiM+/PBDLF26FMeOHUNeXh4mTpyIhx9+GMnJyejo6MDLL7+MuXPnorGxEWKxGH19fSgvL8f7778Po9GIJ598EnPnzuXkuenu7sbf/vY3/PGPf3T5zXoTpFKppykMCq7k7wmPKHf0v7tyMJldxwL3nJwc5OTkMJ/F8WNAhUQ6zEmaPgnFEc/glfyHsfXqwHZL3lC6hqM4e/Ys54Fv7Zq+OPblcjlUKhWCgoKGlH9ISAhWrlyJiooKxMXF3dHuu74OXxz3bIibj4NKs2xgthdUejFwsmXIjQzu6n9LXjJs4wp/OxtsDyXxvc8BihazCYBUQgmenzU6BVmjUwCYJgHH9+7AhVBTaAj7RZ+sju96dhMWt7wAHKnErNdWMV5PSzvuRlNVI5D6iKlhUn2p2dQGqbrHnkyUTshH+819QNK4/nuwXHLbOCofgYGBFvuA3x+eNEARhISEoKenByEhIczYcZc3FP+6K1euxJYtWxAXF3fH5w/xZfi65n9YfwM/npwy6Hao9GIszG7p9zaxfSz6jSKD9Ywdqv7naxYx1quPVAqGwg3kSxzI68Q3fInEYo7uEy8xtuarj1TiOyUgnzHwvGDniwJModTlaDPlgVK0cLyihAxY7GtxDEsN1Xh5ViqOfPUhkDyXk+ORrf/knNXFsQBGgwoOBjDgIWZp8WUotNUWwsLCoFQqERERAXHzcYglQ+MkERQUhBUrVuDrr79GTEwM4uPjh+S63gKHennx4sVYsGABMjIykJmZiT//+c8ICQlBdbVJKH7yk59g+vTpSE1NRWFhIf77v/8b165dQ1NTEwCgr68PYrEYBQUFmDBhAiQSiVl57zVr1uB///d/3Rpm5A0Qi8UeKz/vCriSvyc8olzd/9Y8gFwNR7gTgxDhZy/Phcm3re6vVr6B/UcfZ9pXKpWIixt4aEnTJ1m8li+O/ZSUFFy+fBmAZ/iXlJSgsrLSa3NJ+GEbvjjuCeiGaogpCqIrtkNv7cG280P/fHek/0l5bUuTIGvVnNir6fyy3nywDVXvpT6C9XUt5ivC6cUQUxTE/c9JS/mzSMgjv3oSmZiQ1fHeja9wVr2DH3oBSwtHAgC21JnCSlYXJnAmKcQTirRdHtsGZVc34mOiONWH+J4ABB+fasc7R5stcmffqz0TTleV8baG1NRUM81358o4H1OmTPFrvo/DlzX/9apGQCTGO0ebnW7DGa9WuqEaclbBhcF4xjrT/0K5oaxBKI8heX68l/oI1iniBD0/iUarj1QyXmPsxYNHrm3Ge7fimWOsgWgwO9xOXlSGssaBBWFSWY8N/oIHSVr+XuojZl5T6xRx6FB24QdxFnN//PsnCxbAQN+zQ9fZ3yPxzCL95Q1IpTrRsPcrAGCeueT7GwpMnToVO3fuvOOq6TltATAYDPj000/R29uLkpISs/29vb14//33kZaWhlGjRgEwWRufeOIJJCQkIDExET/72c8QGhrKOe/BBx9Eeno6/vSnPzlLzSeg0Wgsls70BbiSvydetFzd/7qGo0PiDQXYz33zm3/jfOYbhoTC7qZN+gBH507D/PirmB9/lWOQIvcodK8ZGRmor6/nXMdSfwy277u6uoY890JaWhquXjW5h3nitxsfH4+SkhLs3LlzSK/rh+vgq5pPXjS1ieOgTRzn8Hnkb3ZSW6PRKBj+wP7samODM/1vaxJEQgzY98o2YrH/UenFCH7oBYttkYkIuy0ySdFo9dBoB15OOXmeLPAmE5Mnmz5mjiNeUASkjDYf7BV90hZ/EjMmZSROnL/E2UYmO+yV9HWKOBj1Wvwo/IbFe7eFv/5wEkFBpmqsgxkXjoTcpKWlMYuonvjtxsTEYNq0aYMOsffDc/BVzSe/kcfGx+Gx8ZY9HS2dR/4eCoOxNTjT/2wjCxtsXRZabABMWkf2ES8fIYMNW0stFW4QjZvG0UwSJk1ANHZ7Z4RZuyS0en1dC8c4xNdlYniSF5Vh17ObsL6uBesUcVhdmMD8Tdotj23DrqBC3GgYSLfDfs6sKU1jnhtrStOg0Wjw74MXmf7igyxuWAp902g0CAgIEOwbR2FPeB3dUI2UkfG4ITJFHTj6vuMKREVF4e67777jNN9hQ9TJkycREhKCgIAA/PSnP0VFRQVyc3OZ/f/617+YZMrbt29HZWUlJ/TupZdeQnt7O27duoX/+q//MmtfJBLh1Vdfxdtvv41Lly6Z7R8uCA4ORnC/y6IvwhX8rXnNuBu+3P+WuPP7csXP/o/g+dL0SXj13v+PMTKR72HapA+YbXmTuZ4PJCyP/Z2Rv6XpkxBXNBdGo9GmEcoaf3vR1tbmtjLelhAUFMR4b3pq7CQnJyMgIADbtm3jJE/3wzfgq5pDXrQd4S+0SiwUfsB+4be2zxVwZf+zV3kJ6IZqswkKAb/CFH87Ad+wxHgtBcoQHCgTPJZ9jj56YNKzujCBmYS8l/oIFu5/x+Z9LS0caeZRZekFPiIsFNrIFM6x7KqCBE82fYyfjexi+PNXxoWMkfxtK8aEMGW8LU0U7YW958pkMhgMBgCmsSNvHfqcTUlJSQgODsa3337r13wfhK9qPvmNOcJfSL897eniqv4nGti78RWORxM/j6BQriNrRhC2NykB0VO25hNvWXKONqkATzZ9zDwf2MYmABzvVT5IBVSyb9ezm7B12o85zwcSvsduY50iDoHBIViYHce5J6HFmNerGvHRyZugZAPh2I6OBVe+59vjVUelF0OWPZWj+R+dvOmS6zuCxMREhIWF4euvv/bp/HKOwOGqeVlZWaivr0dnZyc2b96Mxx57DHv37mWMUQ8//DDKysrQ0tKCv/3tb1i5ciUOHjzIyQ8QHh5u9Rrz5s3D1KlT8cILL2Djxo2OUkR3dzcCAgKgVqsRFBQEjUYDo9GIoKAg9Pb2IiAgADRNQ6fTMXkApFIpKIpCX18fQkJC0NvbC4qiIJPJoFarIZfLodVqYTAYmHOE2iGJqTUaDYKDg6FSqSASiRAYGAiVSsW0o1QqERQUBLFYzBjqtFqtWTtarRZarZax6svlcvT29iIwMBB6vR56vZ45R6gd0r6lvggMDITBYLDaF/x25HI52tvbQdM0EhISLPYFux2hvug5fRBarRbbtm2DXq+3eA+2+tTevmC3o9frodFoEBoayukLfju2+sKZ8WVtXNgzvnp7e6HVahEfH89p5+bRH5h70+v1oGg9Pv/8cwBAgF4FmVSCBMzEXSM1ONt+GuND23FaeRliTR8CA2RQ9R3D2dZeSPW38dqJdHx143us/8uL+JVEAr3+OYSk5SKABt79n5dQUVGBj//8HH6y9hUky2ahWfsDwsPDcatuF4xGI3Q6HacvUkrvQY+6D61HvodarQZFUQgICLA4vqz1RWtrK2JjY9Hb2wuxWGzzt8Zux57xpVarAcBsfJG+bW1thVQqRVhYmMO/NUfHF7kHmqYRHByM/Px89PT0YNOmTViyZAnCw8Otji+tVuuwfvoi/JrvXZqv7lEjNG8q/rnzJEQiCk8n3IaqT4efTCw1af61SNxXNApKpZK5B4O6B1SAHEql0is0X32+GmFjpwn2Ka1RwWikUT49G8rTTQiQSkAbaTwc1ISwsdPQUb8b+hP7EXr/c6bfpE4HlUoFo0qDIK2WMy50PWqIT+1HrwGQUQCt0UKnNyBEHoAedR8kYgoqjRZ9ej3CL9XAOG6aqS8K74ZKo0OgTIL2qu+xceRyHDx8FmhvhO7SSYgmLgBdtwNiowGnr2zHT41GGBGNWbd2Q0IBBhrY3V0Lo0gMkdEAGiLMSovEptomSChAfekCKBGAo+cQkzYWFRIKWj0NEQBKBHx7A3g0JwxdqjisuPgfRN01G0plJAJGjgfd24v1V4Lx86RudOqM0FT9APm4EmzqSsAzM0zfO+nTh4OaoD57HVqdHu/vPAlKJsej42KgVqs5mh8eHj5ozf9Z/5hzRPO156vQ0tGJgLQJCLl1AXqlckg1f+zYsVCpVPjss8+wePFiv+b3w6/53qX5BnUPyqdno7OzEyKRCB/Ut4LW9eFnUzOZ+7PrPT8mG8HBwejub2coNf+tqgY8MyPHrC8CdXpodHqodUboqr/Hw2On4fXrCYBRjb/vPImfJ9HoUffhP3vO4Cd3paGvrw86nQ49Zw6Y7kEqgSZhLALOHoBWb4DBQCNELoNB3YPHCpOgNIYDV48zmq8/sR8qvRHisidR0aTBj8JMxbzeaEnEI6FNeOuwFg/qjdDFZKPr5g786v97D7QR+CmAGSnhiKEa8cV1CQxtDZDEN0PXchESChhBA180XkBwxlj0/msdKNA4J9Iib+0T2FTTiFONtYCIwk+NRkxPDsPn16TYdakdRgBGiDBZdANUZzNeD38Oj0Yr8J/9F/FIaDPz/CPPcLpPDVrXB5FIBJFEhmdm5ECpVEJ0tR6BWSV488AFUNIoGPUqKHvUCJHLoFIqOeOrpaUFoaGhQ/6er9Vq8c8DDdB33sIDIzoRFhwIpTJySDU/Ly8PKpUKn3/+ORYtWoTIyMhhrfkOG6JkMhnS0011OidOnIiamhr84x//wFtvvQXAZGQKDw9HRkYGiouLERkZiYqKCjz44IMOXefVV19FSUkJnnvuOdsH+yBEIhFEIpGnaTgNP3/PwV7un775v5g9ezaSS+eDCo7AxKgn0dcnRkZcB35ojsCVWyJQwe+DkmhByaRoQi1WJNwLrcSIa/pIUEFnMW/ePISEhCB+4t1QnDZ5OWm1WsQXzcVLE1bh+UlPALQIT67bje+//x6FhYUYPW0RVH19aDn8PQAg8a4ySFlx+oPt+1u3bnG8MIcK0dHRaGlp8fjYiY6OxvTp01FdXY158+Z5jIcfjsHT42awcIQ/lToBb1Y3OdT+4xNHMS9pBHTTMSBvqkPtWIKr+p++dASPxejxwc1ovFndhEfHTQCun2T2/6u6CXRfDB4CQF8+ClqnBx0oAxLGgkotNGtPc3w/an6/GTp5IOZ/9TfQRlP/oe2Mw9zvnZyFspx4yGaWQpswFhr9JYTd9xsoDjdCRImxOu4WlDW7IRcDovzpaG2PASUNAK3VQCSRQUEbYIwdiydaKtA7PgNSCibD07hifNwzCnSfGiKKgkgswSvyjfi++hjGGm8BALQj8wGDAfTlo3jnZjTDKXD8NECnw6cdIyBivXG+V3MVP50yUPOdSpuIx5MNZmMAAG7evIn09HS8U3MFTxePttkP9oK80FtCTEwMrssSIB2VDOO1k0CQa0JFHEVkZCRmzJiBqqoqzJ8/3yMc/HAcd5LmPz5xlEuu+UHtNZRPz3ZJW67q/7dvxuLRCFOYnHzSbPRquBN/akwRqJ4eoP4G3j5yBUa9Dj8b2QVN/X7IJ0wHNaYI9JmDQMBA8vR/K+IAmIwh0hunoOvf/tGtGDw5YQbUR/dg88kW/Hy0Dqr+VMo/uvIpdv7xWzx9ch+0UTOgbzqG+8fIMH3Fffj0bAcA4KZBj58ndZsWMbJjIRFTeDsyC5QsAEadFo9OL8a+Rb9CUGAA7n5xEYK+OofiMB02j5qMnFg1RGKTSLcb9HhmRg5a9p6FiKLwk/jbUFS14ftmk2fmh+0x+NlIBXr7Ix+ptEl4PEmHj06149HodvREjUFgYCAnIopKm2jWt1TqBFAhIQBP82/duoWUlMEnyhcCfekIaK1O8Hk8YsQITE6kIEsdiU2npaBUcjw20i00rCIyMhKzZ8/GoUOHsGDBgqEnMIRw2BDFB03TZgnHCYxGI4xGo8X91lBUVIR7770Xzz//vMPnhoaGIiAggIkvZf8QIiIizI5nb5PLTTUO2F5bpB12vKqtdogHGLsdwsMSN5IDgd2OTCZj/tl7baF2BtMXQu2QSi4SicSpPmX3hUwmM2tH6B6s9amla1tqR6vVIjQ0lDnfmb4IyZsCXcPRQY8vdl/Y0w45XiqVWu0LiqIwYtIcAEBxxDPQqE0hdkb6Gew/+nj/UU+a2uoPqXvxONcDccSkOSiOeAY50qcQnj+ds0+kM0X2br0aieeioyGXyxEWFoZbJ/Zzjus8VcW0HxERwVjvhfrent+a0WhkwjQA2781oXasjS92pRV2nxYVFeHw4cO4++67mX1D8VsTuocxY8agvr7e7HfDH19dXV1m1x2O8Gu+d2n+O8daIRJL8KvZAzkWZA3VwLVjCEgvtqj5/Oo5shA5cKUW7EySEQIu9m7R/IK7QTdUI6z/M5VeDOm1Y4BUAplUgl+k9ALoBRWRAURMY7iLqhrxq9njQDf0AgCC86YBANgmDEbDrx0DJRWBMtCY/8fFkAeYtqu3vQ4dgIj+0AuZxGTIlxXP5fCVhZhe4d5N/xF+EduGz9spBGWXmHKDjAlC0Kr/wvq6ln6uACBFuNQ0MXuvJwXifkd1sdyUc49J0J4yF6HgVk8SUabjVhcmQNZcj+4mQC4RIVQiMh1zst0UxhEgxZokojsUIkLkeOPGSIjlgEgixZtHrmFNaRp+OSsCdEM1ovr7+Z2T7cx3z/9uDAYDRowYgV/OHMF8n4Dzmk/CSD5TxGFNXJxFzb/rrrtw8OBBzJ49G3R3E2RSCaj+Noda89PS0lBXV+fX/H74Nd+7NJ/fp7+YHobXqxrxdu0NrClNs/s9XywPwb9ruAnShcK6XKX5Ye2mnEdUejF+NXscJ8RwTWkajEYjnknsABCIsClzoU0qQFRgIH7ZfwzdUA00HUUYgDVJphC2NTOyQTdUI27KXCYkLCLE1D8BUpNmi1RiiOUhkMvlkPWH4K1TxOEXKW0AAiArno2fQQupRIJwidwUgk2JMP+Pi035lbqTUR7bBolYjPDwcKxJamTl8qOY6wFgnlUAsHXaGmxvNRl95otFWPb9OqiPVEJEiZnnAGAKqaaaevGLfluQ+shuRAVQCMsaj6eSu8m3hYgQObRJBZA110MOQETFYYMqFU/nmhKt8/teo9HgFym9WKcIwS+mZwp+n4BpwTshYSDkcLCaz/5ey2PFCMieYtYOABQXF2PPnj2YM2cOxJdVEEmkTJtDrfnJycmoqakZ9prvkCFq7dq1mD9/PpKTk9Hd3Y2NGzdiz5492LFjBy5fvoxNmzZh7ty5GDFiBJqbm/Hqq69CLpc7bc3785//jLy8PEgkg7aXeR1IvL+QIcUX4OdvPQ+SKyFNn8S5ljXu7BxNK372f0CFRAIYyPHE5zxt0geoVr7Bqa5XHGEyVJF9QiiOeAZbr4I5V6/XQ6lUWrwHe/lbumdvQEREBDo7O9Hd3c1xtfcUAgICmPLifng/7NUcb62S5YhmOpMbxFJiW1dVrHFG8/m5jMpjzY8hicjJPZP/rfEWyhlC8n1okwogBzcHVF/uVFCpEyBrP8fJCWVWYrv6K2DpUgBgEtWy84SwzyWlt9lluMk9kgkNaZ+dJ8SUfwQILp6H3mt9DG9SrYnNi1QXpHWmiY9YIjUbG3RDtVmeFHeDXM/WOA0LC0N3d7dJ8xPGIlBgojGUkMvl6OrqQlhYmO2D/fA4/O/JzkFIIwgceR7Yy5/dJvvadEM1+GeyE3KTc/nFKmzx1CYVAApTOyQfE0kSrv7SlPup48guAEC4VGRKVM5aFFiTnoY16cDrVcDx22Fo7tdkotPsfIwk8TjZt7XfCLUwPmTg+ZH6CMON5J5SN3E5y4vK0Fu9A23HD0MdQ3OSrJNnAvv+lUol6KZjiCq4W7A/TTm2zPvbVt85C+6Ysqz7QUFBUKlU6O7uxqP5sYLGpaFEUFDQsNd8h5KVKxQKPProo8jKysLs2bNRU1ODHTt2oKysDIGBgdi/fz8WLFiA9PR0rFq1CqGhoaiqqkJsrMDbmx3IzMzEk08+6ZNVJ2xBLpczVk1fhJ//0IFvkLGHOztxuaVKd9L0SWaGJl3DUVQr38Dxn/8abxQdBzBgxCqOeIY5rlr5BvYffRy6hqOQpk9CQPokwcSCQsnobfH3VAJ7e1BcXIxjx455xdiZOnUqtmzZMiz1cTjClzRHCIPlz04YSlHmrx785La9G1/hvJDaU/nGGgbLf01pmkMvyOyKefztHF5FZUyiWGLoIdvXKeIgLyqDPECKgJZTnHP41ZbWKeIgyxjPSVRr+PKvzH7i3UTOY5cNVx+p5BgCVxcmMElx2Qam8tg2PNn0MQCgq6cHR0TJnPYJN9Jf5JyfTc0EJR1IVi5kdCQTJZL0nRwLAFvPmSfdHQyEEuxaQmlpKWpra73itzt16lR8/fXX/sTlPoI7UfOFKogCwprPB98j9vWqRsHfqL3PAVv8nXmeEG1lv3fxFyyE9I0Yv9kaz2+XXa00smgWIotm4b3UR0zeRrxFB8DUv/PDlZyFAsKBwPDlX5F632Jm38L4ECyMD0HTF9+Y3RN78eG91EewThHHWbzo0WgRxfK0Uh+pZBYcCIh+y+VyBOeUCvbhOkWcS5/t9sLeSo6lpaU4evSoV/x2p0yZMuw13yFXo3fffdfivsTERGzbts1pIqmpqTAajWbb33rrLSb/1HACCU9yVXnKoYafv+vgqPePNe5sz6bNb/4Ny5cvN7sW+7jiiGewMPk24wlVrXyj3+B0HNtbk5ljAJh5TvGvuXnzZot87OVvqS/Idr1eDzEr39RQIzk5Gfv374dWq/X42ImIiMDChQvx9ddfY+XKlcx2vV4PiUSCv//97+ju7rbSgh9DCW/SHGdgjb+jK5n2eH0FP/SCA+xsw57+t3UfrnxZZnsakc9MaBwGVsjR3Aat3lTJhz6227Ra3W9UArilwCtAwutM28gxW6f9GFtbe/DahgEjFqmexBinFKa2SJgFEAfDl3/tz2JiXtFvgyYDRvoi1iniGOMUG+SFf01pMbTd3TAa9BBJBvwL+H25ThGHcnArL60pTcM/Dlzi5Hlxxaq5I99jUlIS9u7d69Jy4s4iLCwMixYtwjfffINVq1Yx24nmv/7667h9+/aQ89LpdPjDH/6Abdu24fLlywgPD8ecOXPw6quvIjExccj5eAuGs+YP/L65RgiL2mmH5gt5KPINHYD9v317+n+dIg5QNFr1jqTSi6HRaDieRZYwYFBvY3hyKqkqBjyViDcUYPKSevLIX7Hr2U2Y9doqRvPZ1yN/v141cL1EDCwyPNn0scmTqd/DqTy2DYgtA7Cp3zsVePK1Vf3PBdMCw5MA1E2m54I2qYBjJFtdmABDk+lv9ZFKhAUFQpY+HvKiWQBM1fzKY9vQu5Gr/2seeoF59+T3PTGImRZBTP1EnjlMdVneWBEaa47CHgMUQWJiInbv3u01mr9kyRJs2bKFk2ubaP6//vUvKBSKIeflSs13yCPKV3Dt2jXodDrbB3oQBoOBKRPpi/Dzdw2c8f4h3Nnn8tvRNRy1uQJFDExbr0Yyf7+S/zAWJt/G9tZkvHBiA8cIxW+fj+zsbHz99dcQjy60el+W+t6evmhvb0dUVJTN49yJ6OhotLa2epQDQUREBLKzs1FTU8Ns27ZtGzZv3oySkhKMGuWaBKLeDr/mux+u5G/P6rjZOeQl1YKnkS0Mlr/QJMuestDkXALyIv5k08eMMYgd2geAKa9NXs576/ZCE2tK4Lt12o+x69lNHMMQaUd78TjDU5tUwDlmYXwI51gATDvapAKk3rcY6iOVnNLdxEjF9r4S3ztQQOY3EyORdOJzBEyaDQBmXlrEsGYwGPDYhJHMRIo9udImFXC28Vf9e5UdeLg4i/lsb59bAtuQZa0d9up5bGwsrh+uHJJVe1uIiIjA2LFjcfjwYWbbd999h88++wyTJk1CWprzkzVnoVKpUFdXhxdeeAF1dXX48ssvcf78eSxZssRt17x69apf890MT2s+0UTyW3TEmADY5m/3wonA755dCd5WW+z7AMyNUER3iX7uenYTDAYaBoPJILNOEcfRxdWFCZz/yfWFFieI1pNrk0UINogXFN9TS9Zcj/dYYXsA0P6n91Dx/R7QNM3xlmW3RTdUQ3fpKAwGA3o3vsI8r/nHEn7r61o4z/eOukpOLii+t7SzcKSdOHTh798dcXjMuQNhYWEoKCjAoUOHmG2VlZX47LPPMH78eGRkZAw5J1dq/vBLvgRTEsOGhgbo9XrI5XIkJSWZiYan4et5Xfz8PQdr3NkeRff+9Degnn2F5+lkwrRJHwDght1VK9/AwuSHsfVqJLPdUm4pIYwdO9a0kqHTAAFBDvHne2rxQbYrFArBEMChRFZWFs6cOeMR8RdCfn4+Nm/ejMmTJwMA8vLysH37dvT19Xl8NWeoEBYWxtH8kSNHeoVbNRu+rDmAbf4Oha05kQfLWoiGPdd2tv/ZBih7c5XYY7AgK9+2zund+ApiiudAXfkWQImYc95LfYTxYiIgnkO9G19htm2d9mMs3P8O1EcqsevZTdja2sMYpba29mDrw+8C6Pd2f3YTFu4fCN1jQ15UxskjZVptHw1tXDZ+d/A6RmU9gtRpizGLWXEfuKeQkBDQl44AYorTtryozGzyQ3KaEHTfbseItGTOMdY8L2zBnvP4k4+UlBScOHECOxVxWJNu4aQhRF5eHjZv3oy77rqL+fztt9/CYDA4NeEfLMLDw1FZyR0vb7zxBoqKinD16lUkJydbOHNw17x06RJ0Op3Pa74nvjN7YIs/mdTbo8POaL6QEcAR7xg2fyEdt8SX5M1jY31dC+Ntyg8r4+fXA2DVc4p4mhKdZBvwSZi23jDQX6sLE0znNJmOJR6r6+tacLwzAguffJy5Pj+ET15UhqYvHhH0wHrPgjcrG/zcf4/9Azh3/QYOffYRpjzwOHOc+N7nIGuuZzx9Q+QBQNsZSFj3xva85YRysxx6qPRi3Dx7FrGBXAMiP2zTUTh67qjblzE+KQHLXGAAcwVycnI4USe5ubn4+uuvPWbodqXmD0tDVEREBNMJKpUK165dg0ajgVQqxciRIxEaGmqjBfeDlCf2dCI0Z+Hn7xrYMvAIGWgId5vGIaPJw2nrVW5+JyEvJxJ2x7+eIx5bKpUKJ06cAKTWE0MS/iMmzRG8pjXcvHkTEyeal4B1J/jhgvX19Rg50gP1XG2AuOqmpKQgODgYDz/8sM9X07AX4eHhjPeXSqVCc3Mzo/mJiYlekejRWzTHWVjj76xRwNqEgD9xsHWMLdjT/yTxrLW8To7eq9Dx6xRxKO+fcAjtQ7+RCQDKi8qg7FGDWvQLvHfmNhM+h35jDZlQrC5MAI6aqqDuenYTgIHEtGVJBdg17cec65B9fGiTClCZZtJktgFr4X7TSveTTZX94R6ASqXBP76uRl7pLKTetxjAgMFqTTqYEMGuU6ZKqqSSE39VnkxM2JMsMnHo7VQiLm6yzT51FEJjjz/xJRxO7/4GtdIx+MsK75iUEBDNHzVqFIKCgvDggw8OSvN1Op3Z+ezqb46gs7MTIpHIbXrH1ny1Wo3r169DrVb7Nd+FsMbfWaOANUMS29ggZHgghQ3svbYl/vzk5MTbasB4ZF48wVIScvK5PLbNqhGKXEcI/LBsAOhR90FzfL+pyimjwe8M5Ovr19DvwqWcdghWFyZAiwHjEzESATA9X/qLWazHwLNmS911fPvjSWYhiMRQtk4Rhwc0WhxvuoF5BZlcYxLLkxYA2qt/QOD4aQg4c4DRe/G9z6Ec9Wb3zsetW7eQmZnJ2eYKjyh7jZh0QzVOXL+FUZPiB31NV4Ot+SEhIVi1ahUzzp2BN2j+sDREsREUFMR4Lmi1Wty4cQONjY0Qi8WIj49HVFQUJ//AUMFXq2gQ+Pm7B0I5nPhhcWzu/PA8tsEkM3gBx7upOOIZwfbI9SwZhOzNX7V9+3YsW7YMhkcesXqcTCbDotmfcIxjlq7Bv6eurq4hf6njV/wTiUQYO3bskHKwhalTp+Lzzz+HXC5HR0eH05VKhwP4mt/S0oIrV66AoijExcUhOjrar/lOwB38rRkUhLyQ+MYDYjiyxzDhDH97V9DZ4IcgyFnnsScinBdwRSOEJj/kOFqrAepbQMkCQaUXYz2rHWbS0NwGaXo+1EcqMeu1VYwxCgBjWAIGQvT4eG3DUwBgluAcAGa9torpa/bq/S+/PYO80ln4P6NVAGuSREClF6N34yuQjZ/BbGPymPSD5MEi0CYVYE36gAf73SMDBxWOzc65xZ/sEVgyQAEmzd+hDMH/rpnrNAd3YPr06fj8888RFBSE9vZ2zJ8/3+Kx2+pbIJFbN1B1qrTYvHkz7r//fs72l156CS+//LJD3DQaDX7729/iwQcfHBKDkFwuR3q6yVWNaH5TUxPEYrFf8wcBd/C3ZAQgOYMArsGGbzwgBh17DBNs/o4Yr23lgSJ8HQWjP7FlZvvMFj9O7oeMGjDas71n2YZ87cXjTIVUvnep4cu/AgK5owB2eGAc85l4Xq2+9zlGk7dO+zHKGo9ifV0Lnmz6GF+fbMD8CVkICxrQaHbOQvJ32KSZAEy5HumGasZjin0PlqqX3rp1CzExMdY70wr4Y8bR8Dp9ciGoSQuRn5/vNAd3YObMmWaab8mbcvuJFkiDrSc4v63SoqKiAg899BBn+1Br/rA3RLEhk8mQmpoKwBQ73NrailOnTJVoYmJiEBcX53Uusu4q5d3V1YW33noLmZmZgtcQ6gf2cXq9HgAgkUg4x9rbFvtYZ6sqDidY8jxiJwgniJ88BwCg7tMy2/gGJmn6JIwxFkGr72GMTCQ8j3y2x+BkjxFKmj4JtKYXMOhhaLnP5vEAABHxyHrcoUTtnsbRo0e97uEEAPHx8Vi1ahX+85//4O6770Z8vPet5HgCMpkMKSkpAEya39bW5vWa7y709PTgzTff9ArNdyS8lj2BEJpMuLLUsyXPJ/412C+2/PAUoTwYZCWfD/YquiWsLkzAW9XmEzNyPmCaLMx6bRXU50+hPScNJ/74LXMMMTCxwTZSEcMUNzyEG54nlDh+7YFbkAUE4b/m5lvM/8EY8NImgb58lLmO0LHk+iQEhg2h8cSebAgZCu01UAp9l2z8/qNtSBjtHWHYbMTGxmLVqlXYsGEDZsyY4ZKk4CtWrMDbb7/N2Sa0Mr5hwwY8/fTTzOft27dj2rRpAEwr7CtXroTRaMSbb745aE6Ogq35NE1zND86OhpxcXEeLXgylFCpVFi3bt3Qaf7pLYLt0S3nMWKscAU1IbB/h+y/ye/ZFd4xBEJheHxYeu4I5f5j/80P42XrFPtctjGeGHICJ8zknMvWZ21SAdCvoZXRU/F/qbMwfPkxngSYnE6y5nqm0ATRXJJTan1dC2MUIqF5JCk5OZdg4f53QGYap660QCYVc4xQJMk58YhiPjccAUD0NQ5QtPQbGsH0AUnczgdN0zbfy4S8mwYbvkdQW1uL3NzcQbfjasTExGDVqlX49NNPMXXqVJdo/vLly/HOO1zv7KHW/DvKEMWGWCzGyJEjMXLkSBiNRrS3t+PMmTOgaRoRERFISEiAVCq13ZCTINUcgoIs59JxJ8LCwpCWloaysjKnOCiVSgC+63Ls6f7nw1ooHL9CnUxieolS93HP47dxEdX46LkpUCqVHGOUq40/W/75Jyz+ybMwtFy06/jkknnMvbD5OmsIcxXsqV548+ZN5OfnQ6vVes3YAYC6ujqcPHkSxcXFHklW6wsQi8VITExEYmIijEYjbt26xWh+eHg4EhMTh7Xmh4SEIC0tDbNnz3YqX5I3a74lowP7xdSV/S8UMkLAT9jNhJIouGEnZPJDVrJJyF1gYCDzkl0e2wb1lx9j5EvfoPQPixA/Rdgrh6yWL56YjYojZzD7j4tR/9I3HCMT3/izMD6Es8rOBzvsgm+g+9lrHyAoPAJvPvu4xdxd5PuQF5VBecGUWFvE46A+Utmfp2RgRd2eiYS1EAu2UYxkDKLSi1GOatANbZxVeFtGqNerGtHVocBLD8zxOs0/ceIEamtrUVxczHgDDRZSqdSu1ewlS5Yw+akAMKHqZEJy5coV7Nq1y+PhcRRFISEhAQkJCYzmnzt3DgaDAWFhYUhMTHSr15KnNT8oKAijR4/2mOYz2jAuwcz4woYziwn2GB1I/wfeOGHXNZwxZJP8UHxY4qZNKoCM5aUJAKuTBva/l/oIytGG3hFZ+OSUAqvbvurPJziwgDCLdey/C6/j8+27gFc3IoySAF+YDFFsLyXg/2fvu8PjqM713+1Fq95771ZzkeWGGzLV9GAwHS4txgkJl5TfvUByCSUhkIAxBAidGGzABmIwjjFy71YvVu9tVS2ttKtt8/tjPaPZ3dm+K63EvM+jx97ZmTPfnD3zzpzvfN/7XYpAuhQ5ZZp2R/IlVYiCnsYHYGuKGCn1X0Op0eLK/HSzZxxdG4r8PGlS9Y9sj6yQZxgL1hdh7AW9/6cj66arCzrqnOrp6UFmZqbXcX51dTVOnz6NoqIipKen2z7ADngD5/9kHVF0cDgchIaGUqu0Fy9eRFNTEzQaDaRSqUdEEN0lXFtWVmZz8sThcEAQhNm/kZGR+Pvf/44NGzZg8WLHqrfNd+Fdd8AexwZ9X1vHkp/7zpcAACQZRdR+9H1Jp5OupRRqtRqS2AxwfYM84tSprKxEaGgodF11dh9D2k/CEbvcEb1i6thz1A5vG/t6vR5dXV1ITk5228NpvoPD4SAkJIQK/7548SKam5upFw9v5vzy8nLw+dYf3XSuJ0Fy/muvvYbLL78chYWFDp3X28Y9HZYmDPQXUGl/LQBAP8i1qDflDEyPozs6yO9UKpXZKv+2E9PpEVvCDNcgbDoFQ6xB+HRbCXfi4b3rGc9N6jeRWPfyJlxfmIVvz1/AjSZOJmoSc2m7NSeU8TE7KQFdAKjetwP3rszEGZ3hbZ8pZU955gB8LlWlU6lUkLWXAgD4DA6x6RLjzL/jtxf60cUw6bQ2uSB1qkjQhYTJ32Vix3QEgaW2ti5PxJe94V439vV6PTo6OpCYmIjMzMwZP7+vr6+Z1io5IWlsbERJSQmCg4Nn3C5rMOX8sbExtLS0GN6RLomdu3vS6a5xU1FRAR6PR/E6E0y5ntw3KioK27Ztw9q1a1FU5JjDx1X7mfSULEUFOeqMskfnR6rT4x8DYXgswromHFMEk62KmgCwJczQ7tbllnXm6PYAxlpN5CKEIaXO4Mi5v+0TIKwYOxvH8V9LEyHpK6acUJSu3yW9qAdjIsHv6se1wTo8PzWBP/Y1GiKhGCJO1TH52IJybC+FUWTSdnk4tlzibjWMo6FI/M+OA7hKKsHyzfebfUd3QNEhk4io8xqecdNOKhJbwvqdckIygWyfdMCRiw/kOFPH5OPaf57Df640vDvZOq83cn5nZycSEhKQnZ094+f3JOfPS0dUd3e3kVdubGwMPj4+dofj+vv7U6UjSeFbpVIJoVDoNhFEd4kYCgQCl/RqVqxYgb6+PrS0tCApKcnu4+azCKM7YepQshT9Q6bW0bWaLDmyFAoFUlZvRFHAYzh67l7G85LHCYVCfPGPl3HjjTc6bDeTnaZoaGjALbfc4lDbpn3viMPOHamqrjjkwsPD0dDQgKioKK8Z+z09PRCJRFi5cuVsmzJr6OrqMgqlHhsbg1QqtemwIWGJ80nhW3opYWfhLs7h8/kuc75cLkdzczOSk5PtPs5bON9Mg4nmdLAWKTN46gcAQNQ9T1tsmykFjx45YykSimm1n0pJgHm6mUqloml6GF7kjSZKJikLb3T54u7gQUgzlhlFT5HpGd/2KagUPCGfD0l6ASSFa6jjTScm9Mp25HemOh+mjivSttp9P+KmKxKwNI0e3TXdNtkeGVEg7CrHqHIKHw2FgCeRYeslzRCmyZIpLPW7WeqeFT0xctI3LaBu/DtZSu0jERUVhbq6OsTGxs762CfR19cHHo+HNWvWzLYpAAwTkltuuQWlpaVU9b6+vj4AQFBQkEeijjo7O40mZI5yvp+fH/UuT4qdT05OeiXn83g8lzh/2bJlGBgYQFNTk0PRc57gfFup1kxwJOKI3vYbB6sAKI342fj+n3ai2GsLPeKGyYFlb/TN/W2fQNdmEB2n20c+z+4OGYW66SykMgl8Nj+F4puexDWXnEzvJdyJ7XJgCwyf+Xw+8u9bSVXjM63ICkw7gOhpgNsvVc3bjjuxJawfut0vYXuCocIe5L3U9TxwaB/OX3YFlmOA6qeJHc8aiZiT/5L9ST6zgsRikG/t6ph8M3ucBVM/b5eH48GbngRXLDbjeWFXOa5fGI3tclh9pgNATEwMampqEB8f7zWcL5fLQRAE1q9nXpSaabiT8+elI0ogEKCsrAxRUVHg8Xhob2+HWCwGQRBIS0tzqIOYxM7dIXxr78NyJgQWIyIicOHCBYyOjtp909lrv7fCUfsdqexGwlqqGb09R0XCE1Zec8koY/ss7S8SidDa2upQypY919nY2Ei9rDniTCL73pGKfN6CrKwsnDlzxiPlqJ0FvYz3TxUikYjifD6fj7a2NorzU1NTHaoAYkns3FXhW2/izLCwMIyMjGBkZASBgYF2HeMt9htV6oF5BSRLkC1cbfE7sh36y6k9AqdMYuZbU5jFr+ltT1clMk5XINuilwEHAA6XB31MDiVGu11u0NyoueNdAIY0O7oYLPftN/CHsiL8oUBsJDhuCeTE5dtLlfXWvbwJ3/YpcE2EjKqYBwCtra3wlUnB5XIpJx1Z0pwO8rch+4XP44LD5RltI/czTSExdf5dk2E7fYMpms0otYRhXJC6V7aE6DMzM3H8+HGvSnn+8ssvUVBQMNtmUOju7sY333wDAMjPzzf6rqSkxCMOM4lEQnG+QCBAa2srJBIJdDod0tLSHOJ8uti5RqNBT08POjo6wOFwEB4ejpCQkDnP+aGhoRgZGcHw8LDd4v/eZD8d9jp7SM4hYRqRRVb2NN3OBNJ5TlavsyS0ba/9E23mNtHPxVVOgcubzgAwddyQlUZJSEUCdIVmIGbgAoBprSZSyJxePQ+Ydhp9e/NObLnE77ybnsSWrnKoMZ2+19oKCEVSbI0YoGyjt086rExxf9gw3h8Mxy9B42LavlSEKoNf1FrmA7nAwZSaSRbtIB1fpn1LRmDZqp6XnZ2NkpIShxbqPI3du3d7lW6VOzl/Xqq0hoWFIT8/HwRBQKPRIC8vD9nZ2UhPT0dVVZXT7ZJi5zk5OcjIyIBarUZ1dTWqqqrQ29vrULQGn8/3KpJPT09HT08PmpqaKIFCa/A2+x2FI/Y744RiaoMe6URvzzS1jl5NjglanQ5anc4oGsqabVdffTVOnDjhduH7iooKFBcXO+xQ4vP5iFhyOSWcPpfEysmJuzeN/YCAAMpx8lNFaGgo9TCcmpoy4nxSqNYZkMK3ubm5yMzMhEajoTi/p6cHOp3O7ra8jTPT09PR19fncc4nS2OTf67CZ/NT8Nn8FLiXUr/sgb7pFPg8Lvg8rs0UvC1h/YwvqtYmHKbpHqY6HKbXTdeHAmBW7cisRDmXh3/VDBkdT4rMXhMhwzVH/0mlfCjPHMD1D/0caZ2HKc7/8YmdeOKS0wqYXnUnJ1bf9imMvjdN9yOv8ezeT3HFKuNrNe1P01VyANCWH8aD4UMwBX0iRRcitjVR0Dedsvo70ttiip4yjcqwNo4uXrzodZzv7+/vNl0odyAhIQEEQTD+eSpqKyQkhOJ8lUqF3NxcZGVlISMjwyXOFwgEiI+PR05ODrKysqDValFTUzMvOD8tLQ1yuRyNjY3QaDQ29/cW+8n7mOl+toRtJ1oBLg8Phg9ZiIaadmr8O9IQbWZPFVeSD02LVFDnNIFpZCZ9m2lUKnkebkoR3h+OwPvDEWbOFElhsVkqnKSwGB3X/RHHv9oJvV5vEBi/5ITaEtZPpeuZRqGSn0nb3intNSuecXbvp8hattoomok8hnRqbQnrp/5I8HlcgMszeh7Svzd7xtH7jGGuYvqsIaOITcXmTSvqkv+n87ytcTQ8POx1nO/n54e0tLTZNoOCOznfe3rZzeBwOGaVowQCAaRSKTo7OxEZGenSIGMSvq2rq4NOp4NEIqE8ukz53ARBYGJiAgDg4+Nj9h0dY2NjaGhosNiWu8DhcJCVlQWFQoGqqirEx8dbXTVRqVQAALFYbHEfb4a99q9a/AEA10WzbWkR0Z05pCPKUpRR18nvGY+1ZmNeXh4qKyvNPNeugFwhdLRvYpYWQywUGDnS3OHsmwnI5XIEBARApVJ5xdh/+eWXcfXVV7tU6na+gFy9pkMgEMDHxwcdHR1UtJSzsCZ8607OHx8fnxHOBwzRHiTnx8XFWc3xd4Xz6S+K5Aq0J8G0uq2OygEASK1E/dLttMchwnSuLWH94IoToacdx1ThDZh2QJm+SJPC2luXG1ZvCe2lukUCoWE1fccnhpV5K4LjmbohnNz1ERYmGURFSeFyut105xMwPcki2waMUx+53OmoEHKVnYxoousvAaC0TgAAOaugUmsZJ1DA9Mq4qXi4vukU0N8IbcMJ8NOWWxU7Nv0dnIlUYIpk6+vr8yrOf+WVV7Bhwwa2Miosc75MJkNHR4fLRYdMOX94eNgjnH/x4kWrnO/O50BGRgYmJiZQU1ODmJgYq+8OznI+UzU5d1a6YwITV9+TFw5VWw/EQvMxQDqh7NUGJHXwSOfNtO6f5ehZsm26FhUZyfTjEzuxsfcpqFQqMx4kbTcF/XifzU9Bgmln0pawflQlxeB8SzcuKzJEPj24MB/oMhRoINWdyHMnAPgRl9K0L6V6PxhjviiibqrA/cE6CMOmo1fJSCh1TD7uP/PSNM/TMB6chtuCgV3Nk0bPCRKWxsO2E62oahxE25FGu9/X6LpQAMz+pcMeXTK5XA5/f3+v4fy///3vWLdunVuq5Hkj5q0jyhIyMzMxPDxMrQLr9XrIZDLEx8c7XdLVVASRJG+m/UiQqxHkQ9JS2G9CQoLZd/TP7i5DK5PJUFBQgKamJoyOjlrUjTJ9sM412Gu/wVlyr9vOy+RwMd1myylD2u5IOlxGRgZ27tyJ3Nxctwh+79y5k1H40pZNgpTF4PN4GKs+ZrTd3usQiURQq9UerXRjDRqNBn5+fl4x/sfGxpCVleUVD0pvRkZGBkZGRow438fHBwkJCW7j/KmpKcbJwlzkfEvh6M6OefqLs72ViFwBk04QYNl+U5tIh4q90VuWXnZNdatMQU7QTJ0zpppLAMAVivFoUQL+cbaLmhBdc9Tg/OEtjIRy90v48YmduP+SI0l55gDSIoPx+ckq5MaFUw4m+gq8qRPqmggZtY10cElo+iX/eu1vWH7jrdT+TKK4TJM65ZkDOPrbLwAAG0veorYxRU6RoE9SRAIBVCo1pCZtMwkh24KlSlv0NEPyM4nPyjoRGB6J33tB1OnY2Biys7MdSjv7KSI9PR2jo6Nobm424vz4+HinFyM4HA6Cg4MpZ/1Mcr473tno8PHxQX5+PpqbmzE6Omoxus6V9xymaqEzAfq96+PjA2SvBNrPm+1H54trjv7T7ucSmdLL9NZlSbuO1Pwj9ZkkhcXY2PuUWTSP4f+JlO365jPQD/IM2kcLI7EF5QAMPK5SqSDEpUp3lyKTksID8VhTApZrtdQ4V545AHOJcWMozxwALmlPAQbH4zZ5OMLO7UB+YpRZIQpDGRdDRJSSoa33Eu7EQ9omvDUQBg6PT9lM6h/aGg8CoQgalRJ8mS+tX6b71DQyCmHFDr9XWNtfo9EgJCTEa97zc3JyPFrRebbxk3NEAQYhLXq0z9jYGBobG5GRkeGW9u2ZGE5NTQGA175QpKSkoL+/HzU1NcjKyjJ7SCqVBvqZqzfHbNlvTTcKsM+5pFQqkbDyaqP9baXH8fl8FBYW4uTJk1ixYoUTlpu3Fxsby/idtWvQNJ3D2NgYJQRt6XhyX1OIRCJMTk7OmiMqPDwcXV1d8PX1nfWx/9lnnyEjI8OrtEu8FYGBgUZaSGTUkbsqTtnD43OB8+VyOaqrq5Gdne1WzmfSc2KCJUcV3YFA1xCyZ4JDvrhO1B0HAPhJxWbaTuR5Sd0QwPkVfCb7mdqaTu0wSSu4NGmha1kQmimMjIyYpTYAlzQ/CosBTKfTAYbJa2FqLCqEUVikl1PbTSvtAcDL/3rAMMGKXGAUYaWOyacmXFwuF2Hd1UBstJlOF1mRibTrwYWRAC0VRCsSYsVTG60KlJOTMtPfRiwSYVKlglTqusOd/jsYacVYEUP/+fo8yOVyq8+smcKuXbuQkpLyk0/FtgcBAQFGmqcKhQINDQ1u01mZD5yfnJyMgYEBt3O+LX0204gpVx1VljT53jhaDwDgiqdFtMmoItPnh61FEmvRU7YiZkk9JPEl4W76eUwjSkkM7XgBABCw6TeAvNemuLfyzAH4FF2BRIkGx85VYk3RQiNHEZ2rryksxrer/otabCBt2IJ+4xTC1mrEL8qgjmOqI0x3UlGf5cA/evwBTIHD4xuJupv2lemzHQAEIjE0UypIZL5mCzWmka+OLG6pVCq8Yy0l8FJbERER6OjoQFBQ0Kxz/ueffz5r1VFnCj9JR5Qp6urq2Ac7A8LDDcRZXl6O3Nxct6/EO4vZSuNyJALJWVhqf9XiD6iqeiTISnvWjqP3VXh4OOrq6txiZ0NDA86fN19lOvHpmwAAXkwmTu35iPFY8uVGIpHAz88P6enplK22nHJSqRSTk5MWRfUVCgUuXLhg035nQ931ej1OnTrlFQ+F4OBgXHbZZbNtxpxEXV2dVwlRegvCwsLczvnOOp9IkC+nphMH+uox0znp7W6Xh+OeBcHQt5UaJiI4ZbQf0zkdcXZZuibTCZKlaC06TNM9ti5PxKs/VuPTajm2xsFodZw+abjm6D+N2lGeOYC4NRvReOoc4Gc+YSBT78jj9E2nqP+TEWz0FfsOQSBqJbGY2vE+RNlLMVVzGmgy/H/XoT7cGjgMblwOCntLcOYvpwGA2s/3rsWobOuFmKOHj0SEghs3AzCPhjKIsE+XRgcAiVgIpWrKYh9PTk6itraWsS/pIAgC+g5jjVBuXA5w9qzFYz6r6Aah16PnQjnezsmxeQ5PIzAw0Gsq5c011NbWOlQZ+qeC0NBQiMVilJWVITc31y26OI5wpsEpZN8x1vh46/JEo1SqrcsTMTY2hvfPdVzi8unzkbCWlsf0XLL1nLJkG+n8oi86UNX3LqW1kanI5DnEBZdBVXbkkgMq3OiZpm86dUn/yVjEfLs8HL6BkxjpHwMwnbZHRk2R0UzqmHy0fflvvAcAcgAJdwKXqsmRlUXvbzuAl3sHcb6lGxJJLdS9GnxVP4Qb0oMhlDeiKI6HsxUG3p2qOQ1R9lLq//lr78TXjb3Y6D8KaXIBvmocxXObi436iOz7rcunHUqkw04gEkOjnjJzQpG/weTkJGrPkXMDPnCOef5DEAQ+q+jGrYHD2DViCD65LS8aZ88OUs8Cbhyd13nA2bPQ6/U4d+6cW6VMnEVAQADWrVs322Z4FKwjCoCvr++Ml2icK+k0/v7+yMjIQHl5OVJTU6lyt7NhPz3qx1WHkDP2e4t+kVgsRt+5HyEUCiFIeZ3azuSgo/9/dHQUoaGhFtt1xNF21113Qa/XgyAIJK26Fi1H9yJp1bXU9y3HDTpW5Hd00MPVT5w4gfT0dMbILiZbJBIJ5chisv/ge68gICDALaWXTUGuFiYlJaG3t5e6F2YDg4OD+Pbbb3HNNdfMOpe88MIL2L17Ny5cuACJRILly5fjz3/+M+Vg9EawnG8Zfn5+yMzMREVFBZKTk6l7yRn7yZdN8oX4vYQ7zV64TYWj7UmJY3Lo2NKHEIvF0Av5lKOHhLUVeXt1okxhSafIdDJB377tRCtjBaFtJ1rx6Mo0/ON0m3EUFAyTKnrJbDreS7gTI229WBPgD8niPKPvTJ1WpiCdVvR27/rl/4Ni998gWn0lPhwMAbKnF+98A4GwEAJqPz/ouqpRta0E67/4M5TlR+Hr7wPtJb8/nwOU6QNA1nszjVIg/29ki1iMSQtyB9tOtGIh0QPRYCNC89cy7qNvK53+EGKIiuQmLKQ2vX+uA/ctNq+Cqm8rxS83LML75zugGk9EZ2cnsrOzGc8xExgdHcW3336Lq666ClKpdNbsmKvw9/f3yHuBNcwVzvf19UVWVhYqKyuRlJREPRtdsd+UN+lOCFNuZuI9e9omOcPgtE40cDzdmSMWgyMQGtlBahSSixGW4Giql63nA/3ZZnpuU4FtbkoRxEI+xEvXXbo+gxOLdNRvCTNP6ZYUFiNh1UZkP3U16nsGoTyjmY6CwiWOvRR59WAMqHaBS5Gvl/rOwMWG9mJ/+TEiludCFBIIblwcfnGpWvT7cuC+sDC835GKe0IGofT3gSQkkOJ7lO7BQzkrAARDMNmFrsYObDth+JGnfzvQrseY+++JVABQADB2HJP9VFFRgd11A3hsvfFzDTDw9oeDBsmE2xeEwTdQhX0Ixi+K46jvAUw/C8Km8+DfP9eB+5fEAzDI+LS2tiIvz/wcM4WxsTF89913KC4untX5hqfBOqJgiHJwdw62LUxOTgLArKUYOQKJRIKFCxeivr4e/f39SE5OnjX73eUMmgv9b+qcIa/d1Ha6A4lecc/0uJaWFir91JbTyhZiYmKo/+s6qiBIWQyucDr8PD4+nvrOFKOjowCA4NyVOPXl+0bVBG3ZYM0RBRhW98bGxpCbm2v3tTgKmUyG7777bkYdLUeOHMHExAQKCgoQERGB5uZm8Pl8r3jRPXz4MLZs2YIlS5ZAq9Xi//2//4cNGzagtrbWK3LsmaDT6WY8wnMucA4JsViMgoICNDQ0QC6XIykpySn7TVOxyBdqV17yTR1J5HkksDx52Lo80cA7EQsAlQrvlPZSbZLOpgcXRjLeT47oRZEwFd2mw5Km1JYwUJEB9EncthOtmJychF49BZ7EcpoA3dlHvtivUVUhKdYgcEo5eC6tfgPTjiwS5HFMkWJRqi7g6p8BAJ6Ont5OHh8fJgA3JR0T5wMR/+pdkERHQtkdiB+f2IkpmRTL//daDA0PIyEmkjrO1JFGpiY+uDAS20sN9khEIkyYcD5deyUsLAxyTD9zzGCyXd90CtD0Um38IT6eOSovPh7bTrQiKDwaW1dn4bvvvptRR9SxY8cwPj6OvLw8REVFoampCTwej3VCOQmNRjPjaTZzkfMbGxshl8udfs+f2PEsJIXFBqFsXEqHovGtK7AUBWu6mEFicnISd+eEMTrBPK1VSLfH1NFmmrpoyj/6plOYVBkWbIUy/vRzlMbt9LbINq45+k+cLKtC1oIVkERNR1GRAuQkv4rFYqMoMcgNvw+di5VnDiCEL0Ta1T8z2Ns9XckuODIG8fHxePL4R0A3gNBAiu9J59eoQglVxVEo47IRFB5NN9moaqxpyuGWsH60TokwPDpm1o8kIiIicL1Ox8z58fH4A+3jH9LTDXpa5HmiI6cXfkzG5B9o7fn5+WHv3r0z6og6fvw4xsbGjDifw+HMaycUwDqiABgiM2ZaHd8bJpCOgMPhICMjA2NjY6iuroZYLEZcnPkqoifhzoikudT/ppFCdNtNvzs1+joEKYYUPnp/6fV69Pb22gzrdzbqjNx31eIPjKrhMYGyX63EokWLzM5v7bwSiQRjY9MPKLlcDj6fj6CgIOq4AwcO4OTJk1i2bJnd9jsCqVSKqKgo7NmzB4BBO0UsFsPHxwdisRgSiQRSqRQSiQQymQxSqdQlR3dNTQ1EIhHy8/NRWlqK48ePY3x83GpVy5nE999/b/T5gw8+QFhYGM6fP++1qYNCoRBKpRISCZPqgWcwlzgHMHB+eno6xsfHqTFocbJvAXRxbHt0opj0IixNYMgJD3keWxMLsv/Jl3BTkKWuDed0fpJizQllCXRhX2DaQUT2h0qlwkORo3h31JBOR5bSJicY9NVu4FLlvSQ9drb74bIVGy85uoydTqSzh/4ZXf3USzqZGqeOyYdu90sAjLW+qMnTJfFZfVO/UWUpuhbVuqevhXjRWpwoOYYb8qadOXR7yJTJLWGgnFAAIBGLMCyLoc47ODgI7vAwgoKCqP7t6OjA8ePHHdI/ZIrKM0/VMdgnlUoRExODL7/8Elwu1+OcX19fDw6HgxUrVqC8vBwnT56EQqGY8SjO+QSxWIzJyckZdeTNRc5PS0uDQqFATU0NhEKhU5w/LWjtHg0oOqiUNth2JtHT9CzBmYhXS3aRsMfJRT+f8swBvGfST9KMZdC3GNKGqbRqOWj8TEaDGaf8tXX1YlmBId2MFDSna+9Z0is02B9O2QMYKuqRqeBkxJTp9dErCQLTqePilrMQL1mLp7+uQfaK9YxRu6QoOmnD/WeehbINkCQuhHJqkNpvOCAFGBykisMkJiaitbUVx44dw8qVKy11MQW6s8u0H0hHKb0vSNtiY2Pt4nypVAqZTOYS5zc3N0On02HVqlUoLS3FyZMnMTk5OeNRnLMB1hEFw0paY2MjcmZQA0Cr1c7YudwJPz8/5ObmoqOjAxUVFVi6dOlsm+QUvLX/7dG/MrWd3JdJtJz8fOCffzWqcmdNTJx+nKOw5YQCpu3f/dYrUKlUDjm8pFKpUURUSUkJNBoN7rzzTmpbcXExdu3aZeSIGhsbc9uqglarRWFhIWQyw6RQr9djcnISCoUCSqUSk5OTGBoagkqlwsTEBKampqDT6ay2ST7kJBIJ9WCTSqWIjY2FTqeDn58f/Pz8jByJX3zxhVuux924ePEiAHiNo4wJ8fHxqK+v92jknCm8lXNswdfXF7m5uejs7ER5eTmWLl1qsfoTwDzBtxatRMKRqKOJHc/atR/9xdla/5Mv4qSDx3T66IhelK19mar0AZavX990CmrllFHb0y/Wxo4cEttOtKK54iz8QgzRR6TjyNLLN4BLUQvT6SPTArNi6E30pcg2SZsmdjyLH5/YSYnfmkJLAFqdHjweDyqVGu8rpie39AmKOiYfwq5yo22y7JVQlpeDm2JIUzl48KAZ569fvx67du0yOqcp55O/ial+GAlrejFarRaLFy824/zJyUlMTEwYcb5SqYRSqXSJ87VaLfz9/eHn52fkzPdWzp8LiIuLw4ULF1jOtwMymQy5ubno6upCeXk5ioqKrHI+vdAAN6UIPrSIE0fT7qyd48GF+UYLBkyOEbpjyVb/O6IBaK8otrViG+RigOk5JYXFeDAm0uh4rUIBVVgmxKNNAJiiqMwdOyfOV2CBfphqRwyAjGOi20/225Yw4+hX8jekL89tQT/UiDS7vm0nWrHFxAlFXsc7pb3QTxmqS3J5PGjVKrNoK/I5QT7T6PwrFYsoXUBuShF+3LULKpUKd955J+XsWbdunU3Op9vM9Ftbe+fQarVYtGgRI+crlUooFAqLnM/lcqHX683aNOV8iUQCHx8fivMDAgIgk8mMOH8mF0tnCw45ot588028+eabaGtrAwBkZ2fj6aefxlVXXQXA8HLzxBNP4LPPPsPU1BSuuOIKvPHGGwgPn76BvvnmG/z3f/83OBwOXn75ZVx7rUFXpq2tDYmJiQgNDUVzczN8fX2pY/Lz83HDDTfgD3/4g4uXywyxWIzg4GB0d3cjOjra9gFuwFx9QJHw8/ODTqdDW1sbEhISZtsch+HJ/ndFTN1SqhzdyTRw7ge7bKAfPzQ0ZJfIqTuF4C1FR5F9v3btWuzevRu33HKL0cqhtagouiNKrVZDIpEgICAACoWCemAA01Ve6urqcOLECVy8eBF33303taKi1Wpx+vRpqFQqqNVqhyoRmY4dLpcLmUxmdH5HwfSQa21tRXt7OxITE9HX12d2DI/H82hasUajMYo+AwzVf6xVANLr9Xj88cexYsUKLFiwwCN2uQMikQihoaHo7Oy0WP3R3ZjrnO/r64uIiAi0trYaif6avuAxvYhbeoGnH2utchl9fwAWy1GbThbo/7fV/9yUIgjJl2E7K9+Z2kU6Ze4HoA9jjgCjO+nox+mbTkF55gD0l0pRk6KxgMGJ89FQCH5BiwYAjFPr7m/7hBIYf3BhJLYcGsQrxXFGuh8k6FFhxnorxumK9GsmdURMrxkw/B5MTiiyAt9U1kpodXo0pVyF3V8cwJu3wMgZRa6iM61cy9RqqC5pRKnVaojFYgQFBWF0dNQoQojk/MbGRhw+fBhjY2O48847EXZJA0Sr1eL48eOYbC6FRqNFYks7MjcY7GNyQtGjvch0cuo7D3F+e3s7WltbkZaWhs7OTrNjBALBrEhJzAcIhUKEh4ejo6NjxqL55zrny2QyREdHo6WlxWpxD6Z0aUcijJgcSiQmdjwLn81PGSI2YdkJw3ReW/3viAagpWcYnV/pkWD0/UluNU3To+sl0blVpVJB3XQWXACQGTsiSF42rVy6XR6O8mYd3rn1NkOxCcr5wmw3N6XIkAnEcD105xTp0LIGMirqvYQ7AbnBUTiqUOKjoRCkLixC5ZEDyF9zhdH+xoUp+o2cUwKtFqpLFSe1Wi1EIhFCQkIwOjpqtMBJcn5zczNKSkqgUCiwadMmREZGUseePXsW/zrbDJ1Gi/9tb8Gfbl9v1Pfkc8fUQThT7/nt7e1oampCdnY2BgYGzI4RCATQarVuKSLgrXDoymJiYvDiiy8iNTUVBEHgww8/xPXXX4+ysjJkZ2fjV7/6Fb799lt8/vnn8Pf3x2OPPYabbroJx48byiZPTU1hy5YteP/990EQBO6//35s2LDBKP94fHwcf/3rX/HHP/7RvVdqA1FRUaioqEB4ePiM/OCuDGZvAHlD1tbWzoreiqvwVP8LUhbj2dw78FTlv9zeNumc0Wq1kGUth06vtxnZRP5r70oqU3vOVgs0VPS7l/rc1dWF3t5exMTEIDQ0FHw+H/f8718RGhqKK64wPKTUajWmGs6go6MDdXV1UCgU4HK5yMrKAp/Px8TEBOrr6xEdHY3u7m6kp6dDr9fjwIEDuPHGGwEAlZWVaGtrg1qtxpEjR8Dn8zE1NYWKigpMTExAp9NBr9cjKioKpaWl4PF4OHnyJH7xi19Qjipr8MTYYXrIZWdn46OPPkJXVxflsKcjLCwMPT09Rnpd9uDM6D/AsTGR0eqGsGvXLqpPSTzzzDNWFwS2bNmC6upqHDt2zCGbZgORkZGorKxERETEjGiHzFfOdyalwVHNJfoKLgCq0hAJ0ygXptVPT/W/o9dCB5l2R9ouwaVUFtpkRXnmAGSL1oMrkmC7XGZ0LADqZZ5305NG1f4IPUEdv3XzUwb9qRRzpwsZBaWOycc7lyIbVKpII8eUwSaxyXG0/l3+FNUX97d9AsAw2Wja9wVGorIQNaHAHiITYikPC1asx5MHypC1zOCIerUnGFyuHv1n9uNCSzsUvtEGztfVg8/nQ6lUoqmpCdXV1ejt7UVKSgr4fD4OHjyIm2++GYChIlprayvUajVKSkrA5XKhVCpRUVEBpVIJTVctYgkC3PBQlNXUg8Pl4GRZFbbmr0XIWIvRddGjBkgR5JnifAD46KOP0NvbSy3w0hEREYGurq4Zl0WYLwgPD0dlZSUiIyNZzrcD5Pisq6vz6GTYUnTidnk47sd0BKyksBgTNIeFLbij/21FQpHC56Z6iPTjmT6Tjo9tJ1rNIrq2hPXjbUUsHgmVGx1LrzhnmhK3dXki7v+RMDh4Eu4EGNLcAeMIVDLd7ttV/0UVsCBtISun0h1SdDtJhyA9PR5yYHSgH6d7qhETGY7HVq/Cm2c6kbPycqS3fA/EGVKntVotHg3pxfO1wNLRc9hdNgFe1AJk6QINnK9Von1KhFqVDP2HDyMxMRE+Pj748ccfcdNNN4HL5eLChQtobGyEVqvFwYMHKc6vrq7G2bNn8U1ND/Q6HQLDI9FZXwMul4PQtqPoipvEHs70IikZCbw1xXhBaSY5/5NPPoFcLqfmQXRERUWhs7MTiYnuS2/1NjjEKhs3bjT6/Nxzz+HNN9/EqVOnEBMTg3fffRc7duygSg2+//77yMzMxKlTp1BUVISpqSnweDyqJCI5QaQ7orZu3YpXXnkFW7ZsoVayZgppaWlobGyckdLsCoUCAOZszj9pP5mrm5LipvjbGYIn+p+MJvq2I9BjFfYEKYvh7yOBTCLCxQlz0W53ntfV6Cj6ca2trSgvL8fChQtx+vRp8Hg83PDLZ8Dl8zE+Pg7AoItx7tw5SKVSREREYOnSpQgICIBarca+ffsQHR0NX19fXHPNNWhvb8fIyAjlFO/t7cWhQ4cgEAioyce///1vpKSkQK1WY/ny5QgNDUVAQIDRy1RmZibq6+vR1dWFw4cPIzc3F6mpqRgdHcW+fftw/fXXm2lKzOS9e9NNN0Gv1zOGG5P3nqOOKHtx66234h//+IfRNmvRUI899hj27t2LI0eOeMwmdyMtLQ1NTU0s59sB0v7k5GS0tLTYHUFoDUxOLFOtDfpnpZVJiK20CXv7314RW0sOKLp99rT1TmkvHlyYDzHM0+vI6kWjCiX0U0rwJDJqBZeMCqCqD2F65X3r8kR80RNuZI+pWC/Zr4aUvSIj7RUyMonuANx2Yjp1wzTNg65bomwznLO9uxd/UaTgyQUr8OI3R7E+WYNmv1RIff0wpZwAAMg7W9FRVwmBSIy2oFA8s+luM8738fGhOH9oaIiKxpPL5Th48CCkUinKysoozk8UT2FKrcayG25AeHj4Jc6/jrqW9KQ4NLZ2oQv+OPL5u8hOTULmhk2GqnTvv4aNaydx+KpfUBOzbSdacVeWocLSTHE+maZhivj4eDQ0NLCOKBeQnp6OxsZGZGVlefxc84nzm5ubPVagxZqu3nsJhhRcSjOukHkRgvw/Hfb2v7XnkGn7ZOSqKUjHELmPJZtM06RNz01e552yTiiUQIBMQjm7SHFxkqdN++JK/4sg3UzmBT6m+5lc7DB8Dge+/DcA43RHSWGx0TXQF3eMxL8vQR2Tj+t69uNsVy2icrJwvrYRP5ySIz6vEP+dNIkv6g0RTu28cBz/5iP4JOaiOCICqTHpCFl8BbRaLb799ltERUVBJpNRnD8wMEDplA0PD+PgwYPw8/NDaWkpVCoVvv76a1SqfKBVT2HrddchNDQUQUFBuO46PnW94fEp6O9oQV6gDs8c7kRkohR/un09xsbG8O17r2JUsgx+vjLQU91n+j1frVYznisxMRGVlZWsI4oJOp0On3/+OSYmJrBs2TKcP38eGo0Gl19+ObVPRkYG4uLicPLkSRQVFcHPzw/33XcfIiMjweFw8Kc//ckoBQ8Abr/9dhw4cAD/93//h9dff930tB6FRCKBVqsFQRBW86HdgblQRcMaSPulUilaW1vnXLi4J/ufLhjubmiazsEve7nDxzmz+ucu+/V6PU6cOIE77rgDAJBz9e3Qa9SAchzP/vIBtLe3409/+hOWLl2KO+64Aw0NDUhLS6OOFwqF6OrqQlVVFf73f/8XarUau3fvho+PD/r6+nD8+HEkJhpWMAIDAx0SrA0ICMDSpUuxdOlSaLValJWV4dNPP8XY2Bj0ej2j2OhM3rvWVmWioqJw4sQJi9+7CoFAYJeuFkEQ2Lp1K/bs2YNDhw7NqQemWCyGVqudEf6aT5xP6iE4GwlrK4qKdDiZribTX7zpmhP2tG9P/5uuTDsa7WWqXeXjoGgt6eihi9ECgJDPw90F0ZBKpWYTAOWZA9hSWEwJjZPg8Xg2V/JNP1ubEBqitJjLr087sy6tkCcV4sTpT5G3+gr8ZwhIW7IC6aF6HPj+LLqbasETCPD9+9sQn5WHxRuuh7yzBc9uWn/p/CMG+7u7UVFRgaefftqM80+cOIH4+HjIRtsRBD/8/Oc/p+wASHmFcWB0HNwQY2dmgJ8fluRlYQmA8YlKVJ4pwb9q6nHx0oKIVCrGNUf/SY2vLWH9UAmnJyiehjXOj4iIwJEjR2bMlvkIkUgEvV7Pcr4doHO+Wq2ekRQhMtXNUTBxnT39b8sJRf+Xzu+mTiAyNW2rDZvI7WSxDXpKGL1IxMejEYZ9J8WAfHo7+VwwqzYKQBCTaSRMznyt07pd9LZMFyhM2zDtJ9PnL7+jFEfPleO2a4vBT1uO4KAjyOofRLO6C395ey+EEcl47tMDWLx4Me789TNobGxESkoKNdfm8/no6+tDeXk5nnrqKej1enz11VeQSCTo6+vD6dOnERsbi+/bJyD15eHZRx+l+iz9koRVpqgfGBsHxlqguqT3CAASmS8SsvLQA2BBqBY9TXW454+vQqUYw2rfMbw/Hg++cnpcbzvRigfyZ47zSX1AJoSEhGBoaGjGbJkNOMwoVVVVWLZsGVQqFWQyGfbs2YOsrCyUl5dDKBSaefTCw8ON9E2eeeYZPP744+ByuWZOKMBQteHFF1/Exo0b8atf/cpqXrIljI+PQyQSQalUQiqVQqVSgSAISKVSTExMUA8ijUYDmUwGhUIBgUAALpcLkUgEuVwOsVgMLpdrVF1JrVZDp9NRxzC1w+fzwefzoVKp4OPjg8nJSXA4HKpiB9mOQqGAj48PRkdHKbJUq9WM7ZDXABicZRMTE9QESqvVUscwtcPj8ahrYOoLsVgMnU7H2BdTU1OM7UgkEigUCuh0OgiFQkgkEvT09CAwMNBiO9b6gt6ntvqCqR17+4LeDmBIFdVoNEZ9YdqOrb6g9ymfx8XKsIeg1XJQOv4uRkdHXeoLS+Or7ehe5Gy4GRqtDhcvXrSrLyYmJozsYRpfpuPCHeNLJBJR244ePYrY2FiIODro9Wq888r/oa+vDzk5OZQo99///ne0trbiT3/6E3Q6HdRqNTgcDu6//37o9XrqGh588EEIBALweDxkZWUZ9alarXZ6fOXn5yM9PR1KpRKvvfYa2traEBUVZdQXFy9epBx79Hb0ej3Onj2L0dFRcDgcSKVSFBUVwd/f3+nxRV6DXq+Hj4+P2bjg8XgYGhqi+Mp0fKnVaof501Fs2bIFO3bswNdffw1fX1+K7/39/WdMaNEVzheLxejv76cqXbGcb5vzpVIpenp6DNUq3c35IRngX7cAapM+JdrLIBbyoYpYgA8r+gG9EqMKJWQSEd44WIWHliVT7Uj7azEZnuUQ539UPYi7F4RAIBDgn+c6QWg1eO1oE+707YSm8ij8lqzDWz3++PmqdLx5rBEEocej0WN4s9sPHL4AIPR4J/wG/DxmHIOnfoDvotWYqDkKTXSO/ZwfnQf9xATuygrE+N6PMaEDZAtXQ63VYmJ8HD7yOlycMnCiWMjHpEoDcf4aKJRTUJQeRohOj8nwLOp3s8b5kxdOGMaFSIg3u/1wV88e3HfjrzH25SsIKbocw+VtEKcttT2+wrIM7Wg0mAjJgEgkgnp8HCVNA5BdPI3w6FgoRgbx98Ot4PB5EAhFiE/NwEMZYnzSL8PJLz9EiGYYr4ZGgCD0UKk1EHCAn993n0XOz87OhqSvBpNTavASF0FVdwyTUxpIRAKotTrodHrIJCIolFMQ1hwBCECt1YFXfRS6BavA53GhLT8MFcFDTkIUcnIvg1I5hTc+3oXW7n5Eh4fgHt8OjCoM7VjifIIgcObMGYrzJRIJli1b5lHOFwqFGBgYoPhqNjjfG+AK50skEvT29lKVrljOt835Pj4+6O7uRkhIiMucz++uBDdxMXUNd2UFUn0xpgrEI/GGdj443wmOQIi7c8Kg6umCVqfHe/IgcEUS3L0gxNAXk5NQKZSQ1Z8w3O8pS1x+z3+93QccLhecngbcnRtG9emEhoCEB+gXrAI3Oo8aF9L+WkxlrcTmWD+8evgC7vJXwkcsxGRFCXiJi5j74tbfY0yhwH9FizAxMQGNRgNCr8Nr7T64P2wYd/j3QK3RIdjPB5NTaoxNckDoNHit3QccvhDQKzHgm4jg4GCMXRpfSqUSYyEZkGm1RuNr8sJJSMUCjAWlYUe1HFyBCHfnhOLD7kA8sCgadyjOQl3fa+g/Pg/gAFras4PH44HfVYGpyAWGvmg4hbuzC6CTxmBiYgKC7iqoNRqAw8OJPi1i+r5B/+AomtrbwePxIIlOQysC8ciyeKg1I3j99dfR0NCA5557DjqdjloMvPvuu6HX6zE2NgaZTIYHHniA4vwFCxbgo6oBxAarcP+SeKjVarxxtB4PR13E232BIPR6aHV6wzUIeHj3VCsInRZckQT6KSU4XB7A5eEe/x58kpqJmIQkqKeU+PbLT7C0vwv+YVGAXgdCrwNXJLHK+WfPnsXIyMiMcn5/fz/FV/ON8x1eDkhPT0d5eTlOnz6NRx99FPfccw9qa2sdasPf35/RCUXiiiuuwMqVK/HUU085ap7L8PX1xcjIiMfPo9Fo5vTgUavV0Gg0AAwrr3NNlNEd/Z+y2pCqmrDiagDAWPVx6rue0weQsnojZFmORy/ZgkajgdDOVSm9Xo9//etflHjfbEAoFOLaa6/F+rsew8INN0DI50HoF4gtf/wrFixYgLS0NJw9exZHjhxBcXEx3t57mDq2uroan3322YzbLJFI8Nvf/hbHjh1De3u70XcajYYa+3SUlJQgMzMTV1xxBW644QZkZmbiwIEDKCkpsVlByVkkJCSgtdV5jRp34M0338TFixexZs0aREZGUn87d+6cMRsIgnD6WD8/PzMxYk9gPnE+n89nvAc8CW7CQrw9EIYPznfi4aWGUP2PhkLwj4HpFH596zno28oM/7/071un26FvK2Ps/7dOt+Pdsx3U5w/OGwSiHyqMx72LYvHzZQnUd6rzP+Lu4OmS0veEGP5/d/Ag/itkWmT0HwNhEOetoj5PXRJdNcVbp9up79442UbZS0Ky5HKqHY1WD6K7Fm8NhOHDoVB8OGisZcdNXATp9b8AN7kQer0eO3bsMCoSYwnchIXgJhdS1/Xu2Q6I81ZBedZ2QQwS758zFtXWt5wDn8/HX395LwJCI9Hb0gC9RoPUgqUIjohFREIyHi/wx+mKarRUnkP6khXwL5rWwOtvawLvgu2oH25yoeF8baV22amqOGq2TZy3CpLFBvFaiUSEJx+6E8dLK9Ha2WM4R0IBuMmFFjn/0KFDSE9Ppzg/OzsbBw4coCr7eQJJSUloaWmxveM8hyuc7+vry3K+HTB9z59pzr9vcRweWZoAAOAmLQEAAy8XJVD76FvPUc+Bj4amefGD851u63998xno20ohzjfwxUdDIXj7jMl7YWQWhL3V+K+QAXATCuxql3zemOL9wVB8LA+AWmv83vgQTTPqgSVxBmdF8xno9Xrs2rULoaGhjO2R9nxaLcd9i2LxaFEC9G1luCfP8Iyg9xsAcBPNq2Zzk5aYPaNI/HMwFMLUpbj2vscQGxuLmsYWTGnU6E1eh5Siy5GWlobI5HT85Vg7jp+vxJo1a/DQQw9Rxzc0NOCjjz5ibJuORy/97u+f64RKpTJ6HgOAOjoXHw2F4N0B5n540ERzSyiSYP3tD6GjtgIDnW0ADM/znxclWOT8w4cPIyUlZUY5Pzk5edbf8z0JDuEKmwO4/PLLkZycjE2bNmH9+vUYGRkxioqKj4/H448/jl/96ldW2yGr5pWVlSE/Px9nzpzBsmXLcO7cOdx33312Vc0bGxuDv78/zp49i8WLnSs/DwA1NTWGsG8PCg2Sjpu5qoRPt58gCFRWViIvL8+t59Dr9aivr4ePjw+io6PdKojujv4nRbwFKYtRFPAYY4U4T8AR2w8cOIDBwUGsWLHCYV0JU42osbExSKVSq+e1pitF9pc4zTCBUDWcwbFjx9DX14fLL78cCoUC8UvXgyvxpY7v7+/H66+/jmefta9cu7uh1+uxd+9eyGQySvuO3v/Dw8M4fHjacXb99debhfv39PSgpKQEmzZtcvv9rlar8Z///IdRzByY5sSLFy9Co9EgJCQEvMQC22LlnbXYu/tzXHPNNW61190gr+/06dMoLCx0uh2W821jJjlfKpUiJiaGkfNN0/VMUwoA5rS91/sML9scLs+hkt0AzCoU0UF+917CnVT1OzrUMfmM1eDI6nZM6b+AQYeDFJMdP/UfAMBHSXcBgNm10fugpH0CAwMDWLp0qdU0WVPdE3pqHpneYYnzt9kQwjVN8yP0hgkVh8tDS+V5XBzsR9ri5dBMTWGgsxWpC6fTQDan++Hll1/G888/b9FO+nZPYO+Px+GTnI+18T6GcyUYnmumnK/X63HjjTeacX5fXx9++OEH3HbbbR7h/O+//x7XXXcd4/d0zgcMC7+r//I9+BIfq+2e+csD+HjbX3D99de71V53g7y+U6dOYenSpU63U1dXh5iYGKuL4q5iPnE+AJSXl1Mav+4CQRCor6+HRCKxyPn0VGV6KhuZKse76UmIxWIjseltJ1rxaGGskf32gF5NDYBZKjRpA3ke+jF0XqanFzpaQXC7PByEXodHQuXg87hGOlWm59Y3ncKRLhX6+/uxePFiq1lE+qZTVPVTOofTuVQRlgVhVznEWZfZZa+lqoNarRZvnGrDL1am4Pjx4+jt7cWaNWug1+tRVVWF9evXU/uOjo7ihRdewJ///Gej1EyymAf5HKT3KX08kJ/J/z+4MBLvlPaa7QsYP8vp7SXW7oaAL0DxykJsl4cbjZ3R0VEcPnyYSum9/vrrzcaUJzmf1M+yxM10zufz+fDx8cFlL+6FwMffartnX34Y7770R9xyyy1utddRuNxber0eU1NTWLRoEQQCgVElk/r6enR0dGDZsmUOt1tYWIibbroJv/vd7xw+1tfXF+Xl5YiPj0dgYKDDx2dkZKC6utrtL9l0zBcRw4CAAHA4HAQHB6Ovrw8REREuty2XyzEwMACNRoPU1FSo1WrU19dDr9cb7adUKiEUChEaGoqoqCin7XcWdGeLJ3WhTEHarlKp0NDQgJUrV1rUOrhw4QJ0Oh3Ky8tRVnYpUoDWj1KpFDk5OYz9R3dA7du3D35+fhgaGkJCQgKysrKMyqiaHmMK0kEFADLJtOD1ypUroVKpsH//fkMoNV9k1MaxY8ewfLn7o8rsBZfLRUdHB3p7e7Fu3TpotVo0NDSgpqYGk5OTkEqluOaaayzmdwMGLaf169fj66+/prjRXRAKhVQI+k8ZAQEBKC8vR1xcHOO4tIXMzExUVVWxnG8FppwfEhKC3t5et0Rb0jk/JSUFGo3GCudLEDTejugI42ImloTMScfF3SGjAICPa0fMJg50PQxTB8d2ebhBg8kE6ph8vFPaiy2XRGq3hPWblRXnphRBaMFhYmtyotv9EiZwqVKUzhC9M941iP72FuiLY6GNW2jmxOKmFKH+P29AqVSiqqoK5eXl4HK5Rv0oFouRk5ODGNo1k9dP2qRQhOLbnTuNOD8jI4OqKkp3uG0JAzW5MS3hTkI/ZSiswZPIkJS7CFq1GnVnjkCtUiEhO9+oT7766ivGd0b670Lqq5jCmsOQfq22nFi9hAzNOz/A6v9+FEgqpDhfqVRCJBJh48aNVjk/IiICGzZswFdffeX2l3yhUOiVUTZ/+MMf8Nlnn6GzsxNCoRCLFi3Cc88955KzyBqCgoJc4vz09HRUVla63bFCx3zifMAgtdLd3Y3o6GgrR9mHgYEByOVyaDQaJCcnQ6fTMXK+SqXCZT4C/Klaj8Aw42cNJWTeVQ6YcPjW5UVU1Bu9/5kcJ/TnwZYwA48ILVRmpWPaQWYefUp3jNDtIttiAiUejmmxcrVKiQtdh7A8wpBmR7ebbK++vh5jY2OQSCSorKw0a5fO+eQTg+6E4qYUQaFQ4Ntvv4Wf3wgGak8jaZhrxPn0fqIfT3cK+myezmJSKBS4e4Hh2BUrVlAOdJVKhSVLlhjZd/ToUYrzuSlFgHy6+uuWsH4YjwhzJxT5f8rh1DX9OwKAss34eElhsVG1Q0lhMd47PIxPq+RYv3wx9Z5fW1sLpVIJPp/PWLiIjoiICFx55ZXYvXs3br31Vov7OYPZiEC3B+7ifIccUb///e9x1VVXIS4uDuPj49ixYwcOHTqE/fv3w9/fHw888AB+/etfIygoCH5+fti6dSuWLVuGoiL7qtCY4rnnnkN2drbD3sXIyEj4+vqivr4eWq3WYriiJfB4PISEhKCjo8Nj1UncGd0zGzC1PyYmBhUVFfDz87N6s9pCW1sbACArK4sSsfPx8bHqUGxsbMTQ0BCCg4PtPo8j/U93opCgO0tmwvlEh0qlwieffILfvvQGvvvoTfT19Rk5koaHh3Hq1ClMTU0hKCgIqampyM/PZxRuHBsbQ3l5OQ4fPozMzEzk5uaaObWOHz+O/Px8KJVKJCUlwd/fH9999x1uvfVWozYtRUOZbm899h31XUdHBxIXrsT5H75Bfn4+Nm3aRH03MTGB0tJSPPfcc852lVtw66234ttvv8WePXvQ3d0NvV6P3t5eKBQK/PrXv7ZrvEdERGDBggU4cOAAiovtKz1sL6Kjo9Ha2jqnRMLdjYiICCPOd7TiKpfLRVhYGNrb26kKLe7GfOP86OhoVFZWwt/f3yXOb29vh16vN+J8AFY5v6nJB8MBAdRLMlnOmg7TqCjSfqZIHlPHFOlkMgU9uon+vem5yf1Mo7RIBw7TRMRUHJ18qdc3nQI/ayne3fU1miQpkPoHoE8ahxiaE2pkZASnTp2CSqWCv78/Fi1ahIKCAoucX1lZiaNHjyIzMxMLFiwwe8c6efIkcnJyoFarkZiYiICAAHz//fcU56tUKpAtK88cAC8mn7KfjPSiT8ToEZgj8l7UHD+IuMw8vHT/dUYTQ6VSidOnT+OFF15grFpF9gdZocq038nPTFFTptWsLFW+AoAbC+Lx75EOfP3DEfQRZdBqtZDL5RgbG8Pjjz9u13gPCwtDXl4e9u/fz1iW2xXExsaisbHRLZUr3YW0tDS8/vrrSEpKglKpxN/+9jds2LABTU1NDr+D24Pw8HD4+vqioaEBGo3GrlRUOrhcLiIiItDW1oaEhAS32wfMP86PjIxEVVUVAgIC4ONjPcLOGjo6OqDVas0435rDzte3Bb6+MmoskTzzTmmvkSOdzuv29D+d+005gc4xphFJJCw6Q2BcfGLr8kSbTnD6s0mv0+K9L/6NhIKVCAkRo7t/APHR04644dL/4FRZDaaCEiCTyZCbm4tFixbZ5Pz09HTk5uZSnE/23enTp5GdnQ2tVouEhE0IDAzE/v37cfPNN1MLHiSnbwnrh0plHM0rKSw2eobR+76npwdff/01Fi5caOakmJqawvHjx/Hiiy8aLW7om/opgXbTSCh6IQlg+neytRBBbt8uD6cE4CWFxVDH5OOG4ovgcI7g6x+OQMzxxwG1GgMDA7h48SJ+8Ytf2MX5ISEhWLRoEfbt24errrrK5v6OICEhAXV1dTNS4dleuIvzHUrNe+CBB3Dw4EH09vbC398fubm5+O1vf0tNrFQqFZ544gl8+umnmJqawhVXXIE33njDrigZ09Q8Eg8//DDefvttPPPMM3an5l28eJGq9tTQ0ACBQEBN0iYnJ1FfX4+UlBSbIbmNjY0IDAw08gi7C6Q2hLVy6N4MJvvJkEuZTIakpCSHKw9OTU2hubnZqbK6DQ0NIAgCaWlpdp3X0f6nO1OYHC7WUtLcjampKXz99de44//9BW//zxYEBQVBpVIhKSkJra2t8Pf3x7Jly+yqeEZHTU0NmpqazFakSMG8ixcvIi4uDlKpFNnZ2fjuu++QmZmJ4eFhpKWlUfcYmYJH/p+O2n2fIiAgAH5+fhCJROBFpwNcHnSdjunMzRbq6upw+PBhXHbZZU6N05MnT0IgELiUOmwKrVZrceX9p5KaR+f8xsZG8Hg8qsy7UqnEhQsX7OL8pqYm+Pv7e2TiNF85v7q6Gj4+Pk5xvlqtRmNjI7Kzsx22p7GxETqdzlBhs+UMtd3SarO1/qenftAnH6aTDktV+kzPyxRVBViOgiKdU/R/yTb1TacwpdHimx+OQL7odsiOvYeg9MVQqVRI4E+gXSeDn58fJZjqCKxxvk6nw9DQEJKSkiAQCJCfn4+9e/ciPT0dY2NjSOBeRFR/HaPzR32pYtE7pb2Qd7bisTXZCAgIwNvne9BSeR5CsQR/vtfALUzVCZkma6aTDcB4wmGp6p9pW/Tjf3xiWsdu3cubzK4FMEQblJSUYOXKlViwYAFjP1rD6dOnAcCtkUF6vR67d++2yfnA7KXmkXb88MMPRmk47mqXzvlNTU3gcDhUWpJKpUJtbS1SUlJsvge1tLRAJpM5vHhhD+Yz50ulUiQlJTlceZCMdnXmXmpqaoJWq0VaWhq2n2qnHFGWeFVZdwzcpCUW+5/kfUtOadNngWnKl2lUlWlbZOSNpXOTjjO6A438P6FVI7ziS/zsqnX4eM93CEhbBJVKhTPjIiz1U0M23o3lN9/ncLRdXV0dGhoaGDlfr9djcHAQSUlJ4PP5WLRoEb755hukp6dDoVAgSjeIuMEG8G560qjfTSO9mpubIZPJEBAQAJFIhNOnT4PH41l972V6ZtL721qqpOnvR38umP4e9PQ9YHpBiR4d3djYiIMHD2L58uXIzc21aLMlnD17Flqt1qlsMEvQ6/X44osvGKOtvCU1z1nOdyjU6N1337X6vVgsxvbt27F9+3ZHmgVg8PYx+cTeeustvPXWWw63RyItLQ1yuRwVFRVYsGABJiYmEBERgaamJmRmZlrUZwCA1NRUVFVVecQRpVQaQtXn6gOKyX4ul4u8vDxcvHgRpaWlWLBggUPX19zc7FSVRMDwO4+Pj+P8+fNYuHChzYejM/1vzck0k1FRSqUSAoEArYe+wsTEBN544w2EhYUhPz/fpZDQ7OxsqxPCvr4+HD9+HEuWLEFISAjuvPNOdHZ2Qq1Wo6mpiXJEMfUFuW3Xrl1oaWlBfHw87vzvPwAiH5R88Hd899132LBhg9drKWRmZrqUirRs2TLs27cPNTU1Tk2+mcDn8yGVSjE6OjpnUwDcidTUVAwODqK8vBw5OTmYmJhAeHg4mpubkZ6ebrWSX0pKCqqqqjziiJqvnJ+bm4uxsTGUlpYiOzvb6jPVFC0tLU5zfmpqKsbHx1FaWoqCgiXgtJ51yH7TCQCZXkYfHVvC+qdT8BgmGfQVcEt6UtyUIqpcti2YlgunbJ/SQCQW4zptJdSL8vDG3kMIDAxE7s9+hltdWCG1xflyuRxHjx7F6tWrERQURHG+Xq9Hy5geqbSoLYCWWiKfnqx1N9bhsaP/QWBkNIS+QUhfvBzNFWexd+9ebNiwwW4nFAlraXeAZQcUHT8+sRPrXjZE3657eZNRSokp0tPTHY62oWPp0qXYv38/qqurnZp8M4HL5UImk2F4eNiptDRL0Gg0GBsbM9omEokc5iy1Wo23334b/v7+Hk13JpGSkoLBwUGUlZUhJycHk5OTCAsLQ2trK1JTU61GMyQlJaGqqsojjqj5zPnj4+MoKyubUc5PSUmBQqFAaWkpfr60AG+c7rC6v3JKA+6ldFpT6JtOGaVvAQatKVNHBz06ViwWU1Gt2+XhRo5vwDiNW3nmgEUnFB2mKW4kNqUH4HSDBO3dvVi5OA+vf/wZAhMycf/NN7v07piZmWk1qmZwcJBKlQsICKA4v6enB22jfshk4ErT66ysrMSFCxeQkJCAsLAwrF+/HsePH8c333yDK6+80ixqy+DEm44aJqPdhF3l2Lr80sJMl+VFIFvPBPJ3VZ45MJ1mf6m9rctJ26f7PzU11aV3wCVLluDAgQOorKx0ypHFBC6XC39/fwwODrrVJ+ENnO+yWLk3gWmlhAS5QpKbm4uKigqkpKSgpaXF5ip5WVkZ4uPj3fqwB0Dl+DOFUc4F2LJfq9WitrYWPj4+iIqKslnGnSAIVFdXIycnxyW7xsfH0draipycHKur8470Pz2qh4yIov8701Cr1ejs7MThw4fR2dmJu+++e1bTsuRyOT744APceeedjFpTCoUCYrEYfD4fgpTF4KnGMdZSBUmi4bfuPFsCrVaLsjJDZSt/f3+sWLHCpXQfT8Id9+6hQ4eoqFF3QKFQ4MCBA7jxxhuNtv8UI6JImHJ+amoqmpqakJqaapXzy8vLERsb61Cqrz2Y75yv0+lQU1MDqVSK6Ohom5wPwOUXtW0nWnFfbiiam5uRk5NjdQFCrVZD33wGQgHfKELJVDOEHtEDAAcSF+Oao/8EYOxksqRJZeqIIveji+za0gohr42c9Kg1WnT3DeDHk2fR1dePu3/5//BdP9fI7pnE4OAg3n//fdx+++2IiYkxs/mlH6rAF4qphYWKku+Qu6oYrXVV0EypEB6fjHsKoijO9/Pzw8qVKyGVSt0mQm4p/ZEe1WbPRBFwz7177NgxTExMoLi42OEoEiZMTk5i//79VjkfMERExd/7EbhC68/T7t2/wY3rl5hVO7UnG4HE3r17cdttt2FychKRkZH46quvzPRgXIU1zp+amqL0XSsqKpCWloaGhgakpqZajYyqqKhAdHS02xedfwqcX1tbC4lEgqioKLve2dwxOZ+YmEBjYyOjlAQdarUa/zjVBg5fwKitRIfpM4FJh8ge0Bcs6BFRlkS9mWCIiNJgI1GLbz9+DwOSUNz5i98hNTXVYmq3pzE4OIgPP/wQt9xyC6N8Af09HwC++OILXHfddaioqMDY2BgyMzOh1+tx/vx5aDQa+Pr6Gt7z+6oZz0cuDLnreWC6mEF+trQI4Y579/jx4xgbG8MVV1zhFs5XqVT49ttvzbRmmSKi4u5+Hzyx9QyAnq9+j+tW5+Pzzz832j7TnO/d4QduhFgsRkpKChoaGpCRkYGGhgYkJSWhtrYWS5YsYRwkBEEgIiIClZWVyMzMdGlVzBSkwPBcfUDZsp/P51OrJt3d3VAoFAgNDbUocqhUKt2ST+/r64ukpCSUlZUhKyvLakUia/bTQU8zM3U+OeuMcsWJVVZWhn379mFwcBC//OUvZ10bqKenBz4+PigvL4dUKqWichQKBXbv3o3w8HBDRbz4eCgvnMLu3buhUqmg6axDc3Mz6urqMDIygssvvxwBAQHo6+vD7t27ceWVV3okGtERrFr8AQAYVUR0x727Zs0atLa24tNPP7UpgmgPZDIZRCIRRkZGnCrQMB8hFouRmpqK+vp6ZGZm4sKFC0hOTkZdXR0WLVrEyDcEQSA8PBxVVVVIT093ixA3ifnO+TweD7m5uVAoFBTnh4SEIDo6mnFRwFHON03hon9OTk6mON+SA+zNY40AAsEVT99r5Kq4cVqXIaLHNA3PVLTckiYVPZVj6/JEgFwZl7eaOUKsXSsdFfXN+K7kOAaGhvHLp55DcnIytjoXVOAWkJxfWVlJpWBsO9EKtWoSH330EVqHCEwpJ/BI8RKcmAoCjwMQWg0SsvMx2N2O/vYmnNF0Yd26dQgKCoJcLsfu3buxYcMGhFlJcWQCk+6K6UTNtD/t3QeYrtwEuHbvrly5Eq2trdi5cyc2btzocoVOqVQKsVjs1qioW265BW+//bbRNqaV8X/96194+OGHqc/79u3DqlWrsHbtWpSXl2NwcBDvvPMObr31Vpw+fdoj0UZMEIlESE9Px4ULFyjOT0lJQX19PfLz8yEQCMyOITm/pqYGqampDhe+sYafAufn5ORAoVCgt7cX4+PjCA4ORkxMDCPnq1Qqt0zIfXx8kJaWZpPzJy+cwL35C42ckGTUJj0VyyBubnBAkTxA8becmRcA44UMa7xuiVusobe5Dh9W7INcJcTWJ/6b0oPzlBPKVE/PFH19fRCLxaiqqoK/vz/1nj85OYndu3cjNDQUk5OTiIqKwpIlS6DVaqFSqbBo0SK0trbiwoULGBwcxLp16xASEoLBwUED56eFICzEnL+EXeWYsKP4BGBcSZHpegCDw4nuxPOx0Y/uuHdXrFiB9vZ26j3fVc4Xi8WQSqWQy+Vu49Qbb7wR//znP422zTTn/2QiokiQYsOhoaGoqamh9ECYtBXq6uoQFBSE/n4DwbgrxA6A0WrVXIQz9svlcnR1dSE+Pt4o2qCvrw9DQ0NIS0tjfFGwBSZ9Jp1Oh4qKCmRnZzPeVM72vy2tKE+jsbER//jHPxAYGIjHH3/co+XmHYVcLkdZWRlVaWViYgK33HIL5WT59NNPIRAIkJWVhejoaKO+V6lU+OKLL7B582ZwuVzU1dWhqqrK7dUnbIEe7QYARQGPATB2RLnz3lUoFPj3v/+NoqIilx2KTCvkP+WIKBI9PT2UgHlNTQ0CAgIQHBzMmMZ44cIFBAYGYmBgAFqt1q0VlX6KnD8wMIDOzk5DZavRJgCGl9z+/n4MDAwgPT2d4nxrK73WnAQkSM63tADBZL+1kthkJJMl4XJyfyZnCd2xRZ/wmG5jeoGmY9uJVlypPI9/fHcSfsQkfnX3zyCTSWdlRZwJg4ODOH/+PBQKBb6r78fqGBluuukmyGQybDvRivM/7AWPz0NMQgoCI6LAE/tQ16tWq7Fr1y6q3HV9fT3Ky8uNClaYRo5Z6mtbMC1VbqonZQ1blye69d6dnJzE119/PSOcDzgWEbXrn6/YpRE1Pj5OvRcDsBgBmZqaivvvvx+///3v7b0km7CH83t7e6FWqxEREYHq6moEBgYiICCA0WFXX19PpbxoNBoUFBS4zdafIucPDg6is7MTMTEx+KzR8C64dXki5HI55HK5Eecz6cM5ApLzMzMzGcffSEUJuAkLjey3FJnExAdMEbNM+9KdUKaRss5ERP3hy6MYP/EVfHx8IFt5CyQyX49HvtobaUWmwJLpXBMTE7jhhhuoe3HXrl2ULnNiYqJR35tyfmNjI86dO4fbb7/dqcgne5+Dzowzd3P+v//9byxevNjptFQSTFFRrkREfbL9ebs0ojzJ+T+ZiCgS0dHRqKqqQmxsLHJzc1FWVgaRSMQ42LRaLcLDwyEUCnHmzBmb6V6OwFvTjuyFM/aHhYUhNDQUHR0d6OrqQnBwMAiCwPj4uEs5z0yOIHJ1vq6ujjHdz9X+ZxLkdjYyyt5j1Wo1zpw5g6effhpSqdQpp50nERYWZjXVbOPGjdBqtYzVVsRiMZYsWYLXXnsNvr6+EIvFuP322z1pLgVTQXXTz6dGXwdwL/XZnfeuTCbDpk2bsH//fkxMTLikIUKukPf397s1enOuIyoqClVVVYiLi0Nubi7Ky8vB5/MZHVFk9SWRSISTJ08iLy+P5fxLcMb+0NBQivM76xoRWrAWRGcnxsbGHBrrTJMG0208Hg95eXmoqalhXDSi2z89KTB2DumbzAXLmcRpyWPo5baNJi0mmlCk44Os+GPPajsAPFoYi507T+B///d/IZPJvI7zQ0JCKM6/meH77OVroNNqIfUxLJjQfzOhUIhly5bhtddeg7+/P0QiETZv3myi3XWpbxn60xpMx4dpSqQ9Tij68e68d6VSKW6//Xbs378f4+PjLi1wSqVSSKVS9PT0uDWSxxZ8fX1tFn4ADAK7pOD1TIKs7hYfH4+8vDyUl5eDw+EwOqI0Gg0iIiIglUpx7Ngx5Ofns5x/Cc7YHxISgpCQEHR2dqK7sQ5b1uWgq6sLo6OjZpxvcOA472CxxfmyrJVm26w5lJj2YTrGPPpmeoJuGnlD7j+9aGH9erVaLVI7SrDhtg0IyF83Y5xvr1MnJCTEauXna6+9FiqVipEfhEIhVq1ahVdffRUBAQEQCAS48847zc5vbySsPXAmGg1wP+dv2rQJBw4cwPj4uEsLnGKxGH5+fujq6jJKi/c0PMn5PzlHFAAqvDA0NBSFhYWM++h0OiptgMPhICYmBlVVVW5zRk1MTACwXq7Um+Gs/RwOB/Hx8YiPj8fw8DAAQyliT4DP54PL5UKj0ZiRub32mzqK6NEydDgbFWXvcfX19Th37hyuuuoqEASBiYmJOTd2yOit0dFRAOZ9Hxoaissvv5yqRueOEG5bMP0tmX+Pe40+ufve5XK5uOqqq7Br1y7ExcU5XO2QjuLiYuzcuRO33377jPTfXIFEIqEKT1jKX9fr9VSfcblcxMbGUnoWLOe7Zn9cXBzi4u7CyMgICIJg5HxHonwsrW7yeDzweDyo1WqzkHq6/eQK9rYTdCfF9GTCUiqApZVwSzoiDy6MxPZSYAtOUWKs9HNbQ2NjI86cOYMrrrgCHA7Hbs53NcrAXaDbQHK+KYKDg3H55ZcjNzcXer0e20+1W2wDsH+MmDoMyc/W9F6s9Zkn7t0rrrgCX3zxBeLi4lxqd/369bPO+RMTE3juuedw3XXXITIyEoODg9i+fTu6u7vxs5/9bFZskkqlqKqqQnBwsMVqXQRBUNzO4XAQFxfHcj4NrtgfGxuLF++JxcjICPR6PeOk2R2RnTweD3w+H1NTU2bZD3T7mSpqWgLdkcS0rzWOJZ0opKC5cVSVubOFm1KEiR3PwmfzU2hubsbJkyexYUUheAIhxmuOISh/rVVbvQ2kc9zSe35gYCDWr1+P/Px8o3cuOkzHhT2aipbg7LPQE/ducXExvvzyS0OEuAvp1OvXr8enn346bzh/Xs5UmpubrX6fmpqKnJwctLe3o62tzeJ+ExMTGBwcRHd3N9LT05GQkIDS0lJoNBqXbRSLxQ5VmvA2uMP+oKAgt4vAm4LUBzAFk/2kBhQdmqZzZs4Ja5FQTE4qVzA4OIhdu3ZheHgYd9xxB4KCgubt2AkKCsKCBQvA5XJnjFzJ35fpd7YET/X/unXrcO6ca2mefD4fK1euxMGDB91k1dyALc5PSUlBTk4OOjo60NpqeYVscnISAwMD6OrqQnp6OqU3RwpXuoL5et86gsDAQI9zPqkLZgqxWIwPK8x1PEhdkO3ycItV67aE9ZtpgDBFaZElocmJChlNtV0eDnVMPnWMtRfq4eFh7Nq1C3K5HHfccQdCQkIc6ntvcEKZwpL9AQEBVCQDl8ulIgcA910HU2QU+X/6nzV4kvPPnz/vUht8Ph+rVq3CgQPmJehnCjweDxcuXMDNN9+MtLQ0bNy4EUNDQzh69KjbqsOaoqmpyer3ycnJyMkxROO0tLRY3G9ycpKSjUhLS0NSUhJKS0tZzof7ON/dhT9M4ch7PhMHmG4nI1htRdNsO9Fqpq1E53ZL3AMYi2cr0wqxa9cu9Pb2YvPmzQgrvBLSjGWQZiyzen5vhqWx4+fnR0UE2fueb9qvMwFP3bvFxcU4e9Z6hV9b4HK5WL16Nfbv3+8mqxyHOzl/XkZESSQS1NfXIz093ep+hYWFaG1txcWLF81S83g8HhYvXoyenh74+vqCz+fDz88PGRkZaGlpsdm2LWi1WpeOn23MFftFIhH8/PzQ19eHiIgIarsl++11Rljaz97jKysroVarLa7UjY6OoqSkBCKRCDfccIPR6v5c6XtLYO1nhlqtdkuZ5z179iAwMBBdXV0uRVfNJfj4+ODChQtIT0+3upJdWFiI9vZ2jI6Omq10cblcLF68GL29vfDx8YFAIIBAIKA4PyMjwyUb2XFvP1yJ6nnrXDdG+scQEtJrJDav1WrxwCJDsQxbqXH0FditKcbRUsY2Fl0SPL/0fVc/tlAancYOjurqaiiVSixZQorjGr9Yj42N4Yk3PgWPL0DqwmXo54ixgma7o/CWyChg9sY+0/U70yeesl+r1bol9WbPnj3w8/NDR0fHrETfiMVi7N69e0bP6evri7q6OmRkZFjl/CVLlqCjo4NR1J3D4VCcL5FIIBQKIRQKkZWVhaamJio621mwnD8zEAqFCA4ORnd3t1FBJLr9tu57ezWc6KLmDy6MBLqmnw1kJBXpNKmpqYFCocDW5UvN+FhSWIyxcQW+//Vm8LlcXPenfxo5PuZK31sCa7/ldt3F+TKZDO3t7bNSoMidnD8vHVFRUVHQ6XQoKyuzmu9NponV1dUxakRxOByzKm/kBKW3t9elikrsTTpzIMOtAwMDqYk+k/3OptdZqoBnTf9JJBKhpKQELS0tGB8fR0BAAMbGxlBeXo7LLrsMfD4fV1xxBWOe8lzqeyaw9jNDo9G4pbqORCIBn8/HoUOHcO2117rBMu9HREQE9Ho9ysvLkZeXZ3GljUy/qK2tZZywcTgcM60VUnvL9CXXUbDj3jac1XMwFVoNDI/CqwfKEBZ7Eb9ea3AgkvYbnEzhJlpE0+cnHUlM1diYzmsJKpXKaGIhkUjwww8/oLW1FWPNFQhMM1QWLC0txaq0CAhispC2eDnEUpnZZIgdO7MLTy4+uGNSIpFIIBAIcOTIEVx99dVusMz7ER4eDr1eT73nW+P82NhY1NTUMEZjMnG+RCKBj4+Pyzos7Lj3HEwdO6T+b3BwMMW7pP32OuVNnweWzktC2FWO7fJwPLgwEsKucrN9xfIL2P/DUbS3t+NkWSuielOgUChw/vx5XJYeCW1zFdYuSELoZdeCS3tW6JtOQRvi2sLXbMPbxo6j6X2esl+lUrllwVkqlYLH4+Ho0aNznvPnZWoeYAgHTUxMtJqGARginzgcDoaHh2FvAcGkpCRcvHjRou6BPZDJZF5V8cxReKP91tLiMjIyjEJ33WW/rVQ8S86t9PR0hIWFYdGiRXjggQfA5/NRWlqK2267DTfeeCOuv/56i2J53tj3joC1nxnumpQsXLiQqkR56NAh1w2bIwgICEBSUpJNzidTPx3h/ISEBCgUCoyMjDhtHzvu7YelSQNdJJz8ozuD6MKwEQkpkHe0UMeQ9tMr5BlFM13aZpoGoDxzAN+u+i8ozxzAgwsjqfQ7AJTwOLkfHaaV9pKTkxEZGYm8QA7u/9lGCIbacO7cOdx666246dHfYmN2OJ683LywBt12R+At0VDA7I59fdMp6o9puz3wlP1M+pXOgIzq+SlyfkpKitXUO8DA+TweD4ODg3Zzfnx8PCYnJyktU2fAcv7MIjMzExcuXKA+k/abio2bOpuspeea7k/utyWsH+qYfADmXE8iee3NiA4PRU4AgWUbb8UPbeNGnH/rz3+B0MuYFwvnWt+bYjbtN30/MH1HsAee5Hx3LDgvWbIEfX19GBkZQUlJiRssmz3MW0cUYHhIjY+P29wvKysLExMTOHfunN1q7+np6ZDL5aioqHDKIaVQKKgy93MRc81+0xvfnfaTAuZMTimmbV9//TXGxsaQlJSEL774AlNTU1i/fj22bduGZcuW2cybnmt9bwrWfma0tLQgISHB5XZSU1PR1taGpqamOVs22ln4+/vb9dtkZmZSnK9SqexqOy0tDYODg6ioqHDKIcWOe9uwR6+H3I90INEdR/RjH78sDZsLYqhtTPaTx24J62espsRNKYKksBjXHP0nJIXFZhMOunYUKXCuPHPATBSbzvlf7i+BOiYf64oWYdu2bVixYgXF+ZZW7l8/XMeOHSdATkCUZw5AeeYAJnY861SZcE/Z39TUhKSkJJfbSUlJQUdHB5qamn4y6dgk/Pz8KGFha8jMzIRKpcL58+cxOTlpV9upqakYGhpiOd9LYEtwnCxQRILJfvIZY8khYaoHaPpMomsBCrvKcX/bJwBgpDEITHN+QnQk9vznEO7PC0NKwRK8+uqrWLlyJbhcLnWMaZQON6XI6/reUcyW/fTfle4spG+zB57k/MRE1xeJUlJS0NnZiYaGBruq2Xkz5mVqHh1k5TtrIEN3AYNAuT1hcxwOB2lpaSAIAhUVFcjKynLIy+ltZZgdhTfabyu1zs/PDwMDAwgNDXWb/dbOyfSdWq3G1NQUvv76a5w+fRpcLhc6nY7R824x5c8L+94RsPYzg0zRdBUBAQEIDQ3F4OAgUlNTXTdsjsERzudyuVAoFHaJUnI4HKo/KyoqIJVKHQqxZse967BWVtsU+qZT8B3phVwegbCwMMp+pmNMJwL0fehOpS1h/VDDEBVlaRUcAO5v+wQ+m58CYAjxn5qawjfffIPTp08D4EGr1UKWu8boGGsV3R4sMnZWuFJFaDYwm2Pn56m3AQCuiZBh3cubAJinctqCp+y/ePGiW8T7/fz8EBERAblcjpSUFDdYNrdgL+fHxMSAx+NhYmLCrvLsLOfPLfu3nWjFcN8YwsP7ER4ebtX+6Wqp01xqqg1ItmlahVO3+yUoTdrbEtYPfVO/oR29HiqVCl//8284VVYNbkAEdDodnlhnLOJs7fllaru9GlbegtkYO/qmU7i/7YBR1dt3SnuxJQxQx+Qzpk9agqfsHxkZQUhIiMvtSKVSREVFoa+vD8nJyW6wbPYwrx1RKpXKIedQVFQUKisrHXox4HA4yMrKQl1dHfLy8uw+bq6XVp+L9ickJKChoQFjY2NmmgCuwFZ6nlqtRmdnJ44dOwaxWIyKigqMj4/j3nvvtShWDlh2clnre2u6VN6CuTh26PCE/YODg26tJnbHHXfg73//O5RK09el+Y2pqSmHXiAiIyNRUVHh8ItBVlYWqqurUVBQYPcx7Lh3L0hHgiWnAjelCIkpoDjfHn0v8mV/S1g/NTHZEmZoS6VSAV39lC7IlrB+MycVmZ4nWLgWzc3NOH78OEQiESorKzE2Noa7774bS5YsYTy3tQmGad/Tr3cmJiiuCp/Pxtj5d+QCs22SwmKnnHeesH94eNitIrN33nkn/vrXv/7kOF+tVoPPt38qEx4ejvLycoSGhjp0HpbzZx90h5DlQgSJaGxsxNjYmEP6Xkwp3kyft4T1A2HT0a+SwmJAblhw6Oztx8lTn0AgEKCqqgoj7fW4+7H/xtKlSx2+VtO+nysOKBIzPXbov9/PU2+jFh62XHJKicViwAHu94T9o6Ojbo1euuOOO/DSSy/Nec73LpZxMxxNdeHxeHatrJhCKBQiMjISjY2Ndh8zNTVldxqgN2Ku2p+WlgaZTIaGhga322/J+XPw4EF8+eWXSElJQWlpKa6++mq8+uqrVp1Q1mCr773ZCQXM3bFDwhP2X7hwweUKPXSQKyQ/Jb0QwHHOJ7VDHIVAIEBMTAxjyWhLYMe9dVjTbjCdJNC1oWw5FtLS0uDn54f6+nqb9pNpGNvl4WbnNI2AIp1RpqkcksJiHDx5Dp+/9QqSk5Nx7tw5XHnllXj11VctOqFMr9EU7NhxDPqmU1j38iase3kT3mj8DP8g2rCxt9rpCDJP2F9XV+dy9WU64uPjAQCHDx92W5tzAc5wviOOKxICgQBxcXFGGkS2wN63zoPpeUB3utO1f0y5MzU1FQEBAXZxPpkax00pMtL8YwL5bCBBj7z59X/a8OvPzyAxMRHnzp3Dhg0bsO3DnVadUNaeeezYcRzfrvovPHHHu9TnH5/YCeWZA07xvifsr6+vR2Zmptvai4uLA5fLnfPv+fPWEXXx4kVwOByHRcH8/f2dygUPCwuDn58fVaLZFlghutlDeHg4xGKxW6siWKuat3r1agQHB2PPnj245ZZbqPxwZ2Gt773dCQXM7bEDeMb+/v5+8Pl8/Pjjj9Dr9W5p8+abb8a5c94/HtyFsbExEAThcEWSgIAApwRpQ0NDERgYiKqqKrs0R9hxbx2OlNcmRcXtRVhYGKRSKTQajUO22JqYmIKcmKxeko+QwAB8/fXXuOWWW7Bq1SqrnG9Lt8ha38/ESrmr52Cyn0k02F3gphTBZ/NTeC/hTod+P0vwxNjv6+uDRCLBwYMH3cb5mzZtQllZmVvamgsYHx+HTqezK7WajqCgIAwODjp8vuDgYAQHB6OyspLl/BkE6XSi8xDpPLLEnaGhofDx8YFarbbrHKbPF0sw1Rgi+SU5dwk2xvLxzTff4KabbsLKKKFVzrfFfd7S985ipu0no5GviZDhjcbPcM3Rf+Kao/+kUuQdhSfs7+npgUwmw8GDB902/7zttttQVVXllrZmC/MyNe/ixYvo6upyaqVbIpHYTVymCA8Ph5+fH7q6ujAxMQE+nw+CIKiS4XQRSVIEzR2aMLOBuW5/WFgYampqsHz5cqedQqSGkyXnj145Dl50Oj756x+QmpoKsVhsdUXcXsz1vmftZwaXy0VNTQ2ampqQnZ2NFStWuNTeypUr8emnn7rJOu/G2NgYurq6wOFwHD5WKpU6zflhYWHw9fVFd3c3FAqFEefHxsYaicWz4955cFOKAHkrYxrathOtRsLllhA82YU6uRzBwcHYfqrdpnOFPCcTti5PxMSOZ4GwYuoFWFJYjBPnK6CqPYeuoVHEBvpBnLvWZlqGPZFdlvqeXiVwpuCovhJg2X5P2+2u9j019nk8Hmpra9Hc3IysrCysXLnSpfaWL1+Ojz/+2E3WeTdIzncGEonE6WiH0NBQ+Pr6oqury4zzY2JijMYIy/nOw96FiS1hlvf5tkOFxaJ+BAcH25wPTkdZ9TPym6XzLez+AVPByfjoWA3uTYmFIEqCZcuW2WW7tWv0prHjTGr2TNvvs/kpbHTS6cQET9iv1+vB5/Mpzs/IyMBll13mUptLly7Fhx9+6CYLZwfzMiJqeHgYfD7f4ZVxwLDi0dXV5fTERCKRIDU1Ffn5+ViwYAFycnIgEAjMQoGdTQP0Fsx1+/l8PtLS0lBRUeHwaqQ9Okx6vR5vPP1rtJ48gIULF2L//v244447XLKZxFzve9Z+c5A6F5GRkbj11lshl8tdbpPP56O4uNj2jvMAg4OD4PF4Dq+MA4bV8a6uLqcnJhKJBCkpKUacLxQKWc53I+gOF9LpRI+oYao8ZAph8hKkpaWhvLwcW4riLZ4HMDhbJnY8a/HlW990iop+khQWQ1JYDL1ej9L/fIuoIF/kJ0bh0KAWd955p81rs2X7xI5nMfXNa2Z976loIlOYnoeMQnCk+hzT2JlLmiee4nwul4vIyEjcdttt6O+3r5qTNXC5XGzYsMEN1nk/BgYGwOPx7BIdN0VgYCB6e3ud5nyxWGzG+SKRiOV8D8G0Ih1gHLlkiT8fKEyg3vN1Op3Vc1hLBQRgVlmVROWFJhwZEeB/VkTg35/twF0rbKfb2lo82HaiFR+WdoPTUW6zLU+DjERzNILVW8aOs/CE/VqtFnq9HpGRkdi8eTMGBgZcbnM+cP68dEQlJiYiPj4ew8PDqKiocOhYHo+H3NxcVFVVYXx83C32qNVqs4elUCh0OG3QmzAf7Pf390d6ejoqKiocnvgLUhZbFSnncrn42c9+hrNnz+L111/Hww8/7KrJFOZD37P2G6O4uBiHDh1CTk4O9u7di6uuusot7RYVzY2qWq4iKSkJCQkJGBkZcTg1hcvlIi8vD9XV1W7j/KmpKfj4+BhtY8e9AY44MOigO52cAcn5GRkZqKiosHvibzphUJ45QEVBkeCmFIHL5eLGpdmo5obgvco+PHTbDU7ZaQpJYTGEXED79d/M7JqttDx7HH90zOTYJydM7kz98yTnZ2dn45tvvnEb59uKxpgvSE5Opjj//PnzDh1L5/yxsTG32KNSqcxSeVjON8DV+9BqIQcrPERyfmZmJiorK9HX12f1PHSHl6nN2+Xh2Hai1ex8m65Zj/a6Crz+yRf4+a9+CcD5ZxwdHL4AQoH3JC05+rxhx745iouLceTIEWRnZ+Orr75yG+cvX77cLe3MFhxyRL3wwgtYsmQJfH19ERYWhhtuuMFIrLWtrQ0cDofx7/PPP6f2++abb5CWlob09HTs3bvX7PiwsDCzCUF+fj7+8Ic/2G1rWFgY1q5d61AlOxICgQAFBQXo7e1FbW2tTU+6M1AqlXNa6X6+2C+VSlFQUACFQmF3mDeZjmdLj4nP5+PIkSNYunQp4uLi3GE2gPnT956EIGUxXrzpb9SfrcqGjsAT9oeEhODqq69GRUUFrr32Wqcie5hATwee7wgNDcWaNWscqmpEguV823CX/c44kugvwaZaHva+HJty/uTkJDo7O83OQ9ros/kpI2eGqTYIkzMqcPP/4Ni5CmRLNAjrrnbLhISbUgTOtb8AsWCVy215AvZc40yMfU9qTnmS82tqanD11Vc7FdnDhLmsK+MoQkNDsXr1aixatMjhY/l8PgoKCtDf34+amhqW8xngLvtnK/qRtF8ikaCgoAAqlQodHR2M+5o+S+j/f3BhJB5cGIktYf3QN52idKG4KUUQZ6xEa9V5DEQsRGJstNlzwRlsXZ6Iu3PD8FaPv+2dPQx6dVoS+qZTNrmWHfvmCAoKwtVXX43a2lpceeWVbuN8d7UzW3DIEXX48GFs2bIFp06dwoEDB6DRaLBhwwZMTEwAAGJjY9Hb22v098c//hEymYzy/E1NTWHLli1444038Prrr+PRRx81S4MbHx/HX//6VzddonPgcrlIS0tDTEwMWltde7kRiURmA1oikUAikbjU7mzC2+x31NFgan9SUhJGR0ddskEul6O9vZ36fOTIEUxNTWHz5s0utWsKb+t7R+Fp+1ct/gBFAY9Rn5+q/JdbRdw9Zf9nn32G2NhYr9AE+CmC5Py4uDi0tLS41JZYLDYTs2XvW/eAniZg6WWYabup/YmJiUacb9oekwPKtGJS5w9fobWzm9p27NgxqNRq3LY8B4Dz0VtMtvtketeqp7WqVabw5NixNA7cGTHmKft37tyJyMhIBAUFub1tFrbB5XKRmpqKhIQENDc3u9SWRCKhdGXo27yBM53FXLSfzkum9ickJODixYtWjzflk63LE/FOaS9VNXV49CIGutspbj9+/DjUKhWWXHUTdYw7nFESiQSPrkxzuR13wpGU7Lk4dujwlP1ffvklQkNDERIS4va25yocckR9//33uPfee5GdnY28vDx88MEH6OjooMJieTweIiIijP727NmDW2+9lVqlmZqaAo/HQ35+PgoKCsDn883ytLdu3YpXXnnFLToprsLPz8+u6hjWkJSUZFbyVa1WO61D5Q3wNvsddTQw2U8QhEs2yGQyfPLJJ9izZw+am5vxww8/2KyW5Ay8re8dhafsJ9MlT42+DsDggPrd7l+5vZKgp+zfvHmzyw4QFq5DJpO5vBKWlJRkFC0MsPetLahUKrtfcm05GZi+s2W/aZtbwvqxJawfyjMHcH/bJ9TEg9SEAoDg5Vfi070H8OUbL6K5uRnff/Y+lhUsgO/yq5yu1sMEVf1Jrxs79LLnthxunho7nnZAkfCU/bfffjva2trcVjWPhXPw8fGBSqVyqY3ExEQ0NjYabWM5f3ZA8pGj9psuRJBFKe5v+8TQXkw+PhyLQ9nBb/HA82+gubkZL7y3EwlZ+eDz+UY86Go07D+ON3lV35vyvS2Onatjh4Sn7N+0aRM6OztZzqfBpQRU0rNsaTXn/PnzKC8vx/bt26ltfn5+uO+++xAZGQkOh4M//elP8PX1NTru9ttvx4EDB/B///d/eP311x22y90htjKZDCMjIwgMDHTqeD6fj/j4eFRWVmLBggXgcrlzfhDOR/tJITlnHUdSqRSrV69Ge3s7vvvuO/j7++P666931VQzzMe+dwfMHU73euQ8nrKfy+Vi4cKFOHPmDAoLCz1yjvkKd3O+n58fhoeHnY5U4PF4SEhIQEVFBRYsWAAej8fetzYgFosBByOIHHE4mNq/7UQruho6EDUqAZfHoyKtptu+ZMuZA5TjyVBZaTpCSpa7Bmtu5KPtzEHs/WA7/H19cWPxardFQlGIL5jT48eTts9E2o8nOb+wsBCnT5/+yWg7uQvuKn9Owt/fH0NDQwgODnbqeB6Ph8TERJbzZxlGziAG+3U6HXQ6HaMQtWn6NxVZVVgMyAFhVzl+FQcsXZuC9p5+/Oa1DyGW+iJvzZXUse5agLh3Ucyc7H8Sc9l2wLP2FxUV4cSJEy5XSZ0vcNoRpdfr8fjjj2PFihVYsGAB4z7vvvsuMjMzzYS0nnnmGTz++OPgcrlmTigA4HA4ePHFF7Fx40b86le/QnJyskO21dXVwc/PDxKJBAkJCS4r3ycmJqK6uhojIyNISkpyqo2goCCIRCJUVlZCKBQiMDDQ6QeeN8BUiHeugcn+kJAQjI+PG5VcdxQrV67EypUrsWfPHoyNjXlEr2E+9v1cgiftz8zMxM6dO7F48WK3R9LNZ5CcLxaLkZCQYFa9yFHEx8dTnO/o84dEYGAgRCIRqqqq5jzn65tOQXLJ2acf4Lnf0TIDML1vty5PRFecAD4+PmaLTHTnhunEwvTa6ZyvqK1FQMHlAOwr0e2s7XMNnrJ/prRnPNn/qampKC0txdKlS1nOdwAXLlzwKOdzOByH2wgICIBIJEJ1dTUEAgECAgLmbArOthOteDi4B+roPKhUKrfpVs4kmO7bsLAwjI6OWn0WT/NKInwu8f3WFMNnAFiZUoSVAKR79qCurg6/vcJxLWJbYDl/duFJ+5OTk3H+/HlotVqXeWs+wOke2LJlC6qrq3Hs2DHG75VKJXbs2IGnnmL2Dtua7F9xxRVYuXIlnnrqKezYscMh2+Lj4xESEoKhoSGcO3cOqampVJnXiYkJiEQi6PV6aDQayGQyKBQKCAQCcLlcTE1NQSaTYWJiAlwuF0KhEEqlEmlpaejo6EBdXR1SU1OhUCgY2+Hz+eDz+VCpVPDx8cHk5CQ4HA7EYjE0Gg0yMzMxOTmJ9vZ21NfXIz09neoLtVrN2I5UKqXChiUSCSYmJiAWi6HVaqHVaqljSIV/ejs8Ho+6BrIdgiCovhCLxdDpdFb7wrQdiUSCgYEB6PV6REVFWewLejumfTE5OQmJRAK1Wg2dTmf1Gqz16eTkpN19QW9Ho9FApVLBz8+P6ovJyUlwuVwQBGF3XzD1KY/Hw+TkJAYHB6HVap3uC0vja2JiAlNTU4iMjHRLX1gaF+4YX0zXQPazWCy2OL7s6QuBQAAej2dxXDg7vsi0LEt92tPTA4FAAH9/f4fvNdM+ZRpfubm5+OGHH1BYWEhdg16vh4+Pj8P32lwOjXYEdM4/f/682zi/q6sLtbW1SEtLc4rz1Wo1MjMzoVQq0dbWhvr6eqSlpVE6YHOG82MLjDh/bHR03nA+YFj8kslkuCsrEAKBAEql0iHOFwgEUCgURpx/f14YuFwuRkdHWc5nOd/qvZaXl4cDBw5g6dKlLOfbCU9wfmpqKrq7u1FbW4v09HSnOH9qagoZGRkU5zc0NCA1NZVyds8Vzn9oURT6SuuhHzqKqGA/jIZnzwvOn5iYgFarBY/Hc+k9n+T8gYEB9j2f5XynOP+HH35AUVHRT57znVp+eeyxx7B3716UlJQgJiaGcZ8vvvgCk5OTuPvuu5027sUXX8TOnTsdLsdNQiqVIjMzE62traiqqqJE1elQKpUYHh62qz1/f3+bQnf2gM/nIyIiAmlpaRgZGXG5vdnAfCjNKRKJjLbFxcWho6PDZa2A3t5eREVFgcPhuD18HJj7fS8Sicz6fi7B0/0fExODqakp9PT04MyZM/j000/NtCe8DUeOHMHGjRupcf/VV1/Nih1SqRRZWVkU55uKxwIGLaKhoSG72vPz83NLeW9SPzE9PZ3l/FkCE+fHxsais7PTZU2wnp4eREZGgsfjeeSlcK73Pcv51hEdHQ2NRoPu7m6cO3cOn376qZnG3FzCI488Ag6Hg7///e8eP5dUKkV2djbF+aYVtwGDNu1scX5mZqbdcwxvgzh5IcRJBeAmL51tU5wCE+fHxMSgp6fHZe1fuVyO0NBQCIVCl9tiAsv5swtP939UVBT0ej06OztRWlqKzz77DHV1dR47n6fhCudzCAcUmgmCwNatW7Fnzx4cOnQIqampFvdds2YNQkJC8MUXX9htTFtbGxITE1FWVob8/HwAwM9+9jOMjY2hv78fN9xwA/7whz9YPH5sbIxyFpmWLdfr9VS7PB4PCoUCWq0Wzc3NkEgkyMrKssvGwcFB1NXVgc/nIy8vz+myiaRTrKGhwaly47MN0v65Gn5pyX69Xo/y8nIsXLjQpfa//PJLlJaW4oknnnB7RZz52vdzBTNhv16vx3fffYehoSH4+fnh+uuvdyptg86JGo0GISEh4CUWgGOjLW1nLfbu/hzXXHONXefZt28fjh8/jkWLFuGmm27Cnj17cMMNNzhsr6NwlPN1Oh2am5shEomQnZ1t1zmGhoZQW1tLFdlgOX9+3bfu5Pzy8nJs3boVYWFhLrVlivna93MFM8X533//Pfr7+xEQEOAWzgcMC6jx934ErtA6b3Xv/g12/fMVl3Ut9+zZgz/+8Y8YGBjAk08+iccff9yl9kxhjfMJgkBZWRlyc3PB5/Op9/yWlhYIhUKLMiKmGBkZQU1NDTgcDvLz853+3VnOn13Y4vyCggKnUjBJfPnll6iqqsJDDz2EqKgol2w1xXzt+7mCmbL/u+++cyvn8/l8+Pj4IO7u98ETm0sf0dHz1e/xyfbnccsttzhrPgDXOd+h1LwtW7Zgx44d+Prrr+Hr64u+vj4AhgcdvcxhU1MTjhw5gu+++84hY5jw3HPPITs72+U8Si6Xi6ysLFRUVIDH48HX1xdCoRBZWVloaGiwu52QkBBoNBokJiaiubkZERERCA0NddgejUYDwLAiW11djeDgYGg0Gvj6+jotij6TIO2fq7BkP5fLRVRUFPr6+hAREeF0+wRBIDQ0FC0tLW53RM3Xvp8rmAn7uVwurr32Wsjlchw9ehRcLhcqlQpCodArdUSuuuoqXHXVVbNthhG4XC6ys7PNOD8jI8OhCLPg4GDodDrEx8ejubkZ4eHhTjkayHETFxdnxPkymWxOlG+fr/ctl8tFTEwMent7ERkZ6dI5QkND0dra6nZH1Hzt+7mCmeL8q6++es5wPhO6u7uxdetW7N+/3+5FDHeCw+EgOzsbVVVV4HK5kMlkEIlEDnN+YGAg9Ho94uPj0draitDQUISHhztsDzlu4uPjUVVVRc0fWM6fGVjj/Li4OPT09CA6Otqlc5Cc725H1Hzt+7mCmbL/6quvxuDgIA4fPkxxPplGOBfgDs536On25ptv4uLFi1izZg0iIyOpv507dxrt99577yEmJgYbNmxwyig60tLScP/997ucLgUY8q4XLlyIvLw8JCUlISYmBhKJBGFhYejs7LS7nZiYGFRXVyMjIwP9/f22D2CATCaDTCZDSEgIkpKSKDHbwcFBdHR0ONXmTIK0f67Cmv3h4eEYHBx0qf2wsDDEx8ejtLTUpXaYMJ/7fi5gJu0/evQoDh8+jPb2djz55JNu4UHAjiBYgoBGo8HY2JjR39TUlBvOP3MQi8VmnC+VShEeHo729na724mOjqZ0Q+RyuVO2kOMmODgYycnJEAqFCAgIwNDQENra2pxqcyYxn+/b0NBQlzk/IiICsbGxLOczgLXffpw6dQqHDh2iON8daT92JT4Qepc4X6/X46677sKTTz5pd7SpJyASiVBQUIC8vDwkJydTnB8REeEQz0ZFRVH6gAMDA07ZQo6boKAgpKSkUJw/PDzMcv4MwJr9ISEhLqdMRkVFISoqChUVFS61w4T53PdzATNp/5kzZ/Djjz+io6PDbZwPwnbVP8JLON8hl5u9WXzPP/88nn/+eYeNSUhIYDzHW2+9hbfeesvh9uxFZGQkWltbKVFBW6GaaWlpEAgE0Ov1kEql6O/vd3i1hNQuCQgIgFQqpdI9fH190d3djfb2dsTHxzt3QTMAuv1zEdbs53A4IAjCpYoG4eHhIAgCp06dcsVMRsznvp8LmEn7Ozo6oFar8eGHH+K+++5zOi0MMESupqam4oknHsHDDz9scb/z589j1apVOHz4MG688Uaj75555hmr6dFzBeSkhBQPt8X5qampFOf7+Pg4FTFJHzcSiYSKIvbz80NPTw/a2tqQkJDg1PXMBObzfcvhcMDhcKDRaCAQCJxqPyIiAhqNBidPnoRer3drFMt87vu5gJm0v6WlBRqNBh9//DHuvvtulyZDPj4+gMgfXT+8AV6oZfkJQjkM7XAnjh07hp/97GdG39nL+X/+85/B5/Pxi1/8wml7PQly8cFezk9JSQGfz4der4dMJnMqYtIa5/f29qK1tRWJiTNT+dEZzPf7lsvlQq1WO60FFBUVBZVKhRMnTrCcbwLWfvvR0NAArVaLjz/+GJs3bzZLOXYEYrEYEAeg6+Bb4IVZdg4RyhFoB9tw8uRJbN682ei7meb8uRHvOwNITExEWFgYysrK7Io6SExMhEgkQlJSEpWi6AgEAoHFF97o6Gi3iKJ7EtbsnwuwZX9KSgoqKirQ1tbmlLhwYmIihoeH4ePjg9bWVldMNcN873tvx0zaX1BQAJFIhM2bN6O2ttaltvh8Pl588UU888wzjIKugGGx4cknn8TWrVvx4osv4uLFi0Z/v//9712ywZuQkJCAiIgIuzk/ISEBYrEYiYmJTkXCWhs3UVFRbhHI9STm+32bkpKCyspKtLW1ObVSHh8fj6GhIfj7+6O5udkVU80w3/ve2zGT9i9evBgikQibNm1yWbCcx+Phm88/hr6vHITOsoi+rucsuCEZ+POf/2wX5//rX/+iIgZkMhkOHz6MV199FR988IFLmjueRnx8PCIjI1FWVmZXgQKS8xMSEpyKirI2biIjIy0+h70F8/2+TUlJQVVVFVpbW53i/OjoaAwPDyMoKMjtxQXme997O2bS/iVLlkAkEuHWW291uTARl8vFd7t3QN9fDkJrObJJ13sO3OA0vPTSS7PO+awjioaAgADk5uaioaEB9fX1dofHcblc6PW2w+BMj7HmPdfr9R4J93QXbNnv7bBlP5nGGRISgomJCZw/f56xApclkNU6IiMjUV5e7gaLpzHf+97bMZP2r1mzBq+++ipSUlIQFBTkcmrejTfeiJSUFPz1r39l/H7fvn2orKzE73//e4hEIvj5+Rn9zeUqKEzw9/dHXl4eGhsbUV9fz1hZlQk8Hg86nc6hc9kzbpytEDsTmO/3LZnGGRISgsnJSZw/f96hiSKfz6fSPt397J7vfe/tmEn7V65ciVdffRWpqakIDg52OU3j2muvBUccCH1/FeP3+rFuEJODGLhwxG7Ov+6661BeXk79nThxAnK5HHFxcZS+SXt7O5544gmvi/L08/NDXl4empqacOHCBYc431HdGFvjhsvl4vz58w61OZOY7/etSCTCwoULERoaCqVSifPnzzu0IMTn8yGTyRAeHo6qKub7y1nM9773dsyk/StWrMBrr72G1NRUhIeHu7woeeWVV4IjCYZeXsn4vX68F4SiH/113sH5c3eUeAh8Ph+5ublISEhAd3c3KioqbDqZoqOjHdKYAgzlZC3lYfb398PHx8dIAN7bYM3+uQB77OdwOJDJZIiJiUFBQQH6+vpQXV2Nqqoqu4ji8ssvx9TUlNsnlz+FvvdmzJb9MTExDukaMYHD4eCll17Cyy+/jN7eXqPvtFotfvOb3+Cpp56as+HUzoDH4yEnJwcJCQno7e1FeXn5jHO+XC6HWCx2KfXS0/gp3LemnN/f309xvj1RyuvXr4darXa7I+qn0PfejNmyPzY21uWIag6HgzOH/g39YC0ItbHThSD00PWcAzc8zyHxbF9fX6SkpFB/Dz30ECorK40mKlFRUXjyySexf/9+l+z3BEjOT0pKcojzu7q6HDqPtXEzMDAAgUDg1To6P4X7luT86OhoFBQUYGBggOL80dFRm+dYv349pqam3L7g/FPoe2/GbNkfFxfnsk40h8PB+SPfQj9QB0JtHEBBEAT0PWfBDc9FSEiI3W16kvPnhiz7LEAkEiE1NRXj4+NoaGhARkaGxX2DgoKoB5RcLkdoaKjNUDVLJSFVKhX6+/uRm5vrvPEzgLlakpOEo/ZzuVykpKQAMESrNTU1ob29Hf7+/pQHWSQSGXnQhUIhCgoK8PXXX7s1f/yn1vfehtmyPyUlBfv370d6erpL7SxbtgxXXXUVnnnmGbz99tvU9g8++AAqlQqPPvqow20qFAo0NTVRn1tbW1FeXo6goCDExcW5ZO9MQSQSISUlBQqFAvX19cjMzLS4b2BgIOWIcpXzp6am0Nvbi7y8POeNnwH81O5bOucTBIGmpiZ0dHTYxfktLS0s59PA2u8ckpKSsG/fPpfFvxcvXgyOXxx0faXgx62ithMjzYBejcmWoy61HxwcjODgYKNtAoEAERERLj+vPAmhUIiUlBRMTk7iwoULyMqyrKMVEBBATRBd5Xy1Wo2enh6W8z0MZzg/OTkZgDnn+/v7M3I+n8/H4sWL0dTUxHI+Daz9ziExMRF79+7FggULXGqnoKAAnIAE6HrPgx+/mtpOjLaA0Kow0ew9nM9GRNmAr68v+Hy+TZ0gLpeLrq4uHDx40K7w3cnJScaQ67a2NqtOL2+BJfvnClyxn8vlIi0tDQsWLIC/vz8UCgV6enpw4cIFVFVVoba2Fmq1QY+hsLAQ+fn5Lldkcpft3gDWfucglUrh5+eHuro6l9t64YUX8PHHH6OmpgYAMDExgaeffhovvPCCU8Kd586dQ0FBAQoKCgAAv/71r1FQUICnn37aZVtnGjKZDEKh0KZmBI/HQ3d3Nw4ePGjXypk1zvfmyRqJn/J9y+FwkJqaipycHPj7+2NiYsIi5y9ZsgRLlixxSjvSE7Z7A1j7nYNUKkVgYCDF066gufQHECOtIJQGXiP0Wuh6S7Hjg7fnXcq1o5BKpRCLxTbf07hcLnp7e3Hw4EG70uQtjZv29nakpaU5be9M4ad835Kcn5ubi8DAQExMTKC3t9eI88nnfkFBAYqKihyOmPOU7d4A1n7nIBaLERISgspK5rQ6R9BW/iOI0XYQkwZeI/Ra6HpK8eE/3/CqjCs2IsoOJCcno7y8HIGBgRb3IQgCjY2NWLFihV0TOUsrKRKJBFNTU05XcZgpeLMgpT1wh/0cDodaKaFDrVbjwoUL1OpITEyMW1Od2L6fXcym/evXr8exY8ewa9cuZGRkICsry6nKjikpKXjwwQfx29/+Fnv37sUrr7yC+Ph43HLLLU7ZtWbNGrurqs4FJCcno6yszGq6CrliWlRUZKhUYgPWOF+tVtvVxmyCvW8NsMT59fX10Ol04HA4iIqKcijVyRbYvp9dzKb969atw/Hjx7Fr1y5qAcwZzk9MTAQ3JAO6nrPgJ18B/UAtOHwJNm3a5AGrDQ72uYSkpCSUlZXZTFdpampCYWGhXRM5W+/53jQZZAJ73xpAaufQodFoqPd8giAQGRnpUKqTLbB9P7uYTfvXrFmDkydPUpyflZXllE8gLi4O3NAs6HrOgZd8BfSDdQBPiDvuuMMDVjvP+awjyg5wOBwEBgZibGzMYllFf39/CAQCxMbG2tWmpUmHj48PJiYm4OvrS20jCMLrbmpvnzTZgiftFwqFyM3NpUqBV1dXu9WxyPb97GK27V+5ciX0ej3q6+vx5ZdfOj2RePrpp5GcnIzPPvsMf/nLX/D99997Hc/MJoKDgzE6OmrRiezv7w8ul2u3MKOlcSOTyaBQKIyeLSznux+e5vycnByK82tqatwaZcL2/exitu1fsWKFWzh/4MIRBIdFQj/SDH1/JUoO/mdOCwq7G6GhoVQVNCaQi9FJSUl2tWeL8+nPFpbz3Q9P2i8QCMw4352ORbbvZxezbf+yZcuwdOlSNDY24ssvv8Ttt9/uVDvDDUcREBwOYqQF+v5K/GffXvB4PDdb6xrYJ5CdCAgIsCpQHRsb61AYn6WwP39/f/T09FDRBWNjY9i9e7fL1bLcDTbs0jbI0p+OVlS0BbbvZxfeYD+Xy0VmZqaRboWjCAkJwe9//3vccccdKC4uxooVK9xs5dxGQECA1appMTExDvGypXHj5+eHvr4+M863p7z4TMIbxr0rmEnOJyOj3AW272cX3mA/yflBQUFOF60ICgoCNzwPuvaj4MgisGbNGvcaOcfh7+9vlfOjoqKgVqvtjv61NG58fX0hl8updsbHx7Fnz55ZH2Om8IZx7wpYzp89sPa7Di6Xi/T0dISFhTldtMLf3x/ciHzoOo6CIw1FcXGxm610Hawjyk74+PhgaGjI4vccDodK4bNnciKRSBi95wKBAKmpqaiqqkJlZSWOHTuGvLy8Wb8hTGHJ/rmCmbJ/bGzM7VVR2L6fXXiT/cXFxTh69CilT+MofvnLX+KXv/wl/vKXv7jZsrkPiURiVSeK1JBwlfP5fD5SU1OpSj3Hjh1Dbm4ulEqlV6U7etO4dwYzZf/4+Ljbqx+yfT+78Cb7yfRsZzl/suUouKFZqDtzwM2WzX1IpVK7Od+ehQJL44bH4yEtLY3i/KNHj2LBggVQqVQs57sRM2X/xMSE28/D9v3swpvsX79+PU6dOuV0QIqy5Qi4odmoPvUfN1vmHrCOKDshEAhshrP5+/sjKysLFy5csNmeWq22+CLh6+uL3NxcLFiwAOHh4VAqlejr68PAwIBTtnsC1uyfC5gp+1taWuxO3bEXbN/PLrzJfi6Xi/Xr1+Pw4cNOHS+RSPDKK69Q1cFYTMMezvf19XUb5+fk5FCcT1ZPZTnffZhJzrc3dcdesH0/u/Am+7lcLoqLi1FSUuLU8SKRCDp59ZwokDDT4PF4VISLJfj6+iI7O9tlzpfJZBTnR0REYGpqCnK5HP39/U7Z7gl407h3BjNlf1NTE8v5JmDtdy9c4XyhUAidvMpqVdDZxLzUiLKWQucKFAqFXW2r1WoMDQ1ZfaCNjo4CgM3Vj9TUVACG9K6amhrI5XLExMTMei65vfZ7K2bCfrlcDrFYDIVC4dZ22b6fXXib/VKpFN3d3Thx4gSysrKMND88xYXehtnmfI1Gg8HBQatacI5yPkEQqK6uhlwuR2xsLMv5LmIm7B8YGIBAIGA53wSs/e6FWCxGf38/jh07hgULFrCc70bYy/k6nQ4DAwNWteDsHTfkQhBBEKipqcHAwADi4uJYzncRM2H/0NAQ+Hw+JiYm3Nou2/ezC2+zXygUYnBwEEeOHEFubu684vx55YgSCoWIiIiwWzCcBQsWLOY7IiIivL4Kp7NgOZ8FCxYsjMFyPgsWLFj8dDCXOZ9DeIu7z01QqVReFU7HggULFrMJoVA46xVAPAmW81mwYMFiGizns2DBgsVPB3OZ8+edI4oFCxYsWLBgwYIFCxYsWLBgwYKFd4IVK2fBggULFixYsGDBggULFixYsGAxI2AdUSxYsGDBggULFixYsGDBggULFixmBKwjigULFixYsGDBggULFixYsGDBgsWMgHVEsWDBggULFixYsGDBggULFixYsJgRsI4oFixYsGDBggULFixYsGDBggULFjMC1hFlB44cOYKNGzciKioKHA4HX331ldH3u3fvxoYNGxAcHAwOh4Py8nKzNlQqFbZs2YLg4GDIZDLcfPPN6O/vN9rnm2++QVpaGtLT07F3715qe2RkJF588UWjfX/3u9+Bw+Hg0KFDRtvXrFmDu+66yyH7CYLA008/jcjISEgkElx++eVobGw02ichIQEcDsfoz9Smd955B/Hx8SgoKMDp06cBAAqFAgKBAJ999pnRvrfddhs4HA7a2trMzvPUU0+53f7h4WHccccd8PPzQ0BAAB544AEoFIoZsd8U4+PjePzxxxEfHw+JRILly5fj7Nmz1Pf33nuvWV9feeWVRm2cPHkS+fn5SEhIwLvvvkttLyoqwiOPPGK07z/+8Q9wOBx88MEHRtvvvfderFq1yqqtzthvz+8xW/brdDo89dRTSExMhEQiQXJyMp599lnQi4d6e/+z8DxYzmc5n+V8++1nOZ/l/LkOlvNZzmc53377Wc5nOd9tIFjYxHfffUf8z//8D7F7924CALFnzx6j7z/66CPij3/8I/HOO+8QAIiysjKzNh555BEiNjaWOHjwIHHu3DmiqKiIWL58OfW9SqUiYmJiiAMHDhD/+c9/iJiYGGJqaoogCIK47bbbiCuuuMKovcLCQiI2NpZ45plnqG1KpZIQiUTEe++955D9L774IuHv70989dVXREVFBXHdddcRiYmJhFKppPaJj48n/u///o/o7e2l/hQKBfV9e3s7kZKSQpw4cYL4/PPPiczMTOq7oqIi4uGHHzY6Z3h4OBEbG0u8//771LaWlhYCAPHjjz+63f4rr7ySyMvLI06dOkUcPXqUSElJIW6//fYZsd8Ut956K5GVlUUcPnyYaGxsJJ555hnCz8+P6OrqIgiCIO655x7iyiuvNOrr4eFhozYyMzOJL774gjh+/DiRnJxMdHR0EARBEL/73e+I9PR0s/PFxsYS99xzj9H2+Ph44umnn7ZqqzP22/N7zJb9zz33HBEcHEzs3buXaG1tJT7//HNCJpMRr776KrWPt/c/C8+D5XyW81nOt99+lvNZzp/rYDmf5XyW8+23n+V8lvPdBdYR5SCYCJJEa2sr4wNqdHSUEAgExOeff05tq6urIwAQJ0+eJAiCIC5evEjEx8cTAwMDxMDAAJGQkECMjY0RBEEQb731FiGTyQiNRkMQBEGMjY0RAoGAeP3114nVq1dTbf74448EAKK1tdVu+/V6PREREUG89NJLRvaKRCLi008/pbbFx8cTf/vb3yy2W1VVRSxevJhQKBRES0sLkZCQQH33+9//3uimra2tJfz9/Ynnn3/e6KZ97733CJFIZERk7rC/traWAECcPXuW2mffvn0Eh8Mhuru7Z9T+yclJgsfjEXv37jXavnDhQuJ//ud/CIIwEOT1119vsQ2CIIi4uDiipaWFUCgUxOLFi4mamhqCIAhi//79BACit7eX2jc8PJzYvn07ER8fT20jH6YlJSVWz+Oo/faOp9my/5prriHuv/9+o2033XQTcccdd1Cfvbn/Wcw8WM5nBsv5LOeznM9y/nwEy/nMYDmf5XyW81nOdzfY1LwZwPnz56HRaHD55ZdT2zIyMhAXF4eTJ08CAPz8/HDfffchMjISUVFRePTRR+Hr6wsAWLt2LRQKBRUWefToUaSlpeHmm2/G6dOnoVKpAAAlJSVISEhAQkKC3ba1trair6/PyDZ/f38sXbqUso3Eiy++iODgYBQUFOCll16CVqulvluwYAFyc3Ph7++P7Oxs/OlPf6K+W7t2Lerr69Hb20vZuXLlSqxbt84o5LikpATLli2DWCx2q/0nT55EQEAAFi9eTO1z+eWXg8vlUqG5M2W/VquFTqcz20cikeDYsWPU50OHDiEsLAzp6el49NFHMTQ0ZLT/008/jczMTPj7+6OoqAhZWVkAgBUrVkAgEKCkpAQAUFtbC6VSiQceeABDQ0NobW2lbBWLxVi2bJmNHnbMfnvH02zZv3z5chw8eBANDQ0AgIqKChw7dgxXXXWV0X7e2v8s5gZYzmc5nwTL+bNrP8v5LGYCLOeznE+C5fzZtZ/l/LkF1hE1A+jr64NQKERAQIDR9vDwcPT19VGfn3nmGQwODmJoaAi/+c1vqO2pqamIjo6myPDQoUNYvXo1IiIijB5yhw4dwtq1ax22jbTFmm2/+MUv8Nlnn6GkpAQPP/wwnn/+eSMbAeDdd99Ff38/hoaGcMcdd1DbV6xYAaFQaGb/okWLMDg4SN20hw8f9oj9fX19CAsLM/qez+cjKCjI6Bpnwn5fX18sW7YMzz77LHp6eqDT6fDJJ5/g5MmT1APwyiuvxEcffYSDBw/iz3/+Mw4fPoyrrroKOp2OaockvIGBAWzbto3a7uPjg8LCQiNbV65cCZFIhOXLlxttX7ZsGUQikVV7HbXf3vE0W/b/7ne/w2233YaMjAwIBAIUFBTg8ccfN/q9vbn/WcwNsJzPcj4JlvNn136W81nMBFjOZzmfBMv5s2s/y/lzC6wjysvg7+9PrZDQsWbNGqPBvWbNGgDA6tWrcejQISiVSpw+fdphgrcXv/71r7FmzRrk5ubikUcewcsvv4xt27ZhamrKaL/g4GBIJBKjbVKpFEuWLKHsP3z4MNasWQM+n0/dtC0tLejo6PCY/fZiJuz/+OOPQRAEoqOjIRKJ8Nprr+H2228Hl2u4HW+77TZcd911yMnJwQ033IC9e/fi7Nmz1PlJ+Pj4IDAw0Kx9W2OF3O5sX9uy317Mhv27du3Cv/71L+zYsQOlpaX48MMP8de//hUffvghtY+39z+L+QWW81nO93bOYTl/9uxnMf/Acj7L+d7OOSznz579PzWwjqgZQEREBNRqNUZHR4229/f3IyIiwq421q5di+PHj2NoaAhlZWVYvXo1AMOgLykpwYkTJ6BWq7Fu3TqHbSNtccS2pUuXQqvVmlWTsGZ/SUkJampqoFQqsXDhQiP7S0pKIJVKsXTpUrfbHxERAblcbvS9VqvF8PCwQ/3vLvuTk5Nx+PBhKBQKdHZ24syZM9BoNEhKSmLcPykpCSEhIWhqarLb1oaGBnR3d+PQpVUd0tZDhw6hubkZnZ2dDo8Ve+x3djzNlP1PPvkktVqSk5ODu+66C7/61a/wwgsvWDzG2/qfhfeD5XyW8+lgOX/27Gc5n8VMgOV8lvPpYDl/9uxnOX9ugXVEzQAWLVoEgUCAgwcPUtvq6+vR0dFhd+7o2rVrMTExgVdeeQWpqalUCOpll12GM2fOYN++fVRoryNITExERESEkW1jY2M4ffq0VdvKy8vB5XLNQmGt2d/Y2IgdO3Zg5cqV4PF4lP2HDx/GoUOHqNBYd9u/bNkyjI6O4vz589Q+P/74I/R6vd0PRE/Y7+Pjg8jISIyMjGD//v24/vrrGffr6urC0NAQIiMj7Wp3+fLlEAqFeOONN6BSqbBo0SIAwJIlSzAwMID33nuPCi11BUz2OzueZsr+yclJsxUdHo8HvV5v8Rhv7X8W3guW81nOZwLL+TNvP8v5LGYCLOeznM8ElvNn3n6W8+cYZlMpfa5gfHycKCsrI8rKyggAxCuvvEKUlZUR7e3tBEEQxNDQEFFWVkZ8++23BADis88+I8rKyowU9R955BEiLi6O+PHHH4lz584Ry5YtI5YtW+aQHXFxcYSvry/xyCOPGG1PTEwkfH19iYceesgp+1988UUiICCA+Prrr4nKykri+uuvNyrDeeLECeJvf/sbUV5eTjQ3NxOffPIJERoaStx99912206WnPX19SVefPFFartKpSLEYjHh6+tLPP/88x6xnyAMZV0LCgqI06dPE8eOHSNSU1ONyrp60n5TfP/998S+ffuIlpYW4j//+Q+Rl5dHLF26lFCr1cT4+Djx3//938TJkyeJ1tZW4ocffiAWLlxIpKamEiqVym57L7vsMsLX15e48sorjbavXbuW8PX1JTZs2GB3W47YTxD2/R6zZf8999xDREdHU2Vdd+/eTYSEhBC/+c1vCIIg5kT/s/A8WM5nOZ/lfPvsJwiW8z1pP4uZAcv5LOeznG+f/QTBcr4n7f+pgXVE2YGSkhICgNkfWdLz/fffZ/z+mWeeodpQKpXEz3/+cyIwMJCQSv9/e3esmkgURgF4tojKIlqFpIpg5xNYKgjpU6YyKVJZ5AFEkkqfxTdJkwfwDSxDrGxytgiENWyhJHsl8H3lwAwHh/nvcBi8v3N1dbWzgO1jPB5/LIB/u7m5SVVVO9tmHpL/7e0ts9ksZ2dnqdfrGY1GWa1WH+c/Pz+n3++n3W6n0Wik1+tlPp8f9MAmyWAwSFVVeXp62jk+HA53trj97vzJ+0vE9fV1ms1mWq1Wbm9vs9lsiuT/bLlcptvtplar5fz8PJPJJC8vL0net029vLzM6elpTk5O0ul0cnd3l/V6fVDWh4eHVFW1s5gmyePjY6qqymKxOOh6++ZP9rsfx8r/+vqa+/v7XFxcpNFopNvtZjqdZrvdJvkZvz//n5lv5n8l/2dm/vHym/nsw8w387+S/zMz/3j5zfyf5VeS/PtbKQAAAAD4Pv4jCgAAAIAiFFEAAAAAFKGIAgAAAKAIRRQAAAAARSiiAAAAAChCEQUAAABAEYooAAAAAIpQRAEAAABQhCIKAAAAgCIUUQAAAAAUoYgCAAAAoAhFFAAAAABF/AESsXRVOp1hnwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1200x300 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_precip_frequency_differences(threshold, start_time, end_time):\n",
    "    \n",
    "    # Define datasets\n",
    "    wind_datasets = {\n",
    "        'Current': precip_current_ds,\n",
    "        'Future': precip_future_ds,\n",
    "        'Future-Urban': precip_future_urban_ds\n",
    "    }\n",
    "    ############ Freq colormap ###############\n",
    "    clevs2=[1,2,3,4,5,6]\n",
    "    #clevs2 = [3,5,7,10,15,20]\n",
    "    import colormaps \n",
    "    diff_cmap2 = colormaps.thermal\n",
    "    cmap2 = diff_cmap2[:200]\n",
    "    #cmap = mcolors.ListedColormap([diff_cmap1(i / (len(clevs) - 1)) for i in range(len(clevs) - 1)])\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap2(i / (len(clevs2) - 1)) for i in range(len(clevs2))]\n",
    "\n",
    "    cmap2.set_over(colors[-1])   # Upper bound color\n",
    "    cmap2.set_under('white')  # Lower bound color\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    norm2 = mcolors.BoundaryNorm(clevs2, cmap2.N)\n",
    "\n",
    "    ############### Diverging colormap ################\n",
    "    clevs = [-3.9,-2.9,-1.9,-0.9,0.9,1.9,2.9,3.9] # wind levels\n",
    "    tick_labels = [-4,-3,-2,-1,1,2,3,4] # wind levels\n",
    "    # Create a ListedColormap from the custom RGBA values\n",
    "    #cmap = create_custom_diverging_colormap(levels=len(clevs))\n",
    "\n",
    "    import colormaps\n",
    "    diff_cmap1 = colormaps.rdbu_11_r\n",
    "    cmap = diff_cmap1[1:10]\n",
    "    #cmap = mcolors.ListedColormap([diff_cmap1(i / (len(clevs) - 1)) for i in range(len(clevs) - 1)])\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap1(i / (len(clevs) - 1)) for i in range(len(clevs))]\n",
    "\n",
    "    cmap.set_over(colors[-1])   # Upper bound color\n",
    "    cmap.set_under(colors[0])  # Lower bound color\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    norm = mcolors.BoundaryNorm(clevs, cmap.N)\n",
    "    norm3 = mcolors.BoundaryNorm(clevs, cmap.N)\n",
    "\n",
    "    #####################################################\n",
    "    # Set up the figure and 1x3 subplots\n",
    "    fig, axs = plt.subplots(1, 3, figsize=(12, 3), subplot_kw={'projection': crs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on the list provided\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Wind Speed Frequency for Current Simulation #####\n",
    "    wind_speed_current = wind_datasets['Current']['RAINNC']\n",
    "    \n",
    "    # Calculate frequency of wind speeds above the threshold\n",
    "    freq_current = (wind_speed_current >= threshold).sum(dim='Time')\n",
    "    #freq_current = downscsale_wind(freq_current)\n",
    "    freq_current2 = freq_current.where(freq_current != 0, drop=False)\n",
    "\n",
    "    lats = freq_current['XLAT']\n",
    "    lons = freq_current['XLONG']\n",
    "    \n",
    "    ax_wind = axs[0]\n",
    "    #pb = ax_wind.pcolormesh(lons, lats, freq_current, cmap=cmap2,norm=norm2, transform=crs.PlateCarree(), zorder=1)\n",
    "    pb = ax_wind.contourf(lons, lats, freq_current2, levels=clevs2, cmap=cmap2,norm=norm2,transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    #ax_wind.contour(lons, lats, freq_current2, levels=clevs2, cmap=cmap2,norm=norm2,transform=crs.PlateCarree(), zorder=2, extend='both')\n",
    "    #pb = ax_wind.scatter(lons, lats, c=freq_current2, s=5, cmap=cmap2,norm=norm2, transform=crs.PlateCarree())\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_wind.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.35)\n",
    "    ax_wind.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.35)\n",
    "    gl = ax_wind.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    ax_wind.set_title(fr'Frequency of PR ≥{threshold} mm hr$^{{-1}}$', loc='left', fontsize=10)\n",
    "    ax_wind.set_title(f'(Current)', loc='right', fontsize=10)\n",
    "    \n",
    "    # Colorbar for the left plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_wind, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.9, extend='both')\n",
    "    #cbar.set_label('Count', fontsize=8)\n",
    "    #cbar.set_ticklabels(tick_labels2)\n",
    "\n",
    "    ##### Middle Plot: Future - Current Wind Frequency Difference #####\n",
    "    wind_speed_future = wind_datasets['Future']['RAINNC']\n",
    "    freq_future = (wind_speed_future >= threshold).sum(dim='Time')\n",
    "    #freq_future = downscsale_wind(freq_future)\n",
    "    freq_diff_future_current = freq_future - freq_current\n",
    "    # **Filter out points where values == 0**\n",
    "    freq_diff_future_current2 = freq_diff_future_current.where(freq_diff_future_current != 0 , drop=False)\n",
    "\n",
    "    # Define sizes (start from a base size and triple each time)\n",
    "    #sizes = 4 * (2 ** (np.abs(freq_diff_future_current.values)))\n",
    "    \n",
    "    ax_wind = axs[1]\n",
    "    #pb = ax_wind.pcolormesh(lons, lats, freq_diff_future_current, cmap=cmap,norm=norm,transform=crs.PlateCarree(), zorder=1)\n",
    "    pb = ax_wind.contourf(lons, lats, freq_diff_future_current2, levels=clevs, cmap=cmap,norm=norm,transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    #ax_wind.contour(lons, lats, freq_diff_future_current2, levels=clevs, cmap=cmap,norm=norm,transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    #pb = ax_wind.scatter(lons, lats, c=freq_diff_future_current2, s=5, cmap=cmap,norm=norm, transform=crs.PlateCarree(),zorder=2)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_wind.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.35)\n",
    "    ax_wind.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.35)\n",
    "    gl = ax_wind.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax_wind.set_title(r'$\\Delta$ Frequency', loc='left', fontsize=10)\n",
    "    ax_wind.set_title(f'(ACC Effect)', loc='right', fontsize=10)\n",
    "    \n",
    "    # Colorbar for the middle plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_wind, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.9, extend='both')\n",
    "    #cbar.set_label('Count Difference', fontsize=8)\n",
    "    cbar.set_ticklabels(tick_labels)\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future Wind Frequency Difference #####\n",
    "    wind_speed_future_urban = wind_datasets['Future-Urban']['RAINNC']\n",
    "    freq_future_urban = (wind_speed_future_urban >= threshold).sum(dim='Time')\n",
    "    #freq_future_urban = downscsale_wind(freq_future_urban)\n",
    "    freq_diff_future_urban_current = freq_future_urban - freq_current\n",
    "    freq_diff_future_urban_future = freq_diff_future_urban_current - freq_diff_future_current\n",
    "    freq_diff_future_urban_future2 = freq_diff_future_urban_future.where(freq_diff_future_urban_future != 0, drop=False)\n",
    "    #print(freq_diff_future_urban_future.min())\n",
    "    \n",
    "    ax_wind = axs[2]\n",
    "    #pb = ax_wind.pcolormesh(lons, lats, freq_diff_future_urban_future2, cmap=cmap,norm=norm, transform=crs.PlateCarree(), zorder=1)\n",
    "    pb = ax_wind.contourf(lons, lats, freq_diff_future_urban_future2, levels=clevs, cmap=cmap,norm=norm3,transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    #ax_wind.contour(lons, lats, freq_diff_future_urban_future2, levels=clevs, cmap=cmap,norm=norm3,transform=crs.PlateCarree(), zorder=2, extend='both')\n",
    "    #pb = ax_wind.scatter(lons, lats, c=freq_diff_future_urban_future2, s=5, cmap=cmap,norm=norm, transform=crs.PlateCarree(),zorder=2)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_wind.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.35)\n",
    "    ax_wind.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.35)\n",
    "    gl = ax_wind.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax_wind.set_title(r'$\\Delta$ Frequency', loc='left', fontsize=10)\n",
    "    ax_wind.set_title(f'(Urbanization Effect)', loc='right', fontsize=10)\n",
    "    \n",
    "    # Colorbar for the right plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_wind, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.9, extend='both')\n",
    "    #cbar.set_label('Count Difference', fontsize=8)\n",
    "    cbar.set_ticklabels(tick_labels)\n",
    "\n",
    "    # Set a main title for the figure\n",
    "    if select_time_window == True:\n",
    "        start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        fig.suptitle(f'Wind Speed Frequency (> {threshold} m/s) and Differences from {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}\\n', fontsize=16)\n",
    "    else:\n",
    "        fig.suptitle(fr'Frequency of PR ≥{threshold} mm hr$^{{-1}}$ and Differences Between Simulations in {month}', fontsize=12)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "plot_precip_frequency_differences(threshold=50, start_time=start_time, end_time=end_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKIAAAE3CAYAAACZ9+ndAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd4VFX6x7/TZ5JJJm0mvQcIEHoPXRRERNEFBRvFsioguiugP1fBgiC7rq7iKroKKsWOHQSUIj2A9B7Se59Mps+c3x/Ze3cmM5PcqZnA+TxPnidz77nnnPeW77n3Pee8h0cIIaBQKBQKhUKhUCgUCoVCoVD8DL+zK0ChUCgUCoVCoVAoFAqFQrk+oI4oCoVCoVAoFAqFQqFQKBRKQKCOKAqFQqFQKBQKhUKhUCgUSkCgjigKhUKhUCgUCoVCoVAoFEpAoI4oCoVCoVAoFAqFQqFQKBRKQKCOKAqFQqFQKBQKhUKhUCgUSkCgjigKhUKhUCgUCoVCoVAoFEpAoI4oCoVCoVAoFAqFQqFQKBRKQKCOKAqFQqFQKBQKhUKhUCgUSkCgjigKhUKhUCgUCoVCoVAoFEpAoI4oCoVCoVAoQcO7776LgQMHQiQSYfny5Z1dHQqFQqFQKBSKj6GOKAqFQqFQKEFDfHw8li9fjj/96U+dXRUKhUKhUCgUih+gjigKhdIh69evB4/HQ2Fhoc/yXL58OXg8ns/yC0auBxu7OqtXr0Z2djasVmtnV4XyX6ZNm4bbbrsNERERTve/9957SElJgcFgCGzFOsCfz7srDc7Ly0Nubi5CQ0PB4/Fw4sQJp9solM7EH+8QnV12Z9rUEcFcNwqFQmGgjigK5Rrniy++AI/Hw5YtWxz29evXDzweD7t27XLYl5KSgtzc3EBUsUNOnz6N6dOnIzU1FVKpFImJibjpppvw9ttvd3bVfALz0ujs75lnnuns6l2zqNVqvPbaa1i6dCn4fO+aQ41Gg2XLluHmm29GVFQUeDwe1q9f7zTtnDlzXF5vHo+HsrIyt8pesWIFeDwecnJyvLKhqzBnzhwYjUasXbu2s6viEW2fd6lUioSEBEyaNAlvvfUWmpubOeVjMpkwY8YM1NfX44033sCnn36KxMREh22pqal+tqhr40x/VSoVxo8fj61bt3qc74EDB7B8+XI0Njb6rrJBxrXeNl8P15ALts/Ivn37HPYTQpCcnAwej4dbb721E2pIoVC6IsLOrgCFQvEvo0aNAgDs27cPd9xxB7tdrVbjzJkzEAqF2L9/P8aPH8/uKykpQUlJCWbOnAkAuP/++zFz5kxIJJLAVh6tL4Ljx49HSkoKHn74YcTFxaGkpASHDh3Cv/71LyxcuDDgdfIXL730EtLT0+22XS/Ohc7go48+gtlsxqxZs7zOq7a2Fi+99BJSUlLQr18/7N6922XaP//5z7jxxhvtthFC8OijjyItLQ2JiYmcyy0tLcWrr76K0NBQT6ve5ZBKpZg9ezb++c9/YuHChV121CHzvJtMJlRWVmL37t148skn8c9//hPff/89+vbty6Z1psH5+fkoKirCBx98gIceeggAcOHCBYdtFG4w14MQgqqqKqxfvx633HILfvjhB48+rg8cOIAXX3wRc+bMcTm6ryvjTtvcme8Q3tDeNQxmm/xVN6lUik2bNrHvlQx79uxBaWlpUJ4LCoUSvFBHFIVyjZOQkID09HSHXqyDBw+CEIIZM2Y47GN+My8bAoEAAoEgMBVuw4oVK6BQKJCXl+fwIlhdXd0pdfIXkydPxuDBg906pqWl5bpyQviSdevW4bbbboNUKvU6r/j4eFRUVCAuLg5Hjx7FkCFDXKYdMWIERowYYbdt37590Gq1uPfee90q9+mnn8bw4cNhsVhQW1vrUd0DxahRo7B//36n+5577jm88sornPO66667sHr1auzatQs33HCDr6oYUNo+788++yx+++033Hrrrbjttttw/vx5yGQyAM41mNE/W110ts1brheNaXs9HnzwQcTGxmLz5s10lIcT3GmbO/Mdwl8Es03+qtstt9yCL7/8Em+99RaEwv99Qm7atAmDBg0K+jaIQqEEF3RqHoVyHTBq1Cj88ccf0Ol07Lb9+/ejd+/emDx5Mg4dOmQXI2f//v3g8XgYOXIkAOfxBph4KFeuXGF7CxUKBebOnQutVmtX/r59+zBkyBBIpVJkZma6NaUmPz8fvXv3dvphpVKpHOpz4cIF3HXXXQgPD0d0dDQWLVoEvV7vcGxZWRnmzZuH2NhYSCQS9O7dGx999JHH6byxkSuMjefOncM999yDyMhIu55Jb+rqLL7NnDlzkJaW5rIetnAp2517hsnzwQcfREJCAiQSCdLT0/HYY4/BaDRi165dLqecbtq0CTweDwcPHnR5LgsKCnDq1CmHkUkAcOTIEcyYMQPr169HVVWVyzxskUgkiIuL45TWGUyd77nnHs7H7N27F1999RXefPNNt8pirsOlS5dw3333QaFQQKlU4vnnnwchBCUlJbj99tsRHh6OuLg4vP766x3m2dzcjCeffBJpaWmQSCRQqVS46aabcPz4cTbNvn37QAhx+ueOEwoABg0ahKioKHz33Xcdpi0qKsLjjz+OHj16QCaTITo6GjNmzHCInxIoTWuPG264Ac8//zyKioqwYcMGdntbDZ4zZw7Gjh0LAJgxYwZ4PB7S0tIcto0bN47Nw51n1FuNcedctvecu1Mul3vQHSIiIiCTyew+uLnWZ/ny5Vi8eDEAID09nZ3WVFhYiFOnToHH4+H7779n0x87dgw8Hg8DBw60K2fy5MkYNmyYW+fBnXTuarItXNtmoP13CE91yJ32qS1cNKG9a+jKpj/++AOTJ09GeHg45HI5JkyYgEOHDjmtH5dz7uk97e07mytmzZqFuro67Nixg91mNBrx1VdfuWy7uJxrb9tzCoXSNaEjoiiU64BRo0bh008/xeHDh9kPk/379yM3Nxe5ubloamrCmTNn2Kkg+/fvR3Z2NqKjozvM+6677kJ6ejpWrlyJ48eP4z//+Q9UKhVee+01AK0xJCZOnAilUonly5fDbDZj2bJliI2N5VT31NRUHDx4EGfOnOE0Te2uu+5CWloaVq5ciUOHDuGtt95CQ0MDPvnkEzZNVVUVhg8fDh6PhwULFkCpVGLr1q148MEHoVar8eSTT7qVzlsbGZqamhx6FGNiYhzSzZgxA926dcOrr74KQkin1NUWrmUzdHTPAEB5eTmGDh2KxsZGPPLII8jOzkZZWRm++uoraLVajBs3DsnJydi4caPdlFMA2LhxIzIzMx1GHdly4MABAHD48ANaP0CLi4sxb948AMDgwYMxZcoUTJkyBYMGDfL5VDCTyYQvvvgCubm5Tj+snGGxWLBw4UI89NBD6NOnj0fl3n333ejZsydWrVqFn376Ca+88gqioqKwdu1a3HDDDXjttdewceNGPP300xgyZAjGjBnjMq9HH30UX331FRYsWIBevXqhrq4O+/btw/nz552e4/Ywm80wm82wWCwwm83Q6/UQiUQOPfwDBw50OcLKlry8PBw4cAAzZ85EUlISCgsL8e6772LcuHE4d+4cQkJC7NL7W9M64v7778f//d//Yfv27Xj44Yedpvnzn/+MxMREvPrqq3jiiScwZMgQFBQUQK/X221j6uTuM+qNxrhzLjt6zsViMedyvb0HGf0lhKC6uhpvv/02NBoN7rvvPrt0XOpz55134tKlS9i8eTPeeOMNVseVSiVSUlIQERGBvXv34rbbbgMA/P777+Dz+Th58iTUajXCw8NhtVpx4MABPPLII26df39cJ2e42za7wpc6xBUumtDeNXTG2bNnMXr0aISHh2PJkiUQiURYu3Ytxo0bhz179tg5FAFu59yXuupOua5IS0vDiBEjsHnzZkyePBkAsHXrVjQ1NWHmzJl46623HI7hcq69bc8pFEoXhVAolGues2fPEgDk5ZdfJoQQYjKZSGhoKPn4448JIYTExsaSd955hxBCiFqtJgKBgDz88MPs8evWrSMASEFBAbtt2bJlBACZN2+eXVl33HEHiY6OZn9PmzaNSKVSUlRUxG47d+4cEQgEhIsEbd++nQgEAiIQCMiIESPIkiVLyC+//EKMRqNdOqY+t912m932xx9/nAAgJ0+eZLc9+OCDJD4+ntTW1tqlnTlzJlEoFESr1bqVzlsbmfPr7M+ZjbNmzXLIwx91nT17NklNTXUoi6mHu2VzvWcIIeSBBx4gfD6f5OXlOZRvtVoJIYQ8++yzRCKRkMbGRnZfdXU1EQqFZNmyZQ7H2fK3v/2NACDNzc0u01RVVZF169aR6dOnk/DwcAKAxMbGkrlz55KvvvqKNDU1OT0uLy+PACDr1q1rtw4MP/zwAwFA/v3vf3NKTwgha9asIQqFglRXVxNCCBk7dizp3bs3p2OZ6/DII4+w28xmM0lKSiI8Ho+sWrWK3d7Q0EBkMhmZPXt2u3kqFAoyf/58zvXnUj/bP2fn8pFHHiEymazD/Jj7z5aDBw8SAOSTTz5xKNffmsY8787ubQaFQkEGDBjgcIytBu/atYsAIF9++WW72whx/xn1RmNs8+noXHJ5zrmW6+k96Ep/JRIJWb9+vUN6rvX5+9//7nDNGKZMmUKGDh3K/r7zzjvJnXfeSQQCAdm6dSshhJDjx48TAOS7775zq1x/XCdncG2bCWn/HcJTHeLaPjkrm6smtHcN2+Y7bdo0IhaLSX5+PpumvLychIWFkTFjxjjUj8s59/ae9uSdrb388vLyyJo1a0hYWBh7DmfMmEHGjx9PCCEkNTWVTJkyxe5Yrufam/acQqF0TejUPArlOqBnz56Ijo5mYz+dPHkSLS0t7Kp4ubm57MiCgwcPwmKxOASjdMWjjz5q93v06NGoq6uDWq2GxWLBL7/8gmnTpiElJcWuPpMmTeKU/0033YSDBw/itttuw8mTJ7F69WpMmjQJiYmJdlMbGObPn2/3mwmY+vPPPwNoDQr99ddfY+rUqSCEoLa2lv2bNGkSmpqacPz4cc7pfGEjwzvvvIMdO3bY/Tmj7TnvjLq6W3Z79be9ZwDAarXi22+/xdSpU53GzGJGJD3wwAMwGAz46quv2H2ff/45zGazwyiGttTV1UEoFEIul7tMo1KpMGfOHHz55Zeora3Fr7/+invvvRc//fQTpk+fjpiYGFy9erX9E8SBTZs2QSQS4a677uKUvq6uDi+88AKef/55l73zXLANZi0QCDB48GAQQvDggw+y2yMiItCjR48O7YyIiMDhw4dRXl7ucX0Yli9f7jB1b86cOQ7pIiMjodPpOpxWwsRZAlpHn9XV1SErKwsRERFOp7j4W9O4IJfLOa+e1xG+eEY9ycNZPrbnkstz7k653t6Dtvq7YcMGjB8/Hg899BC++eYbr89DW0aPHo3jx4+jpaUFQOtUz1tuuQX9+/fH77//DqB1lBSPx8OoUaN83m61pSNNdoa7bbMrfKlDXHFXEzrCYrFg+/btmDZtGjIyMtjt8fHxuOeee7Bv3z6Hc8nlnPtSV90ptz3uuusu6HQ6/Pjjj2hubsaPP/7Y7pRyrufam/acQqF0TejUPArlOoDH4yE3Nxd79+6F1WrF/v37oVKpkJWVBaDVEbVmzRoAYB1SXB1Rth9jQOvHIQA0NDRAq9VCp9OhW7duDsf16NGDdQ51xJAhQ/DNN9/AaDTi5MmT2LJlC9544w1Mnz4dJ06cQK9evdi0bcvKzMwEn89n4xHU1NSgsbER77//Pt5//32n5VVXV7uVzhc2AsDQoUM5BStvu7JeZ9TV3bJtae+eCQ8PR01NDdRqdYfTPbKzszFkyBBs3LiR/WjZuHEjhg8fzt7bvsBsNuPAgQPYtm0btm3bhurqaggEAgwfPtzrIM4ajQbfffcdJk2axGkqLAD87W9/Q1RUlNcrRra9DgqFAlKp1GE6qEKhQF1dXbt5rV69GrNnz0ZycjIGDRqEW265BQ888IDdR5mvIf+dMtbRVEmdToeVK1di3bp1KCsrY48DWqdjtSUQmtYRGo3GIc6Op3jyjHqqMW1p71zqdLoOn3N3yvX2Hmyrv7NmzcKAAQOwYMEC3HrrrRCLxR6fh7aMHj0aZrMZBw8eRHJyMqqrqzF69GicPXvWzhHVq1cvREVFobq62qftVls60mRXuNM2u8KXOsQVdzWhI2pqaqDVatGjRw+HfT179oTVakVJSQl69+7Nbudyzv2hq55eawalUokbb7wRmzZtglarhcViwfTp012m53quA9WeUyiU4IE6oiiU64RRo0bhhx9+wOnTp9n4UAy5ublYvHgxysrKsG/fPiQkJHB+0XG1Movty4avEIvFGDJkCIYMGYLu3btj7ty5+PLLL7Fs2TKXx7T9SGWCst93332YPXu202P69u3rdrpAYtvDCLhvE1dcfeBbLBa3y7bFl/fMAw88gEWLFqG0tBQGgwGHDh1inartER0dDbPZjObmZoSFhTnsr6mpwdatW/HTTz/hl19+QVNTE2JiYnDzzTfj+eefx6RJk9gXeG/49ttv3Vot7/Lly3j//ffx5ptv2vWS6/V6mEwmFBYWIjw8HFFRUR3m5ew6eHpt7rrrLowePRpbtmzB9u3b8fe//x2vvfYavvnmGzaWiK9paGhASEiIw/PQloULF2LdunV48sknMWLECCgUCvB4PMycOdPpMxFITXNGaWkpmpqafPbx5ckz6qnGtMXbc+lOub6+B/l8PsaPH49//etfuHz5Mnr37u3xeWjL4MGDIZVKsXfvXqSkpEClUqF79+4YPXo0/v3vf8NgMOD3339n4+X4ut1qi7fXyZO2ub2yudSHS/vkCnc1wR9wsdEfuuoLfbvnnnvw8MMPo7KyEpMnT253lU53zrWn7TmFQumaUEcUhXKdwIxw2rdvH/bv328XsHTQoEGQSCTYvXs3Dh8+jFtuucUnZSqVSshkMly+fNlh38WLF73Km+m5rqiosNt++fJlu978K1euwGq1skGglUolwsLCYLFYnK6YxmCxWDin85eNXHHHJnfqGhkZicbGRoftRUVFbpftDkqlEuHh4Thz5kyHaWfOnIm//OUv2Lx5M3Q6HUQiEe6+++4Oj8vOzgbQunpe2w+zgwcPYtSoUbBarejbty/mz5+PKVOmYPjw4eDzfTujfePGjZDL5WzQ4o4oKyuD1WrFE088gSeeeMJhf3p6OhYtWuT2Snq+ID4+Ho8//jgef/xxVFdXY+DAgVixYoXfHFEFBQXo2bNnh+m++uorzJ49227VLb1e7/Te7gh/ahrDp59+CgA+m+rni2e0s55zd8v19T1oNpsBtI5Qc7c+7Y3UE4vFGDp0KH7//XekpKRg9OjRAFpHShkMBmzcuBFVVVVsYG5ft1v+xFXb7Gu4tE+u4KoJXBemUCqVCAkJcaoBFy5cAJ/PR3JyMqe82hJoXeXCHXfcgT//+c84dOgQPv/883bTuqO/nrbnFAqla0JjRFEo1wlMD+zGjRtRVlZmNyJKIpFg4MCBeOedd9DS0sJ5Wl5HCAQCTJo0Cd9++y2Ki4vZ7efPn8cvv/zCKY9du3Y57aljpsC0HQr/zjvv2P1+++23AYB9aRMIBPjTn/6Er7/+2ukHUE1NjdvpvLXRW/xV18zMTDQ1NeHUqVPstoqKCrsllrmW7Q58Ph/Tpk3DDz/8gKNHjzrst70fYmJiMHnyZGzYsAEbN27EzTff7HSlwbYwK/A4yz8mJgbvvPMOSkpKcPLkSaxYsQK5ubk+d0LV1NRg586duOOOOxxWbmPQarW4cOECu5piTk4OtmzZ4vDXu3dvpKSkYMuWLXaxVQKBxWJxmM6iUqmQkJAAg8Hgt3KPHz9up2OuEAgEDhry9ttvcxo54Swvfz7vv/32G15++WWkp6dzHiXXEb54RjvrOedarj/uQZPJhO3bt0MsFrMOT3fOAzNt15XDc/To0Th8+DB27drFOqJiYmLQs2dPdgUzZruv2y1f4G7b7Gu4tE+u4KoJHV1D2/wmTpyI7777jg0DALSuYLhp0yaMGjWK07Q3WzpLV7kgl8vx7rvvYvny5Zg6dWq7ad3RX0/bcwqF0jWhI6IolOsEZuj877//DolEgkGDBtntz83NZXusfOWIAoAXX3wR27Ztw+jRo/H444/DbDbj7bffRu/eve1eIF2xcOFCaLVa3HHHHcjOzobRaMSBAwfw+eefIy0tDXPnzrVLX1BQgNtuuw0333wzDh48iA0bNuCee+5Bv3792DSrVq3Crl27MGzYMDz88MPo1asX6uvrcfz4cezcuRP19fVupfPWRl/gj7rOnDkTS5cuxR133IEnnngCWq0W7777Lrp3724XZJRr2e7w6quvYvv27Rg7diweeeQR9OzZExUVFfjyyy+xb98+u6kADzzwABuj4uWXX+aUf0ZGBnJycrBz507MmzfPbh/z8fHjjz92mM/MmTPZuqxZswaNjY3slLkffvgBpaWlAFrvY4VCYXcsE4i1PYfDkSNHMH78eCxbtgzLly9HTEwMpk2b5pCOGQHlbJ+/aW5uRlJSEqZPn45+/fpBLpdj586dyMvLs+sF9yXHjh1DfX09br/99g7T3nrrrfj000+hUCjQq1cvHDx4EDt37uQck6stvnret27digsXLsBsNqOqqgq//fYbduzYgdTUVHz//feQSqUe1c8ZvnhGO+s551KuL+5B5noArXGUNm3ahMuXL+OZZ56xcyJwPQ9MG/vcc89h5syZEIlEmDp1Kqsvo0ePxooVK1BSUsI6nABgzJgxWLt2LdLS0pCUlOR2uf64Ts5wt232NVzbJ2dw1YSOrqEtr7zyCnbs2IFRo0bh8ccfh1AoxNq1a2EwGLB69Wq37esMXXUHV1M/2+Ku/nrSnlMolC6KP5bio1Aowcmzzz5LAJDc3FyHfd988w0BQMLCwojZbLbb195SwDU1NR2m3bNnDxk0aBARi8UkIyODvPfeew5LLLti69atZN68eSQ7O5vI5XIiFotJVlYWWbhwIamqqnKoz7lz58j06dNJWFgYiYyMJAsWLCA6nc4h36qqKjJ//nySnJxMRCIRiYuLIxMmTCDvv/++R+m8sZHLcu62NrY95/6s6/bt20lOTg4Ri8WkR48eZMOGDU7TcinbnXuGEEKKiorIAw88QJRKJZFIJCQjI4PMnz+fGAwGu3QGg4FERkYShULh9Fq74p///CeRy+UOy0vv2rXL6XLuzv7Onz/PHpeamuoynbPlv4cPH05UKpXD8+asLh0tXz127FjSu3dvTna7ug6zZ88moaGhbudtMBjI4sWLSb9+/UhYWBgJDQ0l/fr1I//+97851ccTli5dSlJSUojVau0wbUNDA5k7dy6JiYkhcrmcTJo0iVy4cIGkpqbaLQcfKE1j8mP+xGIxiYuLIzfddBP517/+RdRqtctjbOvA3Btffvllu9sYvHlG3cmjvXyc2cHlOe+oXG/uwbbXAwCRSqWkf//+5N1333V6j3E9Dy+//DJJTEwkfD7fwW61Wk0EAoFDm7thwwYCgNx///0el+uP69QWrm2zq/x8oUNc2idnZXPVBEJcX0Nn+R4/fpxMmjSJyOVyEhISQsaPH08OHDhglx/Xc+6Le9rTdzZX+XX0jpKamkqmTJlit82dc83Y7Ul7TqFQuh48QgIUfZNCoVD8yPLly/Hiiy+ipqaGDuX2AOb8dcUmwWw2IyEhAVOnTsWHH37I+bimpiZkZGRg9erVAZ/ORvEcg8GAtLQ0PPPMM1i0aFFnV4dCoVAoPsLT9pxCoXQ9aIwoCoVCoXRpvv32W9TU1OCBBx5w6ziFQoElS5bg73//e6esfkjxjHXr1kEkEuHRRx/t7KpQKBQKxYd42p5TKJSuB3VEUSgUCqVLcvjwYXzwwQf4y1/+ggEDBmDs2LFu57F06VJ2VSNK1+DRRx9FcXExJBJJZ1eFQqFQKD7AF+05hULpWtA3bwqFQqF0Sd5991089thjUKlU+OSTTzq7OhQKhUKhUDyAtucUyvUHjRFFoVAoFAqFQqFQKBQKhUIJCHREFIVCoVAoFAqFQqFQKBQKJSBQRxSFQqFQKBQKhUKhUCgUCiUgUEcUhUKhUCgUCoVCoVAoFAolIFBHFIVCoVAoFAqFQqFQKBQKJSBQRxSFQqFQKBQKhUKhUCgUCiUgUEcUhUKhUCgUCoVCoVAoFAolIFBHFIVCoVAoFAqFQqFQKBQKJSBQRxSFQqFQKBQKhUKhUCgUCiUgUEcUhUKhUCgUCoVCoVAoFAolIFBHFIVCoVAoFAqFQqFQKBQKJSBQRxSFQqFQKBQKhUKhUCgUCiUgUEcUhUKhUCgUCoVCoVAoFAolIFBHFIVCoVAoFAqFQqFQKBQKJSBQRxSFQqFQKBQKhUKhUCgUCiUgUEcUhUKhUCgUCoVCoVAoFAolIFBHFIVCcYs77rgDkZGRmD59emdXhUKhUCgUCoVCoVAoXQzqiKJQKG6xaNEifPLJJ51dDQqFQqFQKBQKhUKhdEGoI4rCGUIIHnnkEURFRYHH4+HEiRM+y3vcuHF48skngyYfimvGjRuHsLCwzq4GhUKhUCgUCoVCoVC6INesI2rOnDng8XgOf1euXOnsqnVZtm3bhvXr1+PHH39ERUUFcnJyHNK89957CAsLg9lsZrdpNBqIRCKMGzfOLu3u3bvB4/GQn5+Pb775Bi+//LK/TXCbvXv3YurUqUhISACPx8O3337rkCYtLc3pvTZ//nxOZaxatQo8Ho860CgUCoVCoVAoFAqFcs1zzTqiAODmm29GRUWF3V96erpDOqPR2Am163rk5+cjPj4eubm5iIuLg1AodEgzfvx4aDQaHD16lN32+++/Iy4uDocPH4Zer2e379q1CykpKcjMzERUVFRARtlotVq30re0tKBfv3545513XKbJy8uzu8d27NgBAJgxY0aH+efl5WHt2rXo27evW/XyF/3790dOTo7DX3l5eWdXzSfU1dVBpVKhsLCws6vic4xGI9LS0uyeveuRgwcPgsfjYcqUKR2mpR0WFErw0JX1+dtvv0VWVhYEAgHbqeRsmz+YOXMmXn/9db/lH+xQzadcK/haA9evX4+IiAif5NUehYWFPp8p44xgmvXy/vvvIzk5GXw+H2+++abLbf5g+PDh+Prrr/2Wf0Ah1yizZ88mt99+u9N9Y8eOJfPnzyeLFi0i0dHRZNy4cYQQQiwWC3n11VdJWloakUqlpG/fvuTLL7+0O1aj0ZD777+fhIaGkri4OPKPf/yDjB07lixatIhNk5qaSt544w274/r160eWLVvGuZyxY8eShQsXksWLF5PIyEgSGxvLHs9gsVjIa6+9RjIzM4lYLCbJycnklVdeIR9//DGJiooier3eLv3tt99O7rvvPpfnTK/Xk4ULFxKlUkkkEgkZOXIkOXLkCHs+AbB/qampLvOJj48nK1euZH8vWbKEzJ8/n/Ts2ZPs2rWL3T5mzBgye/Zs1l7bc8jFfi7Xoi1Lly4lWVlZ5IknniDbtm1zOEftAYBs2bKlw3SLFi0imZmZxGq1tpuuubmZdOvWjezYsaPDehPSek4WLFhAFi1aRCIiIohKpSLvv/8+0Wg0ZM6cOUQul5PMzEzy888/t5vPl19+SXJycohUKiVRUVFkwoQJRKPRdGiXLbt27SJ/+tOf3DomGHjqqafIQw89ZLftq6++ImPHjiXh4eEkNDSU9OnTh7z44oukrq6uk2rZMcuWLSP9+vVz2P7222+TG264IfAVCiIefPBBMmvWLCKRSEhZWVm7aWfPnk1uvvlmUlFRYfdnNpudpjcYDP6oMoVCIc71mWHixImEz+ez7yRtOX78OJk+fTpRqVREIpGQrKws8tBDD5GLFy/apfNE723ffWz/Nm/ezKZRqVRk6dKlpKysjKjVapfbvGHXrl0EAGloaLDbfvr0aRIZGUkaGxu9LqMrQjWfcq3QVgNdPfOEOP/WbMu6deuIQqHwbSWdYDabSUVFBTGZTD7Jz5XddXV1PtHS9igoKHCp+QcPHiSEENLU1EREIhF5++23SXl5OWlpaXG6zVtcXb8ffviBZGVlEYvF4nUZnc01PSKqPT7++GOIxWLs378f7733HgBg5cqV+OSTT/Dee+/h7NmzeOqpp3Dfffdhz5497HGLFy/Gnj178N1332H79u3YvXs3jh8/7lbZXMph6hgaGorDhw9j9erVeOmll9jRNgDw7LPPYtWqVXj++edx7tw5bNq0CbGxsZgxYwYsFgu+//57Nm11dTV++uknzJs3z2W9lixZgq+//hoff/wxjh8/jqysLEyaNAn19fX417/+hZdeeglJSUmoqKhAXl6ey3zGjx+PXbt2sb937dqFcePGYezYsex2nU6Hw4cPY/z48S7z6ch+T67F0qVL8dJLL6Gurg733nsvoqKicNttt+G9995DcXFxu8dywWg0YsOGDZg3bx54PF67aefPn48pU6bgxhtv5Jz/xx9/jJiYGBw5cgQLFy7EY489hhkzZiA3NxfHjx/HxIkTcf/997sc+VVRUYFZs2Zh3rx5OH/+PHbv3o0777wThBC37OyKaLVafPjhh3jwwQfZbc899xzuvvtuDBkyBFu3bsWZM2fw+uuv4+TJk/j00089LsvZKEtCiN2UVX9w7733Yt++fTh79qxfywlWNBoNPv/8czz55JMYP3481q9f3+ExEokEcXFxdn8CgQBAa+/bggUL8OSTTyImJgaTJk0CAFitVqxcuRLp6emQyWTo168fvvrqK7t8W1pa8MADD0AulyM+Ph6vv/66XW9eWlqaQ49Z//79sXz5cvY3l3LGjRuHJ554AkuWLEFUVBTi4uLs8mDyWb16NbKysiCRSJCSkoIVK1bgk08+QXR0NAwGg136adOm4f777+/w3FEovsKZPjMUFxfjwIEDWLBgAT766COH/T/++COGDx8Og8GAjRs34vz589iwYQMUCgWef/55Np03er9u3TqHEfbTpk0D0Ko71dXVmDRpEhISEhAWFuZ0m7/IyclBZmYmNmzY4LcyghWq+VTzrxXa00BPMJlMPsmHCwKBwOVMGV8SqNkzALBz504HzR80aBCA1jbJZDJhypQpiI+PR0hIiNNt/mLy5Mlobm7G1q1b/VZGwOhsT5i/mD17NhEIBCQ0NJT9mz59OiGkdWTJgAED7NLr9XoSEhJCDhw4YLed6WkhpHUEi1gsJl988QW7v66ujshkMs4joriUw9Rx1KhRdmmGDBlCli5dSgghRK1WE4lEQj744AOn9j/22GNk8uTJ7O/XX3+dZGRkuBylo9FoiEgkIhs3bmS3GY1GkpCQQFavXk0IIeSNN95odyQUwwcffEBCQ0OJyWQiarWaCIVCUl1dTTZt2kTGjBlDCCHk119/JQBIUVERa2/bEVHt2c/1WrSHxWIh+/fvJ//3f/9H+vbtSwCQ3r17u+xRA4cRUZ9//jkRCAQd9spt3ryZ5OTkEJ1ORwhxtN8Zbc+J2WwmoaGh5P7772e3VVRU2Hnt23Ls2DECgBQWFrZbVntMmDCBxMTEEJlMRhITEx3u5WDlyy+/JEqlkv19+PBhAoC8+eabTtMzPTHORlcuWrSIjB07lv3tbJQl06Pz888/k4EDBxKRSER27drV4YhI5ridO3eSQYMGEZlMRkaMGEEuXLhACGntIUGbXpp169axx48fP5787W9/8+5kdVE+/PBDkpWVRQgh5NNPP+1wZGJ7I2cJab2ucrmcLF68mFy4cIG9Bq+88grJzs4m27ZtI/n5+WTdunVEIpGQ3bt3s8c+9thjJCUlhezcuZOcOnWK3HrrrSQsLIx9zjsaOcu1HGZ0x/Lly8mlS5fIxx9/THg8Htm+fTubZsmSJSQyMpKsX7+eXLlyhfz+++/kgw8+IFqtligUCjsdraqqIkKhkPz2228uzwuF4mva6rMty5cvJzNnziTnz58nCoWCaLVadl9LSwuJiYkh06ZNc3oso+Nc9d4Z7bX9jF7b/rnaRgghv//+Oxk1ahSRSqUkKSmJLFy40G5Esl6vJ0uWLCFJSUlELBaTzMxM8p///MdpLz0zopwQQl588UWHd6brAar5VPOvFZxpINcRUYw+fPbZZ2TMmDFEIpGQdevWsSNqtmzZQrKysohEIiETJ04kxcXFbD5Xrlwht912G1GpVCQ0NJQMHjyY7Nixw6GsFStWkLlz5xK5XE6Sk5PJ2rVr2f1M+X/88QchxHEWTVsd/OSTT8igQYOIXC4nsbGxZNasWaSqqsouL2da1/Zbqb6+ntx///0kIiKCyGQycvPNN5NLly6x+xn7t23bRrKzs0loaCiZNGkSKS8vd3kd2trSFlfv4G23FRQUEEII+fbbb8mAAQOIRCIh6enpZPny5XYjxxoaGsgjjzzCjubt3bs3+eGHH5y2I7ZaMXfu3HZnOXUVrmlH1I033kguX77M/jE33tixYx2Gf585c4YAsHNchYaGEpFIRIYOHUoIIeTEiRN2zhOG/v37c3ZEcSmHqePjjz9ul8dtt91G5s6dSwj530vV1atXndp//PhxIhAISGlpKSGEkD59+pCXXnrJ5fk6efKkUwfFtGnT2DK5OqIuX75MAJADBw6Qn376ifTq1YsQQkhZWRmRSCREp9OR559/nmRkZNjZ29YR1Z79XK9FezQ2NpIvv/ySzJ07l8THxxOZTEZuueUWUl1d7TQ9F0fUxIkTya233tpumuLiYqJSqcjJkyfZbVwdUW3PSUpKCusoJIQQq9VKAJDvvvvOaR5ms5lMmDCBhIWFkenTp5P333+f1NfXt1vutcITTzxBbr75ZrvfcrmcGI3Gdo/j6ohq+/LKNCJ9+/Yl27dvJ1euXCF1dXUdvmgyxw0bNozs3r2bnD17lowePZrk5uYSQgjRarXkr3/9K+nduzc7rcD2w2zp0qV2dbueyM3NZRvq5uZmEhISYjcduC3tdVgQ4t9Oi44+SoK104JC8Qdt9ZnBarWS1NRU8uOPPxJCCBk0aBD55JNP2P3ffPMN+77RUf5c9N4Z7bX9BoOBXLx4kQAgX3/9NamoqHC57cqVKyQ0NJS88cYb5NKlS2T//v1kwIABZM6cOWx+d911F0lOTibffPMNyc/PJzt37iSfffYZMZvN5OuvvyYAyMWLF0lFRYXdVLytW7cSsVjsVriBawGq+a1Qze/6ONNAdx1RaWlp5OuvvyZXr14l5eXlZN26dUQkEpHBgweTAwcOkKNHj5KhQ4ey75OEtH5Pvffee+T06dPk0qVL5G9/+xuRSqV231epqakkKiqKvPPOO+Ty5ctk5cqVhM/ns47ats6bxsZGu6mvixYtIiqVilRUVBBCWh3IP//8M8nPzycHDx4kI0aMYO/J9rSu7bfSbbfdRnr27En27t1LTpw4QSZNmkSysrJYnWfsv/HGG0leXh45duwY6dmzJ7nnnntcXoeOHFFarZbs3LmTACBHjhwhFRUVRKPROGwzm81k7969JDw8nKxfv57k5+eT7du3k7S0NLJ8+XJCSOuAiOHDh5PevXuT7du3k/z8fPLDDz+Qn3/+mRgMBvLmm2+S8PBw9jw2Nzez9Xj33Xc5fZMHO/4dQ9fJhIaGIisry+U+WzQaDQDgp59+QmJiot0+iUTiVrl8Pt9hqhMzRNKdckQikd1vHo8Hq9UKAJDJZO3WYcCAAejXrx8++eQTTJw4EWfPnsVPP/3klh2ekpWVhaSkJOzatQsNDQ0YO3YsACAhIQHJyck4cOAAdu3ahRtuuKHdfNqz31MKCgrwxRdf4Oeff8aBAweQmpqKyZMn48MPP8T48eMhlUo9zruoqAg7d+7EN9980266Y8eOobq6GgMHDmS3WSwW7N27F2vWrIHBYGCHibfF2Tmx3cZMB3R1ngQCAXbs2IEDBw5g+/btePvtt/Hcc8/h8OHDTgP5X0sUFRUhISGB/X358mVkZGQ4nFNP6datG1avXs3+rqioAAC89NJLuOmmmwAABoMBr776Knbu3IkRI0YAADIyMrBv3z6sXbuWfVYAYMWKFezvZ555BlOmTIFer4dMJoNcLodQKERcXJxDPRISElBUVOQTm7oSFy9exIEDB9ipGXK5HLfffjs+/PBDhxU7bRk/fjzeffdd9nfbtoEZis1w5coVaLVa9poyGI1GDBgwAEDrwg5GoxHDhg1j90dFRaFHjx6c7eFSDkPbxQ7i4+NRXV0NADh//jwMBgMmTJjgtJyHH34YQ4YMQVlZGRITE7F+/Xo2oC+FEija6jPDzp07odVq2SlS9913Hz788EN2GtHly5cBANnZ2e3m763ez5o1y6FdPnfuHFJSUqBSqQCAnSYFwOm2lStX4t5772WnanXr1g1vvfUWxo4di3fffRfFxcX44osvsGPHDnbKfkZGBlteVFQUm3fbAMQJCQkwGo2orKxEamqqRzZ2Najm/w+q+V0fVxroDk8++STuvPNOu20mkwlr1qxh782PP/4YPXv2xJEjRzB06FD069cP/fr1Y9O//PLL2LJlC77//nssWLCA3X7LLbfg8ccfB9Aa5uSNN97Arl27nN7jCoUCCoUCAPDNN99g7dq12LlzJ6uFtmFiMjIy8NZbb2HIkCHQaDSQy+Xtah3D5cuX8f3332P//v3Izc0FAGzcuBHJycn49ttv2QWjTCYT3nvvPWRmZgIAFixYgJdeeqnDc5mbmws+3z6CkUajgUwmQ3R0NABAqVSyNjnb9uKLL+KZZ57B7NmzWVtffvllLFmyBMuWLcPOnTtx5MgRnD9/Ht27d2fT2J5HHo/n8l2/pKQEVqvVoZ5diWvaEeUOvXr1gkQiQXFxsd3HoC2ZmZkQiUQ4fPgwUlJSAAANDQ24dOmS3TFKpZL9CAUAtVqNgoICzuVwoVu3bpDJZPj111/x0EMPOU3z0EMP4c0330RZWRluvPFGJCcnu8wvMzOTjZnFvMSYTCbk5eV5tELB+PHjsXv3bjQ0NGDx4sXs9jFjxmDr1q04cuQIHnvsMbfzta0vl2vRlvXr12P//v24/fbbsXbt2g5fXt1h3bp1UKlUHa7cMmHCBJw+fdpu29y5c5GdnY2lS5e6dEL5Ch6Ph5EjR2LkyJF44YUXkJqaii1btuAvf/mLX8vtbHQ6nZ2jsa2z2FvavrwyDB48mP3f0xfN+Ph4AK2x3pj73RUymczt1SGvBT788EMMGTIE3bp1Y7fde++9mDFjBtasWcO+FLWlvQ4LZr8tvuq0aK/Dwt1yumqnBYXC0FafGT766CPcfffdbOyRWbNmYfHixcjPz0dmZiZnHfdW79944w2HeI7ufjSePHkSp06dwsaNG+3qZbVaUVBQgNOnT0MgEHj0bsg859eT9lPN/x9U87s+rjTQHWzfNxmEQiGGDBnC/s7OzkZERATOnz+PoUOHQqPRYPny5fjpp59QUVEBs9kMnU7nEDfX9p2UcY4wzk9X/PHHH7j//vuxZs0ajBw5kt1+7NgxLF++HCdPnkRDQwN77xYXF6NXr16cbD1//jyEQqGd8zc6Oho9evTA+fPn2W0hISGsEwqwd9q2x+eff46ePXtyqosrTp48if3792PFihXsNovFAr1eD61WixMnTiApKYl1QrmDTCaD1WqFwWDo8JkPZqgj6r+EhYXh6aefxlNPPQWr1YpRo0ahqakJ+/fvR3h4OGbPng25XI4HH3wQixcvRnR0NFQqFZ577jkHT+QNN9yA9evXY+rUqYiIiMALL7zAOhe4lMMFqVSKpUuXYsmSJRCLxRg5ciRqampw9uxZNtDdPffcg6effhoffPABPvnkk3bzCw0NxWOPPYbFixcjKioKKSkpWL16NbRarUeB88aPH4/58+fDZDLZvVSNHTsWCxYsgNFobDdQeUdwvRZtWbBgAWbNmsX+vnDhgkOajIwMiMViAK0vBrbL+hYUFODEiRPsOWKwWq1Yt24dZs+e7TRY35o1a7Blyxb8+uuvCAsLQ05Ojt3+0NBQREdHO2z3NYcPH8avv/6KiRMnQqVS4fDhw6ipqfFabLsCMTExaGhoYH93794d+/btg8lkareXvKOXR4a2L6/Otnv6otnRSDdb6uvroVQqO0x3LWE2m/HJJ5/gmWeesds+ceJEhISEYPPmzXj00Ud9UpavOi3a67DgWg4XfN1pQaH4g7b6DLRq2ZYtW2AymexGsFgsFnz00UdYsWIF+wJ/4cIFdpSpM7jqvSvi4uLadV5wQaPR4M9//jOeeOIJh30pKSl27xruUl9fDwDXjfZTzXcN1fyuiTMNDA8PBwA0NTU5jAxqbGx0cLa6eg9tj6effho7duzAP/7xD2RlZUEmk2H69OkOi+64O0ulsrISt912Gx566CG778iWlhZMmjQJkyZNwsaNG6FUKlFcXIxJkyY5XejHW5zVm0vHRHJysk80/8UXX3QYpQa0fsd740Cqr69HaGhol3ZCAdQRZcfLL78MpVKJlStX4urVq4iIiMDAgQPxf//3f2yav//979BoNJg6dSrCwsLw17/+FU1NTXb5PPvssygoKMCtt94KhUKBl19+2a6x4VIOF55//nkIhUK88MILKC8vR3x8vF3Dq1Ao8Kc//Qk//fQTu7pLe6xatQpWqxX3338/mpubMXjwYPzyyy+IjIx0q15AqyNKp9MhOzsbsbGx7PaxY8eiubkZPXr0YEd5eAqXa9GW119/Ha+99lq7ac6fP8+OlDp69Kidw4wZNTR79my71Vl27tyJ4uJil6sS1tbWIj8/n4tZfiU8PBx79+7Fm2++CbVajdTUVLz++uuYPHlyZ1fN7wwYMMBuVaF77rkHb731Fv79739j0aJFDukbGxsREREBpVKJM2fO2O07ceKERx8zvnrRFIvFsFgsTvedOXPGYXTVtc6PP/6Iqqoq5OTkOFyrMWPG4MMPP/TZR4mvOi3a67DgWg4XfN1pQaH4g7b6DLROs0hKSsK3335rt3379u14/fXX8dJLL2HixImIiYnB6tWrsWXLFod8GR3nqvf+ZODAgTh37pzLj5s+ffrAarViz549TlfTZTrInGn/mTNnkJSUhJiYGN9WOkihmu8aqvldE2ca2K1bN/D5fBw7dsxuyu3Vq1fR1NTEaSSN2WzG0aNHMXToUACtU1obGxvZDuj9+/djzpw5uOOOOwC0Ok8KCwu9skWv1+P2229HdnY2/vnPf9rtu3DhAurq6rBq1SrWAXr06FG7NO1pHUPPnj1hNptx+PBhdmpeXV0dLl68yHlUlb8ZOHAgLl686FLz+/bti9LSUly6dMnptbwu3vU7LTrVNQSXQNOdxQ033EAWLlzY2dWgUDqdU6dOEaFQaBecfcmSJUQgEJDFixeTAwcOkMLCQrJz504yffp0dnWlbdu2ER6PRz7++GNy6dIl8sILL5Dw8HCHYOVtNcBVkMnnnnuOREdHs6vZHDt2jLz11ltk/fr1Lo/7448/7Fbh2LhxIwkNDSV//PEHqampsQtQm5qaahfM93rg1ltvdbpCi+2f7eIADFxWUHKm7Varlbz55pukR48eRCQSEaVSSSZNmkT27NnDpmlubib33XcfCQkJIbGxsWT16tV2+TU1NZG7776bhIeHk+TkZLJ+/XqHFZS4lOOsjrfffrvdiloWi4W88sorJDU1lYhEIpKSkkJeffVVu2Puv/9+EhUVdd0FO6YEB870uV+/fmwAZlsaGxuJWCxmA5h/++23RCQSkalTp5IdO3aQgoICkpeXRxYvXkzuvvtu9jgueu8M/HdVJNvgu0yAWkJaVz2CzYpQrradPHmSyGQyMn/+fPLHH3+QS5cukW+//ZbMnz+fTTNnzhySnJxMtmzZQq5evUp27dpFPv/8c0IIIaWlpYTH45H169eT6upqu8C1s2fPJvPmzeN4trs+VPPt60g1v+vjTAMJIeSRRx4haWlp5LvvviNXr14le/bsIcOHDyfDhw9nA8y7CrDNBOseOnQoOXToEDl69Ch7LMMdd9xB+vfvT/744w9y4sQJMnXqVLvVHgnpONB+2/IfeOABEh8fT86dO2enmQaDgVRXVxOxWEwWL15M8vPzyXfffUe6d+9ud7wrrWt7799+++2kV69e5PfffycnTpwgN998s0OwcoVCYVfvLVu2kPbcH4wtO3fudNB8ZqXztu/krrZt27aNCIVCsnz5cnLmzBly7tw5snnzZvLcc8+xacaNG0dycnLI9u3bydWrV8nPP/9Mtm7dSgghZP/+/WxdampqSEtLC3vc2LFj212ErKtAHVE+IBgdUfX19eSbb76xW9WAQrneGTp0KHnvvffstn3++edkzJgxJCwsjISGhpK+ffuSl156yc4R9MILL5DY2FiiUCjIU089RRYsWOCxI6qjF00ujii9Xk/+9Kc/kYiICPYjiRBCDhw4QCIiIuxW0aMED8HYVjDQTgtKZ2Orz0ePHmVXIHLG5MmTyR133MH+zsvLI3feeSdRKpVEIpGQrKws8sgjj5DLly/bHcdF79viytGxcuVKQgh3RxQhhBw5coTcdNNNRC6Xs+WvWLGC3a/T6chTTz1F4uPjiVgsJllZWeSjjz5i97/00kskLi6O8Hg81vGg0+mIQqEgBw8edGkDpXOgmk9xB2fvqDqdjixbtoxkZ2cTmUxG0tPTySOPPEJqamrYNO05ohQKBfn6669JRkYGkUgk5MYbb7RbEa+goICMHz+eyGQykpycTNasWeNw37rriEpNTXWqmYwebtq0iaSlpRGJREJGjBhBvv/+e4f6O9O6tvWqr68n999/P1EoFEQmk5FJkyaRS5cuOdhvC1dHlLO/zZs3E0K4O6IIaXVG5ebmEplMRsLDw8nQoUPJ+++/z+6vq6sjc+fOJdHR0UQqlZKcnBy2k4UQQh599FESHR1NALDnu7S0lIhEIlJSUuLSjq4CjxAfR+y9Dhk3bhz69++PN998s7OrwpKWloaGhgY8//zzePrppzu7OhRKUPDTTz9h8eLFOHPmTJdeZcIVd999N/r16+f2NF9KYAjGtqKhoQG7d+/G9OnTce7cObdWeaJQfMm1rs/+4t1338WWLVuwffv2zq4KpQ1U8ynuQDWQwoWlS5eioaEB77//fmdXxWtojCgfsHv37s6uggPezu+lUK5FpkyZgsuXL6OsrOyaC85pNBrRp08fPPXUU51dFUoXYsCAAWhoaMBrr71GP0goncq1rM/+RCQS4e233+7salC6CFTzgxeqgRQuqFSqa2alczoiikKhUCgUCoVCoVAoFAqFEhDouD8KhUKhUCgUCoVCoVAoFEpAoI4oCoVCoVAoFAqFQqFQKBRKQKCOKAqFQqFQKBQKhUKhUCgUSkC45oKV6/V6GI3Gzq4GhUKhBAVisRhSqbSzq+E3qOZTKBTK/6CaT6FQKNcPXVnzrylHlF6vR3p6OiorKzu7KhQKhRIUxMXFoaCgoMs2Uu1BNZ9CoVDsoZpPoVAo1w9dWfOvKUeU0WhEZWUlSkpKEB4e3tnVcaCxsREAEBER0an18AauNhw6dAjDhw/3f4U8oDOvg1qtxpUrVzBw4ECv8ulMG6xWKyoqKmCxWJCQkACh0FFGtFotNBoNIiIiwOfzoVarodFoEBsbC4lEAqBjG3Q6HaqqqsDj8RAWFoaoqCh2X2NjIy5evIiBAwdCr9dDKBRCKpWCx+P53N72sLUhPz8f0dHRkEgk4PP5rJ2diVqtRnJyMoxGY5dsoDqCar7/oZrvHRqNBhcvXsSgQYO8yqerar5KpWK1xxvNV6vVOH/+PAYMGACj0QiBQBBUms/j8YJCY6nmdy5U84ODzrwOWq0WZ86cwdChQ73Kp7M1v7KyEiaTCQkJCRCJRA5pdDodmpuboVAoIBQK0dTU5Lbm6/V6VFZWOtX85uZmnD17FgMHDgwqzY+KimLrEQwa29U1/5pyRDGEh4cHZQMlk8kAwOkD3VXgakNoaGhQXgOgc69DeHg4Ll265PW56QwbCCGorq5GS0sL0tPTHQSvrq4OarUahBCEhIQgISEBJSUl7L4RI0bYNSC2NlitVmi1WhiNRuj1ehgMBojFYvTp08dpoyMWi2GxWNDY2Ijw8HD2f0IIuz82NhYCgcBfp8PBhv79+6Ourg4GgwHNzc2Qy+VISkrya/m+oKqqCjExMX4/V/6Ear7/oJrvHeHh4bhw4UKX1fyamhpoNBqkpaWxdWCor69HU1MTCCGQyWRITExEcXEx+Hw+qqurkZub26Hmm0wm6HQ6VvNzcnLA5zuGL5VIJDAajWhqagoqza+vr4der4dGo0FISAiSk5P9Wr4vqKqqQnR0tFOHYleBar7/oJrvHeHh4Th37lyX1HwAqK6uhkajQWpqKifNLyoqgkgkQkVFBXJzc+30uyPNF4lELjVfKpUiMzMTTU1NCAsLAyEk6DRfJpMhJSXFr+X7gurqakRFRQWl5gdfja5htFotAEChUHRyTTyH2uA9vhgpE2gbjEYjjh8/jt69eyM2NpbdptFooNFoYLFYEBERgfT0dBBCwOPxUFZWhpqaGkgkEgwcONDBoaTVatHS0sKOaAoJCYFYLEZMTAzEYnG79REKhbBarcjIyHDqqNLpdLh69SrS09N9LrxmsxmNjY1oaWmBRqOBQCBAdnY2eDweYmJicPXqVYSFhUGpVPq0XH9w+PBhDB8+HCveHIz/W5TX2dW55uhsrfEF1Abv6UjPuNAZmv/HH38gOzsbKpUKAGAymdDc3Nyu5tfW1kIkEmHQoEHtar5AIEBoaKhbmk8Ican5er0+IJrf0tICHo+Hnj17gsfjITo6GgUFBZDL5YiJifFpuf7g2LFjGDx4MP75t7/hqZdf7uzqXHN0ttb4AmqD91xLmq/RaNDc3AyLxQKFQmGn+eXl5airq2M1v61DyRvNZxxM6enpTh1VjOanpaX53FnHaD4z0rcra/7JkycxYMAArFq6FEtWruzs6jhAHVEBJNDDCf0BtcF7GG++NwTShqKiIly6dAl9+vRBbW0t6uvrQQiBWCyGXC5HYmKiXY8Ej8eD1WqFTqdDcnIyRCKRXYNjNptRX1+PqqoqhISEuPywaA+hUIjMzEyX+2UyGdLT01FYWIj09HTOPSY6nQ41NTWwWq1O60QIgVAoREREBKKiotjRArYIBALU1tYiMTHRLZsCDSEEi/46FSPGqPD6K6cxf05Tl37xDEY6W2t8AbUhOAikDcXFxbh48SL69OmD+vp6thdaJBJx0nyBQOBzzRcIBO1qvlQqRXp6OgoKCpCRkeGR5jO22EIIgUAgQGRkJKKiolBbWwu1Wu1Qt5qami6h+YsXLsTYYcPw8ttvY85f/oLIyMjOrtY1BdWa4IDa4B5tNb+hoQEAOtT8lpYWpKSkgM/nO2h+Q0MDKisrIZPJkJmZ6RfNz8jIcLsDgqvmM+/5tbW1aGpqsksjFApRXV0d9JoPAEsWLsSYoUPx6jvv4MGnn0Z0dHRnV8kO6ogKIF1x7mZbqA2+wWw2e9VrG0gbSkpKcNNNN7l1jE6nAyEEEREREIlEKCkpgVarxaVLl9C7d2/Ex8ejR48eAPzX2AqFQqSmpiI/Px+ZmZkQCASwWCzQ6/UIDQ21S9vQ0ICGhgaEhIQ4NLjtYbVaHea+WywW9OjRAzqdDg0NDTAajUhNTQ26F6PvvvsO+Zebcej8bXjgzj144dWR+NdrZzq7WtcUwaA13kJt8B4ejwej0ehVL3kgbSguLvZI861WKxQKBcRiMUpKSqDX63H+/Hn06tULCQkJAdH8tLQ0XLlyBZmZmRAKhR1qPjO9xBvNN5vNyM7ODnrN//nnn3HqwgXk79mDGfPn49VnnsHf167t7GpdU3S21vgCaoP3CAQC6PV6r+oR7Jqv1+tBCEFYWBgkEglKS0thMBhw7tw59OzZE4mJiX7XfIFAgPT0dFy9ehUZGRms5ut0Osjlcru0jY2NqK+vh0wmcxnr0BnMt4wtjObr9Xo0NjZCr9cHpeZv374deadOIX/vXty7aBFeXrwYb370UWdXyw7qiAogzDBLXwzZ7CyoDd6TnJyMgoICdOvWzeM8AmmDJ8IaGhpqZ19qaioAIDo6GhcuXGB7mAH/2iASiZCSkoLy8nJYrVa216ayspL98GCmmGRkZLidv8FgYGNjMT1ERqMRhw8fhlQqZR2OMpmMndIYDJhMJjy95AE8/XwfyMNEeGHVANxxww48vaCkS8Q46Sp0ttb4Aq42+GKkp7/o7OvAaD7zUu4JXUHzu3fvzv52pvlMT6y/NT8tLQ0VFRV+0XwmNkhzczOr+QaDAUeOHIFYLIbJZGKX0o6Li/O1eR5jNpux5Kmn8MITT0ARHo7VzzyD3D/9CfOffRZpaWmdXb1rhs7WGl9ANd97GM3v2bOnx3kEu+aHhIQ41fyoqChcuHABfD6fDVHhTxuYTmdbzZdIJKiqqrLTfIVC4bHmM1PSeTweCCEwGAzIy8tjNV8ikUAikSA+Pt7X5nmMxWLB4kWL8NyCBYhUKLD62Wcx5LbbsPC559odaRZoqCMqgHS2h94XUBu8JzU1Fbt370Z8fLyDx54rnW2Dp6hUKqhUKvz2228QCoUBGSIqlUodnCuMU4gZmuts/jkXmA8N5noQQtDU1ISsrCwIBAIcOnQIzc3N0Ov1aGhoQFhYWFAEC/zn2pEAgHvnZQEA+g+Kxs23JeHp58bh80/yO7Nq1xRd9Tm1hasNwdYTaEtnX4eUlBTs3r0biYmJ153mx8TEYNSoUdi9ezeEQmFAYudJJJKAa363bt0gFApx6NAhqNVqGAyGoNL89a+/DoPRiEfvvRcA0L93b8y45Rb87amnsGHLlk6u3bVDV31ObaGa7z1JSUnYu3cvEhMTPQ5a3tk2eIqt5ovF4k7TfCbOldVqZafbeUJsbCxiY2OdvucLhUIcOXKE1fz6+nqEhYUFxWIFn77xBtQaDRY88AAAIKdHD9xz++34v0WL8PmPP3Zy7f6HZy0xxSPMZjPMZnNnV8MruNoQzD0lwXAdcnNzcfr0aY+PDwYbvCE3Nxc1NTU4dOgQ9u3bh3379uH48eMoLy8PqF18Pt/jDxLA8TrweDxERERAKBSCx+MhJSUFhBBUVVWhpKQEBw4cQGFhIQoLC1FaWoqmpiYYjUZfmMKZ5uZm/OPl0/jbqwMgEv3P9mdf7o/vvyzCyZMnPcrzySefZFdZyc3NRV4eDX7e1Z9TgNrgK3Jzcz16thiCwQZvyM3NRV1dnYPml5aWXjOaD4CdnlFZWclqfkFBAQoLC1FSUoKmpiYYDIaAviO1tLTghX/+EyuXLLEbmfDK00/jm23bcOzYMbfzfPfdd9G3b1929boRI0Zg69atvqx2l6SrP6cAtcFX0Pf84NF8b1bW46r5VVVVKC0txcGDBztd83U6Hf72+ut4dfFiuwWyXvrLX/Djb7/h8OHDbufpL83v/G6a64iuLCgMXG0I5p6SYLgOzHBOTwkGG7yBCTIIgJ17rVarUVVVhby8PFgsFgCtvRw9evQI2iWCO7oOVqsVKSkpqKurQ69evXD16lWoVCqEhISwq5HU1dXBaDSyjRQz9JdZlYR5lpihxSKRCHw+HyKRiP3fYrFwbmiXrcxFZrcw3Hxbkt32lDQ55jzWHU8unoxd28vdOg8PPfQQzpw5g08//RQJCQnYsGEDbrzxRpw7d65LBHP0F139OQWoDb5CLBazuuYJwWCDN4jFYgfN12g0TjW/W7duDjE5goWOroPFYkFycjLq6urQs2dPFBQUQKVSITQ0lNX8+vp6px0QzCIZvtb8159/HqmJiZh+yy1225MTErBo7lwsXrgQv+7f79Z7W1JSElatWoVu3bqBEIKPP/4Yt99+O/744w/07t2bcz7XGl39OQWoDb6CiVfkKcFggzdcL5pvNpuRlJTEan5hYSGUSiXkcrmD5jPv9QBcvueHh4dDLBaDz+dDKBSy/7uj+W8uW4Z4lQp3T51qtz0xLg5/eeghPL1wIfYePhwUms8jwTx0xU3UajUUCgWampqC8sOVuZmDYZi2p3C1Yf/+/Rg5cmQgquQ2wXIdvDlHgbDBarWitLQUly9fxoQJE3yePxcbtFotzp07B41GA6VSCYVCwfZEMOIcCAghKC0tdXipkMvldj0j9fX14PP5Dg3qlStXoFarkZGRAbPZjIqKCiiVSrdiiBBCoNFoYDKZYLVaYTab2SV1q6urMWDAAISFhbFpeTyegyaWl5cjq1sKvt5+IwYOdVx2tqHegOHZ3+OLz3/AxIkTOdVLp9MhLCwM3333HaZMmcJuHzRoECZPnoxXXnmFs43uQjXf/1DN9x1U87lp/oULF6BWqztd88vKyhw+QkJDQxEZGclJ85ubm5GWlsbmFRMT41YMkY40v3///qzuudL8qqoqZGVmYtvHH2Pk4MEOZTSp1cgcOxafbNiAW9o4qtwlKioKf//73/Hggw96lU97UM33P1TzfUdX0Pzy8nKcP3/e7WDlXPBE88PCwhAVFRW0ms+sKNh2xdH8/Hw0NTUhPT0dQOtCTzExMUhISHCrDm01n/ldU1ODfv36satbu9L8mpoaZGVm4rv338e4ESMcymjWaJA1bhze/89/cPvtt3M/QU7wheZ3XaXsgjDLvAer15cLXG1oamrCmTPBuQJXS0sLADisohNoysrKPD7Wn/eS0WjEmTNnoFarkZiYiLFjx/q8DICbDSEhIRj835fn6upqNDc349KlS7BYLHajiNLS0pCUlOQyH1tseySc1amurg5Aa8NpNBrB5/NBCIFSqbS7ZwghKCoqQmlpKbKyskAIgV6vh1AoREFBgV3jKRQKwefzceLECURGRiIuLg7V1dXsOZBKpawtFosFhBCkp6eDEIKGhgY0NzfDZDIhJiYGUqkU1dXVEAqFbM9EQ0MD6urq2Lo3NTUhOjqazZ9h8d/G4KZbEp06oQAgMkqCJ5/NwVNP3428Q44NMhOQ0Raz2QyLxeIQz0Amk2Hfvn3OL8J1wvWk+c3NzVTzO4BqPjfNHzhwIIBWzW9paXGq+SkpKUhJSeFUbnua39LSgtraWhBCIBKJOtT84uJilJWVISurNb6eTqeDSCRyqvk8Hg8nT5500Hwej+eg+VarFRkZGU41XyaTsYF3mUVAGhoaUF9fj/r6egCtmh8VFcXe6wzL//pX3DRqlFMnFAAowsPxwhNPYMlTT2Hs2LEOnS3ONL8tFosFX375JVpaWjDCyYfP9cT1pPkajYZqfgd0Fc0fP368z8sAglvzAcf3/JiYGLs4jraan5mZCT6fj5aWFkgkEgfNFwgEEAgEOHnyJCIiIhAXF4fa2lq0tLSwAdRtNd9isbBBw+vr61nNj46OttN8pq1pampiV3sFWp3yERERbFB7hpcWL8aYoUOdOqEAIEwux/JFi7D0L3/BhAkT2LiJDIHWfOqICiBdeRUNBq42hISEcHYMBBqdTgeg9UM5kLR92EtKSjzOy1/3kkajwcGDBzFkyBC/v0i5awMT6LwtVqsVv/76KxISEjrsObFarTh48CByc3PR2NgItVoNvV6P9PR0mM1m1NXVISUlhV1unWlYnMHj8aBSqaBUKtkGIi0tDWKxGFFRURAIBA4NISEERqORXQK8pKQEPB4PfD4farUaUqkUSqUSzc3NuHLlCqxWK7RaLXJycti4I42NjUhNTUVtbS1KSkpQV1eHwYMH2wVHZMoJCQlht6nVany2Ph+nVwxG9AbX997iiBC8V9SCRx99FJ9++qndvmXLlmH58uV228LCwjBixAi8/PLL6NmzJ2JjY7F582YcPHiQbUCvV64nzZdKpVTz29BW80tLSz3Oy1/3klarxf79+zFo0CBERUX5pQwGTzQfANvDzGC1WrFr1y4kJSVx1vwRI0agqamJXTwiNTUVFosFNTU1bIwPk8kEHo/nsveex+NBqVQiJiaG1fzU1FRIJBJOmh8ZGYni4mJW85ubmyGRSBATEwONRoMrV66wPeI5OTng8/l2ml9XV8dq/qBBgxzOp8FgsHNEabVafLBpE47dPQrm1Y+7PEcPWax4rawIf/7zn7Fx40a7fc40n+H06dMYMWIE9Ho95HI5tmzZgl69erV3Oa55qOYHB8Gi+cH4nn+taz4hBAcOHMCIESOgVqvZ93wmZqsnms+859fX1yMlJQVSqRSRkZEdan5UVBSKi4sBwEHzW1paWM1vbm5Gnz59wOfzUVVVhcbGRqSlpaG+vh4lJSWor6/HgAEDHBxEBoPBrsPZYDDgvY0bcfDO4e1q/hyLFauqy/HII49g8+bNdvsCrfnUEUXxCyKRKGh7hBhhtP1IDyRWqxXHjh2zW/Y0GDCbzTh48CDGjh3bpV6m+Hw+unfvjgMHDoDH46FPnz4uh+zX1NQgIiKCXX47KioKpaWlKC4uZlfdYBqVtueguroaVqvVYTpdQUEB5HI5ZDIZampq0NLSgubmZiQmJjqs4sHj8ewaEltHTUJCAkwmE2pra2E0GiEUCqHVaiGRSNgAu7bxlqKjo3H06FEkJSXh4sWLyMnJcSjHYDCw20wmE6wESI5qv6dDIuJDGS7GnXfeiTVr1tjvc9FL8umnn2LevHlITEyEQCDAwIEDMWvWLI+C4FK6JlTzXcNofjAtmQz8T/NHjx7dpVZo4vP56NatGyfNr62thUKhgFarRXNzMyIjI1nNl0qlbMcDAIeVjmpqamA2mx2m09lqPtPj3dzcjISEBIce+/Y0H4CD5ut0OlbzBQKBg+bn5eWxmt+nTx+7vNpqvtlshoUQJMvbv7ZiAR+xIRJMmzYN//73vx3ydEWPHj1w4sQJNDU14auvvsLs2bOxZ8+e694Zdb0gFAqp5rvAarXi+PHjQdcZ15U1v0ePHti3bx/4fD5ycnJc3nu2ms/MDigtLUVJSQkkEonHmh8aGgqZTIa6ujpotVqo1WrEx8cjNTXVLm1Hmm82m1FbWwuDwcBqvlQqZTXfdipfVFQU8vPzWc3v27evXV5tNd9iscBsNneo+SIBH3GhUkydOhXvvfeeQ56u8IfmX5OOqEOHDmHMmDFB95AxwSk7Sxh9AVcbgjn0WGdeB7Vajby8PPTp08fp6B6u+MOGY8eOYdiwYQFzQvnShtTUVKSmpsJoNOL33393Gt+ECQqekZGBpqYmJCcn4+rVq+DxeEhLS2t3DjvTS922J6a8vBxSqRRpaWkAWhuBqqoqCIVCmM1mlJaWIj4+nnOAQZFI5NAANjc3s/GpZDIZVCoVeDweKioqoNfrodPpHHqPfIFIJOIcgyMzMxN79uxBS0sL2zjffffdbKBKf3Po0CGMGjUq6LT1etL8YKYzbdBoNDh8+HBQav4ff/yBIUOGBOxdyZc2MNM0jEYj9uzZ4zS+SX19PfR6PbKystDQ0IDk5GQUFBQAaJ3O3d4S20wvdVvNr6iogEQisdN8Zqq0xWLxmeaXlZWxmq9UKsHn81FeXh40mg+0fuwzH1mDBg1CXl4e/vWvf2Ht2rU+r1tbmI/pYNMlqpfBQTBofu/evd2KA9oWf2n+oEGDuqTmJyUlISkpqV3Nb2hogE6nYzU/JSUFBQUFIIR0qPlA6zdaW+2uqKiAWCxmNd9qtbLv+RaLBSUlJYiPj+ccy0soFDrcF7aaL5VKoVKpwOfzg+o9H/CP5nsVAWzVqlXg8Xh48skn2W3jxo1jI8Azf48++qjdcd9//z26d++OHj164Mcff2S3FxYWstNdmpub7Y7p37+/y6FibcnJycHvv//usV3+Qi6X28097YpwtSGYV83rzOug0WgQHR3t1QcJ4B8boqKicOLECXbutC8QZTmPSwH4xwaxWOy0odHpdGhpaUFycjJkMhni4uLA4/GQmpqK9PR0Tg2IUCi0+2CwjU/FwPRm9OjRA+np6VCpVLh69apXS7eGhYUhJSUF6enpkMvlKCwsxIkTJ3D58mUoFAqIxeJOj4PAEBoaivj4eDQ0NOCXX37xOhAiV6jm+w9qg3doNBpERkYGreYfP34c1dXVPstTNvNDl/v8pfnOenD1ej2am5vZaRTx8fGs5mdkZHT4QQI4/2CwWq12HwQCgQDx8fF+0/ywsDAUFRXh5MmTrOaLRKKgfCatVqtd77w/6devH9V8P0Ft8A6tVguFQuGVEwrwjw0xMTE4ceKETzW/PQKt+Wq12mPNZ+IEdqT5fD4f8fHx6N69OzIyMhAbG4uCggLo9XqfaH54eDiKi4tx6tQpXLp0CQqFAkKhkF2MKJjwheZ77IjKy8vD2rVrHYaJAcDDDz+MiooK9m/16tXsPoPBgPnz5+Pf//431qxZg8cee8xhGdvm5mb84x//8LRqkMvliIyMRGNjo8d5+AONRuMQPLirQW3wDiaO0alTp7xamtUfNnTr1g2jRo3CyZMnfZqvK/xhg1ardejBtlqtKCsrY6fJMaObgNYPjY6C8gGtjtWUlBS7tDweD1qtlu1tcYZYLEZqairq6+tRVFSEwsJCNDY2OsQR4IpcLkdGRgYGDBiA0aNHw2Qycfqg8je//PILtm3bhoKCAuzYsQPjx49HdnY25s6dG5Dy5XI5lEolG7g3WKB6GRx0pg1xcXEQi8U4ceJE0Gl+ZmYmxowZg9OnT3usSe7gDxv0er3DNmb1v7aaTwiBQCBwS/PbjhzQ6/Udaj4T24PR/IaGBo/Pb2hoKDIyMtC/f/+g0vxnn30We/fuRWFhIU6fPo1nn30Wu3fvxr333huQ8kNCQhAbG+vTjjNfQPUyOOhMG1QqFWQyWVBqfnp6OsaNG0c13wntaf7Vq1c71PyGhgYUFRWhoKDAa81PT09Hv379MHr0aJjN5mta8z1yRGk0Gtx777344IMPHJYvBFobiLi4OPbPdtiXwWCAQCBA//79MWDAAAiFQgdv2sKFC/HPf/7TK49tTk4Ozp8/7/Hx/kAoFHb6UqLeQm3wnr59+yImJgaHDh3yeMURf9nA5/N9OprNdOWoy33+sEGj0cBgMGDr1q0oLy8HIQQFBQVs7CdCCBobG3HixAk2mKW7MMvdFhYWQiQSddjzLRaLER8fj7S0NDZ+SElJCQoKCtDU1ORRHYDWnvjBgwd73evmC5qamjB//nxkZ2fjgQcewKhRo/DLL78EtPHs1avXda35myOUfsm3s/XSF3S2DTk5OYiLi7suNF/3metlnP1hg1qthsFgwC+//ILS0lIQQlBYWIjk5GS2U6Kpqclrza+oqEBhYSGEQmGHPd/MdDtG83k8Hqv53nSQMprfdipfZ1BdXY0HHngAPXr0wIQJE5CXl4dffvnFL0vAu6JXr164ePFiwMrjQiC1pr3Rh97Q2XrpCzrbBmZa3qFDh3Dq1CmP8vCnDVynDnuLP9/zf/nlFzYQeGFhoV0gc7VajRMnTjisKMeVtprf0Xu+reanpaX5VPMHDRpkFzeqs/CX5nt0d8yfPx9TpkzBjTfeiFdeecVh/8aNG7FhwwbExcVh6tSpeP7559n5oeHh4Zg7dy47ZO6VV15xGG42a9Ys7NixAy+99JJDsFyuSKVSCIVClJaWBs2qDl1d2AFqg69ISEhAQkICdu/e7dHx/rKhsrLS6ykkXPGHDSqVChMmTMDevXuhUqlQVFSEuLg4dtnUK1euoLm5GSNHjnT748tisUAgEODq1atITEyETCZje2Y6WsWDgc/nIyIigg2yWFhYCKlUyqm3xhUVFRUwGAysPXw+3yFIur+56667cNdddwW0zLYw57G4uJjzEr/+Jhi0xluoDb6B6Zjbu3cvrFYrZ81g8JcN1dXViImJcbs+nuAvzb/pppuwb98+xMbGoqioCCqVitXUK1euoKmpKWg0v6ioCFKp1KsYLZWVldDr9aw9TE9+IPnwQ/84QdxBLBZDJpOhqKjIIWBwZxEMWuMt1AbfwGj+vn37YDab3a6Tv2yora1FREREl9X8mJgYVvPj4uJQVFQEpVLJamp+fj4aGhq80vyCggLEx8cjJCTEbc3n8Xh2ms8shuTNCo7Xsua7fRd+9tlnOH78OFauXOl0/z333IMNGzZg165dePbZZ/Hpp5/ivvvus0uzbNky1NbWoq6uDkuWLHHIg8fjYdWqVXj//feRn5/vbhVZhgwZgitXrgRsLmxH6PV6p0MKuxLUBt/i6YgRf9mg0+ncClznDf68DiKRCKdOnUJMTAxCQ0NhMBhYLUlMTOywcWpsbERZWRn7u6SkBCdOnGDzZhoUb21ITEz0anlfoHUEqslkgkqlQmpqasBidAQjgwcPRmFh4XWp+bMaa/ySbzDppacEkw3Bpvl6vR4KhcLn+boqy1/XQSAQ4PTp04iJiYFcLofBYGCXxuai+U1NTSgtLWV/l5aW4o8//gDQ+jHlK81PSEjwmeYrlcrrXvMHDhyIoqIiVFZWdnZVAARWa9obfegNwaSXnhJMNlDN9997/pkzZxAVFYWwsDAYjUZW8xMSEjrUfLVabafFpaWlOH78OIBWzWcG0PhC823bFk9oq/ltQxp1ZdxyVZaUlGDRokXYsWOHy96cRx55hP2/T58+iI+Px4QJE5Cfn2+3dHFHD8GkSZMwatQoPP/889i0aZM71URzczMkEgl0Oh2GDx+OPXv2oF+/foiOjkZLSwskEgmsVitMJhPkcjk0Gg1EIhH4fD4MBgPkcjlaWlrA5/MhFouh0+kgk8lgNBphsVjYY5h8mOO1Wi0EAgEEAgGMRiPbe8bj8SAWi9Hc3AypVAqtVgur1YqQkBBotVpWpEwmE7tNIBCwwwFte+GkUim7vK/ZbIbFYmk3Hz6fz04fkkqlMBqNdmWLxWJYrVaYzWZ2m1AoBJ/Ph9FotMunPRva5tPY2MieQ4PBgNDQUGi1WvB4PPZ4Z+eUWbHNaDSy25ihnXq93mk+UqkUZrMZZrOZUz4mkwkymQxqtRqEEISEhKClpcVpPm3vC41GA4FAwN4XjLfcNp+O7i9bG8xmMxobG9u9v2zzsbUhJCQETU1NXp0LvV5vZ0NFRQXS0tKg1+s55ePNuTCZTAgNDUVjY6NdPlzPhUgkgkAgcHpfdO/eHZcvX2an4lVXV0OhUKCqqgoqlQqNjY0u7y+dTsc+W42NjWhqaoJQKIRYLIbJZEJzczM73NeVDc7OhbNrU1tbi4qKCsjlcsTExDicU+ZcWK1WhIaGOj0XhBDEx8ejoKAAKpUKYrEYpaWlCA8Pv6Yaq/aw1fyhQ4fi999/R+/evaFUKqnmU80PSs0PDQ0NCs0vLS1FSkrKNaH5Fy9eZDW/pqYG4eHhnDXfZDLZaT4TV8RkMkGj0fhM8+vq6lBVVcXGtfNE861WK+Lj41FYWMiOBCgpKYFCobiuNd9sNiM2Nva60fxtfQbi5tPHO03z6+vrqeZz1PympibI5fKg0PyysjLEx8d3ec3Pyspip+baaj4zypeL5lutVjQ2NkKtVrP5+vo9n9H80NBQqFQqn2l+cXExIiIiurzmu+WIOnbsGKqrqzFw4EB2m8Viwd69e7FmzRo2/pMtw4YNA9A6PNrWEcWFVatWYcSIEVi8eLFbx9nCDIv2NDYAFw4fPozk5GQYDAbw+Xzw+XyYzWaIxWIYjUbweDyIRCKo1WqIRCKIRCJYrVZIJBK7c2axWNhtfD4fAoEAJpOJ/QAGWj3ARqMRIpEIFovFo3wIIex+oVAIQojdMQKBgBVPZhuPx4NQKERzczNEIhF7nKt82q56GEww5yUYgr95CmODr4e9KhQKtLS0ICoqyqf5OoO519ob7irvlYvKI9s550kIQXFxMfR6PXr27AmgdepafHw8iouLkZaWBqFQ2KFwE0JgNBpRUlKC6OhoiEQiNDQ04NixY4iNjXXLhvYwGo3o27evxyttMDDDdC9evIjMzEyUlZWhvr4eDQ0NXuXbFQmE5h85cgRJSUlU86nmBwx/aX5kZCRaWloQExPj03ydwUUvI+5fj9J3p7uVb0lJCXQ6HXr37g2gdRpDbGwsSktLkZqayj5D7UEIgclkQklJCaKioiCVSnH16lUcO3bMbrq6t5pvMBiQk5Pj0bG2MJp/6dIlpKeno6Ki4rrW/MjIyOtO8wf91hoXrbM0P5gDmlPNd01ERARaWlp8ktf3fQaCbzSC8PmYet4xFpa3eumK0tJSaLVa9OrVCwBQVVUFpVKJ8vJyJCcns89lezBOVUbzZTIZCgoKcOzYMSiV/4u5GWyaf/nyZaSmpqKqqgoNDQ1dXvPdursnTJiA06dP222bO3cusrOzsXTpUqfBz5jpLJ4EVxw6dCjuvPNOPPPMM24dFxYWBolEwsYISE9Px7lz5yCRSBASEuIwT5OZxwmA3Wc7YovJxzaOi+0x0dHRGDBgQIf1YgITB2pIZFtEWYPbDR7NBa42aLVadkl5Z+eU8bq7OqfMkEjbbcwoPGf52NJRPkxMMtspaLb7nW1jbLDdxtTdtg5c82FsEAqF7H5X58LZNsYGb88Fc06ZYxmBazvisaN8PDkXzmxo+6zpLx1xyMOVDQqFgu0JCQ8PR1lZGcxmMxoaGiAUCtntrmxg8hGJRCgoKEBKSgprT2VlJbv6hu0yrsyLozMbuJyL8PBw5Ofno1u3bg7pOtIdZ9t69eqFmpoa9OrVC2VlZV2+p4QrbTU/NTUVZ86cgUwm84vmR0VFdQnNl8380OvpG1Tz/7fNl5rP5/ODQvMLCgqQkZERNJqv2fyQQx6ubFAoFKitrUVkZCQyMjJQVlYGk8mE+vp68Pl8REVFsWW5q/lVVVUghIDH4yE9PZ2d5uErzc/KymJjibg6F+3lw9CrVy9UVVWhZ8+eKC8vZ+t3rdNW89PS0nDq1CmEhoZe15rvC6jm/2+brzRfoVA4rNLcWZpfVFTkdHU4Lppv1mrtzqnIpgOKSeuu5rc9xtk22/uirq4OCoUC6enpdprfNjYTF81PSkpi62Eb0iEjIyOoNb+iogLZ2dmoqKjo8u/5bjmiwsLCHLx6oaGhiI6ORk5ODvLz87Fp0ybccsstiI6OxqlTp/DUU09hzJgx6Nu3r0cVXLFiBXr37u2VR1ilUkEul6OsrAxlZWWQy+XsaAlPKCoqQlFREfr37+9WPB3moegsvHVCAdxt8HaEhz/p7OvgC/xlg8lkCpio+doGnU4HvV4PlUqFwsJCxMXFQSqVIjY2FvX19ZxWnTCZTKioqIBIJLJrYJRKJQwGg91oKF/YwOfzERYWBr1e71XwWgaZTMYuGVtfXx+QkW3BiEqlQm5uLkpKSlBWVoaQkBB2tIQnFBcXo7CwEH379nX6kuCKztYaX8QQ6WwbfAG1wTUGg8Fjzd8coXQam8zVdn9ovlarRUpKCgoLCxEbGwuZTIa4uDjU1tYiMTGxwzxMJhMqKysdND8mJgbp6elQKpV2sUZ8ofnh4eHQ6/VeBa9lkEql7PtWXV3ddav5MTExrOaXl5dDKpV6NQqhq2q+L6A2BAf+1Hyz2ezRsVuyeiJq8EBU790HoDU25eYIJebdvAqznKT3tQ16vR4ajQapqalskPKQkBDEx8ejurqa0+JkjOa3dQxGR0cjLS0NMTExPtd8hULBTufzFqbOPB4PdXV1iI6O9jrPzsSnY+XEYjF27tyJiRMnIjs7G3/961/xpz/9CT/88IPHeXbv3h3z5s3zOthZSEgIunXrhiFDhqCmpob9WHMXs9mMgoIC5ObmIi8vz62HuaWlxWfDITsLrjb4cjloX3M9XQd3GTJkCC5fvoyDBw+itrbW4+eEC762gZmOUVBQgPDwcNaxU1FRgbi4OE55MKLetjETCAROR4r5wgZPVtDqCB6Ph759+3b5BsobpFIpq/l1dXVeaf7Vq1cxatQoHDt2zK2Pdqo1wQG1wTWDBg1Cfn5+l9f8sLAw1rHjjubX19cjIiLCqeanpKQ4OIuo5gcvjOYPHjwYjY2NHn9sW61WqvnUhk7Hn5pfUFCA/fv3u635ip49ob54if29OULZTmr/aH5cXBwKCwshl8tZxw4TgoMLjY2NUCgUDqtLM5rf1lkUrJoPtMbiDsS0en/i9cRT2+Xnk5OTsWfPHo/zSktLczqSZu3atVi7dq3H+bYlOzsbp06dQv/+/WE2m1FfX4+QkBDI5XJUV1fjwoULdtMMbetktVoREREBoVCIYcOGYc+ePZyHQvtixENnQ20IDvxlA3Nfa7VaXL16FadOnUJWVpZflgn1tQ0SiQQVFRVISUlhn9+GhgZERkZyHlEpFothsVg4l+kLG4xGo9Ph1p7Q1NRkFxMhmB3CgSQ7OxsnTpzAwIEDYbVaUVtbi5CQEDbg6rlz59rV/PDwcPD5fFbzuX7gUK0JDqgNrmE0X6/XIz8/H2fOnEF6ejpSU1M9ztPVCo6+tkEqlbIxQRiNZz4yuMaGYYLCulOmtxgMBrueeG9Qq9V27RvV/FaY93xnmt/Y2IgzZ8641HwAkMvl4PP5GDFiBH3P74JQG1zD5/MxZMgQO81PTU21CzvhirpjxwAAM+ur8FlULKv1zkZDAf55z2+r+UwgeK6azwTd54qvNN9X56K5udlpKKSuim8joHURVCoVLly4gLNnz7IrxpSWlkKn00EoFGLUqFGcPJdyuRxjx47Frl27OJXrae9MMEFtCA78bUNISAg7rP3UqVMoLi6GVCpF//79fRY40dc2OJt619jYyKlxBVpjqBGzEdpL3Kew+sIGX3041NbWQq1WIyMjwyf5XUuoVCpcunQJZ86cQVlZmZ3m8/l8tzR//Pjx+O233ziVS7UmOKA2dIxUKmWnr545cwb79u2DRCLBgAEDXGo+My2D+b8jfG2Dsx7whoYGzpovm/khiK4RTV8s4FxmMGl+XV0dmpqaqOY7ISYmBhcuXPBa80NCQjBhwgTs3LmTU7lUa4IDakPH2Gr+2bNnWc3v16+fy87ROy6fw5ZuvRA660Nog0Tz6+vrkZaWxjkPnU7n1nRbX9jgq3A1zIIU7i7+Fsxcl44oABgzZgzKy8uRnp7u1ZxNoVDI+XgqjMEBtcE9mPhujY2N2LNnDwYNGuSWiLsiEDa488JvunIUV69edWt0krc26HQ6n0yFqaiogEQioR8k7TBq1ChUVlYiLS0Ncrnc43yEQiEboLUjqNYEB9QG92A6IRjNHzBggNPYQx1Ny2hLsGm+7rMHcfXqVbdGJ/lC890ZdesKJq4V1XzX+Erz+Xw+1fwuRrDYsDlCiStmEwY11rp9bCBtYBxSarUav//+u0vN/77fYIgUCoSZtJzyDZTmu6P7Wq2W89RtwHsb9Hq9T97zq6qqIBAIriknFODjGFFdjYSEhIAGtJPL5V41hsEAtYEboqzBfs2/M65DREQExo8fj2PHjkGrtW+ERFmD3bY5EDa40wtRVVXldqBXb2woLCxEVVWVWz05ziCEQKfTXbdBat0hLi4uoM8N1cvgIBA2yGZ+CNnMD/2Wf2dq/okTJxw0XzbzQ8y7eZVb+QWb5ldXVyMyMtKt/INF87Va7XUdD4orVPPdh9rgO7iMFHVFZ9gQHh7Oar5Go3HYf1d5Ee68ch5qMbd6BZvm19TUuN2R7o0NRUVFqKio8Inmt7S0dPl4UM64bkdEdQbMQ+2L0SSdBbWBG75YobA9Ous68Pl8jBw5EkePHoVIJELPnj0RHh7ukb3+tqGiooJdOrYjampqQAhxuy6e2mA2m8Hn830Se6uoqIjTioCUwEP1MjgIhA2+WKGwPZzZ4Gp1Ol/C5/ORm5vroPkfbXuGTcO1DoHQfK4fDLW1tbBYLFCpVG6V4akNFosFPB7Pq9hbDEVFRZwD81ICC9XL4CCYbJj46y8eHefMBtnMD/3e1jBTV/Py8iAUClnNZzpa0lWhnOvg7+tQWVnJWfPr6upgMpmgVLo3ktcbzQfAeap4exQXF1+zmk8dUQGEayC1YIbaEBx0pg1SqRSjRo2CRqPBhQsXoNFokJGR4bZTxZ82NDY2QiAQcO49qK+vR48ePdwux10b9Ho91Go1mpqa7D5IdDodGhoaoNfrwefzwePxkJiYyDke17UQmPNahGpNcHAt2uDutDhvYDRfq9XiwoULUKvVGHnqGFJSUtyqhz+vQ1NTE/h8PuePjLq6uoBovsFggFqtRmNjo4PmNzY2sjGL3NX8tqv5UYKDa1FruiLXog3+HHHbFrFYjJEjR9pp/oXXbkRqaqpb9fDndVCr1QDAWfNra2sDrvm230V6vR4NDQ0eaT4h5JrVfOqICiD+WLox0FAbgoNgsEEul2Pw4MGwWq0QpeYAPD4sxWc4H+9PG9wJWAu0DkfW6/VuO3TcsaGlpQXV1dVQKpVQKpXg8XgwGo24dOkSoqKiEB0dzcYqMZlMKCgoQGZmZodl0FWSgpdgeE69hdoQHLS1wTZQeKAICQnBwIEDAbQGNJfc8goMbozI8ud1qK+vd0vzFQoFtFqt2+EZPNX8mJgY8Hg8mEwmXLx40SvNpwQv18K1ozYEB21t0H32YECdUYC95ksmvwSAD8PWv3E+3p/Xoa6uzq0pbxEREWhpaeEc743BHRu0Wi0qKyuhVCqRlZUFHo8Hs9mMCxcuOGi+2Wymmo/rPEZUoDEYDDAYDJ1dDa+4nm3wd9wndwim68Dn82EpOQdYuC1vzOBPG9x1zoSGhjrEQOGCOzbU1tYiNTUVcrmcrV9LSwuUSiUSEhLsAuaKRCIkJiaiqqrK7TpRgodgek495Xq2IdAv/e3hzAZ/T8trj5ycHOx4ZoxbxwSb5ut0OrfLcceGuro6pKSkOGh+TEyMU81PSkpCZWVlh/nSzofg5XrWy2DiWrXB39Py2sOw9QUQg9q9Y/ys+e5oYSA1PywszE7zo6OjHTRfKBQiOTkZFRUVHeZ7LWs+HREVQIIhcJ63XM82+Dvukzu4skGUNdhv9bR1xDkrY+8XH7mVnz/vJXdXqKitrUVycrLb5bhjAyEEFosFfD4fVqsV5eXlsFqtLqc0hoSEUEdUF+d60ktfLU/sDzy9Dp350t8WVzb4M2aIrSPOWRnu9uIGm+YnJSW5XY47NlitVlitVggEAhBCUFZWBovF4jJOlEwm4+SIogQv15PmBzPUBv+w6+Xb3UofTJpfU1ODxMREt8txxwaLxcLWi9F8s9nscuSWVCqF0Wh0u07XEnREVADRaDROVyHoSlAbggNXNrhyQvl6NJez/MbcNc+tcvx1HfR6PcRisVvpJRKJR3PZ3bEhKSkJFRUVKCwsxNWrVxEdHd1hXC3GadUewewAuN65lrWmLcHcY3ctXwdXTiguo7ncmdrnLL8Jy36C5K4POOfhT813R78NBgNEIlFANL+yshKFhYXIz89HdHR0h8HKBQIBG+SW0vW4lrWmK0FtcI63o3y5vJPa4q/rYDAYOMfTAwCj0QihUOjWtwGDu5pfVVXFan5UVFSH0weFQiHMZrPb9bpWoCOiAohAIOjsKrQLl9E0wW4DF4LFhosXL6KkpAQnTpxw+1i9Xg+Ae5Bqq14LQVIvHPtxk9tlMeR99R8AwKBb7wEAnDhxwq5B+vxfKzBp0iTO+fnrOlRVVbk1ukkqlXo8dNgdG4RCodsB3cPDw9Hc3AyFQuFu1ShBQLBojSu4jKYJdhu4ECw2XL58GUVFRZBIJG6PJnKm+VtHjQcATN63yyG9taEYkknLcPi1O+y2M8cwtNf+HHxmEABg2NItbFpbzd/0+GBMmDCBsw3+ug7V1dVu9XRLJBKPe6Hd1Xx3R9oymt/eCk208yF4CRat8QZqg+9gNF8gELjlOAGcaz6jxW11vT2YYxjc/eaw1fyKigo0NjYiKiqK07H+fM93R/PFYjFMJvfChzAEQvPVajXnc3qtQR1RAcQTT2wg4TKlK9ht4EKw2FBcXIzJkyd7JNTMSzRXW5ouHHG7jPbyUvQdhUF3zkHTqX3s9pCQEFRXVyMsLIxTPv64DlarlZ3+5g7h4eFobGx0e3lWf99L4eHhKC8vd+mIoh8kwU2waI0ruEzpCnYbuBAsNhQWFmLSpEkejcRxpvkLK0sAAF8mpGJGeZFd+rqvFzvNp71jXFH39WJEz/4Yw17ej7qPZ7Pb5XI5ampqOOumP64DIQRms9ntdjQiIgINDQ2IjIx06zh/30thYWEoKytzeU6p5gc3waI13kBt8B3FxcW46aabfKb5jK5Hz/7YTovbw/YYAMjKynK7LgxhYWGoqamxc5owI2uZmIW2v4NJ8yMjI1FfX++2wycQml9aWuqyXoQQt6chdiWoIyqAMEHSbIOVdTWoDb4jOjoaFovFo9EujY2NADpnDrkoazD4fKFD+d27d8exY8dgtVrRrVu3DvPxx3WoqqpCXFyc28fFxMTgypUrUCgUbk0x8ve91N40DavVisLCQsTHx/ulbIr3BIvWeAO1wXcolUpYLBa3nR+AvebbTqmb1VgDKZ/vdlsg5fPxQ1I6p4Dnspkfgi+SsuUzdO/eHUePHsXFixc5LYvtL82PjY11+7ioqChcuXIFERERQaf5rj46GM33pI2jBIZg0RpvoDb4DqVSCZPJ5LXmy2Z+CKHVDDNfCN1nD4Ivkrqt+c403F26deuGo0eP4vz58+jZsycA14tmbI5QYnLhZQC+vQ41NTVQqVRuHxcZGYn8/HxERkYGlea3N93RarWiqKjIozauq0AdUQHE3WWCgxFqg+/g8/moqKjwaDimNzYwcZw8CWreNgaU7XROPp+PmJgYzp57f1wHo9EImUzm0bGxsbFuN3CBupcIIWzDSQhBeXk5jEYjEhMTO/1Fi+KaYNEab6A2+JbKykrExMS4fZwrGzZHKDt0JjFxQTwJat42pkjb6ZxKpZLzNDd/XAeDweDxS3pcXByqq6vdOj4Q9xKPx7PTfAAoKyuD0WhEQkIC5yn5lMATTFrjKVxtCObRecF0HSorKz1ynLS14f0dzwOEQDazcxfSUKlU7a4+Z9seMW1D284Tb9Dr9R61oUCr5rvbYR0ozbdarXazOcrLy2EwGBAfH39Naz4NVh5A9Ho9O+e3q0Jt8B39+/dHXV2dR8d6Y4PpylGPV9br6Ljy8nKkp6dzyssTG0RZg9sNiC4QCDyeBx4WFuZ2UMVA3EvM/HEAUKvVyM/Ph0KhQHp6OnVCBTnBojXeQG3wHf3790d9fb1Hx9raMKuxxq2Xed1nD3r84dLRceXl5cjMzOSUlyfXQTbzw3YD7AqFQo/jPcnlcrS0tLh1TKA0v6mpCQDQ3NyM/Px8hIeHIz09/Zr+ILkWCBat8QauNgTzAhXBch369u3LjmxyF1sbWB3m8/HRtmfcWmjC15SVlbmt+bbt1eYIJawWC6weLsrgjeaHhoZCq9W6dUwg7iWFQuGg+WFhYdeF5tMRUQEkmHsPuMLVhtLSUuzfv9/PtfEMdwN9t0WhUKBXr15uxyFqizdzfjvzXmKcUc4cQswQUy7nxhMbOnKEMQ2Up3O6mUYqmHoEIyIisH//fiQnJ0MulyMzMzOoXwAp/+N60vyysjKq+R3gjeZ/27sfIqNCEWLQYdzzi8AfdoNXPcvuOrIA5ysuMSv+cNFcQgi+y+mPB0oKOPeQd+QIYzTfU6e8XC6HRqPhPF0lkJqflJQEuVyO9PR0r+89SmC4njS/oqLimtX8sLAw9OrVy+0A487wVPe7Pb4ZAKA2CzH3hu6Yue8kBspN+KHfIKfpOxod66tRVCKRiF2FriMIIeg+/zNUbfgz5t28CgDw0bZn8H2fgbDo9Zi442eEcXRqMTCa7+m1ZRaE4BrPNhDPtEKhYDU/NDT0utJ86ogKIME0VNRTuNqQlJSEkSNH+rk2nsGMmPEkeCDQukLP3r17ERUVhZycHFYs1Go11Go1TCYT2/CEhYUhJibGqaDk5+d3uJSzK3x1L3FZKdEdEhISUFJS4nJUlG15cUNvAgDoLvoukHpsbCyKioo8ngOvUCjQ2NjI+fwG6pnm8XgdLgFLCT6uJ81PTEy85jU/IiICOTk57Au4RqNBY2Ojg+ZHRUU5fUkvKipye0UdoPUDQyAQIDNHhe4ZqSAHfoH2tx8R+uF2t/PislKiO8TGxqKkpMRlD7lteUmPfon3tP+b0jGrsQabI5ROe/eZfba/naFSqVBUVMT5o6ItERERqK2t5dxmBOKZZj58qOZ3Pa4nzY+Pj79mNb+2thb79u3rNM2XzfwQQt7/gnGv++0S1v12CbrPHnQaFJyBy1Rtb4mLi0NZWRmnWLAhISHQWv5nh+6zByGbCZQ9OwQ7J9+K0ytXY4JmqM2+D+3SOkOpVKKoqAjh4eEe1V+hULi1sFKgpuYB16fmU0dUAGGGgLu7MlcwQW1offFVqVSorq7GgQMHAABmsxkRERFQKBQQCASQSCSwWq2oq6vDmTNnEBUVhezsbNaDbzabUVxc7NbS1760wRZ3nVFMemfHJCcnY9euXUhOTnbZW8KMpFKEehbLqT2Y2BoWi8Wj1QhFIhHMZjPn9IF4HiorK6/pQIXXMlQvHQnEi3JbuNrg7MUesNf8Q4cOAeCm+d27d8d3CamY1VgDs9mMq1eveqz5U/IvgFSVAm8tBQAUFdbhpIdxN9x1RjHpnR2TlJSEXbt2ITU11aXmMx8X4UIL/jL5RdxrU1+u9XZ1bZgXeE81nxnRxZVAPNPV1dVQKjtv6g3Fc653zXem7752fnOBqw2u4ufFxMRg3LhxqK2txeHDh9mV2trT/IiICGRnZyN63mboPnsQZrMZV65c8VjzS96djquVaoxcvsOhvgCgc+GQIk31QF0VkNYdPL77mtgRCQkJrOZ3NBK2paUFJe9Ob63vf8+x7rMHQQjBpF+3Y9+cB6E7vNbpsa6uDaP5ZrPZoxFrwar5ngS0vxagjqgAci3Ec6E2/A/m46Qjevbsifr6epw8eRIGgwEymQwZGRlOg9NxxVc2+HI0FNA6NW/QoEE4cOAABAIBUlNTkZSU5FCeKGswDCbuDYE7CIVCSLoPhTn/mNvHWiwWt66Hv54Hs9mMqqoqhIWFoaCgAIMGOR+K7QxCCEwmEywWS1DESLieoXrpSKCdUID7Nrhylrmj+Y2NjTh9+jTOm43Iy8vDHzdMQtZ3X3mk+bMaa1qDw6ZkQvjOTwCAXv/9czdWiK8/CPl8PoYMGeJS822n9Rms7tsN2NvozCElFAoROutD6L94xO36u+vA8tczbbFYUFVVBblcjoKCAgwYMIDzsVTzg4frXfOd6WZnBNZ21wZXzrKYmBhOgbEZzT979iwsNZeQl5eHka/ux9YFfTzSfN1nD0Kn06FnqtKhXm2nSDPn/Nv4BNx6p71ufL05D3fXV7tVdkcwmn/o0CEIBAIkJycjJSXFaVpX14HH4+HnEaMB2Le3zqaBO3NIiUQij6fMBZvmh4aGoqCgAH369OF87LWk+dfHBMQgwWq1ehUjIhigNnhGVFQUhg0bhjFjxqBHjx44fvw4EhMTcf78eY/y84cN7QUBt8V05Wi7QcMjIiIwZswYDBs2DE1NTTh+/LjTdHw+D3w+j3O5XLFYLB45oYDWZVrdWXXPX/dSUVERIiIicOTIEchksg7nwjMr6RUUFKCkpAR1dXVQq9Vs8ENK53A96eWOSbcEoDae0RnXISIiAsOGDcNLmib07NkT6d98jqSkJJw7d86j/PxhQ3tBwG1hpky4Sh8eHo4xY8ZgxIgRaG5uxtGjzjs4BDwCAY9wLpeho+DsZrPZIycUEFyaHx4ejiNHjkAkEnHS/IqKCqr5Qcb1pPk3vPBjAGrjGZ2l+UOGDIHx19fQs2dP/PR4b6SkpODMmTMe5eeuDbcXFzpsGz2+Bzv92ZcBzsPDw1F2259QOPk2tLS0IC8vz2m69mxoO6XQlo4W2DCbzR5PuwwWzS8uLkZYWBiOHj0KPp/f4RRAW80vLi5GbW3tNaH5Xo2IWrVqFZ599lksWrQIb775Jurr67Fs2TJs374dxcXFUCqVmDZtGl5++WUoFAr2uO+//x5PP/00eDweXn/9ddx6660AgMLCQqSnp0OpVLIR4xn69++PadOmYfny5d5UuVPxdDWvYILa4D3h4eEYPXo0jh07huLiYqSmprod06izbeCCUChE7969sX37duzcudNO+K26ZggEIf/9XwtBYg/s/eKjdvNru5y1K6xWq8fzrJuampCYmMg5vT+ug06ng0QiQWhoKGJjYxEWFoaqqiqX0/PUajWqq6uRkJDg0JC509hSfE9XeE47gqsNN/3ys59r4jlcbPDnKkRyuRxjx45FXl4eioqKkJKS4nZ8C1c2dMYIM1fw+Xz07NkTO3fuxI4dO+z0yFpzBfz/dixbDYBkwrP47aVb282vrean/PQtgFan53K5gr3nLBaLV5ofHx/POb0/nmm9Xg+RSAS5XO6W5sfHxzvUnWp+53I9af6vL07xc008h4sN7jrE3cFW84uLi5GWluYzzXfloOGJxBA8/x5gMcPy6gIAwOWLlXZpXE1x9gTbPJxpPtD6Pgu41qWUn75lO7GWy1v9BDf98jN2TLoFN/3yM3YuzAbQ6vS0bTMsFovHMXabmprcCnfhj2faYDBAKBQiLCwMsbGxkMvlqKysRFxcnNP0zc3NqKqquiY132NHVF5eHtauXYu+ffuy28rLy1FeXo5//OMf6NWrF4qKivDoo4+ivLwcX331FYDWkz9//nysW7cOhBDMmzcPEydOtJtn2tzcjH/84x948cUXvTAt+PA0gHIwQW3wDVKpFCNHjmSHt44ZM8at4/1hgyfT9LjEl7rhhhtw4MABxMTEoEePHgAAS9lFdo62UCiEKGuwz4JeFhUVeXQcEwPAnSG7vr4OZrMZlZWVbEPDDNUtKChwmr6qqgqEEGRlZfm0HhTfEAxa4y3Xow3+cO6IxWKMHDkSw4YNw4EDBzpN85lpEJsjlPgIwOaIZwBwt5lLvJdx48bh0KFDiIqKQs+ePQEAhl9H2mm+bOaHHmv+SI19D7A3mm8ymdyKM+Lr58FisdjFAexI86urq2GxWDpV81euXIlvvvkGFy5cgEwmQ25uLl577TW2fb+euZ70MphX73X3Ovhj+qCt5u/btw/jxo1z63hP7iVeXGtgdGYKd7lNB8u8m1fho22teu/rWI3Me35ERAR69+7NbrfVfFeM1DTZdQQVT5mGHkKxXftg+NW+rSgqKvLYBqPR6NZoKn9ofkVFBTvNPycnB4Brza+pqYHJZOrUFbP9qfkeTc3TaDS499578cEHH9gF18rJycHXX3+NqVOnIjMzEzfccANWrFiBH374gb0ZDQYDBAIB+vfvjwEDBkAoFMJgMNjlv3DhQvzzn/9EdbVv57V2NhqNBhqNprOr4RXUBt8iFos9ihHlzAZfT3HzFUKhEGPGjIFOp0NpaSm7PZiuA+BZgFhf2lBTU4ODBw/CYDCgqqoKRUVFKCwsRGFhoZ3OWq1WqNVqnD59GhqNxmUPCqXzCbZ73BOuFxvcDZ7tKUKh0Gea78sefV+OCBMKhRg1ahRMJhOKi4vZ7f66l77rwz2eki01NTWc4r/Y4mvN379/P7RaLaqrqzvU/DNnzkCtVrs1gssf7NmzB/Pnz8ehQ4ewY8cOmEwmTJw4kQ3qez1zvehlsMPFBtvg2f5EKBRydnbb6rAvrsOsxhooc4cjevAgfHFxLT548C3cXdc6SsqX7Qefz8eoUaNACLHrGOBqg227G66QISS0/SDohBCP2uqamhpER0e7dYwvn4e6ujpW82tqauw03zYYutVqRXNzM86ePYuGhgYkJCR0quPXn5rv0Yio+fPnY8qUKbjxxhvxyiuvtJu2qakJ4eHh7EMYHh6OuXPnIj4+HjweD6+88orDEoqzZs3Cjh078NJLL2HNmjWeVDEo8XQ+azBBbfA9kZGRKC8vR0JCAudjAmWDsxFPnjq8+vbtiwMHDqCxsRG9evVysMHd1ftcwePx3F5NQ6/XQ6fTub06na+uAyEEly5dwrBhw1yuQqLRaFBTUwM+n4+wsDCkpqYiNDTUJ+VT/EOwaY0nXE82BGqam1KpRGlpqV1Q747w5XVw5XTaHKHEvJtXdRgclys5OTms5ufk5DjY4KvVtO44exImk8mtc2QwGKDVajkFn7fFl5p/+fJlDBs2zGUwXGeaH4ilxDti27Ztdr/Xr18PlUqFY8eOuT3S71rjetLLYIarDYEKpB4bG4vi4mKXQb0ZmNGqsxprvL4OjM7bjoT67vGhaDp7DvNuXgXA9ysa9urVCwcPHkRTU5NTzW8PxvaRY7tBHiYFMZvAEzo/XigUwmg0drhqny1GoxEajQbp6emcjwF8q/kXL17E0KFDXcYAbGlpQXV1Nfh8PuRyOVJSUoJi6p0/Nd/tbrnPPvsMx48fx8qVKztMW1tbi5dffhmPPGIfRHLZsmWora1FXV0dlixZ4nAcj8fDqlWr8P777yM/P9/dKgYtfD7fo57QYILa4BntOW969uyJs2fPurXygTMbfL0Cnqs8TVeOelQW02MSERGBAwcOsDb4eiRXfHw8CgoKOK+oQQhBaWlphy8IzvDVvdTc3Oz0A4MQAqvVioKCArS0tCAtLQ2pqamIiopCeHi4R8uVUwIH1cvgoDNsaM95061bN1y8eNFrzff0A6I9hxvzwdK2HE/KYjQ/JibGTvN91RPPBOCNj49HYWEhrFYrp5FdhBCUlJR0quZrNBrIZDKHXm5CCAghKCwsdND8sLAwv2q+yWSCWq22+2s7Y8EZTLDcqKgov9Wtq0D1MjgINhsyMzNx+fJlaLXaDtMy+uytDbY6P6uxBuLoaJx6ZSX2zX0IIsv/4h75emTUyJEjoVKpsG/fPrdtmNVYg63fn2r90dzosJ9ZNCMuLg5FRUWwWq2c6k8IYWPyuouv7qWWlhZIpVKHvGw1v7m5GampqUhNTUV0dDTCwsLc6lR3l2DQfLesKykpwaJFi7Bjx44OV/RQq9WYMmUKevXq5TTAuG3wcmdMmjQJo0aNwvPPP49Nmza5U03s2bMH4eHhbA8ZMy1QJBLBaDRCKBSCEAKLxQKJRMJOF2RGUojFYphMJvB4PAgEAjYfi8UCq9UKsVhsl09tbS3MZjM0Gg07BFOv1yM0NBRarRY8Hg9SqRQ1NTWQSCQwm82wWCyQy+XQaDSsR9doNLLbbPMJCQlhX1hlMhl7M5vNZpjN5nbzEQgEEIvF0Ol0bD6EEISEhLD5WCwWmEwm9hiRSAQ+nw+DweCQT01NDVu2rQ0SiQRWq5XNR6fToaWlhc2n7bnQarWQyWQwGo1unQtn+XA9F0w+NTU1kMlkMJlMDueibT7tnQtX57TtudBoNAiRihHWawRKDmx1asPQoUOxe/duDB8+3OU5dWaD0WhE+ugp0BtNKD/0i9vnwvb+cnUu4oZOhFwmQfHBX+zyqTm6EwKBAAaDwa1zERkZicuXL6OmpgYhISFQhMpgsVphNJnR2Njo9L5wlo9IJIJAIHB6X4SGhqK0tBQREREd3l/MlDy1Wo3Q0FA2uCKX+6u2thYhISGshnT0rDm7v3g8Hq5evYr09HTk5+eDEAKRSASDwQCRSITm5mYkJiYiOjoaTU1NLs+Fs2fNaDS6pZ1dlUBrfnV1NdV8qvnta77Agoh7PkDhv2c4tWHw4MEdav6m9O648/wpB83vNv8z6C18FL87w+1zMbnwMoxGI6YU57M2bM7oAb7RACIQgAiEkM/6D0IFFhS8f79dPhXv/ckjzVcoFDCZTKzmhwvNsIIHo5XnlebfUnQFPB4PVqsVcrkcO8cMQNqAdDQ2NrZ7LpgpeZ2l+Xw+H/n5+cjIyHCq+RqNBvHx8T7T/C1fHEMIr/0PqYbmFnz11VeYMWOG3fZly5a1u0iQ1WrFk08+iZEjR7KxTgIB1Xyq+cGm+a6eSdv3/D179qDmkfm4p+CS03OaOOdD5L93r4Pme3ou7qgswWS9HkajETf9cQTf9uqHmVcvQjZvHf694wUsunEZhDzC3tue3F/OzkVYWBgsFgur+W31sj3Nn1x4GZ9n9sCUFSKIWlrsNH/t/lcAK4HVej/CwsIQcfc7CJVIOtT82tpaREVFdarmX7lyxanmi8ViNDc3Iy4ujm2XvNX87748jrAOnGf1Gg22bNmCe+65x257oDXfLUfUsWPHUF1djYEDB7LbLBYL9u7dizVr1rAXqbm5GTfffDPCwsKwZcsWj4e1rVq1CiNGjMDixYvdOm7gwIGIiYnxWEDkcjkrrlwemoMHD3KqV0hICKRSKeeRGsHItWKDTCaDxWIJWJnlh3cgbsiNLvdLpVLIZDJotVpOgfFCQkIQEhLCrubQeOp3Tj0tnqA5d8Ct+dEZo2+F1mBAxeHtTvczS6GGhIQgNDQUV/b8gPTRvl19JSQkBFVVVXZzrp3R2NgIgUAAmUzm1ugE23JCQ0M59SA4w2q1siuMyuVyxMfHOzTWFRUVHk/H6OpxHrhCNd9/uGvD12ndYBWLMevqRT/XjDudofnF79+LxIddd6IxDnONRtOu5m/p3gszrl5y0Pzaj2f7TfMbP50DjUaDbzJaA5HeeuF0u+m7z/8MWosAJe9Od5nGVvMvrrkb3RZ84VHdvkrNxK0XzwIAvsvpD1gJZhZcgkwmg8FiRVVBFS73GYh7Ci45Pb6pqQk8Hq9TNb+wsBBKpRKhoaFBpfnTp0/H+++/b7fN1bRBhvnz5+PMmTPYt2+fx+V6AtV8/+GuDfEPboCEb0Xpunl+rhl3OkPzO0IsFiMsLAx9Du4FAHzfZyBmXDrrkC71z5tQ9uEDDprvDV8mpGLq1Yu4/ewJfJmQir//d7rXm7tewdM3PMemS3p4AwiAgnfu8rpMW813Vy/vripjtSxu3qco/PcMhzRSqRTEau0wL7VazWqDPzX/+z4Dcdflcw7bCSG4evUqYmJiXL7nV1ZWehxqwxvNv+OOO/Cf//zHblugNZ9H3FDL5uZmh9VJ5s6di+zsbCxduhQ5OTlQq9WYNGkSJBIJfv75Z7ca08LCQqSnp+OPP/5A//79AQAzZsyAWq1GVVUVpk2b1q6XTq1WQ6FQsHGpAsX+/fs5rf7CDGXraDRYMMPVBq7npDMI1utgNBo5r6Bna4OvYiv5Cmaqnas67d+/H+np6azoMja0d4wnVFZWQi6XO/3Ia2howNGjRxESEoKYmBiPh90ygfqYDwouTkSz2Qyr1Qqz2Yzy8nIkJyc7FX61Wo2Kigq3V6XQ6/XsykoAkJGRgaamJphMptbelvdGQiZuf3rHgBeOYdV7n2PKlOBdnhmgmh8IqOb7D7PZ3O4KerZLbdva4G5cj45WF2pvP5flvpmpEa7qdPDgQSQnJ7PxQBkb2jvGE6qqqiCTyfBTSqZDfRsbG5GXl+dTzY+NjeWkO4zem81mVFRUIDEx0emsgubmZpSVlSE7O9utOtlqPiEEmZmZdvfLf8KjOhwR9X/NDXjzm69x++23cy53wYIF+O6777B371634654CtV8/+NvzeeiKd4SrNehI8231UVvbGjbRthqvLPpy7bXwhfafPjwYcTHx7N199d1qKmpgVgsxs+prauI2tqhVqtx+PBhyGQyKJVKv2u+7Tluq/kJCQlOYz21tLSguLiYXV2WK8yiRm01XygUto4cC4vqcETUC5pGrPxsM6ZPd92B1BZ/aL5bI6LCwsIchmGFhoYiOjqadUJNnDgRWq0WGzZsYOcbAq3BOT2Z275ixQr07t3br3MkA0UwL3XKFWqD/3BnBT1bG4LJCQW0X5/Lly8jISEBCQkJrDa4wlsHW2xsLLZu3YoBAwYgMjIShBBoNBo0NzdDIpGgd+/eXs/7Zo4XCAT4/vvv2fnnjH+fx+OBEGJ3vfh8PoRCITtNoLy8HDKZDCqVyq4+YrHYrdWRtFotKisrIZFIkJiYCIFA0OE5pviXYNUad6A2eE/bF3/mZbWjFfRsX6ptbXD3A6GjDz7b/R19sDijvfrk5+dDpVIhKSmpQz3yNnCuSqXCUrkCaQIhO/WC0XyxWOxTzReJRPjhhx+QlpYGAHY670rzmWlgfD7fqeaLRCK3NF+n06GyshJisTigmk8IwcKFC7Flyxbs3r07YE6orkBna40v8LcNgVgUorOvQ9u4RYyudaT5us8e/K/uPuiVDc50lNF2Jii4s32+iBdVUFCAqKgopKSk+F2PYmJiMOXhlVg4YRxaLlyCTqfz23u+RCLB999/z+rd9km3YOIvPwNo1cSUn77F/v372WMYzRcKhaisrGQdYra+EKFQ6NZCVbaan5CQAKFQ2OU136fenePHj+Pw4cMAgKysLLt9BQUFbIPtDt27d8e8efMchgt3RTqKq9UVoDb4F8aD7srxyowcajl3IJDV8glFRUUoKyvDuHHjADi/Dm2dT944o3g8HhQKBcLDw9mepdDQUCiVvlumnJmbbTab0b17dwwe7FngdY1Gg5KSEvB4PERHR6OhoQFKpZJzb3t5eTkAID09vdNfwCj/I5i1hivUBv/C9Jy60nzmw6Dpk/s55dfR6Cd38Daf4uJiFBUV4YYbbgDg/Dq0dT5544zi8Xi4fftW9O/fn30595fmW61WdO/eHUOGDPHonLe0tDjVfC4jB2w1Py0tLeCaP3/+fGzatAnfffcdwsLCUFnZuhy8QqEIihWeOpNg1hquUBv8S0eaz2gJVxu4ambb4OXOOhrcHWnbNt/S0lIUFBS0+57vS3g8Hp6bOxYDBjyJT+KS2RhQvtT8jcoEzCgrBNC60MiwYcNaz7mmya18WlpaUFpaCqDVgdbQ0ICYmBjOml9RUQGr1YrU1NSAB+L3p+Z77YjavXs3+/+4ceO8mhedlpbm9Pi1a9di7dq1HucbLDDxHNxZbjLYoDb4l169emHbtm249dZbHfbZri6n1WqRNXYqak/+HsjquYVGo0F9fT0qKiqg0+kQHx/PNk6A/XVwtTqfLwgNDfV47nVH2NrgTcPATCEsLS1FXl4eAODKlSvIyclBdHQ0ALAjTJkpd7YfHyqVqlM/ANLS0hymbQPA448/jnfeeacTahQcBLPWcIXa4D1tnRS2jovs7Gxs27YNt9xyi4OG2PZOa7Va9FjwOao2/Nmtsjypq6fOrLaaHxsb61LznX3weDMaiqkzIQShoaH4PjHNLyMvGBukUimrwZ6Uw7RL5eXlXU7z3333XQCwu7YAsG7dOsyZMyfwFQoiOltrfMH1ZoMvnfcMbbXM1lnEvOc703xbuNrgrm46OKAEAkhjoqG+ko/wrMwOj7U9V/r/xjltq/mMXf68l2zPaUhICJ66ZTUejY31eTmW/wY0DwkJYe3ypK1iNL+iosKl5jc3N6OpqclpbDOVSuVx7EBv8afmd/35bl2Ia6GniNrgX1QqFaKjo2E0Gh2E23TlKOuMShw+qTOqx4nS0lJcunQJUVFRUCgUGDBggNNGyPY62DrZgm2qYXswNphMJp/0UERGRiInJwehoaHg8XgwGAwoLCwEj8dDeHg4EhIS/Lp8t6fk5eXZNZxnzpzBTTfd5LAC0/VGMGsNV6gN/kWlUkGpVMJoNDr0Hus+e5B1RqU+/iWAwPWCuhPHpby8HBcuXGA1v1+/fs5HP9lcB1snm6/iRG2OUOKi2YgSof8+oBkbfBUEWaFQdDnN78qBuP1NMGsNV643GwIxVdCWmJgYxMbGsqslusKX16HtaCjgf06lzRFKhCQnIzwrk9Poqs0RStRbLej57VfsytRcNN8fyGZ+CGvNFfCVF9i6+fp63n3lPIDWUUm+IDw8HDk5Oaxji9F8oLU9uN40nzqiAggzpLujiPTBDLXB/6SmpuLYsWMYMWKEwz7GGSUWtT66wRaoHACuXr3KTsVoD2fXIdhs6QjGBl+JdNvRW1KpNOiCbTqj7TDoVatWITMzE2PHju2kGgUHwa41XKA2+J62L8qM5jsL/Ms4o0T8Vo3xNo6SJ/XriCtXrnis+b6wpaPgu76EsYHH4/mk86Graj7FOcGmNZ7QGTbYOr59Ecw82K5DW51LTU3F8ePHMWrUKJfH+NsG2/M7cXtrrCOuetznx285LazkLxucxbJqja/1TLvHeXJvMTYwcV29hWq+PYGdZHidY7FYgmopUU+gNniGKOv/2fvy8Cauc/1XI8mW5E023vcVg9mMwQGzJYGEQPY0CUuSQgJt07Tpkt4u0P6apO3NDe3t7W1v09IskD2QrUnT7AthsVltMGAwBoxXvC+yLGvX6PeHmWEkjaQZaUaLrfd5eLBmOed8Z3nnnO985/vmO1j9eEJSUpLHcK2Wi7VoOfARpJTTVI7pBgpKpRJdXV1uy0XVBbMdLBdrw04JBVztSyRJBvzMttiwWCz00RDqH5cQvGazGa+99ho2bdo06f1VRfgyNBAMGZTrdnB2/KpWqz1yvmH3Zlx8Zg2kuKqMCiWoVKrxoAtuykXVBbMdDLs3C6pQo5zwesMudQpnJ+xsYMow0Tg/Av8R4UvfwHX8ckWot4NaraYVHO4QKBnWa/oh4cBlTCUO5UrCG8SUwfkb4o7Xmd9iX/pYhPPFRcQiKoDgEto91BGRgTsoayW+iiKFQuGV7GJjY6EzXFUKhNLRtkXrHwGp14JQsTvapspntVoDWSxRQPUlnU4XNh+oPTXXIlom9/iMbuwc3nrrLdx1110O15944gk8+eSTHt99//33odFoJr2vECDCl6GCQMlAWSvxVRQpFAqvkYFjY2MxZrtqri/G0TZfsfSPJ2Hr3Q1pGnsIaqp8QnM+MwoUE2yLDaGObFB9ifJ9EkEETET40n8IOU5DFe+mZiHnw/c8PhNqMjDbpaKiAnv27EF2drbHd4SWgfrGMr95W4/8HaWyKJd+4856mG//omQwGo0+lDgCb4googRAdHQ0HbLRE6hwwp7OzFosFgwNDSFNBIdrQoCLDACg0Wg41QkXmEwmFBcXIzc31690KMWQTqcDML4jISTYjsn5qiCSSqUerWx0Oh16jn4OtVrtoujy97iev+9bLtZi//79WLHpJ27rRMx2CCQoGYQ6Ox5KWLNmDf7xj384XONiXr1jxw6sXr2aV0jacINSqRSM861WKwYHB8Oe84eHhwXl/KKiIuTl5fmVDjURFYtr2Ca63hREdpsNEhb/D3K53GMkJZ1Oh87t90CtVrsouvgc1yNJOyQS4LvPHsArey/g/DNrMfXRN13e56O4MezejP379+Omv19wWyditANb+W68Ek6bzzt8QMkARHbHJxMinO8Koef5BQUFgoWFD4X5JWmzgZBKYbWRkEkJ6NraEZuXS1vuREdHs/qDpRBoGfge+/a2eQJwk4Hvt4b5Ht93fAElA0EQEc4XARFFlADgGrKdC7nrdDpcvHgR5eXlQhRNcHD9QAmJvr4+DA8P+50OpRDhelZZCIUMpSTim45cLmd1XkvB2a+Sr8ooMY71DQwMQKVSebUGC5Wz+/6AkmFsbGzCHUOTy+WIj2e3anOHtrY2fPnll/jnP/8pUqlCAxUVFZye48KXer0e586d45xmoBEMzh8YGEB/v28KA+aklpqAcuUaf/0vMa2h2BQ7M8uzYTRYMO/l1/Dmwhsd7pfu+QxGo9HtDrKzXyVflFEjejPSN73qcG3qo2+yPstHYTM0NASlUunVGixQnM/mB0SoYz+UDCaTKbIomUQQkvONRiMaGho4rx0CjWBwPhVt0xlcfPqwcV8w5pfMb88udQoyV96AGnM8/je2El99dy7O3LYam256Gli1DQBwSC6H0Wh0q4gKtAx8vn0ajYZT/+Aqgy8Wq9TzNTU1uOGv57DJqR8IZSlMyUAFJRLCh1kEVxH5igYQJEmGveVERAb3YFP8+KrIMplMbncb5MXzBZGBTUnkr68mq9WKkydP0pM2NmUUlf5E60uRRcl4KNfU1FTccsstwS5KSGCi9fFQgLddUOZCgHpWLBnYJrqedmyzshMxd34eyL/+CgThqLj+97LlbhckynU7XGTY+alnp6xscFZCAUBVaZpfE3ar1YoTJ05g3rx5ANiVZFT6gexLYi0SKBnezvUc5jyCyYlQ40tfEEoyrNf0Y9MVxQ3A7uON4hemL6BAy0CVSbluB/13z74DyCrMwSfZraj51ndBJKjxRt3/IE457hphwc/exnvZ7i3AnGUIFd+AJEmirq4Oc+fO5fRsoNrBsHszrAYD9F2uCk1/QMmQ8uDL9LWIEko4RCyiAghPzkjDBZNNBiGi0vnyflxcHKKLK0BcCUNNpUFbWDnJwMxDWjiuBHL+AFB/U/+PNlQjpmwRfX/k1H7odDrWd9j+jo+Pd1g49fX14fTp06isrOSklJlIfYnLhzaU/HiJAZIk8eKLL2Ljxo2cTLYnAyZSHw8XsO2s8pFBiKh01PvO5fjykzP4xrr5sFptWHO5Fbszrh49VEKCuHv+AkKV5JAGtfhgk4G2+FrzPADvnD/80v1IeGAnfb/r+fsRLZdCq9W6vMP2tzPnDwwM4OTJk5g3b57fnC9k2G0xFwmUDHddakJvb6/HZ0PJj1cEgUG48SUbwk0GNs4OtAwU56wHAGzGLnUKSJMJBZo21E4pwV9nrcOWI89BZrVi+97/xAMLfgHIoqEF6Zb7PMngbZ7uy32mcv3u1gteOZ/LPM+TDM7ttkudAqmUwL0DPbxPGFDpyJRKvJ2Vj/VDnrmZDygZul+4Hy/kFuHnOv9P6ERwFZHVQgARao7nfEFEBs/go7hy9yylsLAbtLARckgIAtKsUux/ayf2vvwXAMCpU6fcho/e/+pfAQBHjhwB4Gipw/xbIpEAZgP9O2FaJQAJ6j58w/t7AE6cOIHFixdDpVLhyJEjiImJwdKlS1129d0dUQxEX7Lb7aKmT8kwMDDgdSHmi+P6cMKXX36J9vZ2bNq0KdhFCRlE+FJ4eFMyON/fpU4BKSWwtveyKOXhqriiwpJL//oBpFYrJFGORxaeuPWPINuOwh4dD0gJRK/Yij2/vRVf/mAaAFfOz/3ofdo/y54flQHgyPkj3cAVa6zMdf8DQIIjv7/L+3sY5/yqqirExsbi2LFjiI6OZuV8phKNWTee+pJQyqNAcb5Go/HK+b44ro8gvBFqfOkLQk0GJoew8QSbTzqpxA7Nqw+KXTS3oMp5zWNv4vDv10AxJRMpM6dDc+YMcEXxY/rkcbz5ZimSk5NRU1MDu93uoIBxtrb/8gfTXHxyUfe8cbe7+8y/qw7uo/+mjkkyOb+2thZRUVGsnO8OnvqSYfdmB+u2aIUMt99dgZZbq1D40WFO6bPhzrMnYTOZIBXoaCMlA3PDJgLhEFFEBRCh4DzPX0wmGcS2WvGWviRGDZhNsHU2utzTaDQA/G8HQhHjYm1Vec+3OMleUFCAQ4cOYc6cObBYLJg5c6bbZ9nSC0RfEttvEyVD1sKVOPfFu16fn4iWUBRWrlwp+iIw3DCZ+DLYcPbbwFywaDQa6HQ6rzL4Y7XCxW8EfS9KSv/+18xyJBTk4vfp3fiZdQ4wchmmL55yeVcwzp9y0sXaqmpbHSfZi4qKUFNTg1mzZsFkMqGystLj885phjPnU+1riYvD7aePI+tbr+LU72/2+l7EEmpyIVz40hPCRQZnf3zMscaV84XMnw1H/3ctACAaNmgaGqBIS8No3wCirObxI9dWE/b+Ry6qqqpc3hWK8/1BUVERDh48iLKyMhiNRt5+zTz1JecjlpRSLP/RH/lW2CtQpqf79T6dzpX2jZdZ0fTMWrydX4JbjlQLknYEVxFRRAUQE+G4SkQGz/BX0cC0mCEIGUi7AdLCCtguHXd4TigZ/CmvSqXCtddei08++cSn6C/eZBDiWKTYmAjjIQLxMBH6R7jI4EkBJKYM/ioabCYzrAP9mNv3Lv5tkaC6pR3Ra/JheuvbDs8JJYO78nYM6JCT7NkSQqFQ4Prrr8fHH3+MlBRuEYuY8CaDEMciAW5KQb7pUWnRUfMiSvcIWBAufOkJwZKB70aW87Eu5ngPuXa4IpvNYEDCnDmo2ViMhbs6AFk0rv31hzB+vsDFwjIQMnjjSoVCgeuuuw6ffvqpTwoxPjIY9GbI/vYR7zwAbkpBvulRaVGcf/elJp+DqETgHiE2Uic2Qo4YfUBEhqvwNSKeJzhbJ0GuBIw69PX1ITU1lX7OXxnYyu7L0TGZTIb4+Hhcc801vPP1JAP1XKgroygZ2qo/hslkCnJpIgg1RPgyNCCUDJ4mu74qPe7a9zFsT30fAPCvj84jNzoK9v4mbI+fAvWVhcl6Tb/fMrCVnXl0LCWePUKrMwiCQHx8PBYsWMA7X08yUM8JoYwS00cUzfnP3ofR0VHR8okgPBHhy+DAecxzkcFfv3S+8JRlZATt59ux7vV2+pokPh2PxyXiv1c8DkKlptMORDus1/Tj85ICj3VBEARiY2OxaNEi1vue4EkGZn5jHZ2IycnmnT4wrsAU0/KUkoEkyUhQIhEQqdEAwmg0wmg0BrsYfiEigyOEVpLIi+c7WkXJZIAiFhnlSxye8yYDV4WSED6LpFKpT+95koGK3hfKSijAUYbIByoCZ0T4MjTgqwzeIvQJAdVPvsLxY61Yr12IDQt/ji0rfgtp2nT8aN5DDuXwJgNXX0TM5zRjV5Xniijuix4xON+wezP9TwiwRdfyFcwFEyVDZFESARsmM1+GEtzJwLS6YlO8iOHTzZmHMsYc8yWiVPif2/6ET358NQqdct0O0dvBbjRg38wSyGTe+VwMzmfC0O17pDvqODYzaqK/YH6HmJwfgfAIP7V3GCMmJibYRfAbwZLBarXCarUKklb0FQd2/qZHkiSkhRUwnT/qf5mmerYoskulaGpqQmlpKQD/28GdgoeyihLLEomZ5kQaD56cGIa6VVcE4mEi9fFAw2azwWq1YlfS+LFff6LgsHE+l3StJIlX46fQz5Ck1SUdXxFz35UJs92Opfk/BEwAQCIeesyHFtIMJeZuP4Bp08adlfsbBYpNwZOgioJ+1yao1u/kZYnE5wgNM01/+hLf43ZiWUVRMtBH9FjAFg0qEu57ciDC+b6D4nyKG8fe8F0pzcb5077zMv54/B+QKRVYdeBr1vdI0oroNc/6lbczrFcUGNR3ZFdSGp77+Of41qr/YjwlwZSUNNQ9no6ysvHgE2JH/pMolLi24QInfvLV/yfXvqRgce/B97gdl+d8ObZNyaDX6zlvPijX7cDOT7fwzmsyIqKICiD0ej0AICEhIcgl8R3BkMFms+HChQseJ358YDCMR4pTKpV+pXNw13YAQF1dHafnF929cfy9d192vWnWe3xXAqCpafx8ckVFBf2BCse+RFlhDdR9BUBcGcR2nk2NB7vd7vYDFVFCTV5EON83kCSJ8+fPY2xsDK2kDQDwtDoZK7/6zKf02DifStcTfzs/s/8/yr2+w8Sy//fB+Hv/ebvrzeHxoxmJEgt+cvE9mPr6sW3xD/AH8guMmmU4n5CN8+fPY2BgAOXl5bDZxssiRDswJ+NW29VdXoPZCmWUzONkfZc6BeesZrQRMtyvHeS0iKEWFD3P3uOzDHwn82Ipf6jxALi3go04KJ+8mKyc7+94I0kSFy5cGLeeucKNMaufYOdODmDjfKuuFzFZmVA+/C3U1dXh8xU3uX5TruTNleO5YOoXHzuk2R8Xg7jkFJTZu3FWYwGiYgCzHu29ZbDrhzAwMICKigpBOd/bsXJP95XrdsDWfx6SKY0wvfVtXpsWXPtSbF6uyzW+PMqlXL70US6cT4E5DiIKKG6IKKICCLEjeAUCXGQQ2neSVCrF9OnTaWsgf0FZr8THxwuSHlcQinFHsM6+NeTF8+l7FJz9NVF1aTQaceLECYyNjcFoNGLVqlWsZ7C91T2blY6vx/TS0tLQ2dmJ7Gxu57upfAMRClXsMcdMfyKM7wiExUToE1xkENpRKEEQKC0txYwZM7BAp6Gv+7rYYeN8ZrruwOUZTyCmNIyn48T5ynU7QEwpHP+hisK03q8wNqTBjSU5SL2UhAM5C/Dn538FiVTmwvkrV65kDZ3tre6Zk3SqDp2PMSg5HM9br+lHc3Mz5HK5Q1qeQOUbyPDXQi8CKOXcLe3NAPj5C1mv6Y9YRU0STBbOd4a/fZsgCEybNg0zZ86E6YurfEnxFt/xw8b5rW858vAlmdyFm5l5cwHz2J2n8jGV+wsut9PcS0wZv//C95bhtmUlAACz2Yy6ujqvnM8H3r4PTH+BzuXeCWDhiaMOz3JFIMeD0BsAVH30PncvAHA+mrdLnQLDFeVeZFPCOyKKqABCoeDmDDSUwUUGMSxAhDybG6x28HQcDnB/hIt5TaFQoKqqCkajEYcOHcLly5eRl5dH3+d6DMzTM97K44yioiJ89dVXSE1N5fWxnEjjgSRJn8/QRzBxMZH6uCcIPdlyt8B3N9H3tkgJVju4qxfqunLdDvTs/CbMmtsQpVZj07od+Cz+bhh2Xn2P4nyz2UxzfkHBVeeyXJWAnu4zy2PYvdnrgq+goABfffUV0tPTJw3nU3ViNpsB8Le2jSihJgfCuY9TCIYM7jh//HgTu5WOJwUVFxm4jklvx7m4pEMpoyl44uOoqCia8w8fPoyOjg4UFRWJrtjwFISDJEl8/fXXyMrK8pvzw0UpT9UHxfkajYbT5gMlW0QJxQ0RT4sBhF6vdzDxC0cEQwahHYKGajs4K308Oes+ePAgsrOzHZRQbGkIWR53IAgCixcvxoEDB3gdnwzVduADSoZQdVwbca4YXEykPh7qoCb5bA6q+cgQCAflFKiJatSVsNienHUfPHgQ6enpKCgoAOA42RVqwss1HSbn87FyCpe+5AlMGZi7/YHsN54Q4fzgYqL18UCCre96OuZEKeF94XxmMANvDq7Xa/p5KaHcccF6TT/03T2cueLw4cNISUlBUVERgOAqNgiCQFVV1aTnfOY8n805ejgo2EINvFZO27dvx+zZsxEfH4/4+HhUVVXhk08+oe83NzfjrrvuQkpKCuLj47FmzRr09jo6Aj106BDKy8uRn5+PHTscG1AikUChUKCtrc3h+p133okHH3yQp2ihB4VCEfa7JREZQgc5OTnBLgINlUqFa6+9FrW1tS7j1x0mQjswZQg1RZROp8P+/fuDXYxJjYnWxwFho5Ex4ZwuH4sT58mfc/lCtR341CNJki4bD8EExfn19fVoaWnh9I6Q7RAsxQ8lA9vmQ7CVUXq9HgcOHAhqGSY7QpVr+MBZBiGjkTHhT7rMY8abVm1zSYdLO/C1iOIK53Ttdjt0be3Qtbbh8CPfx7rhPk7pWK1WeuMhFMDk/ObmZk7vsLWDr8oaT31FrHkJcFUGsX3O+gK9Xo99+/YFuxh+gdfKKTs7G9u2bUNdXR1qa2uxfPly3HHHHThz5gzGxsawcuVKSCQS7NmzBzU1NTCbzbjtttsctNybN2/Gr3/9a7zxxht4+umn0dHR4ZCHRCLB448/Lox0IQYhI78FC8GSQchdvonQDvHx8Th+/Lhg6Qnh10smk+G6667D6Ogojhw54rXNwqEdvPnNomQIlV1okiRBkiTq6+tRX1+PRYsWBbtIkxrh0Me9IVAyeNp15grK5N85HT4yiL2jSU2Y+U6aExISXDjfn4m3EH69ZDIZli1bBr1ej0OHDgWU88VqJ28LY3ecL0T/9QUU5586dQrHjx938XkTQWAR4XzPYPKfENac1HE153S8ycAcq2I4uGaiv+YgbAYDMn/2CXStbRg4fITTe2q1GrW1jnNyMRSCfEBxPuUeJJCc72tf8VdBxeR8phWskNbIfEBxfkNDA2pra8Oe83kpom677TbcfPPNKCkpwdSpU/HUU08hNjYWhw8fRk1NDVpbW/HSSy9h1qxZmDVrFl5++WXU1tZiz549dBpjY2OoqKjAnDlzkJiYiNHRUYc8Hn30Ubz22mtoaGgQRsIQQuQDFRoIhAy+Ov7miuLiYqhUKjQ1NYmajy+YOXMmCgoKvFrjiN0Ozc3NfkUb4dKGzA9UMC2ijEYjvvjiC1RXV9NHeJYsWeK3g8sI/MNE5MtgLbj9QSDawZ2jV2cw649PPRYVFSEmJgaNjY1e8wg0ZsyYgZKSEuzdu9fjwkTsdmhpaUFcXJzP73NZ5DFlCDbnf/XVV6iurkZ1dTVSU1OxZMmSsLfGCXdMRM4XYsHtTfku5Fiy22xBawe244KKtDQoMzJgkcpxe30tUqoWckqrsLAQCQkJOHPmDGsewcSMGTNQWlrqwvnObSx2O7S1tWH/Tbd6fU574aLPeYQK55vNZgfOT0pKwrJly8Ke832uUZvNht27d2NsbAxVVVUwmUyQSCSIjo6mn1EoFCAIAtXV1fS1xx9/HNOnT0dCQgIWLlyIsrIyh3QXL16MW2+9FVu2bPG1aCGL2NhYxMbGen8whBGRgRvEcNjORGxsLGbOnInLly/z8svEhLx4voMllJBlTk1NxbRp03Do0CG3z4jdDpcvX8bMmTN9fp9LnTBlyFq40ue8/MHx48dRV1eHxYsXY9myZViyZAnS09ODUpYIHBHhS9/gy2TPk4KMTQahFTieHL2yga8yLzY2FjNmzEBvby/N+VQaXGVhHoXhsrjkU0fJycmYOXNmUDm/o6MDs2fP9vqcu0UxlzqhZCBJEgXf3eVzWf1BfX096urqUFVVhWXLlmHZsmURzg8RRDjfMyieFmIzg2282ocHsHdWKVSXm11kEEuBw+QT5pFB6lp8STGiEuJ5K/NiY2Mxffp09Pf3036ZmIElxACfdJOSkjBz5kwcPHjQ4TqTW8UeD21tbci/Ejnckx+v6o2bfK6zUBjTp06dwtGjRx04PzMzM6hlEgq8o+adPn2ajtoVGxuL9957D2VlZUhJSUFMTAx+8Ytf4L/+679gt9uxZcsW2Gw2dHd30+9v3rwZ69atg9lsRmJiImseTz/9NGbPno0DBw5g6dKlvksXYqAmj+orjknDEcGQQWgNdKi0A9Pihq8SiJJhyZIlOHbsGO1IkA/EVpalp6djcHAQnZ2dyM7OdrkvZjuQJAmLxSJ4us6gZCBJEl/s/DPa2tqQkJAAkiSRlJQkev5arRYmkwmLFy8WPa8I+CNUuMYfBEuGDxcuxWmZTJAFS7DbgRklyPlI3Lv5Jbi79YLXNCgZFi1ahLq6OpAkicWLF/OqH74LIb51n5qaisHBQbS3tyM3N9flvtjtwJXz/elTTM7/+EflQeF8g8EQ4fwQRbC5RgiIIQOb3ySYjJAolPS1yp+9CyLxmF/WV18tvAbX3TAdoxYrJDpd0NpBuW4HDG54hmv0O+d5PsX5gY6c5wmpqakYHh5GW1sbDs6Z79LOQvUltkh7u9QpSH13N6f3r3v3LRgyfFPWUzJYrVY0NzfDYrEgMTExYJyv0+kwOjqKJUuWiJ5XMMBbEVVaWor6+nqMjIzgnXfewcaNG7Fv3z6UlZXh7bffxiOPPIL/+7//A0EQWL9+PSoqKlwUCTExMYiJiXGbR1lZGTZs2IAtW7agpqaGt1Cjo6OIjo6GwWCASqWC0WiE3W6HSqXC2NgYoqOj6YVqbGwsdDod5HI5CIKAyWRCbGwsxsbGQBAEoqKiYDAYoFQqYTabYbPZ6HfY0pHJZJDJZDAajYiJiYFer6edsBsMBigUCoyOjjqkQx2foUJE6vV6Oi2j0UjLAABKpRJjY2NQKBS0uSBbOtQ1qVRKy8BWFwqFAjabzWNdOKejVCpdZPBWp851odfrWeuUTQa9Xg+TyQSNRsOaDte6oNqGkkGr1brUhXM63uqCrU5zFq0GQUjQVv2xx7oYPL4HCoUCmZUrYDKZePUvKm+DwYBZs2bhxIkT0Gg0vOuC2b+81QVbOgVLb0FP7R63dZGfn48jR47QOwrMujAYDIiJiYFGo3HpX1zqQi6XQyqVso416u+BgQHIZDLOdRETEwODwQAAnPoXJUNzczNmzpyJsbExdHd3IyoqCkeOHMGCBQsQFxfnc/+i6oIkScTExNB10dPTg/j4eJw4cQJz586l+cp5rFGcMtERzpxPEESE851k2D1tJuzR0bCoVHg9OQM2hQKAHesunfeb898vmwOp0QhbXByMRqMgnJ//vbchldjR/Lc1rOmQUileySnAnWdOYuSVbyJn04s059vT02HUamEkSc6cP2PGDNTX1weF84sffQuXd2x0Wxe5ubk4dOgQ4uPjg8L5fX19iIqKwkdFpbiluUk0zr948SLKyspozlcoFKJzfmxsLE6ePIk5c+ZEOD+MOV8mk01qzv9w2ixkZCeivKoI1R/UYYSU4cdVP0K0FFDKrIhb/zyU0vHjXp07H+LF+RobgQOH2jDt/+VCiXHFbfH3dsFgIxAvIwXjfGZd3DvQDZ1O5zAmZRI70h54Fv/99dOQms245cJZui7iZeP5c53nv5FfgjvPngwa53uri+zsbBw6dAiWuDhaLqE5f3XrBVgsFof+tbr1Av63sAQ5SgXuaTyN2PUvoHP7Pex1ERcLo9HoN+dPnToVRqMR586di3C+QOCtiIqKikJxcTEAYN68eTh27Bj+8pe/4Nlnn8XKlSvR3NxML/7UajXS09NRWFjIu2C/+c1vMHXqVLz//vu8340ggmCir24PL4uci/v+7XeeTAd6gUT7wU893icIAvHx8Th27Biio6NhNpuRkpKC/Px80ct2yyM/RxRpQ9uxrwEAxdfeBrPFip7arwTPiyRJqFQqZGRk0B/r9PR0nDhxAsuWLRM0r/r6eshkMpw8eRI2my1obR9BBGLhtroj6O7uRnFxMT3h+teMOXg7Mw+3XGz0ngAD7+QWwRIfj7tq3R8Z8xfdOx7gxflNz6yl/57/pz/APKIF4kL7OM+baVmwqWLQcvakx+cIgkBiYiL+VDYTGNNj2btvYcqUKT7NA5n4YFYFJFYr7m057/aZOXPmoOSbf8KlN36Gtb2XkfXgDpjtElx+/gG/8mYDSZJQKpXIzMykOT8tLU0Uzj958iSkUinN+aEWoTWCCPjgG5eaQNYdgOmtfyAlNR4jPXo0/nUd2tvbUVJSQnN+yfd3I3njy2jffq/XNCl+kthsuKw14MEt7+HkX+5zeOa/9/0ewEaRpAL+WTwdEpLErU0NiJYTaPrL3ZBI1uLDkjJ8MKsCUqMRt19qcuB/LrjjTL04BfYC9TdfQozUhovb7/P4HEEQOHHfBozKCPx2SiqWvvMmkpOT/eZ8AMj9zuu4vGOD+/uEDMW7XwMAaF590GdXJVxAcX52drYD5x8/fhzXXnutoHmdPn0adrud5vyJDIndz3iEy5cvR25uLl566SWXe3v27MENN9yAxsZGlJaWei+MRIL33nsPd955JwDgZz/7GT766CMUFRVhypQprHkwodVqkZCQgJGREcTHx/sgjbjQaDQAPJso6nQ6XLx4EeXl5QEpE19wkUFoDA0Noauryy9/P0yIKYMQ0eec02NLy1mGmpoazqb6QpeRC/R6PVQqFUiSRF9fHx3dRyqVitqXqqurHcxZ3dWnr6DaYXh4GIODg5g/39HB+ZkzZ6DT6VBSUgK1Wu33AqKzsxNDQ0OYPXs2enp6kJqa6jFNJidaLBYkJyfj/W/+EtEyucd8Hnl/O555dSduueUWv8orNiYC5+v1epw7dw4VFRWBKRRPBIPztVotWltbOfn74YJXcgpx++nj+CS/xMGvEpuPJb7HtrhEn3P2R+QpD3fHNvzhfCEi5FEycK0fNs6vrKyEXC73uS9xKYMz53M9BsMVVDuMjIygr68PlZWVDvcbGxuh0WhQWloqCOd3dXWhr68P5eXl6OnpQXJyMmQy93vITE4ExqMtvhCfBJXEczl+OTqMP//zXdxxxx1+lVdsTATONxqNaGhocJkvhAoCwflk/UG0/uonOHv6Mka1RtzW2eL32ofJD2kPPIumZ9Yi47vvOvhVYvOxJMZRN2d/RDs/Hfd7fMfZU1BlZnBKwx/OFwJ8vhu71CkwkiQUBIG1Q70YGBhAbW0t5s2bh+joaJ/60i51Cjat2ua1DM6cLzSodtBqteju7naJUtfU1IShoSGUlJQgKSnJb87v6elBV1cXKioqeHO+TCZDTEwMno1LQpyXcjyu0+Dp3btwzz33+FVef8HLImrr1q1YvXo1cnNzMTo6ijfeeAN79+7FZ599BgB48cUXMX36dKSkpODQoUP40Y9+hMcee4yTEspdfs8//zxaWlqwdi0/DXIoItjOzoRAMGQQevcv0DK4U354ug5cVRSxPeePDIFUQFFQqVQAxtsyNTUVCoXCr4h2XECZrTLhr+w6nQ719fUAgLS0NAwMDMBkMkGtVrNOoGbMmAGtVov29nacPXsWJEmioqICUVFRGBgYQHJyMm3+S5IkmpubYTAY6KiIzmhtbcWiRYsAIOKcNgwQ4fzgwFnxc9/AuJ9KpgLD+W/qHTZfFHzhrPyg05dIAJa9P+cJP5vyxJ92EGKhxbdOmJyfnp4OhULh1i8onzJ4cqBOHW1iwl/Z9Xo9jh8/DuAq51ssFsTHx2Pu3Lkuz0+fPh1arRYdHR1obGyEzWbzyPktLS0YGxtzy/mXLl3CwoXjUbYinB/6CEe+dEYgZCDKF6Hwo8OgbGZ0Op3HiJvesEudgpi8PCzb9SrU33wJAy+Nj3vm+Hf+m+Jdb8pqXzYqdn66hVaiMPGvGXOwfriPUxofFY2vnQkbGZRItXy4k+JmqpzUPH/KlCl+lcFdPVJg43x/wcb51Dx/3rx5Ls+XlpZCp9Ohra0NTU1NsFgsqKiogEKh8Mj5hYWFrGOtubmZVnZNBs7npYjq6+vDhg0b0N3djYSEBMyePRufffYZbrzxRgDjWsGtW7diaGgI+fn5+NWvfoXHHnvM58IlJSXhF7/4BX75y1/6nEYoIeLEMDQgpgxMRQfTGbm3Z91dt1ysZU0nnNuhqakJU6dOFV2G48ePC77j2NbWhqlTpyIpKQkXLlxAYWGh192e+Ph42prPbDbTjoZTU1Nx6dIlh2dzc3ORmJiI2tpal+MdJEnSfmXCPVzrZEE4j1MKwZLBn0UJE+s1/Zx2+Ndr+rE7MQUxsdGwj41CEhPHKX3mZN1TVB7nibpzGjaShM5ocVggMRHOfampqQlFRUWCyOBpQVZXVycK5xcXFyM1NRVNTU2cOX/GjBkAxh3cUo6G3XF+dnY2jh49iuuuu87hHkmSMJvNtF+hUML+/fvx3//936irq0N3d7fDaYbJjHAepxTCUQZaWfHbgzDs3syJ83d+ugUkJPjWqqcxpDMhKTba7bMAf2U8ZQUVnZwMxfRpWF2zD2Pt7Zzft6nGfSkTo6PYpU5B7kfv88o/0GDWz4ULF1BQUOBXX6LSW+/hmbq6OsGtyTs6OlBYWIj09HQ0NTUhPz8fSqWSVQbqm05FtQVcOb+lpQXMw2dMzl++fLlDetQRfyogXChBLM7n9WXbscNz6MNt27Zh2zb3mktvYDsluHXrVmzdutXnNEMJoTaR8AVcZRD6CJRQixIgOO3gS31Q77C9F659iSRJdHd3Y/r06aKe5dZoNLRDQ6FgNBrR1dWFgoICyGQyn2SIiopyiG5YUlLC+lxeXh6qq6uxcOFCuq2PHTuG6dOnR5RQYYRwHadMcJVByCNQ/ljBslnMcJFhlzoFsXHRKChOhf1cPSTz3Efs5WI1xVYfTIse5/frWwax5FcfsIYk5yqDmPDVUowkSVy+fBnLly/3yJd8j/45gwpvLjTnd3Z2IicnBwRB+MT5MpmME+cXFhZi//79WLhwIb17XldXh6lTp7JaSgUbY2NjmDNnDjZt2oRvfOMbwS5OyCDY41QIBEMGfzifTXHPRYb1mn763S9PdWLNoiKPz3lSiLC9s0udAkKpRFxJMSQSCbQXLiKhdConrtulTkHC3HLoL18GRkcBAF/cdDMW9HVDFiA+8Oeb3tHR4ZXz/T0yzgw4JRQozq+srARBEKivWgarSoW7zp/hnAZXzp86daoL5x8/ftytpVSwIRbnhz9jhhEm0wdKSCWU0EfzgtEOvtSHp3fCtS9duHABU6dOBSCeDG1tbejo6KCPMwgBs9mMAwcOYPHixQ4fPbFkyMvLQ2JiInbv3o3MzEw6+ENmZqYo+UUgDsJ1nDLBVQbnyaS/igV/wcyX66IEAN5MSsXpFd9wuU7B09EwJtxNrqkFirNiJzEmGm88tpz1HQB4v3D8mMYDfZc55e8JvrSNr+3Y3NxMB7jx1g6+5tHe3o729nZcc801Pr3PhkBzfm5uLtRqNd555x2kp6dDJpMhPj4e2dnZouTnL1avXo3Vq1cHuxghh8nE+c7wpljwpsz2d8OZyneXOgV39XS4fY5ZDsoCdeP/7cXG/9vrkA4FT5au3kAaDDD29WFt8bdgf+IADLunuv2mOF+3aTSwaUfxwJXrNTU1+PT6lbj1SDXvcvii9PFVQdTc3IyionGlnre+5Ou8obOz0+HYshCwWq04cOAAqqqqHBRBEqtVlHGdnZ0NtVqNd999F6mpqYiOjkZsbCxyc3MFz0sIiMX54c+YYQTqLGs4WzREZOAOf5Vx7pyKy4vnIyFGiYv7/k3L4GfMgYCht7eXPnImdDuQJDl+jGLxTSBU8YIpQ/v6+nD69GksWLDAZeeFiwy+WgdSPkjS09P9PmcfQXAwWflSCCWUL4sSd0oiPjKsHepzSIdt8eROLq4Td7b3C9PjMePHb7Omo1y3A/ErH3eJtsQmL5c659ouQrRjd3c3J873NY+WlhaUPvQMpOllMOwWxmFtX18fGhoaUFlZ6RPn+2pJQHF+cnIyUlK4KTyFhMVioS3LKERHRyM62vORpQiuYrJyvrOi493CqTAPDbv1y+cvKF5mUxIxj2Nz4Rrn49Bs43f8mN1mnyxDdc2XoK/7ttv7bOmt1/RjsKcHErljYJkFz/zZRWYuXMOVj4QIbHH58mVOnM+WB5e6bWtrw8WLF9F39zq8y/Edb6A4f968eQ5KKKovGY1GQb9bFGJjY1FRUYGEhISg+IMKBc6PxIANIFQqVUiaWPNBsGQQ8mieEDJ48/8kNvQmMzIX3kT/dnbKHaogCAJ6vR6A8H2po6MDg4ODgGL8I8K3jcxmM6xWq8O15uZmtLe3Y/HixawRerjI4I9CzGAwQO40EYkgfDBZOX+9pt9hgsbVikgoOE8O+crgXH7Av11xIWCwEch95G2Ha2yTYMraKlRAEAR9PMNdO/ha3vb2dgwMDECSMm5ly7eNPHH+woULWX2CcOlL/izixOD8ezta6D7t7l9S+Ry88847SEhIcPj39NNPC1qWiY7JwPlsHMM8UrxLnQJ5XLxo1rBsfOE85vi2w85PtwgePY/2ceRjPcQlJSE27qqvQoIgMGWeqz8k5bodon+f+HC0VCr1yvmeyuspr87OTvT09GDp0qU+1avVanXh/JaWFrS1tWHhwoVISkpyecdTXxLiW2swGOijeULh7pbzXjl/yvx5eO+994LO+RGLqACC0gwL3eECiYgMgQWbEsNysRZJs8ULVSomrrnmGijzZwBRMRg+tR+AcO0wOjqKhIQE2C4d5/1uT08PamtrIZfLcdNNVxV8HR0dLg5kmRC7L7nbhYkgPBBOXOMOQskgRDQ6T2kD7if8vsrgbqfan7J4A9tiyLB7M1IfeJb1eW+R5PyBEGlfc801iF25FZLEXPS//BAA13bwta5GR0cRHx8P09sP836X4nypVIqbbrqJdgEQbM7X6/VB4/x77rkHzz33nMO1iDUUP0xkzqe4ILa4CLqLzR7TsNtsvCwDubrgoMqwadU2bPKQPt92YB7Vc8b4tc0uXOhsleWrhY87sMmwS50Cg3bQZ8WTt+8wW7AMvt+ABQsWYN++fZgzZw5ddud28NQvPJWP4nwqPT7129fXh6NHj4IgCKxatYruc21tbT5zvhBzmrGxsaApr++66y688MILDtcCzfkRRVQAweX4lJCWP2IgGEfAhPYRJYQMnqxc3B2p8wXujnW1HPjI7zSCgaioKFg6m3DkyBHkVV6Pxn0fsVoa+YLLly/TETy9wdlc+OTJk1i5ciWGhobw1VdfITMzE4ODg7RvE3cQezxUVFTgwIEDuPbaayeE74nJhnA5MusJnmTgqnThO1mjOJ9P2GxP94VoB08TZ+W6HViYYMV33vx/HtPgUl/uFm8X/rbO7Tts1lt8HOt6gr8T7aioKBj3/DeOHTuGwvW/R8OOHwjG+Z2dnX5x/g033ACtVouvv/4amZmZGBoaQmFhoadkRB/T8+fPx4EDB3D99dcHnPPlcrlgbTNZMZE5n1JMR8V7t3bSd3bC0HDVQorteXvbeWBKOiSxV/ucct0ORMulaN26APvv+yZuOVIDKWNhTKXjSQnlSQY2cHUezvbbm0LIn6NunmTw1XqLC5+zBdngA5lMhuuvvx7Hjh2DyWRCcXGxYLzS3t7uN+frdDp8/fXXSE9Ph1arRUFBgcd0xB7T8+bNm9ScH1nZBBDhbq4LRGTgAsvFWsiL5/ulkPJ2rIyPDKGihKJAEASqqqpwvvpTNDU1oa2tDfPmzfOLgIeGhhAbGwt5/myc+PANSKVS9Pb2QiaTgSAIqFQqzJw5EwRB4PDhw5DL5SBJEjabDWq1Grm5uYiKikJ6ejrS09PR09ODjIwMryFnxe5LKpUK06dPR0NDA8rLy0XNKwLhMdH5UgwLpzenpOKWj98CKY3lnL6355gyiGGZZdi9Gf2Hj+BI/VTomi9h3UA373J6W9Dw6UtCHzHxFwRBYMGCBWh6pRiNjY2CcL5Go0FsbCyUt/8Bx/7rZkilUvT3j9evTCZz4XypVAoANOdnZ2dDoVBAoVBgxYoV6OvrCwnOVygUmDVrFk6dOiV4WPIIxMdk4HxvC3MuPvX+nZON1bfPwflWLVoGScz9+99ht9sduOv2evdzV28cx5RBqIiulBxMxdUmL4omf/Jla4e1Q70+pxdIUJw/ODjoMM/3x1JQo9EgJiYGbW1tGBkZgVwud+H8srIyyGQyHDlyBARBgCAIWCwWJCYmIiMjw4Xzs7KyQoLz58yZg/r6esyfH1y3L8FARBEVQIyNjQGA104fygiWDEJainmSQSjrIbGVPxOhL8nlcsycORMAsG/fPsyYMcNnZ30jIyPQaDT4+Pn/QXZ2NkZHR6HRaLB48WIA44qqw4cPw2AwoKqqit4B0Ol0GBoacolSwbUcgWiHzMxMtLW1QaPRhHV7T0ZMhHEaKBmoyf26i6cwuvVB2O/9oWBpe5JBqEWKKjsbtx6poX8zFytsyi++R/jYZCBJUnCLYTEhlUpp5dC+ffswffp0nyOBarVaaDQafPCDuTTnDw8PY8mS8WPrGo0Ghw8fxtjYGKqqquh6c8f5qampnPINxHhIT09HW1sbhoaGWH2WhAJ0Oh0uXrxI/25paUF9fT2SkpJCNupTIDAZOF8In6Q3Ve+H8bffhWlEi8L8bFzc/gw0678F0mYDcUVp7A/4tAPX49ZsYH47mNZPbN8VvtZRE6EvSaVSlJWVgSAIHDhwAKWlpT5HAtXpdBgeHsbY2BgqKyuh0+kwODhIO0bXaDQ4evQoxsbGsGDBApo79Xo9BgYGQprzU1NT0dLSgoGBASQnJ4uWjz8Qi/MjiqgAYiL4epksMgT7OJu3vCdSOygUClx//fU4fvw4RkZGUFpayul9Zht1dXVh9uzZmDJlClQqFZKSkpCXl0c/m3bNStY6jY2NdYiQ4asMYqOyshJff/01li5dOiHafrJgIrRVoGSgFDa7i2eDlBNo230/LkrlrE7P+Vo0MWVw966/CqmY7CyH396iRbFFbvKEidSXqB1pivOnT5/O6X1mG3V0dHjk/Izvvstap+HG+VVVVSFpZVNbW4vrr7+e/v2Tn/wEALBx40a89NJLQSpV8DGRxqmYkOfk47PPG/HA4l/jE937UE7PQd3Dm/BpWgpGGs7Q/Ojr0bYPS2fgnrZmn971hF3qFNx86ADkLMeZmPm49zXFHc7tEE6bDhTccf6MGTN4p0VxfkpKCs35TAWIWq2mlVJMqFQqvxQlzu0glr/Lycr54derwxhs3vrDDRNdhlA7xuYOE60dCILA/Pnz0d3d7ZP1m91uR05OjlvyFqtdA9UOMpkMS5cuxdGjR9HU1BT2bT9ZMNHGqdigJndWkxXuTn8IFSmHAtviwFPkOX+dd/v6/kTsSxUVFejt7fVJLm+cL9bxxEC1A0EQWLx4MWpra9HY2BhybX/dddfBbre7/JvMSihgYo5TMSAhCNzW0YGR3d/BmvT12NhfhMSEOMhUMbyV9Gy4s9l1nuSJ19kiz9HPSyQOEfASpk+DKovdkpMtDz6OxZnvh3Jf4vodY+P8wcFBmM1m3nnabDbk5eUFXEkTDM4/c+ZMyLW9WJwfUUQFEKFMKlwRDBmE3gXgIwPl64n5LxQwUfvSig3fh7ywnNP7lHJJr9fDYDAIXTxOCGQ7KBQKerfnb3/7Gzo6OgKSbwS+Y6KO02DB111IPjIo1+0Yj8i0apvbsNhiRanzBGcZwnF3nK0dbvpDNWK+8b+c3qcWpHq9nj4uEWgEg/NlMhm2b9+O1tbWgOQbge8IJb70FYGWYVBnRnOvDltiq/DrvDsc7vmqUGaTgQpbzwbD7s3u87LbA8b5zPKFcl/i+i1mkyEjIwM9PT288ptsnK9QKLB9+3ZcunQpIPkGE5GjeQGEP+bgoYJgySCkjyguMlAOx5m/AUcn4oE+vsfMW0oQ0J09GLC8xQBrO8iise+V//P6rtlsxsmTJ2EymSCXy7F06VIRSugdgR4PjY2N6O/vx/r169HS0oKcnJyA5h8BP0Q4nz/Wa/phNBrx38m++YtjAxcZnMNWU4sSShlF+/3w0ySf6fDW22SeWR6pxA7Nqw863A83H1Gs7RCbhq9+6P1ontlsxqlTp6DX6xEdHY1rr71WhBJ6R7A4f926dbh48SLy8/MDmn8E/BDhfP4w7N4Ms9mMuFt+g5FR//1DAf7LwCdiKxNszzK/Jd4Ua8x82WQI9cjqzmCToaioCNXV1V6PyzlzfqjM88U4lsdEU1MTuru7sX79ejQ1NXmN5BruiCiiAgidTgcgvB3PTSYZ2JRPbL8DBUo5ZrlYi+Q5S6HT6SZcO/TXfslp1/fUqVMoKCgQ3KkfX+VioMbDwMAATp06haKiItoqqqenB0eOHMGsWbOgUqmg1+tx4sQJ2Gw2FBcXY2BggPeuUwTCYjLxpZAgCAKrvv4ClZWVgqTHVQbmgsEZno5X+Lpo8Qam09u0B56dEJz/wawKyEdH6Xrqfe5eBweo7tDQ0IDc3FzODma5gq9vsECNh6GhIdTX16OgoIDm/N7eXhw6dAizZs1CbGws9Ho9Tp48CYvFEuH8EEGE830DQRDY/5+3Y8GCBbzec6fQ91cGPpsEQh8DpvKeKH2p9NE3obXK6HrS6XRQKpVe3z179iyys7N9DmIkFALN+Xl5ebjuuusAuHK+0WjEiRMnaM4fGhpCV1eXqOUSGxFFVADhT9jKUEEwZBB6x5evDJ4UE2xWU2LA2RJLGR3lIke47Y6ztYNMJnPZ8WlqaoLBYIBSqURBQQGioqKQnZ2N3t7eoEeXEHs8dHV14eLFi4iNjaWPaFCYPXs2dDodTp48CZvNBolEgjlz5kAmk6GtrQ3Z2dmR3fMgI8L5oQE2GTxZJHlaWLhbgPBVQPFZ6CjX7YBSKgloW4ihXPtw2iwXfxAymcwhHPwudQrmHzuIsbExF87v6ekRXBHFF2K3QU9PD86fP8/K+TNnzqSVTxTnz5o1CwqFAi0tLRHODwFMVL4MBIS09mGTQagIqRT4psXleSbXBrodfFGuebPsLfz+WwAcoyw6z/OV63bg1O+W0Zyfl5cHhUKB7OxsdHV1BV0RFSjOV6lULpw/Y8YM6PV6nD59GhaLBcD43J/i/MzMTJ+jEIYKIoqoCEIWwY5cx1YOZnkCaRnlfFSw59iXAcvbV/jSfvHx8TCZTOjr64PZbMbly5eRnp6OrKwsaLVa1NXV0RNwMZRuodDfKNTW1kKpVGLJkiVuZY2NjUVVVZXLdSryoFarFbWMEUQgJJgLBbs7b+UBLgdbeG4AUMnHJ9diRdBxPirY+fwDgufhDVQkQ64yelvofeNSEwA4OJuNjY2F1WpFT08PrFYrir/4GDKZDMXFxdBqtfTuLyBM2HhniOXU3BdQnL9o0SKHxQgTKpUqwvkRRHAFYh+TYoNy3Q7s/HQLgMByRyA2mqnvDlelHfWNoP52BvXdYnI+9XdPTw/MZjMO/HQOCIJAcXExvbkqJueHEo4fP46oqCivnM9mKThROH9CKqIOHz6MmJiYYBfDBZRDZU8miXq9Ht3d3UFzyuYNXGTgA61Wi3iWMKgAsPflv6CmpgZWqxW9vb0wmUy801+2ZhP2v7XT4RpfGUjDKGpqaljLR+UBgPUZIUHlBwAHD477h6JkuHTpEhYuXChq/r6AUp6xKXioqBnOETCqqqrw1VdfQSqVoqenhybg2NhYZGZejVQSCmfl3cngL6iPky8hbicjwpnzjUYjOjs7g+Zw3xsCyflf/mAaampqQJIkurq66MkoHyx//EPs+e2tDtfYZMj96H23nE32X2S99+UPptF5/HL4CzwZ+xgA8bifyg9w5fyWlhbMny/8Zoi7RQUfZRTAruBxx5cLFizA119/DYlEgu7ubvpI5mTi/Pr6+gjn80A4c77JZEJ7e7tPc9pAIJCcT8Fut+Py5cuCjXE2GajvC4UvbrqZ/vvGzz6mf8sVCliMRtz42ccOaS5//ENICQJPd/4LmS8+J/qc31mG1tZWzJkzR/B83HE2V2XUuqFeSFiUZLvUKVjdegGAK19WVlZi7969AIDLly/jm9/8JoBxzqcsoHapU0CSJBZrB/kJJDDE4vxTp06BIAjMnDlT0HTDDRNSEbVw4UKvpBcMUF733Wk9gXHCvnTpEsrLywNUKn7gIgMf1NTUYPHixYKk5Qx58XzYLje5XOcqA6VEYUuDCdvlJsiL54smBxucZSAIIuR2DphWXGzWUe6cSRIEgRtvvBEAsH//frfpB+sYIlMWoZ16Dg0NoaGhATk5OSgoKBA07YmMcOZ8vV6Pc+fOoaKiIlDF4oVw4nzluh0wffW0y3WuMlATcioNd8oX01eLUfXzSvzw0sMAgPZb7hR8Z95ZIeQsg0wmE4Xz3cnBRT7D7s3YpU6hIw46L2I8cf6KFSsAhCbnM2URmvM1Gg0aGhqQkZGBoqIiQdOeyAhnzjcajYiPjxdFkSwEwoXzPSnHvcmwS52CUtnVI1ftt9yJeSVTsb7k29ix9zeIysxyKbPxy0WA3Y4DD3Sga/N3cXdbM+RxwvGBs0LIWQaxjoi5UzZxUULZ7XZ8vHAJln/4PpSpqS7frY+Kxq127h/sdXiPIAgsX74cgHvOD4a1GxvE4vy0tDSUlJQImnY4YkIqokIVE8XxHBAeMrg7ZsXXWbk3BOMIYTDbgc3KyVsdON+TF89HQsz4Ls/AyQNu3ws1n1fOcgrVDlR0ELvdjoULF04IPxMRhBdfukM4yeBu4szHWfn4UbQt9DXnsN3KzEzIlApUHzoA6R/6WZ/xFZ7SCXY7OCuWPO2W7/x0i8siQrluB+Jl4wur3tcedptPqHG+s5xicP4111wT4fwJgmCPUyEQLjJ4UlSwyUAprth4NmPlDeg7UIMX+5+GRKlATG4ua4AKw+7NqPzf/8bHh49gpLERydf4F1DDUxAMNhneTM6AjCBEVdK443U2xV/zK6/BohvDjB+/g0tvfM/h/npNP17JKcTtp497zC/UON8ZQo0Hq9WKU6dOwWKxYP78+VAoFAKULvwRUUQFEFKpMGFJg4lwk4FNaSKGDJ6OoImBYLaDs78qrs86K3FsXkywqd0gLmhra0NLSwtiYmJoR4eUiTdJkg7/rFYrSJKE3W6nrwHjH0OpVAqZTEb/IwjC4bczfG0H6uhRT08P9Ho95HI5ioqKgu6I11c8+eST+M1vfuNwrbS0FOfOnQtSiUID4caXbAg3GdiOGfx7xvhxhm9ebmN9x50CiG3RYujqwqZV24ANr9L5OE/OGzuHkZcSB1W071MsZpq71Cmwxqhw57kGn9PzF2w+UfRd3ZAQEiidnMluWrUN6+FYrzsB/ODWpzzmQXEzF7S3t+PSpUsOnA+48n0ocX5PTw96enqg0+kglUpRUlIStpwfATvCjS/ZEAgZhPCt5ymN4kffAgAMvPYd1vubVm2j/9756RZkrliO/kOHEZWgxi1Ha6BrbcPOxddi88qnYJc4KkqUaWm4+5LnkxJ8wIyOSuexbgdiZDa0bF/v8OzagW68m5olWN5s8OS03LnOizY8gNkfG6F/49su7wJA39mT9HsUmO8z+dgbOjs7cf78ecTFxYnK+QRBOCjH/BkP1Dw/wvnuEVFEBRDOO16h4oybD8Jx1865jv2RgU3hRP3NppwRK6pesNvBWRa2OmBz8M6E2WpzuabRaGC1WtHQ0ACbzYaVm/8DttZ6r+VRKpVISUlBUVERzp8/T0cQpI4sUn87/5NKpZDL5QDGP2Y2mw0mk4n+kNlsNvp/kiRpv2WUX7A9bzwHgJ8Ju91uR2NjI2JjY5GcnAyVSgWSJHHhwgVcuHDB43sSiYT+32azgSAI9Pf3Iy4ujtWfQyB9zc2YMQNffnnVib5QZv3hDOdxKnTUnkAg2FzjC5zreM2l8x6fpybGbJNlasHiECHvyv9su9n+hPV2t1sPABKLBf8qKsUDffxDNYvhUJ2yHlPPnoW7s+6H3X5VKUfVz6ZV2+jnAODPnz+J79/gqLDWaDQgSRKnTp2CzWbDzc80wLRsmdf8VSoVkpOTUVxcLCrnU35llj/+IQDg88dXAXDlN4qX2WC323Hu3DkolUqkpqbSvkbYOJ8tHTbOj4mJYfWRFKr+RScLwpEvnREIGcQ+dnV5x0a3eTI5SrluBzat2oaYgzIMdLTQz36yaJyD9G9+W9RyOgelYMJCSpD98G6MvOFYBiECR/gC6vukXPsCdn62leZ3Zh1ReVIyZT+8G30vbnBIx5nzL961Bpc5WHlRnD916lRBOP+Duddg1ZFqF8533gS3WCyQSCQB5XwKNpsNUqkUfX19E5bzea0Utm/fju3bt6O1tRXA+MLj8ccfx+rVq+lnDh06hF/96lc4cuQIpFIpysvL8dlnn9GLpEOHDuGRRx6BRqPBr3/9a2zefHWgSCQSREdHo6mpCXl5efT1O++8E2q1Gi+99JIfogYflOO56OhoAKEVoYsrnGXwBzqdDm1t7DvUQoFSHDAxMjKC8vJyByeoXOHJwoetPflYD/GBczvo9XpUV1cHfTdu78t/oZU00qxS2lE88xoFZUwqLu77t8P777zzDsxmM2bPnj3+4bAYODmEtFgsWPHN78PWcWb8XZGVvIQyDpaLtdBoNAD4m+wuWbJEsLLs378fy9ws3AIZTUMmkwU9zG6owXmchpsSChCW8/V6veic7+yQFuDG+e52bJkLBefJPVt7dr3wADK/9ZrP5XdWRlF/k9EK+vd6TT8MBgOqq6vpCbYneHLMzuVdyomvcxrZ770Fi16Pp5/6Pd6JmYboFRdpR/GU4iZ6xVZg3rew9cjfURgfj78eeBrA1YXLu+++C6PRiDlz5ozLou3hVFabzYYb/+trmD59ArNnzxZdyUuknINh9+YI50fgEULyZbAgpAxGo5GV8ylOcXYIzgdNVjOejE1gTWNkZASzZ8/2GNqeqQAaeNlVceUMd98If+GsjKL+VhAk/duwezOMRiOqq6s5tQvbd5ArvvzBNJq/nZ27R0kk+PL+NDScy0G+qc1tHl/+YBquf/wDRKXnI3fzS+hl1NfDyliY7MCmzz+GXC7HzE8+cMmLDXa7HfHx8VAoFJg9e7ZPslHYpU5BpkzGKThEhPPFBS9FVHZ2NrZt24aSkhLY7Xa8/PLLuOOOO3DixAnMmDEDhw4dwqpVq7B161b89a9/hUwmw8mTJx1M3DZv3ozf/e53yMjIwIYNG7By5Urk5OTQ9yUSCR5//HG8/PLLwkkZIhDa434wIKQMer0ec+fOxfTp0wVLkwsovwy+gq9ySQxllHM7ZGZmYsqUKaKYfPI9dkg5bweA6zb+CJaLtSCUcQ5ptLe3Y2hoyEEOs9mMgoIC2mktlRZVBm/52zrO+F12rqDSC+aYJkkSfX19op2vt1gsLh+46Ohot5OgCxcuIDMzEwqFAlVVVXj66aeRm5srStnCBRHOd4Rer8ecOXMEjwzmKXw0ANrC0tP7bFZRFDztWjsjMTaadwhsZ7DJITUaHX5nZGQgISGBVfnrrT74YrFuxOP9pcuuxa82vwGCkOKGv44rbIiU8WO5lPzPxD+Ly6OjyJXJ6Pq2Wq3Iz8934HzTV+MOgrnUHZvllKeoff6ASi/YY7qnpyfkfapMZgS7fwgBoTl/9uzZLpHBvHGKNyjX7QBu/ZPbcf6/Sam4JJHgUScn2cz3na13mGDjTl/4lCsXs8lhsF0d58p1O3Dqd8sQExPDuqHiL+85v0/xMBPtsihAIsHi22/D4ttvg3tPf+OQxByGYagHhDqbrm+r1Yp7PngPA/fe51axEgjwactgj+menp6g5i82eCmibrvtNoffTz31FLZv347Dhw9jxowZeOyxx/DDH/4QW7ZcdfRZWlrq8M7Y2BgqKiqQmpqKxMREjI6OOtx/9NFH8ac//Qk/+9nPJlxIQ+OViWQ4m+4KLUMwJlQWi8Vt2FyxLGmETtO5HaZMmYLBwUHBFFFMBY6QZafSJUkSnz33BxiNRlqG8+fPIyWF/VgK3zJ4OxYoFII1pq1WK/bt24fs7GzeETZfb86CTOq5vMMmOd566y3cddddDtefeOIJPPnkky7PL1iwAC+99BJKS0vR3d2N3/zmN1i6dCkaGhoQFxfHq3wTCRHOd4WQnM91h9pms9EhmJ2hXLcDBicHq0JAKEUIVR5KKUxFCpsyZQp6e3vx9bRZLmX2RQa+CxlnhZ2N4XPFOd3Xjv4Babl56B/og00qB2GxAACampowZcoU1vf41h/1vNhWh8Ea0yRJ4uuvv/aJ8yMIHCKcLy64Hn2+Yd9XHp1Be7Ns9QRfFP18jkdT5XHm/KGhIXR1daHoJ5+4lJn525ej2J7qgMn1d547DTtJQnXfi1f8BrLXg3LdDiBKhWhzHwipHZYrp92am5sxZcoU3BgiEfG4IJicv3fvXmRkZIRsVGUh4POM0GazYffu3RgbG0NVVRX6+vpw5MgRpKamYtGiRUhLS8O1116L6upqh/cef/xxTJ8+HQkJCVi4cCHKysoc7i9evBi33nqrgzJrosBut/tliRMKEFIGrg7qhIYnGbwpLuTF80U5ascXzjIkJSXR5qNCQCwLIgAgrWbAqMO9jz3hIEN7ezumTZsmaL5iI5Bj2mw2o6urC2azGYcPH8a8efNQWloqeGhZCmvWrMHIyIjDv61bt7I+u3r1atx7772YPXs2brrpJnz88cfQaDR46623RClbuCDC+eJivaaf/ucJlMNSNnhbhFCWTcGGO873JjvXiH58FFDUQofpc8VTer9c8VOc7u1BrlQGEFd9YbS1tbnMAUMdgRwPVquV5vyDBw9i7ty5onJ+BP4jlPmSK4SWwZ3/G19g2L2Z/ucJYrYDl2+OP89TcJZBrVZjZGTEq+ybVm2jed/fOnD+frxfOhO3/OfHdBncyfXiif/FNHk/iMQcELhahubm5gjnewCT8w8dOoTy8nJMnz59QnM+b2+yp0+fRlVVFYxGI2JjY/Hee++hrKwMhw8fBjAePemPf/wjysvL8corr2DFihVoaGhASUkJgPGjeevWrYPZbEZiYiJrHk8//TRmz56NAwcOYOnSpbyFGh0dRXR0NAwGA1QqFYxGI+x2O1QqFcbGxhAdHQ2SJGGxWBAbGwudTge5XA6CIGAymRAbG4uxsTEQBIGoqCgYDAYolUqYzWbYbDb6HbZ0KK/7RqMRMTEx0Ov1kEgkUCgUsFgsUCgUGB0ddUiH0rKazWaQJAm9Xk+nZTQaaRmAcafMY2NjUCgUsFqtsFqtrOlQ16RSKS0DW10oFArYbDaPdcFMx50M3urUuS70ej3MZjMMBgM0Go2LDLlVN0FnMKHn6Oce61Sv13OuCyodm80GmUwGrVbrUhfO6TjXRUKMEjaShNlihTI6CqppC9Bz9AuHdHIWrUbPsS951QWX/pU+73pYbTb01O6BxWKBSqXCyMgInY5Op4PRaHSRIXfRavTUfsVaF8z+5VwXw/V7WdvGU/9Kn7d83KmflECMIhodhz/H2NgYLBYLDOcOI3XOEljsZkA9BVEyGaKioqDRaGhHgHq9Hna7ndNYk8vlkEqlbvsFW53mLloNSCRor/nY7Zil/CNw6V8WiwUxMTHQaDScxpq3/sWsU51OB4PBgISEBJw5cwYmkwkJCQloamqiTbOtVqvH/uXOCoQL5HI5vRPHF2q1GlOnTsXFixd9zp8PwpnzCYKYNJxvNBrdcn7Bd17FmE2Kzu33CMr57xeWYtrH/3LL+W8XTsVtZ0+5rYt4mRU2SGAhJVAQJOLXP4/OZ9c6pPNh6UzYCQK3NbKn81HRNNx6qYk352c9uANWuwSXd2xg5XyqTp3rouD7b+Hy8w+MzymkBF7JKYTEZsO9l5o8cn7/C2u9cv6tHZdo3lapVPjhrU/hxw88C5lECpXUhtbnN9CcP/raRmSs/zP6OgdQDAlIuRwSvQGWuDiMjo4GhPMLvv8WJAAu/W1NWHF+Y2Mj/XdTUxMyMjJAEISonB9OCGfOp/r9ZOB8T/N8d3NSfzk/+zu7sOen8yCVSlk5P2vzK2hm8IGnunBXp/nfextSid1tOjmPvINnj2xD2rRsmAb7YJBG8e5ffDifWRdSiR0xi6rw75tWY/bPf46EeXM585Nzna5uvQCpVIp/FZXi1vNnoVKpcIvRiJGREdzT3wWNRuMiQ1tbGxqHBvCf3fux+9qH8NEFPUpjreg+fZpuY4qrxOB8Lv0rFDn/3Llz0Ov1NOenpaVNCs7nbRFVWlqK+vp6HDlyBI888gg2btyIs2fP0ruNDz/8MB566CHMnTsX//u//4vS0lLs3LnTIY2YmBi3SigAKCsrw4YNGyacVZRerw977/Z6vR56vV6w9Nwd07i479/QnT0oWD5MWCwW+oPPFxf3/RvtBz+lf2tOHXB5pq9uj89lY0Pxtbe5XOPTl3pqvxK0PO6gns1BaWwer3fSMAoFLDhw4ABqa2vxxRdfIDk5mfUVNvm5IKn8WpdrVF34mqYzxBjTY2NjaGxsxJEjR3D27FkcOHAAMTExWLx4MfLz87Fw4UKPDjhDATqdDs3NzcjIyAh2UYKKCOdzR9Mza6F59UHB072nvRlms9lnzm96Zq1DCG2mU9u30nPYXnHBmp4OXnmWPvqmyzU+feny8w/wys9XJG/07svTru2B3W7HJdKK1igZmqNluGQz4/PPP3c7D2STnwtSH3rF5RpVF76m6YxAcP7+/fuhVCodOJ/pSzWC0EWE8x0RjJMPPTu/CZPJ5DPnO+PtrHy8P33cOXbSBm7+i4de2Yjk5FjMrcwD+dX7PuXrT1/6XcYq6No6kLa4yqf3nXEvI6KgN5w7dw7Ldr2G/8u/DodONkCpbcFP9Adw8NEfIyEhQZDyBBJijGmDwYCmpiYcOXIE586dw/79+xEdHe3A+cygbRMZEruf9mY33HADioqKsGXLFhQWFuLVV1/FAw9cnQStXbsWMpkMr7/+uvfCSCR47733cOedd6KjowNTp07Frl278NJLL3GKmqfVapGQkICRkRGfd/LFBKWBZQuzTkGr1eLSpUsh6wOAiwxc0dXVhbGxMdpaji98dUR9+vRpqNXqsJjYOR8DpGRla4eamhpUVVUF3ZGpu3ZxlkURJUdf3R4olUrs3bsXxcXFgipYPPn7YpbFU//x1seEHA8U9u7di6lTp/oU1dEZTE60WCxITk7GvYv+5tVH1Md1T+L1t57FLbfcwimfn/70p7jtttuQl5eHrq4uPPHEE6ivr8fZs2fd+v0SAhOB8/V6Pc6dOxeyPgCE7ON9fX0YHh528R3JFb46ZD1z5gxiY2M9Tuz4+tVg+gkRMpqS8zFA2vdRCHO+u3ZhylIWS+LXDS/B2D8I++Agsj54F4WFhYJyvicH51x9y3jrY+HE+QA48+O8efPw+OOP44477vC7DGJiInC+0WhEQ0MD5s8PvpsHNgjZxwcGBtDf3x/woERnz55FdHQ0ioqK3D7DNZgE9W1gcoMnPqG+B3HxCiiUciz/51sgZvBva7Z2OHToECorKyGTcT/Q5IvPKKGgvu95EBIJHozpx90blyEnJyfsgtiIxflCrXmYnCiTyRATE4OBgQG3/hcpLFy4ED/96U9xzz33+F0Gf8D7aJ4zSJKEyWRCfn4+MjMz0dTU5HD//PnzWL16Ne90c3Jy8Oijj+KXv/ylRyIJJwTLJ5KQCCUZfPVjRJKkxwhKoQSmjEzlCVs7xMXFQaPRICkpKSBlcweu7UIQ4yal9fX1SE5OFtzKh4sSyl8INR7MZjNOnjwJg8GAvLw8QRYkgURnZyfWr1+PwcFBpKSkYMmSJTh8+LCoSqhwQCjxpa8QUgZ/0/LVETVJkh7zdjdR9+SUdr2Tg3Ouvpi8gSkjc7HDVn61Wo2hoSG31qTOEDP8uCckW7T44J4ZOHpGCqNOhzarBTPUasE5n4sSivrtT1+i4E90wnDn/AjYEeF88dICuI85T34BAfccoFy3w8UJN/W/s4Nzb74DR7VG3NrOzxqWCU+czzUwkXLdDmDVNmzyg/N8hXLdDqikdpCkBX9r0WFDTEzYKaEAx3bwJzohxfkmkwk5OTkhf7IhUOCliNq6dStWr16N3NxcjI6O4o033sDevXvx2WefQSKR4Gc/+xmeeOIJzJkzB+Xl5Xj55Zdx7tw5vPPOOz4VbuvWrXj++efR0tKCtWvX+pRGKMFyJVJMOENoGcTcyXVnzWKz2cJGEcUEUw62dkhOTsbg4GDQFVHuYLlY66AEkkulOHHiBMrLy6FWqz2+K0Y0Q+fyuHvG430/xwO1M6rX61FeXh6SO7xcsHv37mAXISQR4fzAwt0k0VPUPGewKZS87Sj7o5DwBKYcbO1ARUvlqoiiyieU0swbqMXagCwONZu+DSI3B72pyXh070mvu7X+KIu8lcdTut7yjHB+BJ4QTnzpDqEsA1eOtVqtnNcXbAqlTau2YT3Ls87vsPEFk2f9sUbyxPlcFVFU+YIVcEMmsYMc7Ub3m/8RsmsTb/B3PJjNZjQ0NECn00U4nwW8FFF9fX3YsGEDuru7kZCQgNmzZ+Ozzz7DjTfeCAD48Y9/DKPRiMceewxDQ0OYM2cOvvjiC58tmpKSkvCLX/wCv/zlL316P9QwEbzeCyWDvHg+Wva+L0g67pQF7q4rFAqPYV1DCe6UaWztkJycjI6ODof32N4VQ6njC3QGEwiCCBopC2EZxXc8aDQatLa2QqfTAQCkUilmzJgR+TBNUEQ4/yqU63ag5c+3cF4cuJvAe1IkuLuuUCigUqnc5uVuocB1AeFNScVnIeJugeOO81taWhzec353lzoFm1ZtAwDs/HSLzxGcfIVMKkHn40tx6OESyJMSIevoDJqfECEWY8x24FKPzpwvkUgwY8YMr5svEYQnIpzvCj4KIXdWSnyV0kqlEtHR0W7ve/qG7FJv8Zqft+O9ht2b/eZZtnZISkpCc3Ozx/eY9UX9HQxrKAAYs0lBmqxhPS6YZedSjxTnj42NwW63RzjfC3gponbs8P4R37Jli89OxtncVW3dutVtyPBwAzURCefOKIQMQh6N8kWhYjQaIZfLBStDMMDWDlS0E3dwsEby0b+WP3Bud5Wc4LxrRVkvhYICjQmu44EkSdTV1UEikWDq1KkRxdMkQYTzHcHnmIa7SbwvE2oqSg/XfANlMcQHbO1ARYF1B+pYBgVvu/xCg1qM5P6/r/CPk6fwwxt+jl1PP8zJvwkX66VggC/nA+NBfiKcPzkQ4XxH8OF8vhsMnmAymTiffHA+ZhcIRT0XK1pfOB9wPUIYKDA3Xag6Pfmf16OlJZ+OQBeO4DMeamtrYbfbI5zPA8H1cDnJIJfLw14B4o8MTOUHpVAQ6mgeH+WWVCrl5eiPmQdfJZrz83zTYNaVQzqMdhBCsSekcpBL+iRJ4o3/eRILFizgnIZQSih3deoLuI6H+vp65OTkYP78+ZGP0yTCZOd8NisdoTifi3ULNdn3lfOV63bwtqJxfn7Tqm280nC3e81sB2Z6XBVs3sopNKj0s3W9AAA7gG9//UdUVXGP4iTUIkpIiwCu4+HUqVPIyspCZWVlhPMnESY75wcbFO/IZDKPnE8dmxMDgeaaUAPVBiRJYt53t/Oa54ci+HB+enp6hPN5wm9n5RFwR7Aj2wgBX2WgFBFMqxahnBjyVaIQBOGTHL4oL6h3hFb0MMvPLJfzooRPmYW2OHJOj2nVNDAwgI6ODtHHhLsjikJZhHkrf0NDAzQaDaRSKdLT0/3KK4Lww2TmfGoyKoZVCx8lyi51CmbX7OUlB+2klkPazjvaYvnkYJbfHx9HTAjdNs7p6d94CP8sng7z0BCqPv8YJTbuflv8KQMFNsfv/srLh/MjDsgnHyYz5wcqPW9QrtuBE08u5pUvV14QijO5WF2FY1/alZiK3Ru+jZZdb6L3uXtx/vx5nzaBQgne2uHMmTMYHh6GRCLB7NmzA1SqiYPw7h1hBpPJBEDYEJCBhq8yuFvwF197G2ztDX6Via8ywWKxcHZcKxSEPlLmrR3Y8vN0vE3o8lH5sB0HBMaPytjtdphMJlHHgzuH5ELJ66kddDodjEYjlixZ4lPaJEmipaUFPT09sFgskMlkDopG6uy5898UZDLZhIk4Gq7gwpehHmXJV85nm6yTJImyH74J00f++X3kuhCgJvsnT54MOOezhfT258iHt3ZgqxNPx9v4LKa4RNuj8qEUPnek2fDRgsWIyc6CVKVCVHYW7J2donP+yGsPIuGBl1zKbxDouI2ndtDr9TAYDEHl/IKCAp/yjkAYTOZ5PhsC/X2jeO306dOs7l4ouIuSyjV6qrujdcw0mNzr6Sieu3yD2ZcoHo+NlqHvpQ2cLG8V6WmwW21YtP527L1nHZZctywg83w2CLnJ4qkdjEYjdDqdX5zf1taGrq4uVs73BoIgwn6eH1FEBRDh7KyNgtAyXDrwkaDpcYFKpQrrSQIApF+zEgBgI0kHq6u9L//F67vB8A/FBLV7cM011wiy46PX66HVaum0mP+nVCwHAAyf2k+f82Z7ju1vLvA0Hnp7e3lbQQ0NDaG1tRV6vR4kSSI/Px9VVVU+1VNbWxv27NnD+70IhEOE811x9v/Ej4DrPOlXKpW8AlRwjYLHVbFEpeePMir7kfHowza7xMHq6ssfTOP0vj8Tc6bfLK4y1HaMYq1WC11rG+bs/wqXLl0KCOdnfOt1AED/Sxuh0+nwdmYe1vZ0QK/XB4Tz09LSeMnizPl5eXk+c357e3uE84OMCOcHB84Wj0qlkpclDld+42M5Rf3P5ricy7FAru3g7yYHGwy7N+PWn72Ob3/8B+xO/CkA7987qVKFuMICLHm1Bf/64mNcuHABCxcuFJ3znf+esvFlDL/6UMA4n+88nxnAwl/O7+zsDHvOjyiiAoiIE0NHeNqtEBNGoxFSqdTvdIKp0IlVjkcDGRkz0NZHlou1qKmp8fieu7IKeSyPeQzTOW+SJPH8889j5syZ2L9/PwD/d3t6enqg0WgcPngkScJut+Pkh69hzuo1aG1txdyb1+HYB6/R94HxPkj9TZKkw3Xg6lFHg8GA4eFhl6MWBoPBrQwajQaxsbFoa2tj3b1mwmazoaGhAUuWLEFxcbEg58vz8vKQmJjodzoR+I4I57siEMcNXI7LGQyCfG98Pd7lvJPu6bc7xEjHHdRqrTKHSEjeOJ8qq3OZfVVMuYtkyPwfAH63ZxuMGOfV/fv3C875w8PDDpN3ivOfuqsIv3rtKFpbW1H5s3dxaO8XOHfuHG/ONxqNGBgYQHZ2tkPe3jg/JiYGHR0dnDj/7NmzWLRokWCcn5ubG9ZcMxEQ4XxXBILznbnMYDDwmuev1/RDuW4Hdn7qGmyLjfO8RVpls4il7jsrodylxacdxFBGnek3Qt/dA2VWJgyXuzzmQckUX1SIxj/fjS3TZ+KOl3cKxvl9fX0YGBjAokWLXDif+pv6/9CvqjxyvvO7FE+bzWb09vYiJyfHIW9PnK/VaqFUKtHZ2cmJ88+cOYPFixejsLBQEM7Pzs7GzTff7Hc6wUREERVACKH8CDYmggwSiUSwD2Mwos5ZLtaipfpjAEDS3Ovpe/6URWglFFv6fX19aGhowN13343k5GSMjo4CAOLi4vzOt7a2FgUFBawh2oloFeZ9YxMIhQoVFRU+pU+SJA4ePIjFixc7XBdCBr1ej5qaGmzYsCEsdyIjcI+JwJdCyhCsY4h8d0D57ohztaByft75mvP7TMXXxe334f1ps/Cdpb+m7/lz9EBoJRQFGQF0/L9F+ORTQEuSKHn/bcycOROpqamCcv7x48eRl5fnwpkzZ87E//3rPB7Y0YgH5hb6zPkAUF1dLSrn33fffRPGqe0///lP/OMf/0BdXR2GhoZw4sQJlJeXB7tYAUeE8x0hNue7416+nL9LnYKdjL+9KVw2XYlG6o1HnbleuW4HnU9mthrXVBWif911SNm91+VdqVSKwkd2of+173jMg1JuCa2M6jEC6wa6IfFSj0wZB1ta8bg6GQVSGRYvXiwo59fX1yMrK0tUJa/YnH///fdHON8JEUVUABHO4SspCC2DrxF//IFQkSgCbQnFzI9qB6GdiwudJgWtVouTJ09ixYoV9ORAyL5kNBpZlVBM+COXuwmNEDIcPXoU11577YTghwgcMRHadCLI4Avnsy1whHJS67w4cXdMg5lfVFQUCLMZht2bBVtw8LHw4pqfjCCQMK0UkqwsFP75v9F9573oJQis1/QL2pcMBoNbxb3KYsC+b83A2T//H4CNguUJCDMeamtrJxznj42NYcmSJVizZg2+/e1vB7s4QcNEaNNwksEdL8nlcp8sogDPfEjlt4ljMApm+aj0N63ahp2fbkFMTDTkUTJcbO7E3ux8RNktuL2jHRJivNxRUVEwkxL6XaGDfngDl/yY3y4TSaLHMIbpUhm+dfMf8AiE7UtjY2NelThi1JNQnL906VJeLgJCHUJxfvi55A9jGAwG2sQvXCGkDMHaHTebzbTzOU8QOtKdL5AXz2ctB992YEvH+Rp1vM9fsKVx6tQpXHvttY6Rn8JsPEgkEpc+K4QMSqUSp06dgtVq9SudCEIP4dbH2SC0DMGIBGQymTjJ4GukO75KIXfP707JxL9mzcV702a63DMYDLApFC5KK3dHDpXrdrjI43yNOt7nL5hpGK0kVPe9iOxnn8HSpUtxv3bw6nEVAfuSp6OWbcpU5PzXESx64Vm/8pBIJC68HOF8dnzzm9/E448/jhtuuCHYRQkqIpzvimBxPpd5vq/wlzc3rdqGpQU/Rs7Qrbg8YME97Zdwy53lODz/KvcbDAYoCNKFx5kb+MwNE6GP5nEBM89W0opHjh8DQRBXj4QLzPne+pK/7SKVSkXhfJVKhdOnT0c4nwURRVQAoVQqw95J9kSQITU1FS0tLWhqavL4HBeljNDKKndR5pzz8dQO7qLEiWXB5U5ZxoREInHZVRC7L1HlomT3t62SkpIwMDDgcE0IGRYsWIDCwkJ8/fXX0Gg0fqUVQWhhIvClkDIEyy9gWloaOjo60NjY6PE55iTW3cTenbKKyyLAk4NaZXYWHrv999gw54f4zsKfuyqRlEqsvehafolEwlomoZRMrGV1UmiRNhvGXtuIsdcfhP6Nh+jrzru/Yo8HqlyG3Zuh27UZqvU7vb/kAampqejr63PMQwAZKisrUVhYiH379mFoaMivtISExWKBVqt1+CfmYn4iIsL5jgjWhnNKSgo6Oztx5swZzu/w5Uwuz3re3JCge9cjAEni41mzcaSmGUODY1ffVSrRvuNBt28zvyfU0bxAI+Ge7YBEAhAE7ADeS89xtAITsC8F4gRNamoqenp6HK4JIcP8+fNRVFQU4XwWRI7mBRBU+Ojo6Oggl8R3CC1DMHZK4uLiUFVVhYGBAezduxcLFy4EMO4Y8MKFC5g3bx5nU0wxjsa5U5gwj855agdPDsmZzwitmHLnp4q0mlnLKfZ4oJRPTGWUP8jKysKlS5eQmppKXxNKhqSkJFx//fU4ceIETCYTsrKyImG4JwAinO+KYBzHjomJQVVVFYaGhrB37146epter0dTUxMvzvdFuWNvvwDb73+MgqKrfjzWa/qhXPsCUhKUmJkdjy3n3sKztX/G2unfg9k6vnhjHhWh2sElbbvdbZnEsH5iS5+QSrH9V3/BWxcN+Oevb8NMuSYonG/YvdlBGeWvvBkZGTh//rxDkAqhOf/48eM4e/YsMjIyRAvDnfrQK5DIPS+kTC0DeOedd3Dvvfc6XH/iiSfw5JNPilKuiYgI54cG3HG+0WjEmTNnUFlZKeoRxJOtg1i45X0AcOEjJi8r1+2Aoe0idqlTcIvTsW2z2exx84ap8AmGNdQudQr+ceVvnc0GGVy/7UL2pUBsZGVkZODs2bMOQSrCkfOzvvUaJNGefc6aLvTjvffew3333edwPdCcH1FEBRA2my3YRfAbQsoQrJ0SSoaCggKkpaXh5MmTIAgCJpMJZWVlOHDgAFasWBHQMvG11nHXDlyIWgzlGfM3M33SOIZjH7yO2bNnu7wrVF/S6/Ws566F9nkVHx9PRzGhIOR4kMlkqKysBADs3bsXOTk5vMIPRxB6iHB+aICSIS8vzy3nX3/99X5vjLh1Wp6SBQC45q9/xsJFK+lnX0ueAvPAINb0XcaNvyVxPmYUGGXfjbTZbPhgVgUoT1d8/ESJ7VuEtFqRv+89PJmdjfSfjKHmv+5gdVoqVF8yGo2siwJfoxq6Q2xsLPR6vcM1IccDQRCYP3/8O7V//37k5OQE1T/PPffcg+eee87hGls9v/7663j44Yfp35988gmWLl0qevnCAROJL4VCMDac+XC+Pz73nDmHSqsgddyx9V+/tRjfumGaw7NUZD7nPJ3LYbPZ8NGiZcDsH9HvB9pPFBe0WC1YufdLlJeX4+3kDId7QvUls9ksiG9fb1CpVDAajQ7XJjLn33XXXXjhhRccrgWa8yOrnABiIkTECgcZvCkgmDKoVCosWLDA4X5aWhrOnDmDxMREJCUliepczt0xOm+KKbZ2IEnSo7WBGEfzmGV1Tp80G3Hw3ZfcRi0Sqi9pNBokJCQIkhZfiDUeKioqcOzYMVRVVYmSfgSBQTjwpTcIKQNJkqJElSKvTBQlBMHKgUwZFAqFC+enp6fj7NmzSEpKglqt9hr4wBMoZ+TMBcXujDzI5FLY3twIu82GTTc9jZ0AotVq/HLhj7CWIHCkeRCkm40Eu2YQH5fMhFIuhZWRD+DZwkzsRQsz/VUHvsY1d/w/7P3NzfRE2xlCcj6fyEN8oxp6glhjury8HMeOHXOJ2BRIyOVyTvV6++23O4yhrKwsMYsVVohwviOEtmKhxvK3V2+Dze7KcdT9ewe66WtsnJ+ZmYmGhgYkJyfDSJJ+KaMoS0zD7s10GmmbXgUA/OCFGvzghRq30Vap55mR7wDg+tY2zN38Ej5/4kkoP9LCYLaFnBIqJi8PgzotLL19mD9/PuvRwGBxvpCbEmLP8yc75zFH7a4AAMh/SURBVEcUUQEEZU0hZuhJMcBUNAgtgxg7Jd4ULt5kKCsrQ1dXF8bGxtDR0QGLxQKJRAKbzYbi4mLIZDKcP38eUqkUcrncZdLt7oiaM5yVTdQ7npRQ1DPp867HxX3/dpCBJMmg7Dyxydq2/wPkXLPC5eNPQV48H/21XwLwvy8NDw8jLS2NU7n8BeXIkLJUEmtMx8fHQ6lUoqury+FYSAThhXDlfOYkLhxkeHNKusdFhDcZpk+fTnP+5cuXYTAYQBAESJJEYWEhFAoFzp07B6lU6mC5SIG5CGGbjK/X9ENntODjedcgtawUt5fEYRO2wbB7M26FZz8iht2bYbfbEZWsRmKSCitq6uh7wbIqZpvc9/b24pQBbpXnynU70P2PuwH435dGRkaQmJjIqVyAfwooqVQKs9lM71qLyflxcXHo7Ox0OBYSioiLixMkHPtERDjwpTeEgwzvdL2B4ZOnADiOeWqsU/423clQWlpKc/7Mrz6FyWRCTU0NbDYbJ86nQCmh2K4Djty+89MtV8p31XrKuey71CmARIK5j72Nd5er0PiH32Pf3d/ArF/+wluVBBw97e2w5uXg8Qvn3Cr7hepL7jjfHfxRQMnl8oBwfmxsLBISEtDe3o7c3FxB0xYaYnJ+RBEVQITzeWsKQsoQrEm0NxkIgmCdCJIkibNnz8JoNGLRokUAgOPHj6OlpYX250OSJCe5nP01OV9jwlmhIi+eD0WUHDmLVmP07CH6OlNBEkwYjUZ0dHSg4Yt/un3GcrFWsEgaWq0WpaWlgqTlDcnJyejp6aH7h5hjury8HB9//DGSk5PDKpxyBFcR4XxXBENZ7ivn71Kn4LDViuV7v3Dg/ObmZtq3gzPnu1N6pDz4CqYt/B7WpRjx5u/WAHCvgHKeRKvW74Ri7k8AAMOM6yRJhgTnm81mdHR04Pif73P7jGH3ZsE4X6PRBMyHXnp6Onp6euiFgphjevbs2fjkk0+QnJwcdmG+h4aG0N7ejq6uLgCgg8Gkp6cjPT09mEULKCKc7wqh/QKu1/RjyZb3UL3vLrfP+Mr5ynU7QI7sRc3vbqY5v76+3oHzAceNX28++qj7zt8Gtm/FTfu+QtKc2VgP4LW0bMjVasz4xU9Z8w0mzGYzKr74GHuuuxG7k9LcfveE6ksajQY5OTms9/yxZmNDeno6uru7kZeXB0DcMT1z5kx88sknSE1NnbScH/wZzCRCsBQv/sLB50+YysCErzIQBIGZMx3Das+fPx+nTp1CS0sLYmJicPr0aXz67O+h0+loc05Ks37mzBmYTCZUVFRcKQMJgpC5VUCRJAlYTKivr0flPd8a/23WY/+bO1BUVOSinRbr2AtfHD16FMXFxV4teYTqSzabLWCLsaysLAdHhmKPhyVLluDAgQOYM2cOkpOTRc0rAuERrnzJnFgLKYNY9eFtEupPvjkymYPV6/z589HQ0IDm5mYkJCTg5MmT+GBzrlvONxgMKCmbDdJqwtlhG54cU+FJNwoo0moGxvpx/PhxLP7DCZCkFRhux54nb2blfKvVGlTOpxYAR48eRX5+vldLHqHa32KxBEw5n5GRgdOnT9OKKLHH9OLFi1FTU4NZs2Y5BMYIdXzwwQd46KGrERPXrVsHYPI5Ow9XzmdCaM4XkqMorq/e5l4JReXrK4iELAfOr6iowJkzZ3DhwgUkJibi5MmTsFqtWLx4sQvnNzY2QqfTobKyEqTVBJCe/QsZjUa0tLTAYDCgoqIC8TPKcOzYMZjNZiw/cRQJCQkgGPVntVqDqoiirH+PHTuGnJwc5HiZewvVl0wmU8AUNRkZGThx4gStiBJ7TC9dunRSc35EERVAWCyWYBfBbzBl4HoEzROCcpRM4HaYNm0ajh49itjYWFx//fUwGo04ceIEnY9Op0N+fj6A8dCg0qwr1jskif7GY0iZf8P4T6sZsJjw9a7ncf36b2P/WztRUlICs9kM0jA6/o5cicrKShw+fBhWqxXXXXcdXYd8P1BCtB8blEolJxPWcBwPzo4MxZYhPj4e119/PY4dO4bBwcGAWX5FIAzCsY87gymDEM5Sw4nz3Sm4pk2bhiNHjmBkZITm/JMnT9Jhj3U6HQoKCmCxWJCeno6U234N2O2A1YR923+Ea3/3NQCANIzAruvFl0/cght+8xG+/u3tNOfb+s9DAgKIS3Pg/GXLltGKd76cL7SzW6p+FApFQDk/kJEXFQqFQzjrQHF+XV0dBgcHMX36dFHzEwoPPvggHnzwwWAXI+iYaJwvNoT038aErzK448fS0lIcOXIEo6OjDpxPHePWarUoKSmBwWBAVlYWqqur8cUPZ2JsbAxDQ0NISkoCAPT09ODixYu0ZZNEIkFJSQmsViuqq6shkUhQWlqK+Ph4HD58GGazGddddx3N+cHecKaPHDLm+Z7aLhB9Sei+ExUV5VBusWWg1o51dXXo7+/HjBkzRM1PKAjF+RFFVAAx0ZwY+qvECNbOkdDtEBUVhSVLltC/VSqVg/O5I0eOoK+vD8uXLwcAEMo4WC7Wwmw2o6GhAZ899wfc+MB3AakMlo5GEAQB2+Umhzxsl5toy6moqCgsWrQIw8PD2L9/P9RqNaZNm8b7aJ4YSqgzZ85AIpFwcvY70caDWCAIAgsWLMCZM2fQ1NQUUUaFESZaHw+Us1ShFye+tgPThwezLDKZzIHjVSqVg2+kI0eOoLe3F8uXL8cnx9shTZmKkdceBAE7Ghoa8NF3CrDqdx9DEhUL4xdPgyAImL9a5pC3+avf00c7KM7XaDSorq5GfHw8ysrKeB/NE6P9zpw5A7vdzqmOhRoPgQjj7Q6B4vzKyko0NjaisbExbJRREUw8zhcCnpTlFK+KEfGSK5jfG+ZxaWZZvHH+sWPH0NXVRUfcpk4EWK1WNDQ04MSJE5BIJEhKSsKiRYtY68T5FMGiRYug1WodOD8UXHA0NjbCZrMhPj7e6zc6Mh64YTJzfkQRFUCEgwNAb4jI4B3O/p+cHXZTCqCoqChUVFTAbDbD0Nrg9agBU3Gk0+kgl8tx3XXXYWBgACdPnoRWq4VUKgVJkjCbzZDJZAH/YLW3t2P16tWcnhWiHbxFChQDTEeGgRwPM2bMQE1NDRQKBW0yHEFoI8KXjuC6+SD0DidfGZwVYWwOyJlwXrwwOX91Ra7Dgqa8vBxWqxXaTxZ5PWrAfE+n00Emk+G6667D0NAQTp06hdHRUdjt9gjni4zo6GgYjUYoFIqAjunp06fj0KFDDn4oIwhtRDjfEZ44n8mzQivJfZGBaTHqKYAEG9w5M5fJZDTnW61WXsfLdDodCIKgOf/06dPQarWw2WywWq20VVWgOb+1tTWgnB8MKBQK6PV6qFSqgHP+kSNHXHySTWTwspHfvn07Zs+ejfj4eMTHx6OqqgqffPIJff/hhx9GUVERlEolUlJScMcdd+DcuXMOaXzwwQeYOnUqSktL8eGHH9LXW1tbIZFIkJqaitHRUYd3ysvLJ8QZc7lcDrlcHuxi+AWhZQjGMQ1vMniKWscFlou19D8uiIqK4u3vgilDcnIyFixYgBtvvBHFxcXYu3cvTp8+jWPHjuHYsWO8y+8rSJLktVMtRF/SarUBj95DOTIEAj+mFy9eDJ1Oh0OHDk0IXxQTHRHOd0Uocr7zomO9pt9BGeZNMWbYvZn+xwUymYy3vwumDElJSbjmmmuwYsUKTJ061YHzjxw5witdfxFoztfpdIiJifErDb5IS0sLGudXVVXBaDSipqYmwvlhgAjnc4czz/qKXeoUl80CPjJQ5WDyt9CKMSE4v7KyEitWrEBZWRn279+PkydPcuJ8bxspfBEMznd3yuKzFTf5lbY7BHOev2DBApjN5knD+bxmhNnZ2di2bRvq6upQW1uL5cuX44477sCZM2cAAPPmzcOLL76IxsZGfPbZZ7Db7Vi5ciVstnFnbSaTCd///vfx97//Hc888wweeeQRmM1mhzxGR0fxxz/+USDxQgtSqTQknEn7AyFlCNYA8yaDGEfWhIY7GXJzc7F8+XJUVlaiqqrKwbeF2CAIAikpKfTugTcI0ZeGh4cDvtOSlpaGnp4eAMEZ0zNmzEBBQQHq6+sDmm8E/BHh/NCAJxl2qVOw89MtHt8XeiLvC7hyfqB91KSmpkKr1XJ6VijOdxfGm21BKgTS09PR19cHIDjjYfr06SgpKcHx48cDmm8E/MGlf4T64lLoPh6MzQdvMpx/7gWP7/O1iBID7mTIzs524Hyr1eoxHaEtjNPT06HRaDg9K0Rf0mg0bjl/5RefgPQivy8IBc4vLS2dFJzPix1uu+023HzzzSgpKcHUqVPx1FNPITY2FocPHwYAfOc738GyZcuQn5+PiooK/Od//ic6OjrQ2toKYFwRJZVKUV5ejrlz50Imk7kslH/wgx/gT3/6E90BJhKMRqODo2N3CIXQnO7AVYZQhjcZ5MXz/bKKot7nmwafd7i2Q6CPMJhMJs7nqYXoSyMjIwFXRCkUCnqxF6zxQE0EhoaGAp53BNwxGfjSHdgUAmIvwNwpIjzJsF7Tj02rtnlceHibyCvX7aD/8QGfd0KV841GI+Lj4zk/KwTnJyQk0L+d/XgJvegCHJ3XBmtMp6amQqfTYWBgIOB5R8Adk5nz2bjMV87nqlBWrtuBTau2uYx7TzL8e+41OP/s8x7T9WYRJZbSm4lQ7Ut6vT6gnK/RaBw4n9nPJAQBQoSjiTKZjDaiCVY7JCcnQ6fTTUh9CBM+azxsNht2796NsbExB4dtFMbGxvDiiy+ioKAAOTk5AMajgTz00EPIyMhAZmYmHnnkEZdjNevXr0dxcTF++9vf+lq0kEVMTEzATcqFhtAyBEPp5k0GpkWULwolfy2quOQXExODjAUr/cpHDGRlZaGpqcn7gxCmL42NjXH+IIqBYI7p6667DidOnAj53dXJjMnM+c4Lg13qFHw4b6GonO9OEeEsg/Migrno4KtQoiyqvFlVeQKX/GJiYpDzyDs+5yEWcnJyaKt4bxBiPIyOjjpwvhiKJ08I5phetmwZTp48GeH8EMZE4fyPiqbxVrQ4K2+U63Zg5o/f9qkMXMe1uyPRzu3A5PXbThzFqv17eJeJrPkUl+9eEjALWa596Yubbg5Aaa4iNzcXZ8+e5fSsEOPBecM5UEFTKASb80+fPj2hOZ/3jPD06dOIjY1FdHQ0vvvd7+K9995DWVkZff/vf/87YmNjERsbi08++QRffPGFg/+bJ554AgMDAxgcHMTPf/5zl/QlEgm2bduG5557Ds3NzT6KFZrQ6/XQ6/XBLoZfEFKGmSvvESQdvuAig7/KJK7vu1M6ebouL54/7kQvOtrn8omFaB5lEqIvBSt6EuXIMJhjmiAIzJkzB19//XVklzxEMVk5391EPVCj1Tl/ZxnYFFa+TG7dRdXzBHdKJ0/Xlet2jHO+1Ma7jGIjOjqas3JRKM4PxgYW5bQ22Jw/d+7cCOeHMEKV8/lY8Oj1etx6qYmXkteTMj0Q49U5f+d2cFZYyXxQLJBv/BVp6QmQRckAiQS31Yvrg5VLX9qlTgnYd5WCSqXibHkbzpwfGxsLrVYbMpw/US2jeNuzlZaWor6+HiMjI3jnnXewceNG7Nu3j1ZG3X///bjxxhvR3d2NP/7xj1izZg0d6YkC08SODTfddBOWLFmCX//613jjjTf4FhGjo6OIjo6GwWCASqWC0WiE3W6HSqXC2NgYoqOjQZIkLBYLYmNj6QhkBEHQR4vGxsZAEASioqJgMBigVCphNpths9nod9jSoaLWGI1GxMTEQK/XQyKRQKFQ0OUaHR11SIdS1JnNZpAkCb1eT6dlNBppGQBAqVRibGwMCoWCjsLAlg51TSqV0jKw1YVCoYDNZnNbF+nXrETP0c/pdEZHR2lZvNUFMx3nutDr9YiSyzA2NgaZTOZRBk91qtfrOdcFlc7o6CiUSiW0Wi1dFxnzl6PzyBcu6WhO7gNBENBoNJzrlKqL/tovYbVaPdaFXCaFRqOBUqnE0ImvUbDkZugMJvQc/RwGg4Gu0/RrViJWGY0YRRSsNhKjo6M4//X7GBkZ8VgXHR0dqKmpATBuxRgVFQWz2QyCIEAQBKxWK+RyOX3sQCaT0dGXSJIESZKIjo6mj9VS6VDXJBIJCIKAxWKBXC5HS0sLVq5cCYvF4nWsjY6OQqVSQaPRONQp17FGlVuj0bD2C7Z0uPQvg8EAAB77l1qtRmtrK+Lj41llcDfWnNNx5h3n/kXJQJIkYmJiXOpCrVajvLwcp0+fRlZWFlJSUhzqwtkH30RFOHM+gJDi/OxH3kHn9nv84vzVrRdgsVgc6mJ16wXkPPBX3D025sCnQnL+PwtLceu507h3oBuv5BTiG42n3HL+rsJSrLlw1iWdgR3rvHK+wWDAnkULQUqlsKlUIMxmjI2Nofsfd3vnfAlJc37f82tQ/MgbGLNJ0bn9HgfOz37kHcRIbVBJJbDZJRgdHcXZv9zjlfM7OzsDyvltbW249tprJw3nq9XqoHJ+fHw8ysvLcebMGaSnpyM1NTXC+WHG+QRBBJzzb7/cCovFwspPzun4wvnd/7jbhfO7/3E3Ojs7MeYH5/+7sBQ2pZKVq6OiopD17dfQ8rc1GH1to1fOz35oJ9pe2Mh7TFKc/8mRPozOXYBv1P0dP37zDG5PScErOYWQ6sdwS3MT/j19NiQkiVubGjjzk6f+RcngifPvHejGu+++G1DOb29vx9KlSyc85yckJKC1tRVJSUkhwfmNjY0YGhpCenr6hOJ83oqoqKgoFBcXAxh3Tn7s2DH85S9/wbPPPgtgXMmUkJCAkpISLFy4EImJiXjvvfewfv16Xvls27YNVVVV+NnPfsa3iCGL6Oho3lETgg3d2YMOzqejo6N5Wb14wqF/vhwULTclA9PU8eK+fwuWfuq85SAICdqqP/b6rObUAQdN+8V9/6aJyhkX9/3b4QNFER4AqGcvhSo6Cp1HvnB4JykpCWVlZbDb7bBYLIiLi8PY2BikUinto02pVDpMgPR6PaKjo+kQsTExMfTHBgAsFgt9jZrEGY1GKJVKpKen48KFC5gyZYpX2anxEI4kmpqairq6OqSkpARdBqlUisrKSlRXVyMlJfhOlSO4inDkfM2rD4rG+TX/dYdonP/PwlK399g4//bTfjgBtduxbPk0xK66F29+9/8BAHK/8zqa/7bG66sDL2904PymZ9a65fymZ9a65fzkjS9DKSXR9sJGh3cSExMDyvmZmZloaWlBenq6Qzk+mFVBL9AohDPnJycno66uDmlpaUGXQSqVYt68eaiurkZqamrQyhGBK0KZ89nGJBuE5Hwh4I6rs7/9msPvn137C3zjyt9snN/0zFqveb2Zlg2bSgUJacOaS+cBjFvkbHv3OF6c/m1874a5KNv6KUwkgZXF03F74ymav79xsZFWOAgBqi95c0buzPmUokVMzm9tbUVGRoZLWdTffAmd28dPu7ybX4KbGk4EnS99RUpKCi1nsGWQSqWYO3cuqqurXb614Q6/PXyRJOl20Nntdtjtdp8G5TXXXINvfOMb2LKFv9+FuLg4ByJlHg1kc2zMvKZUKgE4Wm1R6TCJ2Vs61IeImY5cLofNZnN4jvm3SqWCVquFSqWiHT5T6fCRgQpzybzmT10wr3mTwVM6zLqIioqCTCZDTEwM/aw3GdjqlCkPW95s6RiNRlitVp9kYKvTmLJFAMaP46nVaoyePeQ1HTYZqPTkxfNdjvYZzx91/G000hYxAKA/xx6+NSYmxiXaBFsYVKaDcbaz0GzvMCdb1DuJiYkYGxuDavq43zhnOZh1YTKZYDabWeuUy1gzGo2IjY2l73uqU+d0PPUvZphWT/2LCunqTgZ/xxpf3snKygJJkpDL5XRdcI1mFe4IZ86nQhNPBs7v7u72yPm71CkOx0H4cP4DPR0O1+Sjo3SdcuF857w9jUm5lICNNINIz8GGjksAgAecyuOcjid+Uq7b4XI0ULfrWw6/nTlfu+vbYEMwOH9kZATx33wFwNUjjlS9MOEv55vNZqhUqgjnX7mWnZ1NWztEOD98OF+v1weF89nGpNic39vbi7i4OLec78x9znV6/0C3S75UOkOvf8fhmtYq48X5znkrlUoQNhuI0VH6W0DV6fdur8R7dT3ITo5D72sPAwB2qX/JKhcXzmcrj/O1t0rGTxox242Nn9g4ny1okFCcP2XKFAwPD0Mul7vIwPxuPdDbCY1G4xfnW61WKBSKCOdfuZabmwuj0Qi1Wj1hOJ/X1uTWrVuxf/9+tLa24vTp09i6dSv27t2L+++/H5cuXcLTTz+Nuro6tLe34+DBg7j33nuhVCpx882+OVJ76qmnsGfPHs7Oj0MdSqWS7ojhBso3kdAypFQsFywtZ7hzNC6UDFTa3pybi+HsPFT7ElMx7U0Of2XQaDRBdVSelpaG/v7+kGmH/Px8XLrkOtGMIHgI1XFKwZPPEDoSnIAykCSJrG+95vb+ek2/X45gmQ5pnZVK7mTg4zuFSnv3lAz8c3ct3lzxDexSp7j4J+EbPY+Lfyo2GQLlNNcTmJzvTY5w5Xyqj2RkZKC3tzdkxnRBQQFaWlqCXYwIGAhlzt+dksmJ74TmfE8w7N7Mmy89pUXBkwyeAlK4C3gx9dE30Taox/efr2H9xoiBtRcbsfZio8M1oerKH3gyQHGGEJx/4MbAOmMHrvaRrKwsdHd3h8yYzsvLQ1tbW7CLISh4KaL6+vqwYcMGlJaWYsWKFTh27Bg+++wz3HjjjVAoFDhw4ABuvvlmFBcXY+3atYiLi8PBgwd9Nh2eOnUqNm3aFJLhK32B2WwOS/NEJrjKQClfvEWdG6zfK1TRPJaFWQah2oGpaLFcrHUrp7+Oz9kQqn2pv78fSUlJnGT2V4aRkRGXXaBAoqSkBM3NzSHTDpR5eLjvjkwkhOo45QOuMlATZOdJvn10BHbGYqR75waP6QgxuXcuA1cZvC3QmAsdm21cpinXVOKL6IP4YM581ueEApsMgY4YxwaK87nILATne/MxKhSoBTuzTxQVFaGlpSVkxjTluybC+aGDUOb8uMICTs/xkYGNM/tGDCBJ7i60A8WXbPCm2HGnuKM3akRUDLHJEOiIcWwYHBxEUlISp2eF4Pz7zp32+X0+YGvTgoICtLW1hcyYVqlUMJlM0Gg0wS6KYOB1NG/HDvcDLjMzEx9/7N0njjvk5+ezRsB69tlnaf9T4Q6bLfQi3nAFpVjg2vmdlTRsEDscpbt8xWgHtuN0YiJU+1JpaSmOHDmCkpISr8/6K4NGo0FBAbeJlVhIT09He3s7ZsyYEdRyUFi0aBGqq6sxf/78oFqLRTCOUB2nFDwpMqgJL1fOZ06Qqb/fz8zCrXeVg1j7PUiW3cK5XNTEn6+ihcrX+Zidp3agnuNjXcS03Bo8egwrr/x2zldIhGpfKi0txcGDB1Fa6t5HFwUhOD8nJ8evNHwBs00zMjLQ2tqKWbNmBbwcbFi4cGGE80MIoTpOAWDJSzvwcdVSrxzlLAOf6KDUIv5/HlyI760anxdx8QtIveerosX5mJ2ndqCe46JEouRd7/S8kJZc7hBqfYnqB2uHenHw4EFO7/grw/DwMB0MLZBg9qWcnBxcunQJc+bMCXg52LBo0SLs378fFRUVrMf4wg2B9xQ9iREbG8t6bjecwEeGQCtnuEKMdvB2PE9ohGpfkslksNls6Orq8vqsvzJYLBbWs92BRFlZGQYHB4NaBiaioqKwbNkyHDsmbljhCLghVMcpH/CRwXkxYDFbMTw0hv2P/BgAXDab+ByL8wY2CxYK3mTwpQz0AkXTH5DjEqHal6hFZmdnp9dn/ZXBZDIFzBE0dUTHeeE9ffr0COdH4BahOk4BIGH6NE6KcqYM3pRQ7tL7j5cOA3DdcOZiScT1u+ApLW/t8GZaNl6peQoxBPcNcerbFiirpFDrS1RbU5zf3t7u9R1/ZaAiSgYCht2b6X9MlJaWYnh4OCBl4AKZTIZly5ahrq4u2EURBH47K4+AO6ioOOGsweQiAx8ljJARlNh8NrEhEO3ARwHHLDdX5V0o96Vly5Zh7969SEpK8rhoCGUZuEKv12N0dBRmsznoSjEKMpkMmZmZ6OrqCqlJzGTEROjjXGRwt6i4d6AXAHCdm/fcLWK4WhW520V3fp9rO/C1ZnJ+3pdyszkqZ0Mo96UlS5Zg//79dJhrdwhlGbhglzoFq1svYGxsLOQ4Pzs7G52dnRGrqCAj3Ps44CgDZf3Jldu8cZm7+/4qd1yCPXhph6iEBNx1/gzu9TMfMZVSodqXqP5QXV2NpKQkj/NMf2WQSCQ+vScUlOt2oPsfd2NsbAxGozFkImLKZDLk5uaivb095PoHX0xIRVRraysyMzORmJgIqVQa7OLQCJVJiz9wloGpdPJ2HM/5WX+O5rEpbLgqf8RqB1+toLgcY3RGKPclkiRhs9m8KhlDWQY+kEgkoh8z5YuMjAy0t7dPGkUUFWI3KSkpwvkCw1kG5+MJbH+7e5YkSZ83H9gUNobdm6/snG/2uFASqx2Y8vFRYnmrNzaEcl8iSRIWi2XCc/56TT+0Wi0kEgmsVmtIyZOVlYXz589PGkVUhPPFw4fTZuEbl8aDRFFKB3+OHXPlfK5HAKlvgSfu9NYOd50/w6lMbKDqQmzLqFDsS1S7kCQJs9kMmcyzGsFfGdhc9gQSht2bodVqIZVKYbVag1oWZ2RlZeHs2bMRRVQoIj8/HwRB4PLly7DZbFAoFEhOTnYI1xgBO/gep2N71t37fI/puSuL2MfefEEolilY2L9/P+bNmyfqR5QkyaDvlADA6dOnMX/+/JDZJaEQHx+P/v7+kFOQiQU2zp8yZUpITuRCDVwtciiwPctnl/vt3CJ8W8t+tMldWSiFjyffUb76lfL1nVCIXsSGYEzcq6urMXfuXNF5MFQ4f968eQE7LsIVKpUKGo1m0kROjXC+uPhnYSni09P8jmRqt9uRsflVmN77kddnmXkx89y0apvH74IvCiE2xRrXb0goBIkINqqrq1FeXh5yc18x0NDQgDlz5oTcxq5CoYBWq0Vzc3Owi+IXJqQiCnA8l2o0GtHX1wez2Qy5XI4pU6YEJRQj5XU/mBOY2tpaj2E39778F9TU1Li9f9umRwEA/975jN9lGRgYwNSpU3161x/fU0K3QzCUUFxl4BpiVSj09PQgNjaWk4ben3bQ6XSIiYnh/Z7QuONbP8SlI18HuxguIAgCK1asQENDQ0Dy2759O7Zv347W1lYAwIwZM/D4449j9erVAckfcOX8/v5+WCwWyGSySc35x48fh8FgcHv/yx9M88j5dz71IQDg/V/dii9uuhk3fuZ7UJLBwUGs73IMPcxl8r/z0y2s7zDf8/Q+l3bgs+NPLYDilXL0vrgB7+QVYZd6i9dy+AOufSnQ0X36+vqgVCo5RVHyl/MDMYa99YM7/vMDXNy1VfRy8AVBEFi+fDnOnPHd0iPcwMb5kXm+d873hvTXXkT1hgeRI5ciesVWbLWOy+TpO+EOg4OD6H/5IYdrnhRI1NhTrtuBnZ9uwaZV2xzeYb7nSQH1TulM3H76uEs7UOOb8u2389MtnL4hzqDKI5NKMPr6Js7v8UGozvMHBgYQHR0tOufr9fqAKLq8bcYF6tvDFxOF8yesIooJhUKBrKwsAOMOjgcHB9HT0wOpVIrExETExcUFpByhoE1VKBTIzMxEZmamT+/r7eNWZddt/FHAHZELpfARsh2CZQnFVYZp06Zh//79WLJkiaD+uNhw6tQpGAwGVFZWcnren3bQaDRITEz0+X0hMDAwAJ3REhLjmg1nzpxBW1ub9wcFQHZ2NrZt24aSkhLY7Xa8/PLLuOOOO3DixImgRBSMcP5VREdHIzU1FdnZ2T69b0hoBADc8NdzMOhGeL3LRbnDvD+ucLo6IaQXH4wdcV9257m0A5dFiN1uh2r9Tvp3vHYALxeUwQAFEqDlXS4+4NqXysrKsHfvXixbtizC+T7AUz/QaDTQ2xUhMa7ZcObMGXozYLLBmfOHhobQ09MDgiBoPzaBsKgLhb6hVCqRnJyM3Nxcn963Wq24rr0VEqsVmxUKAE9zz9vDop7ibgNjjDkrgyiMp7HZJVodF+xSp0AqJfBRUSnuH+x1uMfMh8qDK/5ZUoaGaUuwM+Na+trIKxt5lY0PQpHzGxoaMDo6igULFnB63l/OT0hI8Pl9rmDrr9TchfruhMK4ZkNjY2PYc/6kUEQxIZfLkZ6eDmA8rOTw8DAdASUhIQFqtVq0j5VQjueGh4fps6rMsnL5OzMzE59//jmmT5/uUyjKWGU0AGBkbHy3RcjIeM7OxoU64ueMUHUAyAdcZcjMzARBEKivr0dFRYVo5WlqakJ0dDRmz57N+R0+7eDcN4J9bhwARkZGcPrzd6HT6UKyL7W1taGqqioged12220Ov5966ils374dhw8fDooiiokI549zfklJiU8cECMdD7+stY5PF/ge5fukMA+aIT0A10W+8864OyUAmxKKz+61UO3w5w/HLQzv0JxCTUIJGrL244uOBNhAQD/SJ+qRDa4ypKen4/2pMxC75zPMny/eRsmFCxcgl8tF43znvhEKx4yHh4dR+6e1Icv57e3tAeP8UIZcLkdaWhqA8X4zPDxMb8rEx8dDrVaLtmAPBc7PyMjA559/jv7+flRUVPD+vvkiA83Nq7a59SPIhnE/f1vc3ueTFgVKgeCujL7w9C51CnRyJZ6OWQBojfT1z66/Eav37+GdHhfw4fy87+5GdUwM500BX9Dc3AyJRMKLY/wdD2Ir1rxhZGQEKpUqZDm/tbWVs1IwVDHpFFFMSKVSJCcnIzk5GXa7HSMjI2hra4PdbkdsbKzgThC9OXXjisHBQWRkZNC/mYtyLn+vXr0aQ0NDaG1tRX5+Pq+8W2s+AXBVyy20VVQgrKyEagdnaygq6l0gwEeG9PR0XLx4UcTSAL29vVi2bBmvd/jI4NwvoqOjMTo6yis/oZGWlob6+np6FzaUUF1djby8PL/6usVigVbraOURHR2N6Ohoj+/ZbDa8/fbbGBsbC7lFERvnt7e3gyTJCc35q1at8pnzm/9xP4CrnM9HCZU4JQZ5+VNwStMBkmRXHnNJz1cFFAW2dvDF+e7/e+MYHk3WYP6BD3CHyQRZw1Gcun4d4oZ78XDrBd7l4gM+fem72kFUV1eLWBqgu7tbVM537hcKhSLoIbRTUlJQX1/vs6WJmKiurkZubq5gnDNRQBAEpkyZgilTpsBut0Or1aKjowMkSSImJgZJSUmC1plQaQ0NDdEbKAB/zr/ppptozi8oKOCVt1h9iG+UVH98QLHJsGnVNpdj3lxBHRHse/GbSH3oVbpcdrs4x/IAfu1gev/HonP+5cuXReV8Z0RFRQWM853nA9Tfe2ZVoEMZjZ80nw9IOfigpqYGOTk5Ye8Xb0J+sVpaWpCVlYUpU6Zw3gmQSCRQq9W0xlOn0wnuBFEwBYhc7rd/nISEBGg0GvT19SE1NZXze2JOcrwpoYRSUvkrA2UFRpWHUj4JaR3mDb7I4E/EKk/o6enhdFbcGf5+oAJ9Lt4ZsbGxsFqtITfxN5vNGBoawsKFC6HX613u/7P7BUi89AOrdQhvvfUW7rrrLofrTzzxBJ588knWd06fPo2qqioYjUbExsbivffeQ1lZmc9y8EFLSwsyMzORnJzsM+ePjY0FjfO9jUuhOH9kZAS9vb20tQAX+Nq/7boRKBRyNDZ0Ye1QH+szXEN9++t/iU0Gb2kxd88pK7CxXeOLjpX9JtTYk7Hpx5+h76NXII+PR5Sb3VJ/ok0xEUqc39fX59PucITzxYE3zp+I8JXzExIS6OM+Y2Nj6O7uhtVqRXR0NJKTkwPG+d7KLJPJBOF8rVaLnp4eB6WWN0ilUqC7DXZZLiQKbr591mv6MThqBL79OgDflEdMcFVCueNXtnbwdhTPU57uIp2ytSNfq2F3CCXOHxgY8Ckipz9cqVAoYLFYfH6fC5ibXGx9SUEQWLLrtZDk/OHhYVRWVsJoNHp/IYQRWjUrECjtf3NzM3Jycrzu4LNBDCeIVGcJlSgDarUanZ2dGBwcxJQpUzi9E2oy+AJ/ZGCzeAq0ryyAvwzTpk3DoUOHsHjxYkHLQZIkTp48iRtvvJH3u/60g0KhCAnytVqtMBqNITUeNBoN+vv7/f5wrlmzBv/4xz8crnni0tLSUtTX12NkZATvvPMONm7ciH379gVEGVVQUACJROIX58fExNATfybnU87OfXG2GWp8mZCQAJ1OJzrn260W2H5xH4YGdDCZ/A957K8ixxcZmE5znfH5m7/klIZQSijAvQzujpuUlZXh4MGDWLJkiSD5UyBJEidOnAgK5wdbEQWMW4qGGudrtVr09fWF3GJJTDA5Pzs726f2YHK+yWSakJwfHx8PnU6HgYEBJCcnsz5D8RTFJcnTslFRmY/uS90o/Ogwp3wsVhLZV5RQvoKy6JJIJKx+o9jK7Q6+tIMQyiOhlFCAexncKczKyspQXV3N22rJG0iSRF1dHVasWMH7XX/GQ7A2H5jf1PWafnzxxRchx/k6nQ5dXV2IiooKibWQP5iwX634+HgoFAoMDAz47JibgjvHt5QTRK6Ob0MhypczsrOzMTAwgEuXLiEtLc1rGcWQgancYVPqcLU04vpcKLYDX3iSga0ekpOT0d7eztsCzhuGhoaQnZ3t0w6MP+0QFRUl+k4J13KEUn/S6/U4d+4c7rjjDr/TksvlvHbAoqKiUFxcDACYN28ejh07hr/85S949tln/S4LF8TFxUGpVKKnp8dnx9wU2Bzf9vb28nZ8G0p9g0JWVhYGBgbQ3NyMtLQ0r044fZKhbfyY2l09XdidmOqikPHm94PrZJ7rc95kcKfM+erWO9H80itY+v8+9JoHG4T0GeVOBspia73T9aSkJKhUKt7WEN6g1WqRlZUVFM4XOiKgLz5jQo3zjUYjzp49i9tvvz3YRQk44uLioFKp0NXVhZycHL/Sio6OpjnfarVicHCQ5nwqwEW4cn5mZiYGBwc9cj5TqTNwqRdtCgJz3+HOe/Wtgw6/+SpkdqlTULW0GNm5STh5vB3rerwHWvE0bt21AyUnddTOuYz+HAf05z02uJPBXR5JSUmIj49HV1eX3+teJnQ6HdLS0nxSdPvL+ZSfNKHgzS+ldWwMEoLAuqGrTu4jnC8uJqwiChhfSFmtVrS0tEAul0OlUiE+Pt6vXSN3jm+5fKDGxsYAsA9Mu90OiUQCq9UKiUTiMdqV0BGfkpOTMWXKFFy+fBmjo6MeJ61USFi5XC5I3t6UUJ6u+/ocXxmCFRnPE9hk8FbOadOmIa6kArbL5wQpA0mSOHXqlM8WL/70JZlMFhLOa81mMwwGg2DjwV+0tbXBZDK53fkMJEiSDPhuFtUvmJwfFxfnV/u4c3zrL+dTsFqtkEqlDpxPfQ8oCB2xheL8rq4ujI6OOvifcoa3ccq2mJcUlUH6P2+7PbZAp+1mQs11Ms/5OS8ysDpRt9sx9q93YbNa0TfquOMopKUTV7DJ4C2aVFlZGRJu+Q1MX3GPeuUJJEmivr4eU6dO9el9fzhfjOMmvrShxWIJOc43GAyCbjCFEyiffhTnK5VKxMfH+9U+MpmMF+cz+ZoL59tsNsjlco/zfKEXvpSfrMuXL0Or1TooKpzHAeUbUuJmI4pNWVNZnIK+F7+JOGWUT1HuAODooUvIzk3CnIpc2P7jXsj+9hGvdJhwxzW0rG443N03RUhLJ67whS/Lyspw9OhRQRVR9fX1KCws9OldodeM/sJbG0qVSihSU9H+3vvIvetOAKHH+R0dHV7X6uGECa2IkkgktFNJq9UKvV6P7u5uWCwW5OXl+e2Ulun4lgsocvflnK3YkEgkyM7OxsjICFpaWpCfn+/w0RXT/1EgnXz7AmdfUL7Ugz/vcoW3tFUqFSCRCLZbotfrERcXN2HIMNyh0+nQ2dkZlMgeW7duxerVq5Gbm4vR0VG88cYb2Lt3Lz777LOAl8WZ83t6emA2m5Gfn+835zMd33JBqHN+VlYWtFotK+dznXi7W8zvTs+jTdudYdi9mddixZ9oR77AWe7R1x0d0nIph78761zATJvVv4VCAcjk6Ozs9NtKEBjfiVUqlYIucsRGoPtOIKHT6dDe3h6S0ZwCCcoaymq1wmAw0Jzvb8AOYGJxPgCa8y9duoT8/HyfFLzOvAOMj6/Uh16FYfdm3pxHjU27dhh7KucjM1uN72WsxWERlT98HaQHWgkFAO+XzcadZ0+5vc/2jY6KikJsbCza29sFCapgNBohl8sF+X4ECv58eyUEgdUH9+GfhaWoeejbIffd0Ov1E47zgxsXMYCQyWSIj49HdnY2bDZbUI71KBSKkDpjyoaEhASkp6ejubkZNpvN4Z68eL7gMlDKE29KFHnxfLfKKr5KLL4yUHkzHZTzgRhKKF/bwdJ+Bi0tLYKUQaVS0bsdviAcxoM3SKXSkIlY0dvbi+LiYlHD97pDX18fNmzYgNLSUqxYsQLHjh3DZ5995pMfGaFAcX5OTg7sdrvgx3q4IBz6eHx8PDIyMtDc3OxiBq9ct0NwGajJobdJonLdDnpC6azQ4rvjzlcGZt58Q59T7wPCLl68yeBuwmz45Em0trYKVoZgcj4zKhgXiKGECiXO7+/vR2FhYdDDd1ssFvziF7/ArFmzEBMTg8zMTGzYsAFdXV0BLYdMJkNcXBytmAqGf5lw4fzMzExcunSJ9egTHxncbTb4Akl8IlY0NWP6V3X4+rWf+8WfvraDL4o0sbDu0nmPMrgrZ3l5Odrb2wUpg79+mgI9HijlnD9tGH0l+BLVr0ON83NzcycU509oiyh3sNvtQflQUNFMQqVDu4NSqUReXh4uXbqEnJyc8cgFV5QoGo0GQGBl8KbI4avg4dMOQlhqiWEF5WtfslqtvCfz7tDS0gKtVouamhqf3qcWNEqlEiaTCcuXLxekXBTOnDlD91exMDg4iKNHjwruHNIX9PX1Be1I3o4d/BQDgYTdbofNZvMpwIS/CBfOVygUyMvLQ2trK+34l5rIBYPzKfh7dI8Cn3ZwVnJ5izDJBjEWMp5k8HRUkCRJv44xM9Nua2uDTqcLGud7Uwo2NjZiaGiI/p370fsA4HN52TA8PBxSnO9LxFqhodfrcfz4cfz617/GnDlzMDw8jB/96Ee4/fbbUVsb+GAuwPhcJxh+XYLB+c5HublAoVAgPz8fra2tyMrKcvg+hst3yxN85ctQgicZPFks+8v5zLQ7OjoEm+cbjUafHJ57gjPnf/mDaYLwfe5H79PpaDQaHDp0CNdff73f6fqLvr4+xMfHi3JUnQ+E5PxJp4iSSCRBI9dQ3yVhQi6Xo6ioCB0dHVCpVEhJGd9ZDLQMQh7Zo6yauMoQyscFfW0HvV4vmMl4UVERioqKfH6fGU1j//79gpSJieHhYcEjRjnDaDSiurpatJC5fHDs2DGUlZWhpKQkqOUINUgkEp+i6AmBQPOlcxQhPpNtuVyOwsJCwTjf14n+mh/8A83SRJ/edQY1oeYqg3LdDlTFmbEkW4X/bhTWSaq/EILz/bUQKigooKMS+wKxOX9wcHDScX5JSUnQOT8hIQFffPGFw7VnnnkG11xzjWBHhPhisnC+ct0OjL26AapvvoKdn24BwH18y2Qyep6vUChoP2O+yuCrAp602UD4eWzeGWwyUAoooZRQvigA+cAfzqf8Svpqncv8VuTl5flUDsB/zve2cR5IzrdarUGPTHr06FEUFhaitLQ0qOUQkvMnnSIqmBDa+7/YIAgCeXl5GBoaoqPqCWFNw+WomhhKICo/Lu3gnL+Yvp34Ql48H8P1e316t7W1NSiTQjZQ7dDe3k47BhUSaWlpaGxsxPTp0wVPm4LVakVhYSEaGxsxY8YM0fJxxrFjx2AwGEAQBHJycjBlyhTo9Xq/JgwTGUJZAfJFOHN+c3Mz0tPTBak7LpNh5bodUJt12H5uB2x6Az64+xd+50vlx6UdqDL+6OCzSF5Yiemfvg/AfXmdlTpi7rIr1+1A/wtr3d73lC9l5ebtOTZ4Co/uC6h26OzspBWdQiItLQ0NDQ2YOXOm4GlTsFqtKC4uxtmzZ0XNxxm1tbXQ6/UgCAJZWVlISUmBXq8Pme+5M0ZGRiCRSCaULxMuCCTn71KnAFeiv1FKKOY95/HOGljiii/d4eFhOqpeILFLnYKC++/DBvsCnP/7fYKly2wHbwp4LgE0mM8adm+G5sxZVG/chFtrDzvcF/I74K4v7VKnwOCF849edyMqtIO8FVDM4/BCgJKhq6uLs581Jrwp+rKysnDq1CnMnj3bp/JxgdVqRUlJCc6ePStqPs44fvw4dDqdC+f7GyFULPjK+ZNSEWW320XXZLMh3BYlFJKSkpCYmIje3l709/cjMzNT8ChOTHjyBSWEQohPO4SSAoqJ/MWrcXHfv3m9YzabodFoUF5eLk6heIKpiFq0aJHf6VVXV6OiomLcKTuAkpISNDY28vpI8e1jVqsVSUlJaGpq8mgOTBAEoqOjER0dDYVCAblcTp+dVygUvKw0qWh0y5YtA0mSaGtrw8WLF5GSkhJxHO8BE5nzhd7pdeb8jIwMUTmfmvz+6eunYLDboUhPw6odW7Frx1ZBZOLTDqsP7sfHi5Z5zXe9pl9wRQ0bqMVm0XdfR9Mz7pVRbLBarRgYGPB58iy0Yo1qh7a2NkF8XDwRm4B8QoaHtOOh40tKStDU1IT6+nrO3zm+0bCsVivUajV6e3sDxvnA+K48xfkdHR24ePEikpOTBeV8i8VCO9umQMnAt6y/+MUvsH79+qA57Z7o83zluh0waPqx/spv57HKd+wmJiZCrVajr68Pvb29os/zmfht2o0496vVeKdgKr654BdegzBwAdUOXN6ngmdw4YGdn27BLvW40k+VnY3dyRlYN9BN5yUElOt2YOenW2CJi8Ptp4+73Pckj9VqRV9fH757hRO5gqonoY+VMzl/3rx5fqcXvWIrBv/1K7pvFhQUoKmpCcePH0dFRYXf6bPBarUiISEBfX19AeV8vV7vwvlTpkwRNFhIKHD+pFREpaSkoKurC1lZWQHNN1CkLgYkEgnS09OhVqvR2tqKxMREn83SvS30hYhS5wlc2iFUFVDAeNl8meycPHlSNKL2BVQ7ZGRk4MKFC36Zmvb19UGlUuH48eMOZrrTp09HdXU1gPGPidFoRHd3t9ujDHzbnZLB26KKyttsNsNoNMJkMmFwcBAWiwUmk4l2pM2cODv/LZVKkZeX5/ARIgiCPiqTnJyMvr4+xMXF8ZJhMiA1NRWXL18OeOSXQHG+GJY4zpyflJTkM+d7mtwyd3fj1lihshjQ9tz9eK+kjL7vr3xc2oFZRsPly5zSDYQ1FDBeNl84v76+PiQ5PzMzExcuXOBtrcq0zhsYGEAUJGglHeultLTUhfMvX77s9vvCd+ElFudTsjlzfk5OjgNvUVaLeXl5SE1NRV9fHxITPR9l/d6mBYiO8TwGXjwei3feeQf33nuvw/UnnngCTz75pMO1119/HQ8//DD9+5NPPsHSpUsBjC9s1qxZA7vdju3bt3vMU0ykpaWhs7Mz4NYDgeJ8XxQG3jhKIpEgLS0NCQkJaG1txWdF03D/yIDg/MZU+qy/okyz2+247u1dwB/rXe77AqodhObldSdrYPvDY/j3uydQ8V+/Q/Ztt9D3hMxrvabfJ84/deoU781mMTdUnDnfn5MDQ0NDAEEg6fbfwrznD/R1vpzPF5QM3gIBCTXP98T56enp6O3t9eob8LsPXgNlgtrjM6+cisV7772H++5ztEQMNOfzUkRt374d27dvpyOwzJgxA48//jhWr14NYFwj9h//8R/YvXs3TCYTbrrpJvz97393MPX84IMP8NOf/hQSiQT/8z//g1tvvRXAuClhQUEBUlJS0Nzc7LCYKi8vx5133ulSMb4iNjYWWq0WOp0uoMohnU4HAGFtqmw0GqFWq9HV1SX6ok4sZdBEaAdfZDCZTCEVUpiSoaioCLW1tX75kmhpacGcOXNcnOQxHTbW1dXR2n/KCT8w7oiwoaGBfl4qlaKyspLT7gXXdpDJZH5zjdVqRXV1tdsd8PT0dBw7dswvv10TFTExMdBqtRgdHQ2oom4icI3RaERiYiIuX74syqKOOXkffethh+tCLYDeKJiK208fF6UdxJzEM9P2pS9R3+tQASVDQUEBjh8/jra2Nl7HiSUSCe2baXt+MbIJKUo+/pfDM0zOP3HiBEwmE0ZHR5GTk0Nby4Yb57uba6WmpqKtrc2vPJi455578NxzzzlcY9sZv/322x0UcdSmLrUgaWtrw549e4I631CpVNBqtdBqtQEtx0Th/KSkJAzbx8eS0Ap3NiWaRCKBlBEkgwuo8rCVK+vBHWh6Zq3f7eCc9j+vuxUJ6Un49c2/QcPtt/qVNhuYxwR96Ut6vZ5zAAMxooo6g5IhLy8P9fX1aGlp4eVnUCKRQN/bC1VaGjLW/i8Qn4k9j81xeIbJ+fX19fjguhWoens3srKyaA7WaDQ4c+YM7HY7/Q2ZP38+Jz9cocb5zc3NfuXBxF133YUXXnjB4VqgOZ+XIio7Oxvbtm1DSUkJ7HY7Xn75Zdxxxx04ceIEZsyYgcceewwfffQR3n77bSQkJODRRx/FN77xDdqUzWQy4fvf/z5efPFF2O12bNq0CStXrnT4+I+OjuKPf/wjfvOb3/AWhg+ocNVFRUUBM90N5wgUFKKiohAVFYX+/v6QcNzmCyZKOwDCHVcMJC5cuIC+vj4olUpMnToVADB//nzs3buXVkRRiuKxsTH09fXBZrOBIAhIJBLExMTAYrGgtbUVJEkiKioKWq0WCoUCKSkpOHbsGL1z8fbbbyM/P58+vmY0GmG321FXVwdgfAdCpVJh2rRpSJtxDZ596pd0+GcuSrFA9iXqI/f111+z7vTIZDLYbLaAlSfckJ6ejubmZsTGxkY4nwcozh8YGIDFYoFcLhc1P+bkmG2C7Mti6J6mBr/zdQcxJ/HMtKm+xPcoWSigubkZ3d3dUKlUNOdXVFRg7969tCJKq9VitL0ZY/+/vfMOc6Ja//h3Jr1tsiXZ3peysNI7SBdBRVFAFyuCveu1YEW9FixXf17LtYEdUFQsqCDCLr33zvbed7PZtM0mmd8fYYYkm162wHyeJw/LZObMec85883MO+95T2MjVl41D1P//J2JwIuIiEB7ezvKy8uxfsYV4BMERv30PS6//HKcOXMGe/bsYW6S165di/j4eJSXl6OgoAAGgwEUReFNVTzi4hUwtndA36xHNMnBA5dcj//dPhwymQxJSUk+OcW6WvMjIiKwefNmZGVlufw+lJrP4/F8epCQyWSdHPr0A0lBQQHy8vICygcTauLi4lBYWAiZTMZqvh/Qmn/18cNdovnecgg6a54vi3KUfHqLX+f1VVPnlpwFALj6RQmFY8e+HuEeS+GcXk5rvkgkYu5XhwwZgvz8fMYRpdFosOdwMVRHd+G+Pc14/c5LIdS1wiSRI0KhgKG1FdV33YeGwYNwfVMaHtv5AV7XtaKgoMBB8/9Z9TUi5RH4ICIKp8wd6KAo/HTdfOzmcKDnS/HeqLtAWMz4YM9HKIAF6g4zpn+1AjU1NT45xXqS5pMkGdKcpz1B8/3yIsyePdvh/6+++ir+97//Yffu3UhKSsLy5cuxcuVKZkneL774AtnZ2di9ezfGjBmD9vZ2cDgcJmyQy+Wivb3doZMffPBBvPPOO7j//vuZFRzCAUEQUKlUaGxsDEvSzAud+Ph41NTU9NikaRcaoXA4BbOca6goKChAe3s7xo8fj8LCQmzfvh3Z2dlITk6GSCSCXq+HVqvFqVOnkJCQAIlEgtGjR0PUfwwAwGLUY9+v32DAgAEYPnw4amtrcezYMWi1WpSUlKCoqAilpaUYc+1tgLUDFAUQBHDk77WYMmUKeDweIiMjHRyo9BRQUhaF3NxcyLNHA1YzQJBoObkHXC4Xe/fuRWpqalArRoWCESN67kqOPR162kFDQ0NYf1suVGjN74rkyN2xtHaw5wzn9JVA6SmabzAYMGHCBBQXFzOan5iYCIlEAq1WC71ejw8y+2LB1YMh4XKRSXJx+UcFAABLaw12vHw5srOzcXbaTCRwuCgzd6CtrQ0lJSUoLi5GSUkJJr7wJ3gWPe6S1OGz5gjs+PAuTJ48GVwuF1FRUdj0+iuYNmMg2o0d2PjncXDik7C2/RAuve5VqG76ANQnB0BweGj46SlG85OTk7s9wrQnTa10R0dHB+bNm4eDBw9i3bp1sFgsqK2tBWDLN9edzpm4uDjU19d3eRLuCwFnzQ/39GNXrFIosQJg8jKFsh6+6Kunc9lr9GpVIiL69YXmzNmQ1C1QfNF8+9+qcPRpUVER2traHDS/X79+SE5OZmYkmUwmJFz/BmJl0XiNPIHrFfG4ND4K6298HDlvvoTadhEGDB4MdWIikmdfCeqzfRj+1XKUlJSgsLAQJSUlEAgEaKmrQcb6r9BmMsPK52IAAA4ISABwSBKbk4aDo0jCH0dfR9zINNzePw5FRQ34fdHdEPRToS1Wjoy3PgY3cwD27t2L+Pj4bl+F1BfN7+5VW0Op+QFbYbFYsHr1auh0OowdO5aZ9jJ9+nRmn/79+yMlJQW7du0CYHurdfvttyM+Ph4JCQm49957O3nYFixYgKysLLz88suBVs1nIiIimJC7rsBkMjFzRHsrtA18Ph9Wq7VXJmBPGXt5t/cDL2sE8wkEuh/8cU5xQrw8rj/wskaAkzEM/Sdfxaw0FBMTg5EjR0Kr1eKLL75ASUkJvv76a5SXl+PSSy9lEv9xuVzGToLLR3l5OWpra0GSJJMsfNCgQczqL3PmzEHLyd2AUAaORA5SLEdOTg4SEhKgVCo7RfF1FO5nPpFDJoMUiECKZABfgMgBo7FhwwZYrVaIRKJOdvW0a1qpVKKysrK7q9Fjkclk0Ol0XXa+njY+AoG2gcfjgaIojyv5hOLtqi9Jwv0l/a5vwt4P7laoohHlLmc+gUD3gz/Oqe7UfFHucgiu/wQD7/6MSZYeFRXFaP5XX32FoqIifPPNNygtLUU/goPqsmbs2XoWXJLEivVLsGL9Eny4412smjQNNTU1IEkSFlCYu2UTBg8eDJIkcWT+jaCWPIePdn2A5KRMTCo6hh/5hRg0aBC2DBgMlUoFLpcLo7EDZ0/VQiDk4arrhkJJaNFWWITd83LxzegIcFT9AHkilHPfwsaNG3uN5sfGxqK8vLxb61BVVYXffvsNlZWVGDJkCOLj45nPzp07u7VuUqkUer2+y87X08ZHINhrPmB76HRFMHpmj7Om2f+WOOjquag2+jtPvzdd0Q/29b6hrhICH6fE+UogNnjS/K6Yimc2m1FWVsYEnNCar9fr8c0336CoqAjffvstiouLQcT0hbbdhOaqWqjWfoFfJs6AVCrEqVfexLhHv0J1TQ3mxMzHiDW12PHWjbjkkkvA4XAw5//24NH1Box+eRsq598M9dkGNB+phsoCRJEcyEkSXJIEAaB/cxEiCRMunT4Qffvb0lpkZiqRyOUiXSJCWmIkdi26Gc9GqWA2m3uF5sfHx6OioqJb6xBKzfd7XtWxY8cwduxYGI1GSKW2RFcDBgzA4cOHwefzO82hjI2NZbxkgC0J1iOPPAKSJF3m6iAIAsuWLcPs2bPx6KOPBvQ2qq2tDQKBAAaDAWKxmJmOIxaLodPpIBAIYLVa0dHRAYqi0NLSAj6fD5Ik0d7eDqlUCp1OB5IkwefzYTAYIBKJYDKZYLFYIJVKodVqHcqht3G53HM3PUZIJBLo9XoQBAGhUAiLxQKhUIi2tjaHcmjPoclkclkObQMAiEQi6HQ6CIVCmM1mmM1mj+VwOBzGBldtQdfL3gYej4e4kdMh4HFReyDPoRx7GwiCQGtrKzgcjsu24PF4TJs6t4Ver3fZpt7awlU5vrZF2oQrYbZYULb9D2Y6l3NbOJdjb4OvbepLWzQe2IT0CVfC2NEBtVrtdXwZTu+GWq1m2sJisUAsFjPLZfrSFq2trTCbzW7Hl7e2CGR80TY07P8HQqEQCYPHYtu2bUhISEBDQwNaW1shEokQHR2N5ORkKJVK1NXVYf369Th9+jTuueceqNVqCAQCHP/jO8TGxiJu1AxIRQKU7VwPlUqFiIgIZlxERUUxbaE/tYtpU9pub+OLy+FAJLDdfBlNHag+mA+hUIitW7fi5MmTiImJcSjHYrFAIpFArVZ3aouSkhJUVFSAx+Ohvb0dMpmMSc7r6/iix4XVamWiBzyNr5iYGJw4cYKZitCTfjzDiT+aD9iSXgoEAlbz7cZP0p0rwSetqPpysVvNJ0mS0SHntphVWgAejweDwRBWzV+d2R/XF5z0qS2y7v8BZopA0fvzulzzr64qdWiL2k/mIev+79FuIXzS/LZvb+vVml/z8VyIxWIkXrvUpebHxMQgISEBsbGxqKurwykRH5sKmjCxwwJSJgNpMqERViw8cxJJ9/6I717ajOKqUnA4HIdxcV91GX7P7A+LUIjn1r+CKWdPouXUaXwXHQuLTMY4ITQcATKy49FK8sABhbScJNREJKHp+AkkjByBCJ4IBoKH8jX/glAoxLZt23Dy5EmoVKqgNL9///4gCCJsmh8dHY3jx49DLpd3m+anpaWFdLqIL/ij+QRBoKmpCUKhkNV8H8ahs+bTz0jObVHz8dywaP68hmro9Xom5cIjV72C//z9MigeDxRJgqPXQa1W45rqMnwbl4yrTh/rVI7FYoFIJAqL5q/K6If5Z090GhfxC27AuB9XQ61W+9wWnsZXqDX/yvIitLa2MjaQpnbMKToTMs3v6Ohg8vBt2bIFSUlJaGhoYPoxKioK8fHxGD9+PGrOnsWfV4vx2BdFeDp1DmR95+E/G/+N6pIqREdGwbDv/6DVatG4PLeT5jeseQxJd38PEceKB65ahg+2vALw+ZDEx0Gr1YE8p4H/mv4cdBYOhstNaDRSkPE5aCc4EFvNGD9nOE6frAG3shWNjR14avcOHK+rxalTpxAXF+ez5peVlaGsrIzRfKlUiuzs7LBqfmRkJI4dOwaFQnFBaL7fEVH9+vXD4cOHsWfPHtx777247bbbcPLkSb/KkMvlHhPGXn755ZgwYQKef/55f6vnNxKJpMvekOt0ui6NwAqWwi2/d9qm0+mY9uJwOG7flPREKndvQOOhfAcb/EE6YFxA582aNBsJoy/rtL10x59QH90WUJn+jCWz2YwNGzZ0e84GLpeL4j15yM7OZn4Yhw4diqSkJIhEIvTv3x9HjhwBSZJITEzEvHnzHMI7//jjD2RNmg3tyZ0uxyaNYtClyJo0G1FDJjHb6L6LGzENcSOnuzuUoXS7Y9+MGzcOCoUCe/bsccjJ4akfiouLMXLkSIwbNw6jRo1CWloa9u/fj+PHj4ctkpDD4XT5A0Fvg9V895z54IZO25w139SmAaVpxh/ZA/BzVn/8dknXTx36MSUTa/sOZM7trg6ln9yI2hW3BKz5ilu+DKh+/R74Hil3fddpe9FHuWj86ja3x/2U5n5KgD9jyWq14u+///a6mlq4IUkSBd891UnzU1JSIBQKMWDAABw5cgRcLheRJBdXxEdCwCVx9bGDIPl8HCFsfav+ZqHLsflrzhAAwL3TbTlFP771XRAEgS3zcpl9Eu/8Fkl3fosrP30T+RtPoaKsGU2NWhSeqUNbYSEoAA80p6PgwwUOfTN27FhERUXhlWhVwJqfkZGBAwcO4OjRo2HT/FDnDLkQoR/uuoLepvmusNdLOvLcarEgfvG3mPrC75j3+p9dXqcHpr+Ipyc8hicmPYW7Z7yKfg98DwC4rvgMfrtkGL6PdVwFPVDN95Wf0vrg5yzHVT/T5l4Lws/pUgmLv3X7nb+av3HjRr+SRc8rC13SaxqSJDFs2DAMHDiQ0fwhQ4YgLS0NfD4fAwcOxKFDh8CLisL874tQHTMMJFfA6PvTsaPx8MA73Jbf9/7VAOCg1XNOHwdltoAXEYGPpj+C64rP4LriM3hu/lAAQKGei1d5E8B58j3mmMryFtRWt+LQvjJ0mCzYff+DaH3pFSiVSkTMfN5nzS8sLHTQ/MzMTBw8eDDsmn8hQVBB/oJNnz4dmZmZuOGGGzBt2jS0tLQ4REWlpqbikUcewaOPPuqxHHrVvEOHDmHIkCHYu3cvxo4di/379+P222/3adU8jUYDuVyO1tZWny9GiqJQVFSE9PT0sIext7W1AUCvXl7d2QY64Xs4ztPU1AS5XA65XB7SCy/QfqCn0fmbq8l++l2oEov7Y8PevXuh1WqRk5MTdG4cs9kMjUbj86ocnrC3obKyEmVlZejTpw9UKhW2bt2KiRMnMvvyskbAoq4DRxHLtKFzf7ia5thRuD+k7d/Y2Iht27bhyiuvBJ/Pd7DBarXi1KlTaGhoAJfLRWxsrMu55o2NjTh69CiTSy/U7Nq1C8OHD2ciQGhN7OjoQExMDDjpQ73eLJkrTmLdz2tw5ZVXetyvu2E13z2hCsN3tuHMzZORKZcAANZ8tzck5wBsK9M0NjYiIiICCoWik+bb57VwZ5v9VA2H1fgC7AdvSXS9HQfYnE8JURK/jneFPzbs27cPOp0Offv2RUJCQlDnNZvNUKvViImJCaocwLPm53/0H0w4sRmcR98EkTUQVosF/5o4GesG34eCjxYA6NwfdH+/cfuHOFPTBv3K27E6KhaLZi5jzmlYvRh5A7LQpjFi3KVZ2PjXCeY7X8btZxHRiPnqc8yaNYuJEqFtcNZ8pVLpciGJ5uZmHD58GJMnTw7LQ8SePXswePBgCIVCB00EbC9+H123FwKJ59WcvrhrHj556zVcc801Ia9fKAlE8wHbvWpqamrYF9jpTs0PVK+ccbah5PRpcM8UoO+qehhWL4bFZALHTQ4YZ232lDvPm+bb52AS5S7HivVLMPvIAUhTUzrt43weX/rBrNOBKwlcm51/k0I95c2fsbR//35bFHBWVtArmlutVjQ3NztofqD3E/Y2VFdXo6SkBJmZmYiLi8MLn63DW5vqAJwfs7yhC9B+4DuXOklZrRAvWMFM0bTHsHoxtKWlkKalAYDbKaOG1YuxOlIJgiRgtTi6P2RZmbhq/24Irn0Pq29Ncav5Z86cQV1dXbdq/r59+5CTk8NE/dGayOVyIZFI8PAvOyGSKzyW8fV9uXjv5ecxb968kNfPH4JWZKvVivb2dgwfPhw8Hg+bNm3C3LlzAQBnzpxBeXk5xo4d63e5o0aNwnXXXYclS5Z43zkICIJAUlISampqgr54vXGhrKZhT1RUFBoaGkKS8N1isaC6uhrpE64ACALm0qNQq9WorKyE1Wp1WPXEYDBAIBBALpf77RQJZT/4m0Q8VKvc0Tm6SkpKYDKZXAohTXV1NaxWKwoKClBQUODwHUVRzDWQnJzsUTCPHz+O5uZmcDgcZmrtgAEDAhZZ+35ISkpCQkICDhw4gPihlwIcHizltnVJeFkjYDWbAaKz08CdE8q+jWlnVCjancvloqysDAUFBcxb/tJS2xScuro6jB8/HgMHDvRYRkxMDAYMGOCw6kcoSU1NRUlJiccxcTFDEASSk5NRXV0d9sUWulPzQ3VT7GxD+bEaSIcmwVjv+U2tLzfmVqsV1dXVyLz3OxAECeNvT7jU/F8vGQoTRaGkpARyuRyAa/vcrQLkrR/8ucn2JYn4qXeuQ/ZjPwMAMu9bHZJV7mjNLysrg16vZ6b5uqKmpgYdHR0oKSlBSUmJw3cbL78Cl23402/NLygocND8QB683Gl+xk3v4D8lP8PMsaB1zXTcPPUVDEsQokg4EJKKMgDnkxbb/l5iczbNXAbD6sVQTJwK9dFj+F71nG3VQzg+oHJ5HCgixdix1fb759eqiNVl+Pzzz1FYWIgBAwbAZDKhtLQUOp0OdXV1GDt2rFfNj4qKQk5ODvbs2RPQ/bA3aM33NCYudmjND/diC92p+aFaTdPZhs2jx4Pg8bE6VgV5rgV8Pg8NX9/e6Thn7XWlxbTmm81mkCSJ1NRUtLa2Omg+QRDgkCRiSduCBPYOx8a9+/D74OHIba4DQZIwrF5sczrMXIYFHmxwV9dgfiftf2/CkXfJH82vra2FwWAAj8dDWVkZds3Pxdg1q0FRFKYt/QObX74KCQkJSE5O9uiMPXHiBJqamsDj8XDmzBnI5XIMGDAg4BX27PshISEBCQkJ2L9/P86ePYv3/jiBQYlxONpkixzSaDT45MHLgJMHQMXE4dJ7PscBQdI5xxOBb3a+ijVxcXhgyP2o0xiZculx78kJZf/ywtkW575r+e5OfPrppzh79ixycnJcar43raU1f9euXRg/frzvDeYjqampKCoqYnLu9mb8ckQ9/fTTmDVrFlJSUtDW1oaVK1ciPz8fGzZsgFwux+LFi/HYY48hKioKERERePDBBzF27FiMGTMmoMq9+uqrGDhwYNjfYAiFQhAEgba2trC+xTAYDAAAgUAQtnOEG2cbIiMjUVpaCqlU6jLJm69YLBYIMgZDX3AQ5rJjzHaFQtEp75g9FRUVEAgEkLh5q+EqiinQfnB2ZHhKNE47PgJNRu6Nw4cPo66uDikpKVCr1Z2cDmq1GqdOnYLVakVERASSk5ORnp7u8loym822vBbJ2dj3+yoMGDAAQqHQYR+r1Yry8nKMGzcONTU1SEhIQGtrKw4cOICRI0cGZIN9P+j1emzZsgVX3fGoLVF4p51bQUgUAM63rSfHknO/hyoSTaFQYMSIEWhqasKOHTtQVFQEiUSCqqoqZGVl+Rx9EBcXh7a2Npw4ccLrQ4y/JCQkID8/n3VEeUAgEIDD4UCj0fj1Vt1fLkTNbyxrxk8lDYggSAi8LInuyVlhsVggvvoNaH7+F9p/f4rZ7krzH9I0M39XVlZidqWjc8UeOhrG/qHEWz+4q6Pzg52nxLz0G/tFM5dhWW7w0xUpdROoktMgBo0GweHiyJEjqK2tRVJSEjQaTacbYbVajTNnbPk+9i64Bbce2oeMjAysiYl32K8fl4/iWVcj6dhBCKcvAcETovazOxDp9IBOa/748eNRXV2NhIQEtLW1Yd++fRg9enRAD172/WA0GrFlyxZc/WY+SGUfxBRQ0EsiYTJpAAB7d20BGZuNT4q+hmSBCp87lUW3tSh3OaTpt0GbYMbP1eenQ9pHSaxSKNFY38Z8548TTSqVYuTIkWhubsaOHTtQWFgIqVSKqqoqpKen+/wCU6VSoa2tDcePHw/5w0NcXBxOnz7NOqI8wOfzweVy0drayjizw8GFpvnasnKIOVyYZVII09KgkPBRr7O4PI6+1tytyGa1WlFcXIzk5GSH9nF3n1+68hEAtsTI9Z9dD5lsMeNAsI/qduWA87UffNECT86mReec4aGgulmHfYUNmDUsGXwuB8eOHUNlZSVSUlJcar5Go8GpU6dgNptx3X/ycezjO5GZmQnZzV9hTWISpr9/GgBw7czJsHz8Gdb/8w9q2tpwzZbNyM7OZvI50dBOr/Hjx6OyshKJiYnQarV4NSIKz2vVIdN8iUSCiRMnYvCXx/A29wiu4NsWs/jrr79wxWXT0f7qveBxgE1xVmzP/xYiEQ/z+z+EW8Y9ixXrl+D1s48AsPWHO6eT83b6xYQvqwWKxWIYX3sT6mHDOml+amqqX5qv0+lw9OhRZsGOUKFSqfxOi9RT8cvDU19fj1tvvRU1NTWQy+UYNGgQNmzYgMsus+W/effdd0GSJObOnYv29nZcfvnl+OijjwKuXN++fbFo0SJ8+umnfh1nPy+zpqYGFEUhPj7eIaLGmcTERJSUlIDH43V6CA8Vzhd9b8SVDampqSgrKwOfz0dcXFxAETLV1dUAl+/326SkpCRUVlaitbXVZR+7ckCEqh+8OTc8RekES3R0NCIjI5GVlYW1a9dix44d4HK5iIiIQH19PWQyGYYOHdppLLtyzHG5XKSnp8NSdQbNzc04cuSIwzVEz97l8XjYtm0bUlNTsX37dlx22WXQ6XTYsWMHUlNTUVhYiAkTJvjkOK6trYVQKGT6Qq1W46o7HwMpcj19gJR5zm/lzukXbCSUq+MnTJgAwKYzRqMRHA4H11xzjd9jt0+fPjh48CDKy8tD/pY2KioK9fX1YdOynob9eK2trYXVavWq+QkJCSgpKQGfz78oNd/Xh3FnGxaoG0BRFKP5edmDXJblreyamhoQ4ii/H9gSExNRVVWF1tZWJCQkdOpjVw8FoeoHbw8ctBPs/Q2nAACv3TQKj86+JKBzUbv/gfX3r0EuXgJi2KW23BUREejfvz9++uknB82vq6tDREQEMz1rvK61U3lKlQzJqVEoLW5ES4seqampMG1+E40NDdj0wUeIn3E+d5695r8Sn4Sbdm7Djh07MHXqVLS1tTGaX1xcjDFjxvikfa40/+q3t4NUZoEEBZNaDZNazezPTR0NDklg/PJPse2XX1ESHY25RaeZ71cplIwzSttuu/5fHvMArrOLWLN/6HAVreE8rYaiKFB0VMa5qC+aBeoGZgYASZIBaX5mZiYOHz6MsrIypKam+nWsN5RKJWpra3u05oQS+/yktbW1sFgsLvXAnoSEBJSWloLP5wf14tQTPbn9fYnmBBxtECclAlYrOM0tqD5zBk9uewz/mvWG27Jc6T59fdXU1GD3qLHIbKz1GJHiTEJCAsoLCtHa2orclnqPfezKBld40wRfcXZ402UHwqrtRXhu5T6mXKVSCbFYjAEDBjD3+SRJIjpChur6BkTI5Th92RXgkyS+5nJxZv5mHNfpsVKnwbdzl+D5/C/xyqCF+PVAJX7FpTDUfIlVCiUyMzNx4sQJhyTX9pofM/sF7Pvv7di5cyfqcm+BGAS2b9+O5KQklJWX+6z59fX14PP5TF/QaT1Gjhx5zlEkxCT9QKg/uhoAcMMNN+AnVTyumW97kbNh3TEIBFyMmtYf7//0Cm6a/G8AQIRChMhIMSirxe149uSMcv4bON/39AulnD5ZmDhxIqxWK9NOgWh+eno6jh49ipKSEqSnp/t1rDdiY2NRXV0NqdTztOuejl+OqOXLPS/TKRQK8eGHH+LDDz/0uyLuMrB/8skn+OSTT/wqq7y8HDweDzKZDO3t7YiJiUF5ebnXH/7U1FTG+xwO6BUxevMUvbjhtrw2bQabLR2F+0EQBNLS0mAwGFBcXIz+M66Hufigz2VaLBbbymZFtmP8cR7Q02x0Oh0KCwuRmZnp1RHmTz/4mhfKlwicUE0PA2yOht27dyMrKwv9+vXDP//8g+TkZIwbN455a+LqfK6mstnvExUV5XG6mNVqZVYS4vP5zPS0qqoqWK1Wn/NHnT17FiUlJUhMTERUVBSGDBmC03m/of/kqwCBBBa78ePKyRRIWwaS48vTvlwul2mrQK/pYcOGYfv27YwTN1QMGDAAO3fuZJbQvdApLy9nHsqNRiOUSqXPml9RURHyh0Kanq75vtx4Jy76EgCgNdumxhpWL2Y032g0ot5qRZTdQ7un8uh9rm+qhdlshuHrW215H278wue3ygRBIDFKDp2FCrnm0/Xz5S23cz4WV/uLcpcH7IgiRkwCYe4AEWe7H4mMjMTOnTvRt29f9O/fHxs3bkTNex8gpakZUSQHkz1MnZiX/zuIz2w38Zl9Y6E3UTiy5GkMeOYZbOyXg/FffIbkEcMBUzvQUAXrro2o+fEHHNhbiiFcPjjnVmcTCoXIzs7GVxHR2EdZMeT3tdBoND7ljyosLERRUZGD5p/8eCHufuI9vKw5BPmINBzdX8q0pSh3OfrFRyD5naPgIA2WkU9grlOZC9QNuCP3M8RadGjky3G4vMXhe3c5c9xNMyEIAoSHvHEkSWLUqFEAAr+mhwwZgu3bt0MgEIRU8/v163dRaX5lZSW4XC7kcjmMRiNUKhXKysqQdm56jjtSU1N9+m0IlJ6u+b44o+xtIDkcB003Go14bO47gCjSp5xUotzlWAHbveOvlwxG6tCROLznhM/Omr8mTMas7fnYf+sdmPHPHygsLERGRobX/I6+9AOtA/TvoLs6eaur/feRQwd73NcT88amQ99uxrWj0wDY8rudOHEC/fv3R//+/bFhwwY88cNpfHTmJ8hBYnJTHc6c++2btWMLDj7zHBQDstF3WBaSP1mO6MsycaP6N1wbdTNOV2vQ1GZknC2G1YuhbmxBUbMBJyaMxrwj+yCMiYbklq9BxuWAw+XiwPU3IovLQwJJouiKa6D4/jtQYhHUarVP+WYLCgpQWFiIxMREKBQKDBs2DG1tbfhw1V+wWiwgz/XhgKf/QtEnN9nG09RX8MUPz0OSEA+dth1GYwc2rDuGduN5x7O5w4JR4zKB1hYg0rfcha4cU86sUiiBcy+TKKsVgE3z6VkfgV7TgwYNwo4dOyAQCILO2WhPv379sH379l6v+RdW6vVzZGRkoKWlBW1tbRCJRLYVH6xWtLW1wXpucLmCJEkYjUa0t7eHpV4URfX61U0IwmWeOPCyRkAkEiEjIwOwdKCmpsbtigHOToXGxsZOosbLGuHXtDaJRILExESUl5d7beNg+8FdUmxvDo5QRkRxOBzI5XLs27cPBw8exMKFC5H71OuIj493WUe6Pd05zOy/89TuJEkiJyfHYTqeUChEZmYmcnJysHHjRo/XGM3EiRORmJiIkSNHIjo6GgcPHrTVnSfC1m/ex9atW3H06FFw0oa4bW9X2zy1cSjbnyYU1/S4ceNQUVGB48ePh6hWNicZncTwYiAjIwNqtRoajQZisZhZCtcXzW9vb79oNd+XhwECFAict4F+gBflLrctra1pQitlRYvVgnkN1S7LcLgBPLeUekyEDJbH58Py4GxwYMUqhRKi3OVoajO6LAMAfh8+Gv/0zYDliVzsGz0MSUlJKCsrC7vmuwv/9/ZAt2L9Eq95Ndx9T8TEgXPVzSASbA/MBEEgMjISe/bswf79+6H8dAUmJyUjiuQwDxeLZi5jHqjsE3b/Mes66HXnx7iYTyAxmgvF3WsAAA/9UQrqj9Wwrv0K1MHdoPZsRlyCAonJkZg2cyD6fvQUii+/ijmeT5KI5XAxYMAAbNq0ySfNnzBhAlRyOUaOHImYmBgcOHAAsbGx0HBicLCoBHUyDup5ACHl49i0kWjMOY71gk1Yu/ffmMmrgX7lQofy6LH7+fpnsDqhHC3LF3Q6p33/eIrYc/6OaqrHb0lJTFvafx9KzT969GhQ5djD5XIhFouhtosqu5BJT0+HRqOBRqOBRCJhHA8ajcbjeKSXO79YNd8Xhz9tA6179vonFArx5a738L/jH4AyqKH55lav5S2auQxNTU24pawE0nET8PWGYzDoDPg1ZyjW9hng+WCCwN5TlfjqknlQ3fF96DU/hImkc1vqoTlzFmtmzPG4nzuHSKpShufnD0NOiu1lLkEQiImJwe7du3HghzVI+/UP/EqcQmKsEqnptlkCtD7J+/VF6+mzaDl2HPu/+BFZqRH4owpYyR2IGQNsz1df5p0FYBsDFEXhqSUf4/pX/0DN2MuxZusZfLX5DADbfdGYV/fi9dn/YbRPnpyMoqeewcDsbOTl5fmk+ePHj0diYiKqF96J3VNnYN++fVAqlRiUMwDQ1oHqMOChza+hsqEZ4tzlEIt4UMiFUI4ZBdO5BOEWsxWaVtv0vhXrl2CBugH/mfIIcjVjIL73F4/ndx7r9v93/m58YYltnP5nFhaoGzD7wB7mu1Bc0/QU98OHDwdVjj0kSUIqlaK5udn7zj2YC9IRBQApKSmor69HVFQUNBoNZDIZk3DMHRRFQalU4vTp09Dr9SGvk1gs7tFhu75QeyAPtQfyXH7HyxphW+q17Bjkcjlqa2tRXFyMxsZGjxexTqdzCJO2dxh4y8Nkj1gshlKpRFFRkcdlM/3tB3dRRZ7wxakTDAUFBTh58iT27t2LK664AsoR05nzuYr8oZ00ztucv3euvz32Nrn6/uTJk0wiSnuMRiM2bdqE7du3Iz8/H2VltuSzVy56CGKxGKmpqYiOjoa8/0igw4CBAwdi4sSJSElJwd/L/4Oa3esd6u+rQ8mffT3Z7YlQXNP0GxeJRIKtW7eGbMnXwYMH48SJE953vEBISUlBQ0MDFAoFtFoto/nOyZqdoTU/HEs992TN9/WNdNUXi1D1xSIkiyisKfgUAuX5N5Ci3OUgCAIPaZpxe10V6urqUFxcjIaGBq+af3LWJOzcWoDjRyqhXX0n4zhJuvM7l8esUiihHD0KmlYDykoaMWn1txCJRIiNjUVRUZHDVB1n/O0HeroFYLsv8OXhTZS7nHGm2T9o2Lcz/fbdHl/7oaioCCdOnMDevXthfPAxKCIiUJoxDItmLoNkwQoszOLjT9N6mM+NYzofxgJ1A+bUVEP2xUYcP2lboaiuthUdmYOhW7UI19dW4K4jq0C1tYCITwUIAALhuf00sJit2LK3FrLMDJh1OpT/9BP4fFsw/QcZfWC1WplEwzRGoxHPSORYKpXjOamc0fwTR4qQdM8PSE5ORnR0NKKvfQMnG9W46ZefMeXH7bh1707UC0iopk6AoK4IUQkqTJ81EKsjdqPyuokObWfflnXbd+Dv6bOwYv0SrFjvfoEb+6l4zh/rnytx9vKR+FEVh2PXzsDQEan4ISa2Uxmh1Hy5XB5SzR8yZMhFpfnJyclobGyEXC6HXq+HRCJBR0cHiouLPR6nVCpx5swZt0uyB0NP1nxfo07FYjHWZfbHivVLmKlK9tcKASBjyDC0rL7PJ81fsX4JdDodlItXI270CPx1ugkCkRD6ykoYGxxXQrVHlLscH2TPw41v/4N/tGKsemwaRCIR4uPjQ6L538cmQTVhHGLGjGLO5w/OWk8QBJ6b8hSuXrXc7T6Aby8oAKCkpARl+3bim1lXAF9+i9j+/VBy7V244uRJjN5/slOd55w4jLr8rTAb29GiNmK6+jgGb1sDgcmI1+v/gui+69GwZy+sFgvEC1ZgUx3wcDYf/Yv2Ix4GxK37GuqvbsX0nHjwOAR+KFqOv2dcATMINLfqII6LxZwnl2P77XegoqIC30WcT5lhNBrBn/wv8Kc9Bf7UJ5n7rrve/gMSwoI0hQRFCxfiu/79ELX/N1R9eReqv7oTt+7eBhhaoIjgQm/ogLrVCM64ybCqHHMbAoAoLhai3OW4d92bmPv7fwEQLtvXHvupeM6fZT8fYv7u98D34HFI/D5hcqcyQnVNjxgxAlFRUcjPz3eYFhkMgwYNwqlTp0JSVndBUD3Zde8nzsu6WiwWZqnI6upqW+I9rdZt6C6ddLuhoQFyuTykIXQAmDdVnpJv93RoG2jHh7PzwtWDv0ajQUNDA6KiohAZGclspyiKaXNXq+4FOpXNbDajpKQEaWlp4PF4bm3wpx8CmdYVLvbt24dNmzYhPT0d1157LRMuGs6cVL5Ct31dne2BRygUoqmpCZMmTYIsx5ZbacOnb+Ky2x6AXCYFyROg8cg2h+O3bNmC8ePHQygUwmQyQZTcH5Y6242lpzHh6jvnbd7GlLvv3W0P9TWt0Wiwb98+DB8+PCRl5uXlYerUqWhtbUVHRwdiYmLASR/qkOjTFeaKk1j38xpceeWVQdchnHjS/JqaGvB4POh0OreaX1ZWBrFYjKamJshkMiQmJoa0fheS5sff8xMAx4cZd9M87DV/fXpfxgFAURSKzpyBPDoa0WUnsPfu+zBq5SqQ/QZ7LI++ab+hqZYJ57efVkj3e0pKisvweU/94OqBwD4Jqu67hfg+uvMUKuf8Qr5OTQwkf8j+/fvxzz//IDU1Fea7HwCXJDF9wx949sdj+Kbi/H6u2m5DVjrEYh4m7D+K1apkpo729TWp1dgyahiyshNB8nkwtWmRnqnEbz8fQrvB8WFv2syBiIqWYP3vR9GmMWJ+Y42D5gsEAjQ3N2PSpElYG2c7n/L7b3HlO7uRSmjRGpOFQ7cmQ/Xrh/h1zUEMHJKIMhEH8noDRi64CuZpc/HdI/fittkzQDXVAY3nX2ys+W6vy7ZepVBC1icLkqQk1OblO3znakw597lSJcPky84nAqY4XBAWm3Mob+MpXHb2vGMj1Ne0VqvFnj17MHToUL9XAHZFfn4+pkyZgtZWW54wuVyOR9fthUDiOY/IF3fNwydvvYZrrrkm6DqEE2fNpxNgZ2RkMEuq+6L5zc3NkEgkIV8t+0LSfNoG53xOqxRKzD5yANLU82lM2traUF9fj8jISCTet9Yhd1JpaSnEYrHb6VyutNPVtD/7azkYzb/vyc8x7+x6tDc2QH38JDhSCa6vLHXYx9PKa3Q9fJ2a6Ok3zd3vwcGDB1Hy9H0YlqaE0tKBvIMt0BYXM6sFemJvQT1+vW4BLjWVoUPfjuvHLYV+9WKIc5fjd+3vaNixk/mNe2xSMib99gG+F/XHPEEdGvfsxo1H9kJ6548AgLyow7ijKBJ1EbE48+IUHHrqGQx/5y2sGD4KrZQV0/5aB2lTM/5+6GEktZtx55SXsGL9EpTwOZj/wVvQ/fUtGk83wFTbhOg+6VAJTEhIlENVPARGWRJumZaDWydlYebStaC4jnnbPv77OfCtNh2W9e2DiKxMGOrq0XzAlrrjyclPoVF4/pnSWz+4gsshYLbY3CCpSimu2f4V/ttvrkNZ4dL8wYMH+zSt3Rtbt27FpEmT0NraCi6XC4lEgod/2QmRXOHxuK/vy8V7Lz+PefPmBV2HYAjvcnTdDIfDQXR0NFpbW5GYmIiGhgbU19cjNTXVbbK7mJgYWK1WNDQ0hNwRdSEkDra3wddIoYiICERERKCxsRFFRUWIjIxEREQEKisroVKpoBg8yW0ZgTijuFwuMjIyUFZWZpsq6MEGX+kJDijAJmA6nQ73338/4kddhpuffSvkK8O5w5sTyJmOwv3QarUQi8VMDpeOwv3gpA0BSC5MFInGPRsdjuFyuRg/fjy2bNkCkiRtkYkiqU8OKHerGtof6+/0SXu7XNUh1Nd0REQEpkyZgl27diE5OTnofHWXXBJYfpreCofDQUxMDFpaWpCQkIDGxkbU19cjJSXFZR4hOgoWsCW8DbUj6kLTfE+h7vbQmt/U1IRRB3ajubkZf6b3RTNlhYwg8d/F/8Ppag2IPo+hMSIWv9IPOudWQXOV08cV9IMOh8NBenq6z5rvagln5/PQdfh9uOuceYFENgXihNJqtdBqtbj//vuRfPdqtF/xJlasXwJ+RAT+98rN+NRDsnfKoMe0y21TXyyPzoVUJoC27fyUJLo+fIUCl50tBtVUh7+Gj8Ss7fmAUY+bmvY4RIcBwK5tBbhyzhBEx0gxc/YgrI1PQv+B8VAXN2Lm7EHYtbcEjWfqsJYkmVxb465+Dk/qj0A3ehZGzZ6EhudzobokEZMv6w+5Qowksxn5Fitefe0LDE4djXvFuYh75/+QlqFE32ybE7BVbYtSX6VQuszhZVKrQXK5eC73PXy8+TlYN/4I8rJ5XqNAVHERmDStP/P/snoTUu2elyOjHFfkDfU1LZVKGc1PSkoKOndRqFdn6umQJAmlUomWlhbEx8f7rPkEQaC6ujrkjqieovmBOr0B9zZ4WnFMJpNBJpOhubkZr//xBD6NeBIPzXwdt89+E+BLYPzp/k7H2Gu9c5nurlv6GFrzS0tLkZmZ6dUG+1VNY9vVuHTbdsjPrSxs0eo67evu3L7U0Zd9PPWNXq+HsbIUl/exCZGQy4G2uNin/tQZOzDp+d8hG3YLbnt6Ck698Dz6SCisjlRhTd8+GP/7WohiY5m6fZiUjeNXzsfIvfmYOkYKzqwslN4yGxDeBgB4P3M2ipptbzuGvXcIa6ZeBl5cPPo89iz+2l2Aq98/jrW13+Lx2QPxzz9nUT1Dh1bOKEiPlYOzfxsoDQWrzgAul0SUMgJVJ86iDFIsiOfgJ0jx9Q+/Y3bipbCY2kHaOaJmFm/BvOpy/BZnew43a3WgLFZcvmkDANd99Obaw3jy2iFe28ief8lr8UZzLFQRAhiMJnyUdXWnfcKl+Xv27EFbW1vQScxDvQprV3NBO6IA2w1xQUEBtFotEhMTER0d7dIJpdfrmelhAoEAfD4fdXV1iI3tHJodKKEKv+5OgrEhJiYGMTExUKvVqKmpgUqlgnzQRId9nB/2A3WucDgccLlcdHR0dIqK6q39UFZWhqKiIkycOBExQyaCyyHRfu5ldSgTobuDThru7jzOidBd9SUvawTIc6vqcTmky74QCoW4YuEDgEgGwAqSy3cow9153dWXxhdHmq/TQmnCMZZIksT48eORn5+PmJiYoEKCe2rC1HAik8lQUFAAvV7PJEZ29UBiNBqZGwyBQACBQIDa2tqQJhDurVpjTzA2/J3ZHwvUDVCr1VBTVkQQJAQEgdf2fYTrEm/G5sUDUFlZD8D2xnNNyQpcuXu7T2U735RzOBzweDyfNL+VL8V9n27DXYdOYUi65zeS2iLX03wCfcjzB1rzJ0yYgPjbv8T7+a+AqzfYJZw970BxFZlFiMTgPPUetsyahVa1HpcMScaeHUVu61962xzEJyrw07Bx6DBZsAKAKBfQ15Th0LQxqKtphdHQgTXf7bXtX9wIsYSP7IEJyB5oe2AYOyodNcVNAAH8c/otiHIBiNPx8L6vYS4/hWkLRiB6yZP4eeFjGDYyDXKFGEIuFwYzB2OGDMbsr8pBiuRoVRswYPMBbMnpi0u/+hxRg8YASpuj2HmlKvrfa04cQc2tX2PKZdnY+/QLmLK81e3KXnQ7WSznpxTq2q2opCJx+M/DiFJGgGPQoLpSDftfgnBrPr1SVqD4smrthYZMJsPZs2dhMBg8an57ezuzSqdQKIRQKERNTQ2TWzMU9CTND9QZ5WyDP2Uk3rcWhrZmtLa24qFbPgUEUhBcgdtV8nyZokbjfC1zOBwIBAKYTKZO9zru+oHOMwQ8jvbmZvyc0c9n+3yd2hgM5eXlKD59ChM2LIeWsF3LW/457XJfV5FZEiEPu5fNwZglv2Dwi/8A5CTgXKaZtrMFjBMKsLX9E7OWYW5LKeaQZmz65yxaG1qR21SLVgqQ3/wlft53PuS2TmPExL1CYO/3GKFQQJAwEMP4HKQL5QCAuPgIyA5sgEwBKEclYMfajTCn9UGbKhUJmWlI51aghsPHPtUlECjT8clv76CmrgVTpryA9muucbBn9Y4vIODZop/pFw+iGz6H4ZzdX219GeL4OEz9bS2i//UXAGDp9wfcOqLs24kgAHoumLytCTXL/wUxl8TzA6fgvyNu73RsuDR/7Nix2Lp1K5RKZVAr3/V2zb9gc0TRcDgcZGZmQiKRdMpjYI/VaoXRaITVaoVarWZW4vEl+bWvmM3mHvUjFQi0DcE4PRQKBZKTkyEWiz1GqgTrWImPj0dVVVWn7a76wdfk6OHK+eSJ5uZm5Ofnw2g0YurUqeByueByOCjd/mfIo6G82edu2povx9LH02VwORykjZ/l8nhSIgdJkiDJ0Aqsuzp6y5HlLt9UOK/pMWPG4MiRI2Ep+0KG1nypVIqKigq3mm+xWDppPpfL9SkRqq/0BM3350bfFbQNgdyE0zf4f6X1QTTJgeDcS6C2omJ8uuEZFM+/Bn1HDsICdQOu2rsTV+3Z4dPS3O6Ij49HZWWlWxtoNj7+Cb7YfBZjn/7Va5n2CcBdJa8OB2q1Gvn5+dDr9Zg6dSr4fD7e3boMFOe8Hvo63WP14LHQtBrQYbLg1PHqTnW3f7N8/Eglis7WY25dDWOnftUiNC2+EoOGp2HGi4/i6qduRZ8BCeBIJeBGyCAUdXZ2y+RCxMbJMXBQIr7New4r1i8BRyiExWoFVrwK6x/fYdK0/khJO59jJKWdxC9D5+PqRAH6dzQyOcMmHT8LcvhEELzz56HtdH64/UGVCAoE5E3XoqTw/NQ8TzQ1aPH7z4fwWMcE7Dylx3sxk/DmFc9hxOofUFXR0kkLwnlNjxs3jtX8ACBJEpmZmZDJZCgvL/dJ85ubm5GZmQk+n3/Bab4odznmlRd7ncLljmBsoHUp7u4fQYijQHA7R2ymXPOmw77B6Kmv9/n2OfNoBFFRzP8T7/jWYV9Xn2BxlSOQhtb8jrJCTPj1vwAAC0GiUWvBVUOfcdtGrqYHHh+S7bCPK9sBW7tTFDBl0xcwFhVgxpGjthcYHA7kN3+JUYZyZt/NL13lcOx+NYF9HTLsauXgcI3tessZeP4lnkDAxahpgyETk5ByAdngofja2g/Xpd+BF7TZaK6pR7NIAREs+CMl08EGw+rF+FlpK4v+HRDlLgcIW04oUBQsej3aiooR/a+/YFi9GNWf3+yyfWhWKZS2HIIbnkbz+9fgv7v/gw9PfIZlulQoJALweBwMaTzjMscge58fXnq3G81HeDweFAoFCIJAWVmZyzBOqVTKOJ54PB4T7tva2oqGhgaflqr0RjAez55COGwI19QyHo8HsViMlpYWh9xUrmxwjp5xKMcuWiZUdTSZTKivr/cYFq7RaHDs2DEIBAJMmDDBwevtLmF8oIQqosq+HG+OKa3BcdUab5FWgdTF+W9/Ep37QjivaT6f79PKJCyd4fF4kMttb+ncab5EIgFBECgvLweXy2Wm9fH5fNTX14ckGrYnaL63KWje8NeG7YP7ITE5Cmk/54Hguw5pt+j14NrVLVSOHS6Xy6wiY59vx9mGt28bg1SVDP9bf7JTGXRb0W9hPT2A+FN3XzRfq9XiyJEj4PP5jObvPFOHcf1icWOJbcWjNTG+R2+sUigxb8FIECSBpkYtNm84ydTZ1RTI2RXn335XNGqx5VglLHOnYNglcYiafQMokwHk5OswpOgEzIImtHQIYK4sQm11K+ISbNfb3l3FAAXU12lgMJO45sHrgHY9TuQfAk8sgLG+BVDJoIg8H/XDefkLTHvgd6ySaCEo2IOK3XuxuKqwkz3Obe08rkmBANn8djzx21IA9tEPnXGIijJb8VzrehxqqcX81S96nILEan7PhMfjISIiAhRFudV8sViMuLg4B82Pjo5mZkCEIhq2J2h+2/Jc/DZ0FESJCT7lMXLGXxvoczR+eSskws55WYHzDgXD6sVY5GYxB8BRU9tbWsARCMD1ECHI4XAgk8nQ1NSE6Ojzjm1fbKDPNeXZX1HxvxvwY2oW5pV11h173OV8coXZbEZ1dTWTYsGVnjhofr9M4JV7QIydCTTXQXLmMA4dLAK8LCzoXL9Lxt7lc53tHS90O4tylyNOLsRjcyfi87+OImVQNqYuXQeCAC5TUtjazMHbt46GxWrBkT/y0HfSdfjrvfcwaUwCjB0UohQCmMCBlNOBH2SDMEZSj2ZZGjSXj4T++0MABQzf+BWio8UwWkwASXaqI91WzvUW5S7Hig1PO9R/leKcDW6m9tu/oNEUFiF/Xi4ioxV4N3EGNHwJcwyj+05tFG7Nv4BSdQfEReGIAmyrGSgUCuh0OofwXHvEYnGnBIdyuRwlJSUO0zgChV6hozcnMQyHDbTzIjb7CrR0NMJUuDdkZatUKhQXF0MqlTLTNdzZ4CnaJ9ROMr1ej02bNmH48OFobm4GSZLg8XhMaHl9fT1IksTw4cMdxh1dn4b9/7i0wRc8JfC2dyK5y5fkrS3cTYdzdkxJRbZrsFVn8MuB5SuenIuB4KpNwnlNm83mXh9y253Qmq/X693qtyvNj4iIQHNzMwwGg8NqnoHQEzQ/2Igof2xYHamCUMTDmAlZQEcH4MYRlXztHBhr61CUvwNmguO1XH8caUqlEiUlJZBKpcx0DWcb0mMj8M7CsXhn4dhOx9s/MHnDVyfUKoUSV5YXudT89vZ2JrcNgE6aP23pOgDAJztexdXHDnp0xria8kKQtgiz6BgpOBwSFovV4WbdOQHv78nJuGLzn6i69x4kyuKxcsnn4L+2ENyjZeg3fTysuzcAlBUD+0ZhbyUH2tZojKTm4g9FC2ZWZ+Ez0zvQtzRi+Og0KPtlAFweiMQcDGyuh5rggSAIGPU6CIU8tLYasetQPdoyB+IzADvkj2KwNBocVZxPTr5O31ut+CyhCi3jx6Fhx06mHVyVY99usgghZBFCTJuSBe6HfzDbXT3UhFvzXU0pY/ENWvMNBoNb/RaJRJ00n3ZkXCia/8fo8Zi+7hdc9ukRoLLV7+P9scE+4tBktkLiYV/n/WlcaVjatW/jh+QqHMschUUP3gAAbiO8YmJiGM2nn+18sYE+V96rtgT9Ha3e28pXJ5QodznqPp2PvLw8DB06FBqNBgAYzY+NjUVzczMAm+YLrGZYnrgBAAHq0DaQoy/D5i9/w9i87TDYOdjosl3VR5S7HPOSCGwU9wNhMMHev0G38dTf1mLrTbfA3KZl2kCUuxxfPzTFtoIcB2j54BqMemkjDAd342HdAcTUFCNCKML/GfvhBv0x9OGKMOW9T1Ab1Q/KPfvRWJSK6TP6gmcxgW+2OdL5HAKlqhFogwLfmxKwiEfisz2lIAkCForC0xOfwE+V3+DGgctAUFasWL8EyXNa8Gb+Gy7b094xxTie7Nj5yLuIOqNBMyVw69Sit98SdTWkKULUmjid2tAV4bymrVZrUFHgFwIX3VOOSqVCTU2NX0mA09LSUFRUhNTUVJersPlKMMf2FEJtA+0oEPUZi2vj/Qt99dUxkpKSgoqKCiYhnD82hMs5pVAokJ6eDpFIhCm3PgSQJFa+/hRqamow7Zb7AJ4QJEm6nC7WUbg/qKXmfUky748TyhcHkstk5mZLp31C7fCzd0YFW7bLsRDGa9psNoPD8f6QzuIZlUqFqqoqv5IAp6amXrCa74/zBACurir1aX+qtRkUKMTGReDHlfuQ+6HM5XlFuctRfEsGji57G4d/WY+7Ln8VN1OUx5sx++iVRTOXdXpj6UxKSopD4nJ/+sHVTekVC17HlFQpFjyxCEnREo8rHrlymtH7Fd//EFoIEk9NfxHgifHtfAWqqqrw1F8tgCwOJJcPw+rzzjFR7nI8v/MDpGsqYRYJHezwtuoS3WanjlcjO8eWv4nkELBYzttoXwadd6lvdhyo/1uCoX0V+OiAGuOW3QkA6P/qq/gpLgHXfvgSAEDbrIHZKMLkNauh/fcOPGNOwKrGVdCYzeDyOGhu1CGjvhIQikHVVaC8tAmytAToTATKq9txSQYPcrkQE0fG4o+qWgDAJav/D4lZKiQlSHGomutXxBltS+PevWgrLAZIEnATXWRv9yqFEs1NOmzfUoDpe/cx39Nt4ky4NZ99+RA8KpUKFRUVblfOc0VqaiqKi4uRnJwcVG7FnqD5+uoaxL6wlfm/P84TAGhcnuvT/g0ag8P/I6WOL/hdRbO4wlVkbMnP/4J4wQqgXo/FD3t3zqakpDgkLnfuh4Ac23bHenpB4SqJ+Yr1SxARsRhZWVnYPH4SJASJxeoGrF27FhUVFZg4cSKGDh3KvHT4LSkJV1wzGACFM8cqcGUTCU32A6iweynhLbpN982t+GvCZIiGXYsfTFFoN9s8UZkcWz/Js/vD8O4zECmVaGvTQpSYgH0354KLafjXp7ZZFsMqD2LjZZ/g6ZISzG+oAfXINYC2GJkSLj5rz8JE3XFcHyUEJNFIphqQFyFGR20NeOm23xgu19ZXRM4YZI6/Ah+QPGS/ko/7fi1EC+V4Xd034E5AY8Tyjc8hNT0aR6R/YjOfgw6T47OBO+g++b12Je5q3oHcmqNoqNdiwaCHPPaRli+B1mT7u+DDXOZ7d+3Kan54uehevdDTtUpLS1FbW+vTMQRBIC0tDeXl5aitrQ04dNqW86Z3N3mobHB2DpipDpzVHsHh1h1BlenK4cHlch1CHwO1wdc8Ut6or6+H1WrFsGHDsH//OeeG1Yob//UinvjgW5ACcaf6ObdXKPshlBFI/kxftFIUrC5CUkM1BZK2zdfyvLWDq+/DeU03Nzcz08tYAoeerlVaWoqamhqfjrkQNd/f3Eb0/s42uI2wEgghEvJgtlg7hZrTb123n6qBYfViDPiiDM3HjuEtKht8WFHXanBd5jk0ehPMv+xgbjzpOohyl7t8uHF24HrrB3e5O0S5yyG+4TPcLm+CoawUpfUaj/W0x769ac1/orYK8Z9/DAAYKtDh5k8P46mdEvThkA6LMtDnXrF+CdI1tpxX84rPMjbY19VTxNsCdQNy8g6As+S/+O2nQ8wNPt1mdB3t7W+obwMAcAhgd7+JuL3ZlleKIEnMq6/FLw+8iEP7y3BoXymaDxyEvH8/tH23CFvKtKiPSUH2Qw9AIOCipKgBLQYARj12HW7Ent2l2L+rGG1t7WhSm5g6nj1dB8DmJLt0ch+MG52KlLRojBrbefVDX5ijysW88iLAavXopKPHJP33ZWeLQSgcIw9ctW24NT8iIiIsZV9M0NO1AtH8iooK1NTUwGLx7WHYmZ6g+YtmvAbgfK4jGk85iuz3d7bBnQNJInD/gO5vTiXna5UgCIf6e8v15k3zXeXG81SmKHe51/Zyxr6+086egNVqxdChQxH/+cewAij6aS2SRCI89NBDGDZsGIRCISiKgunYAcwuOj8lcETUHagzAlWf38LYYF9Xd/UmeTy0FRXjIzIPh2+ORbxcAP3K2/FOw58AbFMd9+4qQaLCtn9i3yT0TxDgY+kBDOVq0dfUiFfnDUFHm+13bo0qAe3tttxIhNEAXkc7nuFNAFL72rYRBEz1tagvrsTZU+efp4nkPuBcfiMIqQIcDhcnk3ahPGodbuSWOLRT6ac3oezjXJyNTAeHx0WEXAQux/HacaXhubVlSE6Lxt8n30Al51soVVJoz5xFa1klDNXVLvM8rVi/xCEKmP4kRTvG8Llq23Be02q1ukdM5+1OLko3HL16W1lZmc/HcLlcZGZmQqfToaioiElm7g/t7bacOMGG/nYnobTB2Ungq0PEU8Jpd0ilUrS1tUEmk/ltg8toniAcJUeOHAFJktBoNKipqcHO7z/BhJvuR0fpYZ/bIFT94I8drvrJ17xOro4V8GzyYzR1+F03b9FToXCu+bKCYziv6dLSUowZMybk5V6MREdHIzo6OiDN1+v1vVrzg82/5KsNhFCMa6qrsLbvQIgSExy+O1rWBAC47KU/UfHpTWj5ZiGOFM5E4cvrYQKJ7adqMc+N42GVQolGoQJPTl7SabvBg20ymQytra2Qy+U+22CfP4mGIki81JqCNW/dgv6JCq8PJq7am9b8trY2VFdXY/Pjo9DyyONoK7A9fAiio8GTR+DmAfdilUKJiUeOYGnFb9BzhRCbjczKg7QN9Dl8ectPkCSQnIl2YwdTP+eIMvsyKIoCtetv7Hv4Uaze8ztzHuBc3qy6GodtztFDFEWh/333YENmGiTnfGuWxhrEZSUjcuxwRBmqkfnsI+jYuwm8piqUFNpWTew/IAEJ9BMSbI4p+/K95WahnZSubPKVTrlCXJQRzmu6pKQEo0ePDnm5FyO05peWlvp8DL3QhV6vR3Fxca/VfHfXiat8ga7wZoN9RKF+1SJb5JILKHUTqFMHQQyfCIIv8Dsyy1VElacy5HI51Go1FAoF2tvb8dslw8Bra/OYi9BdmbZtvjnBXB1/7NgxiKpr8NPd96HeasHd/2yA9fhJ9L9kEiQ3fuFw7C9TrsT8opM4cbQK85LPO0vsNd95CrUzdJ/w+DaHXNLvH+Gjf07g7OX/B2uT7cWQsdbm9D99qBS5zXVYP3kaNh3ejpQILgapDPg7eiKyF9+C0Q/eydisezgH1o9fRt7fJ6EefwPWmFKw5iCg/+ZNQNOCqz5UYZVCiZPHqtB3xqUgSA6IwRNAVRaCSMpCe0cHrCOmQpj/I142bMHnnzwAwPY7sTpShT03P409o+ZjDV+Eh40nsGTCFYDVig82vczY5txvln/Nx5jxmWhsaINcIUbtqQqUHrTlN5Rn94fVbIHVYgHJ4XiNHHbuQ1dtG85ruqCgACNHjgx5ub2Ji9IRRSMSiTolsvaGRCJBUlISKisr/ZreB/SMJIaBQj/YG07vDvhYd44Df6dkBTLdis4bQlGU137wVJ9gHFBqtRpmsxlWq5VxQs2ePRuZmZmd8hnZ/9+VU6WrxpIvU/Ls9/XWPvbfC/uO8lietzp5qmMg/eTLlEVnwtUPVqsVVqv1og/ZDTVisbhTImtfjklOTkZFRYVf0/uA3q359I1o27e3OWz3dEO3OtK2qIc4JRmSBSugW7UIAFDbcj7i6fsdRXj8q90wrF4M3bkInVvey3PpiKJvIiUd5493lSPC1c0mnTeEIAif+8GVbc4RBfZOIFfY76NWq2EymbDpmrkwAch48zVcddVV6NOnD/S/rUX0o7Z8RGmaSryw8wN8XPwkFqgbMGr6E4gfeBnGlZcgpa0GqxRKzG/sHNnhb4Sbp7rS/yeFQtwxZSna9nVO5O6cd8PVQxE9xfLyolJQzfUwLrkVlMWKfklCdDSXI0pGYs+S53FlzhP4++w2mM/lFGlp1sFisaLgTB3EYj5OnahmynR+EHT1oOrp4cwVqxRKrACwSnE+obkvD8rhvKYtFgur+SFGIpF0SmTtDbFYzKR0uNA03xfNcLbB+bqwL8OdEwoAfu6bg2vmDwMZrQLRd7BPTgFvTh/n/ezr5qz5N5acZa4nd+d0d81X/bUByrFjIL/nR69RWfY6qNFoYDAYcOyxJ9A/KwuNlBXPHTmIfv36QRMXD5FK5VBeZO6nqH7nGUTfvQaGxAcB6/kynX97PdWXdrZ1mCzYs7MIo8dlYvrMgQAAsqgBfQ42MFMM6TJmbc2DOPdzLN/wDAaU/YkV+BMRYic9zxyAzRtOgs/nMpFGTFtGq5j/bx7QB+TYmaDOHgbVWA1wOKAObYXozGEc2XEcsWhDYnIkCm6ajZkJ92KF7h8I42Ix4Y//YXSLGnVDJ+Kh2CsADrBiY+eIJppVCiXm32R7dohd/jtWJ2cx33FEIoji4kAKBaDMZoDDceh3d7m1vBFuzQ9mKvCFwEX9i6dSqVBaWuqXIwqwObAEAoHfTqyekMTQV2ingvNDv7MNoYhMcbVqnrdy6bo5J7l2dwxBEMjIyEB1dTUaGxsRFRXlsh881TdQJ1R5eTkKCwvB5XJx4sQJCAQCDBkyBNdee63D2zbaJl9WEQz3WHLl7PFWL3f5rNxRu/dvAP7b4Et/hxJP5wlXPzQ2NkKpDC7JNEtnlEolSktL/XJEAYBQKAzoxUVv0nz6Ztr5ZtvZBm9vpQk+HyeuvAPWkvPT86YPSmT+zoqLcPn20b5cZwfJoqZKLML56RR0JJRzBItDPc5pfk1NDRoaGhAdHQ2FQtHpYUiUuxywuzm3xzmXkj2epn1VVlbi7FnbQ9DJkyfRYrXgzu1bMGzYMEbzxfFxTHuf+nMpgKWwWilYrRTu6DiNN6lLcJVBjdzmOhAkybwdD2QsuYoGcLZJlLscKwAIVUoIrB0Q5S7HykPv4NozJ9yWSTtyANdJ3okoFYQf/4naqFhEx0ghFYuxtdiCpsoWaI/fCeBOjHMq95iLtvYWDeCrzb7i6Tzh1Hx/dYnFO7Tm++OIAgCBQBDQi4vepPnu8MeGFeuXODg37Lnu7HH8NnAQOn64HPMafEuFsqboc8zPvINZDc2dk9jd9Zmeno7a2lo0NDQgJiYGCoXCbYSVO+d11PBhiBk1EgOXFwFcgcf96e3V1dU4deoUeDweykpK0O+lF8D7/kd8odMwmh+RldnpOObvPzs7SfzVfHu92zc6B0NH2JyoWd/+BqBz1CgALF//NBSX5EB97Djun/0mqp/7CP965T7me0IsQ1Oj1uGYxMXfoFlncqj/lKMnQf31I4j0AaBOH4B1p206oJbkQxzBx64/CqGKi8CUfQdQLJWDsi7E6qjzKxM/HXuFW1uc4fzrbVB1lfghtc+5SgKggNsmLcWK9UvAEYtA+ZBOwdffiHBd083Nzb1aJ0LFRe2IAmyJwgIhNjYWFRUVoCjK5x+p3pJ42FUkDv0g3tbW5nc53vbxZaU2+zrY/9/ZGeWNhIQEnD17FgaDAQqFolP5ruoSrLNDKBSioaEBUVFRkEgkyM3N9egBd+cEtK9HuMaS/XRJe2eSP1PdfN03VDaE0xnlzZZw9UNlZSX69u0Lq9Xa7fkmLjQC1XyVSoXKykpYrVafH2p6i+bTN+qu3hj6o/mLZi4DQQBUieN2kjyfiHzOG397dCzQjqFF5xwj9tCOGzp/knNEiyvi4+NRUFAAvV4PhUIBcVIScgfej0Xnzu2qLvS/qyOVuKGxFrkt9X6tbCMUCtHY2IjIyEiIRCK8p25yuWrjgaLzzrCxVQdxTNkPWr4E0/tdjipNBx6avhR3nrv+Ax1L7qKC7HND0VProuYZ8cXpz/D+hhfAEYnAUbnOkeK8zdUDDg1Bkkz/fJOYBgC4xUNSYFf1dMaTM4q2x1cnlKvcMZ4Ip+ZnZGSwmh8GzGYzKC8LIrhCqVSiqqrKr4iq3qL5nvDHBldTfWlWp/Vn9rH/1xNX7tkB3PiFy2mE9tfmivXudT8uLg6FhYXQ6XRuH/TdaciimcsgMLej7PbLoO7bx2t9aYRCIZqamnBo4Z3o99F7mDJzJoRz5rjc136qM10XV/UJdCzpa2ph7Dsc5COPg0jrD+Jcsu3vDrwNnkyGPrcDBV/YzrdA3YAxT/2MI4ktEJgtyFjzEVZ9+CKqt25G+hv7OpW9QN0A+YTJaD1+wuG3l+DygOnXwPrnKlCnzt+Tl5W3oqZDDIqiMPXU+TxY9O+CK731NE6Y82Vkw2q1vezikLbVYOlo6euryz22j7/5y8Kp+SkpKRe95l+8lp+Dx+N1SqzqK8nJyejo6EBJSQnq6+tRU1ODuro66PV6l/vz+fxeE4LnbpqTsw2+OAE8JYv2Ns3O03Q+V44aX5wgKSkpUKvVDv0eyLQsXxEKhYiKisKJEycwb948l2PA2R5PTiggfGPJXTs4RzuFIgdTIDbQ57Z3lgZbF09leEt0Hq5+0Ov1sFqtWLVqFc6cOcMs/csSPHw+P+Dk40lJSbBYLD1a82nnQiCJVl397WyDt5s4inJ/Y00f72n1H/256XyAY8Jv5+Sy/kS7pKSkoLW1FRRFYcrPP4AkKJ/ejue2NIDgcPx+gOXz+VAoFDhx4gTmzp3r0gklyl2OCc/+xvx/V+IwaPm2xKmzfn/PIbkqXWagY8l5+p277QauEPrKKgDA9TXlaG9ucSjH1dQaf/qBNJlAmkzed4RjQnH7vveWZNhXFs1c5tbJ5WmMh+ua1mq1IEkSq1atwqlTp5hoCJbgEQgEAWt+YmKiW8139ezQHZpvf434o/nuCJUN/i6QAQA4l6ScPt4efxwIycnJ0Gg0TB/5eqxh9WKof7wPcj+cUICtzSIjIxH72kuYN2+eS82nWaBuwKKZy2wvU85Nd3OVHD2QfjAbDFg3fDTqtmwH2ecSEDweo5ftDY3QFpeg8txMd3r70XKbzqtX3QFjXR0WXf46El7dg3az1WFBB8D2G9Bhdz9qX2dCJAY563rmu44OC+pNYkRlD/Cp7t601xm6TnQfexv7zuV7ixKmCdc1rdFowOfzsWrVKpw4ceKi1fyLPiJKIBBAq9VCJpN539kFsbG20MK2tjbGqdXa2ory8nL079/fYV+DwcCcsyfjKRLIHxu8Ta0DPEecuEpm7ksSbG8YjUYoFAqUl5eHLZrGarVi7dq1iI2NBYfDgUQiwaJFiyAWix32CyTxOuC5H7w5sVzhqW39rZuvU/R6yvXgzoHpy/TCcNlgNpsRERGBuLg4GAwGbN++HVdccYX3A1m8Qmt+oKtTqVS2vAj2mq/RaHqM5tu/Sfb1IcBTok5/bDi/Wo37aW72DgV3yWgNqxejvcPich+HcmYuwyVSi9s38vY2KBQKlJWVIbVPFj5fPw6rFM8EncjdmZ9++onRfJlMhttvv91lfglXjpR/LxiBYRkxmDQwHj9E2drRvh899YModzni9E1QqRQ4quV0mlJoPwXBU6Jz+wS9AGA+Fw03t7QAP6U5PpjZH+s8xdJ5G10Py7n7LG9TIjwlF3aHPw/g9LRC53FqX3d35w/XNW21WiGVShEXF4eOjg7s3LmT1fwQQWt+oKvQutP8srIyZGdnO+zbHZpv79wPhab5YwMdnRqqc3tz+p/XFc8OC4PBgMjISPxXHo0VJMfr/oGydu1aKJVKkCQJiUSC2267zaecQvYru+kqKrHy4DsgEuJhqKlltGxWaQEA1/1A65Pzb/2a+BSAw4E4OQmU1QqCJBk9o/db5PT7o191vm3so7Scf6fcvdCwrw8hloGcfzf2PPYUomLlMAuTkHLrTZha1c/j7zR9PnfTJd2NLbq+voxBunx390eLZi5zWcdwar5YLEZcXBwsFgu2b9+Oq666KqTn6A1c9BFRsbGxaGpqCjriQCaTMXlEBAIB4uPjO+0jEol69Yp5QOhscJdw2tfjvEWquDuWlzUCIpEIUVFRiIqKQklJScDL9HqCJElkZmYiMTERJEmipKQEERERbqNv7J1/vtgV6rHk7/Q7f8oFXPe3vzaEevVC+zI9TQn1RLiuaaVSic2bN4MgCERFRTE3wizBExsbi5aWFrS2tgZVjrPmx8XFddqnuzQ/oDfRcP0w748Nns7rbxSLgMdxOM7V21LD6sV44cgXnY6l39IykQIiETYPGo7Ng4fbNN/FG9RQRBL06dMH+2fNxj+XzUJRURHkcnmnCB5nR41+1SIYVi/G49cMxtRLEsE5N2XB+abfWz+8vvNdvFLxK8bLTC7tcdm35952A65v4Ol68P3IY0HbNfzer1C1/m9YTCbM2rEFuc11kCcngWM0uk2cTp/TbLFi0LEzPo8Zf/rO+Q2//XZ73I7jLtJ8Nkdg6FCpVGhtbQ064sBe84VCIfMi2p7u0nx/o0loXF1j/thA5+jz9ffG27XqLZLXXURkJ50ViRAZGYkIgkSD1YJvFUr80j8HxsZGJoLGnb74E03cp08fTHt9K6a8tB4FBQU+5ZC017oF6gZIkpNw7dkTMFTXQGK3CJarfnBVN2lWJvN7BwCwWNB25qxDDiZXLw7c5UUMZBzRdfshMRX61EtgFslwusIAS00tZn14wGWZzr+F3hKx29tt39++OkLtI+38mfIdbs0HbIn2L1bNv+gdUQRBIC0tDW1tbaiqqgp4mp49Wq3WpUfcZDLB5GNYek/F2YZgnBfujnU3Rc2dk8bfOtA2yGQyJCYmoqysLOiHUlcMGTIEJ06cwK5duzB//ny3jpRAclF5G0uuopK8Ee7E3865x/y5HsKRRN5VLjR7R6EvTsFwXdMDBw7ExIkTMWzYMJSWlmLEiNA7CS9mUlNTodPpmJxPwaLVaiGRSDpt702aT1EU0jJjQFkcc2j9kNHPJxt8uXH3tOqQq7/d3RSLcpeDa+nAKoUSxvrOuUScbzRNJhOuLj4DEUFix9BRGHdoL/O22T5PUrAMGjQIVRYzzlo6YLnvYZdtYm+TYfVin6f9/ZDRDz9k9HNZ5or1S0CZzdCcOYsdbfxOzhZ3TiZ/p0F4ayP7uk00V2Pnnffgl+xB2HL9Aohv/AJTN/yBq4vPuD2OLr/DYsWIJ9a6PEcwD0qucqHZP9D4Una4runs7GxMnDgRI0aMQHFx8UW/pHeoSUlJgV6vD5nm63S6Xn+fTz/vfBPp+BIlafFXDjbQ14crZ4Av2L8YCJXDyvncztcu3Q/3zXoDT858HU1WC2Ivm459jz2By59Y5TL6xt20ZU/k5OTA2lYHS/0Z3PW73icnlict5YiEEMXHQ5qRjoH3fI2kxV+5nZJOr4LHOTcNkHYK2ufsC8QmGnd66Mm+9NwbsO3WRRCMmogrdu/A1I1/Ycd/5nfaz9P0fH8YyGnF/JtGIWtgUlDlAO7tCrfmjx49GmfPnsXo0aNDfo7egF+OqNdffx0jR46ETCaDSqXCnDlzcObM+ZuK0tJSEATh8rNmzRpmv99++w19+/ZFv379sG7duk7Hq1SqTglShwwZghdffDFAM72TmJiIyMhIFBUVBT3gpFKpywSv9JLsvZlQ2UA/5AcS2RTsOe1t4PP5yMjIQHNzMzo6OgCELgdSfX09Tp48iSuvvBJ8Pj+k9vrTD/ZJ3UNlWyA4R12ljb/Cow3enEKhHjeeEuO7I5zXdFlZGfbt24dx45zXlWIJBQkJCYiOjkZxcTHa29uDKksqlTIrq9jTmzT/59gEjByTgf3jhjhsv/rkEQcbXOWycP7bfkoYDX1Tq/tuIZMbw92Nny9OLTOHh0Uzl6HDw0sE+pz2/cA9t5reVykZMFMUc+MeirxDjY2NUL74PJ47fBC3aZoYZ0+gN9v2DywUSYAiiU4PIvZONJNazbStKHc51iSlQZEzkCkr3Nif4+M2FcTxcTA1NWF1zhwAQNa9Kx3Gkv1YccgHxef61W6BRgAGspx3OK/piooK7Nmzh9X8MGGv+UajMaiyJBJJr9d88QLbBNWNaeMdthd+eIODDYbVizFu8f8gSUsF51xkiDtnrqfk0wQByG9yXoLifBn2+7rDk/PIHrofxByg+pkxuP3AXpTvPwhxYiLuXPVMSJxQgG1lu9dmJ+HIty+g/cd7g45G1lVWwlBTA21xCdpMFpDonM9w0cxlzAcAbsu8nfl74IOrsfLgfxAzJvRODefffVe2mtRqWE0m1OXl45f+OZ2uB2fHv684n4v+fbhB0Yqd5Ry06QNbhMYXwnlNV1VVYceOHRe15vvliNqyZQvuv/9+7N69Gxs3bkRHRwdmzJgBnU4HwJYcrqamxuHz0ksvQSqVYtasWQCA9vZ23H///fjoo4/wwQcf4N577+3k+Glra8Pbb78dIhN9RywWIykpCU1NTUGVI5fLXZYhkUhcvjXvTTjbEApngHN+Ind/+1OeJ1z1g0KhgF6v9ykvkPO56GPKysqwfft2ZlWu/fv3QyAQoE8f/5Ie+oK7seS82l+wbRkKnKO+6L91xna314OrfgjEUeQOTzmx/Ck7nNe0SCSCVCoFl3vRp/ILGyKRCMnJyazmA7g273f89tMhFJ6pc9jubAP91tUd3m7EdaWlkGakQ5Jqm4KwSqF0mSjd16kR9jfk7pBIJFiX0Y/5/yqFEhKCwFWlBX7fFNvfSJeXl2Pr1q2M5h88eBB8Ph/9+vXzVITfLFA34MaSAtxYUtBpO2073e70h6CskKSmQpychAkL3w9pfbxBPyRozp6LOvv+JQCAzsJhxpLzA42rfvAlOo7GW140T/nG/HkgCuc1LRAIIBaLWc0PIyKRCCkpKUFrfkREBJqbmztt702a/+uSy/Hlof9gTs1O/BKfwGynbbB/ofD4NpuGcFxMUfLFafz5A5/hoTQLPt/yMm6cdq/LfeydUZ5+Q3w5n0QiQeI9a1Dw5EjsvPMeDHxpM0SUFUU/rYVZpwt4KnZlZSXy8/Md7vM5HA4GDhwYUHk0tM3XV5Yy26q+ugNVX7qfPkd/Gr66jWmPy8zlSJw1E42792BuaWFIX0DYR9g6L1iR21yH2MmT0LjvAEgeH9rSMpi1OofrIRDHvydEucvxQlMKqrbtQl1JbdDluWurcGu+VCrtNQuZhQO/HFHr16/HwoULMXDgQAwePBhffvklysvLceDAAQC2JQ7j4uIcPmvXrsX111/PhLC2t7eDw+FgyJAhGDp0KLhcbqe30Q8++CDeeecd1NfXh8hM3xEKhW5XQPIVkiQRGRnZqf5ardblG5TehFarRdzwKQCCm5Znj7vV8sLlOHHVDzqdLqA5wPb1TE5ORkNDA7Zs2YKtW7eioKAAl156aUjq7Iy7sRTo6oRdTUfhftTu/dulDc71DGfuKudk+P4Szms6ISEBAoEAjY2NYSmfxYZAIGCSUQYKQRCIjo5GXZ2jE6c3aT45cASuq612SGa9SqGEVqtF4sLOb7tdrZzmaoqcM+uGj4G2uAS6snKHfewfLkIdvaPVanFl0WmHcq84dazT4hG+YF/PpKQktLS0MJp/6tQpjB8/3ksJgeFuLLm7oS+6OwtcsQjP8EZi62f3hKVOrnCOcrLv38r/zWNssHeaOTuhAo1O8/bwSv8bzHnCrfkSiaRb7n0vJvh8ftARUQRBICYmBrW1jg/AvUnzZwxJQp9oLq6eOwxXb/6DcbLTNthfT+31DdCVlsF0zvnm7hqy1yOrxYJVkSoUr1yNpcU/4crKXRBERuHLn17vVJdgokZdodVq8dH217DzjntgaW9Ho5mDypOnYKirc+no8jWSKSEhAa2trYzmnzx5MuSaT9clkLH0SUs0Bv7rUUxc9S34isCS83urmzOiGz6H1WTC6Pf/D7ETxkF9/LhLG+ydZ77gaZojvT1c9wz2hPOajouLg0wm66QjFxNB5Yii8+pERUW5/P7AgQM4fPgwFi8+P+giIiJw++23Iz4+HgkJCbj33ns7rVi3YMECZGVl4eWXXw6megGjUCiCfvij26SyspKZhy0QCLp9hbBgEQgEaO8wu4woCZRgHQ3+Rv246ofo6GjU19cH5QAjSRLjx4+HVCqF2WxGVlYWhgwZElBZ3rhQxpInG+yjzcI9nTBQJ124+2HQoEE4fvx42MoPFVu3bsXs2bORkJAAgiDwyy+/dHeV/CIyMhINDcHdyERGRoIkyQtT862k2xVtwoUvTgXnv52hb2TpfrB3kERFRaG+vj6oqXMkSWLs2LGQSqXo6OhAnz59MHTo0IDK8oY/Y2mVQon4qVNwbcz1aOJIQPJ4YamTtzo4480Gb1N8POHPg4jZYg04R0lXaP7JkyfDVn64ePHFF9G/f39IJBJERkZi+vTp2LNnT3dXyy30PV8wKBQKcLlcVFRU9FrNH7r1ADgvfg4y+7xuOdsQ6HQzksPBgpZ6nP7gI8j798dj5AhcuvJrh8UP7J0NoYqSEeUux7p+OSBNJuSm34bc7PtgWL0Yixuq0UYFN8XK/j6/vb0dWVlZGD58eND1doU/Y4meMm9YvRiSlGQkzro8LHVyZpVCiXW637F+4lT8PW0Gxnz0vsNYCeX14Pyb0hVOKCD813ROTs5FrfkBx/9arVY88sgjGD9+PHJyclzus3z5cmRnZ3ea+7h06VI88sgjIEmykxMKsL1pWLZsGWbPno1HH30UmZmZgVYzIOg320VFRUhNTQ04TFqlUkGn06GsrAwAYLFYEBkZ2atXzrNarajd909IwxRD4dDyxxnlaq6vSCRiQm2DQaVSQaVSYevWrSgsLARJhmc9gEDmK/eESCh7ussGZydqMJFi4c4FweVymbeurlZl6ynodDoMHjwYixYtwnXXXdfd1fEb2ilRVFSElJQU8AJ8cFcqldDr9Yzmm83mXqv59Eo1VqsVVZ/d6FHz/ZnmEKqbRl+cUfS56PQB9ucWCoUhWTHVXvOPHz+OK664IugyXeGP1jB2r1oUlrr4cm5XBKKXoXo4pcspqG7FoMd+DLjscGs+SZJQKpWorq5GQkKC9wN6CH379sUHH3yAjIwMGAwGvPvuu5gxYwYKCwt75GpQCoUCDQ0NQWt+TExMr9Z8gssDlLZVvg2rF0OUu9ztGLe/tv1xFF+xcysAYC9FdVqcIdROBPqa1ulyAQA32/1uCQQCXHX0YNDniImJQUxMTI/SfJvdXfeiyJ7mI0chio3D1ccPd/ouUL2k7ynm15TDrNeDKxa7jMLuCrpC82NjY1FZWYmkpOCTrncVodL8gB1R999/P44fP47t27e7/N5gMGDlypV4/vnnXX4vl3sOGbz88ssxYcIEPP/881i5cqVfdautrWVCb8ViMYxGIyiKglgshk6ng0AggNVqRUdHB5NklsfjgSRJtLe3QyqVMjepDQ0NzNKNJpMJFouFOcZVOVwuF1wuF0ajERKJBGazGVFRURAKhaisrERJSQl4PJ5DOfTcUJPJ5LIc2gbA5jDR6XQQCoUwm80wm80ey+FwOODz+TAYDC7bgrbTU1vYl9PU1AShUAir1eq1LezLkUgk0Ov1IAiCmf7oqk29tYWrcnxtC7qcpqYmiEQiWCwWh7bQ6XTQaDSwWq0+tYW7NqUT21EUBZPJZMs9FUBbeBpftA1mszmotnB3jYRqfHkaF01NTRCLxejo6HAoR3tiB+JGTAWHJKE1tEMqskXh1e77B2q12qEcDofjdly4G1+tR7c6lCMRCmC2WBAz+FLU7N/MTNPypU3d2eBrm3obX3QOo+3bt+Oyyy6DXq8Hh8Nhxpe3a62rVu+ZNWsWkwewO6ipqQGPx0N7e3vAmi8QCBjNF4vFAWt+R0eHg+aXlpaCz+f3Ss2/rq4SdXV1XjXfyiFhEUsw9/QxGAyGi07zATBls5rvv+arv7oZSYu/AgnKlkeKY4HJSqLysxsdtPr37EEgrBZcdeaEX+OracUCppxIgQUSjgVmikDszZ+g8otFPU7zk5KSsH37dsbJ0RM135kbb7zR4f/vvPMOli9fjqNHj2LatGkhP18oNJ/P5zNTISUSScg0v6SkpNdqvvqrm33SfA5BQcKxoPiTm3uV5uv1erS2trq9lvzRfLPZDJIkYTQaYTQaL0rN75DJMOfsCVitVrTp9ZCSpE+a760t5jfWQKvVYlVGP8w5dhAWkymk46unar5KpbroND+gcI0HHngA69atQ15enlvv3Y8//gi9Xo9bb701kFMAAJYtW4bvv/8ehw4d8uu4jo4OlJSUMKGy9lRWVvoc+SISiaBWq2GxWELS0XK5HBKJpNesqOGK3pSI0R3ubEhKSkJ5ebnLceMPer0eEokkJHkI3CGRSFwuHdyb8GRD+c71zN+FW35H/YHNYalD1qTZQR3fFf1AkiQGDBiAXbt2oaKiAps2bQpyyoMP45ui0NHRAY1G4/AJdnW5cGE2m1FaWury2q2qqmJWxPSGUChEa2srq/l2+KL5N9RV4epjwb9pDhfubEhOTkZZWVlINF8sFoPP5wedY9IdF7rmF/9vAfP3mQ9uQPXymzvtc13hKcwrKwqqDgMfXuN9Jw90lebn5OQ4aP6uXbsCLo+yeo/8o6yWkGm+yWTCp59+CrlcjsGDBwdSZa9YLBaUlpa61Nbq6mq/NF+j0YRU86VSaUiiLbsLXzRf/c1CnPnghi6qkf+E+z7faDRCJBKFJK+wO3qD5nv73Q/WBoLLAa+b26ArNX/Hjh2oqqrCpk2bsHPnzoDLs/qg+bTTr7s1n6D8uBopisKDDz6ItWvXIj8/3+NqYJMnT0ZMTAx+/PFHnytTWlqK9PR0HDp0iMmtM3/+fGg0GtTV1WHOnDl48cUX3R6v0Wggl8vR2toKLpeLhoYGpKamQq/XQ61Ww2w2Q6PRICMjw+ckpSaTCceOHYNEIoFKpXKbD8sX1Go1DAYDKIrqVSHX9qjVagC2sObeiicb6KR0wU6D2r59O4qLizFz5kyoVKqgynLFhd4PXYVz7il/p+d1pQ21tbU4ffo0FAoFsxiEN+w1USwWIycnBw8//DDuvdf1qjWAbRWYSZMm4e6778a7777r8N3SpUs9ajBgm1q9du1azJkzxxezgsLePh6Ph/r6egfNt1gs0Gg0SEtL89mBbjKZcPz4cYjFYiiVSkRHRwdcP7VaDaPRCIvFgsTExIDL6U56wnUaLJ5soKOi4uPjgzrH9u3bUVpaiunTp4dlGu2F3g9dhafkyr7QlTbU19fj5MmTUCgUUKlUPt032muiRCJB9iWDccOiu3DbfQ+5PebkkcO4Ydo43H3XXXjvvfccvvNF82nWrVuH3Nxc6PV6xMfH45dffsHIkSN9OtZX7O3j8/mora1FWloaDAYDWlpaGM1PTU31+eGxo6MDx48fh1AohFKpRExMTMD1U6vVaG9vR0dHR6+aZmNPT7hOg8WTDfT9QbDPYdu3b0dZWRkmTZoUlr6+0Puht9Admh8VFYWoqCifxpW9JkqlUgwcMgxzFtyCxQ//y+0xZ08cx3UTR+Luu+7Cf//7X4fvulrz/YqIuv/++/Htt99i5cqVTJb32traTisOFRYWYuvWrbjjjjv8qowrXn31VWzevBlnzpzx6zixWIzIyEgUFRVBo9EgJiYGcXFxyMrKQktLi8/l8Pl8iEQiyOVyWCyWoDLb83g8REREgCAIlJaWoqysDKWlpUyYZ2+Ax+MFPJe+p+DJBqlUGvQKWjRKpRLl5eUhKcuZC70fuopgV2fsShvi4uIwZMgQ1NfXM9F2/ugRl8vFG2+8gRdffBFtbW0u96EoCo8//jgefvhhvP7662htbXX4PP3006EyJ+SIRCJERUWhqKgIra2tiImJQWxsbMCaHxERAavVipqamoDrxOPxIJPJQJIkSkpKWM3vJjzZIJFIQha5GhMTg4qKipCU5cyF3g9dRTDJ6YGutUGlUmHYsGEOmu+PHnE4HPzf22/iw2UvQ3PuYcoZiqLwxrNP4Oa7H8Abb7zhk+Z/9913kEqlzGfbtm0AgClTpuDw4cPYuXMnZs6cieuvvz6sKwAKhUJER0ejqKgIarUa0dHRiI2NRZ8+ffzSfB6PB6FQiIiICAC2iKpA4fF4kEql4HK5DprfW1bSA3rGdRosnmwQi8Uhie6mV05kNd89rA3+oVKpMGLECNTV1TGa748ekSSJ995+Ex+9+QrU51a4dMWbzz2JBYvvwZtvvtntmu+XI+p///sfWltbMXnyZMTHxzOf77//3mG/FStWICkpCTNmzPCrMq7o27cvFi1aFNCNYkREBDIzMxEXFwc+nw8+nw+hUAiKovz6UVAqlSgrK4NMJgvKSUGSJEiSRHx8PFJTU5GSkoLU1FQ0Njb69aPZndA29Ga82SAWi4MOtY2OjkZ0dDSKi4uDKscdF0M/dCWBOqS62gY+n4+DBw+iuroan3zyid8Ojauvvhr9+vXDm2++6fL7devW4cSJE3jqqacgEAgQERHh8OnpqwHJZDJkZmYiPj6e0XyBQACCINw631xBO5FlMllQTgp7zU9LS2M0v6mpCc0ebhJ6Ej3pOg0UbzZIJJKgnYNKpRKRkZGs5nugJ9kQqEOqOzT/0KFDqK2txWeffea3Q2PWrFnonzMYn/xnmcvvt23cgJNHDuKtpc/4rPlXX301Dh8+zHxGjLBFFkskEmRlZWHMmDFYvnw5uFwuli/3b/VDf7HXfIFAwOg+SZLQaDQ+l6NSqVBRUQGJRBKUk4IeH3FxcYzmp6WloaWlBU1NTQGX25X0pOs0ULzZQOfdCQaVSgWFQoHS0tKgynHHxdAPvYGutoHL5TKa//nnn/t17woAM2bMwKDho/C/N191+f3OvE04tHcX3n7puR6h+X61LEVRLj8LFy502O+1115DeXm53x2XlpYGiqI6LXn/ySefgKIon0PFvJGYmIiWlhafowmUSiUGDhwILpeLqKiogN+WtLe3Mz9wBEEwn9TUVOh0ul7xxsTeht6KNxtCsaxvZGQkxGIxGhsbw5JI7mLoh95AV9uQl5fHLBfdt29fv1cUJQgCb7/9Nt555x1UVVU5fGc2m/HUU09h6dKlXheT6G0kJCSgtbXVZ82PiYlhND86Ojrkmp+SkgKDweD3DUZ3cDFcp9HR0WhoCG4VnsjISEgkEjQ1NbGa7wbWBv/Jy8sDh8NBRUUFMjMzPabEcAVBEPjgnbfw9f/+i+oKxwhti8WCN597Evc99bxf005kMhmysrKYj7sV4qxWa7f1d2JiItra2nyOIIuOjkZOTg6zUq3z76OvuNJ8wJaPrr293S/nWHdxMVynUVFRQWt+dHQ0hEIhWlpawpIP9mLoh95AV9uwdetWcDgcVFVVIS0tDf369fO7jA/feQvfffYRKkpLHLZbrVa88ewTuOfxZ/xKOxFOze/dbsoAIQgCycnJEAqFKC4u9impoEwmA5fLhVwuD1hwPCUATEhI6BVvSy7kZOU0XC4XUqkUxcXFqK6uDuhNuUqlQnNzM1QqFbOsbyi5GPqhN9DVNkyaNAkqlQrp6enM9Gh/GTVqFK666iq88MILDttXrFgBs9mMu+++2+8ytVot86YEAEpKSnD48OGwTU31F4IgkJSUBJFIhOLiYp8WrKA1PyIigtX8C/w65XA4kMlkjOYH8lIoJiYGjY2NiI+PR1FRcAm1XXEx9ENvoLs0PzU1FXK5PCCn+LBhwzDj6uvw7kvPOWxf+93X0Om0eOFh9zkDfUGn0+GZZ57B7t27UVZWhgMHDmDRokWoqqrC/Pnzgyo7GBITEyGRSFBUVOST5kulUmY6daAPnp7GR3x8fK+IhL0YrlMOhwO5XI7i4mJUVVUFpPkKhQItLS1ITExkNd8NrA3+M2HCBMTGxiI5ORnR0dGorKz0u4xBgwbhynm5eOfFZx22/7b6O6ibm/DSvx4Mqo6h1PyL0hFFo1AomFVzKisrff7hCXTqll6vd3scQRBoaGhAXV2d3+V2JZ5s6C34YkNMTAwyMjIQExMDrVaL4uJin1dhAWyhnPRc2nCE7V4s/dDT6WobpFIpbr31VvTv3x9DhgwJOFLn9ddfx8qVK3Hs2DEANkfSCy+8gGXLlgU0F37//v0YOnQohg4dCgB47LHHMHTo0E7Oru5GLpcjOTkZFRUVqKio8NnBFOjULW/jo6mpKagcVF3BxXKdRkdHM5qv1+sD0nyFQgGRSBSWlw8XSz/0dLraBrFYjFtvvRUDBgzA0KFDA9b8/77xKtb/8iNOHLatQm3Q6/F/Lz+Ht5e9HvSUaw6Hg9OnT2Pu3Lno27cvZs+ejaamJmzbtg0DBw4MquxgiYiIQGpqqt+aL5PJAnJOeBsfzc3NQeWg6goulus0KioKGRkZUKlU0Ov1KCoq8iualSRJREVFQSAQsJrvBtYG/xGLxbj55puRk5ODoUOHBnyP+N7r/8amP37FsYO2tCNGgwHvvPQs3njtVQiFwqDqGErN5wZVkwsAHo+HjIwMdHR0oL6+Hh0dHUhLS/N4TFRUFGpra5GSkuLXuegQXVeUl5cjKyurxy/56smG3oI/NvD5fMTGxsJkMqG2thYWiwUEQTA5aDwxZMgQ/PnnnyguLsZll10WbLUduNj6oafSnTZIpdKAfxwzMjJwzz334KmnnsKff/6Jt99+G1lZWbj22msDKm/y5MlBL4fcVfB4PKSnp6OjowMNDQ1ob29Henq6x2OioqJQU1Pj91sxb5qfmZnJan4X4K/mq1QqREZGoq6uDmaz2WfNHzRoECorK8MSCXix9UNPpTttEIvFAUdnpqam4ua7H8Cbzz6BL9dtxBcfvIvYxCRcf/31QddLKBTi559/DrqccMHlcpGeng6z2Yz6+nq0t7cjLS3NY19GRkaiqqrK72XbPZVZUVGBjIwMn6KzupOL7Trl8XidNB8Ak3fMEzk5OaisrAxLbsCLrR96Kt1pg1AoDDg6MykpCQvvfwTLnnkc3/6Vh6//9z6iYpS48cYbQ1KvUGn+Re+IouHxeEhMTIRGo0Ftba3H5Zf5fD7z8EAvl8jhcLyew50HsrGxETKZrFcsbxmsF7UnEIgNfD4fycnJAGx5FehVMqRSKUQiEbOqgr1gkSSJgQMHoqioCFarNaTJ7i7WfuhpdLcNVqsVJpPJ6wOyK5577jlkZWXhu+++w9tvv42NGzdeEDcNvsLj8ZCQkMDkEYmPj/e4L635Go0GYrEYXK73n09346OpqQkSiYTV/C4iEBt4PB6zdLLFYkFlZSUoioJUKoVQKASfzweXy3XQdZIkcckllzBTgXwZI+G0oafB2hAajEZjQPV4a+kzSM/MxK+rvsWn77yBv/7446LSfC6Xi4SEBGi1WtTU1CAhIcHjvlarFYBN8+n7PG+465fm5maIRCJW87uIUGq+RCJxuM931vycnBycPXuW1XwXsDaEhkA1f9lzTyE9Mwtrv/saH7/9Gn75+ecelzy+Z9WmBxAREQGTyeT1rRNJkjAajTh06JDPK965C+9ra2tDVFRUQPXtatgwS1tIYlpaGlJTUyEUCmEwGNDU1ITy8nKUlpaioqKCeWhNTU3FmDFjAprj6wm2H3oG3W3DsGHDsHPnTuaG2R+io6PxzDPP4JZbbsGsWbMwduzYMNSw5yOTydDR0eF1RVSSJNHe3o5Dhw75nOfD3fhobW1FTExMQPXtarp7jIeCUGh+amoqo/lGoxFNTU2oqKhgNJ9+i56cnIxx48YFnOzYHWw/9Ay624YhQ4Zg9+7dAWm+QqHAfU89jyfvug1jJ03FpZdeGoYa9nykUiksFotPmm8ymXDo0CGf8/m5Gx9qtRpKpTKg+nY13T3GQ0EoNV8kEsFoNKK5uRkVFRUoKSlBeXk5o/lJSUm49NJLmRfUoYLth55Bd9sQzH1+REQEXn5xKZbcczuGjRmPqVOnhqGGwcFGRLkgKSkJpaWlyMjIcLsPSZJoaGiASqXyOfO8uyzzvemNlDsbehOhsoEgCCYPlD0mkwllZWUgSRIWiwUymSzkjka2H3oG3W2DVCrFgAEDkJeXh9jYWGRkZEAsFvt8/IMPPojGxkbcddddYaxlz8cXzedwOGhoaEBMTIzPDxTuxkdPeyPlie4e46Eg3Jrf0dHBrBRsNpshlUpZzXcBa0PwSKVS5OTkIC8vD0qlEllZWX5p/gsP34vGulo8fs/iMNay55OUlISSkhKPms/lclFfX4+oqCjExsb6VC6r+T2DrtD8iooKEAQBs9kMiUSCyMjIkJyThu2HnkF32yAWizFo0CDk5+cjJibGb82/6667cKykEo/ccVsYaxk4rCPKBSRJgs/ne5zyolAoUFtbiz59+vjsSKKT4AWbGLI7YW3wDp/PZ/KOcblcVFdXh/xcbD/0DHqCDSqVCtOmTUNjYyN27dqFoUOH+vwQLBQK8cYbb4S5hj0fkiQhEAjQ3t7uti8VCgWqq6tDovkEQYCiqF7xEqInjPFgCbcN9rkmuVwuampqWM13AWtDaIiJiXHQ/MGDB/scYSkQCPDJf5aFuYY9H4IgmOhGd1NeIiMjUVlZib59+7Ka38voCs2nc01yuVzU1taG3GHB9kPPoCfYEBMTg6lTp6K5uRm7d+9GTk4OVCqVT8fyeDx8/PbrYa5h4FyQjiiNRhN0GVarFXV1dZDL5W730el00Gq1PuWHAmyhuQBcJvUtKSlhIqv0ej1OnDiBkSNH+l/xMOPJht5CV9vQ1NQEmUzmNQzcH9h+6Bn0JBv4fD6ys7Oxb98+ZppdKLSwNxAqza+trfX4VtNgMECr1fqcB8Kb5tMPj3q9HsePH8eoUaP8r3iY6UljPFC62obGxkZIJJKAE0u7gu2HnkFPsoHW/AMHDrCaHwAURaG2ttbjixuDwQCdTudzwmB344MgCBQXFzPRtAaDAceOHWM1P0x0tQ0NDQ0Qi8UBJ5Z2BdsPPYOeZAOXy8WAAQNw4MABjB8/HkDv1/wLyhHF5/MRFxfHJJVmYWFhudiJi4sLKJl5b4DVfBYWFhZHWM1nYWFhuXjozZpPUD3BxRdCjEYjE0bHwsLCcrHD5/N7xKof4YLVfBYWFpbzsJrPwsLCcvHQmzX/gnNEsbCwsLCwsLCwsLCwsLCwsLD0THrPMg4sLCwsLCwsLCwsLCwsLCwsLL0a1hHFwsLCwsLCwsLCwsLCwsLCwtIlsI4oFhYWFhYWFhYWFhYWFhYWFpYugXVEsbCwsLCwsLCwsLCwsLCwsLB0CawjioWFhYWFhYWFhYWFhYWFhYWlS2AdUW7YunUrZs+ejYSEBBAEgV9++cXh+59//hkzZsxAdHQ0CILA4cOHO5VhNBpx//33Izo6GlKpFHPnzkVdXZ3DPr/99hv69u2Lfv36Yd26dcz2+Ph4LFu2zGHfJUuWgCAI5OfnO2yfPHkybrnlFr9toCgKL7zwAuLj4yESiTB9+nQUFBQ47JOWlgaCIBw+zvX67LPPkJqaiqFDh2LPnj0AAK1WCx6Ph9WrVzvsm5ubC4IgUFpa2uk8zz//fFhsaG5uxk033YSIiAgoFAosXrwYWq22y2xwRVtbGx555BGkpqZCJBJh3Lhx2LdvH/P9woULO7X7zJkzHcrYtWsXhgwZgrS0NCxfvpzZPmbMGNxzzz0O+3788ccgCAJffvmlw/aFCxfi0ksv9anO/trgS990pw0WiwXPP/880tPTIRKJkJmZiX//+9+wX0i0N/QDS2hgNd8Gq/ms5gdqA6v5rOb3JljNt8FqPqv5gdrAaj6r+UFDsbjkzz//pJ599lnq559/pgBQa9eudfj+66+/pl566SXqs88+owBQhw4d6lTGPffcQyUnJ1ObNm2i9u/fT40ZM4YaN24c873RaKSSkpKojRs3Un///TeVlJREtbe3UxRFUbm5udTll1/uUN6oUaOo5ORkaunSpcw2g8FACQQCasWKFX7bsGzZMkoul1O//PILdeTIEerqq6+m0tPTKYPBwOyTmppKvfzyy1RNTQ3z0Wq1zPdlZWVUVlYWtXPnTmrNmjVUdnY2892YMWOou+++2+GcsbGxVHJyMvXFF18w24qLiykA1ObNm8Niw8yZM6nBgwdTu3fvprZt20ZlZWVRCxYs6DIbXHH99ddTAwYMoLZs2UIVFBRQS5cupSIiIqjKykqKoijqtttuo2bOnOnQ7s3NzQ5lZGdnUz/++CO1Y8cOKjMzkyovL6coiqKWLFlC9evXr9P5kpOTqdtuu81he2pqKvXCCy/4VGd/bfClb7rThldffZWKjo6m1q1bR5WUlFBr1qyhpFIp9d577zH79IZ+YAkNrObbYDWf1fxAbWA1n9X83gSr+TZYzWc1P1AbWM1nNT9YWEeUD7gSRpqSkhKXP1BqtZri8XjUmjVrmG2nTp2iAFC7du2iKIqiWltbqdTUVKqhoYFqaGig0tLSKI1GQ1EURX3yySeUVCqlOjo6KIqiKI1GQ/F4POqDDz6gJk2axJS5efNmCgBVUlLilw1Wq5WKi4uj3nrrLYc6CwQCatWqVcy21NRU6t1333Vb7rFjx6gRI0ZQWq2WKi4uptLS0pjvnn76aYcL9OTJk5RcLqdee+01hwt0xYoVlEAgcBCuUNlw8uRJCgC1b98+Zp+//vqLIgiCqqqq6nIbKIqi9Ho9xeFwqHXr1jlsHzZsGPXss89SFGUTxmuuucZjOSkpKVRxcTGl1WqpESNGUCdOnKAoiqI2bNhAAaBqamqYfWNjY6kPP/yQSk1NZbbRP6p5eXle6+yvDb6Or+604corr6QWLVrksO26666jbrrpJub/Pb0fWMIDq/nvui2X1Xz/bKAoVvNZzWc1v6fDav67bstlNd8/GyiK1XxW81nN9xV2al6YOHDgADo6OjB9+nRmW//+/ZGSkoJdu3YBACIiInD77bcjPj4eCQkJuPfeeyGTyQAAU6ZMgVarZUIgt23bhr59+2Lu3LnYs2cPjEYjACAvLw9paWlIS0vzq34lJSWora11qJ9cLsfo0aOZ+tEsW7YM0dHRGDp0KN566y2YzWbmu5ycHAwaNAhyuRwDBw7EK6+8wnw3ZcoUnDlzBjU1NUxdJ0yYgKlTpzqEHefl5WHs2LEQCoUht2HXrl1QKBQYMWIEs8/06dNBkiQTmtvVNpjNZlgslk77ikQibN++nfl/fn4+VCoV+vXrh3vvvRdNTU0O+7/wwgvIzs6GXC7HmDFjMGDAAADA+PHjwePxkJeXBwA4efIkDAYDFi9ejKamJpSUlDB1FgqFGDt2rNc6+2uDr+OrO20YN24cNm3ahLNnzwIAjhw5gu3bt2PWrFkO+/XkfmDpObCaz2q+O1jNZzWf1fwLD1bzWc13B6v5rOazmu8brCMqTNTW1oLP50OhUDhsj42NRW1tLfP/pUuXorGxEU1NTXjyySeZ7X369EFiYiIjgvn5+Zg0aRLi4uIcfuTy8/MxZcqUgOpH18dT/R566CGsXr0aeXl5uPvuu/Haa6851BMAli9fjrq6OjQ1NeGmm25ito8fPx58Pr+TDcOHD0djYyNzgW7ZsiVsNtTW1kKlUjl8z+VyERUV5WBnV9ogk8kwduxY/Pvf/0Z1dTUsFgu+/fZb7Nq1i/khnDlzJr7++mts2rQJb7zxBrZs2YJZs2bBYrEw5dBC19DQgPfff5/ZLpFIMGrUKIc6T5gwAQKBAOPGjXPYPnbsWAgEAp/q7Y8Nvo6v7rRhyZIlyM3NRf/+/cHj8TB06FA88sgjDv3f0/uBpefAaj6r+e5gNZ/VfFbzLzxYzWc13x2s5rOaz2q+b7COqB6AXC5n3pDYM3nyZIdBPHnyZADApEmTkJ+fD4PBgD179gQk7r7y2GOPYfLkyRg0aBDuuece/Oc//8H777+P9vZ2h/2io6MhEokctonFYowcOZKxYcuWLZg8eTK4XC5zgRYXF6O8vDysNvhKV9rwzTffgKIoJCYmQiAQ4L///S8WLFgAkrRdkrm5ubj66qtxySWXYM6cOVi3bh327dvH1INGIpEgMjKyU/nexg69PZh292aDr3SXDT/88AO+++47rFy5EgcPHsRXX32Ft99+G1999RWzT2/oB5beB6v5rOazms9qPsvFA6v5rOazms9qPktnWEdUmIiLi4PJZIJarXbYXldXh7i4OJ/KmDJlCnbs2IGmpiYcOnQIkyZNAmAb3Hl5edi5cydMJhOmTp0aUP3o+vhTv9GjR8NsNndaScKTDXl5eThx4gQMBgOGDRvmYENeXh7EYjFGjx4dFhvi4uJQX1/v8L3ZbEZzc7Nf/RBqGzIzM7FlyxZotVpUVFRg79696OjoQEZGhsv9MzIyEBMTg8LCQp/rfPbsWVRVVSH/3Nsdus75+fkoKipCRUVFQGPHFxsCHV9dacMTTzzBvC255JJLcMstt+DRRx/F66+/7vaYntgPLD0DVvPP28BqfmdYze9+G1jNZwklrOaft4HV/M6wmt/9NrCa3/NhHVFhYvjw4eDxeNi0aROz7cyZMygvL/d5juiUKVOg0+nwzjvvoE+fPkzo6cSJE7F371789ddfTGivv6SnpyMuLs6hfhqNBnv27PFYv8OHD4MkyU5hsJ5sKCgowMqVKzFhwgRwOBzGhi1btiA/P58Jiw2HDWPHjoVarcaBAweYfTZv3gyr1erzD0o4bZBIJIiPj0dLSws2bNiAa665xuV+lZWVaGpqQnx8vE/ljhs3Dnw+Hx999BGMRiOGDx8OABg5ciQaGhqwYsUKJqQ0WFzZEOj46kob9Hp9p7c6HA4HVqvV7TE9uR9YuhdW88/bwGq+e1jN7z4bWM1nCSWs5p+3gdV897Ca3302sJrfC+jOTOk9mba2NurQoUPUoUOHKADUO++8Qx06dIgqKyujKIqimpqaqEOHDlF//PEHBYBavXo1dejQIYfM+ffccw+VkpJCbd68mdq/fz81duxYauzYsX7VIyUlhZLJZNQ999zjsD09PZ2SyWTUXXfdFbANy5YtoxQKBfXrr79SR48epa655hqHZTd37txJvfvuu9Thw4epoqIi6ttvv6WUSiV16623+lx/etlZmUxGLVu2jNluNBopoVBIyWQy6rXXXgubDRRlW9Z16NCh1J49e6jt27dTffr0cVjWNdw2uGL9+vXUX3/9RRUXF1N///03NXjwYGr06NGUyWSi2traqMcff5zatWsXVVJSQv3zzz/UsGHDqD59+lBGo9Hnc0ycOJGSyWTUzJkzHbZPmTKFkslk1IwZM/yqsz82UJRvfdOdNtx2221UYmIis6zrzz//TMXExFBPPvkkRVFUr+kHltDAaj6r+aGywRWs5ne/Dazms9jDaj6r+aGywRWs5ne/Dazm93xYR5Qb8vLyKACdPvRSnl988YXL75cuXcqUYTAYqPvuu4+KjIykxGIxde211zr8gPnCbbfdxvwA2rNw4UIKgMMSmf7aYLVaqeeff56KjY2lBAIBNW3aNOrMmTPM8QcOHKBGjx5NyeVySigUUtnZ2dRrr73m18VJURQ1adIkCgC1e/duh+2TJ092WOY2HDZQlO1mYsGCBZRUKqUiIiKo22+/nWpra+syG1zx/fffUxkZGRSfz6fi4uKo+++/n1Kr1RRF2ZZMnTFjBqVUKikej0elpqZSd955J1VbW+vXOZYuXUoBcPhRpSiKevHFFykA1Ouvv+5Xef7YQFG+9U132qDRaKiHH36YSklJoYRCIZWRkUE9++yzVHt7O0VRvacfWEIDq/ms5ofKBlewmt/9NrCaz2IPq/ms5ofKBlewmt/9NrCa3/MhKIqiXMdKsbCwsLCwsLCwsLCwsLCwsLCwhA42RxQLCwsLCwsLCwsLCwsLCwsLS5fAOqJYWFhYWFhYWFhYWFhYWFhYWLoE1hHFwsLCwsLCwsLCwsLCwsLCwtIlsI4oFhYWFhYWFhYWFhYWFhYWFpYugXVEsbCwsLCwsLCwsLCwsLCwsLB0CawjioWFhYWFhYWFhYWFhYWFhYWlS2AdUSwsLCwsLCwsLCwsLCwsLCwsXQLriGJhYWFhYWFhYWFhYWFhYWFh6RJYRxQLCwsLCwsLCwsLCwsLCwsLS5fAOqJYWFhYWFhYWFhYWFhYWFhYWLoE1hHFwsLCwsLCwsLCwsLCwsLCwtIlsI4oFhYWFhYWFhYWFhYWFhYWFpYu4f8Bt9BZUhpP53sAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1200x300 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "############## 10m Wind Speed Frequency and maximums ######################\n",
    "# Downscaling function\n",
    "def downscsale_wind(ds):\n",
    "    # Assuming `ds` is your xarray dataset\n",
    "    ds_downscaled = ds.coarsen(\n",
    "        south_north=20,  # Downsampling factor of 6 for south_north (to get resolution of 12km)\n",
    "        west_east=20,     # Downsampling factor of 6 for west_east\n",
    "        boundary=\"trim\"\n",
    "    ).sum()  \n",
    "\n",
    "    return ds_downscaled\n",
    "\n",
    "def plot_wind_speed_frequency_differences(threshold, start_time, end_time):\n",
    "    \"\"\"\n",
    "    Plots the total frequency of wind speeds above a threshold for the current simulation,\n",
    "    and the differences in frequency between the future and current, and future-urban and future simulations.\n",
    "    \n",
    "    Parameters:\n",
    "        threshold (float): Wind speed threshold (m/s) for counting frequency.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Define datasets\n",
    "    wind_datasets = {\n",
    "        'Current': wind_current_ds,\n",
    "        'Future': wind_future_ds,\n",
    "        'Future-Urban': wind_future_urban_ds\n",
    "    }\n",
    "    ############ Freq colormap ###############\n",
    "    #clevs2=[1,2,3]\n",
    "    clevs2 = [0.9,2.9,4.9,6.9,8.9]\n",
    "    tick_labels2 = [1,3,5,7,9]\n",
    "    import colormaps \n",
    "    diff_cmap2 = colormaps.thermal\n",
    "    cmap2 = diff_cmap2[:200]\n",
    "    #cmap = mcolors.ListedColormap([diff_cmap1(i / (len(clevs) - 1)) for i in range(len(clevs) - 1)])\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap2(i / (len(clevs2) - 1)) for i in range(len(clevs2))]\n",
    "\n",
    "    cmap2.set_over(colors[-1])   # Upper bound color\n",
    "    cmap2.set_under('white')  # Lower bound color\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    norm2 = mcolors.BoundaryNorm(clevs2, cmap2.N)\n",
    "\n",
    "    ############### Diverging colormap ################\n",
    "    clevs = [-2.9,-1.9,-0.9,0.9,1.9,2.9] # wind levels\n",
    "    tick_labels = [-3,-2,-1,1,2,3] # wind levels\n",
    "    # Create a ListedColormap from the custom RGBA values\n",
    "    #cmap = create_custom_diverging_colormap(levels=len(clevs))\n",
    "\n",
    "    #diff_cmap1 = colormaps.rdbu_11_r\n",
    "    diff_cmap1 = colormaps.temp_diff_18lev\n",
    "    #indices_sections = np.r_[3:4, 1:2, 5:6, 9:10, 7]\n",
    "    indices_sections = np.r_[6:7, 2:3, 9:10, 16:17, 13:14]\n",
    "    cmap = diff_cmap1[indices_sections]\n",
    "    #cmap = diff_cmap1[1:10]\n",
    "    #cmap = mcolors.ListedColormap([diff_cmap1(i / (len(clevs) - 1)) for i in range(len(clevs) - 1)])\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap1(i) for i in range(19)]\n",
    "    #colors = [diff_cmap1(i / (len(clevs) - 1)) for i in range(len(clevs))]\n",
    "\n",
    "    cmap.set_over(colors[10])   # Upper bound color\n",
    "    cmap.set_under(colors[8])  # Lower bound color\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    norm = mcolors.BoundaryNorm(clevs, cmap.N)\n",
    "    norm3 = mcolors.BoundaryNorm(clevs, cmap.N)\n",
    "\n",
    "    #####################################################\n",
    "    # Set up the figure and 1x3 subplots\n",
    "    fig, axs = plt.subplots(1, 3, figsize=(12, 3), subplot_kw={'projection': crs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on the list provided\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Wind Speed Frequency for Current Simulation #####\n",
    "    wind_speed_current = wind_datasets['Current']['wspd_wdir10'].sel(wspd_wdir='wspd') \n",
    "    \n",
    "    # Calculate frequency of wind speeds above the threshold\n",
    "    freq_current = (wind_speed_current >= threshold).sum(dim='Time')\n",
    "    #freq_current = downscsale_wind(freq_current)\n",
    "    freq_current2 = freq_current.where(freq_current != 0, drop=False)\n",
    "\n",
    "    lats = freq_current['XLAT']\n",
    "    lons = freq_current['XLONG']\n",
    "    \n",
    "    ax_wind = axs[0]\n",
    "    #pb = ax_wind.pcolormesh(lons, lats, freq_current, cmap=cmap2,norm=norm2, transform=crs.PlateCarree(), zorder=1)\n",
    "    pb = ax_wind.contourf(lons, lats, freq_current2, levels=clevs2, cmap=cmap2,norm=norm2,transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    ax_wind.contour(lons, lats, freq_current2, levels=clevs2, cmap=cmap2,norm=norm2,transform=crs.PlateCarree(), zorder=2, extend='both')\n",
    "    #pb = ax_wind.scatter(lons, lats, c=freq_current2, s=5, cmap=cmap2,norm=norm2, transform=crs.PlateCarree())\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_wind.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    ax_wind.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    gl = ax_wind.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    ax_wind.set_title(fr'Frequency of Wind ≥{threshold} m s$^{{-1}}$', loc='left', fontsize=10)\n",
    "    ax_wind.set_title(f'(Current)', loc='right', fontsize=10)\n",
    "    \n",
    "    # Colorbar for the left plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_wind, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.9, extend='both')\n",
    "    #cbar.set_label('Count', fontsize=8)\n",
    "    cbar.set_ticklabels(tick_labels2)\n",
    "\n",
    "    ##### Middle Plot: Future - Current Wind Frequency Difference #####\n",
    "    wind_speed_future = wind_datasets['Future']['wspd_wdir10'].sel(wspd_wdir='wspd') \n",
    "    freq_future = (wind_speed_future >= threshold).sum(dim='Time')\n",
    "    #freq_future = downscsale_wind(freq_future)\n",
    "    freq_diff_future_current = freq_future - freq_current\n",
    "    # **Filter out points where values == 0**\n",
    "    freq_diff_future_current2 = freq_diff_future_current.where(freq_diff_future_current != 0 , drop=False)\n",
    "\n",
    "    # Define sizes (start from a base size and triple each time)\n",
    "    #sizes = 4 * (2 ** (np.abs(freq_diff_future_current.values)))\n",
    "    \n",
    "    ax_wind = axs[1]\n",
    "    #pb = ax_wind.pcolormesh(lons, lats, freq_diff_future_current, cmap=cmap,norm=norm,transform=crs.PlateCarree(), zorder=1)\n",
    "    pb = ax_wind.contourf(lons, lats, freq_diff_future_current2, levels=clevs, cmap=cmap,norm=norm,transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    ax_wind.contour(lons, lats, freq_diff_future_current2, levels=clevs, cmap=cmap,norm=norm,transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    #pb = ax_wind.scatter(lons, lats, c=freq_diff_future_current2, s=5, cmap=cmap,norm=norm, transform=crs.PlateCarree(),zorder=2)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_wind.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    ax_wind.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    gl = ax_wind.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax_wind.set_title(r'$\\Delta$ Frequency', loc='left', fontsize=10)\n",
    "    ax_wind.set_title(f'(ACC Effect)', loc='right', fontsize=10)\n",
    "    \n",
    "    # Colorbar for the middle plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_wind, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.9, extend='both')\n",
    "    #cbar.set_label('Count Difference', fontsize=8)\n",
    "    cbar.set_ticklabels(tick_labels)\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future Wind Frequency Difference #####\n",
    "    wind_speed_future_urban = wind_datasets['Future-Urban']['wspd_wdir10'].sel(wspd_wdir='wspd') \n",
    "    freq_future_urban = (wind_speed_future_urban >= threshold).sum(dim='Time')\n",
    "    #freq_future_urban = downscsale_wind(freq_future_urban)\n",
    "    freq_diff_future_urban_current = freq_future_urban - freq_current\n",
    "    freq_diff_future_urban_future = freq_diff_future_urban_current - freq_diff_future_current\n",
    "    freq_diff_future_urban_future2 = freq_diff_future_urban_future.where(freq_diff_future_urban_future != 0, drop=False)\n",
    "    #print(freq_diff_future_urban_future.min())\n",
    "    \n",
    "    ax_wind = axs[2]\n",
    "    #pb = ax_wind.pcolormesh(lons, lats, freq_diff_future_urban_future2, cmap=cmap,norm=norm, transform=crs.PlateCarree(), zorder=1)\n",
    "    pb = ax_wind.contourf(lons, lats, freq_diff_future_urban_future2, levels=clevs, cmap=cmap,norm=norm3,transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    ax_wind.contour(lons, lats, freq_diff_future_urban_future2, levels=clevs, cmap=cmap,norm=norm3,transform=crs.PlateCarree(), zorder=2, extend='both')\n",
    "    #pb = ax_wind.scatter(lons, lats, c=freq_diff_future_urban_future2, s=5, cmap=cmap,norm=norm, transform=crs.PlateCarree(),zorder=2)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_wind.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    ax_wind.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.25)\n",
    "    gl = ax_wind.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax_wind.set_title(r'$\\Delta$ Frequency', loc='left', fontsize=10)\n",
    "    ax_wind.set_title(f'(Urbanization Effect)', loc='right', fontsize=10)\n",
    "    \n",
    "    # Colorbar for the right plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_wind, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.9, extend='both')\n",
    "    #cbar.set_label('Count Difference', fontsize=8)\n",
    "    cbar.set_ticklabels(tick_labels)\n",
    "\n",
    "    # Set a main title for the figure\n",
    "    if select_time_window == True:\n",
    "        start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        fig.suptitle(f'Wind Speed Frequency (> {threshold} m/s) and Differences from {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}\\n', fontsize=16)\n",
    "    else:\n",
    "        fig.suptitle(fr'Wind Speed Frequency (≥{threshold} m s$^{{-1}}$) and Differences Between Simulations in {month}', fontsize=12)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "def plot_max_wind_speed_differences(start_time, end_time):\n",
    "    \"\"\"\n",
    "    Plots the maximum wind speed for the current simulation,\n",
    "    and the differences in maximum wind speed between future and current, and future-urban and future simulations.\n",
    "    \"\"\"\n",
    "\n",
    "    # Define datasets for each scenario\n",
    "    wind_datasets = {\n",
    "        'Current': wind_current_ds,\n",
    "        'Future': wind_future_ds,\n",
    "        'Future-Urban': wind_future_urban_ds\n",
    "    }\n",
    "\n",
    "    precip_cmap = matplotlib.colormaps['plasma']\n",
    "\n",
    "    p_clevs=[10,17,25]\n",
    "    p_cmap = mcolors.ListedColormap(precip_cmap(np.linspace(0.2,0.7,len(p_clevs))))\n",
    "    p_norm = mcolors.BoundaryNorm(p_clevs, len(p_clevs))\n",
    "    #norm = mcolors.BoundaryNorm(clevs, cmap.N)\n",
    "    p_cmap.set_over(precip_cmap(np.linspace(0.99,1,1)))\n",
    "    p_cmap.set_under('white')\n",
    "\n",
    "    ############### Diverging colormap ################\n",
    "    clevs = [-10, -7,-5, -3,-1, 1, 3, 5,7,10] # wind levels\n",
    "    # Create a ListedColormap from the custom RGBA values\n",
    "    cmap = create_custom_diverging_colormap(levels=len(clevs))\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    norm = mcolors.BoundaryNorm(clevs, len(clevs))\n",
    "\n",
    "    # Set up a 1x3 subplot (1 row, 3 columns for comparisons)\n",
    "    fig, axs = plt.subplots(1, 3, figsize=(17, 5), subplot_kw={'projection': crs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on the list provided\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Max Wind Speed for Current Simulation #####\n",
    "    wind_speed_current = wind_datasets['Current']['wspd_wdir10'].sel(wspd_wdir='wspd') \n",
    "    max_wind_current = wind_speed_current.max(dim='Time')  # Maximum wind speed over time for each grid point\n",
    "    lats = wind_datasets['Current']['XLAT']\n",
    "    lons = wind_datasets['Current']['XLONG']\n",
    "    \n",
    "    ax_wind = axs[0]\n",
    "    pb = ax_wind.pcolormesh(lons, lats, max_wind_current, cmap=p_cmap,norm=p_norm, transform=crs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_wind.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax_wind.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax_wind.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    ax_wind.set_title(f'Max Wind Speed (m/s)', loc='left', fontsize=12)\n",
    "    ax_wind.set_title(f'(Current)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar for the left plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_wind, orientation='vertical', fraction=0.05, pad=0.05, shrink=0.8, extend='both')\n",
    "    cbar.set_label('m/s')\n",
    "\n",
    "    ##### Middle Plot: Future - Current Wind Speed Difference #####\n",
    "    wind_speed_future = wind_datasets['Future']['wspd_wdir10'].sel(wspd_wdir='wspd') \n",
    "    max_wind_future = wind_speed_future.max(dim='Time')\n",
    "    max_wind_diff_future_current = max_wind_future - max_wind_current\n",
    "    \n",
    "    ax_wind = axs[1]\n",
    "    #pb = ax_wind.pcolormesh(lons, lats, max_wind_diff_future_current, cmap=cmap, norm=norm, transform=crs.PlateCarree(), zorder=1)\n",
    "    pb = ax_wind.contourf(lons, lats, max_wind_diff_future_current, cmap=cmap, norm=norm, transform=crs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_wind.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax_wind.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax_wind.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax_wind.set_title(r'$\\Delta$Max Wind Speed (m/s)', loc='left', fontsize=12)\n",
    "    ax_wind.set_title(f'(ACC Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar for the middle plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_wind, orientation='vertical', fraction=0.05, pad=0.05, shrink=0.8, extend='both')\n",
    "    cbar.set_label('m/s')\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future Wind Speed Difference #####\n",
    "    wind_speed_future_urban = wind_datasets['Future-Urban']['wspd_wdir10'].sel(wspd_wdir='wspd') \n",
    "    max_wind_future_urban = wind_speed_future_urban.max(dim='Time')\n",
    "    max_wind_diff_future_urban_future = max_wind_future_urban - max_wind_future\n",
    "    \n",
    "    ax_wind = axs[2]\n",
    "    pb = ax_wind.pcolormesh(lons, lats, max_wind_diff_future_urban_future, cmap=cmap, norm=norm, transform=crs.PlateCarree(), zorder=1)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_wind.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    ax_wind.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.8)\n",
    "    gl = ax_wind.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--', zorder=2)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax_wind.set_title(r'$\\Delta$Max Wind Speed (m/s)', loc='left', fontsize=12)\n",
    "    ax_wind.set_title(f'(Urbanization Effect)', loc='right', fontsize=12)\n",
    "    \n",
    "    # Colorbar for the right plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_wind, orientation='vertical', fraction=0.05, pad=0.05, shrink=0.8, extend='both')\n",
    "    cbar.set_label('m/s')\n",
    "\n",
    "    # Set a main title for the figure\n",
    "    if select_time_window:\n",
    "        start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        fig.suptitle(f'Max Wind Speed and Differences from {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}\\n', fontsize=16)\n",
    "    else:\n",
    "        fig.suptitle(f'Max Wind Speed and Differences Between Simulations in {month}', fontsize=16)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "# Example call to the function\n",
    "#plot_max_wind_speed_differences(start_time, end_time)\n",
    "\n",
    "# Example call to the function\n",
    "plot_wind_speed_frequency_differences(threshold=17.4, start_time=start_time, end_time=end_time)  # Adjust threshold as needed\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "297360000\n"
     ]
    }
   ],
   "source": [
    "print(len(wind_current_ds['wspd_wdir10'].sel(wspd_wdir='wdir').values.flatten()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running 1000 iterations in 100 chunks of 10 with 4 workers...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Bootstrapping (chunked): 100%|██████████| 100/100 [00:31<00:00,  3.19it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running 1000 iterations in 100 chunks of 10 with 4 workers...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Bootstrapping (chunked): 100%|██████████| 100/100 [00:33<00:00,  2.97it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running 1000 iterations in 100 chunks of 10 with 4 workers...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Bootstrapping (chunked): 100%|██████████| 100/100 [00:33<00:00,  2.98it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "############ plotting wind freq and area histograms ###############\n",
    "from matplotlib.ticker import FuncFormatter\n",
    "# Define wind speed intensity bins and labels\n",
    "WIND_SPEED_BINS = [(2, 10), (10, 17), (17, np.inf)]\n",
    "BIN_LABELS = ['2-10', '10-17', '≥17']\n",
    "\n",
    "# Functions to calculate relative changes\n",
    "def calculate_relative_change(future, current):\n",
    "    return ((future / current) - 1) * 100\n",
    "\n",
    "def calculate_relative_change_urbanization(future, current, future_urban):\n",
    "    f = ((future / current) - 1) * 100\n",
    "    fu = ((future_urban / current) - 1) * 100\n",
    "    return fu - f\n",
    "    #return ((future_urban / future) - 1) * 100\n",
    "\n",
    "# Function to calculate frequency (number of occurrences) per intensity bin for wind speeds\n",
    "def calculate_frequency_per_bin(wind_data, bins):\n",
    "    bin_frequencies = []\n",
    "    for lower, upper in bins:\n",
    "        # Count occurrences within each bin across all time steps and grid points\n",
    "        bin_mask = (wind_data >= lower) & (wind_data < upper)\n",
    "        bin_frequency = bin_mask.sum().item()  # Total occurrences in this bin\n",
    "        bin_frequencies.append(bin_frequency)\n",
    "    return bin_frequencies\n",
    "\n",
    "def plot_wind_speed_frequency_bar(start_time,end_time, land_only=False):\n",
    "\n",
    "    # Step 1: Use all occurrences of wind speed values for each simulation across all time steps and grid cells\n",
    "    all_wind_current = wind_current_ds['wspd_wdir10'].sel(wspd_wdir='wspd')  # Replace with the appropriate variable for wind speed in your dataset\n",
    "    all_wind_future = wind_future_ds['wspd_wdir10'].sel(wspd_wdir='wspd')\n",
    "    all_wind_future_urban = wind_future_urban_ds['wspd_wdir10'].sel(wspd_wdir='wspd')\n",
    "\n",
    "    if land_only == True:\n",
    "        land_mask = xr.open_dataset('/pscratch/sd/d/dbrooks/acc2017_analysis/masks/landmask.nc')\n",
    "        # Access the latitude and longitude arrays (XLAT, XLONG)\n",
    "        lats = land_mask['XLAT']\n",
    "        #lons = land_mask['XLONG']\n",
    "\n",
    "        # Get the shape of the latitude and longitude arrays\n",
    "        n_lat, n_lon = lats.shape\n",
    "        # Exclude 15 grid cells from each side (latitude and longitude)\n",
    "        lat_slice = slice(15, n_lat - 15)\n",
    "        lon_slice = slice(15, n_lon - 15)\n",
    "\n",
    "        # Subset the data using the grid cell indices\n",
    "        land_mask = land_mask.isel(south_north=lat_slice, west_east=lon_slice)\n",
    "\n",
    "        land_mask = land_mask['LANDMASK'] == 1\n",
    "\n",
    "        all_wind_current = xr.where(land_mask, all_wind_current, float(\"nan\"))\n",
    "        all_wind_future = xr.where(land_mask, all_wind_future, float(\"nan\"))\n",
    "        all_wind_future_urban = xr.where(land_mask, all_wind_future_urban, float(\"nan\"))\n",
    "\n",
    "        domain_type = 'Land Only'\n",
    "\n",
    "    else:\n",
    "        domain_type = 'Full Domain'\n",
    "\n",
    "    # Step 2: Calculate frequency for each bin for each simulation\n",
    "    freq_current = calculate_frequency_per_bin(all_wind_current, WIND_SPEED_BINS)\n",
    "    freq_future = calculate_frequency_per_bin(all_wind_future, WIND_SPEED_BINS)\n",
    "    freq_future_urban = calculate_frequency_per_bin(all_wind_future_urban, WIND_SPEED_BINS)\n",
    "\n",
    "    #print(freq_current)\n",
    "    #print(freq_future)\n",
    "    #print(freq_future_urban)\n",
    "\n",
    "    # Step 3: Calculate relative change between simulations\n",
    "    relative_change_future = calculate_relative_change(np.array(freq_future), np.array(freq_current))\n",
    "    rel_change_c_vs_fu = calculate_relative_change(np.array(freq_future_urban), np.array(freq_current))\n",
    "    relative_change_urban = calculate_relative_change_urbanization(\n",
    "        np.array(freq_future), np.array(freq_current), np.array(freq_future_urban)\n",
    "    )\n",
    "\n",
    "    f_array = all_wind_future.values.flatten()\n",
    "    c_array = all_wind_current.values.flatten()\n",
    "    fu_array = all_wind_future_urban.values.flatten()\n",
    "    #print(len(f_array), len(c_array))\n",
    "\n",
    "    # Run bootstrapping\n",
    "    \n",
    "    acc_ci_lower, acc_ci_upper, acc_sig = bootstrap_relative_change_chunked(\n",
    "        c_array, f_array, fu_array, WIND_SPEED_BINS, n_iterations=1000, batch_size=10, n_jobs=4, urban=False)\n",
    "    #print(acc_sig)\n",
    "    #print(acc_ci_lower, acc_ci_upper)\n",
    "\n",
    "    accurb_ci_lower, accurb_ci_upper, accurb_urban_sig = bootstrap_relative_change_chunked(\n",
    "        c_array, f_array, fu_array, WIND_SPEED_BINS, n_iterations=1000, batch_size=10, n_jobs=4, c_fu=True) # ACC+Urban Effect\n",
    "    \n",
    "    urb_ci_lower, urb_ci_upper, urb_sig = bootstrap_relative_change_chunked(\n",
    "        c_array, f_array, fu_array, WIND_SPEED_BINS, n_iterations=1000, batch_size=10, n_jobs=4, urban=True)\n",
    "    #print(urb_sig)\n",
    "    #print(urb_ci_lower, urb_ci_upper)\n",
    "    \n",
    "\n",
    "    # Step 4: Plotting\n",
    "    fig, ax1 = plt.subplots(figsize=(5, 4))\n",
    "    ax2 = ax1.twinx()\n",
    "    ax2.grid(True, axis='y', alpha=0.5, zorder=0)\n",
    "\n",
    "    # Bar width and positions\n",
    "    bar_width = 0.2\n",
    "    x = np.arange(len(WIND_SPEED_BINS))\n",
    "\n",
    "    # Plot bars for each simulation\n",
    "    ax1.bar(x - bar_width, freq_current, width=bar_width, color='black', label='Current',zorder=2)\n",
    "    ax1.bar(x, freq_future, width=bar_width, color='#1E88E5', label='Future',zorder=2)\n",
    "    ax1.bar(x + bar_width, freq_future_urban, width=bar_width, color='#D81B60', label='Future-Urban',zorder=2)\n",
    "\n",
    "    # Primary Y-axis (left)\n",
    "    ax1.set_xlabel('10m Wind Speed (m s$^{-1}$)')\n",
    "    ax1.set_ylabel('Frequency (# of Occurrences)')\n",
    "    ax1.set_yscale('log')\n",
    "    ax1.set_xticks(x)\n",
    "    ax1.set_xticklabels(BIN_LABELS)\n",
    "    ax1.set_ylim(10, 10e7)\n",
    "\n",
    "    # Secondary Y-axis (right) for relative changes\n",
    "    ax2.plot(x, rel_change_c_vs_fu, color=\"#FFB507\", marker='^', linestyle='-', label='ACC+Urban', linewidth=2)\n",
    "    ax2.plot(x, relative_change_future, color='black', marker='o', linestyle='--', label='ACC Impact', linewidth=2)\n",
    "    ax2.plot(x, relative_change_urban, color='black', marker='s', linestyle=':', label='Urbanization', linewidth=2)\n",
    "    ax2.set_ylabel('Relative change (%)', color='black')\n",
    "    ax2.set_ylim(-30, 90)  # Adjust based on expected range of relative changes\n",
    "\n",
    "    \n",
    "    # Convert to NumPy arrays for fill_between\n",
    "    x = np.array(x)\n",
    "    acc_lower = np.array(acc_ci_lower)\n",
    "    acc_upper = np.array(acc_ci_upper)\n",
    "    urb_lower = np.array(urb_ci_lower)\n",
    "    urb_upper = np.array(urb_ci_upper)\n",
    "    accurb_lower = np.array(accurb_ci_lower)\n",
    "    accurb_upper = np.array(accurb_ci_upper)\n",
    "\n",
    "    # Fill between CI bounds\n",
    "    ax2.fill_between(x, accurb_lower, accurb_upper, color=\"#FFB507\", alpha=0.3, label='95% CI (ACC+Urban)', zorder=1)\n",
    "    ax2.fill_between(x, acc_lower, acc_upper, color='blue', alpha=0.2, label='95% CI (ACC)', zorder=1)\n",
    "    ax2.fill_between(x, urb_lower, urb_upper, color='green', alpha=0.2, label='95% CI (Urban)', zorder=1)\n",
    "    \n",
    "\n",
    "    # Add legend for secondary y-axis lines\n",
    "    ax2.legend(loc='upper right', fontsize=8)\n",
    "    ax1.legend(loc='upper left', fontsize=8)\n",
    "\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "        \n",
    "    # Title and layout adjustments\n",
    "    if select_time_window == True:\n",
    "        start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        ax1.set_title(f'Frequency of 10m Wind Speed Intensities from \\n{start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}', fontsize=12)\n",
    "    else:\n",
    "        #ax1.set_title(f'Frequency of 10m Wind Speed Intensities in {month}\\n ({domain_type})')ax1.set_title(f'Frequency of 10m Wind Speed Intensities in {month}\\n ({domain_type})')\n",
    "        ax1.set_title(f'{month}')\n",
    "    fig.tight_layout()\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "GRID_CELL_AREA = 4  # Placeholder for grid cell area in km^2, adjust as needed\n",
    "\n",
    "# Function to calculate area per intensity bin\n",
    "def calculate_wind_area_per_bin(wind_data, bins):\n",
    "    bin_areas = []\n",
    "    for lower, upper in bins:\n",
    "        # Find pixels within each bin\n",
    "        bin_mask = (wind_data >= lower) & (wind_data < upper)\n",
    "        bin_count = bin_mask.sum().item()  # Total grid cells in this bin\n",
    "        bin_area = bin_count * GRID_CELL_AREA\n",
    "        bin_areas.append(bin_area)\n",
    "    return bin_areas\n",
    "\n",
    "def plot_wind_speed_area_bar(start_time,end_time):\n",
    "    # Step 1: Use maximum of wind speed values for each simulation across all time steps and grid cells\n",
    "    max_wind_current = wind_current_ds['wspd_wdir10'].sel(wspd_wdir='wspd').max(dim='Time') \n",
    "    max_wind_future = wind_future_ds['wspd_wdir10'].sel(wspd_wdir='wspd').max(dim='Time')\n",
    "    max_wind_future_urban = wind_future_urban_ds['wspd_wdir10'].sel(wspd_wdir='wspd').max(dim='Time')\n",
    "\n",
    "    # Step 2: Calculate area for each bin for each simulation\n",
    "    area_current = calculate_wind_area_per_bin(max_wind_current, WIND_SPEED_BINS)\n",
    "    area_future = calculate_wind_area_per_bin(max_wind_future, WIND_SPEED_BINS)\n",
    "    area_future_urban = calculate_wind_area_per_bin(max_wind_future_urban, WIND_SPEED_BINS)\n",
    "\n",
    "    # Step 3: Calculate total area of the domain\n",
    "    # Assuming each grid cell has an area `grid_cell_area`\n",
    "    total_area = GRID_CELL_AREA * max_wind_current.size\n",
    "\n",
    "    # Step 4: Convert lists to numpy arrays and calculate fractions of the total area\n",
    "    area_current = np.array(area_current)\n",
    "    area_future = np.array(area_future)\n",
    "    area_future_urban = np.array(area_future_urban)\n",
    "\n",
    "    fraction_current = area_current / total_area\n",
    "    fraction_future = area_future / total_area\n",
    "    fraction_future_urban = area_future_urban / total_area\n",
    "\n",
    "    # Step 5: Calculate relative change between simulations\n",
    "    relative_change_future = calculate_relative_change(fraction_future, fraction_current)\n",
    "    relative_change_urban = calculate_relative_change_urbanization(\n",
    "        fraction_future, fraction_current, fraction_future_urban\n",
    "    )\n",
    "\n",
    "    # Step 6: Plotting\n",
    "    fig, ax1 = plt.subplots(figsize=(8, 6))\n",
    "\n",
    "    # Bar width and positions\n",
    "    bar_width = 0.15\n",
    "    x = np.arange(len(WIND_SPEED_BINS))\n",
    "\n",
    "    # Plot bars for each simulation as fractions of the total area\n",
    "    ax1.bar(x - bar_width, fraction_current, width=bar_width, color='black', label='Current')\n",
    "    ax1.bar(x, fraction_future, width=bar_width, color='#1E88E5', label='Future')\n",
    "    ax1.bar(x + bar_width, fraction_future_urban, width=bar_width, color='#D81B60', label='Future-Urban')\n",
    "\n",
    "    # Primary Y-axis (left) for fractions of area\n",
    "    ax1.set_xlabel('Wind Speed (m/s)')\n",
    "    ax1.set_ylabel('Fraction of Total Area')\n",
    "    ax1.set_ylim(0, 5)\n",
    "    \n",
    "    ax1.set_yscale('symlog', linthresh=0.001)\n",
    "    # Optional: Define custom ticks if desired\n",
    "    custom_ticks = [0, 0.01, 0.05, 0.1, 0.2, 0.4, 0.6, 0.8, 1.0]\n",
    "    ax1.set_yticks(custom_ticks)\n",
    "\n",
    "    # Optional: Set custom labels for the y-ticks to match fractional values\n",
    "    ax1.get_yaxis().set_major_formatter(plt.FuncFormatter(lambda x, _: '{:.2g}'.format(x)))\n",
    "\n",
    "    ax1.set_xticks(x)\n",
    "    ax1.set_xticklabels(BIN_LABELS)\n",
    "    ax1.legend(loc='upper left')\n",
    "\n",
    "    # Secondary Y-axis (right) for relative changes\n",
    "    ax2 = ax1.twinx()\n",
    "    ax2.plot(x, relative_change_future, color='black', marker='o', linestyle='--', label='ACC Impact')\n",
    "    ax2.plot(x, relative_change_urban, color='black', marker='s', linestyle=':', label='Urbanization')\n",
    "    ax2.set_ylabel('Relative change (%)', color='black')\n",
    "    ax2.set_ylim(-400, 60)  # Adjust based on expected range of relative changes\n",
    "    ax2.grid(True, axis='y', alpha=0.5)\n",
    "\n",
    "    # Add legend for secondary y-axis lines\n",
    "    ax2.legend(loc='upper right')\n",
    "\n",
    "    # Determine the month name based on `monlist`\n",
    "    month = {'04': 'April', '05': 'May', '06': 'June'}.get(monlist[0], \"Unknown\")\n",
    "\n",
    "    # Title and layout adjustments\n",
    "    if select_time_window == True:\n",
    "        start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        ax1.set_title(f'Fraction of Total Area by Maximum Wind Speed Intensity from \\n{start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}', fontsize=16)\n",
    "    else:\n",
    "        ax1.set_title(f'Fraction of Total Area by Maximum Wind Speed Intensity in {month} by Simulation (Full Domain)')\n",
    "\n",
    "    fig.tight_layout()\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "# Call the function to plot\n",
    "plot_wind_speed_frequency_bar(start_time,end_time,land_only=False) # frequency\n",
    "\n",
    "#plot_wind_speed_area_bar(start_time,end_time) # area\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x300 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "############# Cloud Mask #################\n",
    "def plot_cloud_frequency_differences(threshold, start_time, end_time):\n",
    "    \"\"\"\n",
    "    Plots the total frequency of wind speeds above a threshold for the current simulation,\n",
    "    and the differences in frequency between the future and current, and future-urban and future simulations.\n",
    "    \n",
    "    Parameters:\n",
    "        threshold (float): Wind speed threshold (m/s) for counting frequency.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Define datasets\n",
    "    wind_datasets = {\n",
    "        'Current': c_storms,\n",
    "        'Future': f_storms,\n",
    "        'Future-Urban': fu_storms\n",
    "    }\n",
    "    ############ Freq colormap ###############\n",
    "    #clevs2=[1,2,3]\n",
    "    clevs2 = [3,5,7,10,15,20]\n",
    "    import colormaps \n",
    "    diff_cmap2 = colormaps.thermal\n",
    "    cmap2 = diff_cmap2[:200]\n",
    "    #cmap = mcolors.ListedColormap([diff_cmap1(i / (len(clevs) - 1)) for i in range(len(clevs) - 1)])\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap2(i / (len(clevs2) - 1)) for i in range(len(clevs2))]\n",
    "\n",
    "    cmap2.set_over(colors[-1])   # Upper bound color\n",
    "    cmap2.set_under('white')  # Lower bound color\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    norm2 = mcolors.BoundaryNorm(clevs2, cmap2.N)\n",
    "\n",
    "    ############### Diverging colormap ################\n",
    "    clevs = [-13.9,-9.9,-5.9,-3.9,-1.9,1.9,3.9,5.9,9.9,13.9] # wind levels\n",
    "    tick_labels = [-14,-10,-6,-4,-2,2,4,6,10,14] # wind levels\n",
    "    # Create a ListedColormap from the custom RGBA values\n",
    "    #cmap = create_custom_diverging_colormap(levels=len(clevs))\n",
    "\n",
    "    import colormaps\n",
    "    diff_cmap1 = colormaps.rdbu_11_r\n",
    "    cmap = diff_cmap1[1:10]\n",
    "    #cmap = mcolors.ListedColormap([diff_cmap1(i / (len(clevs) - 1)) for i in range(len(clevs) - 1)])\n",
    "\n",
    "    # Extract individual colors from the base colormap\n",
    "    colors = [diff_cmap1(i / (len(clevs) - 1)) for i in range(len(clevs))]\n",
    "\n",
    "    cmap.set_over(colors[-1])   # Upper bound color\n",
    "    cmap.set_under(colors[0])  # Lower bound color\n",
    "\n",
    "    # Create a normalization for the contour levels\n",
    "    norm = mcolors.BoundaryNorm(clevs, cmap.N)\n",
    "    norm3 = mcolors.BoundaryNorm(clevs, cmap.N)\n",
    "\n",
    "    #####################################################\n",
    "    # Set up the figure and 1x3 subplots\n",
    "    fig, axs = plt.subplots(1, 3, figsize=(12, 3), subplot_kw={'projection': crs.PlateCarree()})\n",
    "\n",
    "    # Set month name based on the list provided\n",
    "    if monlist[0] == '04':\n",
    "        month = 'April'\n",
    "    elif monlist[0] == '05':\n",
    "        month = 'May'\n",
    "    elif monlist[0] == '06':\n",
    "        month = 'June'\n",
    "\n",
    "    ##### Left Plot: Wind Speed Frequency for Current Simulation #####\n",
    "    wind_speed_current = wind_datasets['Current']\n",
    "    \n",
    "    # Calculate frequency of wind speeds above the threshold\n",
    "    freq_current = (wind_speed_current == threshold).sum(dim='Time')\n",
    "    #freq_current = downscsale_wind(freq_current)\n",
    "    freq_current2 = freq_current.where(freq_current != 0, drop=False)\n",
    "\n",
    "    lats = freq_current['XLAT']\n",
    "    lons = freq_current['XLONG']\n",
    "    \n",
    "    ax_wind = axs[0]\n",
    "    #pb = ax_wind.pcolormesh(lons, lats, freq_current, cmap=cmap2,norm=norm2, transform=crs.PlateCarree(), zorder=1)\n",
    "    pb = ax_wind.contourf(lons, lats, freq_current2, levels=clevs2, cmap=cmap2,norm=norm2,transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    #ax_wind.contour(lons, lats, freq_current2, levels=clevs2, cmap=cmap2,norm=norm2,transform=crs.PlateCarree(), zorder=2, extend='both')\n",
    "    #pb = ax_wind.scatter(lons, lats, c=freq_current2, s=5, cmap=cmap2,norm=norm2, transform=crs.PlateCarree())\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_wind.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.35)\n",
    "    ax_wind.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.35)\n",
    "    gl = ax_wind.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = True\n",
    "    gl.bottom_labels = True\n",
    "    ax_wind.set_title(fr'Frequency of Storm Points', loc='left', fontsize=10)\n",
    "    ax_wind.set_title(f'(Current)', loc='right', fontsize=10)\n",
    "    \n",
    "    # Colorbar for the left plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_wind, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('Count', fontsize=8)\n",
    "    #cbar.set_ticklabels(tick_labels2)\n",
    "\n",
    "    ##### Middle Plot: Future - Current Wind Frequency Difference #####\n",
    "    wind_speed_future = wind_datasets['Future']\n",
    "    freq_future = (wind_speed_future == threshold).sum(dim='Time')\n",
    "    #freq_future = downscsale_wind(freq_future)\n",
    "    freq_diff_future_current = freq_future - freq_current\n",
    "    # **Filter out points where values == 0**\n",
    "    freq_diff_future_current2 = freq_diff_future_current.where(freq_diff_future_current != 0 , drop=False)\n",
    "\n",
    "    # Define sizes (start from a base size and triple each time)\n",
    "    #sizes = 4 * (2 ** (np.abs(freq_diff_future_current.values)))\n",
    "    \n",
    "    ax_wind = axs[1]\n",
    "    #pb = ax_wind.pcolormesh(lons, lats, freq_diff_future_current, cmap=cmap,norm=norm,transform=crs.PlateCarree(), zorder=1)\n",
    "    pb = ax_wind.contourf(lons, lats, freq_diff_future_current2, levels=clevs, cmap=cmap,norm=norm,transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    #ax_wind.contour(lons, lats, freq_diff_future_current2, levels=clevs, cmap=cmap,norm=norm,transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    #pb = ax_wind.scatter(lons, lats, c=freq_diff_future_current2, s=5, cmap=cmap,norm=norm, transform=crs.PlateCarree(),zorder=2)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_wind.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.35)\n",
    "    ax_wind.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.35)\n",
    "    gl = ax_wind.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax_wind.set_title(r'$\\Delta$ Frequency', loc='left', fontsize=10)\n",
    "    ax_wind.set_title(f'(ACC Effect)', loc='right', fontsize=10)\n",
    "    \n",
    "    # Colorbar for the middle plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_wind, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('Count Difference', fontsize=8)\n",
    "    cbar.set_ticklabels(tick_labels)\n",
    "\n",
    "    ##### Right Plot: Future-Urban - Future Wind Frequency Difference #####\n",
    "    wind_speed_future_urban = wind_datasets['Future-Urban']\n",
    "    freq_future_urban = (wind_speed_future_urban == threshold).sum(dim='Time')\n",
    "    #freq_future_urban = downscsale_wind(freq_future_urban)\n",
    "    freq_diff_future_urban_current = freq_future_urban - freq_current\n",
    "    freq_diff_future_urban_future = freq_diff_future_urban_current - freq_diff_future_current\n",
    "    freq_diff_future_urban_future2 = freq_diff_future_urban_future.where(freq_diff_future_urban_future != 0, drop=False)\n",
    "    #print(freq_diff_future_urban_future.min())\n",
    "    \n",
    "    ax_wind = axs[2]\n",
    "    #pb = ax_wind.pcolormesh(lons, lats, freq_diff_future_urban_future2, cmap=cmap,norm=norm, transform=crs.PlateCarree(), zorder=1)\n",
    "    pb = ax_wind.contourf(lons, lats, freq_diff_future_urban_future2, levels=clevs, cmap=cmap,norm=norm3,transform=crs.PlateCarree(), zorder=1, extend='both')\n",
    "    #ax_wind.contour(lons, lats, freq_diff_future_urban_future2, levels=clevs, cmap=cmap,norm=norm3,transform=crs.PlateCarree(), zorder=2, extend='both')\n",
    "    #pb = ax_wind.scatter(lons, lats, c=freq_diff_future_urban_future2, s=5, cmap=cmap,norm=norm, transform=crs.PlateCarree(),zorder=2)\n",
    "    \n",
    "    # Add features and title\n",
    "    ax_wind.add_feature(cfeature.STATES, edgecolor=\"black\", linewidths=0.35, alpha=0.35)\n",
    "    ax_wind.add_feature(cfeature.COASTLINE, edgecolor=\"black\", linewidths=0.35, alpha=0.35)\n",
    "    gl = ax_wind.gridlines(draw_labels=True, linewidth=0.35, color='gray', alpha=0.5, linestyle='--', zorder=1)\n",
    "    gl.top_labels = False\n",
    "    gl.right_labels = False\n",
    "    gl.left_labels = False\n",
    "    gl.bottom_labels = True\n",
    "    ax_wind.set_title(r'$\\Delta$ Frequency', loc='left', fontsize=10)\n",
    "    ax_wind.set_title(f'(Urbanization Effect)', loc='right', fontsize=10)\n",
    "    \n",
    "    # Colorbar for the right plot\n",
    "    cbar = plt.colorbar(pb, ax=ax_wind, orientation='vertical', fraction=0.05, pad=0.01, shrink=0.8, extend='both')\n",
    "    #cbar.set_label('Count Difference', fontsize=8)\n",
    "    cbar.set_ticklabels(tick_labels)\n",
    "\n",
    "    # Set a main title for the figure\n",
    "    if select_time_window == True:\n",
    "        start_time = datetime.strptime(start_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        end_time = datetime.strptime(end_time, '%Y-%m-%dT%H:%M:%S')\n",
    "        fig.suptitle(f'Wind Speed Frequency (> {threshold} m/s) and Differences from {start_time.strftime(\"%Y-%m-%d %Hz\")} to {end_time.strftime(\"%Y-%m-%d %Hz\")}\\n', fontsize=16)\n",
    "    else:\n",
    "        fig.suptitle(fr'Valid Storm Frequency and Differences Between Simulations in {month}', fontsize=12)\n",
    "\n",
    "    # Adjust layout for better spacing\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.99])\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "#plot_cloud_frequency_differences(threshold=True, start_time=start_time, end_time=end_time)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "atms-shap",
   "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
}
