{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "from datetime import datetime \n",
    "from datetime import date\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from keras.models import Sequential\n",
    "from keras.layers import LSTM, Dense\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MinMaxScaler,StandardScaler\n",
    "from keras.callbacks import ModelCheckpoint\n",
    "import tensorflow as tf\n",
    "import joblib\n",
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged = pd.read_csv(r'../data/long_merge.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "zones = [72, 71, 63, 62, 60, 59, 58,57, 50, 49, 44, 43, 35, 34, 33, 32, 31, 30, 29, 28, ]\n",
    "rtus = [2]\n",
    "cols = []\n",
    "\n",
    "for zone in zones:\n",
    "        for column in merged.columns:\n",
    "            if f\"zone_0{zone}\" in column and 'co2' not in column and \"hw_valve\" not in column and \"cooling_sp\" not in column and \"heating_sp\" not in column:\n",
    "                cols.append(column)\n",
    "\n",
    "for zone in zones:\n",
    "        for column in merged.columns:\n",
    "              if f\"zone_0{zone}\" in column: \n",
    "                if \"cooling_sp\" in column or \"heating_sp\" in column:\n",
    "                  cols.append(column)\n",
    "# for rtu in rtus:\n",
    "#     for column in merged.columns:\n",
    "#         if f\"rtu_00{rtu}_fltrd_sa\" in column:\n",
    "#                 cols.append(column)\n",
    "cols =['date'] + cols + ['air_temp_set_1',\n",
    " 'air_temp_set_2',\n",
    " 'dew_point_temperature_set_1d',\n",
    " 'relative_humidity_set_1',\n",
    " 'solar_radiation_set_1']\n",
    "input_dataset = merged[cols]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\arbal\\AppData\\Local\\Temp\\ipykernel_12772\\1855433847.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  input_dataset['date'] = pd.to_datetime(input_dataset['date'], format = \"%Y-%m-%d %H:%M:%S\")\n"
     ]
    }
   ],
   "source": [
    "input_dataset['date'] = pd.to_datetime(input_dataset['date'], format = \"%Y-%m-%d %H:%M:%S\")\n",
    "df_filtered = input_dataset[ (input_dataset.date.dt.date >date(2019, 3, 1)) & (input_dataset.date.dt.date< date(2021, 1, 1))]\n",
    "\n",
    "if df_filtered.isna().any().any():\n",
    "    print(\"There are NA values in the DataFrame columns.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "testdataset_df = df_filtered[(df_filtered.date.dt.date >date(2020, 3, 1)) & (df_filtered.date.dt.date <date(2020,7, 1))]\n",
    "traindataset_df = df_filtered[(df_filtered.date.dt.date >date(2019, 3, 1)) & (df_filtered.date.dt.date <date(2020, 3, 1)) | (df_filtered.date.dt.date >date(2020, 7, 1)) & (df_filtered.date.dt.date <date(2020, 12, 1))]\n",
    "\n",
    "testdataset_df.set_index('date', inplace=True)\n",
    "traindataset_df.set_index('date', inplace=True)\n",
    "\n",
    "testdataset = testdataset_df.values\n",
    "traindataset = traindataset_df.values\n",
    "\n",
    "columns_with_na = traindataset_df.columns[traindataset_df.isna().any()].tolist()\n",
    "columns_with_na"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['zone_072_temp', 'zone_072_fan_spd', 'zone_071_temp',\n",
       "       'zone_071_fan_spd', 'zone_063_temp', 'zone_063_fan_spd',\n",
       "       'zone_062_temp', 'zone_062_fan_spd', 'zone_059_temp',\n",
       "       'zone_059_fan_spd', 'zone_058_temp', 'zone_058_fan_spd',\n",
       "       'zone_057_temp', 'zone_057_fan_spd', 'zone_049_temp',\n",
       "       'zone_049_fan_spd', 'zone_044_temp', 'zone_044_fan_spd',\n",
       "       'zone_043_temp', 'zone_043_fan_spd', 'zone_035_temp',\n",
       "       'zone_035_fan_spd', 'zone_033_temp', 'zone_033_fan_spd',\n",
       "       'zone_032_temp', 'zone_032_fan_spd', 'zone_030_temp',\n",
       "       'zone_030_fan_spd', 'zone_028_temp', 'zone_028_fan_spd',\n",
       "       'zone_071_cooling_sp'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "traindataset_df.columns[0:31]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1073512, 391818)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(traindataset), len(testdataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['scaler_vav_2.pkl']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "traindataset = traindataset.astype('float32')\n",
    "testdataset = testdataset.astype('float32')\n",
    "\n",
    "scaler = StandardScaler()\n",
    "traindataset = scaler.fit_transform(traindataset)\n",
    "testdataset = scaler.transform(testdataset)\n",
    "\n",
    "joblib.dump(scaler, 'scaler_vav_2.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "train,test = traindataset,testdataset\n",
    "\n",
    "def create_dataset(dataset,time_step):\n",
    "    x = []\n",
    "    Y = []\n",
    "    for i in range(len(dataset) - time_step - 1):\n",
    "        x.append(dataset[i:(i+time_step),:])\n",
    "        Y.append(dataset[i+time_step,0:31])\n",
    "    x= np.array(x)\n",
    "    Y = np.array(Y)\n",
    "    return x,Y\n",
    "time_step = 30\n",
    "X_train, y_train = create_dataset(train, time_step)\n",
    "X_test, y_test = create_dataset(test, time_step)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1073481, 30, 55), (1073481, 31))"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, y_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\keras\\src\\layers\\rnn\\rnn.py:204: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
      "  super().__init__(**kwargs)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "model = Sequential()\n",
    "model.add(LSTM(units=50, return_sequences=True, input_shape=(X_train.shape[1], X_train.shape[2])))\n",
    "model.add(LSTM(units=50, return_sequences=True))\n",
    "model.add(LSTM(units=30))\n",
    "model.add(Dense(units=y_train.shape[1]))\n",
    "\n",
    "model.compile(optimizer='adam', loss='mean_squared_error')\n",
    "\n",
    "checkpoint_path = \"lstm_vav_02.keras\"\n",
    "checkpoint_callback = ModelCheckpoint(filepath=checkpoint_path, monitor='val_loss', verbose=1, save_best_only=True, mode='min')\n",
    "# model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=3, batch_size=128, verbose=1, callbacks=[checkpoint_callback])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\keras\\src\\saving\\saving_lib.py:415: UserWarning: Skipping variable loading for optimizer 'adam', because it has 2 variables whereas the saved optimizer has 24 variables. \n",
      "  saveable.load_own_variables(weights_store.get(inner_path))\n"
     ]
    }
   ],
   "source": [
    "model.load_weights(checkpoint_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m12244/12244\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m114s\u001b[0m 9ms/step\n"
     ]
    }
   ],
   "source": [
    "test_predict1 = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'zone_072_fan_spd',\n",
       " 1: 'zone_071_temp',\n",
       " 2: 'zone_071_fan_spd',\n",
       " 3: 'zone_063_temp',\n",
       " 4: 'zone_063_fan_spd',\n",
       " 5: 'zone_062_temp',\n",
       " 6: 'zone_062_fan_spd',\n",
       " 7: 'zone_059_temp',\n",
       " 8: 'zone_059_fan_spd',\n",
       " 9: 'zone_058_temp',\n",
       " 10: 'zone_058_fan_spd',\n",
       " 11: 'zone_057_temp',\n",
       " 12: 'zone_057_fan_spd',\n",
       " 13: 'zone_049_temp',\n",
       " 14: 'zone_049_fan_spd',\n",
       " 15: 'zone_044_temp',\n",
       " 16: 'zone_044_fan_spd',\n",
       " 17: 'zone_043_temp',\n",
       " 18: 'zone_043_fan_spd',\n",
       " 19: 'zone_035_temp',\n",
       " 20: 'zone_035_fan_spd',\n",
       " 21: 'zone_033_temp',\n",
       " 22: 'zone_033_fan_spd',\n",
       " 23: 'zone_032_temp',\n",
       " 24: 'zone_032_fan_spd',\n",
       " 25: 'zone_030_temp',\n",
       " 26: 'zone_030_fan_spd',\n",
       " 27: 'zone_028_temp',\n",
       " 28: 'zone_028_fan_spd',\n",
       " 29: 'zone_071_cooling_sp',\n",
       " 30: 'zone_071_heating_sp',\n",
       " 31: 'zone_063_cooling_sp',\n",
       " 32: 'zone_063_heating_sp',\n",
       " 33: 'zone_062_cooling_sp',\n",
       " 34: 'zone_062_heating_sp',\n",
       " 35: 'zone_059_cooling_sp',\n",
       " 36: 'zone_059_heating_sp',\n",
       " 37: 'zone_057_cooling_sp',\n",
       " 38: 'zone_057_heating_sp',\n",
       " 39: 'zone_049_cooling_sp',\n",
       " 40: 'zone_049_heating_sp',\n",
       " 41: 'zone_043_cooling_sp',\n",
       " 42: 'zone_043_heating_sp',\n",
       " 43: 'zone_035_cooling_sp',\n",
       " 44: 'zone_035_heating_sp',\n",
       " 45: 'zone_032_cooling_sp',\n",
       " 46: 'zone_032_heating_sp',\n",
       " 47: 'zone_030_cooling_sp',\n",
       " 48: 'zone_030_heating_sp',\n",
       " 49: 'air_temp_set_1',\n",
       " 50: 'air_temp_set_2',\n",
       " 51: 'dew_point_temperature_set_1d',\n",
       " 52: 'relative_humidity_set_1',\n",
       " 53: 'solar_radiation_set_1'}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idx_2_col = {}\n",
    "for i, col in enumerate(traindataset_df.columns[1:]):\n",
    "    idx_2_col[i] = col\n",
    "\n",
    "idx_2_col"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(391787, 31)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_predict1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_predict1_unscaled = test_predict1*scaler.scale_[0:31] + scaler.mean_[0:31]\n",
    "y_test_unscaled = y_test*scaler.scale_[0:31] + scaler.mean_[0:31]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\pandas\\core\\indexes\\base.py:7588: FutureWarning: Dtype inference on a pandas object (Series, Index, ExtensionArray) is deprecated. The Index constructor will keep the original dtype in the future. Call `infer_objects` on the result to get the old behavior.\n",
      "  return Index(sequences[0], name=names)\n",
      "d:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\pandas\\core\\indexes\\base.py:7588: FutureWarning: Dtype inference on a pandas object (Series, Index, ExtensionArray) is deprecated. The Index constructor will keep the original dtype in the future. Call `infer_objects` on the result to get the old behavior.\n",
      "  return Index(sequences[0], name=names)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "var = 0\n",
    "\n",
    "df = pd.DataFrame([testdataset_df.index[31:],test_predict1_unscaled[:,var], y_test_unscaled[:,var]] ).T\n",
    "fig, ax = plt.subplots(figsize=(10,8))\n",
    "df.plot(x = 0, y=1, ax = ax, label = 'Predicted')\n",
    "df.plot(x = 0, y=2, ax = ax, label = 'Actual')\n",
    "\n",
    "anomalies = df.where(df[1]-df[2]>0.38)[0]\n",
    "df['anomalies'] = anomalies\n",
    "\n",
    "df_new = df.dropna()\n",
    "\n",
    "df_new.plot.scatter(x='anomalies', y=1,  c='r', ax = ax, label = 'Anomalies')\n",
    "\n",
    "# ax.scatter(anomalies,test_predict1[anomalies,var], color='black',marker =\"o\",s=100 )\n",
    "\n",
    "\n",
    "ax.set_title('Testing Data - Predicted vs Actual [Zone 72 Temperature]', fontsize=20)\n",
    "ax.set_xlabel('Time', fontsize=15)\n",
    "ax.set_ylabel('Value', fontsize = 15)\n",
    "ax.legend(fontsize = 15)\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\pandas\\core\\indexes\\base.py:7588: FutureWarning: Dtype inference on a pandas object (Series, Index, ExtensionArray) is deprecated. The Index constructor will keep the original dtype in the future. Call `infer_objects` on the result to get the old behavior.\n",
      "  return Index(sequences[0], name=names)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'MSE')"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(10,8))\n",
    "df['residual'] = df[1] - df[2]\n",
    "df['mse'] = (df[1] - df[2])**2\n",
    "df.plot(x = 0, y='mse', figsize=(10,8), title = 'Mean Squared Error', ax = ax)\n",
    "ax.set_xlabel('Time', fontsize=15)\n",
    "ax.set_ylabel('MSE', fontsize = 15)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[27], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m get_ipython()\u001b[38;5;241m.\u001b[39mrun_line_magic(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmatplotlib\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mqt\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m----> 2\u001b[0m test_predict2 \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_train\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\keras\\src\\utils\\traceback_utils.py:117\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    115\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m    116\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 117\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    118\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m    119\u001b[0m     filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\keras\\src\\backend\\tensorflow\\trainer.py:442\u001b[0m, in \u001b[0;36mTensorFlowTrainer.predict\u001b[1;34m(self, x, batch_size, verbose, steps, callbacks)\u001b[0m\n\u001b[0;32m    437\u001b[0m \u001b[38;5;129m@traceback_utils\u001b[39m\u001b[38;5;241m.\u001b[39mfilter_traceback\n\u001b[0;32m    438\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mpredict\u001b[39m(\n\u001b[0;32m    439\u001b[0m     \u001b[38;5;28mself\u001b[39m, x, batch_size\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mauto\u001b[39m\u001b[38;5;124m\"\u001b[39m, steps\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, callbacks\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m    440\u001b[0m ):\n\u001b[0;32m    441\u001b[0m     \u001b[38;5;66;03m# Create an iterator that yields batches of input data.\u001b[39;00m\n\u001b[1;32m--> 442\u001b[0m     epoch_iterator \u001b[38;5;241m=\u001b[39m \u001b[43mTFEpochIterator\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    443\u001b[0m \u001b[43m        \u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    444\u001b[0m \u001b[43m        \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    445\u001b[0m \u001b[43m        \u001b[49m\u001b[43msteps_per_epoch\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msteps\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    446\u001b[0m \u001b[43m        \u001b[49m\u001b[43mshuffle\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m    447\u001b[0m \u001b[43m        \u001b[49m\u001b[43mdistribute_strategy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistribute_strategy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    448\u001b[0m \u001b[43m        \u001b[49m\u001b[43msteps_per_execution\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msteps_per_execution\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    449\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    451\u001b[0m     \u001b[38;5;66;03m# Container that configures and calls callbacks.\u001b[39;00m\n\u001b[0;32m    452\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(callbacks, callbacks_module\u001b[38;5;241m.\u001b[39mCallbackList):\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\keras\\src\\backend\\tensorflow\\trainer.py:625\u001b[0m, in \u001b[0;36mTFEpochIterator.__init__\u001b[1;34m(self, distribute_strategy, *args, **kwargs)\u001b[0m\n\u001b[0;32m    623\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    624\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_distribute_strategy \u001b[38;5;241m=\u001b[39m distribute_strategy\n\u001b[1;32m--> 625\u001b[0m dataset \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_iterator\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    626\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(dataset, tf\u001b[38;5;241m.\u001b[39mdistribute\u001b[38;5;241m.\u001b[39mDistributedDataset):\n\u001b[0;32m    627\u001b[0m     dataset \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_distribute_strategy\u001b[38;5;241m.\u001b[39mexperimental_distribute_dataset(\n\u001b[0;32m    628\u001b[0m         dataset\n\u001b[0;32m    629\u001b[0m     )\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\keras\\src\\backend\\tensorflow\\trainer.py:634\u001b[0m, in \u001b[0;36mTFEpochIterator._get_iterator\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    633\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_get_iterator\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m--> 634\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata_adapter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_tf_dataset\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\keras\\src\\trainers\\data_adapters\\array_data_adapter.py:236\u001b[0m, in \u001b[0;36mArrayDataAdapter.get_tf_dataset\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    233\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m shuffle \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbatch\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m    234\u001b[0m     indices_dataset \u001b[38;5;241m=\u001b[39m indices_dataset\u001b[38;5;241m.\u001b[39mmap(tf\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mshuffle)\n\u001b[1;32m--> 236\u001b[0m dataset \u001b[38;5;241m=\u001b[39m \u001b[43mslice_inputs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindices_dataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    238\u001b[0m options \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mdata\u001b[38;5;241m.\u001b[39mOptions()\n\u001b[0;32m    239\u001b[0m options\u001b[38;5;241m.\u001b[39mexperimental_distribute\u001b[38;5;241m.\u001b[39mauto_shard_policy \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m    240\u001b[0m     tf\u001b[38;5;241m.\u001b[39mdata\u001b[38;5;241m.\u001b[39mexperimental\u001b[38;5;241m.\u001b[39mAutoShardPolicy\u001b[38;5;241m.\u001b[39mDATA\n\u001b[0;32m    241\u001b[0m )\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\keras\\src\\trainers\\data_adapters\\array_data_adapter.py:197\u001b[0m, in \u001b[0;36mArrayDataAdapter.get_tf_dataset.<locals>.slice_inputs\u001b[1;34m(indices_dataset, inputs)\u001b[0m\n\u001b[0;32m    191\u001b[0m inputs \u001b[38;5;241m=\u001b[39m array_slicing\u001b[38;5;241m.\u001b[39mconvert_to_sliceable(\n\u001b[0;32m    192\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_inputs, target_backend\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtensorflow\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    193\u001b[0m )\n\u001b[0;32m    194\u001b[0m inputs \u001b[38;5;241m=\u001b[39m tree\u001b[38;5;241m.\u001b[39mlists_to_tuples(inputs)\n\u001b[0;32m    196\u001b[0m dataset \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mdata\u001b[38;5;241m.\u001b[39mDataset\u001b[38;5;241m.\u001b[39mzip(\n\u001b[1;32m--> 197\u001b[0m     (indices_dataset, \u001b[43mtf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mDataset\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_tensors\u001b[49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mrepeat())\n\u001b[0;32m    198\u001b[0m )\n\u001b[0;32m    200\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mgrab_batch\u001b[39m(i, data):\n\u001b[0;32m    202\u001b[0m     \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mgrab_one\u001b[39m(x):\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\data\\ops\\dataset_ops.py:741\u001b[0m, in \u001b[0;36mDatasetV2.from_tensors\u001b[1;34m(tensors, name)\u001b[0m\n\u001b[0;32m    737\u001b[0m \u001b[38;5;66;03m# Loaded lazily due to a circular dependency (dataset_ops ->\u001b[39;00m\n\u001b[0;32m    738\u001b[0m \u001b[38;5;66;03m# from_tensors_op -> dataset_ops).\u001b[39;00m\n\u001b[0;32m    739\u001b[0m \u001b[38;5;66;03m# pylint: disable=g-import-not-at-top,protected-access\u001b[39;00m\n\u001b[0;32m    740\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mtensorflow\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpython\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdata\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mops\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m from_tensors_op\n\u001b[1;32m--> 741\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfrom_tensors_op\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_from_tensors\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\data\\ops\\from_tensors_op.py:23\u001b[0m, in \u001b[0;36m_from_tensors\u001b[1;34m(tensors, name)\u001b[0m\n\u001b[0;32m     22\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_from_tensors\u001b[39m(tensors, name):  \u001b[38;5;66;03m# pylint: disable=unused-private-name\u001b[39;00m\n\u001b[1;32m---> 23\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_TensorDataset\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\data\\ops\\from_tensors_op.py:31\u001b[0m, in \u001b[0;36m_TensorDataset.__init__\u001b[1;34m(self, element, name)\u001b[0m\n\u001b[0;32m     29\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, element, name\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m     30\u001b[0m \u001b[38;5;250m  \u001b[39m\u001b[38;5;124;03m\"\"\"See `tf.data.Dataset.from_tensors` for details.\"\"\"\u001b[39;00m\n\u001b[1;32m---> 31\u001b[0m   element \u001b[38;5;241m=\u001b[39m \u001b[43mstructure\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnormalize_element\u001b[49m\u001b[43m(\u001b[49m\u001b[43melement\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     32\u001b[0m   \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_structure \u001b[38;5;241m=\u001b[39m structure\u001b[38;5;241m.\u001b[39mtype_spec_from_value(element)\n\u001b[0;32m     33\u001b[0m   \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_tensors \u001b[38;5;241m=\u001b[39m structure\u001b[38;5;241m.\u001b[39mto_tensor_list(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_structure, element)\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\data\\util\\structure.py:134\u001b[0m, in \u001b[0;36mnormalize_element\u001b[1;34m(element, element_signature)\u001b[0m\n\u001b[0;32m    131\u001b[0m       \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m    132\u001b[0m         dtype \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(spec, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdtype\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m    133\u001b[0m         normalized_components\u001b[38;5;241m.\u001b[39mappend(\n\u001b[1;32m--> 134\u001b[0m             \u001b[43mops\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconvert_to_tensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcomponent_\u001b[39;49m\u001b[38;5;132;43;01m%d\u001b[39;49;00m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m%\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[0;32m    135\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m nest\u001b[38;5;241m.\u001b[39mpack_sequence_as(pack_as, normalized_components)\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\profiler\\trace.py:183\u001b[0m, in \u001b[0;36mtrace_wrapper.<locals>.inner_wrapper.<locals>.wrapped\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    181\u001b[0m   \u001b[38;5;28;01mwith\u001b[39;00m Trace(trace_name, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mtrace_kwargs):\n\u001b[0;32m    182\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m--> 183\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\framework\\ops.py:713\u001b[0m, in \u001b[0;36mconvert_to_tensor\u001b[1;34m(value, dtype, name, as_ref, preferred_dtype, dtype_hint, ctx, accepted_result_types)\u001b[0m\n\u001b[0;32m    711\u001b[0m \u001b[38;5;66;03m# TODO(b/142518781): Fix all call-sites and remove redundant arg\u001b[39;00m\n\u001b[0;32m    712\u001b[0m preferred_dtype \u001b[38;5;241m=\u001b[39m preferred_dtype \u001b[38;5;129;01mor\u001b[39;00m dtype_hint\n\u001b[1;32m--> 713\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtensor_conversion_registry\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconvert\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    714\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mas_ref\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpreferred_dtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maccepted_result_types\u001b[49m\n\u001b[0;32m    715\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\framework\\tensor_conversion_registry.py:234\u001b[0m, in \u001b[0;36mconvert\u001b[1;34m(value, dtype, name, as_ref, preferred_dtype, accepted_result_types)\u001b[0m\n\u001b[0;32m    225\u001b[0m       \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[0;32m    226\u001b[0m           _add_error_prefix(\n\u001b[0;32m    227\u001b[0m               \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mConversion function \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mconversion_func\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m for type \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    230\u001b[0m               \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mactual = \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mret\u001b[38;5;241m.\u001b[39mdtype\u001b[38;5;241m.\u001b[39mbase_dtype\u001b[38;5;241m.\u001b[39mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m    231\u001b[0m               name\u001b[38;5;241m=\u001b[39mname))\n\u001b[0;32m    233\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ret \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m--> 234\u001b[0m   ret \u001b[38;5;241m=\u001b[39m \u001b[43mconversion_func\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mas_ref\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mas_ref\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    236\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ret \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28mNotImplemented\u001b[39m:\n\u001b[0;32m    237\u001b[0m   \u001b[38;5;28;01mcontinue\u001b[39;00m\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\framework\\constant_tensor_conversion.py:29\u001b[0m, in \u001b[0;36m_constant_tensor_conversion_function\u001b[1;34m(v, dtype, name, as_ref)\u001b[0m\n\u001b[0;32m     26\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mtensorflow\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpython\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mframework\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m constant_op  \u001b[38;5;66;03m# pylint: disable=g-import-not-at-top\u001b[39;00m\n\u001b[0;32m     28\u001b[0m _ \u001b[38;5;241m=\u001b[39m as_ref\n\u001b[1;32m---> 29\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mconstant_op\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconstant\u001b[49m\u001b[43m(\u001b[49m\u001b[43mv\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\ops\\weak_tensor_ops.py:142\u001b[0m, in \u001b[0;36mweak_tensor_binary_op_wrapper.<locals>.wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    140\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m    141\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m ops\u001b[38;5;241m.\u001b[39mis_auto_dtype_conversion_enabled():\n\u001b[1;32m--> 142\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mop\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    143\u001b[0m   bound_arguments \u001b[38;5;241m=\u001b[39m signature\u001b[38;5;241m.\u001b[39mbind(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    144\u001b[0m   bound_arguments\u001b[38;5;241m.\u001b[39mapply_defaults()\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\framework\\constant_op.py:276\u001b[0m, in \u001b[0;36mconstant\u001b[1;34m(value, dtype, shape, name)\u001b[0m\n\u001b[0;32m    177\u001b[0m \u001b[38;5;129m@tf_export\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mconstant\u001b[39m\u001b[38;5;124m\"\u001b[39m, v1\u001b[38;5;241m=\u001b[39m[])\n\u001b[0;32m    178\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mconstant\u001b[39m(\n\u001b[0;32m    179\u001b[0m     value, dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, shape\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mConst\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    180\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Union[ops\u001b[38;5;241m.\u001b[39mOperation, ops\u001b[38;5;241m.\u001b[39m_EagerTensorBase]:\n\u001b[0;32m    181\u001b[0m \u001b[38;5;250m  \u001b[39m\u001b[38;5;124;03m\"\"\"Creates a constant tensor from a tensor-like object.\u001b[39;00m\n\u001b[0;32m    182\u001b[0m \n\u001b[0;32m    183\u001b[0m \u001b[38;5;124;03m  Note: All eager `tf.Tensor` values are immutable (in contrast to\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    274\u001b[0m \u001b[38;5;124;03m    ValueError: if called on a symbolic tensor.\u001b[39;00m\n\u001b[0;32m    275\u001b[0m \u001b[38;5;124;03m  \"\"\"\u001b[39;00m\n\u001b[1;32m--> 276\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_constant_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mverify_shape\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m    277\u001b[0m \u001b[43m                        \u001b[49m\u001b[43mallow_broadcast\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\framework\\constant_op.py:289\u001b[0m, in \u001b[0;36m_constant_impl\u001b[1;34m(value, dtype, shape, name, verify_shape, allow_broadcast)\u001b[0m\n\u001b[0;32m    287\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m trace\u001b[38;5;241m.\u001b[39mTrace(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtf.constant\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m    288\u001b[0m       \u001b[38;5;28;01mreturn\u001b[39;00m _constant_eager_impl(ctx, value, dtype, shape, verify_shape)\n\u001b[1;32m--> 289\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_constant_eager_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mverify_shape\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    291\u001b[0m const_tensor \u001b[38;5;241m=\u001b[39m ops\u001b[38;5;241m.\u001b[39m_create_graph_constant(  \u001b[38;5;66;03m# pylint: disable=protected-access\u001b[39;00m\n\u001b[0;32m    292\u001b[0m     value, dtype, shape, name, verify_shape, allow_broadcast\n\u001b[0;32m    293\u001b[0m )\n\u001b[0;32m    294\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m const_tensor\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\framework\\constant_op.py:301\u001b[0m, in \u001b[0;36m_constant_eager_impl\u001b[1;34m(ctx, value, dtype, shape, verify_shape)\u001b[0m\n\u001b[0;32m    297\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_constant_eager_impl\u001b[39m(\n\u001b[0;32m    298\u001b[0m     ctx, value, dtype, shape, verify_shape\n\u001b[0;32m    299\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m ops\u001b[38;5;241m.\u001b[39m_EagerTensorBase:\n\u001b[0;32m    300\u001b[0m \u001b[38;5;250m  \u001b[39m\u001b[38;5;124;03m\"\"\"Creates a constant on the current device.\"\"\"\u001b[39;00m\n\u001b[1;32m--> 301\u001b[0m   t \u001b[38;5;241m=\u001b[39m \u001b[43mconvert_to_eager_tensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mctx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    302\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m shape \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m    303\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m t\n",
      "File \u001b[1;32md:\\anaconda3\\envs\\smartbuilding\\Lib\\site-packages\\tensorflow\\python\\framework\\constant_op.py:96\u001b[0m, in \u001b[0;36mconvert_to_eager_tensor\u001b[1;34m(value, ctx, dtype)\u001b[0m\n\u001b[0;32m     76\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Converts the given `value` to an `EagerTensor`.\u001b[39;00m\n\u001b[0;32m     77\u001b[0m \n\u001b[0;32m     78\u001b[0m \u001b[38;5;124;03mNote that this function could return cached copies of created constants for\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m     90\u001b[0m \u001b[38;5;124;03m  TypeError: if `dtype` is not compatible with the type of t.\u001b[39;00m\n\u001b[0;32m     91\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m     92\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(value, np\u001b[38;5;241m.\u001b[39mndarray):\n\u001b[0;32m     93\u001b[0m   \u001b[38;5;66;03m# Make a copy explicitly because the EagerTensor might share the underlying\u001b[39;00m\n\u001b[0;32m     94\u001b[0m   \u001b[38;5;66;03m# memory with the input array. Without this copy, users will be able to\u001b[39;00m\n\u001b[0;32m     95\u001b[0m   \u001b[38;5;66;03m# modify the EagerTensor after its creation by changing the input array.\u001b[39;00m\n\u001b[1;32m---> 96\u001b[0m   value \u001b[38;5;241m=\u001b[39m value\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[0;32m     97\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(value, ops\u001b[38;5;241m.\u001b[39mEagerTensor):\n\u001b[0;32m     98\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m dtype \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m value\u001b[38;5;241m.\u001b[39mdtype \u001b[38;5;241m!=\u001b[39m dtype:\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "%matplotlib qt\n",
    "test_predict2 = model.predict(X_train)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "var = 0\n",
    "plt.plot(y_train[:,var], label='Original Training Data', color='blue')\n",
    "plt.plot(test_predict2[:,var], label='Predicted Training Data', color='red',alpha=0.8)\n",
    "anomalies = np.where(abs(test_predict2[:,var] - y_train[:,var]) > 0.38)\n",
    "plt.scatter(anomalies,test_predict2[anomalies,var], color='black',marker =\"o\",s=100 )\n",
    "\n",
    "\n",
    "plt.title('Training Data - Predicted vs Actual')\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Value')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.mixture import GaussianMixture\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "\n",
    "# Generating random data for demonstration\n",
    "np.random.seed(0)\n",
    "X =  test_predict1 - y_test\n",
    "\n",
    "\n",
    "pca = PCA(n_components=2)\n",
    "X = pca.fit_transform(X)\n",
    "\n",
    "\n",
    "# Creating the GMM instance with desired number of clusters\n",
    "gmm = GaussianMixture(n_components=2)\n",
    "\n",
    "# Fitting the model to the data\n",
    "gmm.fit(X)\n",
    "\n",
    "# Getting the cluster labels\n",
    "labels = gmm.predict(X)\n",
    "\n",
    "# Plotting the data points with colors representing different clusters\n",
    "plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', alpha=0.5)\n",
    "plt.title('GMM Clustering')\n",
    "plt.xlabel('Feature 1')\n",
    "plt.ylabel('Feature 2')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC1mklEQVR4nOzdd3gc1fXw8e+d2aZVL5Zl2bLl3k0zxRiwaQFCJxA6AZI3ISGVJKSRBOeX0NJIQkkIAUJogdAJHWKqARtsY9ybbLmol5W0fea+f4wsW5ZkS/KuVuV8nkdg7c7MPbsr7R7dcq7SWmuEEEIIIcSAZ6Q6ACGEEEIIkRiS2AkhhBBCDBKS2AkhhBBCDBKS2AkhhBBCDBKS2AkhhBBCDBKS2AkhhBBCDBKS2AkhhBBCDBKS2AkhhBBCDBKS2AkhhBBCDBKS2AkhOvXAAw+glGLJkiXtbq+pqWH27NlkZGTw2muvAXDjjTeilMIwDDZt2tThWi0tLWRlZaGU4sorr+yL8JOusrKSH//4x8ycOZOMjAx8Ph8TJ07kO9/5DuvXr287btdzkywvvvgiN954Y9KuP3/+fObPn5+06wshEsuV6gCEEAPHtm3bOPnkk6msrOT111/nqKOOand/RkYG999/P//3f//X7vYnnniCWCyG2+3uy3CT5qOPPuKMM85Aa803v/lN5syZg8fjYe3atTz00EMcccQR1NfX90ksL774InfeeWfSkru77rorKdcVQiSHJHZCiG5Zv349J510ErFYjLfeeouZM2d2OObCCy/kn//8JwsWLMAwdg8I/OMf/+Dcc8/lueee68uQkyIQCHD22Wfj8/l4//33GTVqVNt98+fP52tf+xr/+c9/UhhhYgSDQfx+P9OmTUt1KEKIHpChWCHEfi1btoxjjjkGl8vFu+++22lSB3D11VdTXl7eNkQLsG7dOt59912uvvrqTs8JBAL84Ac/YOzYsXg8HkaOHMl3v/tdWlpa2h135513ctxxx1FYWEh6ejozZ87ktttuIxaLtTtu/vz5zJgxg8WLF3Psscfi9/sZN24ct9xyC7Zttx1n2za//vWvmTx5MmlpaeTk5DBr1iz+9Kc/7fO5+Pvf/05FRQW33XZbu6RuT+eff/4+r6GU6rSHrbS0tN1QdTAYbHtufD4feXl5zJ49m0cffRSAK6+8kjvvvLPtmru+ysrKANBac9ddd3HwwQeTlpZGbm4u559/fofh8l3P2dtvv83RRx+N3+9ve732HootKytDKcXvfvc7/vCHPzB27FgyMjKYM2cOH3zwQafP16RJk/B6vUybNo1HHnmEK6+8ktLS0n0+R0KI3pEeOyHEPr377rvceOONlJSU8OqrrzJixIguj504cSLHHnss9913H6eccgoA9913H6WlpZx44okdjg8Gg8ybN49t27bx05/+lFmzZrFy5Up+8YtfsGLFCl5//fW2+WkbN27kkksuaUsAly9fzm9+8xvWrFnDfffd1+66FRUVXHrppXz/+9/nl7/8JU8//TQ/+clPKC4u5oorrgDgtttu48Ybb+SGG27guOOOIxaLsWbNGhoaGvb5fLz66quYpsmZZ57Zk6exV6677jr+9a9/8etf/5pDDjmElpYWPvvsM2prawH4+c9/TktLC//5z39YtGhR23m7XqOvfe1rPPDAA3z729/m1ltvpa6ujl/96lccffTRLF++nOHDh7eds3PnTi677DKuv/56brrppnY9rp258847mTJlCrfffntbLJ///OfZvHkz2dnZANxzzz187Wtf4wtf+AJ//OMfaWxsZMGCBUQikUQ+TUKIPWkhhOjE/fffrwEN6OzsbF1VVdXlsb/85S81oKurq/X999+vvV6vrq2t1fF4XI8YMULfeOONWmut09PT9Ze+9KW2826++WZtGIZevHhxu+v95z//0YB+8cUXO23Psiwdi8X0gw8+qE3T1HV1dW33zZs3TwP6ww8/bHfOtGnT9CmnnNL2/RlnnKEPPvjgbj8fu0yZMkUXFRV1+/hdz82eAP3LX/6yw7Fjxoxp9/zMmDFDn3POOfu8/rXXXtvh+lprvWjRIg3o3//+9+1uLy8v12lpafr6669vu23Xc/bGG290uM68efP0vHnz2r7fvHmzBvTMmTN1PB5vu/2jjz7SgH700Ue11s5rVFRUpI888sh219uyZYt2u916zJgx+3xcQojekaFYIcQ+nXXWWTQ2NvLd734Xy7L2e/wFF1yAx+Ph4Ycf5sUXX6SioqLLlbAvvPACM2bM4OCDDyYej7d9nXLKKSilWLhwYduxS5cu5ayzziI/Px/TNHG73VxxxRVYlsW6devaXbeoqIgjjjii3W2zZs1iy5Ytbd8fccQRLF++nG984xu88sorBAKB7j8pfeSII47gpZde4sc//jELFy4kFAp1+9wXXngBpRSXXXZZu+e2qKiIgw46qN1zC5Cbm8sJJ5zQ7euffvrpmKbZ9v2sWbMA2p7jtWvXUlFRwRe/+MV2540ePZq5c+d2ux0hRM/IUKwQYp9+/vOfc/DBB/OrX/0K27Z56KGH2n2g7y09PZ0LL7yQ++67jzFjxnDSSScxZsyYTo+trKxkw4YNXa6WrampAWDr1q0ce+yxTJ48mT/96U+Ulpbi8/n46KOPuPbaazskPPn5+R2u5fV62x33k5/8hPT0dB566CH++te/Ypomxx13HLfeeiuzZ8/u8vGNHj2a9evX09LSQnp6epfHJcKf//xnRo0axb///W9uvfVWfD4fp5xyCr/97W+ZOHHiPs+trKxEa91uuHVP48aNa/f9vobYO7P3c+z1egHanuNdw8WdtT98+HA2b97co/aEEN0jiZ0QYr8WLFiAUooFCxZg2zYPP/wwLlfXbx9XX3019957L59++ikPP/xwl8cVFBSQlpbWYY7cnvcDPPPMM7S0tPDUU0+1SxKXLVvWuwcEuFwurrvuOq677joaGhp4/fXX+elPf8opp5xCeXk5fr+/0/NOOeUUXn31VZ5//nkuuuiiXrXt9Xo7nWe2KxnaJT09nQULFrBgwQIqKyvbeu/OPPNM1qxZs882CgoKUErxzjvvtCVde8ewp0TX2tuV+FVWVna4r6KiIqFtCSF2k6FYIUS33HjjjSxYsIDHH3+cSy65hHg83uWxc+bM4eqrr+bcc8/l3HPP7fK4M844g40bN5Kfn8/s2bM7fO1aObkr6dgzGdFa8/e//z0hjy0nJ4fzzz+fa6+9lrq6urZVpZ358pe/TFFREddffz3bt2/v9Jinnnpqn+2Vlpby6aeftrvtzTffpLm5uctzhg8fzpVXXsnFF1/M2rVrCQaDQMeesl121dnbvn17p89tVyubE2Xy5MkUFRXx+OOPt7t969atvP/++0ltW4ihTHrshBDd9otf/ALDMPj5z3+O1ppHH320y567f/zjH/u93ne/+12efPJJjjvuOL73ve8xa9YsbNtm69atvPrqq3z/+9/nyCOP5OSTT8bj8XDxxRdz/fXXEw6Hufvuuw+oCPCZZ57JjBkzmD17NsOGDWPLli3cfvvtjBkzZp/DnNnZ2Tz77LOcccYZHHLIIe0KFK9fv56HHnqI5cuXc95553V5jcsvv5yf//zn/OIXv2DevHmsWrWKO+64o2016S5HHnkkZ5xxBrNmzSI3N5fVq1fzr3/9izlz5rT1KO5K0G699VZOO+00TNNk1qxZzJ07l69+9atcddVVLFmyhOOOO4709HR27tzZVrLm61//eq+fv/0xDIMFCxbwta99jfPPP5+rr76ahoYGFixYwIgRI/a76lYI0TuS2AkheuSGG27AMAx+9rOfYds2jz32WK+vlZ6ezjvvvMMtt9zCPffcw+bNm0lLS2P06NGcdNJJbT12U6ZM4cknn+SGG27gvPPOIz8/n0suuYTrrruO0047rVdtH3/88Tz55JPce++9BAIBioqKOPnkk/n5z3++3x0yjjjiCFasWMEf//hHHn/8cW699VYsy6KkpIQTTzyRO+64Y5/n//CHPyQQCPDAAw/wu9/9jiOOOILHH3+cs88+u91xJ5xwAs899xx//OMfCQaDjBw5kiuuuIKf/exnbcdccsklvPfee9x111386le/QmvN5s2bKS0t5W9/+xtHHXUUf/vb37jrrruwbZvi4mLmzp3bYXFJMnz1q19FKcVtt93GueeeS2lpKT/+8Y959tln2bp1a9LbF2IoUlprneoghBBCDA0NDQ1MmjSJc845h3vuuSfV4Qgx6EiPnRBCiKSoqKjgN7/5Dccffzz5+fls2bKFP/7xjzQ1NfGd73wn1eEJMShJYieEECIpvF4vZWVlfOMb36Curg6/389RRx3FX//6V6ZPn57q8IQYlGQoVgghhBBikJBlSUIIIYQQg4QkdkIIIYQQg4QkdkIIIYQQg8SQWjxh2zY7duwgMzMz4dvnCCGEEEIkg9aapqYmiouL91vce0gldjt27KCkpCTVYQghhBBC9Fh5eTmjRo3a5zFDKrHLzMwEnCcmKysrxdEIIYQQQuxfIBCgpKSkLY/ZlyGV2O0afs3KypLETgghhBADSnemkcniCSGEEEKIQUISOyGEEEKIQUISOyGEEEKIQUISOyGEEEKIQUISOyGEEEKIQUISOyGEEEKIQUISOyGEEEKIQUISOyGEEEKIQUISOyGEEEKIQUISOyGEEEKIQWJIbSkmhBAi+bTdgo4ug+j/wKoBIw+881Heo1DKk+rwhBjUJLETQgiRMNpuQDffBZF3wA6BUkAcIm+hPUegs36GYWSkOkwhBi0ZihVCCJEwuuVRCL8B2GAWglkMxihQaRB9B5ruSHWIQgxq0mMnhBAiIbRVCZF3AQ3kgQ5BfCcQaT3CgtDj2HYFeI9zhmbN4tQFLMQgJImdEEKIhNDWNrArQKeDvRmo6/zAyIsQeQXNGHTubzC8h/VpnEIMZjIUK4QQIkFs50tvp8ukro0FbIL6S7CDnyU/NCGGCEnshBBCJIY5HmwbaO7BSRoC52GHNiQrKiGGFEnshBBCJIgN7OzdqY2fx664AK11QiMSYqgZsIndzTffjFKK7373u6kORQghBEDDPw7wAsvRlRcmJBQhhqoBuXhi8eLF3HPPPcyaNSvVoQghhNgldqCJHcAy7Ggdhiev3a12vAqi74LdAEYueI5CmUUopRLQphCDx4DrsWtububSSy/l73//O7m5uakORwghBGCHlifuYoEftf1Ta43d/C9ouAaa/wQt90Pz7dBwLbrln2gdT1y7QgwCA67H7tprr+X000/npJNO4te//vU+j41EIkQikbbvA4FAssMTQoihqfmXibtW/F3s2h9CrAzYDARwPq4mgCsddBTsegg9hFZpqHQZvhVilwGV2D322GN88sknLF68uFvH33zzzSxYsCDJUQkhhMDalMiLQezZvW6LA2uc/+Fuvc2A5sew087AMNIT2L4QA9eAGYotLy/nO9/5Dg899BA+n69b5/zkJz+hsbGx7au8vDzJUQohhEi+WOtXBPRKaPxFqgMSot9QeoCsLX/mmWc499xzMU2z7TbLslBKYRgGkUik3X2dCQQCZGdn09jYSFZWVrJDFkKIIcOuOB7YnqLWFWT+FiP9rBS1L0Ry9SR/GTBDsSeeeCIrVqxod9tVV13FlClT+NGPfrTfpE4IIUQSGRPBTlVip6H5byCJnRADJ7HLzMxkxowZ7W5LT08nPz+/w+1CCCH6mOl36hOnii7DtsIYZvem6ggxWA2YOXZCCCH6MXdRigPYNe9OiKFtwPTYdWbhwoWpDkEIIQSA7wII3pfaGOJxkFk5YoiTHjshhBAHzPCMB0amNojgTaltX4h+QBI7IYQQieE9ObXtxz5ObftC9AOS2AkhhEgMXdeDg/P2f0iP20/l6g0h+gdJ7IQQQiSGbuz+sVk3AKMS277KTOz1hBiAJLETQgiRGKoH23rFNkLunxPbvr0tsdcTYgCSxE4IIURi6JbuHxtah+GdAQxLYAA9aF+IQUoSOyGEEAfMjtdDbE0PzvjE+V/Wi0mJR4ihShI7IYQQBy62EKjvwQm1ABj+7GREI8SQJYmdEEKIAxfbBERTHQW2FUl1CEKklCR2QgghDpx9IEmdSlgYVB+BHXwtcdcTYoCRxE4IIUQChHp/quu7CYsCQhC4Frvpvwm8phADhyR2QgghDpxy9/AE7+5T8/9fYmMBaPkettWTgslCDA6S2AkhhDhwrrH06CPFc2rbP5VyAT1NDLuh+lK07EYhhhhJ7IQQQhw47wn0aJuwjK/udUMC59m12Yhu+kcSritE/yWJnRBCiANmuIrBNaX7J5gj2v6ptUXSVtQG/4jd8ihah5NzfSH6GUnshBBCJIYOdP/Y6ot2nxZZmoRgdolD05/QgVsluRNDgiR2QgghEsOu6sHB63b/M74+4aG0Z0JkITr0QpLbESL1JLETQgiRGCqjR4fb4R3OP8zhSQhmT27AhvCraB1PcltCpJYkdkIIIRIj7Qs9Oz78oPN/z3GJj6WdHWAHwdoBuiXJbQmRWpLYCSGESIz0KwGz+8dbzhCsYbrAPCYpIe3WCNYGtJ2M1bdC9B+S2AkhhEgIwzAh8+7un2CO2f3vvB6c12s21JyL1roP2hIiNSSxE0IIkTBG+nxQB3XvYPOw3eeZXsCVlJjaK0eHlvRBO0KkhiR2QgghEsszqXvHtTzc/nvX0YmPpTOBG/umnVZa22hrBzq+CW3LNmciufrizyMhhBBDSWxtNw/8tP233ssh/nbCw+loPbYdxTA8SW9Jx1ahIwshXgY6BsqP9sxAeU9EmYVJb18MPdJjJ4QQIrG6XQjY2n2KtqHla8mJpzO1tyW9CR1djm75F8TXgsoBcyQoN0TeQQf/ibZqkh6DGHoksRNCCJFY7hndPHD33rI6sgawkxJOp6wHsVseT9rltY6gwy+DjoA5HowMUB4w8sCcCPHN6Mg7SWtfDF2S2AkhhEiszGu6eWDO7n82Ji/J6lLz77Dj1cm5dnwD2DvALO54nzJB5UFsGdpuTk77YsiSxE4IIURCGe5SoDvz19Zjx1oTG70yiRF1QTdA6OnkXNtuBm05vXSdUenOkLUUTBYJJomdEEKIhLKtaiDavYNrr3T+7y5JVjj7FvswOdc10gDDWTDRqZCT9Cl/ctoXQ5YkdkIIIRKr5dUeHNy6MtZ7VFJC2a/oSuzwwsQvZHBNdPbAtSs63qdtsGvBPRNlZCa2XTHkSWInhBAiwQI9P8VzfOLD6JY6aPg6uu5b2KFnsO3ELOBQKg3lPQnQEN/iLKLQGuwmsDaAOQLlPTYhbQmxJ6ljJ4QQIrHcxwB/7PbhdnQd2Kks/WGB9TE0fgxcj40L1AhI/xYq/WyU6uX+sp4jUMpER/4H8R2AU8cO9yyU71SUOSKRD0IIAJQeQpvmBQIBsrOzaWxsJCsrK9XhCCHEoGVXdHP3CQAKIPMGaPpussI5AH5I+xoq8wqUkd6rK2gdBWur02unssAc1ftkUQxJPclfZChWCCFE4mX8ugcH10B0J9Afk50ghP6IrjoLO/xmr66glAflmoByT0e5SiSpE0kliZ0QQoiEMzK+2LMTIk8DvesR6xvl0HANdliKCov+TRI7IYQQ/UA5qKJUB7F/Dd/AjkdSHYUQXZLETgghRJL0pIRJGFRh0iJJnAjUfDnVQQjRJUnshBBCJEf+n3pwsAbdzaLGKfcRthVKdRBCdEoSOyGEEElhuHOBvO6foOuSFkvCVf+/VEcgRKcksRNCCJFEPUjsurW/bH/xUaoDEKJTktgJIYRIooweHCsfSUIcqAHzW3T33Xcza9YssrKyyMrKYs6cObz00kupDksIIcS+qJ4Ug1+VtDCSwY4sSXUIQnQwYBK7UaNGccstt7BkyRKWLFnCCSecwNlnn83KlStTHZoQQoiuuGf08IQBVLy38fZURyBEBwN6S7G8vDx++9vf8uUvd2/puWwpJoQQfcuOtUDtIT04QwED52PJKFqX6hDEENCT/MXVRzEllGVZPPHEE7S0tDBnzpwuj4tEIkQiuwtJBgKBvghPCCFEK8Odjk0hUJXqUJLCDn6C4T801WEI0WbADMUCrFixgoyMDLxeL9dccw1PP/0006ZN6/L4m2++mezs7LavkpKSPoxWCCEE0MPCw2lJCyMpAt9PdQRCtDOghmKj0Shbt26loaGBJ598knvvvZe33nqry+Susx67kpISGYoVQog+ZFceA7q7PXZ+IJjMcBLMxChaneogxCDXk6HYAZXY7e2kk05i/Pjx/O1vf+vW8TLHTggh+p5ddRrYG7t59MCaYwcKo2htqoMQg1xP8pcBNRS7N611ux45IYQQ/ZDv7B4cPJCSOhh48YrBbsAsnvjpT3/KaaedRklJCU1NTTz22GMsXLiQl19+OdWhCSGE2Bf3wQy8nrjus+0ohjGQds0Qg9mASewqKyu5/PLL2blzJ9nZ2cyaNYuXX36Zk08+OdWhCSGE2Bd7E5ALdHcv2EygKXnxJFq4DPyTUh2FEMAASuz+8Y9/pDoEIYQQvRIHZYL2ANFuHD+AkjqAwNnY7o8x3P5URyLEwJ5jJ4QQYgBwTQHlpXtJ3UBkQeCHqQ5CCEASOyGEEMnmPhRcg3yoMvZOqiMQApDETgghRJIZhgsyrgUGc5mpMLYluxuJ1JPETgghRNIZnpmQ8ZNUh5FcVm2qIxBCEjshhBB9w8j4AuBOdRjJE/8s1REIIYmdEEKIPuQbrHurGmBLj51IPUnshBBC9B1PTqojSB57gJVpEYOSJHZCCCH6jjE81REkiQ06N9VBCCGJnRBCiD7kPjLVESRP6C5sO5zqKMQQJ4mdEEKIPmOYLjAvTHUYSVIDDXemOggxxEliJ4QQom/l/xIwUx1FckT/hh18NdVRiCFMEjshhBB9yjBcYP4y1WEkT+Bn2LE1qY5CDFGS2AkhhOh71r2pjiCJGqHlP6kOQgxRktgJIYRIgR2pDiC5wv9NdQRiiJLETgghRArkpTqAJKvFtkOpDkIMQZLYCSGE6Huu36Y6guSLbUh1BGIIksROCCFEn1P5R6U6hOSLbUl1BGIIksROCCFEn1NKASWpDiO5Wl5IdQRiCJLETgghRGrk/jvVESSX/iDVEYghSBI7IYQQKWF4C8DzhVSHkURBtLZSHYQYYiSxE0IIkTppZ3bzQHdSw0gWbVWkOgQxxEhiJ4QQInVUd7cWiyU1jKTRkVRHIIYYSeyEEEKkjpGT6giSbLDX6xP9jSR2QgghUsc1LtURJFfk7VRHIIYYSeyEEEKkjGG4gfRUh5E84efb/qntZrTdgNZx7EgZdssb2JHKFAYnBiNXqgMQQggx1I0E1qU6iOSIv4sdXgEtv4PYJ0DHOXc2gO86jJxr+jo6MQhJj50QQohOabsZbVWj7WByGzJHJff6KWVBw/kQW0RnSV2b8B+wq37QZ1GJwUt67IQQQrSjrR3oyLsQWwE6BioN7TkU5Z2LMpKwGMB/JDS9mfjr9hu6e4fZz2FHf4bhyU1uOGJQkx47IYQQbXR8C7rlHxBZCChQWaCjEH4J3fIA2q5LfKPezwPexF93IKo7NdURiAFOEjshhBAAaG2jw/8FqwrMSWAUgJEB5nAwJ0B8Azr8v4S3a7iGQ+4/E37dgak+1QGIAU4SOyGEEA5rK8Q3gTEC1F4fD8oFqgBiy9B2Y8KbNryHJvyaA5Vd91qqQxADmCR2QgghHHajs1OCkdH5/UYG6KBzXFLI3DIAot9JdQRiAJPETgghhEN5AMOZU9cZHQXcoJI0H849JznXHXDiqQ5ADGCS2AkhhHC4xoJZBHZVx/u0dm53jQOjMDnt++Ym57pCDCGS2AkhhABAKR/KOx+Ig7UddGvPkY6CVQYqA+Wdh1IqOQGknQF4knNtIYYIqWMnhBBiN89RKGx05A0nmUM7CynMYlTaaSj35KQ1bRhp2K5TIf5c0toYGKamOgAxgEliJ4QQoo1SCrxzwX0QxDeADoGRBa4JYDej45tBpYExPDk9d57JMsXM8/VURyAGMEnshBBCdKCMDPAcDIC2KtDB/0BsJegwKLcz1857PMo9KcEt+xJ8vQEo+gtAChWL3pHETgghRJe0VYFuecCpcWcMByPPKYkS+wwd3wrpl6Lc0xLXoFuGIaEh1QGIAUwWTwghhOiSjrzlJHXmRDBynZIoRqazEwUt6PDLaB1LWHvKd1jCriXEUCSJnRBCiE5puxFiK8AYBspsf6dSYBRDvBzimxPWpjNvTwaT7JZn0dpKdRhiABowid3NN9/M4YcfTmZmJoWFhZxzzjmsXbs21WEJIcTgpZtb59T5O79f+YC4c1wiZT2R2OsNRE0/RDf+QZI70WMDJrF76623uPbaa/nggw947bXXiMfjfO5zn6OlpSXVoQkhxOCk0gCvk9x1RkedUigqLaHNGv7pCb3egBX+OzqyONVRiAFmwPR3v/zyy+2+v//++yksLOTjjz/muOOOS1FUQggxiKlccE+B6Iegcpzh1z1ZO8EsBtf4JDReDOxIwnUHmJZHwXdUqqMQA8iASez21tjobEKdl5fX5TGRSIRIJNL2fSAQSHpcQggxWDg17eahrc1gbQBjBKh0IAJWBSgXyncSSiVht4is/0LgkMRfd6CJLUJrC7X3HEchujBghmL3pLXmuuuu45hjjmHGjBldHnfzzTeTnZ3d9lVSUtKHUQohxMCnXKNR/sudMiS6Hqz1Tk+dqxjlvxjchyalXcOfDkhiBy0M0I9qkSJKa61THURPXXvttfz3v//l3XffZdSoUV0e11mPXUlJCY2NjWRlZfVFqEIIMShobYO1DXSjM6fOHINS7iS3GUFXHoWT3AxVPij8GMNI7nMt+rdAIEB2dna38pcBNxT7rW99i+eee4633357n0kdgNfrxev19lFkQggxeCllgGt0H7fpRaddAqG/92m7/UvYKTnjTU7PqBh8Bkz/rtaab37zmzz11FO8+eabjB07NtUhCSGESLZ4eaojSL36Xzs9pkJ0w4BJ7K699loeeughHnnkETIzM6moqKCiooJQKJTq0IQQQiSB1hGIvZXqMPqBz9CR91IdhBggBswcO7X3MvtW999/P1deeWW3rtGTMWohhBCppXUIXXlQqsPoJ7IxiqSm3VA1KOfYDZD8UwghRML4Uh1AP9KIbQcxjC52ARGi1YAZihVCCDG0OCM1ksi0CS1KdQRiAJDETgghRP/l/VGqI+g/7HWpjkAMAJLYCSGE6L+yL0h1BP2HkZvqCMQAIImdEEKIfsswXJD7VKrD6B8sqQIh9m/ALJ4QQggxNClXAZrhQGWqQ0mt4P3ojLPBbgLlQ+s4RN4C3QBGDnhPwDCLUh2lSDFJ7IQQQvRbWtvo0NPgmQHRIZ7YUYGuOqqT2zNBeaDlEey0s8H/ZQxDBuSGKnnlhRBC9F/WZohvAHM0uM9KdTT9VBPoWrC2QPBhCD2a6oBECkliJ4QQov+yqkBHwEgHIz/V0fRzEbB3QOg5bDuY6mBEikhiJ4QQov9SJqBBa3ClpzqagSG+HGIfpzoKkSKS2AkhhOi/zNGgspwFAqKbbIg2pToIkSKyeEIIIURKaW1DfC06+glY5c5CANcslOcQMIaD5xBn9Sdu4FLg4RRHPAC0/BGdcSpKSf/NUCOJnRBCiJTR2kaHX4LIm6BjoNKBOMQ3omMfofyXonxnoHUYYsvBG4bIIcDSVIfez21BV85DqwxQ2eDKBddY8J6I8hwiCd8gJomdEEKI1ImtgMjrTvJh5u2+XdtgbUSHnkBlfBvlvxSsoyG+Hu0NQwAkudufStCVoIEoEM2A8Kto78nozO87xZ/FoCOvqhBCiJTQWqOjiwEbjLz2dyoDzDHO0Gx8Dco9C1wTwDUBBdh6GDRdnYqwB7BmsBWE/wtmIWRcBbT2mmoLw3CnOD6RCJLYCSGESJFY65y67M7vVp7WnrtKZ3rdnnf5j0bL+oBeaAIdhZaHsCNbIPYKUAuAjQfcp0LObzBMb2rDFL0mg+xCCCFSRDlf2t7HMZrOPqqUMsB1abICG+QioMsh9gi7kjpHFGLPQfVcbCuSquDEAZLETgghREoo5Qb3NKeUidYdD7BbQHnBNabz8/N/kdwAh6wAVF+U6iBEL0liJ4QQImWU53CnTp1d3r7nToec21xTwBzb+blKATJkmBwr0Z0l26Lfk8ROCCFEyijXWJT/AlAZYK2H+HqIrwV7J7gPQvnPRylzH1eY2GexDjW6WlYdD0SyeEIIIURKKc8hznBrbCXaqgZcKPcEcE10hmv3Je82qPt8n8Q55NiXAytTHYXoIUnshBBCpJwy8sB7LKqH5xmeCdikAy3JCGuIi2HHqjDchakORPSADMUKIYQY2ApeSnUEg1ftMdgVN6c6CtEDktgJIYRIOG03oKNL0JH30LGVaB1NWluGqwjcZybt+uJ+7IovpToI0U0yFCuEEIOMtoMQX4mObwZslDkK3NNRRm7y29YWOvwmRN8Bu965URlgjgLfGSj31OQ0nP0jqHkdCCXn+kPeIuzIKgzvtFQHIvZDEjshhBhEtLUdHXwU4lvYVQBYEwdzOKSdj3In94NZh/8H4edBZYI5DpQJOgLWdnTwEUi/GuXqvHzJgTBchdgUAOUJv7ZoVX8Oevja1jIzor+SoVghhBgktA6hg49BvAzM0ta9VceDORHsBnTw32irInnt2wGnp05lOonkrjIlygvGWLDr0ZH3kta+JHXJp6t/luoQxH70KLELhUK8++67rFq1qsN94XCYBx98MGGBCSGE6KHYKqenzhwLe5YJUQYYY8CuQUeTWJssvgHsOjAKOt6nlHN7fA3abkx401JMt4/Y/0l1BGI/up3YrVu3jqlTp3Lccccxc+ZM5s+fz86dO9vub2xs5KqrrkpKkEIIMZhpO4i2atD2gZXs0PEtgG6f1O2iFKh0iK8+oDb2HUDrAokuCwp7QMd3H5dAzvCgzC7qC7ZVl+oQxD50O7H70Y9+xMyZM6mqqmLt2rVkZWUxd+5ctm7dmsz4hBBi0NJWNXbwGXTTbeim36GbfosdfBptVfXyitZ+7je6ccwBMHIAE3S48/t1ExgZYGQmp333ccm5bsplpDqA9iJvpzoCsQ/dTuzef/99brrpJgoKCpgwYQLPPfccp512GsceeyybNm1KZoxCCDEgaa3R8W3o8OvYwWfR4TfQ1g7ndqsC3XIfRF51erFUlvP/yGvolvt6NRdOmaMADbqT5E1rJ7EyJxz4A+uKazy4RoO93WmvXftR0I3gPhylfMlpP+s7ybluqmXcluoI2rPjqY5A7EO3+61DoRAuV/vD77zzTgzDYN68eTzyyCMJD04IIQYqrePo8EsQec9JqFBobAhngecYsGvA2uIsbGgbuswAnQ/WBnToZUj/UrsViFpbzgpT5UGpTt6+3TPAHAF2GRjjnOFX50SwK0BloTyHJu0xK+UG35no4MNgrQMjH/CCbm5N6qajvHOT1r7hnopNMbAjaW2kRm2qA2iv+afY7skoz9TOfw5FSnX7FZkyZQpLlixh6tT2NYj+8pe/oLXmrLPOSnhwQggxUOnIuxB+DYw8MEY4SZbWoOucciA6Cq6xHeejKROM4RBfA3YlmEVouwmiS9DRj5wkSaWh3bNR3sPb1aZTRiakXYAOPeYkVsoPKNAtTlKXdhbKNSapj1u5J0L61ejoIoh91jr8mgXu41Heo1FGsocVixh0iV10Uaoj6Kj+C+i0S9GZP8IwktQDK3ql24ndueeey6OPPsrll1/e4b477rgD27b561//mtDghBBiINI6BNH3nMTKyNt9h1Kg8sGqdIYr6aJYr8p0evTsRrTyoYP/gtgaZ/GDSgc7AOFn0fEV4L8CZQ7bfap7EhhfR0eXOckhcTDHozwHo1yjk/mwd8fgGo1yjUbbpwNRUBko5emTtkn/AbRc0jdt9ZXoK8AoYFuqI2kv9DBEa9EFf5Ladv2I0kNojXggECA7O5vGxkaysrJSHY4QYpDS8Q3opjuc3RY6S2isaqfem2eOM3Ta4QIhsCtRGd9CRz+ByButxX73uJaOg7URPEeg/FfIB+se7IopgJ3qMBIr7Q4IfTPVUXQu888Y6aemOopBrSf5ixQoFkKIRNMWoIEuyn4YWaDSnASvM1YlmKPQKhNiy0AVdEwQlcsZso2tdoZsxW4ZL6Q6gsSzXgbGpzqKzjV9O9URiD1IYieEEIlmDnNKeuj6zu+3A04RYSMdrK2gY87tOgZWOSgT5T0epQNgNzuJYGdUtjPnzpa6YnsyMiZA3kLAn+pQEsiLUfRSqoPokh1ameoQRCtJ7IQQIsGUkQfug5x5cnsX49UR0LXgOwmVfpkzB8/aAvH1zv+NbJT/AnAfDLhaF1d0VV4ihtMrKCsT92Z4ijGKlkHei6kOJTE8hzv/z/pnauPoSuP/pToC0UreDYQQope0jkLsU2ebLrsajCyU+xBwH4zynYK2a5xtvnA7Q686BMTAfRDK9zlnhah7BsTWta5cTQf3JJRKc65vFoM5EuLl4CrtGIBdBWaRUztOdMrwTMA2FoD9y1SHcmAMZyje8M/BDpTQ//bFlR67/kISOyGE6AWtw+iWxyC2tLVenB+sGnRsDbg/QfkvQ/m/BLHl6NjHYNeDMQLlng2eg9qSN6XSwHNQp20o5QLvsWjrEbB2glHo9OBp20kkiYBn7n4L/mqtnSFbaF2hOsQWWuRfANUDPLHbc1jZNw/CD6UulE5FUh2AaNWrxO5f//oXf/3rX9m8eTOLFi1izJgx3H777YwdO5azzz470TEKIUS/o8NvQ2wxmCWt9eJ23RGF2Gp06L8Y6ZeBdw7KO6f3DbkPQ6WF0eHXnFWwKMAGIxc8Z6K8x3Qdo9ZOYhn90JnLB068nqOcXsOhkuCpQZB0hJeB/wTn3+lfhfATSDIlOtPjOXZ333031113HZ///OdpaGjAspyta3Jycrj99tsTHZ8QQvQ72g5C7ENnGzC11wR95WldrboSbR34alWlFMp7DCrze04vYNrZKP8lqMzrMNJOQqnO38a11ujwa+jggxBfBXicr/gadPBBdPhVelrtSlvV6Mhb6NAL6PDr6PjWHl8jNXwM+Cnl0Qfb/mm4i8A9P3WxdMGOvJvqEAS9+En/y1/+wt///nd+9rOfYZq7l/LPnj2bFStWJDS4vb399tuceeaZFBcXo5TimWeeSWp7QgjRKbsG7Aan16wzKsfZcSGBZUiUkYPyHoXynYTyznUWaOyLtcWpf0cGmOOdWI3c1np4GRB5E6yybrWttcYOL0Q3/wkdfBwdfhkdehrdfAc69JQz17AfMwwT6OK1GjCCaL1HD13WL1IXSleCz6Q6AkEvErvNmzdzyCGHdLjd6/XS0tKSkKC60tLSwkEHHcQdd9yR1HaEEGKflAkYrfXqOmPjDJmmrpdIxz51FmQY+R3vVPmgm9HRT7t3sdhSCD3nzO0zJ4JrEpiTnMUekf+hw28kNvikCKY6gAOnw7v/bfXDYfTIi9jBt1IdxZDX4zl2Y8eOZdmyZYwZ036/wZdeeolp06YlLLDOnHbaaZx22mlJbUMIIfbLKHRWo8Z3OLXo9mbXOGVMzBSuVrUqAG/rwo69KAWkgV2x38tobTn73qKdx7znNVSuM6cw+gHaOxfVVb29fiEdCKU6iAPTuuDG0VUJnFSKQ+AabOMhDN9hqQ5myOpxYvfDH/6Qa6+9lnA4jNaajz76iEcffZSbb76Ze++9Nxkx9lokEiES2d11HQgEUhiNEGKg0dp2Fh3ENwNxMIaBe4qzCtUzF2095uweYRQ4iY7WoAOgG8H7+dQmOsoPah8f/iq2V6LQBbsarG3OY99Fa9ANTo+g1q3HlIEx60CjTh7zJrC+muooDki7/XY9makLZJ8saPwh+N5MdSBDVo8Tu6uuuop4PM71119PMBjkkksuYeTIkfzpT3/ioosuSkaMvXbzzTezYMGCVIchBiGtNRVlVVSX12IYiqKxhRSM7GTISwxY2m5Gh56E2Gegg7QNrZojIe088BwBdiNEFoK1DqdQsOUkVN7jUL6TUhq/ck9FRz9yetT23o5MR0HbKHd3Rllat0dTrXOq7SaIr3HKt+y6T4fRoTfANbGtjEt/Ywyb350Oyn6s/WuolJ9+u2xFb8OOVWG4C1MdyZCkdA+WNMXjcR5++GFOOeUUioqKqKmpwbZtCgv7/sVTSvH0009zzjnndHlMZz12JSUl3dpEV4iuNNYEeP2ht9m4rIxQszPnJT3bz9QjJ3L8xcfgz+yfH2yi+7S20S0POuVMjGJnsYFSTkJkbwOVi8r4KhhFznBmbCXabnQKDrsmgzm6y9WqffcYQuiWeyG2BoyRYGQ4d9jNYG93eh7Tv7LfREzrELrpd2AHwciB6FKnt05lgXKDHXZq5LlGgvcklP+ilD/2rtiV60Gfnuowek0NX9uuRI1dcSTQxbZ1qWZehDHsV6mOYtAIBAJkZ2d3K3/p0W+fy+Xi61//eluyVFBQkJKkrru8Xi9ZWVntvoQ4EKGWMM/d9Qor3l5NRk46pdNLKJ1egjfNy+KXl/HSva8Tj/XHuS+iR6zNEP+sNSHK3D1PTXnAGAt2FTq6xClFYo5A+U7C8H8B5TsF5SrtF4mNUmko/6XgPsTZsza+zvnSdc7OGP5Lu9W7plQauI90hpjjW1qTulwnqdM20OL0YprjnEUW1pakP7beMoZPhPQfpDqMXtP1f2p/g3loagLpDusx7Ob+VkR5aOjxu8+RRx7J0qVLkxGLEP3eusUb2bxiCyWTi8nISXc+2JUiuyCTEeOHs/rDDZSt7G9b/Ygei292ViDu6uXak1JOb1VsuTMHrx9TRh4q/WpUxjecnjT/Rc6/07+8/3Ipe17Hdyy4D3MKJOuIszWaHXASRiMP3JNAZTpD1vH1SXxEB05lfAX8X2fvoc0BIXpX++91f51n16r5Vuy4/KHb13o8x+4b3/gG3//+99m2bRuHHXYY6entV4TNmpW8ybPNzc1s2LCh7fvNmzezbNky8vLyGD1a9koUybd28QZMl4nb6+5wX1q6DytusXFZGRMOHpuC6ETi7O/DyA06jlPWJPW9c/uilAGusc5Xr6+RhvZfAtElrStplbPwwhwBxghQ3l1HOsPV/ZhSBmR+G20cCs3/L9Xh9JhdMR0ybkSlnw/2Z6kOZz8iELwLsr6d6kCGlB4ndhdeeCEA3/727hdKKYXWGqVU204UybBkyRKOP/74tu+vu+46AL70pS/xwAMPJK1dIXYJNoXweLv+S9/ldhFqHuAlFYYQrS2Ib2wt1Gs7Kz9dU1trvykneVOdvU02gjnd2ct1iDAMH7bnYGcXC3NcxwO0DWgwsvs6tB5TykRlzMNuLgZ2pDqcHopB88/QzX9kQGwpFnxQErs+1uN3pc2bNycjjm6ZP3/+ANm+RgxW+cV5bF29vdP7tNbEIjFyh+f0bVBDgNaaHRsr2LB0M4HaZtJz/Iw/qJSSycUYxr57zCzLYuvq7dTuqMcwDUZOKKJwdAHoRnTwcWdxAbt6mQwwi8F3mtMbZW8DY0z7WnB2ADBQnsOT9XD7LeU5DB1b6SzA2HuY2q5oHZadnprgeqPgeagZqPXWalIdQDcFsKNNGP22PMvg0+PEbu/CxEIMJVOPmsiKd1bR3NBCRk77aQgNVY2kZ/uZdNj4FEU3OFmWxcJ/v8/Hry4nGAjh8riIx+J8+MLHzJo3jZOvmI+nk6FxgKqt1bzywELK12wnFo2D1qRlpTH58HGceG4Zft9nThHhXfu96hjYWyH8LHiOh8hrYK0Hle303OlG5zjPseDuxzXbksU9yynzEv0AtM/ZOg0LdC3gQfnO7tHcva5oHXJ29VD+toUoWmuw64AoqCxUZ4Whe8hwZdK/Z0kOEnWfwy58G8Po/PdUJFaPE7sHH3xwn/dfccUVvQ5GiP5u7MzRHHrSLBa/tIxAbRPZw7LQtqahqhGtNcddMIeisf13pfhAtPSNz3jvmY/IKcgiKz8TK27jTXMTDcdY/PJy0rP9zP/iXMD58K/aWkNdRQPhljCLnltM9bY6Rowdji/di9aa5voWPnn1A2INOzj76xMwdyV14Kz0NMaBtRZ0Eyr9K+joYoitAGxwTXZ66twHo5TZecCDmFJu8F8ArtHo6Idg1QAmuGaivHPAdWC7D+n4BnTkA2f1LjaYw8FzFJpMiL7nDJsTA5WB9hyK8h6HOoChX203A9lA4wHFLfanFlruhcyvpzqQIaFHdewAcnPbb6Qci8UIBoN4PB78fj91dXUJDTCRelIHZjALByNsWLqZqi3VoBQjxg1n/EFj8Pi6v0osHotT9lk5NdvrMEyD4glFjJxQ1K7G0mBlxS2W/e8zli9cSc2OOpRSFJUO4+DjZzJ97uT9Dg2K7otGYjxww6OUr9tJJBihdnsdVtzGk+amaGwh/sw0/FlpfPmmSwgHoyx87F02frqFUFOY+ooGanfWM/GwcYyePBLD3P26tDSsom77Bi7+4XRKp3bS82PtACMHI+vHAGgdw1ko4RkSP+PdoXXMGZZWJqjsA35edPQTdPAJp+iz8uEUfI4627PZLWDkgmuMc5/d5KzIdU9F+b/U6x0+7OBrEPghg2If2f7OnAJ5D2CYB96jOxT1JH/pcY9dfX3HYojr16/n61//Oj/84Q97ejnRx7at38lL977Ozk1VaFsDGsNlMmriCE7/2skUlhTs9xo7N1Xy8n1vsn1DBXbcQmvwpnuYeOg4Trny+A5DlION6TI57OSDOGj+dBprmjAMRVZBJqY59Hpwkq1mWy2bVmxh27qdtASCKA0YClUP9ZWNFI7OJ29ELhuWlbHkleWUr9nOsJICho8eRl1FPcpQbFm5DdvSjJ1R0pZ8+DNcVIZhy+qWzhM7TCDWtihMKRlC2ptSbjATs9uKthvQoWfAKncKHhPGGeKN7N7hwi5wyqm4RoM5CnQexFajI4tQaaf0ruHIm0hS10fsOoguht6+VqLbErKka+LEidxyyy1cdtllrFmzJhGXFEkQqG3ihb++SlV5DaMmjcDldl7+WCTG1tXbef7uV7nkp+eSltF10dKG6kaeu+tlKrfUUDx+OB6fB601wUCIFW+vJh6zOP97Z2C6Bn+S43K7yB+Ru/8DRa/Yts3KRWtZ8+F6Qi0RDENhmCZuj4nhMonH4uzYWEU8brH+401sXbON0mklbT97tqXxZ6ZhmgYVmyoZPqaA9KzWYVflxzAhGu5iFb9uAnOy9M71ER39FKLLndqByuv0yllVrXMaY4AbsJ3ELrbSmQvpGufMfYwtRvvmo9pKrvSAXZ3gRyI6p0DjJOoi6RI2ZmSaJjt2DLRl40PLmo82UFFWxejJI9uSOgC3103JlJFsX7eT9Z/se9XzqvfXsXNTFaOnjGwbulVKkZ7tZ8T44WxYupktq7Yl9XGIwU9rzbtPf8hL975BsDmMbdvE4xaxSJRgU5hgY5B4PE40HKWhspGta7aRnuVv9wdFerafeDSO1+8lGnGO28WmAMv2kpPX4Gxivye7HpQL5RmoqyUHoNinzpCrSnd2+tAhnF47H87HlA1EnCLIeJzyNDrkbPVmt4Bu6V27e86vHND6e9kdDbjALEl1IENCj38annvuuXbfa63ZuXMnd9xxB3Pnzk1YYCLxNi7bjNfnaTfXaBeX28QwFVtWlTPruK4nQK9ZvJ60DF+n10hL9xGLxNiyahvjZsnqadE7zQ0tLH55KU/8/nmqy2vQ1u7ES7f+17I1VpPz13+TbbPy/TXkF+XhcrvIHZ6N6TIpHF1AzfZaYpEYCkU8trt3rmZbEzlFE5l4SACsdU7PD6azbZYywXuiU89OJJXWUYh+BJFXnOfe1mB7cZI6ExSgDcAC4q1lZ/zOtmh2tfNv5abXu0iowZJoDITdHXaAPbin6fQXPU7szjnnnHbfK6UYNmwYJ5xwAr///e8TFZdIgnjMwjANIsEIkXAMl8skLdPXNtykDIN4dN8FpiPBKC5P1z82hmEQi8YSGrcYGizL4qMXl/LRS0tZ/MpSarfVYdv7X9sVi8SpKKuhuryOyvIacgqyGDtzDHkjcigeN5xtGyoINYeIR+M0VgdoqA7g9Xs4/uIzyC3NQUeXQHyFU17DdTDKOxtc0/vFfq+Djda6tXfNQuOD8NMQea91Xp2rtfc02Prlc3a3QOEMw7a+76jWYT07CioInuNRnW391i297OkTvdN4BqStS3UUg16PEzvblqo/A1VWQSbvPfMRZSu3tiV52QVZjJw4guyCLKKR6H5LdRSNLWTFO6sZRsdJ07ZtY1u2FOgVvbL4pWW8/tDb1GyvpWZbHVbc2tVFt185w7Joqm0mFonT3NjCuiUbmTZnEuMOKiUes6ivasSX6SUejzNtzkQOPmEm42aNcRZGuEah9VmAHpIlTPqKjq1FRxaBtaE1gbOdxRKuKWA0g27GWTCxa6FKCLQHZyhW4fSo2s6/tQW6BlxTUN6ju9W+bTVA9F2Ifua04ypxriH6lF33PkZe914z0Ts9Tux+9atf8YMf/AC/v/3chFAoxG9/+1t+8YtfJCw4kTj1lQ1s/nQLgbpmvGkesvMzseIWtTvqCdQ2kT8il2GjC5h8+L6L604/ejKrP1hHoK6ZrLzdfyVrrancUkNuUTbT1y2CUw8BrxfWroW9i1rPnw81NfBZf9/nsBNXXgkLF0JZWYoDGVxaGlv46KVPCAaClH1WjhXr2daEkZYI/mw/LQ0tpKV7CTaF2LJ6GznDssnMy+Dsb53GtKMmYZgG/sy0DosiBlPvnLYbIfYZ2ioHFMo11umBTEBB317HFF2MDj7p9NYZ+c5wd/RjZ0hVpYOrEOwdzqIIFWrtnQsBQWcenPaDmQ26wVlggQHug1D+L6LMkfts245WQOPXwFrdB49U7Ff0akAWWSZTj9/NFixYQHNzc4fbg8EgCxYsSEhQIvEWv7yU+spGZs6dgsfnJlDXTCwax+UxaawOUL29lhMunkte0b5XeU44ZCxHnHoIjdWNlK/dQWN1gLqKBspWlmO6DE685Fj8ma2raiMRuOGGPnh0YqDbsno7dTsbqNpaQzjY85VzLYEgecOzSctwphZoNFXlNQwvHcbZ157KEaceQmZuBulZ/kG90lXH1qCb/4wOPgKR9yHyHrrlX+jmO9Hx8tTEZNejQ8/jFHie6Gw7ZmQ7c+NUptNrpwGzqLVAdD4Yw4E0nI8oD7gng+coMEc6PW3+K1GZP3CS1n2wgyuhbr4kdf2KjR2XEjPJ1OMeu111nfa2fPly8vKk8GB/1BIIsuqD9eQWZpM3IpeM3HSqymtoqAqgFIw7aEzrytb9/0VvGAbHX3IMReOG8+lbK6ncUoNhKA49cSaz5k1jzLQS2PChc/Cpp8Ijj8APfgAHHZScBxcKQVrX5VnEwBALxwgGgtRXNmLHez7dw4pbhIMRMnLTmXbUJOKWRTQY4wvfO53cwpzEB9wPaasaHXrcqRdmTnB6xQB0HKzN6NBjkP6Nvu+5i60EuxbMiXvd4aZ1dQTYVeCe0VrmpBJU3Jlfp7LALADD76xWdk1EeY8Fz1H77WXVOgKBy0A2Det/ar4ARS+lOopBq9uJXW5ubmuhTsWkSZPaJXeWZdHc3Mw111yTlCBF71WUVfHBC0tYtWgdaRk+WppCFIzMY+Ih49odt/mzrbQ0du+vKNM0mTF3CtOPnky4JYxhGnjTOqkhdf318PHH8KMfwcsvd33BcBgWLIDHHoPt22HYMDjnHPjNbyAnZ/dxpaUwYwZcfTX83//B6tXw3e86CeTxx8PDD8Py5fDgg9DU5Nx2773g98P3vw9PPeVc58wz4S9/gYw9JlzfeSf8+9+wZg20tMC4cXD55fC974FbitMmW1Z+BhoIB8O9Ol9raGkMUlRaSO7wHKrLaykcXUBmbm8n1Q88OrrMSYrMSa2rR1spF5hjIb4Z4iudvV77Mi6rDjBg70TMLIJ4nTOPTjc59evc08E1dncNu4xvolxjnK3LlAvMUSjVvRWwuukthubiiF3lYfqzjdjNz2BknJPqQAalbid2t99+O1prrr76ahYsWEB29u79+TweD6WlpcyZMycpQYr901oTDUexbY3P70UpxfK3VvL6Q29Tt7OBSDBCNBSlqbaJnZsqmXTYOHKGOa9hLBrHMA186T0r8KmU2mcxYzIznaHY73wH3nwTTjihs8CdJO6NN+AnP4Fjj4VPP4Vf/hIWLXK+vHvE9cknTkJ3ww0wdiykpzuJGMBPf+okcw884MyB+8EP4OKLweVyegwffRSWLnWOy8yEP/9593U3boRLLnGu6fE4CeJvfuMkevfd16PnRfRcyZSRFI7O59O3e/mBpJ0fpeIJI4jHLILNIeZ9cU67eo2DXnyNMx+ts6Fm5QKl0PHNqD5O7JThRXeWaJhFztZteifsWoyldWsR2wh4j0e5D3J65oxejAaF7jmQsAewImAA1JRtvgkksUuKbr/rfelLXwJg7NixHH300bilF6Nf0FqzecVWli38jK2rt4PWjBg/nOLxRXz434/RNkw6bByg2bmpiozcdAI1Taz5cD2HnjQLj89DzbZaCkbmMXrqqMQHeM018Kc/Ob12H33U8UPn1VfhlVfgtttg15Z0J58MJSVw4YVO79v/+3+7j6+qglWrYNKk3bctXOj8f9YsuP/+3bevWQO33w7f/jb89re7r71okdO7t2di94c/7P63bTsJZn4+XHUV/P73kLvvuYfiwLjcLk7/6sksfHwR0Xi0x+crU1E4ugBt2+zYUMH0oydz0PEzkhBpf2bhDG12QavWY/qYa3zr/q7NsGdZEuUD13SINQJpEF8HKGfenXc+ynd6rxe1aB0DnZo5hak3UHbTaMCOb8Rw7XvBnui5Hv/WzJs3ry2pC4VCBAKBdl+iby19YwVP/P45Vr67BoWz5dL6jzfzxO+eo2xlOcNK8lFKUVCcRywSo3z1NgK1TWzbsJPFry5n3SebsG2bo886HI/PTdXWaras3kbVtprElLbxeODXv4YlS+Dxxzve/+abzv+vvLL97Rdc4PTGvfFG+9tnzWqf1O3pjDPafz+1tcDs6ad3vL2uDvZcBLR0KZx1lpPMmaYz/HrFFWBZsE7qLvWFqUdO4tATZvboHG+6B1+6l9zCbEZPKSa/OJfTvnIiZ379FHz+XmwxNZC5xjurTvfcSUPbzipSOwg6hjJH931c5jhwzwJ7G9gNu+PTIdCV4JkHWT9A+S9FpV+OyvwOhv8ClHEAu0JY24Ge/4EwOPRh8n5vA8aI9aj5W3p3fmzfOx2lVGlpx8+lAaLH4xTBYJDrr7+exx9/nNra2g73W1YK/iIcoqq31bLw3+9hukzGTCshEo5Su6OOUHOI6m112JZF7c56svIyKV+3Aw140jzEoxa2pakqq8K2bM779ufJKsjkkZue5LN311K7ow4rZpE/Mo/jLz6GY849gqy8zN4HetFF8Lvfwc9+Bued1/6+2lpnqHTYsPa3KwVFRc79exoxout29l684/Hs+/Zw2Jlnt3Wr00M3ebLTu1haCj6f08N47bXOAg2RdEopLvv5+SxbuJJw8/7n2mXkppOe5SerIJNLfvYFDp4/nbQM35DYp7gzyn0wOvKBUzZEDQe9A+Lbnf1VdTOYhWjl21efXkJoqwodXe4MDWODawJ4jgblcfaDtatwehZd4JqESjsP5UrwaIGO4OxGMRTn2PXd/Dr1mLNNn1obRX8ShkN9PbzAEJoq0Yd6/Kz+8Ic/5H//+x933XUXV1xxBXfeeSfbt2/nb3/7G7fccksyYhRdWLdkI4HaZsbOHE19VSMbPtlESyAEaIKBIJFglHf+8wE5hVnEInEKRuZhukxnf83qAMPHDCNnWDYr31vLindWsXHZFsLBSOv2Yibb1+/ksZufZv3Hm7j0hi9QUOwkSFprArVNREJR0rP9uzdW74pScOutzjDoPXvNe8nPh3gcqqvbJ3daQ0UFHH54x2sl2jPPOPP0nnqqfc29ZcsS35bYp8mHT+Dsb57C47c9h97HrhO+DB8lU4oZNbGYky6fxyEnzBjUZUy6Q7lKwH8OuuUpiL3lLD7YVdxXeQEvBP+DBpRndlJi0LHV6NATrStbW8uVxNeB8T74zkZlznMWcWCDUQiu8agkfLhrlb3/g8SBWRZGrYyiT/KjXg+iHmlE9zSxC70PvvlJCW8o6/FQ7PPPP89dd93F+eefj8vl4thjj+WGG27gpptu4uGHH05GjKIL1dtqcXvdhIMR1n+8kVBzmMzcdGLhOFprtNZEQlGqttbQ3NBCfWUj2ta4vW68aR5GjC1keGkhqz9az8blW4hFY+QUZJEzLJvsgkyKSgsxTINV76/ljYfeRmvNtnU7ePovL3LvTx7m/hse5d4fP8zr/3qLxpr9DMOfdJKT2P3qV+2HQE880fn/Qw+1P/7JJ51ka9f9ybQrIdhzkYbW8Pe/J79t0cHVv76Eq2+6BK+/k9WPCg45cQa/euaHfOsvX+E7d/8/Dj1x5pBP6nZRnsPBd6zTO2YUgDnCKSPiPRY8hwIWOvRfp4hxgmm7AR36j1OWxJwE5mgwRzn/1jEIPwvaRnnnorzHotyTk5LUARCrBuqTc20BgHrUec/XPytAH+6DZ5shuEdvYXkMY8R6uLse/lqPOmIzavwG1Bnl8HHrKEjkX9hW6+v03HMwZ45TxSAzc/d86D3deKPzfv3pp850nexsZ0TmuuucDoK1a50qCZmZzsjLbbe1Pz8cdiokHHzw7nPnzIFnn933g21udio0fO1rHe8rK3Om7+yax90P9Pi3qq6ujrFjnaKQWVlZ1NXVAXDMMcfw9a9/PbHRiX3y+NzO7hHb6wgGQuQUZlNX2UBLUxBfupdYNI5CobWNYRq0NAYx3SZKKbLyM8gdkUuwMUigNSkzTQOlFL50H16/p7W2nZ9IMMK6jzfx0UtLWfT8EhqrA+SPyCUjJ51gIMQ7T33I1rU7+MJ3Tye7IKvrgG+9FQ47zFkAMX26c9vJJ8MppziLKwIBmDt396rYQw5xSo4k28knO8OzF1/slGgJh+Huu6FePhhSwTAMLrr+HM685nO89q+3eOfJDwgFQkw7ejKX3PAF8oZIXbpes7aCa6Qzt21vRrGzpVdsJXRzK65ui30GVkVrDb09y60oMEaCtQ4dW574YdfOBP+S/DaGspANzzShD/bCFC/6oiyM71ehX2iGL7b/DFD3N8AED/pXzoiMuq0WddkO9IelkAU0/AZeORQuvRQ+9zmnekEk4iRl8+c786yPOaZ9+1/8Ilx2mZNovfaac2wsBq+/Dt/4hlMR4ZFHnM+VCRN2TwGKRJz51T/4AYwcCdGoc8555zkL7664ovPHm5HhlNm65x6nrT2qgnDXXc7nx9VXJ+KZTYgeJ3bjxo2jrKyMMWPGMG3aNB5//HGOOOIInn/+eXL2rDkmkm7szDF8/OpyanbUYbpNrLhFsDGItjWh5jDasrEB27IJNodwu11UloXJyPHj8blZvWgtOzZV0FDtFCpWyqChtgm3x01mbjqFowtwuU3CaFoaWlj4+HvEQjFKp5e09ZCkpfvIGZZF2cpyFr+0lJMun9d1wIcc4iRPjzyy+zalnKHQG290frF+8xsoKHASuptuat+LlixTpjg9hDfc4PyC5+c7pU+uuw5OOy357SeQ1pqqrTVsXrGVSDBCek46Ew4pbSttM5CkZ/k559rTOOfagfUapJLWlpNc0cWcWGUCylnEkOi2ra2Aa3dh5HbtKmfrsPiGhLfbqdiyvmlnqHqhGRWwsS9ufV85OxP9i2pnOHavxI4MA/2vYjCdzwxd5MI4rRz9ZhDOyYTIs+gfPIyaORNeegmM1oHEz38exo93krP33mt/za9+1Xl/Bmc06NVX4Y47nOk0557r3D5/PrzwglMBYVdil53dvnKCZTmjQvX1TgWFrhI7gG9+05mDff/9Tv1UcDoB7rvP+VzL77h/eqr0OLG76qqrWL58OfPmzeMnP/kJp59+On/5y1+Ix+P8Yc+SESLpxh80hrGzxrDhwbeIxyzi0TjBphDxuIVtOV3ihlJOYfeYTdSKogyDcDDC9vU7iUXjbXtyao1Ta8oCK2oRbg7TUB1orQOmaW5wdgU49KSOw16my3Tm6i1ax9HnHIH/yiu7Xk308MPO1558PrjlFudrX7ran3X+/PYrAXfpKo4bb3S+9nTGGR1X1ULH6z7wwL5jTKFYNMb/HnuP5f9bSUsg6LxOGrKHZXLMeUdx2MmzZMhyENF2E8RWObs6KBe4xqGNsU4ZEd1Fb7PWgHaGahPOcK7dJZtezP7ppVgftTM0qUcDaJ+Cc1rL16QbcGYm6rEAelMUxu3x83VieltSB8DU1vu2tb5GG2KonRXY18zHMPb4+cjIgC98Af72NwgGnSHaXTqrgLB8efs/xF0up7duy14rdp94wknili/fXQMVnM+hfRk3zmn3rruc2qxKOZ0UtbVO0teP9Dix+973vtf27+OPP541a9awZMkSxo8fz0HJ2jZKdCoajuH2uNC2TX1FA7Ztt9s83XQZ7UqWaBu0bRMNxUCx343WY+EYsXAM02UQi8Rpqm0iHrc45MSZZO1V0d+flUZDdSPNDS2794oVfer955aw6Lkl5BXlUDi6AKUUtm1Ts72O1x5ciD8rjWlHdVEqRgwoOvYpOvSss0MDu5I1H7hmgmsqRF4BbXXsPdNNThFj14SEx6TMsWjec7Yw23vunNZOeRPXlIS323kwBU7pF5F4m6PwQQhOz3B+9BpbOwfOyEA9FnCSvp8VtB2u8/b6GfQ6yZsKa+fPgPrWz6G8/2FXzMMoemv3scXFTl3R+vr2iV1nlQ78/o7JmcfjTPHZ5amnnGHcCy5w6qYWFTkJ4N13d68Q/Xe+4/TwvfaaM2x8553OHL1DD93/uX3ogGauhsNhRo8ezejRKaiNNMRFQhGev/sV1ny0gRHji2isaSLc0r5EhNXFnpuWZe37D+u9j4/boJxrbVu3g/od9eSMyMY0TdxeN8NG5ZNTmIXL48Kb5iEei7Pp0y2sX7qZlvoWcgqzmDR7AqOnjmz/F1k/obUm2BRq3UnDNyB7tZobWlj25gqy8jLazXM0DIPCkgLK127nk9eWM+WICf3yNRDdp+Nl6OC/wQ478+h2JW92M8Q+cpI7owSsTc7iBZXWmlg1OKVGPHPBHLPPNnrFPR3MErDKwCzdndxpC+ytYBSiPH30x7/ndIjc1TdtMQHooyHmfkA9GkBpnOHYF5o7HvBEAH7cg2HJ3Naf3yoL2IldMR+jaKFz244dztBsogrEP/SQs7vQv//dfh5oJNK98084wdnW8o47nB7FTz7puPCvH+hxYmdZFjfddBN//etfqaysZN26dYwbN46f//znlJaW8uUvfzkZcYq9rP9kM+s/2UxOYRZrF28ktzCbmh0WkWAnRTlb99lu04Okbu9z7LhNU0MLzU1BXG4XLrdJ+bodeH0eTrzsWNw+N8/e9TKrF63HtiziMYv6qkbUX19j4uxxnPOtzzNq4oh+kTxprVn94XqWL1zJzk2VKAXFE4o4eP4MJs0e3y9i7K7t63fSWB2gZErnE9PzinLZsamSup31FIzsP3NBRM/p6EdgN4I5sf2Hk5EBFDsJXdr5EP2wtbRI65DXrh0d0s44oJ9tHd+Cji4FazNggGsaynMwyhwG/ovQwcda71OtX3Ewi1BpF6DMwl632yOekdDNz+rOFeJcoAWnHl4BUNf6vcYZUh4G6VejMq5AR7dA/akHGPQAYGl4IoAudaN/3/G1VK+1oP7agH6zBaZ0c370BDd6hAv1dBP66zmgdmA3bcIwhjtzn3etlE0EpZxevD1//isq9r8qdk/f/razo1JjIwwf7vT+9TM9Tux+85vf8M9//pPbbruN/7fHVk8zZ87kj3/8oyR2fWTtRxswTIOGqkai4Rj5xXmEWiJEwtGO9Sl7k8jth7Y0trIw0zxOWZVghNUfrOeZv7zE2sUbKSodRmVZFZVl1cQiMay4xbtPfUT5mu2cctUJzP/i0SktJKu15t2nP+SdJz/AtjTZBc5k8/VLNrFp+RbmXziXo844bMAkd1bcQmswjM7jNV0mtmV32YsrBgato868OpXbxZ6wmWBXoAhBxjcgvhHsGsAEVynKLDqw9iPvoUPPtw7pZgA2xNehY4sg7WKUe6LTbmwl2nLq1SlzNLhnoIycA2q7RzyzDuRkMNMg49co7yxQuSilnOc+vgFt1YPyotyTUIbTO66847Cz74HGryYm/v7qzRZUhYV9Qw4c3THZ0pO9cH8j6pFA2yrY/TIU+oZ8jGsr4fId6MuzIXoy/D0fGhr2P/e6J844wxmO/cY34Pzzobwc/u//nML369d37xqXXebsa/72286CO08y5qsemB6PyTz44IPcc889XHrppZjm7g/mWbNmsWbNmoQGJ7rWEgji8bppqArg8bqJRmLOnLnOPrcV9HLLxX2yLJtQUxiXy6RgVB51O+t59+kPyR2eRV1FA+Vrd+DyuMgZnk3ByHyyh2USqGnm3Sc/YMmryxMfUA9sW7eD959dTHpWOqOnjCS7IIvsgixGTx2FL93Hu09/SMXmqpTG2BO5RTmkZfhoaQx2en+gronM3Ayyh+2jHI3ot7SOoXUcZ7uoTubO7aJae8m0jVIup1acdy7Ke9SBJ3XxzU5Sh2qtUzfSGXo1J4Jdiw49gbabUUYGynskhv8iDP8lKO8xfZvUAco1Eehtz3Qu2BGw1qCMvLY/7pTyoNzTMHxzMbyz25K6tjZ98yDnXjCOPbDg96UqntLrqEcCaI+CC4s7PyDfhNPS4fUWqO7BLlTnZWHfPwLqbdQ1FajvboasLPjf/zqWOjkQV13lJIovveSsur31Vvjxj50qCN2VlgZnnunMzbvmmsTFlkA9/rjfvn07EyZ0nHhr2zaxmKxE6it5RTmEgxFQEI/HqdxSRbA51Pke4NpZOJFopsvE7XWhTOfDJNwcpmJzFbFonIpNlbjcLmdbsx11VG2rIdgUpqmhmaa6Fha/vIxoOHV7Oa75cANNtc3EYzGqtlbTVN9M61Re8opyaGkIsmbxwJk3U1RaSOmMEqrKa7Di7d9QI8EIzfUtzDpu2tDbP3UA01qjYyuxmx9AB36DDvwaHXzW2UVCd1FgWEedv+LMgs7vP5B4op84PXXmiL3q1BlglIK1w6ll1w8oZUB6J8Vku6W2dU5izxZfKKUwfMehCn4PniQMzy0No47dAn+pO7Dr/KXOuc7S/W/btzd9fzF6ywRnZLqrY+4egS6fCIf6sHdOhK93nB9n75yI/sFeifepGej/lqA3T0BvnODUlzt6r1qLN97ovDYFewXwwAPtC9/vsnAhfLbXz+SPfgSbNzulSlatgq98Zfd191RW1nkVhGgUXnnFKasycmTH+/uBHg/FTp8+nXfeeYcxY9pPvn3iiSc45JBDEhaY2LcpR05k+VurSMtMo2JzFc2NTnkLr99LpOWAJpd0264EIlobI9jk1M3TtubThauIhCNYUYtQSwRrV/kVDcpQWDGLmp11lE4fxYhxw2moCuDyuBg9dSSjp45s1xOcDNFwlEXPL6Z87Q52bqpEAy6PSW5hNuNmjSEtIw1vmoeabR33Qu6vlFKceOlxNNU1U7aqnPRMP540D8FAiHgsxvS5k5l96sGpDlN0k9YaHX4DIi85uzaobEBD9F3QYSAKKh/27DXSNljl4CpJzupTa6Mz1NuZ1vp42tqe9L1ouy39PGh5FOjpRvNxoBLo3Ye2MnLQ6ZdB9Ilend+pqjjqou2ogI26qdYZmPlW3v7O6ugvdRg3tb6vXbQd/c4YKOzNGsq++YzpV6qrnZ0t7r8fKiudnr5+qsev6C9/+Usuv/xytm/fjm3bPPXUU6xdu5YHH3yQF154IRkxik6MnTmaQ06YwTtPfUiwKYwds3F7XWitcXtdznyq1mQqaTTYrXO7ovHdvW812+vakj7TZTh7frbGoW1NfVUj3qYgj9z0FEVjh5NdkIm2NR6fm4mHjePzXzkRf5Y/KStVbdvmtX+9RfnanWitnaFJBbFInOpttUTDMaYfPZl4zOp8S6t+LH9ELhf84CxWvreWz95dTag5zMhJI5h13FSmzZmEN0166wYMayNEXgXSwbVn70Shk7xZO8HeDroap3x/DHQAzBGotPNQSalTZ7LvN5Rdiwr6B8PIws77I9T9P6C65xdo+QW2rTGyL+7xqcozObFvvYUu9DdzUa1JmdGb5G7PpA7Q38ztZVIHyf1gcdiht1C+4/rPPOf//tcZyh0xwqll189KnOxJad1ZZdd9e+WVV7jpppv4+OOPsW2bQw89lF/84hd87nOfS0aMCRMIBMjOzqaxsZGsrIE/1ygei7P45WXcfs3faKwOoAwDwzQwXc6bqxW3UCiikdg+N1RPGOUMz1pWF3P99uL2uSmZNII5Zx2OYRiEmsNs37CTorGF5A3PoWxlOY01TWTmZzDp0HEce/5RFJYU9OgX3YpbBJtCGKaBPzON7RsqePj//kM4GGHrqm1k5WdimM7zZds2jdUBxs4ajbbhC987g+lHT+7ts5FSWmtsy07pAhXRe3bwSYj8D1yd1B3UGqy14DrUmXphbXMKDrsPRnkOQ5nDkxNT6EUI/9eZX7f376COgrUVlX4VytO/Rm5sKwA114F+u5dXKITcv2J4Z/Ss3brvQfS/vWyzC3slZ/ZP87uX3PX2vH3au9xCoo2H7B+ifMf3n+QuhXqSv3Q7sdu0aRNjx44d0E/wQEvstNbUbK+jdkcdhmkwfEwBbq8Hj8/duiOEc8z/Xfh7Vry9mozcdGKtu0bEY3Fn71dD0VTfgp3s1ZAKDNPA4/M4q2D3U/x41zken5sjzziM0qklaK1Z/8lmylZuJSs/g0gwQjQcIx61QClGTizi1KtP4PgL5+43YYlFY3z61iqWL1xJfWUjhmlQOsNp49OFqyiZXMzKRWtpqGwkIzcDt8d5PuurGtC25sTLjuOC758pvVwiabS2Ib6mtXRIuZOcuWahPIeggw+27rvaxXBgfBN4DsdIv9S5Dirp783aqkA33+3MszNKdi/g0DGnvIlrPCrj6yi1nwr+KaC1ja65BqyFvbxCJuT+GcM7t9tn2LEY1E7vZXv70NMkLSlJHWDMB3vhgV+nSz5wTYesn2N4piWxnYGhJ/lLt/thJ06cyM6dOyksdGrXXHjhhfz5z39m+PDk/HU41DXWBPjfY++x/uON1Gyro6G6kWg0Tv6IXEqnl3DQvOkcNH86WfmZHHriQaz+YAP+LD+RlgihQAif34thGkRCfTMXQimFy2WibRvDNLqX2GlnCHTtRxsZPXkkzfUtVJVXEw1FaawOkJWfRfawbBSKYHOI2u11vPHQO/gz0jj67MO7vGw8Fuflf7zJ0v99hsfjJjM/Aytus+Lt1TRUN6KUwu11M3n2BDYu20x9VYBAJEYkHCUajJCWmcaIccMJNYclsRNJobWNDr/o9MrpaGvpkDjEN6JjH7UetK+Vi1bbtmAqGUveO6HMIvBfiA79B6wN7B6aVeAah/Jf1C+TOnCeIzXsHuza6yH2TC+u0AT112MPexXDTO/WGYbbje27BcIJnov1rTxnc7buDMsmK6kD8B0BoQjoRYm5XgdOLzDh50ASux7p9jvC3h17L774Ii0tsmVLMrQEgjx758t88PzHbFm9nU0rtrBzUxW12+vYuKyMz95dzesPv81//vA89ZUNHH/xXMZMG0n11hpqdtQRCUdorGmkuryWQE1z8nvrcObOxWNOQeKuaql1Riloqm+icks1NdvriEXixGJxQOHPTEO1TsVOS/ehDINoKMrSN1cQag51ec3VH6xn2cKVFI4qoHhCEZm5GeQMy2LMtFEYhklVeQ3hYIS0DB/T506hdMYoZ2RJa0y3i7TMNN75zwc89Kv/sHF52YE9MUJ0JrYCIm+CygLXRGel6a7SIVaFs1WYDjq7NuxNRwHVWtKjbyn3NFTGt1H+i8F7NHiPQ6V/yempM0f0eTw9ZeTfBu7eThmqhuqretZeznm9bGs/vpXnJGm72rmptuNq2WQmdQDBNyH/N0CytomznTmkoRexrSG4WOMA9J+ZrqLN6g/Ws/qD9QTqm6jaUk08Gic929+6B6uicksNLpfJltXbefvJD4hH4xx68iyUadDSECTSEiUe7ftCtM7KV92j+Xym2wUa6ioaaAkEsW0LO27jz25f/HJXj6AyFHU769m5qesacyveWYVhGPiz2u9Zq5Ri3EFj0Lam7LOtgLNCtmJTFabLpGBkPpl5GUw+bDylM0YTqG3ipXtfp76yoftPghD7obV2do/ABmOvUhDKAHM0zqrXdGcXCb3Hh5oOOcOe7ongntqXYe8RYg7Ke0xrnboLnHl9agDtD53xpQM4eRl25RXY4bfRnSXdncn74ADa24d9JXfJTuoAWIKyq8GdBhQBXnbvNmKQsPRCV0Dgdx06l0TXuj0Uq1THORwDeb5df2DbNuVrd7Dmw/UEapvIys9k4qHj+OydVQRqmmhpDKIBT5q3bYJ/WoZBc0MLZSvLmTlvGoueW8LS11ewacUW4pEEFa88ANau1bjd5G3ducKybFwuk1AggsvjIi2945COZdu4fW5sW3eo1ba7fYua7XWkZ3esig6Qke0nvziXYFOY8rU7iISjBOqa8KZ5aWkMUlQ6jNwRuTTVNeNN97J19XZWvr+WY849stuPKZGqtlazctE6Ni7djG3ZjJlewrQ5kyiZ3D/rJ4nuiLbOqcvu/G7lAQzwzAZ7p7P3alsS4XZ2cUi7AKVkmkBvKM9stDkPrLf2f3Bn9AfQVIGOXwzpV6C6KhbdyvDkQdE67IqLgE9612ZXOhmW1XfWoxp3vwcnJ6lz6Lr/gtsDhh/IArsaCOIU0k5gIhZ5Gh05DuVLYvHnQaTbiZ3WmiuvvBKv13kzCYfDXHPNNaSnt59v8NRTTyU2wkEqFo3x6M1P88ELH9NU19y6atNH3ohcWhqCNAda8HjdtDS0YHp2v0xKKUyXi5ZAiLqd9WxdvY2M3HRM08Dl6d0KyFwdpj4Bc2N2XcfZfqd7v9ShphCeNA/xaAwrauFN9+DxuolFYrg8JtGwsxDDilvEo3E8Hhfp2X5yi3LarqG1dhaLuEwMw1nA0VTXSbHK1mNzCrOZdtRkYtEYHzz/MVbMxlfgpai0kLQMHyvfW0NTXRNW3CYSjPD0n18kvziPqUf27dDXuo838uK9b9BQ2Uh6th+lFB88v4RP317FiZccy6EnHci2SSJ1Wns09jmHDmdfVf95EF/rlDdBOcO1rgko1dsyFV3TOtpalNeLMhK0N2e/pMGV4eQevWWVQegJtHs6yntEt04xih7DbnkJmr5zAA13Yq/krq+SOseDYH4B7NaeQjUG9BagPsHttED4VZDErlu6/e7wpS+1776+7LLLEh7MUKG15qH/e5LXHlyIy+MiMzfD2W81FKWyrJrmhiCxSJTC0QXQmiTt2TtqGM5Hw86NVWhbY8XiTqHiLT2v1TRZ13EL7/CYnsy/Ve/nSlyo13ARa/mxfSxrlfNGYrqM1rIbnSd5ylSYLhNta3x+HydfMY8NSzex/K1VNFYFaKhqpCUQJBqJYcdtXG6TYFOII04/BJ/fSyQUYeV7a1nxzmoaqgN4/R5mzJ3CmOklfPiCU4rHMNoPB7Q0BvFnpHHMeUcwYtxwbFuz/uNNjJs5muaGFlZ/sJ5oKIo/24/b46KhOkBTfQvP//UVgD5L7gK1Tbxy//8INoYYO3P0Hq9/AdXltbz56LsMLx3GyAn9f16TaE8pD9o9FSLvgB7WsXSI3ezsLuEa49Sjc890vpJE283oyCKILQa7CZQb7Z6J8sxBuUYlrd3UiTs1/ygGdvT+MtYGiLyO9szu9gIWI/007KbrSXiB32/ldeip09lGkpO6XQ0Vg7ENYlXAOpweu0SzwNrU4bNQdK7bid3999+fzDiGlA3LNvPuUx/g8XnIH7F7jk1apo+WhiAo7ZT5iMXx+NzEwjE8ac4KuFg0jjIULo+LpvomMvMy0ZYNaOLRng3F5uowt/AOGcT4Cp+BplfJ3YV6jXM+cAvvcLU+hWavk6y6vC6suN3pMLFhGLg8LgpG5lE4Op/ZnzuIQ0+ahbY1L/3jTULNYafnr3XhXTxmEWwMsvGTMv7922fxeN1s+nQLHq8bf5afptpmXv/X2+QX55JVkMnW1dsZMbYQr9+L1ppAbTO1O+o47ORZFI8vQinFlMMnsGl5GSjYtm4nkWCE7GFZTq8jGm3bjJ4ymngkzqLnFjPx0LFtpWaSae3iDdTurKd0ekmHN7KCUXls/mwrqxetk8RugFKew9HR5WBvA2Pk7s2cdci5zX0omGOTHoe2m9DBf0FspbOrhMpwFmdE/oeOrwb/pSjX+KTH0bdczuM0NNgunJ0meim4BDKCrauauyntmxD6fe/b7Mxf6toldeD03Om/1CU/uYv8EzK+D/YjYHW9qO3AyZKA7kr+J5ToYMnLywg1hRlW0n6/O4UiPdtPuCVM1BOlrrKR9Cw/kWCUSLB1ZwelcXvduL0uLMuieHwhlWU1BGqbezyloV75eExPbkvKepPc7ZnUATzGZOqVD7ezDznxiIXpcQon2/bunTDcXhfpOeltc+zKVm5j47IyDj1pFv5MPx6fx5mvF7MwXArTNHF7XMSicQK1TSx+eSmmaXDw8TPxpu2usm9ZNltXbWPEhOHkDs9mx4YKrLiz1Vl6jp/DP38IJ15ybFuyNPnw8Sx+6RM2r9jq7Ijh92DFLQyXQXN9C2mZPgpG5WGaJltWbePVfy4kpzCbjJx0xh9cSnpWcoasKsqqcbUOLe9NKWfF8LZ1B9DbIFJKucaB/3x06Dmw1uN8aNk4c+gOQvnP75MyJjryrrO/qzmurXyKc0c+WBvRoRcg49qkDP2milIG2nsCxJYD6UAX++52y2d0vkF314zsr2FHXgR79QG0u4e9d5TINtqSvF7tUNFjAYiVOQuBLIMDG+PeB/cs6a3rpsHz29oPBOqa2LR8C8GmEP7MNMYdNIasvI57K1aV12K6zQ4jMNC6+tPjIrswm6y8TOor6/GkuQm3RNBoXKbzYT9qYjGWZZGVl0U0HKeirOtVovvybzUFNL1K7vZO6u5lRtt58Zjl/BIqsGO2s2K2dcGU2+Ni5KQRpGc5cwNbAkHqKxqo3VlHqCXMkleX4/KY+LQXt8fVtnAEwOWJO4tKtLPwoqq8mlBTGKUUWXmZ5BXnUji6gPqdDVzys/OIReLUVTRgugxGTSqmYGReuzeH7IIsTvvKSdz3s0eo3FLthKhAGQZZ+RlMPnwC8UicVZ+sZceGSqq2VlNYUoDpNskbkcv8Lx7NjGMSvzrRdBnY+1hdbFtadpUY4JTnUHCVQmwl2qoG3Cj3eHBNRCl30tvXOgSxJaBy2id14PwSmCMhXuYUQ3Z3sgPGAKZ8J6Ajb0LkwFes6nATyt+92nZtCv4DVacBWw+s8S5Wv+o9bu+T5C5yP87QdhJXrvrOSt61B5kBl9jddddd/Pa3v2Xnzp1Mnz6d22+/nWOPTe2ESq01H720lEXPLaaxpqlt8UB2QSZzzpzNEZ8/tF0ykZWfgcvtItwS6XT1ZiQUo3B0Pl+97XKWvLKcDcs2O8OSlk32sGwOPn46x55/FB+/upy3Hl9EbmHr6rpe7vDSm+RuX0kdOHXtNBplKHApDNNwRps0ZOVnkpW7O+H1ZfhoqGqkoaqJup31BGqbcHvcRMOxdkkdgMvtwraCRFrChFvCrF2yEY/bjUazY0MFGbkZTDxsLOFghEBtM9OPnsy4WWP2+fiDgSCGy8DtdaFQuDxmaw+jZs1H6wk2hWmqaQIFzY1BXJ5GSqePoqUhyIv/eANfho8JByd22Gz0lJEseWU5sWi8bVeMXWxbE24JMz7BbYq+p4w88B7bwz6fBLEDrfP5cjq/X6XhzEdr6MOg+oYyMtFZP4fmOyH0DHAANVkDx2Pr2zDSz+z2KYbhxs7+FTRe2ft291XSpCdFjBMmuSMIhmdgbu+YCgMqsfv3v//Nd7/7Xe666y7mzp3L3/72N0477TRWrVrF6NGjUxbXp2+v4vWH3saX5mXM1FFOUmDZ1O6s5/WH38Hr93Lw8bv3GZw2ZzIfv/YpwcYgHp8bt9f569yyLELNYaKhCKMmFrNpxVZMt8mk2eMZMbaQ8QeVMnLSCEzT6ak58vTDqCirZuW7q/GmeQg2hdBdLFTYn54kd/tL6tooWmvaKbxpbqLhKIbLIHtY++1QoqEoLrfJsJI8PD4PpsvAijvzXvaeLKttjdYQCUdxuV1k52fhaX3+bMsmUNvEuiWbyCnMbtszd1+a6pt587H3SM/0M+mw8VRsqiSnMBsUVJfXUllWjeEyMN0mGTl+8otyaQkE2bC0jOlHT6a+spGPX13O+INKEzpMMP6QsYyaNILyNTsYNbm4Lbmz4hbb1+9kWEk+U4/q+wK1YhBRHpyPgCjOkORe2kqseDreNwgYZgFk/xI77SKo/wXopb28kgVN38eOfgjpF6Hc07v1XqB8s9G9HQXuTp26lCR3yWNbYQyzf+5s0t8MqNmIf/jDH/jyl7/MV77yFaZOncrtt99OSUkJd999d8piikVjLH55GaZpMKwkv62HyTANho3KxzRNFr+8lFg01nbO1CMnMm3OJDxpHpobg9RVNLBzcxVln5WzrbW22sr31/C/R95ly2flbPhkM+8/u5ilb65ot0DCn5nGOd86jbOuPZXhY4bhS/fiTXM7vWS98G81hXvZnYB+hc+4UK9pd0y3kzpo13to2zYohS/dh9vtclbL2jYtgSChpjB5RbmMmlhMXlEOJVNGEovEcbnNDgtCIqGI8/iUak2Kd/9tYpgGWQWZ1FfUo7XNqEnF+33MG5Zupr6igYJR+aRn+YmGY2xZVc72DTtpqm/GRhMNRfGkecguyMZ0mWTmZhAJRakoqyJvRA7la3fQUHUg83Q6Skv3ccY1n2P01JHs2FDB5hVb2fzZVrau2U7BqHzO+NrJ5A7PSWibYohROc4Qq10DnZUnsqvByIdBt3iiPcMzGVX4AOTcBxT2/kKRx6HuC+jKedjBN/d7uFIeoKTn7fSk+HB3dqgYKOoTvDXbIDZgeuyi0Sgff/wxP/5x+xf3c5/7HO+//36n50QiESKR3cvKA4FAwuOqLKumamsNw0Z2/ouVX5xLdXkNFZur2orKZuVncu63Po/H52b1h+spX72dUEsEt9dFTk42WoMVswjUNjF8zDCKJxQRbAqx9M3PyMrP5PiLjmm7flq6jyNOOxTT7eKBGx6joboRf5afbWu3Ew3HOo1pX/bVc9ejpG4vBaPyMV0muYXZNNU3E2wJo1rj9xVmMe2oSYyZPgrTZXLSpcdRvno7TQ0txCIxtK0xXCbxWJxYNI7L7cLn9+L1O0WF07P8batYndXEFrnDc8jI2f+8l9qd9TRUNbJjQwWBOmcY3eV1E2x0yqwYpgFKMWxkHr50p4ajUgqf30tdRQPF44qcGnvd2Ru3hwpLCrjkZ+excVkZOzZWYFk2RWMKmXDo2KQt2hBDh1IKvHPR8XVgl7WuzvU4PXV2Dehm8J6FMjrOEx5slEpD+Y6BonexK34APNfLK2mgAgLXYMdvw8g6Z9+H5z0PdQd3//K92VFisPTcxV/Etv/Q6YIy0d6ASexqamqwLIvhw4e3u3348OFUVFR0es7NN9/MggULkhpXLBrHilu4PJ0/lS6PC8uyO3zwjxg3nCtuvJDn7nyZSDDaup1VOps/3UI8ZpGe5aepvpmyleXkDs/Gn5lGdn4mK95ZzZhpo9i6Zjs7N1Xh9roYN6uUiYeO5dQvH88Lf3uN+qpGTI+JisZ3FwruwQhtZ8ndhXotmexOFLub1ClTMWpSEd+566t88sYKNizbTO7wHAzTwIpZxCJRcoZnc8Ilx+D2OEOqR515GJVbqnjzsXep2lJLJBRt7YZ3FjRk5mWRV5RNVn4mW1Zto6F6d8Lu9jrlU0pn7P8v4R0bK3jv6Y8oW7kVK2Zjuk1M08Dr95JblEOgpsl53RQYew3rGobCsmwCdU1k5mWQmdeDcgc94E3zMm3OZKbNkfklIvGUawL4L3FWv9rlzlJ2ACMHvGegfMenNL5UMIp+h12xFlh7YBcK/hT2k9gZHj82aUA3yoQcyDZhfZrc9XKyd3dUXY0efr+sjt2PAZPY7bL3C7qvgoU/+clPuO6669q+DwQClJT0out7H3IKs/FnpdFc30JWQSaxSBzbcra+Mk2D5vpm/Jlp5Ow1rwzANA1qd9YzespIikoLaawNEA5G2nqa0rP9BGqbqa9spHB0AdnDsvjsvTU8eOPjgMLr9xBqDrP45WWMnFDEWd88lWgoxhuPvMOWhiBaawyl2oYurR70Ku2d3PUmqQPQlmbr6u18/OannHz5PEqmjGTlu6sJNoXxpLmZNnMSsz93MKOn7N4iy+V2cc63Ps/0uVP45LVP2bJ6O7FojHGzxjD96MlUb6vl/WcXU1RaSF5RDnUVDURDUUy3i+xhmVRvrd3vlluBuiaev/sVWgJBwBnW9fq96NaFCabLdObWaRvDNGmqayavKLftZy0SjpKWkUawOczcc47A55ftncTApNzTwTUB4uvAbmwtjjwRZeSkOrSUMYqex66YyYEVEo5jN/4NI/tr+z4s7dsQunXfx1TFUXfs3s2hVztK7L1DxR316AuzoDCRaUAaTlrRlMBr7ul9dOVR6JzbMXxzktTGwDdgEruCggJM0+zQO1dVVdWhF28Xr9fbtgVasuQWZjN59njeemIRxgaDQE0T2tZ4/R4KRuUTDUc54rRDO50PFQ5GnJ0QMls30N7rjxzDMEDrtiHVxpomKsuqychx6rxtWr6F5oYWlFJsWVnOx699SmFJPqMmjsC2bDZ9ugWgy31V98cZfm3fU9eEu8dFjG1L8+9bnqFiUxVfWnAhR51xGC0NLXh8HjLzMjpNzE2XyZQjJjLliI4LBCrKqvjsndVUbamhcEwBI8Y6r7/Wmu3rKygYlcfk2fueF7Tmww3s3FxF8fjhbFlZTiziDOG63CZev5dQSxg77iR16dl+PGkep85dmgdta4KBEBnZ6UyfM4nZpxzU7eeivrKBle+vZe1HG4hF4xRPGM60Oc7KXRliEKmilDepu1sMSBm/gOafHdg1QndiG17wn4thdrE3cMaFELqdfSaRhS70YyPhou3ob+b2vqetNblTd9Q710toUgeo9P1ulXfg6qHhWuzcf2F4pye5rYFpwCR2Ho+Hww47jNdee41zzz237fbXXnuNs88+O4WRwfDSYQRqm2isDpCWmYbb46K+qpGKsmpGTxvFEacd0ul5bq8bj8/dVnzYn5WGL93nlEHJ8qO1RgMut7MKdsvKclBQt7OBHRsrW+ebmSilsOIWjTUBtK0ZPmZY22T+tqSpFz3jF+o17ZI6cHruLtRrepzcxcJx3nv6I+p3NnDRj8/loPndWzm2t+aGFsrXbMeybNZ9spF1SzdRWJJPZm4G4ZYIeSNyOPXqE8jK3/e8oA1LN+P1eTBNk4ycdOLROKHmMOGWuFN7L26TkZNOWpaP5roWCkbmYcUtKstqsOIWoyYVc/Y3T+OQE2eQlt69lVrb1u3gubteoXJrNemZfky3ybI3V7LyvbUcdeZs5l0wR5I7IfoLdyJGd8LQchO0/BnbexZk/RDDbD/31zAzsP3fgeBt+77UIT70O2MOPBn7Vl4Seup26ash0mZougW8/+qj9gaWAZPYAVx33XVcfvnlzJ49mzlz5nDPPfewdetWrrnmmpTFFGrZNRQ6glGTiqkuryEWjZMzLIvc4dnYlqZ87Q6GjxnW4VyP1820OZN46/FF5I/Ixe1xU1Q6jE2fbsHtdROPxvGmecgZnk1LY5CaHXWYpknlVmcVW1brvC5nu6ymtvpmqz9cT0tjkLTMNOKRGFbc2j3Xrpv2XijRhLstyevt9mOhpjDrl23ihXtexZPmYdpRPSt6WrOjjufufJmta7bjS/MyeuooqrZUU1FWhVKKky4/jhnHTKWgeP9/zcZjcQyXiT/L3/o8xckelkUkGEVrTTgYYeSEIjJy0gnUNjOspAClFFOPmsy0OZOYNW8avrTu9wZHw1Feuu9NanfWM3bGGIzWlcvDRuXTWB1g0XOLKR43nMmHT0BrzY6NFWxdvZ14zCJnWBYTDiklLSOtR8+XEOIAuCYCJonZSaEZIo9AzfvY+f/BcLWfmmNkfQVbByD0131fJlHJWFKSOnC2a/P1Te3D+GJsqxnDTM785oFsQCV2F154IbW1tfzqV79i586dzJgxgxdffJExY/ZdgDaZNi4ro2ZbHaMmFeNym5RMLsaKW84cLcNgx4YKPn1rJYeeNLPT3piD5s9g/ceb2LJ6G4WjCyieUERLIET52u1YUYsR44ZTsbkKZSoy8zII1DpDvW5fx9pSSilsW7f11rk9LkzTcBZ42N1/c+pq9euet/c2uQtUN/Pxa5+SX5zP5MPHt9Xk2x/btnntwbfYumY7Y6aOatt1YczUUbQ0BqneVktmbka3kjqA4vFFbPp0Cy63SVFpIZs/3YLb4yIjJx3duu+uy+MiHo1zxjUnc/RZh7fu3evpVU/jxuVbqNhURfGEorakbpfsYVk0VAf49J3VlEwdyWsPvsWaD9cTbg6DUigUBSV5nHTZcUw6bHCXnhDtabsO7Abnw9Io6pNtxoTDMPOxvZdD5IHEXVSXQe3VMPw/HdvLvg47vgliryauvb6m0sB7JoT+1AeN2RB6FjIu7YO2BpYB9y7xjW98g7KyMiKRCB9//DHHHXdcSuMJ1DaB1m3DpYZh4Pa425K49Bw/jTVNRELRTs/PH5HLOd/6PJNmjydQ00T5mh34/F6mHjGRo889gtmnHMRhn5vFRdefw+TZ44m2XqfdjgzKSeoUTgIUi8bx+Jwev3gs3q1Cvbvsq6RJd+rcdUdzXQv//furlPdgr9MdGyrYsrKcojGFHbbSSs/24/G5Wb5wZbfnE049aiLp2X5qd9QzcuIIiieOIByKUl/VQNXWGmKRGKbLZPapB3Pk6Ydhuky8ad5er8aq2V6Htu0Ou0jskpmXwfb1O3n1gf+x9PUVZOZmUDpjNGNnjKZkSjGNVQH+e89rbN+ws1fti4FFW5XYwUfRgd+jm/6Cbrod3fI3dGxVqkMbUlTmFaAS/MeU/hQ7tLjz+9L/X2Lb6mv2Nsj8Cp0WvE6G0DM9Ho0aCgZUj11/5PF5sLXucnVuLBLH7XO3JX6dGT5mGBf96Bx2bKygsTqAy+OiZHJxh6G30hmj+eC/nxANRrBdBobR+vLtqmiinV0c4rG4U29Ua2LReKd70namO3XqDmRv2T1FmqP8955XufaPX+7W8TXb64iGY/izOh+OzC7IcrYjq2vevcXaPhSPL2LeBUez8N/vsXX1NnKGZeFym1RtrSY928+hJ83i+IuOoWRKcbd7FffFNI1Oa8DuYls2sUiMtYs3MmxUfrsafKbLpHhCEWWflbN84UpGThhxwPGI/ktb1eiWf4JVBkahU19ORyG+Bh3fCukXo9yzUh3mkKBco9D5f4aGX0B8KWAn5sKN34a0RR1uNnwHYeMHgolpp89FMQwvdvbt0NgHSequeotq8Nda7AlJ7A5Q6fRRZOSk01jT1KGkiW1rArUBjvnCUW012rqilGLkhBH7/NCeNmcSxeOL2L5+B8GmEN40D2gnr3N7XcQiceLROJ40j7M3q1JEw1EsS++3tFBPig8nKrn7799f5+u/v6pbCwaU4ey/21UCbVs2ylCYZvd6J5VSHH7qwQwryWfle2soW1mOL93LkacfyoxjpjJqYmKTp+IJRbh9LkLNYdIy2i+20FrTVNdE4ZhhVG2poai0Y/V7pRTZBZms/2Qz0XAUTydD8WJw0JF3nKTOnAiq9Y8K5QGdDlYZOvwKuKa07lwgks1wTcTOux8i/4PG3wNbE3DV2q7v8v8Agr9KQBupYVddhlH4EHbjwcCy5DamDRIzB3JwkcTuAOUX5zFr3jQWPbcEbdtkD8vGMBSRYISdZVUMKyngoHmJWZI9duZoZh4zBYWmalstoaYw3nQPvnQvdTvrcblNXF43aRlews0RZ66f24Vtx/Cle525dtGOvwS92VEiEcldLBgnUNtEzrD997CNnDiira5fdkHHv87qqxoZf3BpjwoFK6UY2zrcuas7P1mFL0umFDP+oFJWfbCeUROK8LbWvbMtm4rNVWTmZTB66kiqttZ0GYPpdhGPxXpdvkb0f9puhtgyUPm7k7pdlAJzJFjl6Nh6cLXOLVbpXf7MaB2CeBkQByMPjGIp7toLhuGDtNMg7TTsqivA/iB5jaVfMKATO+yPsFveAO9oiCxLcmPl0lvXCUnsDpBSiuMvmovLZbJs4Uq2rCpHKYXpMhg9ZSQnXXYcw0bl7/9C3eD2uDn1yycQi8Rwedw0VDcSag5RX9FINBxn+OgCps6ZiOlyUbujnsqyKprqm2moaiQWjeP1eYipOLZlYVk26N4ldbskIrl796kPOeNrn9vvcQXFeUydM4mPXlyK2+NqG5LVWlOzvQ7TZXDoiTN7/aGV7A870zQ57csnttUXjEXjGIaBtjV5I3I46fJ5GIbik9dXEI3E8Hg79vA21TUxanJxW1IoBiHdDDoMKrfz+5UbrFoIPYxGAQaY48B7JLimtv0ca22hI+9C9F2wqgDLqTHmmgJpn0eZndf+FPtnFD6IHd4IDRcAzYm/vunFphQoS/i1+0zTD8F/BUndhaKVrvw9quj6pLYx0Cg9hGYeBgIBsrOzaWxsJCur404QB6q+qpHyNbtLVIyZNqrDRP9ECNQ2sfrD9axdvIH6ykbqdtRRXx3gkBNmtJsPZsUtNn26hZXvr8W2bdxeF+HmSFtJj1wd5j5eIaO1jElPkro97ZkcNuPmak6hXnWvttvBJ03nt6/e2K1jQ80hXr7/f6z+YL2z04TLwIrbZBVkcux5RzL7lIP7fW9EPBanbGV5aymTOPkjcpl42Diy8jKJRmI8+MvH2bmpkpIpI9utnm1pDFKzvY6zvnEKB82XopyDlbYD6KbbABOMvf8g1BBbDfFV4BoPZqlzm10HyotKOwflnQuAHXoVwv91VikawwAX6Cawd4KrFJX+ZZQxwPYK7We0ttGVPX+/bFOwGMPV+WiFXXEBsLz31+4PMv8BTdcC4aQ3pYav7ffv/QeqJ/mLJHaDwDtPfsAbD7/DuFkdy75EQhHefvJDIsEIbo8LpZy5f8GmEOHmMBNiNdzCOzzG5F4ldbtcqNdwEWv5MceyVnX/A6No3DD+teGubh9vWRbla3ZQ9tlWIsEo2cOymHjYOPJHdNHDMcBsWb2N5+96hZrtdWTmZuDyuGhuaEHbNgefOJNTrzoel1s62gczO/hviLwF5iTYs7yJXQ2Rd52hJ+98UHv8HFg7QZmojG8BLnTzH52OEnOv+ZraAms9+M7GSDulDx7N4GaHKqCxl5UZ0n+CkXlV59et+hbYrxxAZP3BGHAfCrGnk99UzkMYviOS304K9SR/kU+IQaB0Rgm+dC/NDS3tVlOCs++q6TKIhqK43CbxmIUVt/D43ETDUdbG87had7+HrSv/VlN4VZf2/Do9LLhjmial00sonZ7YPX/7izFTR3Hhj87h07dXsebD9cRjcUpnlDDruGlMPWqiJHVDgPIei46vA2sDGCNAZQBRiK0CbHBPbZ/UARhFYK2D2Eqn5p3dAOaETi5ugsqG2Mdo34mova8jesRIK8JWr0HDyT0/ObwMupoelnkNNA70xG4LeC8G40KIPE5Sh2Sji2CQJ3Y9Ib/Vg8DIiSOYfvRkPn79U2LRONkFWSgFwaYQlWVVuFwmKEVdRQPastt+vbTWKENRbx9YUrdLb5JDf4afcDCCT+aNtRk2Kp8TLzmW+RcejW3ZuNyuQT/MIHZTZjH4v4QOvwTxDc7wKW7AcHZDMIo7OUkBLrRdhTKG4RS37OKvJuUDHQId6Zggih4zfGOwC5ZBzcE9O/H/t3ff0XGU9/7H3zOzfbVa9WZV996NscGNYjAtQOIEEhIg1B+QQPjdhJJ7MVyKb26AmwvEDs5NDAkhCb+bkAQCCd0OJoALxjbulossWbb6qm6b+f0hIxCSbZXVjnb0fZ2z5+Dd2Wc+u9bBX808z/eJvgp038hXdU9Abxj4+WkDrvmXkP4WuL8O9VcD9QNznuCmgRk3QSVcg2LRlaqqLL5mIXMunkk0HOHg9jIOfFJGQ3WAvFG5NDW0EG5rb2ysaCqqprY3LTbA0M39H0fGsDSa6ptNzTBYaZqG3WGXom4IUmyFKN4bUZK+i5J0M4rvVnDOa7/adsKfhyjgAvX4ZSDjBKunjeb2q4D9vEovPqNoNtq3H+sdvekkDd49L/Q90GBhHIO6u8FeAo7FDNi1pOg2aVT8OfLrmkU43U7Ou2YRpy2ZRvmeI0SjOul5aWz4+0c01ze3L55w2Dp2rIhGokS6aX0ST5n56aRlpeBwnbzHnxBDkaIoYCsAjk87cEzFiOxqL9i+2ArFaAXFhmIfDVp++8ILvbK9PUqn40JgNKM4lqB8cQzRZ4riwFCywOjlzjBNl0DS7u5f82Qnbp/iz4u+DI1JQAMDdy2pESPwOxT/lQM0fmKRK3YWk5qdwsQzxzFlwQTyR+Wy/b1dx5v7tjf5/ZQe/UIH9Tj/JGQUpFMyuZDhU4vxpcomzkKckn0K2Eoguq+9kIP27Wb0AEQPgm0C2EahqMkorsVAFCL7QW9qv+0aPQbRUrCPBccsUz+KJbm/Ftvx1BTa24VYQNvvILSFAW0m3Prv6JHagRs/gcgVO4urOxbA4bQTPb5oQtVUDB2ikc8KO0VTcLoc6IZOqCUcs3On5vgZP2c0297dSWtTGx6fC4/PQ8G4fBwOG750HzMXT5FbjUL0gKL6wXMVRuv/QrgUCANGe0sT+2konstRlONXvx1zUBT38V0sykCPtt+idSxGcS1CUeWXqZhLuhlafgkEYjKcqrqO97PbH5PxzDfQ+1xHoe52yPz1AJ9n8JPCzuL8GT5UTcXhdhAORQi1hTF0o9N8BFVR8Pjc5JRkE6hr5PDOin6f1+bUmHnuFLKKsjB0OLTjcPu2Wk4bmmYjd3g2C6+YS8GYYaceTAgBgKLlgPf/QGRf+61WVNAKQSvo9AuSoijgmAb2ye3HGRFQU1FU67R5GmxUVUX3/wc03NKr9+nhEKr9BNvDJf8IAl+NQbrBRjn+iNHeu5+KfogeDaNqQ3t6j9yKtbjp507BneRC1w30qN5e5Lns7fPajv87oOsG4XAEFCNmq1PdXjcp2e3bq6XmpJA3MoeMYWlEIzqKAjklmbi8MnlbiN5SFA3FPhrFOR/FeWb7QosTXPVWFA1FG4ZiK5KiLg4U19nguKB3b6qZiF7f/RZiqmdq/0MNSgYxL+o+Hbf1TwMwbmKRws7ipp89idEzR+Bw2oiGoxi6gR41MPT2ViefFnqRUITqw7VUl9ei2vr/Y6FpKk6Pk2hUZ++mUhqqAjTVtZCem4bX72Hja1v4/X/+ie3vn2DisBBCJBhFUSD53+j1Ctm259CrLsc40Upm0XOtfzQ7gemksLO4nOIsLr/jItJyU/H63bjczuMFnYY/I5niiYUMG5mD0+1A13U0TSVvRE6/z9vS2MrBT8rY8c9dNDe0kD8mj6Lx+aTlpJCel0bxxALCbWHeeG4tgZrGGHxSIYQwn2pLB9d1vX9jdBtG7cpuXpjY70xDSlQWUMgcO4tqqA6w7+ODtDW14fa5GDmtBH9mcvvK2KhBUloSWQUZuJNcBFuDbP9gD6GWEDklmWQXZfJi6VEi4b7/9hgJRdi5fi+pWX5ySrLIG965WFQUhZySLA58UsbujaXMXDylvx9ZCCEGB1tx394XfgK98tfgvhbVfzMAas4f0StHxyBUEtAUg3HM4gV60PNUlSk+UthZjK7rvP/yRj7460YC1Y0dzUzrqwIYUZ1p50xC+cISepvDjtNpR9NUckuyCbWFSUrzUX+0vs857E47ReMLOHaoipzirG6PUVUVVVWpKZffsIQQFuJaAk339vHNddD6OHrrTyH1VVRnPtjvhvB/9DNUE9jPg3CCblXmOB1C6zn5qmMF7HKFU27FWszmt7bx1m/fxdChaEIBJRMLKRqfjz/dR3VFLXs3dV46bxgGR/YdJTUnheR0X3u/OwWS07zYnX2v+3XdoLWxlUgoSt2xhhMeZ+gGtn6cRwghBhvV5j31QacUhLol7eOlfxscd/R7RCXl3yD5v/o9jilCFeD7/ikO8oH7wrjEGcyksLOQUFuI9X/fjN1hJ2NYGqra/terqiolkwrJKsyk8sAxSrcepOpwDUcPVrF/6yG8KW4uueU8sgszqDtaj9vnxpeWhMN1giX4PRAJRzi8u4LWpjZqymvR9a4roIKtITSHRuFYaXkihLAY7f4YDBJEb/wlAGraLeC4qV+jGbhQPReC1v0etYPbDlBKgJN1bmg53th5aJPCzkKOlB6l+nAN6bmpXV5TFIUxs0aQVZjByGnFeJLd+DOTWfC1uVx5z+WMmz2aaWdPpq05SFNdM1lFmX1ueq6oCqqq4En2oKoKbS0htv9zF+HgZ82PW5vaKN9zhOGTiyieWNDXjyyEEIOSknElkNb/gVqe7fhPNe3/guuuvo8VWg+AknF+f1OZI3AVEDzJARGovX7I7xsr98AsJBKOEo3q2OzdL7W3O2y4k9zM+/Icisbld3l9xrmTaagKsOmNLTTXN2OzadjsWq8XUSgK2Bw23D4XTpcDb4qXcChK+b5K0A0MA+wuG2Nnj2TJdWdjdwztZpJCCOtRFAUj4yWoXgSE+j7QF/afVVOuQ49eA43/DW0/691YkcbPstkvgPArfc81aFVj1K9ASb3V7CCmkcLOQlKy/HiT3TTWNePP8HV5vbG2GU+ym5TM7huVajaNc745n3Gnj+KT93bR1NBMuDVM2e4K2ppO9lvSFyl4fB7CrWFySrIYNiqXQG0TC5bOIRo53lJlZA4FY/PQNNmIXAhhTaotE933CDTeS3+KO71pLWrS/M/G1TRIuRO9wQGtT/RioHoADCME3huh3oqFHRD8bwzjliG7XaUUdhaSnpvKyOnD2fTGVrx+T6crd+FQhNrKOk6/aAb+jBN3oFcUhfzReeSPzkNR4I3f/IPM/HTqjwVorO3hUnkVHG47BWOHUTQ+/3hD5EaKxuczbGRufz+mEEIkDMVzMUa0AVoe7PsgTdejq/8FzmmoWt5nz9uLobUX47Q+gd62AYw3AWs3QzYan0dJ/obZMUwhc+wsZv5X5lA0Pp9DOw5z9GAVDVUBjh6oomxnOcMnF3HGpaf1eKxpZ0/G43PT3NCKZlNJSvOi2U/8I6OoCnaXHV9qEilZfkomFWKz22iqb8ad5CI5vetVRCGEsDJFUSDpyv4P1PgQ1F6P3rAcPVrX/pzWdUrNyTWB8RpWL+oAaPmp2QlMI4WdxaRm+fnKnRdx7rcW4EtLIhqNkpzp47xrF/Hl713Uq+IqMz+dMy+bjSfZTSQUIdwWBpSO/Zs1m4r6+YeiYLNpqIpCqC1EqC1MJByl7mg9404fhaoqNFQHiIQjA/b5hRBisFFVG5DRz1GcYEQg+FcIPIihN6I4xiM33k6k2uwAplGMIbR8JBAI4Pf7aWhoIDnZ+htiR6NRQm1hHC57n+eyVR44xjP3/Y49m0qpO9pAJBghHIqgR3VUTcXQdRRNbf+t1DDa+0M67KRm+xl72iham9tIzU4hqzCDyv3H0KM6/gwfUxZOZOqiCf1qqSKEEIlCb94FjRf3YwQNyAPVAQQh6Q5UzyXt7VCa+9u82JrUHOvsRd6b+kWu2FmYpmm4va5+LVDILspkzKyReJM9aJoKx1uZoNDRm04BbHYNp9eJ0+PE0A1cXhe+tCTGzBxJa1Mbezftx2a34fG5qT1Sz6u/eJO/rnqD0OdaoAghhFWp3jGcvAfbqUSBMtDLQW+D4FsYRhAl6eoYJbQePTw0/32Rwk6clKIoLP7WAmZfOANvipdIMEwkEgXDwNDbr9CpNg2n24mqqtjtdvJGZPN//utqvvGvX6buaD0YUDQ+n5TMZJJSvOQOzyanOIut7+7gk3U7zf6IQggRH8m9WMF6Qm1ANQTXY7StQ1E08P0qBuNaUNsBsxOYQgo7cUpev5evfv8Svvf0TYydPQqn24Fq07A7bdgcNjRVoa25jWg4itvn4pJbz2fKgokc2lFOTUUtOcWZXZadu5Nc2O02tqzZPuSbSQohhgbVswicMVhIAUAtND2K3rYWxTM7RmNajN1tdgJTSGEnesTusDNlwQQeeeWH3PjjbzJq+nCSM3y4vS7sLgf+DB/jTh/FTT/+FouuPJNAbSN1lfUYRnt/vO54/R7qjjV02pFCCCGsTE19ALyPxWCkKESPQfOq9r50vodiMKbF1A/NlbGynEb0isvj5KIbF3PmZbPZ/t5uyvdW4va5yBuejT/Tx96PDrDq+78iEooQqGmitrKevJE5OLtZJBEORnAlOU9Y+AkhhBWpvovR7cOh/rJ+jtQM4YMQfB3V+1X0SDm0roxJRmv4A7Dc7BBxJ4Wd6JOUTD9zvzSr48+H9xzhz0+9StWhalKy/Li8bpoDrdQcqWPLO58wZeFEHK7Ptg7TdZ1AXRPTz50khZ0QYshRXRPQnV+D4O/7MUoUOAaBH6G3vQXuC0FZDi33xCpmwtNbDqF6Cs2OEVdyK1b0WzQa5a3n/0FNRR3Fk4pIy03Fl+qlaHw+JRPyOVZWw55NpR1z6YItQQ7tKCe7KINJ88ebnF4IIUzi+14MBjHa+9uFPoTAI6B/CCTFYFyLCCw1O0HcyRU70W+Hd1VweHcF2cWZ7a1QjlNQGDltOK1NQaoratj38QFsdg3NplE4bhjnfmsBGXlpJiYXQgjzqLY09OQfQeCu/g2k5YHiBL26vcCjh9s/Dgl1ZgeIOynsRL8FapoIByO4va4ur2k2jTGzRnLsUBULls4lKdVLSpafovH5cgtWCDHkqZ7L0Ns+gVBfW5YogAGKAmoa6EdiGU8kICnsLCQaiXJw+2GqyqpBUcgdnk3+6FxUdWDvuNscNhRFIRqJdlushYNhPMluJi8cT0qmf0CzCCFEolGSLsaofRMo78O7DYhug6gdyAfVfsp3DC3KqQ+xGCnsEkB1eQ2fvLeLPRtLiUai5I8dxsS5Yygcl9/RH+5YWTV/++VblO0sJxKOggEOt53hU4o5/9pF+DMGbgu1wrF5pGQlU1tZT2Z+eqfXDMOgtrKe8XNGD2gGIYRIWPaxYB8J4b4Udp8KA/tBj1UoqzjL7ABxJ4XdIFe65SAvP/0atUfq8CZ7UTSFDX/bzCfv7mTB0jmcdsF0mhtaeGnF3ynbXUHeiBxcnvZta1oaW9nxz91EQhGW/sslOJwD85uc1+9l5uKpvPn8P6guryUtNwVVVQmHIhw9UIXX72HmeVO7NCkWQggBiuLEcF0C4bWANGyPqaR5ZieIOynsBrHmhmb+tvotGmubKZlU9FlhVAA1FXWs+X//JKcki6rDtRzefYSicZ3nrXl8bvJH51K65SClHx9g7GmjBizr7Iumoxs6G/62mYM7ylEARVXIKkhn4dfOoHhCwYCdWwghEp5rITT6gIDZSaxDKQTHNLNTxJ0UdoPY7o2lVJXVdLrl+qn0vFT2bzvEJ+/tov5YAIfL3u38NofLgaEb7N92aEALO03TOPPS2UyeN54Dn5QRbA3hS/VSMqkQp7s/G18LIYT1qZoP3XkOBP9Me3860W9GGYS2gmOc2UniKmH62D388MPMnTsXj8dDSkqK2XHi4lhZNQCa1v1fk9fvoWxXBaHWIDb7iWt0zaYSbAkNSMYvSk73MXn+eGadN5Wxp42Sok4IIXoq+U7QJpmdwkIMaHoIwwiaHSSuEuaKXSgUYunSpcyZM4df/OIXZseJC82mdTT17Y4RNdBsGtnFWRzc0f2kW8MwCAXDnRY11FbWsWdjKbWV9TjcDoonFFA8oaDTFb9ga5DDu48QCUVITveRU5J1yjlyNUfq2PnBHo6UHkWzqRRNKGTMzOF4/d5efnIhhBh6VC0LPfUJaF4Frc+ZHcci2jAa/hsl5QdmB4mbhCnsHnjgAQCeeeYZc4PEUf6oXDSbRqgt3Gk7Lmgv2JoDLZx24TSKxhfw8ZpPqD/WQEpW53YiVYdr8GckM2bWCAzD4KO3trHmhXU0VDWi2TXCwTD/UFXGzh7JxTcvxu1zs/mtbXzwyiaqy2vRozour5PiCQUs+Opccoqzus26/Z+7eO3Zd47fFnag6zpb1u5g44hsLrp5Mbkl2QP2PQkhhFWothx0313Q+geg1ew41tD2AiCFnSUEg0GCwc8uwQYCiTUpdfiUYgrHDWP/1kPkj8rrKO6ikSgV+46SnpfKhLljSM9LY84ls1j34gcEaptITvdh6AaBmgAOt4OzrjyTjGHp7N28n9d/9Q6appFRkMbR/VXUHKkj1BZm/9aDVJQeY+biyfzjf9/H7rCTNyIHm12jJdDKjg/2UFtZz9J/uaTLbhFH9h/lb6vfJtwWpmRSYceVvWgkStnOcv666g2u+revdKzWFUIIcWKq6kR3XAih/zU7ikUEMPQGFHVo9FG1dGG3fPnyjit9g0nV4Rq2v7+b/VsOousGRePzGT9ndJerWg6nnYtuWsxfV73Owe2H0aOfNSjKLEjn/GvPImNY+y3WeZfPJqsggy1rPuFI6VFQFCaeOY4pCydQMqkQwzD4+O1thFrD+DNd7Pjnblob23B5Xbi9TvSozoevbGT3+r2UTCwgp+SzK3Nev4fiCQXs33qIzW9u5eyr5tNY20SwNURSiodP1u0iUNNIycTCTrdrNZvGsNF5lO85wt6P9jPxjLED/M0KIYRF+H4ANa8hq2Rjw4i2SmEXD/fff/8pC6/169czc+bMPo1/zz33cOedd3b8ORAIUFBgbtuN3Rv38eov3qSusgGPzw0KHNp+mM1vb2PxtxYyaV7n1TvpualccfdllH58gMN7jqBHdTLz0xk9o/PcNVVVGTd7FGNPG0lbSxBFUXC6HR2FVktjK4d2lpOckUTplkO0tYRIyfajHO/KbXfaaW1uo+pQNXkjcrrkVlWVlEw/H776EbVH6ynbVUEkFMHtc3PsYBWeZHe3c/DsDhuGblC5/6gUdkII0UOqPQU97SWo/QZw2Ow4iU8/CHT9t82KTC3sbrvtNq644oqTHlNcXNzn8Z1OJ07n4Ln9V1/VwN9Xv01zfWunW5aGYXD0YBWv/3oNWYUZZBdldnqfw2ln7GmjetSuRFGUbvdsNXQdQzdoCjTTVN9EUoq3o6j79H0KoGoqVYdrKBibh6Z1bp/S1tLGnk2ltDa2kVWUSZLfS3NDC2W7KnB5nWTmp3e/ClYBXZemm0II0RuqIxcj+02M6usg+q7ZcRJbaD04Z5udIi5MLewyMjLIyMgwM0Jc7d5QSu2ROoomdL5lqSgK2UWZ7N96iB0f7O5S2MWC2+cmsyCDj9/5BEM3sH2h510kFGl/zqUQbGkjHAyjeT47Ro/q7N9ahmFAyeTCjvYq7iQXBWPz2LOxlPJ9lQyfWNR53HAURVFk8YQQQvSBoigY/n+D2guBiNlxEldwHfhuMztFXCRMH7tDhw6xefNmDh06RDQaZfPmzWzevJmmpiazo/VY+d4j2Bw2VLXrLUtFUXAnuSjbWTEg51ZVlSkLJ6AoEA5FOrVR0XWdxvpmMoalkeT30NYaQv1C77yaI3UEahopGDesS8+8nOJs3EluDn1ymFAo/Nm4UZ3DeyrIHZ7FyOklA/K5hBDC6lRHCXh/wFDc0D5mIhvNThA3CVPY3XfffUybNo1ly5bR1NTEtGnTmDZtGhs2bDA7Wo9pNvWktyQN3UCzDdxfyYQzxjDvy6cD7Qs4mhtaaKxtoqG6keS0JEZOH05SmpeU9GQqS6tobmgh1BaitrKesl3leJJdFI7J6zJucloSI6YWE43q7Nt8gIp9lRzeXcGB7WVkF2aw5Ppzur09LIQQomdU3zWQspqhMk9sIOiNvzM7QlwkTGH3zDPPYBhGl8fChQvNjtZjhWPz0aM60UjX7WJ03aCtJcjwycUDdn5N07jwpnO58MZz8SZ7MAyDpFQvo6YPZ/SsEdQdbaBwXD5fvetSSiYX0ljXxLGyGsBg6sKJDBuV2+0OF5FwlHCwvddeJBShurwWp8fJOVfN58p7Lyd/VO6AfSYhhBgqVNdc1Jy1YD/b7CiJqfkxsxPEhaXbnQw2o2YMJ29ENmW7KsgfnYfN3j6HLRrVKd9zhMyCdMacNnJAM2iaxle+dxE5xZlsemMLgZomwsEwNRV15BRnctbX5zFiSjFzL5lJTUUd4WAYX1oSmk3jl/f+hpqKOrIKP5sXGQ5F2LV+L4d2HCYtN5W84TkEW4M01TVRuuVgl1W+Qggh+kdNX4leOQEIn/JY8XmNZgeIC8U42Z5VFhMIBPD7/TQ0NJCcnGxKhiOlR3n56dc4UnoMAOX4itGsggyWXH82xRPi146loTrAgU/KCAcj+NKSKJlUiMNpP+HxH776Ea//6h0cLgcZw9LQbBp7NpWyZ9N+/Jnte8T6UpOA9oKvbGc5086ZxJduOT9eH0kIIYYEvbUSGuabHSPhqDm7zY7QJ72pX6SwM0FrUyt7Nu2nfO8RDN0gpyQ7IfZU1XWdDX//mA9f2UTt0XrCwQiHdhzGleRkwpwxpGR2bv4YqGmkrSXINQ9e0WW3CiGEEH1nGFGMo3JHpLeGQmEnt2JN4E5yM3n+eCbPH292lF5RVZXTlkxj0ryxHNpRTvneSt78zVqKxufj8nRdHOFLS6LmSB01FXVS2AkhRAwpisaQuSoTMwmzrKBfhsanFDHlTnIzZtZIxp0+Cl9qEobe/XF6VEdRlQFd6SuEEEOX/L+1d2zo4cS8Ytcb8lORgAzDoLq8hh0f7GHnh3sI1JgzITQzP52swgzqKuu7fb22sp60bH+3W5QJIYToJ2WE2QkSjAZNT6LrJ7gaYRFyKzbBBGobeft369izsZTmhhYAktN9TJo3lnlfPr37Lb0GiM1uY8a5U3jp6deoOVJHWk5Ke5d0wyBQ00hzfQuzLzyzfU9cIYQQsWUvgtAes1MkCAVwQ3gbRLaAY6rZgQaMFHYJpLW5jZdWvsaejfvIGJZOZn46hmFQfyzAuy9+SEuglQtvOrfLHq8DadL8cTTVN/P+yxvZv/UQiqpg6AYev5s5l8zk9ItmxC2LEEIMKfbJEHpjYMZWRoHRCFQOzPhxZwC1oNugbY0UdmJw2L1+H/s27yd/zLCOtiSKopCWk4LT42Dbul1MXjAhri1TVFXljEtPY8xpI9n30X6aA624vE6GTy4iuyiz0564QgghYsh1PjQ/PkCDJ0HqCqg7d4DGN0sEWp5D996EqllzRyQp7BLIjg/2oNls3faa8yZ7OHawmr2b98e1sPtURl6arHwVQog4Uu3F6IwE9sZ+cGM72LJjP+6g0AB1t0HG/5gdZEDI4okE0tzQjNPtOOHrml2jtbE1jomEEEKYyj5rgAYOtk9Lw6J3XSJr0YObzU4xIKSwSyBpOSm0NrV1+5phGERCEfwZ5jVeFkIIEWf21AEcXAE8Azi+yeq+b3aCASGFXQIZd/poFFWhpZurcvVVATx+N6NmDDchmRBCCFM4pg/Y0IpeDvZpAza++Q6ihxvMDhFzUtglkJHTSpiyYDxHDxzj6MEq2pqDtDS2UrG3ksbaRmZfMJ2c4iyzYwohhIgX+1xgYBYBGI3/A+6vD8jYg0bLz8xOEHOyeCKB2Ow2zvv2WaQPS2PLmu3UVtahqApZRRlMP2cykxeMl1WoQggxhKiaDd0xH0KvxX7w4MvgvQG00RC16I4NkZ1mJ4g5KewSjMNpZ+4ls5i5eAp1RxtQ1PZ2Jza7/FUKIcSQlHwvVP8TiPUuREFoewm834bAo0B1jMcfBJSBnKNoDrkVm6AcLgfZRZlkFWRIUSeEEEOYassD/38Bsd55yIDIThT3ZeC5FpTcGI8/GBSaHSDmpLATQgghEpzqng+Zb4MyM7YDK14URUHxXQ9pz4LnBsBCPUtDK9Cb/mB2ipiSwk4IIYSwAFXLQM1+HlJfid2gznlA+y5Hqr0YNfn7qDnvA4tidw6zNd2D3rTZ7BQxI4WdEEIIYSGqcyR4nojNYLbuW2ipOU+D4/bYnGMwaPoqeijWcxTNIYWdEEIIYTGK7zxisj7S0E58jtRbwPGV/p9jsKidiR4Om52i36SwE0IIISxGURRIfbf/AwXLTnoONe0RYF7/zzMoGFB3qdkh+k0KOyGEEMKCVGcapL0LpPd9kJYHT3mIkv0/YLul7+cYTPQ96K1rzE7RL1LYCSGEEBalOrIg8zVIuh9sp4FSArh7MULVKY9QFAU14w5wXN7HlINMc2LvRiGFnRBCCGFhquZDTfo6SvovUDKeA1dvCjCj54f67wZ1fK/zDToJvhuFFHZCCCHEEKAoThQtE9wX9uJd/h4fqWopkP4MuL7Z22iDTDN6pM3sEH0mhZ0QQggxhCiOqaBN6tnB7ut7NbaqpaCm/BtkfgDJTwFFvc43KLQ8Y3aCPpPCTnTS2tTKoZ3llO0qp7U5cX9jEUII0T1FsUHKU8AptghTClGSb+jTOVQtFdWzGFIe7dP7TRfda3aCPpNNRgUAobYQ7/91I1ve2U5DdQAUhZTMZKYumshpF0zD7rCbHVEIIUSMqPZc9IxXofE/Ifg7QP/cqwrYFkLaiva2Kf1hSwccQKh/48SbmmN2gj6Twk4QjUR59ZdvsfnNbSSleskpzsIA6o818MZza6mvauD8b5+Fpp24UaUQQojEoto8kHo/hnEvRvgwREpBzQL7BNQY/f9eteWja8UQ3R2T8eJDBc/XzA7RZ3IrVlC65SBb/7GD7OJMMvPTsTvtOJx2sgoyyMxP5+N3PuHQjnKzYwohhBgAiuJAdQxH9ZyD6pocs6Kug/fG2I430NSJqPYCs1P0mRR2gp0f7sWI6nh8XXsbJaV4CbdF2LNxnwnJhBBCJDrFfTHYF5gdo4ds4LvN7BD9IoWdoKE6gMPlOOHrDpedhmprbI4shBAivhRFAe8VoGQC/ZyzN9CUDLAndi8+KewEyelJhNpOvPFxKBjGl+qNYyIhhBCW4jgTbMOBDNoXUwxGGhCE1j9hGPopjx6spLATjJk5EkWF1qau7U2aAy3Y7BqjZ440IZkQQggrUFUnJN0OtiwgCRiMnRZSwPBA28sYkcRtdyKFnWDE1GImzB3LkdKj1BypIxqJEglHqS6v5ejBKibPH0/R+HyzYwohhEhgqnMm+P8T3JeCOgoYTC1F3GArBlsm6HUQWmd2oD6TdicCm93GkuvPxp/hY+u7Ozm85wgA/gwfC782l7mXzEKzSasTIYQQ/aPaR4H/bgwjBEYQo/G30DoYmhi3QmQz4APFBpFKswP1mRR2AgCXx8lZX5/HrCXTqCqrQVEgqzADr1/m1gkhhIgtRXGA4sBQmsyO8jlRoB4MIPiByVn6Tgo70YkvNQlfapLZMYQQQgwFtkE6f1vfjl73GGrq/zU7Sa/JHDshhBBCmMO1xOwEJxZ82uwEfSKFnRBCCCFMoap2cP3A7BgnpAe2mh2h1xKisDtw4ADXXXcdJSUluN1uRowYwbJlywiFEmxTYSGEEEJ0oqZcD+rZZsfoXssjZifotYSYY7dz5050Xefpp59m5MiRbNu2jRtuuIHm5mYefXQwrKYRQgghRF+pWSvRKx8FVpkd5Qv2o+sNqKrf7CA9phiGYZgdoi9+/OMfs3LlSkpLS3v8nkAggN/vp6GhgeTk5AFMJ4QQQoje0iuvBDaaHaMz32Oo3otNjdCb+iUhbsV2p6GhgbS0tJMeEwwGCQQCnR5CCCGEGJzUnN+C7XyzY3TW+H2zE/RKQhZ2+/bt48knn+Tmm28+6XHLly/H7/d3PAoKCuKUUAghhBB9oWY8AWlrzY7xOTp65TfNDtFjphZ2999/P4qinPSxYcOGTu+pqKjg/PPPZ+nSpVx//fUnHf+ee+6hoaGh41FWVjaQH0cIIYQQMaA6coBUs2N8TuI0LDZ1jl11dTXV1dUnPaa4uBiXywW0F3WLFi1i9uzZPPPMM6hq7+pSmWMnhBBCJAa9/mloe8zsGJ9x/weq/3JTTt2b+iVhFk+Ul5ezaNEiZsyYwXPPPYem9X7vUinshBBCiMSg6wE4dgYQNDtKBzVntynntdziiYqKChYuXEhBQQGPPvooVVVVVFZWUlmZuJv0CiGEEOLEVDUZ/C8ymEoVXR88ReaJJEQfu9dee429e/eyd+9e8vPzO72WIBcchRBCCNFLqnskumMzVF0PfGh2HKh+HLLuMTvFSSXMrdhYkFuxQgghRGLSowGoOh84+dz8gZWKmhP/hRSWuxUrhBBCiKFN1ZIh612TU9ShR80sLE8tIW7FJopQW4jdG/ax/Z+7qa8KkJzuY/yc0YyZNQKn22l2PCGEECKhqaqKrvwIjLvMC1H7Y8j8kXnnPwW5FRsjrU2tvPz06+x4fw+aTcPlcdLWEiQaiTJm1gguunkx3mRPTM8phBBCDEV65bXAOvMCpL+Fas8/9XExIrdiTfDenzewbd1OckuyKBiTR2ZBOgVj8sgdns2O9/ew7sXEaW4ohBBCDGZqzmpgsXkB6v8Fve19DCNqXoYTkMIuBpobmtm2bicpGX6cns63XJ1uBylZfj55bzeBmkaTEgohhBDWouY8Bck/BcbF/+TRXdCyAqPtrxiGHv/zn4QUdjFQXVFHU10TyRm+bl/3Z/hoqmuiurw2zsmEEEII61I956Jkv4iSuQYl4+/gWRanMwchXAYtf4DIvjids2eksIsBVW3f19bQu6/add1AURUUVYlzMiGEEMLaFEVF0XJRbCWQ9LU4nTUCigOiBzGCr8XpnD0jhV0MZBVmkJabSt3Rhm5frztaT2p2CjklWXFOJoQQQgwdqmoDvPE5md4I6BDaFp/z9ZAUdjHgdDuZdtZEWpvaaKgOdOyGYRgGgZpGmhtamHrWRNxel8lJhRBCCItTC+N0ompAB6N+UM2zkz52MTLzvKk01jWz6Y0t1FTUodk1opEo7iQXp180g9kXTDc7ohBCCGF99lEQ3BGfcxlBUDPic64eksIuRjSbxtnfmMf4OaPZ+9F+muqb8fq9jJhazLCROSiKzK8TQgghBpznGgi+DMThKpoRAcdsFGXw3ACVwi6GFEUhb0QOeSNyzI4ihBBCDEmKYwKG4zII/SEOZwujOE+Pw3l6bvCUmEIIIYQQ/aQoCqQ8FKezhTCig+tijhR2QgghhLAUVdWAOG35VTcDvbU1PufqASnshBBCCGE9yffF6UQGNJwRp3OdmhR2QgghhLAc1bMQ3P8Sp7M1obfsidO5Tk4KOyGEEEJYkuq/EVL+Cgwb+JMFbh74c/SAFHZCCCGEsCzVNQo1521IeYGBLfDKBnDsnpPCTgghhBCWp7qmQtYroF1jdpQBJYWdEEIIIYYEVXWjZt4Lvh8NyPh65Z0DMm5vSGEnhBBCiCFF9V4GrlsGYOSX0ZvWDsC4PSeFnRBCCCGGHMX/XUh6APjiXq8q4KPPJVKTuYsoZEsxIYQQQgw5iqKC9wpwz8doeRfC7wNBsI0A10XQtgVaftiHkSPo4TCq3R7ryD0ihZ0QQgghhiRFUUAbhuL7GvC1Tq/ptlF9LOyAtlfBfkn/A/aB3IoVQgghhPgCVVXB+fW+vTmyP7ZhekEKOyGEEEKIbigpy0Cd0fs32nJiH6aHpLATQgghhOiGoigomc8fX2TRC54FAxOoB6SwE0IIIYQ4AUVRUJOuhMwtgOPUb9AWoGpyxU4IIYQQYtBSNRdkfQx4T3JUAaQ9Gq9I3ZLCTgghhBCiB1RVQ8neBK4fAO7PvZIErutRsl9G1fxmxQOk3YkQQgghRI8pioKScj1wPYZhdDw3WEhhJ4QQQgjRB4OpoPuU3IoVQgghhLAIKeyEEEIIISxCCjshhBBCCIuQwk4IIYQQwiKksBNCCCGEsAgp7IQQQgghLEIKOyGEEEIIi5DCTgghhBDCIqSwE0IIIYSwCCnshBBCCCEsYkhtKfbpnm6BQMDkJEIIIYQQPfNp3fJpHXMyQ6qwa2xsBKCgoMDkJEIIIYQQvdPY2Ijf7z/pMYrRk/LPInRdp6KiAp/PNyg37v2iQCBAQUEBZWVlJCcnmx3H8uT7jh/5ruNHvuv4ku87fobSd20YBo2NjeTl5aGqJ59FN6Su2KmqSn5+vtkxei05OdnyP7SDiXzf8SPfdfzIdx1f8n3Hz1D5rk91pe5TsnhCCCGEEMIipLATQgghhLAIKewGMafTybJly3A6nWZHGRLk+44f+a7jR77r+JLvO37ku+7ekFo8IYQQQghhZXLFTgghhBDCIqSwE0IIIYSwCCnshBBCCCEsQgq7BHHgwAGuu+46SkpKcLvdjBgxgmXLlhEKhcyOZgkrVqygpKQEl8vFjBkz+Mc//mF2JEtavnw5s2bNwufzkZWVxaWXXsquXbvMjjUkLF++HEVRuOOOO8yOYknl5eVcddVVpKen4/F4mDp1Khs3bjQ7liVFIhH+9V//tePfw+HDh/Pv//7v6LpudrRBYUg1KE5kO3fuRNd1nn76aUaOHMm2bdu44YYbaG5u5tFHHzU7XkL7/e9/zx133MGKFSs444wzePrpp1myZAnbt2+nsLDQ7HiWsmbNGm699VZmzZpFJBLhhz/8IYsXL2b79u14vV6z41nW+vXrWbVqFZMnTzY7iiXV1dVxxhlnsGjRIl599VWysrLYt28fKSkpZkezpB/96Ef87Gc/49lnn2XChAls2LCBa6+9Fr/fz+233252PNPJqtgE9uMf/5iVK1dSWlpqdpSENnv2bKZPn87KlSs7nhs3bhyXXnopy5cvNzGZ9VVVVZGVlcWaNWuYP3++2XEsqampienTp7NixQoeeughpk6dyk9+8hOzY1nK3Xffzbp16+RKf5xcdNFFZGdn84tf/KLjuS9/+ct4PB5+/etfm5hscJBbsQmsoaGBtLQ0s2MktFAoxMaNG1m8eHGn5xcvXsx7771nUqqho6GhAUB+jgfQrbfeyoUXXsg555xjdhTL+stf/sLMmTNZunQpWVlZTJs2jZ///Odmx7KsM888kzfffJPdu3cD8PHHH/Puu+9ywQUXmJxscJBbsQlq3759PPnkkzz22GNmR0lo1dXVRKNRsrOzOz2fnZ1NZWWlSamGBsMwuPPOOznzzDOZOHGi2XEs6Xe/+x2bNm1i/fr1ZkextNLSUlauXMmdd97Jvffey4cffsh3v/tdnE4n3/rWt8yOZzl33XUXDQ0NjB07Fk3TiEajPPzww1x55ZVmRxsU5Iqdye6//34URTnpY8OGDZ3eU1FRwfnnn8/SpUu5/vrrTUpuLYqidPqzYRhdnhOxddttt7FlyxZ++9vfmh3FksrKyrj99tt57rnncLlcZsexNF3XmT59Oo888gjTpk3jpptu4oYbbug0vUPEzu9//3uee+45nn/+eTZt2sSzzz7Lo48+yrPPPmt2tEFBrtiZ7LbbbuOKK6446THFxcUd/11RUcGiRYuYM2cOq1atGuB01peRkYGmaV2uzh07dqzLVTwRO9/5znf4y1/+wtq1a8nPzzc7jiVt3LiRY8eOMWPGjI7notEoa9eu5amnniIYDKJpmokJrSM3N5fx48d3em7cuHH84Q9/MCmRtX3/+9/n7rvv7vi3c9KkSRw8eJDly5dz9dVXm5zOfFLYmSwjI4OMjIweHVteXs6iRYuYMWMGq1evRlXlgmt/ORwOZsyYweuvv85ll13W8fzrr7/Ol770JROTWZNhGHznO9/hxRdf5J133qGkpMTsSJZ19tlns3Xr1k7PXXvttYwdO5a77rpLiroYOuOMM7q07dm9ezdFRUUmJbK2lpaWLv/+aZom7U6Ok8IuQVRUVLBw4UIKCwt59NFHqaqq6ngtJyfHxGSJ78477+Sb3/wmM2fO7LgSeujQIW6++Wazo1nOrbfeyvPPP8+f//xnfD5fx5VSv9+P2+02OZ21+Hy+LnMXvV4v6enpMqcxxr73ve8xd+5cHnnkEb761a/y4YcfsmrVKrmrMkAuvvhiHn74YQoLC5kwYQIfffQRjz/+ON/+9rfNjjY4GCIhrF692gC6fYj+++lPf2oUFRUZDofDmD59urFmzRqzI1nSiX6GV69ebXa0IWHBggXG7bffbnYMS3rppZeMiRMnGk6n0xg7dqyxatUqsyNZViAQMG6//XajsLDQcLlcxvDhw40f/vCHRjAYNDvaoCB97IQQQgghLEImaQkhhBBCWIQUdkIIIYQQFiGFnRBCCCGERUhhJ4QQQghhEVLYCSGEEEJYhBR2QgghhBAWIYWdEEIIIYRFSGEnhBBCCGERUtgJIYQQQliEFHZCCMu45pprUBSly2Pv3r0xGf+ZZ54hJSUlJmP11dq1a7n44ovJy8tDURT+9Kc/mZpHCDG4SGEnhLCU888/nyNHjnR6lJSUmB2ri3A43Kf3NTc3M2XKFJ566qkYJxJCWIEUdkIIS3E6neTk5HR6aJoGwEsvvcSMGTNwuVwMHz6cBx54gEgk0vHexx9/nEmTJuH1eikoKOCWW26hqakJgHfeeYdrr72WhoaGjiuB999/P0C3V85SUlJ45plnADhw4ACKovDCCy+wcOFCXC4Xzz33HACrV69m3LhxuFwuxo4dy4oVK076+ZYsWcJDDz3E5ZdfHoNvSwhhNTazAwghRDz8/e9/56qrruKJJ55g3rx57Nu3jxtvvBGAZcuWAaCqKk888QTFxcXs37+fW265hR/84AesWLGCuXPn8pOf/IT77ruPXbt2AZCUlNSrDHfddRePPfYYq1evxul08vOf/5xly5bx1FNPMW3aND766CNuuOEGvF4vV199dWy/ACHE0GAIIYRFXH311YamaYbX6+14fOUrXzEMwzDmzZtnPPLII52O//Wvf23k5uaecLwXXnjBSE9P7/jz6tWrDb/f3+U4wHjxxRc7Pef3+43Vq1cbhmEY+/fvNwDjJz/5SadjCgoKjOeff77Tcw8++KAxZ86cU33UE55XCDG0yRU7IYSlLFq0iJUrV3b82ev1ArBx40bWr1/Pww8/3PFaNBqlra2NlpYWPB4Pb7/9No888gjbt28nEAgQiURoa2ujubm5Y5z+mDlzZsd/V1VVUVZWxnXXXccNN9zQ8XwkEsHv9/f7XEKIoUkKOyGEpXi9XkaOHNnleV3XeeCBB7qdm+ZyuTh48CAXXHABN998Mw8++CBpaWm8++67XHfddadc6KAoCoZhdHquu/d8vjjUdR2An//858yePbvTcZ/OCRRCiN6Swk4IMSRMnz6dXbt2dVv0AWzYsIFIJMJjjz2GqravK3vhhRc6HeNwOIhGo13em5mZyZEjRzr+vGfPHlpaWk6aJzs7m2HDhlFaWso3vvGN3n4cIYTolhR2Qogh4b777uOiiy6ioKCApUuXoqoqW7ZsYevWrTz00EOMGDGCSCTCk08+ycUXX8y6dev42c9+1mmM4uJimpqaePPNN5kyZQoejwePx8NZZ53FU089xemnn46u69x1113Y7fZTZrr//vv57ne/S3JyMkuWLCEYDLJhwwbq6uq48847u31PU1NTp758+/fvZ/PmzaSlpVFYWNi/L0kIkfjMnuQnhBCxcvXVVxtf+tKXTvj63/72N2Pu3LmG2+02kpOTjdNOO81YtWpVx+uPP/64kZuba7jdbuO8884zfvWrXxmAUVdX13HMzTffbKSnpxuAsWzZMsMwDKO8vNxYvHix4fV6jVGjRhmvvPJKt4snPvrooy6ZfvOb3xhTp041HA6HkZqaasyfP9/44x//eMLP8PbbbxtAl8fVV1/di29KCGFVimF8YWKIEEIIIYRISNKgWAghhBDCIqSwE0IIIYSwCCnshBBCCCEsQgo7IYQQQgiLkMJOCCGEEMIipLATQgghhLAIKeyEEEIIISxCCjshhBBCCIuQwk4IIYQQwiKksBNCCCGEsAgp7IQQQgghLEIKOyGEEEIIi/j/lmo1g7W3hpsAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.cluster import KMeans\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "# Generating random data for demonstration\n",
    "np.random.seed(0)\n",
    "X = (test_predict1 - y_test)\n",
    "\n",
    "k = 2\n",
    "\n",
    "pca = PCA(n_components=2)\n",
    "X = pca.fit_transform(X)\n",
    "\n",
    "kmeans = KMeans(n_clusters=k)\n",
    "\n",
    "kmeans.fit(X)\n",
    "\n",
    "\n",
    "\n",
    "# Getting the cluster centers and labels\n",
    "centroids = kmeans.cluster_centers_\n",
    "# centroids = pca.transform(centroids)\n",
    "labels = kmeans.labels_\n",
    "\n",
    "# Plotting the data points and cluster centers\n",
    "plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', alpha=0.5)\n",
    "plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', c='red', s=200, linewidths=2)\n",
    "plt.text(centroids[0,0]+0.2, centroids[0,1]+0.5, 'Normal', fontsize=12, color='red')\n",
    "plt.text(centroids[1,0]+0.5, centroids[1,1]+0.2, 'Anomaly', fontsize=12, color='red')\n",
    "plt.title('KMeans Clustering')\n",
    "plt.xlabel('Feature 1')\n",
    "plt.ylabel('Feature 2')\n",
    "plt.tight_layout()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k = 60\n",
    "X= test_predict1 - y_test\n",
    "processed_data = []\n",
    "feat_df = pd.DataFrame(columns=[\"mean\",\"std\",])\n",
    "for i in range(0,len(X), 60):\n",
    "    mean = X[i:i+k].mean(axis = 0)\n",
    "    std = X[i:i+k].std(axis = 0)\n",
    "    max = X[i:i+k].max(axis = 0)\n",
    "    min = X[i:i+k].min(axis = 0)\n",
    "    iqr = np.percentile(X[i:i+k], 75, axis=0) - np.percentile(X[i:i+k], 25,axis=0)\n",
    "    data = np.concatenate([mean, std, max, min, iqr])\n",
    "    processed_data.append([data])\n",
    "processed_data = np.concatenate(processed_data,axis=0) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = processed_data\n",
    "\n",
    "kmeans = KMeans(n_clusters=2, algorithm='elkan', max_iter=1000, n_init = 5)\n",
    "\n",
    "kmeans.fit(X)\n",
    "\n",
    "pca = PCA(n_components=2)\n",
    "X = pca.fit_transform(X)\n",
    "\n",
    "\n",
    "# Getting the cluster centers and labels\n",
    "centroids = kmeans.cluster_centers_\n",
    "centroids = pca.transform(centroids)\n",
    "labels = kmeans.labels_\n",
    "\n",
    "# Plotting the data points and cluster centers\n",
    "plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', alpha=0.5)\n",
    "plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', c='red', s=200, linewidths=2)\n",
    "plt.title('KMeans Clustering')\n",
    "plt.xlabel('Feature 1')\n",
    "plt.ylabel('Feature 2')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.mixture import GaussianMixture\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "# Generating random data for demonstration\n",
    "np.random.seed(0)\n",
    "X = processed_data\n",
    "\n",
    "# Creating the GMM instance with desired number of clusters\n",
    "gmm = GaussianMixture(n_components=2, init_params='k-means++')\n",
    "\n",
    "# Fitting the model to the data\n",
    "gmm.fit(X)\n",
    "labels = gmm.predict(X)\n",
    "\n",
    "\n",
    "pca = PCA(n_components=2)\n",
    "X = pca.fit_transform(X)\n",
    "\n",
    "\n",
    "# Getting the cluster labels\n",
    "\n",
    "# Plotting the data points with colors representing different clusters\n",
    "plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', alpha=0.5)\n",
    "plt.title('GMM Clustering')\n",
    "plt.xlabel('Feature 1')\n",
    "plt.ylabel('Feature 2')\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.cluster import KMeans\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "# Generating random data for demonstration\n",
    "np.random.seed(0)\n",
    "X = test_predict1 - y_test \n",
    "\n",
    "kmeans = KMeans(n_clusters=2)\n",
    "\n",
    "kmeans.fit(X)\n",
    "\n",
    "\n",
    "pca = PCA(n_components=2)\n",
    "X = pca.fit_transform(X)\n",
    "\n",
    "\n",
    "\n",
    "# Getting the cluster centers and labels\n",
    "centroids = kmeans.cluster_centers_\n",
    "centroids = pca.transform(centroids)\n",
    "labels = kmeans.labels_\n",
    "\n",
    "# Plotting the data points and cluster centers\n",
    "plt.figure()\n",
    "plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', alpha=0.5)\n",
    "plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', c='red', s=200, linewidths=2)\n",
    "plt.text(centroids[0,0], centroids[0,1], 'Normal', fontsize=12, color='red')\n",
    "plt.text(centroids[1,0], centroids[1,1], 'Anomaly', fontsize=12, color='red')\n",
    "plt.title('KMeans Clustering')\n",
    "plt.xlabel('Feature 1')\n",
    "plt.ylabel('Feature 2')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "329763"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(labels==0)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tensorflow",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}