{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:gray\">\n",
    "Copyright &copy; 2020-2021 by Fraunhofer-Gesellschaft. All rights reserved.<br>\n",
    "Fraunhofer Institute for Integrated Circuits IIS, Division Engineering of Adaptive Systems EAS<br>\n",
    "Münchner Straße 16, 01187 Dresden, Germany\n",
    "</span>\n",
    "\n",
    "---\n",
    "\n",
    "## ESB - Energy Saving by Blockchain\n",
    "\n",
    "Eurostars – EXP 00119832 / EUS-2019113348\n",
    "\n",
    "---\n",
    "\n",
    "## Prediction of Energy Consumption for Variable Customer Portfolios Including Aleatoric Uncertainty Estimation\n",
    "\n",
    "*Oliver Mey, André Schneider, Olaf Enge-Rosenblatt, Yesnier Bravo, Pit Stenzel*\n",
    "\n",
    "The notebook is part of a paper submission contributed to the **10th International Conference on Power Science and Engineering (ICPSE 2021)** will be held on Oct. 21-23, 2021 in Yildiz Technical University, Istanbul, Turkey.\n",
    "\n",
    "---\n",
    "\n",
    "# B1: Feature Extraction\n",
    "\n",
    "This notebook loads the available datasets and extracts the features needed as input for the prediction models for a pre-defined date (*2019-02-02*) and a customer (*#20*). The feature extraction uses pre-fitted scalers.\n",
    "\n",
    "---\n",
    "\n",
    "<span style=\"color:gray\">\n",
    "Version 0.4.1 (October 12, 2021)<br>\n",
    "Authors: Oliver Mey, André Schneider (Fraunhofer IIS)<br>\n",
    "</span>    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings, logging, os\n",
    "warnings.filterwarnings('ignore')\n",
    "logging.disable(logging.WARNING)\n",
    "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import joblib\n",
    "import time\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import holidays as hd\n",
    "import seaborn as sns\n",
    "import tensorflow as tf\n",
    "import tensorflow_probability as tfp\n",
    "\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.preprocessing import RobustScaler\n",
    "from datetime import datetime\n",
    "\n",
    "%matplotlib inline\n",
    "sns.set(rc={'figure.figsize':(16, 6)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = '..'\n",
    "timezone = 'Europe/Madrid'\n",
    "seed = 12345\n",
    "epsilon = 1e-5\n",
    "quantiles = [0.5, 0.15865, 0.84135]\n",
    "skip = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "properties = {\n",
    "    'data_path' : path + '/data',\n",
    "    'models_path' : path + '/models/C1_01',\n",
    "    't_consumption_daily': [-14, -1],\n",
    "    't_consumption_hourly': [-7, -1],\n",
    "    't_weather_daily': [-13, 0],\n",
    "    't_weather_hourly': [-2, 0],\n",
    "    'epsilon': epsilon\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function Definitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fix_DST(data):\n",
    "    data = data[~data.index.duplicated(keep='first')]\n",
    "    data = data.resample('H').ffill()\n",
    "    return data\n",
    "\n",
    "def crop(data):\n",
    "    hour_index = data.index.hour\n",
    "    t0 = data[hour_index==0].head(1).index\n",
    "    tn = data[hour_index==23].tail(1).index\n",
    "    data.drop(data.loc[data.index < t0[0]].index, inplace=True)\n",
    "    data.drop(data.loc[data.index > tn[0]].index, inplace=True)\n",
    "    return\n",
    "\n",
    "def time_from_to(date, t):\n",
    "    t0_ = pd.Timestamp(date)+pd.Timedelta(days=t[0])\n",
    "    tn_ = pd.Timestamp(date)+pd.Timedelta(days=t[1])+pd.Timedelta(hours=23)\n",
    "    return slice(t0_, tn_)\n",
    "\n",
    "def day_from_to(date, t):\n",
    "    t0_ = pd.Timestamp(date)+pd.Timedelta(days=t[0])\n",
    "    tn_ = pd.Timestamp(date)+pd.Timedelta(days=t[1])\n",
    "    return slice(t0_, tn_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Definitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DataLoader:\n",
    "    \n",
    "    def __init__(self, properties):\n",
    "        self.data_path = properties.get('data_path', '/tmp')\n",
    "        self.categories = ['consumption', 'weather', 'profiles']\n",
    "        self.files = [self.data_path + '/' + '20201015_' + name + '.xlsx' for name in self.categories]\n",
    "        return\n",
    "    \n",
    "    def scale_data(self, data):\n",
    "        x = data.groupby(data.index.date).mean()\n",
    "        x.index = pd.to_datetime(x.index)\n",
    "        x = x.append(pd.DataFrame(x.tail(1), index=x.tail(1).index+pd.Timedelta(days=1)))\n",
    "        x = x.resample('h').ffill()[:-1]\n",
    "        x.index = data.index\n",
    "        y = data / x\n",
    "        return y\n",
    "    \n",
    "    def load_metadata(self):\n",
    "        customers = pd.read_excel(self.files[self.categories.index('profiles')])\n",
    "        customers.columns = ['customer', 'profile']\n",
    "        profiles = pd.DataFrame(customers['profile'].unique(), columns=['profile'])\n",
    "        holidays = hd.ES(years=list(range(2010, 2021)), prov=\"MD\")\n",
    "        return customers, profiles, holidays\n",
    "    \n",
    "    def load_data(self):\n",
    "        consumptions = pd.read_excel(self.files[self.categories.index('consumption')], parse_dates=[0], index_col=0)\n",
    "        consumptions.columns = pd.DataFrame(consumptions.columns, columns=['customer']).index\n",
    "        consumptions.index.name = 'time'\n",
    "        consumptions = fix_DST(consumptions)\n",
    "        crop(consumptions)\n",
    "        consumptions_scaled = self.scale_data(consumptions)\n",
    "        weather = pd.read_excel(self.files[self.categories.index('weather')], parse_dates=[0], index_col=0)\n",
    "        weather.columns = consumptions.columns\n",
    "        weather.index.name = 'time'\n",
    "        weather = fix_DST(weather)\n",
    "        weather_forecast = weather.copy()\n",
    "        weather_forecast.index = weather.index-pd.Timedelta(days=1)\n",
    "        crop(weather)\n",
    "        crop(weather_forecast)\n",
    "        return consumptions, consumptions_scaled, weather, weather_forecast\n",
    "    \n",
    "    def prepare_data(self, consumptions, weather, holidays):\n",
    "        days = pd.DataFrame(pd.to_datetime(consumptions.index.date), index=consumptions.index, columns=['date'])\n",
    "        days['day_of_week'] = list(days.index.dayofweek)\n",
    "        days['day_of_month'] = list(days.index.day)\n",
    "        days['month'] = list(days.index.month)\n",
    "        days['day_category'] = days['day_of_week'].replace({0:0,1:1,2:1,3:1,4:2,5:3,6:4})\n",
    "        days.loc[days['date'].apply(lambda d: d in holidays), 'day_category'] = 4\n",
    "        days = days.groupby(['date']).first()\n",
    "        consumptions_daily_mean = pd.DataFrame(consumptions.groupby(consumptions.index.date).mean(), index=days.index)\n",
    "        weather_daily_mean = pd.DataFrame(weather.groupby(weather.index.date).mean(), index=days.index)\n",
    "        return consumptions_daily_mean, weather_daily_mean, days"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Feature Extractor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FeatureExtractor:\n",
    "    \n",
    "    def __init__(self, properties, customers, consumptions, consumptions_scaled, weather, \n",
    "                 weather_forecast, holidays):\n",
    "        self.models_path = properties.get('models_path', '/tmp')\n",
    "        self.t_consumption_daily = properties.get('t_consumption_daily', [-13, -1])\n",
    "        self.t_consumption_hourly = properties.get('t_consumption_hourly', [-2, -1])\n",
    "        self.t_weather_daily = properties.get('t_weather_daily', [-2, -0])\n",
    "        self.t_weather_hourly = properties.get('t_weather_hourly', [-2, -0])\n",
    "        self.encoder = properties.get('encoder')\n",
    "        self.epsilon = properties.get('epsilon', 1e-5)\n",
    "        self.scaler_names = ['consumptions', 'consumptions_daily_mean',\n",
    "                             'weather_daily_mean', 'day_of_month', 'month',\n",
    "                             'weather_forecast']\n",
    "        self.scalers = properties.get('scalers', {})\n",
    "        self.customers = customers\n",
    "        self.consumptions = consumptions\n",
    "        self.consumptions_scaled = consumptions_scaled\n",
    "        self.weather = weather\n",
    "        self.weather_forecast = weather_forecast\n",
    "        self.holidays = holidays\n",
    "        self.days = self.get_days(consumptions.index, holidays)\n",
    "        self.consumptions_daily_mean = pd.DataFrame(consumptions.groupby(consumptions.index.date).mean(), \n",
    "                                               index=self.days.index)\n",
    "        self.weather_daily_mean = pd.DataFrame(weather.groupby(weather.index.date).mean(), \n",
    "                                               index=self.days.index)\n",
    "        return\n",
    "\n",
    "    def get_days(self, dates, holidays):\n",
    "        days = pd.DataFrame(pd.to_datetime(dates.date), index=dates, columns=['date'])\n",
    "        days['day_of_week'] = list(days.index.dayofweek)\n",
    "        days['day_of_month'] = list(days.index.day)\n",
    "        days['month'] = list(days.index.month)\n",
    "        days['day_category'] = days['day_of_week'].replace({0:0,1:1,2:1,3:1,4:2,5:3,6:4})\n",
    "        days.loc[days['date'].apply(lambda d: d in holidays), 'day_category'] = 4\n",
    "        days = days.groupby(['date']).first()\n",
    "        return days\n",
    "        \n",
    "    def split(self, indices, seed=12345):\n",
    "        n = len(indices)\n",
    "        n_validate = n//10\n",
    "        n_test = n//10\n",
    "        n_train = n-n_validate - n_test\n",
    "        np.random.seed(seed)\n",
    "        I = np.random.permutation(indices)\n",
    "        I_train = I[0:n_train]\n",
    "        I_test = I[n_train:n_train + n_test]\n",
    "        I_validate = I[n_train + n_test:]\n",
    "        return I_train, I_test, I_validate\n",
    "\n",
    "    def fit(self):\n",
    "        I_train, I_test, I_validate = self.split(self.customers, seed)\n",
    "        self.scalers['consumptions'] = RobustScaler(quantile_range=(0,75))\n",
    "        self.scalers['consumptions'].fit(self.consumptions_daily_mean.loc[:, I_train].values.reshape(-1, 1))\n",
    "        self.scalers['weather'] = RobustScaler(quantile_range=(0,75))\n",
    "        self.scalers['weather'].fit(self.weather_daily_mean.loc[:, I_train].values.reshape(-1, 1))\n",
    "        self.scalers['day_of_month'] = RobustScaler(quantile_range=(0,75))\n",
    "        self.scalers['day_of_month'].fit(self.days['day_of_month'].values.reshape(-1, 1))\n",
    "        self.scalers['month'] = RobustScaler(quantile_range=(0,75))\n",
    "        self.scalers['month'].fit(self.days['month'].values.reshape(-1, 1))\n",
    "        X = self.weather_forecast.loc[:, I_train]\n",
    "        X.index = pd.MultiIndex.from_arrays([X.index.date, X.index.time], names=['date','time'])\n",
    "        X = X.stack().unstack(level=1)\n",
    "        self.scalers['weather_forecast'] = RobustScaler(quantile_range=(0,75))\n",
    "        self.scalers['weather_forecast'].fit(X)\n",
    "        dates = self.consumptions_daily_mean.index.date\n",
    "        return [I_train, I_test, I_validate], dates, self.scalers\n",
    "    \n",
    "    def load(self):\n",
    "        scalers = [joblib.load(self.models_path + '/' + name) for name in self.scaler_names]\n",
    "        self.scalers = dict(zip(self.scaler_names, scalers))\n",
    "        return\n",
    "    \n",
    "    def extract(self, date, customers):\n",
    "        n = len(customers)\n",
    "        X1 = self.consumptions_scaled.loc[time_from_to(date, self.t_consumption_hourly),customers].values.T\n",
    "        X1 = X1 + self.epsilon\n",
    "        X2 = self.weather.loc[time_from_to(date, self.t_weather_hourly),customers].values.T\n",
    "        X2 = self.scalers['weather_forecast'].transform(X2.reshape(-1,24)).reshape(n, -1)\n",
    "        X2 = (X2 + 1) / 2\n",
    "        X3 = self.days.loc[pd.Timestamp(date),'day_of_month']\n",
    "        X3 = np.ones((n, 1)) * X3\n",
    "        X3 = self.scalers['day_of_month'].transform(X3)\n",
    "        X3 = (X3 + 1) / 2\n",
    "        X4 = self.days.loc[pd.Timestamp(date),'month']\n",
    "        X4 = np.ones((n, 1)) * X4\n",
    "        X4 = self.scalers['month'].transform(X4)\n",
    "        X4 = (X4 + 1) / 2\n",
    "        X5 = self.days.loc[pd.Timestamp(date),'day_category']\n",
    "        X5 = np.ones((n, 1)) * X5\n",
    "        X5 = self.encoder.transform(X5)\n",
    "        X6 = self.consumptions_daily_mean.loc[day_from_to(date, self.t_consumption_daily), customers].values.T\n",
    "        X6 = X6 / (2 * self.scalers['consumptions'].scale_) + self.epsilon\n",
    "        X7 = self.weather_daily_mean.loc[day_from_to(date, self.t_weather_daily), customers].values.T\n",
    "        X7 = self.scalers['weather'].transform(X7.reshape(-1, 1)).reshape(n, -1)\n",
    "        X7 = (X7 + 1) / 2\n",
    "        Xa = np.nan_to_num(np.concatenate([X1, X2, X3, X4, X5], axis=1))\n",
    "        Xb = np.nan_to_num(np.concatenate([X6, X7, X3, X4, X5], axis=1))\n",
    "        return [Xa, Xb]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "loader = DataLoader(properties)\n",
    "consumptions, consumptions_scaled, weather, weather_forecast = loader.load_data()\n",
    "customers, profiles, holidays = loader.load_metadata()\n",
    "encoder = OneHotEncoder(sparse=False)\n",
    "_ = encoder.fit(np.arange(5).reshape(-1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "properties['encoder'] = encoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extracting Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_customers = customers[customers['profile'].astype(str).str.contains('hogares')].index.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "extractor = FeatureExtractor(properties, selected_customers, consumptions, consumptions_scaled,\n",
    "                             weather, weather_forecast, holidays)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "I, dates, scalers = extractor.fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "features = [[extractor.extract(date, Ii) for date in dates[15:]] for Ii in I]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results: 2 Feature Vectors Xa, Xb\n",
    "\n",
    "The feature vector *Xa* contains 168 scaled consumption values (past 7 days, hourly), 72 scaled temperature values (weather of the past 2 days, hourly and weather forecast for the current day, hourly), the day of month, the month, and the onehot encoded day category. In total, *Xa* consists of **247** values.\n",
    "\n",
    "The feature vector *Xb* contains 14 scaled daily mean consumption values (past 14 days), 14 scaled daily mean temperature values (past 13 days and forecast for the current day), the day of month, the month, and the onehot encoded day category. In total, *Xb* consists of **35** values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "Xa, Xb = features[1][0][0], features[1][0][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((31, 247), (31, 35))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Xa.shape, Xb.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.50040346 1.43535144 0.99047953 ... 0.         0.         0.        ]\n",
      " [3.07341324 0.76264108 0.30506243 ... 0.         0.         0.        ]\n",
      " [3.32322362 3.1514354  0.34062459 ... 0.         0.         0.        ]\n",
      " ...\n",
      " [2.46919953 2.45427995 2.35730272 ... 0.         0.         0.        ]\n",
      " [0.6861781  0.6893548  0.63852754 ... 0.         0.         0.        ]\n",
      " [1.98075064 0.07911554 0.07446227 ... 0.         0.         0.        ]]\n"
     ]
    }
   ],
   "source": [
    "print(Xa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.5625147  0.33254103 0.47375953 ... 0.         0.         0.        ]\n",
      " [0.22573396 0.17973922 0.19113448 ... 0.         0.         0.        ]\n",
      " [0.13118713 0.40967529 0.5782349  ... 0.         0.         0.        ]\n",
      " ...\n",
      " [0.48304874 0.531488   0.43916006 ... 0.         0.         0.        ]\n",
      " [0.35627175 0.32133381 0.33325558 ... 0.         0.         0.        ]\n",
      " [0.09057036 0.50294343 0.40155193 ... 0.         0.         0.        ]]\n"
     ]
    }
   ],
   "source": [
    "print(Xb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(Xa[0], color='g')\n",
    "plt.xlabel('feature vector (247 features)')\n",
    "plt.ylabel('feature value')\n",
    "plt.title('Feature Vector Xa')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7IAAAGECAYAAAALPBxtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAB+bElEQVR4nO3dd3hUZfo+8PtMyWRaKkkIvSWACCT0oiAiICUiiAooWFHXgrrqumtZXRXbuj/bWlbXtl8b1kUQAdHFQg9SbCR0QkslyZlMP3N+fwwztEBIMjNnzsn9uS4vM+2cB06G5J73ed9XkGVZBhEREREREZFK6JQugIiIiIiIiKgxGGSJiIiIiIhIVRhkiYiIiIiISFUYZImIiIiIiEhVGGSJiIiIiIhIVRhkiYiIiIiISFUYZImIqMXo3r07CgoKMHny5PB/999/f5OPt2XLFvz1r3+NYIVHybKMCy64AIsWLTrpsUcffRSPPfZYk4577bXXoqqqqsl1+f1+TJ8+HU8++eRx9z/yyCO48847AQDnn38+fv755yafg4iIqCEGpQsgIiKKpXfeeQdpaWkROdb27dtRWloakWOdSBAEzJgxA59++ikmTZoUvt/tdmPhwoX48MMPm3TclStXNqsug8GA5557DlOmTEH//v0xZswYfPzxx9iwYUOTayIiImosBlkiIiIAO3bswLx581BdXQ1JkjBr1ixMmzYNgUAAjz/+ODZv3oy6ujrIsozHHnsMbdq0wQsvvABRFPGXv/wFF198MR599NHwCOratWvDt1988UVs2rQJZWVl6N69O5555hm88sorWLZsGQKBANq2bYuHHnoIWVlZx9V0ySWX4MUXX8T+/fvRtm1bAMBXX32FXr16oUuXLqesGQA++eQTvPXWW9DpdEhNTcVTTz2FF154AQBw1VVX4bXXXoPD4cAjjzyC6upqCIKAa6+9FhdffDHWrl2LefPmwWKxwOl04pNPPkFCQkK4rtatW+Pvf/877rrrLsiyjOeffx4ffPABzGZz+Dnvv/8+tm7dCq/Xi2uuuSZcFxERUSQwyBIRUYty1VVXQac7OrPmzTffRHJyMubOnYunn34avXr1giiKuPzyy9GtWzfIsoyysjLMnz8fOp0Or732Gl5//XW8+uqrmDt3LpYuXYonnngCa9euPe159+/fj0WLFsFgMOC///0viouL8fHHH8NgMGD+/Pl44IEH8Prrrx/3mpSUFIwfPx6fffYZbrvtNgDA/Pnzcf3118Pv95+y5sTERDzzzDP4/PPPkZ2djbfffhuvvPIKnnjiCXz22Wd45513kJSUhFmzZuFPf/oTxo4di9LSUlx66aXo2LEjAGDbtm1Yvnx5OECf6JxzzsHll1+O2267Da+88grat29/3OMmkwmff/45SktLcfHFF6Nv377Iyclp9PUiIiKqD4MsERG1KPW1Fm/fvh179+7FfffdF77P7Xbjt99+w8yZM5GcnIwPP/wQJSUlWLt2LaxWa6PPm5eXB4Mh+GP3f//7H37++WdccsklAIBAIACXy1Xv62bMmIE77rgDt956K7Zv346ysjKMGjUKu3btOmXNHo8H55xzDrKzswEAV1999UnH3b17NzweD8aOHQsAyMrKwtixY/HDDz9g8ODByM7OPmWIBQCfz4f169cjIyMD33zzDc4///zjHp8+fXr4uOeccw5Wr17NIEtERBHDIEtERC2eJElISkrCggULwvdVVFTAbrdjxYoVmDdvHq655hqMHj0aXbp0wRdffHHSMQRBgCzL4ds+n++4xy0WS/jrQCCA66+/HjNnzgQAeL1e1NTU1Ftbnz59kJaWhlWrVmHFihWYPn069Hr9aWueP38+BEEI3+92u7F//3507dr1uBpOJMsy/H7/SfXWZ968ebBarfj0008xdepUfPbZZ5g6dWr48WNHvWVZDod4IiKiSOCqxURE1OJ17twZJpMpHAoPHjyISZMm4ZdffsHKlSsxatQozJw5E71798by5cshSRIAQK/Xh4NfWloaDhw4gMrKSsiyjOXLl5/yfOeccw4++eQTOBwOAMDzzz+PP/3pT6d8/syZM/H5559j2bJl4bmmp6t58ODBWL16NcrKygAAH374If7+978fV3Pnzp1hNBqxbNkyAEBpaSmWLl2KYcOGNfj39emnn+L777/HM888g6ysLDzzzDN49NFHsXXr1vBzPv/8cwDAgQMHsGrVKgwdOrTB4xIREZ0pfjxKREQtXkJCAl5++WXMmzcP//73v+H3+3H77bejf//+SElJwd13342CggLo9XoMGDAgvEhTfn4+nnvuOdxyyy146aWXMH36dFxyySXIyMjAeeedd8rzXXrppSgtLcVll10GQRCQnZ190nY2x5o4cSKefvppjBw5MtwWfbqaAeCee+7B9ddfDwDIyMjA448/DgAYM2YMZs6ciZdffhkvv/wyHnvsMbz44ouQJAm33HILhgwZctr5vlu2bMHjjz+Ot956CykpKQCAoUOH4vrrr8ftt9+OTz/9FADg8XgwZcoU+Hw+PPDAA+jcufMZXw8iIqKGCPKxfVBEREREREREcY6txURERERERKQqDLJERERERESkKgyyREREREREpCoMskRERERERKQqDLJERERERESkKgyyREREREREpCqq3kf28OE6BALxu3tQeroNlZUOpcugKOC11S5eW23j9dUuXltt4/XVLl5b7WrutdXpBKSmWk/5uKqDbCAgx3WQBRD39VHT8dpqF6+ttvH6ahevrbbx+moXr612RfPasrWYiIiIiIiIVIVBloiIiIiIiFSFQZaIiIiIiIhUhUGWiIiIiIiIVIVBloiIiIiIiFSFQZaIiIiIiIhUhUGWiIiIiIiIVIVBloiIiIiIiFQl6kHW4XBg0qRJ2Ldv30mP/f7777jkkkswbtw43H///fD7/dEuh4iIiIiIiFQuqkF28+bNmDFjBnbv3l3v4/fccw8efPBBLF26FLIs46OPPopmOURERERERKQBUQ2yH330ER566CFkZmae9Nj+/fvhdruRl5cHAJg6dSqWLFkSzXKIiIiIiIhIAwzRPPi8efNO+VhZWRkyMjLCtzMyMlBaWhrNcoiIiIiIqIUoffc/sPbpA1ufPKVLoSiIapA9HVmWT7pPEIRGHSM93RapcqImI8OudAkUJby22sVrq228vtrFa6ttvL7aFY1rK0sSir/7HxITdMgYfW7Ej09nJprvW8WCbFZWFioqKsK3y8vL621BPp3KSgcCgZMDcbzIyLCjvFxUugyKAl5b7eK11TZeX+3itdU2Xl/tita19Yu1gCzDUV7F7x2FNPfa6nTCaQcuFdt+p23btjCZTNiwYQMA4L///S9GjBihVDlERERERKQRkugAAAQcDoUroWiJeZCdM2cOfv75ZwDAM888gyeeeALjx4+Hy+XC7NmzY10OERERERFpjOQIjgT6xVqFK6FoiUlr8bfffhv++vXXXw9/3aNHD3zyySexKIGIiIiIiFoISQwGWYkjspqlWGsxERERERFRNIRGZAN1dZADAYWroWhgkCUiIiIiIk0JjchCljkqq1EMskREREREpCmhEdkTvybtYJAlIiIiIiJNCY/InvA1aQeDLBERERERaYrkcEBISAh+zSCrSQyyRERERESkKZIoIqF1dvBrthZrEoMsERERERFpiiSKSMjODn9N2sMgS0REREREmiHLMiSHCENKCnRmM1ct1igGWSIiIiIi0gzZ44Hs80Fvs0Nvs3NEVqMYZImIiIiISDNCwVVvt0NvZ5DVKgZZIiIiIiLSjNDiTnrbkSDLxZ40iUGWiIiIiIg0w3/siKyNQVarGGSJiIiIiEgzAkcWdwqPyIoiZFlWuCqKNAZZIiIiIiLSDL9YCyA0ImuD7PdD9rgVrooijUGWiIiIiIg0QxJFQK+HzmyG3m4HcLTdmLSDQZaIiIiIiDRDcjigt9khCEI4yEoi95LVGgZZIiIiIiLSDMkhQm+zAQjOkw3eV6tkSRQFDLJERERERKQZkiiGR2I5IqtdDLJERERERKQZkkOE4UiADf2fW/BoD4MsERERERFphiSK0B1pKRZMiRAMhuACUKQpDLJERERERKQJst+PgNMZHokNLfjEEVntYZAlIiIiIiJNkOqCc2FDiz2FvuaIrPYwyBIRERERkSZIjiNB1p4Uvk9vSwrfT9rBIEtERERERJoQGnkNrVYc+pojstrDIEtERERERJoQDrIntRZzH1mtYZAlIiIiIiJNCC3qdOKIbMDlguz3K1UWRQGDLBERERERaUJ4RNZ67IhsaC9ZzpPVEgZZIiIiIiLSBMkhQmexQDAYwveFRmc5T1ZbGGSJiIiIiEgTJFE8rq0YOCbIci9ZTWGQJSIiIiIiTfCLYriVOCTcWswRWU1hkCUiIiIiIk2QHA6OyLYQDLJERERERKQJUn0jslYrgOBoLWkHgywREREREameLMuQHOJxe8gCgKDXQ2e1ckRWYxhkiYiIiIhI9QIuFyBJJ7UWA8H2Yknk9jtawiBLRERERESqF95D1lZPkLXZOSKrMQyyRERERESkeqGgeuoRWQZZLWGQJSIiIiIi1QsFVUN9QdZm44isxjDIEhERERGR6oVHZOtpLTbYkyA5HJBlOdZlUZQwyBIRERERkeqFFnOqt7XYZgckCQGXM9ZlUZQwyBIRERERkepJjloIBgMEk+mkx/T24JY8nCerHQyyRERERESkepLogN6eBEEQTnosNEorObgFj1YwyBIRERERkepJDrHetmIA0NuSgs/hiKxmMMgSEREREZHqSaIIvc1W72NHW4trY1kSRRGDLBERERERqd7pR2TZWqw1DLJERERERKR6wRHZ+oOszmSCkJDA1mINYZAlIiIiIiJVC/h8CLjdpxyRBYKjsgyy2sEgS0REREREqhZqGT5tkLXbITkYZLWCQZaIiIiIiFQttIjTqRZ7Cj3m54isZjDIEhERERGRqh0dkU065XP0djsCXOxJMxhkiYiIiIhI1UJzX0+12FPoMY7IakdUg+zChQsxYcIEjBkzBu+9995Jj//666+45JJLcNFFF+HGG29EbS33dSIiIiIiosYJB1n7aVqL7XbIHjcCPm+syqIoilqQLS0txbPPPov3338fCxYswPz587F9+/bjnjNv3jzMnTsXX3zxBTp37ow33ngjWuUQEREREZFGSQ4REAToracPsgAgiWwv1oKoBdlVq1ZhyJAhSElJgcViwbhx47BkyZLjnhMIBFBXVwcAcLlcSExMjFY5RERERESkUZIoQme1QtCdOt6E2o65crE2RC3IlpWVISMjI3w7MzMTpaWlxz3nz3/+M+6//36cc845WLVqFaZPnx6tcoiIiIiISKMkhwjDaebHAoAhPCLLIKsFhmgdWJblk+4TBCH8tdvtxv3334933nkHffr0wVtvvYV7770Xr7322hmfIz391K0D8SIj4/RvKFIvXlvt4rXVNl5f7eK11TZeX+2KxLU95HEhMS3ltMdyerJQAsAq+Pn9FCPR/HuOWpDNyspCYWFh+HZZWRkyMzPDt4uLi2EymdCnTx8AwOWXX47nn3++UeeorHQgEDg5MMeLjAw7ysv5iY8W8dpqF6+ttvH6ahevrbbx+mpXpK6tu+owErKyT3ssyacHABw+UAbw+ynqmnttdTrhtAOXUWstHjZsGFavXo2qqiq4XC4sW7YMI0aMCD/esWNHHDp0CDt37gQAfPPNN+jdu3e0yiEiIiIiIo2SREd4MadT0VksgCBwjqxGRHVE9s4778Ts2bPh8/kwbdo09OnTB3PmzMHcuXPRu3dvPPHEE7jjjjsgyzLS09Px+OOPR6scIiIiIiLSIDkQgFTngN52+mmHgk4Hvc3GObIaEbUgCwAFBQUoKCg47r7XX389/PXIkSMxcuTIaJZAREREREQaFnA6gUCgwRFZILgFj+Tg9jtaELXWYiIiIiIiomgLtQqfUZC12TkiqxEMskREREREpFqhYKpvYPsd4MiILIOsJjDIEhERERGRajV6RJaLPWkCgywREREREamWv1EjsjZIDgfkQCDaZVGUMcgSEREREZFqBY4s3nRmI7JJgCwjUFcX7bIoyhhkiYiIiIhItfyiCMFkgi4hocHn6u3BLXrYXqx+DLJERERERKRakljb4B6yIaH2Yz8XfFI9BlkiIiIiIlItyeGA3p50Rs8NtR9zL1n1Y5AlIiIiIiLVkkTxjBZ6Ao6OyHILHvVjkCUiIiIiItWSHGJ47mtDwiOyYm00S6IYYJAlIiIiIiLVkkQRhjMckdUZjdAlJrK1WAMYZImIiIiISJUCHg9kr/eMtt4J0dvsbC3WAAZZIiIiIiJSpdDI6pnOkQWC7cXcfkf9GGSJiIiIiEiVQiOrjRuRtXFEVgMYZImIiIiISJUkR3DRJo7ItjwMskREREREpEqSeKS1uDEjsnY7F3vSAAZZIiIiIiJSpXBrse3Mtt8JPtcO2etFwOOJVlkUAwyyRERERESkSpJDBHQ66CyWM35NeC9ZtherGoMsERERERGpkuQQobfZIOjOPNaE5tNywSd1Y5AlIiIiIiJV8otioxZ6Ao4ZkWWQVTUGWSIiIiIiUqWAw9GohZ6AY0Zk2VqsagyyRERERESkSn6xtlELPQGA3h58Pkdk1Y1BloiIiIiIVElyOKC3JzXqNTqzBdDr4WeQVTUGWSIiIiIiUh05EECgrq7RrcWCIEBvs7G1WOUYZImIiIiISHUkhwOQ5Ua3FgPBebJsLVY3BlkiIiIiIlKd0IhqY0dkQ6+RHI5Il0QxxCBLRERERESqExpRNTRyjizAEVktYJAlIiIiIiLVCY/INqW12M4gq3YMskREREREpDqhINqk1mKbDQFnHWRJinRZFCMMskREREREpDqhIKuzNn5E1nAk/HKerHoxyBIRERERkepIDgd0ZjN0RmOjXxvae5ZBVr0YZImIiIiISHUkUYTe1vi2YuDovFpJrI1kSRRDDLJERERERKQ6kkOE3t74tmLg6Lza0IJRpD4MskREREREpDrNGpENBVmRrcVqxSBLRERERESqIzmaEWSPLBDFEVn1YpAlIiIiIiJVkWU5OCLbhK13AEAwGKCzWLiXrIoxyBIRERERkarIHjdkv7/JQRYA9DY7R2RVjEGWiIiIiIhUxX9kJLWprcVAcJ4sR2TVi0GWiIiIiIhUJbRIU7NGZO0ckVUzBlkiIiIiIlIVyRHc/zW0H2xT6G228MguqQ+DLBERERERqcrREdmkJh9Dbwu2FsuyHKmyKIYYZImIiIiISFVCLcHNbS2GJCHgdkeqLIohBlkiIiIiIlIVSRQBvR66xMQmHyO0UBQXfFInBlkiIiIiIlIVyRHcQ1YQhCYfIzSaywWf1IlBloiIiIiIVEUSRRia0VYMcERW7RhkiYiIiIhIVSSHo1l7yAIIB2EGWXVikCUiIiIiIlWRRLFZCz0BgN4e3LqHrcXqxCBLRERERESqIom1zdpDFgAEUyIEg4EjsirFIEtERERERKoh+/0IuFzN2kMWAARBgN6eBMnhiFBlFEsMskREREREpBqh4NncObLBY9ggibXNPg7F3hkFWbfbjaKiIsiyDDc3DCYiIiIiIoWE5rSG5rg2h95u5xxZlWowyG7atAkXXHABbrzxRpSWlmLkyJH46aefzujgCxcuxIQJEzBmzBi89957Jz2+c+dOzJo1CxdddBGuu+461NTUNP5PQERERERELUZoTmtkRmTtkES2FqtRg0H26aefxttvv42UlBS0bt0aTz/9NObNm9fggUtLS/Hss8/i/fffx4IFCzB//nxs3749/Lgsy/jDH/6AOXPm4IsvvkDPnj3x2muvNe9PQ0REREREmhYOss1ctTh0DI7IqlODQdbtdqNbt27h2yNHjoQkSQ0eeNWqVRgyZAhSUlJgsVgwbtw4LFmyJPz4r7/+CovFghEjRgAAbrrpJlxxxRVN+TMQEREREVELEW4tjsSIrN2OgMsF2e9v9rEothoMsgaDATU1NRAEAUCwHfhMlJWVISMjI3w7MzMTpaWl4dt79+5Fq1atcO+996KgoAAPPfQQLBZLY+snIiIiIqIWxB9uLY7AHFkb95JVK0NDT/jDH/6AK6+8EhUVFfjjH/+IlStX4pFHHmnwwLIsn3RfKAwDgN/vx7p16/Duu++id+/eeO655/Dkk0/iySefPOPi09Ob/80bbRkZzf+kiOITr6128dpqG6+vdvHaahuvr3Y19trWSh4YbDZktk5p9rmFtpkoA5BkCMDK77GIi+b7tsEgO2rUKHTp0gUrV65EIBDAzTfffFyr8alkZWWhsLAwfLusrAyZmZnh2xkZGejYsSN69+4NAJg0aRLmzp3bqOIrKx0IBE4OzPEiI8OO8nJ+uqNFvLbaxWurbby+2sVrq228vtrVlGvrKKuCYLVF5HvCGQjGoYqSUjht6c0+Hh3V3PetTiecduCywdbi6upqJCcnY8KECZg0aRJatWqF6urqBk88bNgwrF69GlVVVXC5XFi2bFl4PiwA5Ofno6qqClu3bgUAfPvtt+jVq9cZ/JGIiIiIiKilkhxiRNqKgaMLRvm5l6zqNDgiO2TIkONagoHgaOr3339/2tdlZWXhzjvvxOzZs+Hz+TBt2jT06dMHc+bMwdy5c9G7d2+89NJLeOCBB+ByucIrIhMREREREZ2KJIowHrMWT3OEgmxoJWRSjwaDbGjEFAB8Ph+WLVt23H2nU1BQgIKCguPue/3118Nf9+3bF5988smZ1kpERERERC2c5BCR2KVLRI6lt9oAQYDk4F6yatNga/GxjEYjJk6ciJUrV0arHiIiIiIionrJsgzJ4YjI1jsAIOh00FmtHJFVoQZHZI+dDyvLMn755RfU1rKHnIiIiIiIYivgcgKSBIM9cqvhGmx2br+jQmc8Rza0nU56ejruv//+qBdGRERERER0rNDIqT6CQVZvt3NEVoUaNUeWiIiIiIhIKaG5rJFqLQ4dy1t6KGLHo9g4ZZB96623TvvCa665JuLFaIns94dHsYmIiIiIqPmiMyJrg7SDI7Jqc8ogW1xcHMs6NGfPow/DO/o8mEZcoHQpRERERESaIB3Z7zVS+8gGj2WH5HBADgQg6Bq1Fi4p6JRB9oknnohlHZpjSE3DoSVL0eHc0Sftw0tERERERI0Xbi22J0XsmHq7HQgEEHC5oLdaI3Zciq4G58hu3LgRr732GpxOJ2RZRiAQwL59+7BixYoYlKdeSYMH49Abr8O9YzvM3XKULoeIWgDP/n0Q169D6rjx0JvNSpdDREQUcZIoQkhIgM5kitgxQ/NtJVFkkFWRBsfOH3jgAeTn58PhcKCgoAA2mw1jx46NRW2qZsvvB11CAsR1a5QuhYhaiKoli1G16AvsfeSvcO3coXQ5REREESc5xIi2FQNH59ty5WJ1aTDICoKAG264AYMGDUKXLl3w/PPPo7CwMBa1qZou0YzUgf0hrl8HWZKULoeIWgBXURFMnTpDlgIoeepxVC1eBDkQULosIiKiiJFEMaIrFgPHjMhyL1lVaTDIWo8Mr3fo0AHbtm2DyWSCxGB2RjJGnAtJFOH8/TelSyEijfNVlMNfVYmkYcPR8aFHYMvLR8Vnn2D/s8/AX31Y6fKIiIgiwi+KEV2xGOCIrFo1GGR79+6NO+64A0OGDMGbb76JJ598Enq9Pha1qV5q/37Qmc1sLyaiqHMWFQEALLndobdakX3TLciafQ1cO7Zjz8N/hWPzJmULJCIiioCAwxGFEdlgqzJHZNWlwSB7//334+qrr0bnzp1x3333IRAI4JlnnolFbaqnMxph6z8Ajp82IOD1Kl0OEWmYq7gIOqsVCW3aAghOC0keMRIdHngYhtQUHHjxOZR98B4CPv5bRERE6hWNEVmdyQQhIYEjsirTYJC966674Ha7AQDnnXce7rvvPnTp0iXqhWlF0uChCLjdqPt5s9KlEJGGuYq3wpzb/aT970xt2qD9fQ8iZfQYVH/zNUoefxSeAwcUqpKIiKjpAj4vZI874os9AcH2Yj9HZFWlwSA7cOBA/L//9/8wZswY/Otf/0J5eXks6tIMc/ce0CcnQ1zL9mIiig5fVSV85eWw5Hav93GdMQGZM65Am9vugP9wNfY+9jBqvv8OsizHuFIiIqKmk8TI7yEborfZw8cndWgwyM6YMQMfffQRXn31VdTU1GD69Om45ZZbYlGbJgg6HewDB6Fuy2ZITqfS5RCRBrmOzI81d+9x2ufZ+uah48OPwNy1G0r/8xYO/utlSM66WJRIRETUbKE5rNEakeUcWXVpMMiGuN1ueL1eyLLMxZ4ayT5oKGS/H46NG5QuhYg0yFm8FTqzGaZ27Rt8riElFW3vvButLrkUjo0/Yc/Df4Vr27YYVElERNQ8oTmskZ4jGzqmJNZG/LgUPYaGnvDmm2/i888/h9frxbRp0/DRRx+hVatWsahNMxI7d4YxIxPi2jVIHn6u0uUQkca4iotgzsk9aX7sqQg6HdLGT4S5ew8ceu1VlDz9ONIvuhhpEwvO+BhERESxFhoxNUQjyNrskBxsLVaTBoPsr7/+igceeACDBw+ORT2aJAgC7IMHo+rLRfDXVMOQnKJ0SUSkEf7qavhKS5E84rxGv9bcpSs6PPQIyt79DyoXfA7n77+h9fU3wJiWHvlCiYiImik8RzbC2+8AwXAsezwIeL3QJSRE/PgUeQ1+9P6Pf/yDITYC7IOGArIMsXC90qUQkYY4i7cCwCkXemqI3mxG9pwb0fq6OXDv2YM9D/8V4k+cBkFERPFHctQCggCd1RrxY+u4l6zqsIcsRkxt2sDUvj1XLyaiiHIVFUGXmAhTh47NOk7S0OHo+NeHYczIwMGXX0Tp/72NgMcToSqJiIiaTxJF6G22qEyDCbUrcy9Z9WCQjSH7oKFw79wBb3mZ0qUQkUa4iouQ2C0HQgQW4UvIao0Of3kAqePGo+a7Fdg772/w7CuJQJVERETNJzkcUWkrBgC9LbilD4OsepxxkK2t5SpezWUfFGzRFtetVbgSItICf20tvAcPNLmtuD6CwYCMSy9H2zvvhuRwYO9jf0P1t8u55ywRESlOEsWorFgMAHo7W4vVpsEgu3PnTkycOBETJ05EaWkpxo8fjx07dsSiNs0xpqfDnJPL9mIiighX8ZntH9sU1l5no+PDj8HcoyfK3n8XB156gas5EhHFGU9JCWpXrVS6jJgJtRZHQ2iklyOy6tFgkH3sscdw3333IT09HVlZWbjyyivx17/+NRa1aZJ90BB4D+xnux4RNZureCuEhAQkduwUleMbkpLQdu6dyLhsBup+3oI9f3sQziPhmYiIlFf+6Uc49Na/IblcSpcSE5IjeiOyOosF0On4oa2KNBhkq6urMXz48PDtK664Ag5e4CazDRgA6HSo5agsETWTs6gI5q45EAwN7qTWZIJOh9Sx49DhvgchGIw4+MpLkAOBqJ2PiIjOjORwwPn7b4Asw71jm9LlRJ0cCATnyEYpyAo6HfRWG0dkVeSM5sh6PB4IggAAKC8vR4C/xDSZwZ4Ey1lnQ1y3hnPOiKjJJIcD3v37YO4eufmxp5PYsRNaTbkEklgL905OLyEiUppj4wZAkgAAruJihauJvoDTCchy1BZ7AgC93c4gqyINBtkZM2bguuuuQ2VlJf7xj3/g8ssvx4wZM2JRm2YlDR4Cf2Ul3Du2K10KEamUa9uR+bERXOipIZazewN6PRybNsbsnEREVD+xcD2MGZlI7NwFrm3aD7KSGFx4NlojsgCgt9m42JOKNNiPdumll6JTp05YsWIF/H4/HnnkEZxzzjmxqE2zbPn5EIxG1K5dA3O3HKXLISIVchYVQTAakdi5S8zOqbdYYMntjrrNm5Ax7bKYnZeIiI4niSKcv/+GtAsnQJYkVH/zNQJeL3QJCUqXFjX+IyOl0R6R9e7fH7XjU2Q1OCJ71VVXYeDAgbjnnntw7733MsRGgC7RDGvffDgK10E+0hJCRNQYruIiJHbpCp3RGNPzWvvmw3vwALylpTE9LxERHSVu3AAEArANGAhzTi5kvx/uXTuVLiuqQoswRXVE1p7ExZ5UpMEgK4oinE5nLGppUZIGDw5/mkZE1BiSsw6ekr0xbSsOsfXNAwDUbd4U83MTEVGQY/16GLOyYGrfAeacXEAQwluyaZUUixFZmw1SnYOLGqpEg63FZrMZo0aNQvfu3WGxWML3v/rqq1EtTOssZ/eBzmyGuHYNrGf3Vrqc4/iqqlD23n+QOXMWjOnpSpdDRCdwbdsGyDIsUdg/tiHGjAwktG0Hx+aNSB07LubnJyJq6fxiLZxbf0PahEkQBAF6qxUJbdtpfsGn0NxVvT06+8gGj20HZBlSnQMGe1LUzkOR0WCQnTZtWizqaHF0RiNs/QfCUbgOAe9VcTWnoeKT+ajbvAk1HTqi1eQpSpdDRCdwFW+FYDAgsUtXRc5v65uHqiWLIdXVQW+1KlIDEVFL5fhpAyDLsA8YFL7PkpuLmpU/Qvb7o7olm5IkUYRgSoTOGL3fmUOjvZLIIKsGDX6nT5nCIBMtSYOHoPbH71G3ZTPsAwYqXQ4AwLV9G8R1a4Mrk25YzyBLFIecRUVI7NxFsQ/ArHn5qFq8CHW/bEHS4KGK1EBE1FKJ69fB2Lo1Etq1C99nzu2O6m+/gXvvXpi7xG4RwFiSRDGqo7HA0fm3XLlYHRqcI5ufn49+/fqd9B81n7l7D+iTkyGuXaN0KQCCG02Xz/8A+pQUtLr4EngPHICHK7fF3KE3X8fOP92FqsWLuJfZCfzV1dj/0gtw792jdCmKCbhd8Ozdo8j82JDETp2hT0pCHbfhISKKKX9NDVxFW2EfMAiCIITvN+fkAji6NZsWSQ4xqvNjAcAQCrJHtvqh+NbgiOyiRYvCX/t8Pixbtgx6vT6qRbUUgk4H+8BBqFnxP0jOOugtyrboiWvXwL1rJ1pfNweWs3qh4rOPIRaug6ktR2VjRZYkOH7aAMFgRMVnn6Dyi//CPmgIUkZfgMSOnZQuT1Gy348Dr74E9/ZtCLhcaH/3vUqXpAjX9m1AIKBokBV0Olj75MGxYb2m29iIiOKN46fCYFvxwEHH3W9IToExKyu44NO48QpVF12SKMKQnBzVc+hCrcVcuVgVGhyRbdu2bfi/Tp064YYbbsCSJUtiUVuLYB80FLLfD8dPPylaR8DjQcVnH8PUqTPsg4fCkJwCc04uHIXrIcuyorW1JJ69exBwu5E580p0fGQeks4ZAXHDeux99GHsfXIexHVrIfv9SpepiLL578O9fRssZ/eGa+vvwQWPWiBnURGg1yu+B7UtLx8BlwtOja+SSUQUT8T165CQ3QYJbdqe9Jg5pztc24o1u+Ku5HBEfURWbwu2LrMjTh0aDLIn2rFjByorK6NRS4uU2LkzjBmZircXVy1ZDP/hw8icPhOCLvhtYR8wMLhf5AG2F8dKKBSYu3eHqU1bZF05G13+/v+QcfkMSDU1OPjaK9j557tRuXAB/DU1ClcbOzU//oCa/32L1HEXos0fboXebkflogVKl6UIV3EREjt2gs5kUrQOS8+zIBiN3IaHiChG/NXVcG0rhm3AwOPaikMsud0RcDrh1ei0MMkhRnUPWSC4GKsuMZFzZFWiUXNk8/PzMXnyZMyePTsWtbUIgiDAPngwnFt/g7+mWpEafFWVOLz0K9gHDT5ulMfWfwAgCBAL1ytSV0vkKtoKY+vWMCSnhO/TW6xIHTMOneY9iTZz74SpXXtULvgcu+69Cwf//S/Nb4Du3r0LZe++A0vPs9Bq6qXQmUxIHXshnL/+AtdObf/ZTxTweODevUvRtuIQnckES8+z4Ni8kV0bREQxIIbaigcMqvdxc65258kGPB7IXm/UgywQXPCJI7Lq0Kg5soIgICkpCTZbdFcMa2nsg4aiatFCiOvXI/WCMTE/f8WnnwCyjFaXXHrc/eH24vXrkH7RxfV++keRIwcCcG0rhn3g4HofF3Q62Pr0ha1PX3gPHUT1t9+gdtWPENesRmKXLkg5/4Lg4g8amq/or63FgZdfhD45Gdk3/AHCkfn5KaPOR9WSxahatABt596pcJWx49qxHZAkRfaPrY81Lx91WzbDu38fTO3aK10OEZGmOdavQ0KbtjC1PbmtGAAM6a1gSEuDs7gYKedfEOPqoiu8h2wMMgiDrHo0OCL70EMPhefItmnTBjabDZdddlksamsxTG3awNS+A8R1sW8vdu3YDnHtaqSOuxDG9FYnPW4fOAjeQwfZXhwDnpK9CLhcMJ9BSElonY3MmVei89+fRcbMKyE5nTj079ew809/RMWCz+Gvro5+wVEmSxIO/utlSKKINjffdtynsLpEM1LHjEPdls0tagVjV/FWQBCQqPD82BBbnzwAgIPtxUREUeU7fBiu7dtOWuTpWIIgHJknW6S5TplQsNTHYG9Xvc3OxZ5U4pRDN3PnzsWuXbtQUlKCgoKC8P1+vx86XaOn1lID7IOGoOLTj+AtL0NCRmZMzinLMsrnvw99cgrSLpxY73Ns/fqj7P13Ia5fB1PbdvU+hyLDVbQVAGDpfuZto3qzGannX4CU886H87dfUf3tclQt+gJVixfB3n9gcLXjLl1VOZpe/slHcBVtRevr5tS7YnPK+Rfg8NKvULXoC7S5+bbYF6gAV1ERTB07QW82K10KAMCQkgJTp86o27wR6RMLGn4BERE1iWNDsK3Y1n/gaZ9nzs2FuHY1fGWlSMhqHaPqoi8cZGMxImuzw1NSEvXzUPOdMsj+6U9/wv79+/Hggw/iwQcfDN+v1+uRkxMfowFaYh80GBWffgRx7RqkT7ooJucU162Be+dOZF1zPXSJifU+x5CcAnNudzgK1yN98hRVBiK1cBYXwZiZBUNKaqNfK+h0sJ7dG9aze8NbVobq/32D2h+/h7huDUwdOwXbjgcNgs6YEIXKI6927WpUf70UKedfgKShw+t9jt5iQcoFY1G1cAE8+0o039oa8Hrh3rUz7trFbHn5qPzvZ/DXVB83t5uIiCJHLFyHhLbtYGrT5rTPM+cEPwx3FRdpK8iGWotjMkfWBskhQpZl/t4b5045tNquXTsMHjwYS5YswaBBg8L/9e/fHwYNzcGLF8b0dJhzciGuWxOTdpCAx4OKTz6GqWMnJA0ddtrn2gccaS/evy/qdbVUciAAV3ExzI0YjT2VhMxMZF4+A13+/iwyr5wN2edF6Vv/xq577kLFZ5/AV1UVgYqjx713D0rfeQvmnFxkXDb9tM9NHT0GgikRVV8ujFF1ynHv3AHZ74+LhZ6OZeubDwCo27xZ4UqIiLTJV1UFdwNtxSEJ2dnQ2+xwbSuOQWWxc7S1OAZB1pYE2eeD7PFE/VzUPA32CH/77be46KKLcMEFF2D06NEYNWoUhg+vf4SEmsc+aAi8Bw7Auy/6gfHwsiXwH646brudU7H168/Vi6PMs68EAWcdLLmRW8RHl5iIlPPOR8e/zUO7u/6ExG7dUPXVl9j157tRNv8DyJIUsXNFiuRwBBd3slqRfdMtDS5cpbfZkHL+aIiF6+E9eCBGVSrDVVwECEJ4Vcp4kdCuHQzp6XBs2aR0KUREmuTYEPz961SrFR9LOPJzwlWssSDrcAB6PXRmS9TPFQrLXPAp/jUYZJ9++mncdNNNyM7OxkMPPYRzzz0X06effpSEmsY+YCCg16N27eqonsdXVYWqr76EbcAgmHMa/qXYkJwMc/ceEAvXaW7xgHjhOmb/2EgTBAGWnmeh7a23o/MTTyP53BGo/nop9r/wLCSnM+Lnayo5EMDB116BVF2N7D/cCkNy8hm9LnXsOAhGIyo1PirrLC6CqV176C1WpUs5jiAIsPXNg/O3XxHgp9dERBEnFq6HqX0HJLQ+s1Zhc253+CrK4auqjHJlseMXa6G32WLS6huah8u9ZONfg0HWbDZjwoQJyMvLg8lkwsMPP4w1a2K/um5LoLfbYenZC+L6tZADgaidp+LzT4BAABnTLm34yUfY+w+E79AhthdHibNoK4wZGTCmpUf1PMZWGciadTWyZl8D59bfUfLEY/CWl0X1nGeq4rNP4PztV2TOnAVzl65n/DqDPQkp550Pce0aeEtLo1ihcgI+H9w7tkflg45IsPbNh+z1wvn7b0qXQkSkKb7KSrh3bD+jtuKQ0BQULbUXS6IIvS36bcXA0RFZP0dk416DQTYhIQFerxcdOnTA77//Dp1OB6/XG4vaWqSkwUPgr6yEe8eOqBzftXMnxNWrkDr2QhhbZZzx6462F6+LSl0tWXB+bBHMEWwrbkjyiJFod+fd8NfUYO+8R+AsVnbzdLFwHQ4vWYzkkechecTIRr8+ddyFEAwGVH21qOEnq5Bn9y7IPl9Mv0caw9K9B3SJiXBs3qh0KUREmhJqK25oteJjmdq1h85sDnd7aYHkcMRkfiyAcGAOcAueuNdgkB09ejRuuOEGnHvuuXj77bdx2223ISUlJQaltUy2/HwIRiNqo7CnbHi7naQkpE2of7udUznaXrye7cUR5j2wH4G6OljOYP/YSLL06IkO9z8IvdWGff94GjUrf4zp+UM8+/fh0FtvILFLV2RMv6JJxzAkpyD53JGoXb0KvoryCFeoPGdoa6YzmAqgBMFggOXs3qjbsjmq3SRERC2NWLgOpg4dkZCVdcavEXQ6JHbN0dQ8WWVGZGtjcj5qugaD7E033YTHH38crVu3xssvv4wBAwbghRdeiEVtLZIu0Qxr33w4CtdB9vsjemxx/Vq4d2xHq6nToEts/D6U9gFH2otjsBhVSxIKKUq0jSZktUaH+x6EJbc7St/6N8o//TimQURy1uHASy9Cl5iINjffCp3R2ORjpV44AYIgoOqrLyNYYXxwFRchoW27mH0a3RS2vvmQamrg3r1b6VKIiDTBV1EO986djWorDrHk5sJ78IBmwpjkEKG3R38PWQDQmc2AXs/FnlSgwSALAFu2bMGzzz6Lzp07Iz09HenpZzaPb+HChZgwYQLGjBmD995775TPW7FiBc4///wzq7gFSBo8BJIowrk1cvPNAl4vKj75CKYOHZE07JwmHcPWb0CwvXgD24sjyVVcBEN6OozprRQ5v95qRdvb/4jkkefh8Fdf4uArL8Vk0R45EMCh1/8FX2UF2tx0S5P2zz2WMS0NScPPRc2PP2hqgQvZ74drx3ZY4nR+bIi1dx9Ap0Md24uJiCJC3FAIALANOPO24pCj82S3RbQmJciShEBdXcxGZAVBgN5mD66UTHGtwSD72muv4YMPPsCSJUvgdrvxz3/+Ey+99FKDBy4tLcWzzz6L999/HwsWLMD8+fOxffv2k55XUVGBp556qmnVa5Tl7N7QWSwQ166N2DEPL1sCf1UVMi6f0eB2O6diSEoKthevZ3txpMiyDFdRUczbik8kGAzIvPIqZEyfCcemn1Dy1ONR32+2cuEC1P28BZnTZ57R6tlnItQyf3jJ4ogcLx649+yG7PHE7fzYEL3NBnO3HDg2b1K6FCIiTRDXr4OpU2ckZGQ2+rWJnTpDMBo1MU82FChj2ZWkt9u5arEKNJhovvzyS7z++uswm81ITU3FRx99hEWLGl5QZdWqVRgyZAhSUlJgsVgwbtw4LFmy5KTnPfDAA7j11lubVr1G6YxG2PoNgPjTBgQisLCWv/owqhYvgq3/gGYHJvuAgfCVsr04UrwHDkByiHERUgRBQOoFY9F27p3wlZVi77xH4N69Kyrncmz8CVULFyBp2DlIPi9y3RjG9FZIGjocNd9/B391dcSOq6Tw1ky58T0iCwDWvnnw7ivR5DxlIqJY8pWXw7N7V3BrxiYQDAYkdu2mqSBriNGILAAY7Ha2FqtAg0HWYDAgISEhfDspKQkGg6HBA5eVlSEj4+iquJmZmSg9YWuM//znPzjrrLPQt2/fxtTcIiQNHgLZ40bdlk3NPlbFZ8HtdlpNu6zZxwq3F3P14ohwFSs3P/ZUrL37oP1fHoBgNKDk6ScgFq6P6PG9Bw/g0BuvwdSpMzJnzY74nnBpEyZBDgRweOlXET2uUpxFRUjIbgNDUpLSpTTIlpcPAByVJSJqptDP3qYGWQAw5+TCU7I3rvaMbwrpyDzfmI7I2mwckVWBBhNpdnY2VqxYAUEQ4PV68cYbb6Bt27YNHri+1tNjf2EtLi7GsmXL8Pbbb+PQoUONLDsoPT02k76bIyOjaW86OW0ASt9MhWfTBnQZP7rJ5xe3bUftqpVoO/VitD3rzPfmPKUMOyp7nw3nxkK0mnNVTDamjldNvbbHqty9AwmtWqFNzy7x9XeZ0ROZ/3gaW594CgdffQnGK2ag3aWXNLtGv9OJLf96CbqEBPR+4F6YMqKwb26GHXUjzkXld/9DtysvR0JKcuMPEYFrGwmyJGHHjm3IGHlu3NR0Whl2lLZrC+9vPyNj+lSlqzklVfxdUpPw2mpbS7q++zdtgC0nB216dmnyMYwD81C1cAFMFfuR2r9fBKuLvNNd24piCQDQqkMWrDH6HhAz0+H87dcW9T0XLdH8O2wwyD744IP405/+hKKiIuTl5aFv3774xz/+0eCBs7KyUFhYGL5dVlaGzMyjPf5LlixBeXk5LrnkEvh8PpSVlWHmzJl4//33z7j4ykoHAoH4nauZkWFHeXnTP82x9h+Iwyu+xaE9h6C3WBv9elmWUfLqv6G3JyFx1Lhm1XIsU99+qPm/d7B/428wte8QkWOqTXOvLRC8PtVbfoGlVy9UVMTjggI6ZN1+F/DOW9j73gc4vH03sq6+BjpjQsMvrYccCODAK/+E68BBtPvjPahFIhCh78kTWS+4EOXffY/tH3yCjEZ2IkTi2kaKe/cuSC4X0KFL3NTUkMRefXB4+TIc2lMKvcWidDkniafrS5HFa6ttLen6esvKULdjB1pdenmz/syB9DaAXo9DhZvh75ATwQojq6FrW72/DABQ69PDGaPvAa/eBKmuDmUHD0M4g05Uql9z37c6nXDagctTthY/99xzAIB9+/bhnXfewYYNG7Bu3Tp88MEHaNOmTYMnHjZsGFavXo2qqiq4XC4sW7YMI0aMCD8+d+5cLF26FAsWLMBrr72GzMzMRoXYlsA+aAhkvx+On35q0usdhevh3r4NraZcAr258dvtnIotv3+wvXg924ubw3foICSxFpY4mB97KjpjAlpfdwPSp1wCce1q7Hvmafhrm7aUf9XiRajb+BMypl0OS4+eEa70eAmts2EfOAjV//tW1asOhvePjePvkRPZ8vIBSYLz11+ULoWISJUcR6ZvNaetGAB0JhMSO3aCU+XzZEMtvnpb7DoxQ23MUp16f4doCU4ZZBctWoTS0lL87W9/Q01NDTweD/x+P6qrq1F9BouoZGVl4c4778Ts2bNx8cUXY9KkSejTpw/mzJmDn3/+OZJ/Bs1K7NwZxoxMiGvXNPq1Aa8X5Z/Mh6l9eySdc25E6zIkJcHSoyfEDVy9uDmO7h8b3yFFEASkTyxA9k23wFOyF3vn/Q2efSWNOkbdz1tQueBz2AcPQcqYsVGq9HhpEwsge9w4vHxpTM4XDa7iIhizsmBISVG6lDOW2LUbdDYbHJu4DQ8RUVOIheuR2KVrRLblM+d2h3vXzogsHqoUSRShM5tjOjIaDrJc8CmunfI7Yvjw4TjvvPMAAIMHDz7uMUEQ8Pvvvzd48IKCAhQUFBx33+uvv37S89q1a4dvv/32TOptUQRBgH3wEFR9uRD+mmoYklPO+LWHv14Kf2UlWl9zfZO32zkd24BBKPu/t+Ep2YvEDh0jfvyWwFVcBH1KCoyZjV9WXwn2AQNhbNUK+//5PPY+MQ/ZN94EW5+8Bl/nLS3FwddfhaldO2TNviZmc4FNbdvB1n8Aqr9ZjtSxFzapPV9JciAA17Zi2PoPULqURhF0Otj69IVj0ybIkgRBr1e6JCIi1fCWHoJn7x5kXDYjIscz5+bi8JLFcO/cEfVuqGiRHCL09tgueBjas1bNXV0twSkTzt/+9jf8/vvv6NevH7Zu3Xrcf2cSYiky7IOGALIMcf2Zrxzrr65G1eJFsOb3i9o/WrZ+/QCdDo4Ir2jbUsiyDOeR/WPjapGnBiR26owO9z+EhKwsHHjxeRxetvS0o/IBtxsHXn4REAS0uXkudCZTDKsNjsoGXC5Uf7M8pueNBM++EgScTlW1FYdY++Yh4KyDa/s2pUshIlKV0GrFtgGR+RDT3C0HEAS4thVH5HhKkERHTNuKAY7IqkWDQ3XvvfdeLOqgUzC1aQNT+w4Q160+49dUfP4pZL8fGdMuj1pdBnsSLN17Qixke3FT+EpLIdVUx8X+sY1lTE1F+3vvgy2/H8o/+gBl//cOZL//pOfJsoxDb78J74H9yL7hDzAesx1XrCR26Ahr3zwc/npZcNEkFQnvHxtHWzOdKWuvsyEYDKhjezERUaM4CtchsWs3GNMis6q/3mKFqV07Ve8nKzlqY7r1DnB0Pi634Ilvke85pYizDxoC986d8JaVNfhc957dqF31I1IvGIOErKyo1mUbMBC+slJ4SvZG9Txa5Dyyf6xFhSEFCC4gkX3TLUibMAk136/Avuf+cVL7zeFlS+AoXIdWU6fB2utshSoF0iddhICzDjX/+0axGprCVVQEY6uMiP0yE0u6RDPMPXrCsXkTP+giIjpD3kMH4SkpgX3goIge15zTHa4d2+v90FkN/KIY+yBrPRJkOSIb1xhkVcA+KDhHWVx3+kWfZFlG+fwPoLfZkDbxoqjXxfbipnMVFUGfnAxjVmulS2kyQadDq6nT0PraOXBv34a9TzwK75E9oet++xUVn3wEW/8BSL1wgqJ1JnbuAsvZvXF42VIEPB5FazlTciAA57YimHPV+UEHANj65sNXVgrfoYNKl0JEpArhtuL+zVut+ETm3O6QvV649+6J6HFjQZZlBByO8JzVWBEMBugsVvgZZOMag6wKGNPTYc7JhbhuzWlHNxw/FcJVXIT0i6fGZP9Gthc3jSzLcBVvhSW3u6rmx55K0rDhaHfXnxCoc2Lv44+idtVKHHztFSRktwkuNhYHf8b0SRdBcoioXqGOReW8Bw8g4HCosq04xNq3LwDAsWmTsoUQEamEuH4dzDm5MKamRvS45pxcAFBle3HA7Ybs98d8RBYA9HYbAmwtjmsMsiphHzQE3gMH4N23r97HAz4vKj7+CAlt2yH5nBH1PicabAPZXtxYvvJy+A8fVuX82FMx5+Si/f0PwpCSjENvvg5IEtrccht0iYlKlwYguNiFpedZOLz0K1VsQeBS4f6xJzKmpcPUoSMcmzlPloioIZ4DB+Ddvw+2Zu4dWx9DcjKMrVurMsiGWntjvdhT8Jx2jsjGOQZZlbAPGAjo9ahdW/+iT9XLv4avohyZ02fGdLsLe35/thc3kqsouOp3vO8f21gJGZlo/+cHkHL+aLS5ZS4S4qxtOm3SRZBqa1Hzw3dKl9IgZ3ERDGlpMLRq/h6CSrL2zYN7x3b4xVqlSyEiimuODesBQYA9SluumXNy4dpWDDkQiMrxoyW02JIyI7J2br8T5xhkVUJvt8N6Vi+I69ae9I+Qv6YaVV8uhDUvH5aeZ8W8LkuPnhDXr2N78RlyFhdBb09CQna20qVEnN5iQebMWXG5V52lew+Yc4L76QV8PqXLOSVZluEqCs6PjYe27Oaw9c0HZBl1W7YoXQoRUVwLtRUbUiLbVhxiye2OgMsF7/76O/vi1dER2djuIxs8p52LPcU5BlkVsQ8aAn9VJdw7dhx3f8V/P0PA50PGpdHbbud0bAMGwldexvbiM3A0pOSqPqSoUVrBZPgPH0btyh+ULuWUfIcOQhJrVd1WHGLq2BH6lBTUsb2YiOiUPPv3w3tgf7D7LkpCiwc6Vbaf7NERWQVai+12SA6RAzVxjEFWRWz5+RASElB7zJ6y7r17UPvjD0g9/wLFWjlD7cXi+nWKnF9N/BUV8FdVwqKxtmK1sPQ8C4lduqJq8Zdxuw2BU8X7x55IEATY+uaj7tdfEPDF/9xkIiIliIXrAEGALUptxQBgTG8FQ1q66ubJhkZEDUq0FttsgCQhoLJ96FsSBlkV0SWaYe2TB8f69ZD9/uB2Ox++D53VirSC6G+3cyqh9mIHVy9uUGj/WK3Nj1ULQRCQNuki+KsqUbt6pdLl1Cu4NVMKjJnR3Qc6Vmx5+ZA9nvACVkREdJQsy3AUroc5tzsMySlRPZc5Nxeu4iJV/a4miSIEgwGCKfaLRxrsSeEaKD4xyKpM0uAhkBwinFt/g2PjT3AVF6HV5KnQW6yK1mUfMCjYXqzCPcpiyVVUBL3NjoTsNkqX0mJZe/eBqWMnVC1eBFmSlC7nOLIsw1m8FZbu6p8fG2Lu0QOCycRteIiI6uE9sB/egwdgHzAo6ucy53aHVFsLX2lp1M8VKZLDAb3drsjPRN2RlZIlbsETtxhkVcZydm/oLBbU/PgjKj7+EAlt2iJ5xEily4Itvx/bi8+As3hrcH6sjm89pQiCgPRJF8FXXg5x3RqlyzmOr6wMUnV1eC6TFuiMCbCedTbqNm9U1SgAEVEsiOuPtBX36x/1c1lUuJ+sJNZCb4t9WzFwtJ2ZI7Lxi79Nq4zOaISt3wA4CtfBV16OjMtnxHS7nVPR2+2w9DwLjg1sLz4VX2UF/BUVmto/Vq2seflIaNcelYsWxtVWBK5Q67nGvkeseXnwHz7Mjg0iomPIsgyxcB3M3XvAkJwc9fMZW2dDb7fDpaIFnySHQ7EgG9ryhyOy8YtBVoWSBg8BAFj79IW119kKV3OUfcBA+MrL4dnDX1br4yoKfgLKhZ6UFxyVLYCv9FBwkY04odWtmay9+wKCgLrNm5QuhYgobnj3lcB36BDsA6PfVgwEf/aZc7vDuU1NI7KiInvIAggHaEnkXrLxikFWhczde6DVpZcj88qrlC7lOLbQ6sVxFAziibN4K3RWKxLatlW6FAJg6zcACW3aoCqORmW1ujWTISkJiV26wrGJ2/AQEYWI69cBOl1M2opDzDnd4a+ogK+yMmbnbA7JoVyQFUwmCEYjJEetIuenhjHIqpCg0yFt3HgY09KULuU4epst2F7M1Yvr5SoqgjmH82PjhaDTIW1iAbwH9sOxcYPS5cBXUQ5/VaVmV7S25eXDs3cPfFVVSpdCRKS4YFvxelh69AyvjhsL5twj82RVMCor+/0IuFzBbXAUIAgC9DY758jGMf5GTRFlHzAQvgq2F5/IV1UFX3kZ24rjjH3gYBizsoKjsgp/+OIMtZ5raKGnY1n75gMA6rZsUrYQIqI44CnZC19ZaUxWKz6WqV176MxmuIrjf55saG6qUiOyoXNLDrYWxysGWYooW35/QK9ne/EJXNw/Ni4JOh3SJhTAU7JX8fmbruKiYOt5G222nidkZ8OYkclteIiIoExbMRD8uWfulqOKlYtDc1OVWuwJOBJkOSIbtxhkKaL0NhssPXqyvfgEruIi6MxmmNq1V7oUOkHS4CEwtspA5aIvFP2edRVvhTm3u2ZbzwVBgDUvH66tvyHgditdDhGRYmRZhqNwHSw9z1Kkbdac2x3eQwfhr43vuZ9xMSJrs3HV4jimzd+YSFH2gYOOtBfvVrqUuOEs0nZIUTPBYEDqhInw7N4F568/K1JDsPW8XLNtxSG2vnmQ/X7U/fqL0qUQESnGs2cPfOXlMVut+EShvcrjfRsevxgM2oq3FnNENm7xt2qKOFtevyPtxeuVLiUu+Kur4SstDf/goPiTPOwcGNLSULlQmVHZltJ6bu6WA53FongbNxGRksTCdYBeH/x9SQGJHTtBSEiI+wWfQnNTFW0tttkRcLsR8PkUq4FOjUGWIi60erFYuI7txQhuuwNw/9h4JhgMSBs/Ee4d21Hzc+xHC1tK67lgMMDauw/qtmyOmy2PiIhiKbha8TpYevZSbjVegwGJXbrG/YJPkigCggC91apYDaHRYC74FJ8YZCkq7AMGwl9RwfZiAK6ircGQ0r6D0qXQaSSdcy70ySkomf9xzM/tbEFbM9n65kNyiHDv2KF0KUREMefZvQv+igrYBw5UtA5Lbnd4SvZCcjoVreN0JIcIncUCQa9XrIbQaLAkxvd84pbKoHQBpE22vH4o1b8Dcf06JHbqrHQ5inIVFcHcLUfRf4ipYTpjAtLGT0D5h+/D9O1ypJ5/QUzOG2w9P4TkESNjcj6lWc7uDej1cGzeCHNOjtLlEFEck2UZAacTUm0NHLVGuMqqIfv9kH0+yH4fAj7fka+P3OfzQ/Yfuc/nQ8B/5L4jzz/2uYFjvhb0eiQNPwcpI0dBl5gY1T+T0m3FIeacXECW4dq+DbY+fRWt5VQkUVR0fizAEdl4xyBLURFuL96wHq2mXQZBEJQuSRH+mmp4Dx1E0jnnKl0KnYHkkaMg7dyG8vffhVRdjfQpl0T9eze0BYLWF3oK0VsssOR2R93mTciYdpnS5RCRAmRJgr+2FlJNDfw11fDXVB/5uuaYr4P/l/3+xp9Ar4dgMEIwGqAzGiEYDBCMxiP3Bf/Tm0wQjEboDAb4q6tR8fF8VH25CCmjL0Dq6DFRafuVZRni+vWw9jpb0XZZAEjs0hXQ6+HaVhzXQdZgT1K0hqMjslzwKR4xyFLU2AcMQunbb8CzexcSO3dRuhxFhOafmHM5P1YNdEYjevz5Hvz63MuoWrwI/upqZM2+GoIhev9UOouLoEtMhKlDx6idI95Y++aj/MP34C09hISs1kqXQ0QREvB44K8+Ekxra+CvPj6Y+mtqINXUBLczqWcNDZ3NBkNyCgxJyTDndg9/rU9OQkpGKkSnLxxEBUMopB69HX6sCdM0XDt3ouqrRahauACHly1B8ojzkDr2QhhTUyPxVwMAcO/aCX9VJVpdPDVix2wqncmExE6d43o/WcnhgDEzU9EaDHYG2XjGIEtRY8vLR+mR1YtbapB1Fm+FYEpEYseWE1LUTtDrkTnrKhhSU1G54HP4a2vR5qabo9Zu5ireisQW1npu65uH8g/fQ93mTUgYe6HS5RBpmq+qEu7t2+F3iIBfgixJkCU/ZEkCpNDt4H8IHPP1sY/5Q7f9xzw3ED4W/BL8ogjZU88e0Xr9kTCaDGN6OsxdukKfnAxDcjIMySnQJ6fAkJIMQ1LyaT80TM+wI1AevTBh7tIFbW+ZC8/+/aha8iWqv/ka1d8uR9Kw4Ui7cCISsrKafQ7H+nXBRe/y8ppfcASYc3Jx+OulCHg80JlMSpdzEkmshblrV0Vr0FmtgCBwL9k4xSBLURNsL+4FsXBdi20vdhVthTmnZYUULRAEAekFk2FITkHp/72NkmeeQtu5d8KQFNkWJ79YC++BA0gaMiyix413xowMJLRtB8fmTUhlkCWKGFmW4T14AK5txeH//JWVp36BIAR/PukNEPT64H8GfbA195j/oDdA0OmCt41G6BITjzxmCD9Xb7cdCawpMKSkwJAcDK96q01VC9mZ2rZF9nU3oNXkKaha+hVqf/getT/+APuAgUibMKnJCzfKgQDEDeth6XU29BZl24pDzLndcXjJYrh37YSlR0+lyzmOHAhAcjgU3XoHAASdDnqrjSOycYpBlqLKPnAgSt/aAveuXTB3aVmjsi01pGhJ8oiR0Ccl4eBrr6DkyXloe8ddSIhgm1OopUvr+8fWx9Y3D1VLFh/5RUWZLSiI1E72++Heu+docN2+DYHQ3ptJSTDn5MI85kKYc3JgSEsLh09Brwd0OlUFzFgztspA1hWzkT7pIhz+ehlqVnwLcf06WHv3QdqEgkYvVhdsK65CqynTolRx45m75QCCAFdxUdwF2YDLBQQCigdZIDgwwxHZ+MQgS1EVXL34bTg2rGtxQbYlhxQtseXlo91df8L+F55FyROPoe3tf0Rip04RObarqAhCQgISO0bmeGpizctH1eJFqPtlCz/sITpDAbcbrp07wsHVvXMHZK8XAGDMzIKtb34wvObkwJiZ1SI7oSLNkJyCjGmXIW3CRFR/+w2ql3+NkqfmwZyTi7SJk2Dp1fuM/p7FcFtxfgyqPjN6iwWmdu3hLC5CutLFnCA0Aqr0qsWhGjgiG58YZCmq9FYrrGf1gli4Hq2mXd6ifqi6ira22JCiNeau3dDhz/dj33P/QMnfn0CbP9wK69m9m31cZ3ERzF1zorqYVLxK7NQZ+qQkODZtYpAlOgV/bS1c27eFg6tn7x4gEAAEAab2HZB87shwcDUkpyhdrqbpLVakT7oIqWPGoeaH73F42VfY/9z/g6lDR6RNmAhbvwGnHOGWAwE4NqyH5eze0JvNMa789My53VHzw3eQ/f64+lkUGgHV25Xv2NHb7fAeOqh0GVSP+PmOJc2yDRiIuhbYXuwM7R8bRz8YqOkSstugw18ewP7n/x/2v/gcWl99LZKGDm/y8SSHA959JbDHweqVShB0Olj75MGxYX3c/QJFpARZluGrKIeruBiu7cHg6jt0CAAgGAxI7NIVaeMnwpyTi8Su3eIuELUUOpMJqReMQcp5o1C7ZjWqlnyJg6++DGNWa6SNn4CkIcNO+vfMvWMH/IcPo1Ucbjlmzs1F9Tdfw71nN8xduyldTlh4RNam7PY7wRrskMRtSpdB9eBvDhR14fbiwpbTXiyJIrz798E+cJDSpVAEGVJS0e6ev+DAyy/i0Buvw19dg9QLxzep08C17UjreQvZP7Y+trx81P74PZzFRbCe1UvpcoiaTA4EIHu9CHjcCHi8kD1uBNweBLweBNxuyF5P/bc9bsie4Os8B/ZDqq4GAOgsFpi75SB5+Lkw5+TC1LETdEajsn9IOo5gMCD5nHORNGw4HBs3oOrLRSh9+01ULvgvUsddiORzR4ZXAhYLg23Ftr55yhZdD3NO8GeQq7g4PoNsvLQW1zkgBwKcVx5nGGQp6o5rL760ZbQXO7cF94+1dI+vxROo+fQWC9re/keUvvVvVHz6EfzVh5Fx+YxG/3BzFhVBMBpb7NZUAGDpeRYEoxF1mzYyyFJckQMB+A8fhvfQQXgPHoT30EH4qw+HQ2fA44Hs8Rz9+sg81TMlJCRAZzJBZ0qEYDJBZ0qAJbf7kTbhXCS0actfmFVC0Olg7z8Qtn4D4PztV1R9uRDlH76PykVfIHX0GKSMGg2xcD2svftClxh/o+iGpCQktM4Ofrg6foLS5YSFW4vjYDFAvc0GBAIIOJ1xUQ8dxSBLMWEbMAh1P/8b7l07Ye6i7J5gseAqPjI/tnNnpUuhKNAZjWh9/Y0wJKfg8NdL4a+pRuvr5kBnTDjjY7iKi5DYtVuLHmXRmUywnNULjs0bkTHjihbxIRfFl4DXC1/poXBYDf53CN5DB48LpzqLBYbUNOgSE6FLTIQhOQWCKQE6UyJ0JlMwjCYmQpdggi7RBCGhvtum4HMTTAypGiQIAqy9zoa119lwbd+GqsWLULngc1R9uRCy3w/bwIFKl3hK5tzuENevjasRR0kUwx/4KC00Kiw5RAbZOMMgSzFhy89H6X/0cBSubxlBtmgrzF27cd6fhgk6HTIunwF9SgoqPp6P/bW1aHPr3DPaH1By1sFTshfpBZNjUGl8s/bNQ93mTfDu3wdTu/ZKl0MaJMsypNqaY8LqoXBo9VdWArIcfKIgwJjeCsbW2Uju3gMJrbOR0Lo1ElpnQ5+UxA9a6IyZu+Wg7dw74SkpQdVXX8J7cD9sffKULuuUzDm5qPl+BTz7SpDYoaPS5QBAXOwhG6K3B+fpSqIItM5WuBo6Fn/LppjQW6yw9jq7RbQXS3V18Ozbh/SLLla6FIqBtHHjYUhJwaE3/42Sp55A2zvugjE19bSvcW3bBshyi54fG2Lrk4cyAI5NGxlkqVkCPh88Bw7AV3rw+BHWgweDe1IeISQkIKF1NsxduyFh+LlHAms2jFlZ0CWceVcFUUNM7dsj+4ablC6jQaGfRa5txXETZP2iGBfzY4Gj7c3cSzb+MMhSzNj6D0Tdls2aby92bSsOhhTuH9tiJA0eCr09CQdeehElTzyKtnfcDVObNqd8vqt4a3gV0pbOkJKCxM5dULd5E9InXaR0OaQysizDvX0bqpYsxrZffoYsSeHHDKmpSGidDfuQoeGwmpCdDUNKaty0TxLFA2N6Ogzp6XAVFyF19BilywFwpI03XoLskTr83Es27jDIUsyE24vXr9N0kHUWbT2yiA/nx7Yk1rN6of29f8H+5/6Bkifnoe1td8Cck1Pvc51FRUjs3IWjP0dY++ah8r+fwV9Tzb0w6YzIgQAcmzbi8JLFcO/cAZ3NhuyCiQikt0ZCdjaMWa25PQ1RI5hzu8P5yy+QZTkuuuYkh4iE1q2VLgMAwi3OEoNs3OFHkhQz4fbiDeshh+YkaZCraCsSu3Rt1MI/pA2JHTqiw18ehN5uw77/9zQcGzec9JyA2wXP3j0wd2dbcYitbz4AoG7z5qieJ+DzIeD3R/UcFF0BnxfV36/A7gfvw8GXX4RUW4vMK2ahy1P/QOdrrkLS0GFI7NSZIZaokSw53SGJtfCVHlK6FADB0Biam6o0XUICBJMJksOhdCl0Ao7IUkzZBwwKthfv3BFX+5VFSmgRnzS2SLZYxowMdPjzA9j/4rM48PI/kXnFLKScd374cdf2bUAgAHMuW89DEtq1gyE9HY7NG5E8YmSzjhVwu+ErL4O3rBS+sqP/95WVwV99GNsRnO+kT0qGITkZhuQU6JODX+uTk2FISoYhJQX6pGTozOa4GJmg4NoDNd/9D4eXL4NUWwtTx07IvvFm2Pr1h6DXK10ekeqF5sk6i4uQoPCCRgGvF7LHE1crBOvtdkhirdJl0AkYZCmmrHl5EAyG4OrFGgyyoUV8LJwf26Lp7Xa0u+teHPzXyyh79z/wV1cjffIUCIIAZ1ERoNdr8vu/qQRBgK1vPmp++A4Bj6fB7RYkZ90JIbUU3rIy+MrLINXUHPdcvT0JxsxMWHr0DP7fkoDaA2Xw11RDqq2B89AhSLU1kOsZqRUSEmBISj456B4XflNgsNu5QnmU+KoqUf31MlR//x1kjxuWXmcj7cIJMPfoyQ8ZiCLImJUFvT0Jrm3FSBlxnqK1hPeQjZM5skCwvZgjsvGHP3kppvQWKyxn9YK44cjqxRpbcIOL+FCIzmRCm1vmovT/3kbVoi/gr65G1qyrgvvHduocF3vjxRNr3zxUf7sczt9/g7VvHiSHeHxILSuDrzz4deCEXyYMqakwZmTC2rsvEjIzYczMgjEzE8aMzJNaTDMy7CgvP36ekyzLCDidwXBbUwN/TTX8NTWQamvgrw7+33voIPxFWxGoqzu5eEEIjvImp8CS2x32wUOQ2KUrg1YzePaV4PDSJahdtwaQZdgHDkbaheNhat9B6dKINEkQBJhzc+EqLlK6lPBcVEO8BVmOyMYdBlmKOfvgIajbshni2tVIGjpc6XIiiov40LEEvR5ZV10LQ0pqOMy6d+9C6tgLlS4t7li694AuMRGlb78JWfIft10KBAGG9HQkZGTB3n8AjJlZRwNrq4xmfyggCAL0Viv0VivQpu1pnxvw+SDV1gaDbk01/LU14fDrq6xEzfcrUP3tchhbZcA+aDDsg4fC1Pb0x6QgWZbhKtqKqiVfwfnLFggJCUgZdT5Sx4yDMb2V0uURaZ45tzscGwrhq6xQ9D0XGvmMl31kgWCo9h7Yr3QZdAIGWYo5+8DBqP72G5R98D4sZ/XSzCqlkssFz57dSJtYoHQpFEcEQUCri6fCkJqKsnf/c6T1nAs9nUgwGJBWMBnO3387blQ1ITMLhvRW0BmNSpcIANAZjdClp8OYnl7v45LTCcfGnyCuW4Oqr75E1eJFSGjbDkmDh8A+aDCMrTJiXHH8kwMBOH7agKoli+HZvQt6ux3pF09Fynnnx9UcOSKts4T2ky0uhnGogkH2yMhnfLUW27iPbBxikKWYE3Q6tL76Wuz5219R9u7/IfvmWzXRgufezvmxdGopI0fBkJyC2jWrYM5hkK1P2rjxSBs3XukymkVvsSB5+DlIHn4O/DU1EDesh7h2DSo++wQVn32CxK7dkDR4CGwDBsGQFB8rciol4PWidtWPOLxsKXxlpTBmZiHzytlIGnYOu1qIFJDQth10Fgtc24qQNHSYYnXE44is3m6H7PWe0ToOFDsMsqSIhOw2SJ88BRWffgxH4XrYBw5SuqRmcxZtBfR6zo+lU7Ll5cOWl690GRQjhuRkpJ5/AVLPvwC+8nKI69eidu0alL3/Lso+fB+WnmchafBQWPP7tajtYiSHA9UrvkX1N19DEkWYOnVG9h9ugS2/v+bWTSBSE0Gng7lbDpwKz5OVRBHQ6aCzWBSt41jhvWQdDgbZOMIgS4pJHXshxA2FKHvv/2Du0QOGONkvrKlcxVuD82P5DxwRncCYkYG0CZOQNmESPPv3QVy7BrXr1uDQm69DMBph7dMX9kFDYO3TR7N7UPsqK3D466Wo+eF7yB4PrL37IPXCCTDndtdEVw6RFphzuqNuy2b4a2sV6xqRRBF6qy2uPtgKtTlLonjKqSUUewyypBhBr0fra67DnkceQvkH7yH7hj8oXVKTBdxuuHfvRtqFE5QuhYjinKltO5imTkP6lEvg3rkD4to1ENevg2NDIXRmM2z9BsA+aDAsPXqqfo9UORCA87dfUfP9Cjg2bQQEAUmDhiB13IUwtWuvdHlEdAJzbi4AwLWtCPb+AxWpQXKI0Nvja358OMg6uHJxPIlqkF24cCFeeeUV+Hw+XH311bjiiiuOe3z58uV48cUXIcsy2rVrhyeeeALJycnRLInijKltO6RPugiVCz6HfeAg2PL7K11Sk7i2bwMCAZg5P5aIzpAgCDB37QZz127IuHwGnFt/h7h2DRw/FaJ25Q/QJyXBPmCQKrfz8VdXo2blD6j54Tv4Kyqgt9mROmYsUkaPgTGNoxlE8SqxYycICQlwFRcrF2RFMa7mxwLHtBaL3Es2nkQtyJaWluLZZ5/FZ599hoSEBEyfPh2DBw9Gt27dAAAOhwMPP/wwPv30U2RlZeH555/Hiy++iAceeCBaJVGcShs/EY6fNqD0/96BOae7KlepdBUXAXo9zN1ylC6FiFRI0Oth7XU2rL3ORsA3G3VbtkBct+ak7Xxs+f1g6tgprlruQoKjr7+g5rvv4Ni8MfjhXo+eyJh6Kaz5/eJm5WkiOjXBYIC5azdF95OVRBEJcbZt2bGtxRQ/ohZkV61ahSFDhiAlJQUAMG7cOCxZsgS33norAMDn8+Hhhx9GVlYWAKB79+5YuHBhtMqhOCYYDMi65jrsnfcIyud/gNbXzVG6pEZzFm1FYsdOnB9LRM2mMybA3n8A7P0H1Ludjz4pCdaz+8Daty8sZ52t+EJR/urDqPnxyOhrZeWR0ddxSD53JBJat1a0NiJqPHNud1R+8V9IzjroLdaYn19yOOJuRFZnNgM6HbfgiTNRC7JlZWXIyDi6X15mZia2bNkSvp2amooLLrgAAOB2u/Haa69h1qxZ0SqH4lxih45IGz8BVYsWwjZwIGx98pQu6YwFPB64d+9C6tgLlS6FiDTm2O18JFFE3S8/o+7nzXBs+gm1q34MdoLk5MLWpy+sffJiFhzlQADOX39B9fcrULd509HR12mXw5qXz9FXIhUz5+QCsgzX9m0x/31MDgQg1Tniag9ZILiiM/eSjT9RC7KyLJ90X33ze0RRxM0334wePXpgypQpjTpHenr8t6BmZMTXGzGepV99BTZv2YSK9/6D9kP6wWCN/aeAjRG6ttWbdgKShOxB+Ujl9dYEvm+1TbXXN8MOdGkDXDQOsiShdutWHC78CYcLN6D8ow9R/tGHSMxujdQB/ZE2oD+Sep0V8UDpqaxC2TffovTr5fCUlcOYnIS2F1+ErDGjYW7TJqLnagrVXls6I7y+sSEl9cV+gwHCvt3IGH1uTM4Zura+2lpAlpHculXcXe99qSnQe1xxV1e8i+bfV9SCbFZWFgoLC8O3y8rKkJmZedxzysrKcN1112HIkCG47777Gn2OykoHAoGTA3O8yMiwo7ycn9w0RqtZ12Dv44/i91f+jdZXXat0Oad07LWtWLcR0OngzWjL660BfN9qm6aub2YHWCd0gHXCxfBVlKPu5y1wbN6MQ0uW4eDCLyGYEmE9qxesffrA2rsvDEem+jSWHAig7pefUfP9CtRt2QwEArD0PAvZUy+FLa8fBIMBDgAOhf9eNXVt6SS8vrFl6tgJlZt/gTUGf+fHXlvPgYMAAJeQEHfXW060wFVVHXd1xbPmvm91OuG0A5dRC7LDhg3Diy++iKqqKpjNZixbtgyPPvpo+HFJknDTTTdh/PjxuPnmm6NVBqlMYucuSB03HoeXLIZ9wCBYe52tdEkNchUXBefHJio7T42IWi5jqwykjBqNlFGjEfB44Nz6O+q2bA62IW/cAAAwdegIa988WHv3RWKnhheM8h0+jNofvw/Ofa2qgt6ehNSxFwbnvh5Z34KItMmc2x2Hly1BwOOJ6fofodbdeGstBoI1efaVKF0GHSOqI7J33nknZs+eDZ/Ph2nTpqFPnz6YM2cO5s6di0OHDuG3336DJElYunQpAODss8/GvHnzolUSqUT6RRfDseknlP7nLXT622NxHRADHg/cu3YiZfQYpUshIgIA6Ewm2PrmwdY3D7Isw7tvXzDQbtmMqkVfoGrhAujtSbD27g1rnzxYzuoFvcUCIDT6ugU1338XnPsqy7D07IWMy2bAlpcPwcDt54laAktudxz+6ku4d+6ApedZMTtvaFXgeNzBQm+zc9XiOBPVn0gFBQUoKCg47r7XX38dANC7d29s3bo1mqcnldIlJKD11deh5KnHUf7px8i6YrbSJZ2Se+cOyH4/948lorgkCAJM7dvD1L490iZMguRwoO6XLajbsgWOTZtQu2pleMEoU7v2cPxUeHT09cIJwdHXE6YFEZH2JXbtBggCnMVFsQ2y4RHZpJid80zp7XYEnE7IkgRBr1e6HEKUgyxRU5m75SBl9BhUL18G+4BBsMRpUHQWFwGCEFzhj4gozultNiQNGYakIcMgSxLcO3fAsXkT6n7egupvvoal51nIuHwGbH05+krUkuktFpjad4BrW3FMzxvXI7J2OyDLkOrqYEiKv6DdEvGnFMWtVlMuQd3mjSh9+010fPjRuNyj1VW0FaYOHRXfx5GIqLGEIyOx5pxcZEy7DLLfz/BKRGHm3FzUfP9dTP9tkBwidImJcbmFVyhcSw6RQTZOnH6lByIF6UwmZF11LXzlZaj4/FOlyzlJwOcNzh2J09FiIqLGYIglomOZc7pD9nrh3rM7ZueURDEuF3oCAMORdmfOk40fDLIU1yw9eiJ51Pmo/uZruLZvU7qc47h37gzOj83trnQpRERERBFlzg1Om3IVF8XsnJLDAb0tPoNseESWQTZuMMhS3Mu45FIY0tJw6O03EPB6lS4nzFW0NTg/NpfzY4mIiEhbDPYkJGS3gbModouzxvOIbKiu0IJUpDwGWYp7ukQzsmZfA9+hQ6j84r9KlxPmLC6CqX0H6C1WpUshIiIiijhr3zw4f/0F3tJDMTmf5BDjcqEnAOGRYo7Ixg8GWVIFa6+zkXTOCBxe+hXcu3YqXQ4CPh/cO7azrZiIiIg0K3XMWAh6Paq++jLq55JlOa5HZAWDATqzGZLDoXQpdASDLKlGxmXTYUhJwaG33kDA51O0FrF4G2SfD5buDLJERESkTYbkFCSPGIna1avgq6yM6rlkjweyzwe9LX5XBNbb7ByRjSMMsqQaeosFmbOugvfAflR9uVDRWmp//e3I/rEMskRERKRdqeMmAACqliyO6nlCc0/19vhsLQaCtTHIxg8GWVIVW5882IcOQ9VXX8K9d49iddT8/AsS2raL23kcRERERJFgTE9H0tDhqP3hO/irq6N2nlBAjNdVi4EjI7Jc7CluMMiS6mRePhN6mw2lb70B2e+P+fllvx/i1iJYOD+WiIiIWoC08RMhSxIOf70kaucIzT2N1zmyAKC3JzHIxhEGWVIdvc2GrCtnw1OyN+ptLvVx796FgNcLc/ceMT83ERERUawlZGXBPmgIqlf8L2qtteoYkQ22FsuyrHQpBAZZUilbfn/YBw5C5cIF8OzfF7Pz+sVa1Hz/HQBwRJaIiIhajLQJkyB7PDj8zbKoHN8v1gKI9xFZO2S/H7LHrXQpBAZZUrGMmVdCb7bg0FtvQJakqJ0n4PGgdu1q7H/+/2HnXXegdtWPSB8+NK7/oSUiIiKKJFPbtrD164/qb5ZDcjojfnzJ4QD0eujM5ogfO1JCv/v5ueBTXDAoXQBRUxnsSciceSUOvvYKDi9birTxEyJ2bFmS4PztV9SuWQ3Hpp8gezwwpKUhdeyFSBoyFO3yz0J5Of8RIyIiopYjbWIBHD9tQPX/vkH6xIKIHlsSRehtdgiCENHjRlKo7VkSHUBGpsLVEIMsqZpt4CDY1q9D5YLPYMvLQ0J2myYfS5ZluHfugLh2NcT16yCJInQWK5IGD4V9yFCYu+VA0LGJgYiIiFqmxI6dYDm7Dw5/vRSpF4yFzmSK2LElhxj33W6h+iRHrcKVEMAgSyonCAIyr5yF3Q9uxaG330T7e+9rdNj0HjqI2jWrIa5dA195GQSjEda+eUgaPBSWs3tDZzRGqXoiIiIidUmfVICSJ+eh5rsVSB07LmLHDY7Ixve2hkdHZNmVFw8YZEn1DMkpyJwxE4feeB3V33yN1DEN/6Pqr66GuG4tateuhmfPbkAQYOlxFtImFcDWbwD0cTw/g4iIiEgp5m45MPfoiaqlXyF51CjojAkROa7kEJHYoWNEjhUtR0dkHQpXQgCDLGmEfcgwiOvXoeLzT2Htm4+EzJPnLUguFxw/FUJcswbOrb8BsgxTx07IuGwG7IMGw5CSEvvCiYiIiFQmfWIB9v3jadT++CNSRp0fkWNKogO6ON56BwB0iYkQDAaOyMYJBlnShGCL8VXY89D9KH37DbS7+14IOh1kvx91P29B7drVqNu8CbLPB2NGBtImFiBp8JBmzaklIiIiaonMPXoisUtXVC35EsnnjoBgaF6kkP1+BJx1MMT5HFlBEKCz2SA5GGTjAYMsaYYxLQ0Zl01H6TtvoeLTjxFwuSAWrkfAWQe9zY6kc0YgachQJHbpGtcr4hERERHFM0EQkDapAAdeeA61a1cjefi5zTqeVBds1Y33xZ4AwGC3c0Q2TjDIkqYknTMC4vp1OLz0KwgJCbDl94N98FBYz+rV7E8LiYiIiCjI2rsvTO07oGrxIiQNHd6snR1Cc071cd5aDARrZJCND/zNnjRFEARk3/AHuLYVw9LzLOgSE5UuiYiIiEhzBEFA2sQCHHz1JTgK18M+aHCTjxUKhmoYkdXb7fBVVipdBgHgppikOXqbDbb8fgyxRERERFFk69cfCdltUPnlQsiBQJOPE5pzGu/b7wChEVnuIxsPGGSJiIiIiKjRBJ0OaRMmwbt/H+o2b2rycdQ2IhtwuSD7/UqX0uIxyBIRERERUZPYBw2GMSMjOCory006RjjIWtUxIgtwL9l4wCBLRERERERNIuj1SB0/EZ7du+D87dcmHUNyiNBZLKpYmFNvD4ZtLvikPAZZIiIiIiJqsqShw2FITUPVoi+a9HpJFFXRVgwcOyLLIKs0BlkiIiIiImoyndGI1HHj4dpWDGdxUaNfLzkcqth6BwD09iQAHJGNBwyyRERERETULMnnjoDenoSqLxc2+rV+VY3IBluL/RyRVRyDLBERERERNYvOZELq2Avh/PUXuHftbNRrJVFUz4isjXNk4wWDLBERERERNVvKqFHQWayobMSorCzLkByiKvaQBYKLW+ksVs6RjQMMskRERERE1Gy6RDNSLxiDuk0b4SkpOaPXSE4nIEmqaS0GgnvJSiK331EagywREREREUVEyvkXQJeYiKrFZzYq66utBQAYjiyipAZ6u50jsnGAQZaIiIiIiCJCb7Mh+bzzIRauh/fQwQaf768NBkKdSlqLgeCfkXNklccgS0REREREEZM69kIIRiOqFn/Z4HN9NTUAAIPaWos5Iqs4BlkiIiIiIooYQ1ISkkeMRO2aVfBVlJ/2ub4jI7JqWbUYCNYqORyQZVnpUlo0BlkiIiIiIoqo1LHjAUFA1ZKvTvu80BxZNS32ZLDbAUlCwOVUupQWjUGWiIiIiIgiypiWhuTh56L2x+/hrz58yuf5amogGI0QTKYYVtc8odDNebLKYpAlIiIiIqKISx0/AXIggKqlS075HH+tCL3NDkEQYlhZ84TaoBlklcUgS0REREREEZeQkQn74CGo+e5/8Iu19T7HV1urqrZi4JgRWQf3klUSgywREREREUVF2vhJkH0+VH+9rN7HfbW10Kto6x3g2Nbi+sM5xQaDLBERERERRYWpTRvY+g9A9f++geSsO+lxvxpHZG0ckY0HDLJERERERBQ1aRMmIeByofrbb056zFejviCrM5kgJCRwjqzCGGSJiIiIiChqEjt0hLVPXxz+eikCbnf4/oDPB8nlUtUesiF6m41BVmEMskREREREFFVpEwsQqKtD9Xf/C98Xas1V24gsEGwvlhwMskpikCUiIiIioqgyd+0GS8+zcHjZEgS8XgBA4EgQVOWIrN0OP0dkFcUgS0REREREUZc2sQBSTQ1qf/weAMJBkCOy1BQMskREREREFHXm7j2Q2C0HVUsWQ/b7w3NM1ToiK4lctVhJDLJERERERBR1giAgfVIB/FVVqF2zKjyiqberax9ZILjYk+xxI+DzKl1Ki8UgS0REREREMWHp1Rumjp1QtfhLSDU1gCBAb1VhkLUnAQBHZRUU1SC7cOFCTJgwAWPGjMF777130uO///47LrnkEowbNw73338//H5/NMshIiIiIiIFCYKAtIkF8JWVombljzDY7RB06htbC83r5TxZ5UTtu6a0tBTPPvss3n//fSxYsADz58/H9u3bj3vOPffcgwcffBBLly6FLMv46KOPolUOERERERHFAVtePhLatIVUUw1jkvrmxwLB1mIA3EtWQYZoHXjVqlUYMmQIUlJSAADjxo3DkiVLcOuttwIA9u/fD7fbjby8PADA1KlT8cILL2DmzJnRKomIiIiIiBQm6HRImzgJh17/F4xJSUqX0ySGIyOydb/8jIDbpXA1TWNIToG5W47SZTRZ1IJsWVkZMjIywrczMzOxZcuWUz6ekZGB0tLSRp0jPT3+++kzMtT5KRM1jNdWu3httY3XV7t4bbWN11dbWo0fjZolXyIxO1uV19ZvbY89RiOqv16K6q+XKl1Okwh6PQa9+zYMFkvUzhHNaxu1ICvL8kn3CYJwxo+ficpKBwKBk48TLzIy7CgvZ7uBFvHaahevrbbx+moXr6228fpqU9t770dG61TVXtvOT/xd1XNk9TYbDtdJQF10/gzNfd/qdMJpBy6jFmSzsrJQWFgYvl1WVobMzMzjHq+oqAjfLi8vP+5xIiIiIiLSLl2iGTqjEYBb6VKaxJCSAsORaZQUe1Fb7GnYsGFYvXo1qqqq4HK5sGzZMowYMSL8eNu2bWEymbBhwwYAwH//+9/jHiciIiIiIiKqT9SCbFZWFu68807Mnj0bF198MSZNmoQ+ffpgzpw5+PnnnwEAzzzzDJ544gmMHz8eLpcLs2fPjlY5REREREREpBGCXN9kVZXgHFlSCq+tdvHaahuvr3bx2mobr6928dpqV7TnyKpv92EiIiIiIiJq0RhkiYiIiIiISFUYZImIiIiIiEhVGGSJiIiIiIhIVRhkiYiIiIiISFUYZImIiIiIiEhVGGSJiIiIiIhIVRhkiYiIiIiISFUMShfQHDqdoHQJDVJDjdQ0vLbaxWurbby+2sVrq228vtrFa6tdzbm2Db1WkGVZbvLRiYiIiIiIiGKMrcVERERERESkKgyyREREREREpCoMskRERERERKQqDLJERERERESkKgyyREREREREpCoMskRERERERKQqDLJERERERESkKgyyREREREREpCoMskRERERERKQqDLJRsHDhQkyYMAFjxozBe++9p3Q5FGGzZ8/GxIkTMXnyZEyePBmbN29WuiRqJofDgUmTJmHfvn0AgFWrVqGgoABjx47Fs88+q3B11BwnXtu//OUvGDt2bPj9+/XXXytcITXFP//5T0ycOBETJ07E008/DYDvWy2p7/ryvasNzz//PCZMmICJEyfirbfeAsD3rpbUd32j+t6VKaIOHTokjxo1Sj58+LBcV1cnFxQUyNu2bVO6LIqQQCAgDx8+XPb5fEqXQhGyadMmedKkSXKvXr3kkpIS2eVyySNHjpT37t0r+3w++dprr5VXrFihdJnUBCdeW1mW5UmTJsmlpaUKV0bNsXLlSvnyyy+XPR6P7PV65dmzZ8sLFy7k+1Yj6ru+y5Yt43tXA9auXStPnz5d9vl8ssvlkkeNGiX//vvvfO9qRH3Xd8eOHVF973JENsJWrVqFIUOGICUlBRaLBePGjcOSJUuULosiZOfOnRAEAXPmzMFFF12Ed999V+mSqJk++ugjPPTQQ8jMzAQAbNmyBR07dkT79u1hMBhQUFDA97BKnXhtnU4nDhw4gAcffBAFBQV44YUXEAgEFK6SGisjIwN//vOfkZCQAKPRiK5du2L37t1832pEfdf3wIEDfO9qwKBBg/Cf//wHBoMBlZWVkCQJtbW1fO9qRH3X12QyRfW9yyAbYWVlZcjIyAjfzszMRGlpqYIVUSTV1tZi6NCheOmll/D222/jww8/xMqVK5Uui5ph3rx5GDBgQPg238PaceK1raysxJAhQ/D444/jo48+QmFhIT755BMFK6SmyMnJQV5eHgBg9+7dWLx4MQRB4PtWI+q7vueeey7fuxphNBrxwgsvYOLEiRg6dCh/5mrMiddXkqSovncZZCNMluWT7hMEQYFKKBry8/Px9NNPw2KxIC0tDdOmTcN3332ndFkUQXwPa1f79u3x0ksvIT09HWazGbNmzeL7V8W2bduGa6+9Fvfeey86dOhw0uN836rbsde3S5cufO9qyNy5c7F69WocPHgQu3fvPulxvnfV7djru3r16qi+dxlkIywrKwsVFRXh22VlZeG2NlK/wsJCrF69OnxblmUYDAYFK6JI43tYu4qKirB06dLwbb5/1WvDhg24+uqrcdddd2HKlCl832rMideX711t2LFjB37//XcAgNlsxtixY7F27Vq+dzWivuu7ePHiqL53GWQjbNiwYVi9ejWqqqrgcrmwbNkyjBgxQumyKEJEUcTTTz8Nj8cDh8OBzz//HGPGjFG6LIqgvn37YteuXdizZw8kScKiRYv4HtYIWZbx+OOPo6amBj6fD/Pnz+f7V4UOHjyIW265Bc888wwmTpwIgO9bLanv+vK9qw379u3DAw88AK/XC6/Xi2+++QbTp0/ne1cj6ru+AwcOjOp7lx9nRVhWVhbuvPNOzJ49Gz6fD9OmTUOfPn2ULosiZNSoUdi8eTMuvvhiBAIBzJw5E/n5+UqXRRFkMpnw5JNP4rbbboPH48HIkSNx4YUXKl0WRUCPHj1www03YMaMGfD7/Rg7diwmTZqkdFnUSG+88QY8Hg+efPLJ8H3Tp0/n+1YjTnV9+d5Vv5EjR4Z/h9Lr9Rg7diwmTpyItLQ0vnc1oL7re+uttyI1NTVq711Brm9CGBEREREREVGcYmsxERERERERqQqDLBEREREREakKgywRERERERGpCoMsERERERERqQqDLBEREREREakKgywREcWNhx56COeffz6effbZJr2+pKQEt912W4Srio5I1vr+++9j/vz5AIDFixejoKAABQUFmD17Nnbv3h1+3tSpUzFhwgRMnjwZkydPxr///e+TjiVJEv7whz9g3LhxePfdd5tUz5YtW/DXv/61Sa9trHfeeQf//e9/Y3IuIiKKH9xHloiI4sb8+fOxYsUKtG7dukmvP3DgAHbt2hXhqqIjUrXu378fn3/+OT766CNUVFTg4YcfxoIFC5CdnY13330Xjz76KN544w04nU7s3bsXq1evhtFoPOXxSktL8eOPP2LTpk3Q6/VNqmn79u0oLS1t6h+pUa688kpMmzYNw4cPR0ZGRkzOSUREyuOILBERxYWZM2dClmXMmTMHhYWFKC0txS233IKpU6eioKAAr776avi5r776KqZNm4aCggJccMEF+PrrryFJEh544AHs3bsX1113Hfbt24f8/Pzwa469/dlnn2HmzJmYMmUKZs2aBQD4+OOPMXXqVFx88cW4+uqrsWPHjpNqvOuuu/DGG2+Eb3/wwQe44447AADffvstLr30Ulx88cWYPn06Nm7cCADw+/144oknMG7cOEyYMAH3338/vF7vcbUCwPLly3HxxRejoKAAM2bMwJYtWwAAL774Iq677joUFBTg7rvvPqmmf/3rX5g8eTIEQUCrVq2wcuVKZGdnw+/3Y//+/UhJSQEQHCW1WCy48cYbUVBQgMcffxxut/u4YzkcDlx//fXw+/2YOnUq9u7dix07duDaa6/F1KlTMXnyZHzyyScAgEAggMceewyXXnopJkyYgPHjx2PDhg04ePAgXnjhBRQWFuIvf/kL1q5di0mTJoXPcezt+v5sr7zyCqZMmYLJkyfj5ptvDgfiZcuWYcqUKZg6dSouvfRSrF+/HgCg1+sxfvx4vP7666f4ziIiIk2SiYiI4kRubq5cWVkpy7Isz5o1S/7mm29kWZZlt9stz5o1S/7yyy/lffv2ybNmzZJdLpcsy7K8aNEiedKkSbIsy/KaNWvkiRMnyrIsyyUlJXJeXl742Mfe/vTTT+WBAwfKoijKsizLa9eulWfOnCk7nU5ZlmX5hx9+kMePH39SfatXrw6fS5Zledq0afLKlSvlXbt2yZMmTZKrqqpkWZbl4uJiefjw4XJdXZ38zjvvyFdccYXscrlkSZLk22+/Xf7888+Pq3X79u3ysGHD5L1798qyLMurVq2Shw8fLouiKL/wwgvyuHHjZJ/Pd1I9gUBAHjx4sFxSUnLc/Vu2bJGHDRsm9+vXT/7pp59kWZbl5cuXy3fffbcsiqLsdrvlW2+9VX7sscdOOuaxf08+n0+eMGGC/Msvv8iyLMu1tbXy+PHj5Y0bN8o//fSTfNttt8mSJMmyLMv/+te/5BtvvDH893vDDTecdE1OvH3in+3zzz+X77jjjvDtDz/8UL7++utlWZbl0aNHyxs3bgxfnxdffDF8zOLiYvm888476c9CRETaxdZiIiKKO06nE+vXr0dNTQ2ef/758H1bt27FhAkT8NRTT2HhwoXYs2cPNm/ejLq6ukafo3v37rDZbACAFStWYM+ePZg+fXr48ZqaGlRXV4dHNAFg8ODB8Hg8+Pnnn2E2m1FVVYWhQ4fi/fffR1lZGa6++urwcwVBwN69e7Fq1SpMnjwZiYmJAIDnnnsOQHBkMmTNmjUYMmQI2rdvDwAYOnQo0tLS8MsvvwAA8vLyYDCc/CP78OHDEEUR7dq1O+7+3r17Y+XKlfj+++9x4403Yvny5Rg9ejRGjx4dfs6NN96I2267Dffff/8p/452796NvXv34r777gvf53a78dtvv2HmzJlITk7Ghx9+iJKSEqxduxZWq/WUxzqVY/9s//vf//Dzzz/jkksuARAc9XW5XACAiRMn4tZbb8XIkSMxfPhwzJkzJ3yMDh064MCBA/B4PDCZTI2ugYiI1IdBloiI4k4gEIAsy/jwww9hNpsBAFVVVTCZTPj1119x88034+qrr8bw4cMxcOBA/O1vfzvpGIIgQJbl8G2fz3fc4xaL5bjzTZ48Gffcc0/4dllZGZKTk0865rRp07BgwQIYjUZMmzYNgiAgEAhg6NCh4ZAKAAcPHkRmZuZJAbSiogKBQOC4+46t89j7/H7/SbUeS6fTQZZlBAIB6HQ6lJaWori4GOeeey4AYMSIEbDZbNi7dy/Kyspgt9sxcODA8PHrC8fHkiQJSUlJWLBgwXH12+12rFixAvPmzcM111yD0aNHo0uXLvjiiy9OOkZjr8P111+PmTNnAgC8Xi9qamoAAHfeeSemTZuGH3/8EZ999hlee+01fPbZZ9DpdJAkCYIgQBCE0/55iIhIOzhHloiI4o7NZkNeXh7eeustAEBtbS1mzJiBb775BuvXr8fZZ5+Na665BoMGDcI333wDSZIABOdLhoJSUlISfD4ftm/fDgD4+uuvT3m+4cOH48svv0RZWRmA4NzXq666qt7nTpkyBd9++y2WLl2KqVOnAgCGDBmClStXhufVfvfdd7jooovg8XgwdOhQLFq0CF6vF4FAAA8//DC+/PLL42oNvb6kpAQAsHr1ahw8eBB9+/Y97d9TSkoKkpKSsH//fgDB4HfnnXdiz549AIIjvX6/H127dsWhQ4fw1FNPwe12Q5IkvP3225gwYcJpj9+5c2eYTKZwkD148CAmTZqEX375BStXrsSoUaMwc+ZM9O7dG8uXLz/uOoRCeFpaGg4cOIDKykrIsozly5ef8nznnHMOPvnkEzgcDgDA888/jz/96U/w+/04//zz4XQ6MWPGDDz00EPYsWNH+BwlJSVo164dEhISTvvnISIi7eCILBERxaVnnnkGjz76KAoKCuD1ejFp0iRcdNFFqKiowLJlyzBhwgQYjUYMHToUNTU1cDgcyMnJgV6vx7Rp0/Dxxx/jnnvuwZw5c5CWloYLL7zwlOc699xzMWfOHFx77bUQBAE2mw3//Oc/6x3hy8jIwFlnnQW/34+srCwAQE5ODh555BH88Y9/DI90vvLKK7BYLJg+fTr279+PqVOnQpZlDBo0CLNmzUJdXd1xtT700EO49dZbIUkSEhMT8eqrr8Jutzf49zR27Fj88MMPmDlzJtq3b4958+bhtttugyAISEpKwquvvgqz2Yzp06ejpKQEU6ZMgSRJGDx4MG655ZbTHjshIQEvv/wy5s2bh3//+9/w+/24/fbb0b9/f6SkpODuu+9GQUEB9Ho9BgwYgGXLliEQCCA/Px/PPfccbrnlFrz00kuYPn06LrnkEmRkZOC888475fkuvfRSlJaW4rLLLoMgCMjOzsaTTz4Jg8GA++67D3fffTcMBgMEQcDjjz8eDq4//PDDaa8vERFpjyDX189EREREqlBSUoLbb78dn376aYtsrZUkCVOmTMGbb76JVq1aKV0OERHFCIMsERGRyv3nP/+B0WjEjBkzlC4l5t5++23Y7fbwAlFERNQyMMgSERERERGRqnCxJyIiIiIiIlIVBlkiIiIiIiJSFQZZIiIiIiIiUhUGWSIiIiIiIlIVBlkiIiIiIiJSFQZZIiIiIiIiUpX/Dxf7pUT5H0V+AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(Xb[0], color='r')\n",
    "plt.xlabel('feature vector (35 features)')\n",
    "plt.ylabel('feature value')\n",
    "plt.title('Feature Vector Xb')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}