diff --git "a/LinearRegression.ipynb" "b/LinearRegression.ipynb"
new file mode 100644--- /dev/null
+++ "b/LinearRegression.ipynb"
@@ -0,0 +1,1213 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7f8a8b55-b7c8-4810-9a72-912b8794d04d",
+   "metadata": {},
+   "source": [
+    "# Linear Regression for the prediction of energy consumption data over 48 hours\n",
+    "### 1 - Linear Regression with Energy consumption data and weather data\n",
+    "### 2 - Linear Regression with Energy consumption data and 2 variables 'Lastgang_Moving_Average' and 'Lastgang_First_Difference'\n",
+    "### 3 - Linear Regression with Energy consumption data and 2 variables 'Hour' and 'DayOfWeek'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "38514e31-43e4-4452-9ec5-50f376e5f8d3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Install all required packages with 'conda install NAME' or with pip install NAME'\n",
+    "# pandas\n",
+    "# numpy\n",
+    "# matplotlib\n",
+    "# scikit-learn\n",
+    "# statsmodels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "ca3f47bb-e6ef-4a33-a60d-77c500a9c6ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Import all required libraries\n",
+    "import sys  # Provides access to some variables used or maintained by the interpreter\n",
+    "import pandas as pd # Library for data manipulation and analysis, ideal for working with structured data like tables\n",
+    "import numpy as np # For scientific computing, supports large, multi-dimensional arrays and matrices\n",
+    "import matplotlib.pyplot as plt # For creating static, interactive, and animated visualizations\n",
+    "import matplotlib.dates as mdates # For handling date formatting in plots\n",
+    "from sklearn.preprocessing import MinMaxScaler # For scaling and normalizing features, often useful in data preprocessing\n",
+    "from sklearn.metrics import mean_squared_error, mean_absolute_error # For calculating common statistical metrics to evaluate models\n",
+    "import statsmodels.api as sm # Provides classes and functions for the estimation of many different statistical models\n",
+    "from sklearn.preprocessing import MinMaxScaler #To use MinMaxScaler to normalize and scale continuous numerical data\n",
+    "from pathlib import Path  # Used for filesystem path manipulation in an object-oriented way"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "88b3929e-0b04-4036-b43e-5738f74b2bc9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/sarah/anaconda3/envs/BT2024SARIMAModel/bin/python\n"
+     ]
+    }
+   ],
+   "source": [
+    "#To display the current environment\n",
+    "print(sys.executable)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "ad3b8a68-11be-4cf0-9d33-dfcea476d122",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "First and last rows from dfClimaAll:\n",
+      "   dy  Globalstrahlung_15Min  Sonnenhöhe  ExtraterrestrischeStrahlung  \\\n",
+      "0   1                      0       -65.0                            0   \n",
+      "1   1                      0       -65.0                            0   \n",
+      "2   1                      0       -65.4                            0   \n",
+      "3   1                      0       -65.5                            0   \n",
+      "4   1                      0       -65.2                            0   \n",
+      "\n",
+      "   StundenwertStrahlung  Diffusstrahlung  StrahlungGeneigteFläche  \\\n",
+      "0                     0                0                        0   \n",
+      "1                     0                0                        0   \n",
+      "2                     0                0                        0   \n",
+      "3                     0                0                        0   \n",
+      "4                     0                0                        0   \n",
+      "\n",
+      "   DiffusstrahlungGeneigteFläche  Direktnormalstrahlung  Lufttemperatur  \\\n",
+      "0                              0                      0             2.5   \n",
+      "1                              0                      0             2.5   \n",
+      "2                              0                      0             2.5   \n",
+      "3                              0                      0             2.5   \n",
+      "4                              0                      0             2.4   \n",
+      "\n",
+      "   Windgeschwindigkeit  Schönwetterstrahlung  Taupunkttemperatur  TheorPVProd  \\\n",
+      "0                  1.2                     0                 0.8            0   \n",
+      "1                  1.2                     0                 0.8            0   \n",
+      "2                  1.2                     0                 0.8            0   \n",
+      "3                  1.1                     0                 0.8            0   \n",
+      "4                  1.1                     0                 0.8            0   \n",
+      "\n",
+      "     TimestampWeather  \n",
+      "0 2021-01-01 00:00:00  \n",
+      "1 2021-01-01 00:15:00  \n",
+      "2 2021-01-01 00:30:00  \n",
+      "3 2021-01-01 00:45:00  \n",
+      "4 2021-01-01 01:00:00  \n",
+      "        dy  Globalstrahlung_15Min  Sonnenhöhe  ExtraterrestrischeStrahlung  \\\n",
+      "35035  365                      0       -56.5                            0   \n",
+      "35036  365                      0       -58.5                            0   \n",
+      "35037  365                      0       -60.3                            0   \n",
+      "35038  365                      0       -61.9                            0   \n",
+      "35039  365                      0       -63.3                            0   \n",
+      "\n",
+      "       StundenwertStrahlung  Diffusstrahlung  StrahlungGeneigteFläche  \\\n",
+      "35035                     0                0                        0   \n",
+      "35036                     0                0                        0   \n",
+      "35037                     0                0                        0   \n",
+      "35038                     0                0                        0   \n",
+      "35039                     0                0                        0   \n",
+      "\n",
+      "       DiffusstrahlungGeneigteFläche  Direktnormalstrahlung  Lufttemperatur  \\\n",
+      "35035                              0                      0             5.5   \n",
+      "35036                              0                      0             5.5   \n",
+      "35037                              0                      0             5.5   \n",
+      "35038                              0                      0             5.5   \n",
+      "35039                              0                      0             4.9   \n",
+      "\n",
+      "       Windgeschwindigkeit  Schönwetterstrahlung  Taupunkttemperatur  \\\n",
+      "35035                  2.4                     0               -18.2   \n",
+      "35036                  2.4                     0               -18.2   \n",
+      "35037                  2.4                     0               -18.2   \n",
+      "35038                  2.4                     0               -18.2   \n",
+      "35039                  1.8                     0               -14.0   \n",
+      "\n",
+      "       TheorPVProd    TimestampWeather  \n",
+      "35035            0 2023-12-31 22:45:00  \n",
+      "35036            0 2023-12-31 23:00:00  \n",
+      "35037            0 2023-12-31 23:15:00  \n",
+      "35038            0 2023-12-31 23:30:00  \n",
+      "35039            0 2023-12-31 23:45:00  \n",
+      "Number of missing values per column:\n",
+      "dy                               0\n",
+      "Globalstrahlung_15Min            0\n",
+      "Sonnenhöhe                       0\n",
+      "ExtraterrestrischeStrahlung      0\n",
+      "StundenwertStrahlung             0\n",
+      "Diffusstrahlung                  0\n",
+      "StrahlungGeneigteFläche          0\n",
+      "DiffusstrahlungGeneigteFläche    0\n",
+      "Direktnormalstrahlung            0\n",
+      "Lufttemperatur                   0\n",
+      "Windgeschwindigkeit              0\n",
+      "Schönwetterstrahlung             0\n",
+      "Taupunkttemperatur               0\n",
+      "TheorPVProd                      0\n",
+      "TimestampWeather                 0\n",
+      "dtype: int64\n",
+      "Number of rows in dfClimaAll: 105120\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Step 1 - Reading Data\n",
+    "\n",
+    "## dfClimaAll: Data from 2021-2023\n",
+    "## dfEnergyAll: All data from the transformer station from 2021-2023\n",
+    "\n",
+    "# Load data for 2021\n",
+    "dfClima21 = pd.read_excel('/home/sarah/Documents/BT2024/Weather_Data/2021TimeWeather.xlsx')\n",
+    "\n",
+    "# Load data for 2022\n",
+    "dfClima22 = pd.read_excel('/home/sarah/Documents/BT2024/Weather_Data/2022TimeWeather.xlsx')\n",
+    "\n",
+    "# Load data for 2023\n",
+    "dfClima23 = pd.read_excel('/home/sarah/Documents/BT2024/Weather_Data/2023TimeWeather.xlsx')\n",
+    "\n",
+    "# Merge the DataFrames\n",
+    "dfClimaAll = pd.concat([dfClima21, dfClima22, dfClima23])\n",
+    "\n",
+    "# Check the resulting DataFrame\n",
+    "print(\"First and last rows from dfClimaAll:\")\n",
+    "print(dfClimaAll.head())\n",
+    "print(dfClimaAll.tail())\n",
+    "\n",
+    "# Check for missing values in each column\n",
+    "## .isnull(): Returns DF where values with NaN are replaced by True & values without NaN are replaced by False\n",
+    "## sum(): Sums up the number of True values\n",
+    "print(\"Number of missing values per column:\")\n",
+    "print(dfClimaAll.isnull().sum())\n",
+    "\n",
+    "# Convert 'Timestamp' into a Datetime object and set it as index, if not already set\n",
+    "if 'TimestampWeather' in dfClimaAll.columns:\n",
+    "    ## pd.to_datetime: Converts values into Datetime objects —> Pandas can then treat these as timestamps\n",
+    "    dfClimaAll['TimestampWeather'] = pd.to_datetime(dfClimaAll['TimestampWeather'])\n",
+    "    ## set_index: Sets index for the Timestamp column to facilitate access to data based on time points\n",
+    "    dfClimaAll = dfClimaAll.set_index('TimestampWeather')\n",
+    "\n",
+    "# Number of rows in dfClimaAll\n",
+    "print(\"Number of rows in dfClimaAll:\", dfClimaAll.shape[0])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "316d6e1f-b0eb-4600-882c-bfa5ce581986",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "First and last rows from dfEnergyAll:\n",
+      "                     Lastgang\n",
+      "Timestamp                    \n",
+      "2021-01-01 00:00:00    472.88\n",
+      "2021-01-01 00:15:00    498.83\n",
+      "2021-01-01 00:30:00    480.48\n",
+      "2021-01-01 00:45:00    446.74\n",
+      "2021-01-01 01:00:00    459.55\n",
+      "                     Lastgang\n",
+      "Timestamp                    \n",
+      "2023-12-31 22:45:00    833.17\n",
+      "2023-12-31 23:00:00    767.89\n",
+      "2023-12-31 23:15:00    770.04\n",
+      "2023-12-31 23:30:00    730.45\n",
+      "2023-12-31 23:45:00    744.21\n",
+      "Number of rows in dfEnergyAll: 105108\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Step 1 - Reading Data\n",
+    "\n",
+    "## dfClimaAll: Data from 2021-2023\n",
+    "## dfEnergyAll: All data from the transformer station from 2021-2023\n",
+    "\n",
+    "# Path to the directory containing the Excel files\n",
+    "directory_path = Path('/home/sarah/Documents/BT2024/All')\n",
+    "\n",
+    "# Create a list of all Excel files in the directory\n",
+    "file_paths = list(directory_path.glob('*.xlsx'))\n",
+    "\n",
+    "# List to store the individual DataFrames\n",
+    "dfs = []\n",
+    "\n",
+    "# Loop over all file paths\n",
+    "for file_path in file_paths:\n",
+    "    # Read the Excel file\n",
+    "    df = pd.read_excel(file_path)\n",
+    "    \n",
+    "    # Convert the 'Timestamp' column to a datetime\n",
+    "    df['Timestamp'] = pd.to_datetime(df['Timestamp'])\n",
+    "    \n",
+    "    # Convert the 'Lastgang' column to a numeric type, treat errors as NaN\n",
+    "    df['Lastgang'] = pd.to_numeric(df['Lastgang'], errors='coerce')\n",
+    "    \n",
+    "    # Sort the DataFrame by 'Timestamp'\n",
+    "    df = df.sort_values(by='Timestamp')\n",
+    "    \n",
+    "    # Perform linear interpolation for 'Lastgang' on the individual DataFrame\n",
+    "    df['Lastgang'] = df['Lastgang'].interpolate(method='linear')\n",
+    "    \n",
+    "    # Add the DataFrame to the list\n",
+    "    dfs.append(df)\n",
+    "\n",
+    "# Merge all DataFrames in the list\n",
+    "dfEnergyAll = pd.concat(dfs).set_index('Timestamp')\n",
+    "\n",
+    "# Sum the 'Lastgang' values for identical timestamps\n",
+    "dfEnergyAll = dfEnergyAll.groupby('Timestamp').sum()\n",
+    "\n",
+    "# Check the resulting DataFrame\n",
+    "print(\"First and last rows from dfEnergyAll:\")\n",
+    "print(dfEnergyAll.head())\n",
+    "print(dfEnergyAll.tail())\n",
+    "\n",
+    "# Display the number of rows in dfEnergyAll\n",
+    "print(\"Number of rows in dfEnergyAll:\", dfEnergyAll.shape[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "dda00bbf-4a50-45f8-8c98-c29eff6bf793",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Missing timestamps in dfEnergyAll:\n",
+      "DatetimeIndex(['2021-03-28 02:00:00', '2021-03-28 02:15:00',\n",
+      "               '2021-03-28 02:30:00', '2021-03-28 02:45:00',\n",
+      "               '2022-03-27 02:00:00', '2022-03-27 02:15:00',\n",
+      "               '2022-03-27 02:30:00', '2022-03-27 02:45:00',\n",
+      "               '2023-03-26 02:00:00', '2023-03-26 02:15:00',\n",
+      "               '2023-03-26 02:30:00', '2023-03-26 02:45:00'],\n",
+      "              dtype='datetime64[ns]', name='Timestamp', freq=None)\n",
+      "Check after adding the missing timestamps:\n",
+      "                     Lastgang\n",
+      "2021-03-28 02:00:00    372.28\n",
+      "2021-03-28 02:15:00    372.28\n",
+      "2021-03-28 02:30:00    372.28\n",
+      "2021-03-28 02:45:00    372.28\n",
+      "2022-03-27 02:00:00    554.20\n",
+      "2022-03-27 02:15:00    554.20\n",
+      "2022-03-27 02:30:00    554.20\n",
+      "2022-03-27 02:45:00    554.20\n",
+      "2023-03-26 02:00:00    520.34\n",
+      "2023-03-26 02:15:00    520.34\n",
+      "2023-03-26 02:30:00    520.34\n",
+      "2023-03-26 02:45:00    520.34\n",
+      "Number of rows in dfClima21: 105120\n",
+      "Number of rows in dfEnergyAll: 105120\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_271366/1871761932.py:32: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n",
+      "  dfEnergyAll = dfEnergyAll.sort_index().fillna(method='ffill')\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Step 2 - Preparing the Data\n",
+    "\n",
+    "# Create a complete timestamp index for the years 2021 - 2023 in 15-minute intervals\n",
+    "all_timestamps = pd.date_range(start='2021-01-01 00:00:00', end='2023-12-31 23:45:00', freq='15T')\n",
+    "\n",
+    "# Convert this into a DataFrame\n",
+    "df_all_timestamps = pd.DataFrame(all_timestamps, columns=['Timestamp'])\n",
+    "df_all_timestamps = df_all_timestamps.set_index('Timestamp')\n",
+    "\n",
+    "# Compare the complete timestamp index with dfEnergyAll\n",
+    "missing_timestamps = df_all_timestamps.index.difference(dfEnergyAll.index)\n",
+    "\n",
+    "print(\"Missing timestamps in dfEnergyAll:\")\n",
+    "print(missing_timestamps)\n",
+    "\n",
+    "\n",
+    "# Missing timestamps\n",
+    "missing_timestamps = pd.DatetimeIndex(['2021-03-28 02:00:00', '2021-03-28 02:15:00',\n",
+    "                                       '2021-03-28 02:30:00', '2021-03-28 02:45:00',\n",
+    "                                       '2022-03-27 02:00:00', '2022-03-27 02:15:00',\n",
+    "                                       '2022-03-27 02:30:00', '2022-03-27 02:45:00',\n",
+    "                                       '2023-03-26 02:00:00', '2023-03-26 02:15:00',\n",
+    "                                       '2023-03-26 02:30:00', '2023-03-26 02:45:00'])\n",
+    "\n",
+    "# Create a DataFrame with the missing timestamps\n",
+    "df_missing = pd.DataFrame(index=missing_timestamps)\n",
+    "\n",
+    "# Merge this DataFrame with the original DataFrame\n",
+    "dfEnergyAll = dfEnergyAll.combine_first(df_missing)\n",
+    "\n",
+    "# Fill the missing values. Use 'ffill' for forward fill.\n",
+    "dfEnergyAll = dfEnergyAll.sort_index().fillna(method='ffill')\n",
+    "\n",
+    "print(\"Check after adding the missing timestamps:\")\n",
+    "print(dfEnergyAll.loc[missing_timestamps])\n",
+    "\n",
+    "# Number of rows in dfClima21\n",
+    "# Ensure dfClima21 is already defined before executing this line.\n",
+    "print(\"Number of rows in dfClima21:\", dfClimaAll.shape[0])\n",
+    "\n",
+    "# Number of rows in dfEnergyAll\n",
+    "print(\"Number of rows in dfEnergyAll:\", dfEnergyAll.shape[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1e574dec-2c98-4062-a450-d13163d962c9",
+   "metadata": {},
+   "source": [
+    "## 1 - Linear Regression with Energy consumption data and weather data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "d7e1513e-2337-45c7-92b9-82db88714c50",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of missing values per column:\n",
+      "Lastgang                   0\n",
+      "StundenwertStrahlung       0\n",
+      "Globalstrahlung_15Min      0\n",
+      "StrahlungGeneigteFläche    0\n",
+      "TheorPVProd                0\n",
+      "Direktnormalstrahlung      0\n",
+      "Schönwetterstrahlung       0\n",
+      "Lufttemperatur             0\n",
+      "dtype: int64\n",
+      "First and last rows from dfEnergyAll-Edited:\n",
+      "                     Lastgang  StundenwertStrahlung  Globalstrahlung_15Min  \\\n",
+      "2021-01-01 00:00:00    472.88                     0                      0   \n",
+      "2021-01-01 00:15:00    498.83                     0                      0   \n",
+      "2021-01-01 00:30:00    480.48                     0                      0   \n",
+      "2021-01-01 00:45:00    446.74                     0                      0   \n",
+      "2021-01-01 01:00:00    459.55                     0                      0   \n",
+      "\n",
+      "                     StrahlungGeneigteFläche  TheorPVProd  \\\n",
+      "2021-01-01 00:00:00                        0            0   \n",
+      "2021-01-01 00:15:00                        0            0   \n",
+      "2021-01-01 00:30:00                        0            0   \n",
+      "2021-01-01 00:45:00                        0            0   \n",
+      "2021-01-01 01:00:00                        0            0   \n",
+      "\n",
+      "                     Direktnormalstrahlung  Schönwetterstrahlung  \\\n",
+      "2021-01-01 00:00:00                      0                     0   \n",
+      "2021-01-01 00:15:00                      0                     0   \n",
+      "2021-01-01 00:30:00                      0                     0   \n",
+      "2021-01-01 00:45:00                      0                     0   \n",
+      "2021-01-01 01:00:00                      0                     0   \n",
+      "\n",
+      "                     Lufttemperatur  \n",
+      "2021-01-01 00:00:00             2.5  \n",
+      "2021-01-01 00:15:00             2.5  \n",
+      "2021-01-01 00:30:00             2.5  \n",
+      "2021-01-01 00:45:00             2.5  \n",
+      "2021-01-01 01:00:00             2.4  \n",
+      "                     Lastgang  StundenwertStrahlung  Globalstrahlung_15Min  \\\n",
+      "2023-12-31 22:45:00    833.17                     0                      0   \n",
+      "2023-12-31 23:00:00    767.89                     0                      0   \n",
+      "2023-12-31 23:15:00    770.04                     0                      0   \n",
+      "2023-12-31 23:30:00    730.45                     0                      0   \n",
+      "2023-12-31 23:45:00    744.21                     0                      0   \n",
+      "\n",
+      "                     StrahlungGeneigteFläche  TheorPVProd  \\\n",
+      "2023-12-31 22:45:00                        0            0   \n",
+      "2023-12-31 23:00:00                        0            0   \n",
+      "2023-12-31 23:15:00                        0            0   \n",
+      "2023-12-31 23:30:00                        0            0   \n",
+      "2023-12-31 23:45:00                        0            0   \n",
+      "\n",
+      "                     Direktnormalstrahlung  Schönwetterstrahlung  \\\n",
+      "2023-12-31 22:45:00                      0                     0   \n",
+      "2023-12-31 23:00:00                      0                     0   \n",
+      "2023-12-31 23:15:00                      0                     0   \n",
+      "2023-12-31 23:30:00                      0                     0   \n",
+      "2023-12-31 23:45:00                      0                     0   \n",
+      "\n",
+      "                     Lufttemperatur  \n",
+      "2023-12-31 22:45:00             5.5  \n",
+      "2023-12-31 23:00:00             5.5  \n",
+      "2023-12-31 23:15:00             5.5  \n",
+      "2023-12-31 23:30:00             5.5  \n",
+      "2023-12-31 23:45:00             4.9  \n"
+     ]
+    }
+   ],
+   "source": [
+    "# Step 2 - Preparing the Data\n",
+    "\n",
+    "# To check if the indexes in both DataFrames are set equally\n",
+    "dfClimaAll.index.equals(dfEnergyAll.index)\n",
+    "\n",
+    "# Adding the columns from dfClima21 to dfEnergyAll\n",
+    "dfEnergyAll = dfEnergyAll.join(dfClimaAll[['StundenwertStrahlung', 'Globalstrahlung_15Min', 'StrahlungGeneigteFläche', 'TheorPVProd', 'Direktnormalstrahlung', 'Schönwetterstrahlung', 'Lufttemperatur']])\n",
+    "\n",
+    "# Checking for missing values in each column\n",
+    "print(\"Number of missing values per column:\")\n",
+    "print(dfEnergyAll.isnull().sum())\n",
+    "\n",
+    "# Printing the first and last rows from the dataframe\n",
+    "print(\"First and last rows from dfEnergyAll-Edited:\")\n",
+    "print(dfEnergyAll.head())\n",
+    "print(dfEnergyAll.tail())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e33a35b4-0b2d-41d0-9be7-5ed46491538b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                     Lastgang  StundenwertStrahlung  Globalstrahlung_15Min  \\\n",
+      "2021-01-01 00:00:00    472.88                     0                      0   \n",
+      "2021-01-01 00:15:00    498.83                     0                      0   \n",
+      "2021-01-01 00:30:00    480.48                     0                      0   \n",
+      "2021-01-01 00:45:00    446.74                     0                      0   \n",
+      "2021-01-01 01:00:00    459.55                     0                      0   \n",
+      "\n",
+      "                     StrahlungGeneigteFläche  TheorPVProd  \\\n",
+      "2021-01-01 00:00:00                        0            0   \n",
+      "2021-01-01 00:15:00                        0            0   \n",
+      "2021-01-01 00:30:00                        0            0   \n",
+      "2021-01-01 00:45:00                        0            0   \n",
+      "2021-01-01 01:00:00                        0            0   \n",
+      "\n",
+      "                     Direktnormalstrahlung  Schönwetterstrahlung  \\\n",
+      "2021-01-01 00:00:00                      0                     0   \n",
+      "2021-01-01 00:15:00                      0                     0   \n",
+      "2021-01-01 00:30:00                      0                     0   \n",
+      "2021-01-01 00:45:00                      0                     0   \n",
+      "2021-01-01 01:00:00                      0                     0   \n",
+      "\n",
+      "                     Lufttemperatur  Lastgang_Moving_Average  \\\n",
+      "2021-01-01 00:00:00             2.5               549.123854   \n",
+      "2021-01-01 00:15:00             2.5               549.123854   \n",
+      "2021-01-01 00:30:00             2.5               549.123854   \n",
+      "2021-01-01 00:45:00             2.5               549.123854   \n",
+      "2021-01-01 01:00:00             2.4               549.123854   \n",
+      "\n",
+      "                     Lastgang_First_Difference  \n",
+      "2021-01-01 00:00:00                      25.95  \n",
+      "2021-01-01 00:15:00                      25.95  \n",
+      "2021-01-01 00:30:00                     -18.35  \n",
+      "2021-01-01 00:45:00                     -33.74  \n",
+      "2021-01-01 01:00:00                      12.81  \n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_270933/1800522370.py:11: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n",
+      "  dfEnergyAll = dfEnergyAll.fillna(method='bfill')\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Step 2 - Preparing the Data\n",
+    "\n",
+    "# Calculating the moving average for 'Lastgang'\n",
+    "window_size = 96  # This corresponds to 24 hours at 15-minute intervals\n",
+    "dfEnergyAll['Lastgang_Moving_Average'] = dfEnergyAll['Lastgang'].rolling(window=window_size).mean()\n",
+    "\n",
+    "# Calculating the first differences for 'Lastgang'\n",
+    "dfEnergyAll['Lastgang_First_Difference'] = dfEnergyAll['Lastgang'].diff()\n",
+    "\n",
+    "# Since the first `window_size - 1` values of the moving average will be NaN and the first value of the first difference will be NaN, fill these values.\n",
+    "dfEnergyAll = dfEnergyAll.fillna(method='bfill')\n",
+    "\n",
+    "# To check the first few rows to ensure the new features look as expected.\n",
+    "print(dfEnergyAll.head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "fb21c191-8540-483e-bcc4-fd9f865b7355",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Step 3 - Data Scaling\n",
+    "\n",
+    "# Initialize the scalers\n",
+    "lastgang_scaler = MinMaxScaler(feature_range=(0, 1))\n",
+    "features_scaler = MinMaxScaler(feature_range=(0, 1))\n",
+    "\n",
+    "# Apply the scaler to the corresponding columns\n",
+    "dfEnergyAll['Lastgang'] = lastgang_scaler.fit_transform(dfEnergyAll['Lastgang'].values.reshape(-1, 1))\n",
+    "dfEnergyAll[['StundenwertStrahlung', 'Lufttemperatur', 'Globalstrahlung_15Min', 'StrahlungGeneigteFläche', 'Lastgang_Moving_Average', 'Lastgang_First_Difference']] = features_scaler.fit_transform(dfEnergyAll[['StundenwertStrahlung', 'Lufttemperatur', 'Globalstrahlung_15Min', 'StrahlungGeneigteFläche', 'Lastgang_Moving_Average', 'Lastgang_First_Difference']])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "1a5fc765-e790-410a-93c0-8467c81966f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                            OLS Regression Results                            \n",
+      "==============================================================================\n",
+      "Dep. Variable:               Lastgang   R-squared:                       0.460\n",
+      "Model:                            OLS   Adj. R-squared:                  0.460\n",
+      "Method:                 Least Squares   F-statistic:                 1.119e+04\n",
+      "Date:                Tue, 14 May 2024   Prob (F-statistic):               0.00\n",
+      "Time:                        21:11:16   Log-Likelihood:                 82832.\n",
+      "No. Observations:              104928   AIC:                        -1.656e+05\n",
+      "Df Residuals:                  104919   BIC:                        -1.656e+05\n",
+      "Df Model:                           8                                         \n",
+      "Covariance Type:            nonrobust                                         \n",
+      "=============================================================================================\n",
+      "                                coef    std err          t      P>|t|      [0.025      0.975]\n",
+      "---------------------------------------------------------------------------------------------\n",
+      "const                         0.1713      0.011     15.500      0.000       0.150       0.193\n",
+      "StundenwertStrahlung         -0.3576      0.021    -17.201      0.000      -0.398      -0.317\n",
+      "Globalstrahlung_15Min        -0.6210      0.018    -35.408      0.000      -0.655      -0.587\n",
+      "StrahlungGeneigteFläche      -0.6210      0.018    -35.408      0.000      -0.655      -0.587\n",
+      "TheorPVProd                   0.0012   4.05e-05     30.811      0.000       0.001       0.001\n",
+      "Direktnormalstrahlung      1.745e-06   3.98e-06      0.438      0.661   -6.06e-06    9.55e-06\n",
+      "Schönwetterstrahlung       6.207e-05   4.03e-06     15.407      0.000    5.42e-05       7e-05\n",
+      "Lufttemperatur                0.1988      0.003     66.759      0.000       0.193       0.205\n",
+      "Lastgang_Moving_Average       0.4090      0.002    227.184      0.000       0.405       0.412\n",
+      "Lastgang_First_Difference     0.3231      0.007     43.715      0.000       0.309       0.338\n",
+      "==============================================================================\n",
+      "Omnibus:                     1743.772   Durbin-Watson:                   0.051\n",
+      "Prob(Omnibus):                  0.000   Jarque-Bera (JB):             1756.805\n",
+      "Skew:                           0.298   Prob(JB):                         0.00\n",
+      "Kurtosis:                       2.786   Cond. No.                     3.23e+18\n",
+      "==============================================================================\n",
+      "\n",
+      "Notes:\n",
+      "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n",
+      "[2] The smallest eigenvalue is 2.49e-27. This might indicate that there are\n",
+      "strong multicollinearity problems or that the design matrix is singular.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Step 4 - Creating the linear regression model and generating predictions\n",
+    "\n",
+    "## Performing linear regression with energy consumption data and meteorological data from 2021-2023\n",
+    "# Splitting the data into training and testing sets\n",
+    "# The last 192 data points (48 hours at 15-minute intervals) are the test dataset\n",
+    "train = dfEnergyAll.iloc[:-192]\n",
+    "test = dfEnergyAll.iloc[-192:]\n",
+    "\n",
+    "# Define the target and explanatory variables for training and testing\n",
+    "y_train = train['Lastgang']\n",
+    "X_train = train[['StundenwertStrahlung', 'Globalstrahlung_15Min', 'StrahlungGeneigteFläche', 'TheorPVProd', 'Direktnormalstrahlung', 'Schönwetterstrahlung', 'Lufttemperatur', 'Lastgang_Moving_Average', 'Lastgang_First_Difference']]\n",
+    "X_train = sm.add_constant(X_train)  # Adding a constant column to include the intercept in the model\n",
+    "\n",
+    "y_test = test['Lastgang']\n",
+    "X_test = test[['StundenwertStrahlung', 'Globalstrahlung_15Min', 'StrahlungGeneigteFläche', 'TheorPVProd', 'Direktnormalstrahlung', 'Schönwetterstrahlung', 'Lufttemperatur', 'Lastgang_Moving_Average', 'Lastgang_First_Difference']]\n",
+    "X_test = sm.add_constant(X_test)  # Adding a constant column to include the intercept in the model\n",
+    "\n",
+    "# Create and fit the model with training data\n",
+    "model = sm.OLS(y_train, X_train).fit()\n",
+    "\n",
+    "# Generate predictions for the test data\n",
+    "predictions = model.predict(X_test)\n",
+    "\n",
+    "# Output the summary of the model\n",
+    "print(model.summary())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "51e723df-ec12-4974-8495-c15af04d8646",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean Squared Error (MSE) for the last 48 hours: 29459.063725402957\n",
+      "Mean Absolute Error (MAE) for the last 48 hours: 144.12908664901138\n",
+      "Root Mean Square Error (RMSE) for the last 48 hours: 171.63642889958692\n",
+      "Mean Absolute Percentage Error (MAPE) for the last 48 hours: 19.288364449886654%\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+0AAAIACAYAAAD36o37AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3xTZRfA8V/SpntvWkrZQ9kgCsheiiCKiIoDBHEPfJ04AH1x4UJxK0PFha+AGwGVJXvKnmWUTrp3m+S+fyT3tulMZ9pyvp9PP9Dk5t4no0nOPec5j05RFAUhhBBCCCGEEEI0OHpHD0AIIYQQQgghhBBlk6BdCCGEEEIIIYRooCRoF0IIIYQQQgghGigJ2oUQQgghhBBCiAZKgnYhhBBCCCGEEKKBkqBdCCGEEEIIIYRooCRoF0IIIYQQQgghGigJ2oUQQgghhBBCiAZKgnYhhBBCCCGEEKKBkqBdiFr277//cuedd9KqVSvc3Nzw8vKiZ8+ezJs3j5SUFEcPr85NmTKFli1bOnoYNbZnzx4GDRqEr68vOp2O+fPnV3qbCxcu4Orqik6nY+fOndU+9gcffMCSJUuqffuqWLJkCTqdjtOnT9fL8ewxePBgBg8eXOl2LVu2RKfTaT9eXl5cfvnlfPHFF3U/SMp+7Owde0kvv/wyK1eurLWxqU6fPo1Op6vw9fToo4+i0+k4cuRIuds8++yz6HQ6du/ebfexW7ZsyZQpU6owWsebMmUKXl5eFW7TEP9mqmLOnDk2fzcGg4EWLVowffp04uPjHT28etNUPqvq02233YZOp2PMmDGlrsvIyODZZ5+lffv2eHh4EBERwY033sjBgwcr3a/6PvXGG2+Uef0bb7zRqP/mhKgNErQLUYs+/fRTevXqxY4dO3jiiSdYtWoVK1as4MYbb+Sjjz5i2rRpjh5inXv++edZsWKFo4dRY1OnTiUuLo5vv/2WLVu2cPPNN1d6my+//JKCggIAFi5cWO1j12fQ3tj179+fLVu2sGXLFi2Ymjx5Mh9++KFDxvPBBx/wwQcfVPl2dRW020N9X1q0aFGZ15vNZr744gu6d+9Oz54963NoDdI111zDli1baNasmaOHUiOrVq1iy5Yt/P7779x8880sWrSIYcOGUVhY6Oih1Yum8llVX3799VdWrlyJj49PmdePHTuW+fPnM336dH799VdeffVV9u7dS9++fTlz5kw9j1aIpsfZ0QMQoqnYsmUL9913HyNGjGDlypW4urpq140YMYLHHnuMVatWOXCEdSsnJwcPDw/atGnj6KHUigMHDjB9+nSuvvpqu2+zaNEiQkJCiIqK4ptvvuGtt97C3d29Dkcp/Pz8uOKKK7Tfhw8fTlRUFG+99Rb33XdfmbcxmUwYjUabv9Hacskll9T6Puta586d6dOnD19++SUvv/wyzs62Xw1Wr15NTEwMTz31lING2LAEBwcTHBzs6GFUSH0/rkivXr0ICgoCLH83Fy5cYPHixWzatIkhQ4bUxzABUBSFvLy8en+vbCqfVTWVm5tb6WOfnp7OPffcw3//+1/eeeedUtefOHGCDRs28Nxzz/HEE09ol7dt25Z+/fqxfPlyHn300Vofe12ry88KIapKMu1C1JKXX34ZnU7HJ598UuYbvIuLC9dee632u9lsZt68eXTs2BFXV1dCQkK44447iImJsbnd4MGD6dy5M1u2bKFfv364u7vTsmVLFi9eDFjOfvfs2RMPDw+6dOlS6sSAWgq5Z88exo8fj4+PD76+vtx2220kJSXZbPvdd98xcuRImjVrhru7O506deLpp58mOzvbZju1hHT//v2MHDkSb29vhg0bpl1XsuTw+++/5/LLL8fX1xcPDw9at27N1KlTbbY5e/Yst912GyEhIbi6utKpUyfefPNNzGaztk3xErq33nqLVq1a4eXlRd++fdm6dWtFT4/mwIEDjBs3Dn9/f9zc3OjevTuff/65dr2arTUajXz44YdaCWlltm3bxoEDB7j99tuZPn066enp/PDDD6W2M5vNLFiwgO7du+Pu7q4FnT/99BNgKSk+ePAg69ev146tPp7lleWuW7cOnU7HunXrtMvWrFnDuHHjaN68OW5ubrRt25Z77rmHCxcu2PU4lXTixAnuvPNO2rVrp5U+jh07lv3795c5lm+++YZnn32W8PBwfHx8GD58OEePHrXZVlEU5s2bR1RUFG5ubvTs2ZPff/+9WuNT+fn50aFDBy2zo75m5s2bx9y5c2nVqhWurq78/fffAOzcuZNrr72WgIAA3Nzc6NGjB8uWLSu1361bt9K/f3/c3NwIDw9n5syZZWYkyyqPz8/P58UXX6RTp064ubkRGBjIkCFD2Lx5MwA6nY7s7Gw+//xz7Tkvvo/4+HjuuecemjdvjouLC61ateKFF17AaDTaHCc2NpaJEyfi7e2Nr68vN910k93lztOmTSM+Pr7Mx3/x4sW4urpy6623kpeXx2OPPUb37t3x9fUlICCAvn378uOPP1Z6jKq8fgHWrl3LsGHD8PHxwcPDg/79+/Pnn3/abJOUlMTdd99NZGQkrq6uBAcH079/f9auXWvX/a6O8qZFdO7cmR07djBgwADtfe7VV1+1eQ8DSxnx448/TqtWrXBxcSEiIoIZM2aUep99//33GThwICEhIXh6etKlSxfmzZtX6nWnHnvDhg3069cPDw+PUu+v9ujduzcACQkJNpfb8zwA/Pjjj3Tt2hVXV1dat27NO++8o33+FKfT6XjwwQf56KOP6NSpE66urtp78PHjx5k0aZLN58D7779vc3uz2czcuXPp0KGD9h7atWtXm2DSntdFWZ9VeXl5zJw50+a5eeCBB0hLS7PZrmXLlowZM4ZVq1bRs2dP3N3d6dixY7nVKiWlpKRw//33ExERgYuLC61bt+bZZ58lPz9f26ZHjx4MGDCg1G1NJhMRERGMHz9eu6ygoIC5c+dq3yeCg4O58847S33Gq+Nevnw5PXr0wM3NjRdeeKHS8T722GM0a9aMhx9+uMzrDQYDAL6+vjaX+/n5AeDm5lbpMapj0aJFdOvWDTc3NwICArj++us5fPiwzTblTVkq+fxX9Flhz2tOiLommXYhaoHJZOKvv/6iV69eREZG2nWb++67j08++YQHH3yQMWPGcPr0aZ5//nnWrVvH7t27tQwIWL6033nnnTz55JM0b96cBQsWMHXqVM6dO8f//vc/nnnmGXx9fXnxxRe57rrrOHXqFOHh4TbHu/7665k4cSL33nsvBw8e5Pnnn+fQoUNs27ZN+8A9fvw4o0ePZsaMGXh6enLkyBFee+01tm/fzl9//WWzv4KCAq699lruuecenn766VIBhGrLli3cdNNN3HTTTcyZMwc3NzfOnDljs7+kpCT69etHQUEB//3vf2nZsiW//PILjz/+OCdPnixVbvz+++/TsWNHbZ75888/z+jRo4mOji71paG4o0eP0q9fP0JCQnj33XcJDAxk6dKlTJkyhYSEBJ588kmt9LVv375MmDCBxx57rPInk6Jy+KlTpxIZGcmMGTNYuHAht912m812U6ZMYenSpUybNo0XX3wRFxcXdu/erQUAK1asYMKECfj6+mr3uzpn+U+ePEnfvn2566678PX15fTp07z11ltceeWV7N+/X3vO7RUbG0tgYCCvvvoqwcHBpKSk8Pnnn3P55ZezZ88eOnToYLP9M888Q//+/fnss8/IyMjgqaeeYuzYsRw+fBgnJycAXnjhBV544QWmTZvGhAkTOHfuHNOnT8dkMpXan70KCws5c+ZMqUzou+++S/v27XnjjTfw8fGhXbt2/P3331x11VVcfvnlfPTRR/j6+vLtt99y0003kZOTo83HPnToEMOGDaNly5YsWbIEDw8PPvjgA77++utKx2M0Grn66qvZuHEjM2bMYOjQoRiNRrZu3crZs2fp168fW7ZsYejQoQwZMoTnn38eQCtBjY+Pp0+fPuj1embNmkWbNm3YsmULc+fO5fTp09rJu9zcXIYPH05sbCyvvPIK7du359dff+Wmm26y63G75ZZbePTRR1m0aBFjx47VLk9NTeXHH3/k+uuvx9/fn/T0dFJSUnj88ceJiIigoKCAtWvXMn78eBYvXswdd9xh1/Eqs3TpUu644w7GjRvH559/jsFg4OOPP2bUqFH88ccf2knC22+/nd27d/PSSy/Rvn170tLS2L17N8nJydq+1q1bx5AhQ5g9ezZz5syplfGVJT4+nltvvZXHHnuM2bNns2LFCmbOnEl4eLj2uOTk5DBo0CBiYmJ45pln6Nq1KwcPHmTWrFns37+ftWvXakHuyZMnmTRpkhZA7tu3j5deeokjR46UCg7j4uK47bbbePLJJ3n55ZfR66uek4mOjgagffv22mX2Pg+rVq1i/PjxDBw4kO+++w6j0cgbb7xR6gSAauXKlWzcuJFZs2YRFhZGSEgIhw4dol+/frRo0YI333yTsLAw/vjjDx5++GEuXLjA7NmzAZg3bx5z5szhueeeY+DAgRQWFnLkyBGbwNqe10VJiqJw3XXX8eeffzJz5kwGDBjAv//+y+zZs7UpOMXfi/ft28djjz3G008/TWhoKJ999hnTpk2jbdu2DBw4sNzj5OXlMWTIEE6ePMkLL7xA165d2bhxI6+88gp79+7l119/BeDOO+/kkUce4fjx47Rr1067/erVq4mNjeXOO+8ELCcxxo0bx8aNG3nyySfp168fZ86cYfbs2QwePJidO3faZNJ3797N4cOHee6552jVqhWenp7ljhUsJ22++OILduzYob13lxQVFcW4ceN4++236dWrF5dddhkxMTE8/PDDtGjRwq7pZep9Keu7RMkTXwCvvPIKzzzzDLfccguvvPIKycnJzJkzh759+7Jjxw6bx6wqyvqssOc1J0SdU4QQNRYfH68Ays0332zX9ocPH1YA5f7777e5fNu2bQqgPPPMM9plgwYNUgBl586d2mXJycmKk5OT4u7urpw/f167fO/evQqgvPvuu9pls2fPVgDl0UcftTnWV199pQDK0qVLyxyj2WxWCgsLlfXr1yuAsm/fPu26yZMnK4CyaNGiUrebPHmyEhUVpf3+xhtvKICSlpZW7uPx9NNPK4Cybds2m8vvu+8+RafTKUePHlUURVGio6MVQOnSpYtiNBq17bZv364AyjfffFPuMRRFUW6++WbF1dVVOXv2rM3lV199teLh4WEzRkB54IEHKtyfKjs7W/Hx8VGuuOIK7bLJkycrOp1OOXHihHbZhg0bFEB59tlnK9zfpZdeqgwaNKjU5YsXL1YAJTo62ubyv//+WwGUv//+u8z9qc/lmTNnFED58ccfK91nZYxGo1JQUKC0a9fO5rWljmX06NE22y9btkwBlC1btiiKoiipqamKm5ubcv3119ts988//yhAmfe/pKioKGX06NFKYWGhUlhYqERHR2uvzSeeeEJRlKLXTJs2bZSCggKb23fs2FHp0aOHUlhYaHP5mDFjlGbNmikmk0lRFEW56aabFHd3dyU+Pt7m/nfs2LHUYzdo0CCbsX/xxRcKoHz66acV3hdPT09l8uTJpS6/5557FC8vL+XMmTM2l6t/VwcPHlQURVE+/PDDUs+toijK9OnTFUBZvHhxhcdXFMtr1mAwKAkJCdplCxYsUABlzZo1Zd7GaDQqhYWFyrRp05QePXrYXBcVFWVzn+x9/WZnZysBAQHK2LFjbbYzmUxKt27dlD59+miXeXl5KTNmzKjwfq1bt05xcnJSXnjhhQq3UxTLY+Dp6VnhNmXdD/V9uuR72CWXXKKMGjVK+/2VV15R9Hq9smPHDpvt/ve//ymA8ttvv5V5TJPJpBQWFipffPGF4uTkpKSkpJQ69p9//lnp/VOUos+E+Ph4pbCwUElNTVWWLVumeHp6Krfccou2XVWeh8suu0yJjIxU8vPztcsyMzOVwMBApeRXTUDx9fW1uQ+KoiijRo1SmjdvrqSnp9tc/uCDDypubm7a9mPGjFG6d+9e4X2053VR8rNq1apVCqDMmzfPZrvvvvtOAZRPPvlEuywqKkpxc3Oz+bvMzc1VAgIClHvuuafC43700UcKoCxbtszm8tdee00BlNWrVyuKoigXLlxQXFxcbL4PKIqiTJw4UQkNDdXet7755hsFUH744Qeb7Xbs2KEAygcffGAzbicnJ+0ztTKZmZlKy5YtlZkzZ9rs45prrim1bUFBgfZ+o/507drVrs8W9X26sh91X6mpqYq7u3upz5mzZ88qrq6uyqRJk7TLSr4nq0o+/xV9VtjzmhOirkl5vBAOoJbmluys3KdPHzp16lSq9LBZs2b06tVL+z0gIICQkBC6d+9uk1Hv1KkTQJlNX2699Vab3ydOnIizs7M2FoBTp04xadIkwsLCcHJywmAwMGjQIIBSJWcAN9xwQ6X39bLLLtOOt2zZMs6fP19qm7/++otLLrmEPn362Fw+ZcoUFEUpleW/5pprbM74d+3aFSj7fpc8zrBhw0pVQ0yZMoWcnBy2bNlS6f0py7Jly8jIyLApSZ06dSqKomiZUEArPX7ggQeqdZyqSExM5N577yUyMhJnZ2cMBgNRUVFA2c9lZYxGIy+//DKXXHIJLi4uODs74+LiwvHjx8vcX/GpIFD6OdqyZQt5eXmlXpf9+vXTxmmP3377DYPBgMFgoFWrVixbtoyHHnqIuXPnlhpP8eqCEydOcOTIEe34RqNR+xk9ejRxcXFaOf/ff//NsGHDCA0N1W7v5ORkVxb7999/x83NrVrlygC//PILQ4YMITw83GaMaq+F9evXa2P09vYu9bhPmjTJ7mNNmzaNwsJCvvzyS+2yxYsXExUVpWVUwTLdpX///nh5eWmvrYULF1brdVWWzZs3k5KSwuTJk23us9ls5qqrrmLHjh1aKXmfPn1YsmQJc+fOZevWrWVOWRg0aBBGo5FZs2bVyvjKExYWVuo9rGvXrjbvS7/88gudO3eme/fuNvdt1KhRpaYI7Nmzh2uvvZbAwEDt/fiOO+7AZDJx7Ngxm+P4+/szdOjQKo/XYDDg7+/PxIkT6dWrl81UIXufh+zsbHbu3Ml1112Hi4uLdnsvLy+bqo3ihg4dir+/v/Z7Xl4ef/75J9dffz0eHh6l/h7z8vK0KVB9+vRh37593H///fzxxx9kZGSU2r89r4uS1M+Zkp/LN954I56enqU+l7t3706LFi20393c3Gjfvr1dn0Oenp5MmDDB5nL1uOpxAgMDGTt2LJ9//rmWaVYrX+644w6t98Qvv/yCn58fY8eOtXncunfvTlhYWKlpJ127drWppqjI008/jcFgsOtv57777uOHH37g7bffZv369Xz33Xe4uLgwdOhQuxvRPfLII+zYsaPUzyOPPGKz3ZYtW8jNzS31XEVGRjJ06NAyp2/Yq+RnBdj3mhOirknQLkQtCAoKwsPDQysvrIxaoldW9+Hw8PBSJXwBAQGltnNxcSl1ufqFKS8vr9T2YWFhNr87OzsTGBioHSsrK4sBAwawbds25s6dy7p169ixYwfLly8HLOW3xXl4eJTbRba4gQMHsnLlSoxGI3fccQfNmzenc+fOfPPNN9o2ycnJ5T4W6vXFBQYG2vyuliyWHGNJVT2OvRYuXIibmxtXXXUVaWlppKWl0bVrV62c2mQyAZZpAE5OTqWei9pmNpsZOXIky5cv58knn+TPP/9k+/bt2pfeyh6nsvznP//h+eef57rrruPnn39m27Zt7Nixg27dupW5v8qeI/WxLuuxqMrjc+WVV7Jjxw527tzJoUOHSEtL491337UJHqD035patvv4449rQb/6c//99wNo8/+Tk5OrPc6kpCTCw8OrVa6sjvPnn38uNcZLL7201BiLn1SoyhhVAwYMoH379tqJpn///Zfdu3dz5513aiXby5cvZ+LEiURERLB06VK2bNnCjh07mDp1apnvO9WhPjcTJkwodb9fe+01FEXRls/87rvvmDx5Mp999hl9+/YlICCAO+64wyFLl5V8zYPldV/87yMhIYF///231P3y9vZGURTt+Tx79iwDBgzg/PnzvPPOO2zcuJEdO3Zo87tL/s1Vp5P92rVr2bFjB3/88Qc33HADGzZs4KGHHrIZK1T+PKSmpqIoSpmvv7IuK2u8ycnJGI1GFixYUOpYo0ePBope6zNnzuSNN95g69atXH311QQGBjJs2DCbZTar87pITk7G2dm51NQanU5HWFhYpZ9DUPr5Lu84YWFhpeb6h4SE4OzsbHOcqVOncv78edasWQPAN998Q35+vk2wmpCQQFpaGi4uLqUeu/j4+FJ9TOx9rWzfvp0PPviAefPmkZeXp322qSXsaWlp2hz8VatWsXDhQj7++GNmzJjBwIEDmThxImvWrCElJcXuaSnNmzend+/epX6aN29e6jEs776U9R2qKsrapz2vOSHqmsxpF6IWODk5MWzYMH7//XdiYmJKfcCUpH7Yx8XFldo2NjbWZj57bYmPjyciIkL73Wg0kpycrI3lr7/+IjY2lnXr1mnZdaDcOVv2NGdTjRs3jnHjxpGfn8/WrVt55ZVXmDRpEi1btqRv374EBgYSFxdX6naxsbEAtfZ41MVxjh07xqZNmwBssi7F/fHHH4wePZrg4GBMJhPx8fHV+pKtNvMp3qwIKPWl7MCBA+zbt48lS5YwefJk7fITJ05U+ZgqdW7ryy+/XOrYarOhqlBfd2V9iY6Pj7d7/WRfX1+tgVZFSr5e1ed65syZNg2dilPn1QcGBpY7zsoEBwezadMmzGZztQL3oKAgunbtyksvvVTm9eoJp8DAQLZv316tMRY3depUnn76abZv387XX3+NXq+3CRCWLl1Kq1at+O6772we05KvybLY+/pVn5sFCxbYrAxQnBoMBgUFMX/+fObPn8/Zs2f56aefePrpp0lMTGyQq3UEBQXh7u5ebsMy9b6vXLmS7Oxsli9fblN5snfv3jJvV5X3Y1W3bt20440YMYJRo0bxySefMG3aNC677DK7n4fCwkJ0Ol2Z89fLe/2VHK+/vz9OTk7cfvvt5VYitWrVCrCccP7Pf/7Df/7zH9LS0li7di3PPPMMo0aN4ty5c3h4eFTrdREYGIjRaCQpKckmcFcUhfj4eK1qrKYCAwPZtm0biqLYPA6JiYkYjUabz6FRo0YRHh7O4sWLGTVqFIsXL+byyy+3WaUiKCiIwMDAcu+Xt7e3ze/2vlYOHTqEoihcf/31pa47d+4c/v7+vP3228yYMUN7XZZ8jPz8/Gjbti0HDhyw65j2Kv4dqqSS36Hc3NxIT08vtV15TVnLenzsec0JUdck0y5ELZk5cyaKojB9+nRtre7iCgsL+fnnnwG0MsalS5fabLNjxw4OHz5sU4paW7766iub35ctW4bRaNS6qqofVCWbnn388ce1NgZXV1cGDRrEa6+9BljKPwGGDRvGoUOH2L17t832X3zxBTqdrtaWHxo2bJh2cqLkcTw8PMr9YloRtQHdp59+yt9//23zo5Zuq1/Q1ZLmytYQLy9boway//77r83laud5VV08lzqdrtT+fv311zKnO9jjiiuuwM3NrdTrcvPmzfWypm+HDh1o164d+/btKzOz07t3b+3L7pAhQ/jzzz9tghKTycR3331X6XGuvvpq8vLyWLJkSYXblfecjxkzhgMHDtCmTZsyx6gG7UOGDCEzM7PUa8GeZnnFTZ48GWdnZz7++GO++uorhg0bZhM06nQ6XFxcbL7YxsfH29U93t7Xb//+/fHz8+PQoUPlPjclKynActLswQcfZMSIEaXeSxqKMWPGcPLkSQIDA8u8X+pjVNbfsKIofPrpp3UyLp1Ox/vvv4+TkxPPPfccYP/z4OnpSe/evVm5cqXNZ19WVha//PKLXcf38PBgyJAh7Nmzh65du5Z5rLIy235+fkyYMIEHHniAlJSUUisTgP2vC/Vzt+Tn8g8//EB2dnatfS4PGzaMrKwsVq5caXP5F198YTMOQDuRoTbu27lzZ6mpNmPGjCE5ORmTyVTm41bdpp5XXXVVqc+0v//+m9DQUK644gr+/vtvrcRffR8quYpLcnIyx44dqzSRUVV9+/bF3d291HMVExOjTYNTtWzZkmPHjtmcLExOTtZW76gqe15zQtQFybQLUUv69u3Lhx9+yP3330+vXr247777uPTSSyksLGTPnj188skndO7cmbFjx9KhQwfuvvtuFixYgF6v5+qrr9a6x0dGRtbJeqbLly/H2dmZESNGaN3ju3XrxsSJEwHLXGJ/f3/uvfdeZs+ejcFg4KuvvmLfvn01Ou6sWbOIiYlh2LBhNG/enLS0NN555x2b+fKPPvooX3zxBddccw0vvvgiUVFR/Prrr3zwwQfcd999ds+/q8zs2bO1OcKzZs0iICCAr776il9//ZV58+ZV2Hm+LEajkS+++IJOnTpx1113lbnN2LFj+emnn0hKSmLAgAHcfvvtzJ07l4SEBMaMGYOrqyt79uzBw8NDK03t0qUL3377Ld999x2tW7fGzc2NLl26cNlll9GhQwcef/xxjEYj/v7+rFixQsv0qzp27EibNm14+umnURSFgIAAfv75Z63EsjrGjBnDkiVL6NixI127dmXXrl28/vrr1f4y5u/vz+OPP87cuXO56667uPHGGzl37hxz5syp8+kDqo8//pirr76aUaNGMWXKFCIiIkhJSeHw4cPs3r2b77//HoDnnnuOn376iaFDhzJr1iw8PDx4//33Sy3RVZZbbrmFxYsXc++993L06FGGDBmC2Wxm27ZtdOrUSeuq3KVLF9atW8fPP/9Ms2bN8Pb2pkOHDrz44ousWbOGfv368fDDD9OhQwfy8vI4ffo0v/32Gx999BHNmzfnjjvu4O233+aOO+7gpZdeol27dvz222/88ccfVXpMwsLCGD16NIsXL0ZRFKZNm2Zzvbpc1P333691/P/vf/9Ls2bNOH78eIX7tvf16+XlxYIFC5g8eTIpKSlMmDCBkJAQkpKS2LdvH0lJSXz44Yekp6czZMgQJk2aRMeOHfH29mbHjh1aJ3PV+vXrGTZsGLNmzbJrbq7JZOJ///tfqcs9PT21E2/VNWPGDH744QcGDhzIo48+SteuXTGbzZw9e5bVq1fz2GOPcfnllzNixAhcXFy45ZZbePLJJ8nLy+PDDz8kNTW1RsevSLt27bj77rv54IMP2LRpE1deeaVdzwPAiy++yDXXXMOoUaN45JFHMJlMvP7663h5eWlTGSrzzjvvcOWVVzJgwADuu+8+WrZsSWZmJidOnODnn3/W5pyPHTuWzp0707t3b4KDgzlz5gzz588nKiqKdu3a2f26KEmtNnjqqafIyMigf//+Wvf4Hj16cPvtt9f8QQbuuOMO3n//fSZPnszp06fp0qULmzZt4uWXX2b06NEMHz7cZvupU6fy2muvMWnSJNzd3Uv10rj55pv56quvGD16NI888gh9+vTBYDAQExPD33//zbhx48rMllcmLCyszPdiddnK4suojR8/nlmzZnHfffcRExNDz549iYuL4/XXXycnJ6fUnPSa8vPz4/nnn+eZZ57hjjvu4JZbbiE5OZkXXngBNzc3baUBsKwk8PHHH3Pbbbcxffp0kpOTmTdvnl3T+1SVveaEqBcOaX8nRBO2d+9eZfLkyUqLFi0UFxcXxdPTU+nRo4cya9YsJTExUdvOZDIpr732mtK+fXvFYDAoQUFBym233aacO3fOZn+DBg1SLr300lLHKa+DKyW6nqudgnft2qWMHTtW8fLyUry9vZVbbrnFpku0oijK5s2blb59+yoeHh5KcHCwctdddym7d+8u1X26og7LJTuy/vLLL8rVV1+tREREKC4uLkpISIgyevRoZePGjTa3O3PmjDJp0iQlMDBQMRgMSocOHZTXX39d6+CtKEXdXV9//fUy7/fs2bPLHFNx+/fvV8aOHav4+voqLi4uSrdu3crsrF3ycSzLypUrFUCZP39+uduoHYnffPNNRVEsz/vbb7+tdO7cWXFxcVF8fX2Vvn37Kj///LN2m9OnTysjR45UvL29FcDm8Tx27JgycuRIxcfHRwkODlYeeugh5ddffy3VPf7QoUPKiBEjFG9vb8Xf31+58cYblbNnz5Z6nOztHp+amqpMmzZNCQkJUTw8PJQrr7xS2bhxY6nOvGon8O+//97m9upzV/yxNpvNyiuvvKJERkYqLi4uSteuXZWff/653G6/JZX3N1DWcct6zSiKouzbt0+ZOHGiEhISohgMBiUsLEwZOnSo8tFHH9ls988//yhXXHGF4urqqoSFhSlPPPGE8sknn1TaPV5RLF2lZ82apbRr105xcXFRAgMDlaFDhyqbN2/Wttm7d6/Sv39/xcPDo1T3/KSkJOXhhx9WWrVqpRgMBiUgIEDp1auX8uyzzypZWVnadjExMcoNN9yg/Y3fcMMNyubNm+3uHq/68ccfFUAJCAhQ8vLySl3/6quvKi1btlRcXV2VTp06KZ9++qn2PlNcye7ximL/61dRFGX9+vXKNddcowQEBCgGg0GJiIhQrrnmGu21lZeXp9x7771K165dFR8fH8Xd3V3p0KGDMnv2bCU7O1vbj/qatOf9QV19oKwf9e+wvO7xZb1Pl3w/VBRFycrKUp577jmlQ4cO2ntAly5dlEcffdRmhYKff/5Z6datm+Lm5qZEREQoTzzxhPL777+XeqzKO3Z51OcqKSmp1HUJCQmKl5eXMmTIEO2yyp4H1YoVK5QuXbooLi4uSosWLZRXX31VefjhhxV/f3+b7Sp6b42OjlamTp2qREREKAaDQQkODlb69eunzJ07V9vmzTffVPr166cEBQVpx5o2bZpy+vRpRVHsf12U9dzk5uYqTz31lBIVFaUYDAalWbNmyn333aekpqbabFfee4+9713JycnKvffeqzRr1kxxdnZWoqKilJkzZ5b596YoitKvXz8FUG699dYyry8sLFTeeOMN7fXi5eWldOzYUbnnnnuU48ePVzruqihvH3FxccqDDz6otG3bVnFzc1PCw8OVa665RlsxpCKVvU+//vrrZX5OffbZZ0rXrl21v6Nx48ZpK2oU9/nnnyudOnVS3NzclEsuuUT57rvvyu0eX9YYKnvNCVEfdIqiKHV7WkAI4Uhz5szhhRdeICkpqU7mygshhBAlFRYW0r17dyIiIli9erWjhyOEEI2alMcLIYQQQogamTZtGiNGjKBZs2bEx8fz0UcfcfjwYd555x1HD00IIRo9CdqFEEIIIUSNZGZm8vjjj5OUlITBYKBnz5789ttvpeZoCyGEqDopjxdCCCGEEEIIIRooWfJNCCGEEEIIIYRooCRoF0IIIYQQQgghGigJ2oUQQgghhBBCiAZKGtEBZrOZ2NhYvL290el0jh6OEEIIIYQQQogmTlEUMjMzCQ8PR68vP58uQTsQGxtLZGSko4chhBBCCCGEEOIic+7cOZo3b17u9RK0A97e3oDlwfLx8XHwaIQQQgghhBBCNHUZGRlERkZq8Wh5JGgHrSTex8dHgnYhhBBCCCGEEPWmsina0ohOCCGEEEIIIYRooCRoF0IIIYQQQgghGigJ2oUQQgghhBBCiAZK5rTbSVEUjEYjJpPJ0UMRFzEnJyecnZ1laUIhhBBCCCEuEhK026GgoIC4uDhycnIcPRQh8PDwoFmzZri4uDh6KEIIIYQQQog6JkF7JcxmM9HR0Tg5OREeHo6Li4tkOYVDKIpCQUEBSUlJREdH065dO/R6meEihBBCCCFEUyZBeyUKCgowm81ERkbi4eHh6OGIi5y7uzsGg4EzZ85QUFCAm5ubo4ckhBBCCCGEqEOSprOTZDRFQyGvRSGEEEIIIS4e8u1fCCGEEEIIIYRooCRoF0IIIYQQQgghGigJ2oVD6HQ6Vq5cWafHGDx4MDNmzKjTYwghhBBCCCFEXZKgvYnbvHkzTk5OXHXVVVW+bcuWLZk/f37tD6oSY8eOZfjw4WVet2XLFnQ6Hbt3767nUQkhhBBCCCFE/ZOgvYlbtGgRDz30EJs2beLs2bOOHo5dpk2bxl9//cWZM2dKXbdo0SK6d+9Oz549HTAyIYQQQgghhKhfErRXkaIo5BbkO+RHUZQqjTU7O5tly5Zx3333MWbMGJYsWVJqm59++onevXvj5uZGUFAQ48ePByyl5WfOnOHRRx9Fp9Npa9PPmTOH7t272+xj/vz5tGzZUvt9x44djBgxgqCgIHx9fRk0aFCVMuNjxowhJCSk1HhzcnL47rvvmDZtGsnJydxyyy00b94cDw8PunTpwjfffFPhfssqyffz87M5zvnz57npppvw9/cnMDCQcePGcfr0ae36devW0adPHzw9PfHz86N///5lnlwQQgghhBBCiNog67RXUV5hAVe98JRDjr1q9mu4u7javf13331Hhw4d6NChA7fddhsPPfQQzz//vBaA//rrr4wfP55nn32WL7/8koKCAn799VcAli9fTrdu3bj77ruZPn16lcaZmZnJ5MmTeffddwF48803GT16NMePH8fb27vS2zs7O3PHHXewZMkSZs2apY33+++/p6CggFtvvZWcnBx69erFU089hY+PD7/++iu33347rVu35vLLL6/SeFU5OTkMGTKEAQMGsGHDBpydnZk7dy5XXXUV//77L3q9nuuuu47p06fzzTffUFBQwPbt27XxCSGEEEKIi9vmIwf5e/8e/jPuxip9bxeiIhK0N2ELFy7ktttuA+Cqq64iKyuLP//8U5sv/tJLL3HzzTfzwgsvaLfp1q0bAAEBATg5OeHt7U1YWFiVjjt06FCb3z/++GP8/f1Zv349Y8aMsWsfU6dO5fXXX2fdunUMGTIEsJTGjx8/Hn9/f/z9/Xn88ce17R966CFWrVrF999/X+2g/dtvv0Wv1/PZZ59pgfjixYvx8/Nj3bp19O7dm/T0dMaMGUObNm0A6NSpU7WOJYQQQgghmp4Fvy4nNiWZPu06MqJ7b0cPRzQRErRXkZvBhVWzX3PYse119OhRtm/fzvLlywFL9vqmm25i0aJFWtC+d+/eKmfR7ZGYmMisWbP466+/SEhIwGQykZOTU6U59R07dqRfv34sWrSIIUOGcPLkSTZu3Mjq1asBMJlMvPrqq3z33XecP3+e/Px88vPz8fT0rPa4d+3axYkTJ0pVA+Tl5XHy5ElGjhzJlClTGDVqFCNGjGD48OFMnDiRZs2aVfuYQgghhBCiaYhLSSY2JRmA+LRUB49GNCUStFeRTqdrFKUuCxcuxGg0EhERoV2mKAoGg4HU1FT8/f1xd3ev8n71en2pufWFhYU2v0+ZMoWkpCTmz59PVFQUrq6u9O3bl4KCgioda9q0aTz44IO8//77LF68mKioKIYNGwZYSu7ffvtt5s+fT5cuXfD09GTGjBkVHkOn01U4drPZTK9evfjqq69K3TY4OBiwZN4ffvhhVq1axXfffcdzzz3HmjVruOKKK6p034QQQgghRNOy6+Qx7f+JErSLWiSN6Jogo9HIF198wZtvvsnevXu1n3379hEVFaUFpV27duXPP/8sdz8uLi6YTCaby4KDg4mPj7cJfvfu3WuzzcaNG3n44YcZPXo0l156Ka6urly4cKHK92PixIk4OTnx9ddf8/nnn3PnnXdqZesbN25k3Lhx3HbbbXTr1o3WrVtz/PjxCvcXHBxMXFyc9vvx48fJycnRfu/ZsyfHjx8nJCSEtm3b2vz4+vpq2/Xo0YOZM2eyefNmOnfuzNdff13l+yaEEEIIIZqW4kF7fFqKA0cimhoJ2pugX375hdTUVKZNm0bnzp1tfiZMmMDChQsBmD17Nt988w2zZ8/m8OHD7N+/n3nz5mn7admyJRs2bOD8+fNa0D148GCSkpKYN28eJ0+e5P333+f333+3OX7btm358ssvOXz4MNu2bePWW2+tVlbfy8uLm266iWeeeYbY2FimTJlic4w1a9awefNmDh8+zD333EN8fHyF+xs6dCjvvfceu3fvZufOndx7770YDAbt+ltvvZWgoCDGjRvHxo0biY6OZv369TzyyCPExMQQHR3NzJkz2bJlC2fOnGH16tUcO3ZM5rULIYQQQlzkzGYzu08VJZAS09McNxjR5EjQ3gQtXLiQ4cOH22SHVTfccAN79+5l9+7dDB48mO+//56ffvqJ7t27M3ToULZt26Zt++KLL3L69GnatGmjlYd36tSJDz74gPfff59u3bqxfft2m4ZwYGkYl5qaSo8ePbj99tt5+OGHCQkJqdZ9mTZtGqmpqQwfPpwWLVpolz///PP07NmTUaNGMXjwYMLCwrjuuusq3Nebb75JZGQkAwcOZNKkSTz++ON4eHho13t4eLBhwwZatGjB+PHj6dSpE1OnTiU3NxcfHx88PDw4cuQIN9xwA+3bt+fuu+/mwQcf5J577qnWfRNCCCGEEE3DqYQ40rKztN8T0lKqvFyzEOXRKfJqIiMjA19fX9LT0/Hx8bG5Li8vj+joaFq1aoWbm5uDRihEEXlNCiGEEELUrpPxsfx32ZdMH3EN/Tt1rvLtv9v0Nx/8/iPdW7Vlb/QJAH5+9iV8PKrfJFk0fRXFocVJpl0IIYQQQghxUVu9dyfRCXG8/9tKzGZzlW+vzmfv1/FS/Dy9AEiQZnSilkjQLoQQQgghhLionU1KAOB8ygV2nDhapdsWGo3siz4JQO+2HQj18wckaBe1R4J2IYQQQgghxEXtbFKi9v8VWzdV6baHYs6QV1iAn6cXrULCioL2dAnaRe2QoF0IIYQQQghx0So0GolLTdZ+33rsEHEpyRXcwtauE5bS+J5t2qHX67WgXdZqF7VFgnYhhBBCCCHERet8ygVMZjPuLq70atMeRVH4cfs/dt9+9ylL0N6rdXsAQn0tQXu8BO2ilkjQLoQQQgghhLhoqaXxLYJDGH/FAAB+27WN/MLCSm+bnZfHoXNnAOjV1hq0+wUAkCjl8aKWSNAuhBBCCCGEuGidu2AN2oNC6NvxUkL9/EnPyebv/Xsqve2+0ycxmc1EBATRzD8QQCuPj0+VoF3UDgnahRBCCCGEEBcttXN8i+BQnPR6ru3TD7CvId3uk0Xz2VVq0J6SlUGB0VjbwxUXIQnahRBCNGg5+fkUypceIYQQdeTshaLyeIAxvfticHLiyPmzHI45W+Ftd1qD9l5tOmiX+Xp44mowAJCUnlYHIxYXGwnaRY3NmTOH7t27a79PmTKF6667rt7Hcfr0aXQ6HXv37q3T47Rs2ZL58+fX6TGEEBY5+fnc/MaLPPDJO44eihBCiCZIURRtTntkkCVo9/P0YnCXHgCs3FZ+tj0xLZXohDgAerRuq12u0+m0ZnQJaSl1Mm5xcZGgvYmaMmUKOp0OnU6HwWCgdevWPP7442RnZ9f5sd955x2WLFli17b1FWgDdOnShbvuuqvM67755hsMBgMJCQl1Pg4hhP3OJMaTnpPN0fPnyC8scPRwhBBCNDGp2Vlk5eWi0+loHhisXX795VcC8Ne/uzmffKHM2y5c+xsA3Vq2wc/Ty+Y6Watd1CYJ2puwq666iri4OE6dOsXcuXP54IMPePzxx8vcttCO7pj28vX1xc/Pr9b2V1umTZvGsmXLyMnJKXXdokWLGDNmDKGhoQ4YmRCiPMW/7CRKiaEQQohaps5nb+YfoJW0A1wSGUWvNu0pMBp588dlKIpic7vD586was8OAO676tpS+w1Rg3ZpRidqgQTtVaSgUIDZIT8KSuUDLMbV1ZWwsDAiIyOZNGkSt956KytXrgSKStoXLVpE69atcXV1RVEU0tPTufvuuwkJCcHHx4ehQ4eyb98+m/2++uqrhIaG4u3tzbRp08jLy7O5vmR5vNls5rXXXqNt27a4urrSokULXnrpJQBatWoFQI8ePdDpdAwePFi73eLFi+nUqRNubm507NiRDz74wOY427dvp0ePHri5udG7d2/27Km4w+ftt99Ofn4+33//vc3lZ8+e5a+//mLatGmcPHmScePGERoaipeXF5dddhlr164td59lVQqkpaWh0+lYt26ddtmhQ4cYPXo0Xl5ehIaGcvvtt3PhQtFZ2//973906dIFd3d3AgMDGT58eL1URQjR0CWk1V7QnpadhclsruGIhBBCNCXacm9BtokbnU7Hf8bdiIuzgV0nj7F6707tOkVRePfX5QCM6nEZnSKjSu1XK4+XTLuoBc6OHkBjU4jCXBIdcuznCMEFXbVv7+7ubpNRP3HiBMuWLeOHH37AyckJgGuuuYaAgAB+++03fH19+fjjjxk2bBjHjh0jICCAZcuWMXv2bN5//30GDBjAl19+ybvvvkvr1q3LPe7MmTP59NNPefvtt7nyyiuJi4vjyJEjgCXw7tOnD2vXruXSSy/FxcUFgE8//ZTZs2fz3nvv0aNHD/bs2cP06dPx9PRk8uTJZGdnM2bMGIYOHcrSpUuJjo7mkUceqfD+BwYGMm7cOBYvXszkyZO1yxcvXkxoaChXX301Bw4cYPTo0cydOxc3Nzc+//xzxo4dy9GjR2nRokW1Hve4uDgGDRrE9OnTeeutt8jNzeWpp55i4sSJ/PXXX8TFxXHLLbcwb948rr/+ejIzM9m4cWOpM7pCXIzii80FrMl6tztPHOWxxR9yx+CRTBsxujaGJoQQogk4e8GSaY8MDi51XfPAYKYMHcUnq3/h/d9Wcnn7Tvh5erF23y4OnTuDu4sLd48cU+Z+Q/3VOe0StIuak6D9IrF9+3a+/vprhg0bpl1WUFDAl19+SbD1Teqvv/5i//79JCYm4urqCsAbb7zBypUr+d///sfdd9/N/PnzmTp1qjY3fO7cuaxdu7ZUtl2VmZnJO++8w3vvvacFym3atOHKKy3zhNRjBwYGEhYWpt3uv//9L2+++Sbjx48HLBn5Q4cO8fHHHzN58mS++uorTCYTixYtwsPDg0svvZSYmBjuu+++Ch+HqVOnMnr0aE6dOkXr1q1RFIUlS5YwZcoUnJyc6NatG926ddO2nzt3LitWrOCnn37iwQcftP8BL+bDDz+kZ8+evPzyy9plixYtIjIykmPHjpGVlYXRaGT8+PFERVnO1Hbp0qVaxxKiqUks9mWnJl98/jlyAIBfd21l6vCr0emqfwJUCCFE01Fepl1105VD+PPf3ZyMj+X931byn3E38vEfPwNw66ARBPn4lnm7okZ0ErSLmpOgvYoM6HiOEIcduyp++eUXvLy8MBqNFBYWMm7cOBYsWKBdHxUVpQXNALt27SIrK4vAwECb/eTm5nLy5EkADh8+zL333mtzfd++ffn777/LHMPhw4fJz8+3OVlQmaSkJM6dO8e0adOYPn26drnRaMTX11fbb7du3fDw8LAZR2VGjhxJ8+bNWbx4Mf/973/566+/OH36NHfeeScA2dnZvPDCC/zyyy/ExsZiNBrJzc3l7NmKl/uoyK5du/j777/x8vIqdd3JkycZOXIkw4YNo0uXLowaNYqRI0cyYcIE/K1naIW4mMXXUnn88djzACRnZnAsNoYOEZE1HZoQQogmQA3ao4LLDtqdnZx44rqbuO/j+azeu5O07CySMtIJ8w9gYv/B5e43zC8AsFSJKYoiJ4tFjUjQXkU6dDUqUa9PQ4YM4cMPP8RgMBAeHo6hWHMNAE9PT5vfzWYzzZo1s5mLrapuYzl3d/cq38ZsnXP66aefcvnll9tcp5bxV7d0XK/XM2XKFJYsWcILL7zA4sWLGThwIO3atQPgiSee4I8//uCNN96gbdu2uLu7M2HCBAoKyu5ardfrS42nZFM/s9nM2LFjee2110rdvlmzZjg5ObFmzRo2b97M6tWrWbBgAc8++yzbtm3T5vwLcbEqnqGo7lq3ZrOZE3Hntd+3HDkoQbsQQgjyCwu1aViRweUn5TpFRjH+igH8sGUD249bpng+cPU4m8Z1JQX5+KLT6SgwGknLzsLfy7t2By8uKtKIrgnz9PSkbdu2REVFlQrYy9KzZ0/i4+Nxdnambdu2Nj9BQUEAdOrUia1bt9rcruTvxbVr1w53d3f+/PPPMq9X57CbTCbtstDQUCIiIjh16lSpcahB7CWXXMK+ffvIzc21axzF3XnnncTExLB8+XKWL1/OtGnTtOs2btzIlClTuP766+nSpQthYWGcPn263H2plQpxcXHaZSWXr+vZsycHDx6kZcuWpe6PeuJEp9PRv39/XnjhBfbs2YOLiwsrVqyw6/4I0VTl5OeRmVu02kN1M+3nUy6QW5Cv/b75yMGaDk0IIUQTEJOchKIoeLm54+9ZuiKyuLtGjCbE1w+A7q3aMuCSrhVub3B2JtDLB7CtGhOiOiRoF5rhw4fTt29frrvuOv744w9Onz7N5s2bee6559i509Ix85FHHmHRokUsWrSIY8eOMXv2bA4eLP8LsJubG0899RRPPvkkX3zxBSdPnmTr1q0sXLgQgJCQENzd3Vm1ahUJCQmkp6cDlu72r7zyCu+88w7Hjh1j//79LF68mLfeeguASZMmodfrmTZtGocOHeK3337jjTfesOt+tmrViqFDh3L33XdjMBiYMGGCdl3btm1Zvnw5e/fuZd++fUyaNEnL/JfF3d2dK664gldffZVDhw6xYcMGnnvuOZttHnjgAVJSUrjlllvYvn07p06dYvXq1UydOhWTycS2bdt4+eWX2blzJ2fPnmX58uUkJSXRqVMnu+6PEE1VyXmACWmp1aqyOR4bA0BEQBA6nY6jsee4kJFeK2MUQgjROJyIO092iR5M2nz24JBKy9c9XN144ZYpDOnSnSevv9mucne1GV2iBO2ihiRoFxqdTsdvv/3GwIEDmTp1Ku3bt+fmm2/m9OnT2vrlN910E7NmzeKpp56iV69enDlzptLmb88//zyPPfYYs2bNolOnTtx0000kJlreJJ2dnXn33Xf5+OOPCQ8PZ9y4cQDcddddfPbZZyxZsoQuXbowaNAglixZomXavby8+Pnnnzl06BA9evTg2WefLbP8vDzTpk0jNTWVm2++2WZe/Ntvv42/vz/9+vVj7NixjBo1ip49e1a4r0WLFlFYWEjv3r155JFHmDt3rs314eHh/PPPP5hMJkaNGkXnzp155JFH8PX1Ra/X4+Pjw4YNGxg9ejTt27fnueee48033+Tqq6+2+/4I0RSpQXvzQEtFS25BPll5uRXdpEzHrEF7r7bt6dTcsgrElqOHammUQgghGrqtRw8x7b3XeWbpZzYnf89dUJvQ2dev6pLIlsy5eQoRgUF2ba82oyu+EooQ1aFT6mhdqQ0bNvD666+za9cu4uLiWLFihc3a3cuXL+fjjz9m165dJCcns2fPHrp3726zj/z8fB5//HG++eYbcnNzGTZsGB988AHNmzfXtklNTeXhhx/mp59+AuDaa69lwYIFVZqDnZGRga+vL+np6fj4+Nhcl5eXR3R0NK1atcLNza3Kj4MQtU1ek+Ji8eO2f3jrp+/p37EzB85Gk56TzaKHnqRNWHiV9vPY4g8tS76Nm0h6dhafrf2Nfh0v5ZXbp1d+YyGEEI3eQ5++y7+nTwHw5p330bttBwDmLvuSNft2cffIMdw6aHitH/ejVT/xzca/mNBvIA9dM77W9y8av4ri0OLqLNOenZ1Nt27deO+998q9vn///rz66qvl7mPGjBmsWLGCb7/9lk2bNpGVlcWYMWNs5j9PmjSJvXv3smrVKlatWsXevXu5/fbba/3+CCGEqF8J1sxEqL8/wdZ5hFUtMVQURSuPbxfenL4dLwVg18lj5BeW3WBSCCFE03H0/DktYAdY8tcfWra9eHl8XQj1U5d9S6uT/YuLR511j7/66qsrLO9VA+vymnylp6ezcOFCvvzyS4YPt5z5Wrp0KZGRkaxdu5ZRo0Zx+PBhVq1axdatW7Uu459++il9+/bl6NGjdOjQoXbvlBBCiHqjNu4J9fUnxNePE3Hnq9yMLik9jfScbJz0elqHNsPF2ZkQXz8S09PYffK4FsQLIYRomr7/Zx0Avdt24N/TJ9l/5hR7Th2nR+t2nLWWx0faWR5fVSHaWu1SHi9qpsHOad+1axeFhYWMHDlSuyw8PJzOnTuzefNmALZs2YKvr6/NsmBXXHEFvr6+2jZlyc/PJyMjw+ZHCCFEw5KYbg3a/QK0eYFVDdqPW5d6iwoOxdVgQKfT0beDJVDffFS6yAshRFOWlJ7GX/v3AHD3yDFc0+sKwJJtv5CRTm5BPk56PREB9s1Rr6owf8ta7SUbqwpRVQ02aI+Pj8fFxQV/a9dFVWhoKPHx8do2ISGlz4yFhIRo25TllVdewdfXV/uJjJT1eoUQoqFRM+1hfv6EWPuUqIG8vY7FngOgfXhRL5R+1uz6lqOHqtWNXgghROOwYtsmTGYzXVu2pkNEJJMGDcfg5MS+0yf5aYclwRceEIjBuW6Kj9Ul4tJzsskrkClZovoabNBeHkVRbJZYKGu5hZLblDRz5kzS09O1n3Pnztl1XCEaAnktiouB0WQi2bosW4ifP8Fapr1qQfvxWEumvV2xoL1H63a4GVxISk/jhDUTL4QQomnJKyjg5+2WwPzGfoMBSxA92ppt/2r9WgBaBIXW2Ri83T3wdLU0DU6o4ueXEMU12KA9LCyMgoICUlNtX+CJiYna8mNhYWEkJCSUum1SUpK2TVlcXV3x8fGx+SmPwWAAICcnpzp3Q4hap74W1demEE1RUkYaZkXBxdkZf0+vapfHH4uzNqFrVhS0uxoM9GrTHoDNR6REXgghmqI/9uwgIzeH8IBA+nfqrF1+66DhODs5YTKbAYisoyZ0qhA/+9Zqz8jJlsSMKFedNaKrqV69emEwGFizZg0TJ04EIC4ujgMHDjBv3jwA+vbtS3p6Otu3b6dPnz4AbNu2jfT0dPr161cr43BycsLPz09bV9zDw6PCLL4QdUVRFHJyckhMTMTPzw8nJydHD0mIOqPO/wvx9Uev12slhknpaZjNZvT6ys85p2VnkWQN8ts2i7C5rl/HS/nnyAG2HD3I5KGjanXsQgghHMtsNvO/zesBuKHvQJyKfWaE+vkzuuflWnm8vWu0V1eorz/RCXHalK+y/Pnvbl787gseuuZ6JvQbVKfjEY1TnQXtWVlZnDhxQvs9OjqavXv3EhAQQIsWLUhJSeHs2bPExsYCcPToUcCSPQ8LC8PX15dp06bx2GOPERgYSEBAAI8//jhdunTRusl36tSJq666iunTp/Pxxx8DcPfddzNmzJha7RwfFhYGoAXuQjiSn5+f9poUoqmKV5d7s2Yognx80el0FJpMpGZnEehdfoWUSl3qLSIwCE83N5vr+na4BIDDMWfJzM3B292jNocvhBDCgbYfP8LZC4l4uroxutflpa6/ddBwftu9DaPJRFRI3ZXHQ9HnWEWZ9mWb1gGwN/qkBO2iTHUWtO/cuZMhQ4Zov//nP/8BYPLkySxZsoSffvqJO++8U7v+5ptvBmD27NnMmTMHgLfffhtnZ2cmTpxIbm4uw4YNY8mSJTYZxq+++oqHH35Y6zJ/7bXXlrs2fHXpdDqaNWtGSEgIhYWFtbpvIarCYDBIhl1cFBKta9qqX3acnZwI8vYhKSOdxPQ0m6A9Oy+P/y77kj7tOjK+7wDt8uPW0vjiTehUgT6++Hp4kp6TTWJ6mgTtQgjRhPy8YwsA1/S+Ag9Xt1LXh/kHMPOGSZxJTODSyJZ1OhZtrfZy5rSfToznyPmzAFp1mBAl1VnQPnjw4ArnZUyZMoUpU6ZUuA83NzcWLFjAggULyt0mICCApUuXVneYVeLk5CQBkxBC1IOSmXaAYF8/kjLSSUpPpVPzFtrl6w/uY8vRg2w9doh24RF0iWoNFGtC16x00A4Q4O1Dek42KZkZtAkLr6u7IoQQop6ds66/fnn7TuVuM7xbr3oZSzPrsm+HY86UOb1r9d6d2v+TMtLqZUyi8WmwjeiEEEJcvNQ57cWD9pBymtH9e/okYOn78MoPX2vL6hyzlse3C7edz65Ss/XJmRm1N3AhhBAOpwa/aj8UR7qsXUc8XF05m5TIlqOHbK4zm802QXtKViZGk6m+hygaAQnahRBCNDiJWtAeoF2mlRiWmBf47+lTABicnDiffIFPVv9Cdl4eMclJQAWZdi9vQIJ2IYRoSrLz8sjJzwcgyMfPsYPBsuzb9ZdfCcDS9WtsKpH3Rp8gKT0NLzd3nJ2cUBRFPpNEmSRoF0II0aAoiqLN/QuzybT7AbaZ9gsZ6ZxPuYBOp+OZG28D4IctG/hhywYAgn188bcG5yVJpl0IIZoeNcvu5eaOh6urYwdjNaH/YFycDRw6d4Y90UWNulft2QHA0C49CPLxBWReuyibBO1CCCEalLTsLPILC9HpdAQXy5IUBe1FmXa1NL5tWARDu/RgTO++ACxc+xsA7cpoQqeSoF0IIZoeNegNbgCl8aoAL2+usXax/2r9WgBy8vPZcHAfAKN6XKZ93iVlpDtkjKJhk6BdCCFEg6KWvwd6+WBwLuqXGqzOabd2lgfYZy2N79bK0nzugdHjbLLz5ZXGQ1HQnpIlQbsQQjQVajVWsDVz3VDcNGAITno9O08c5UjMWTYe+pfcggIiAoK4tEVLgn2tmXZpRifKIEG7EEKIBkVrQufvb3O5Oqc9OStDa9Szz5pp7xrVBgAPVzeeGn+LdpvymtABBHpbviBJpl0IIZoONehtSJl2gGb+gVrH+q82rOUPa2n8yB690el0hKiZdimPF2WQoF0IIUSDoi335msbtPt5eGKwNuq5kJFORk420QlxAHRt2Vrbrmeb9jw4+joGXdqNPu06lnscLdMuQbsQQjQZSemW8vKQBtCErqRJA4cBsPHQfnafOg7AyO69gaKTDJJpF2WRoF0IIUSDos5ZL77cG4Ber9e+1CSmp7H/TDQALYJDSjWbu7H/YF6cdCeuBpdyjxNgDdpzCwrIyc+rreELIYRwoIaaaQdoGRLGgEu6oigKiqLQtWVrwgOCAIrmtKfLnHZRmgTtQgghGpT41NLLvanUtdoT0lNLlcZXlYerK+4uls7CUiIvhBBNQ1EjuoY1p11166Dh2v9Hdb9M+7/MaRcVkaBdCCFEg6LNaS+RaYeiDvJJ6ansi7YE7d1aVS9oB+kgL4QQTY3afT24AZbHA3Rq3oLrrxhA91ZtGdq1h3a5Ot4LGemYzGYHjU40VM6VbyKEEELUn/LK46Eo034mMYHjcTEAdGtZ/aA9wNubmOQkCdqFEKIJyC3IJzM3Byj6vGiIZoy9odRlAd4+OOn1mMxm0rIyCWxg3e+FY0mmXQghRIORW5BPek42AGFllMeH+vkBsOnwfkxmM6F+/mUG9/aSTLsQQjQdF6xZdg9XVzzd3Bw8mqpx0uu1XiuJsla7KEGCdiGEEA2GWhrv5eZW5hcuNXOSlWdpHNe1Bll2kA7yQgjRlGjz2RtoaXxl1LXlZdk3UZIE7UIIIRqMovnspbPsULobcE1K40Ey7UII0ZQkNuDO8faQZd9EeSRoF0II0WAkqGu0l1PyXvLybsXWZ6+OAAnahRCiyVCXSwtupPPBQ7Rl39IcOg7R8EjQLoQQosGIVzPt5TQQ8nJzx8PVskybv6cXkUEhNTpeoLfli52UxwshRONXtNybn0PHUV1FmXaZ0y5sSdAuhBCiwYi5kARARGBQuduo89q7tmyDTqer0fGkPF4IIZqORJnTLpooCdqFEEI0GGeSEgCICgktd5uIAEtAX5P12VVq0J6Rm0OB0Vjj/QkhhHAcdS54SKPPtKc5dByi4ZGgXQghRINgNJmISbZk2lsElR+03z1qDHcNH83Yy/rV+Jg+7h44OzkBUiIvhGg4FEXh39OnyCsocPRQGpVGXx5fbE67oiiOHYxoUCRoF0II0SDEpSZjNJlwM7hUmCVpGRLG7UNG4uLsXONj6nQ6Ary8ASmRF0I0HBsP7eehT9/l/d9XOnoojUZ+YSHpOdlA421EF+jtg06no9Bk0u6LECBBuxBCiAbiTKKlND4yKAS9vv4+nrS12rMkaBdCNAwn488DsOnQAcm42umCtXmbq8GAt7uHg0dTPQZnZ/w9LSeSE2VeuyhGgnYhhBANwtkLlc9nrwvSjE4I0dCkZmUBlpOJaq8PUTF1Hniwj1+Nm5Q6kjSjE2WRoF0IIUSDoGbaW9RwGbeqkrXahRANTWp2pvb/PaeOO3AkFmazucE362zs89lVwb7WoF2a0YliJGgXQgjRINjTOb4uSKZdCNHQqJl2gN0ODtrNZjPT33+Dye+8QlZerkPHUpHG3jleVdSMTtZqF0UkaBdCCOFwiqJwNikRgKjg+g7aLVkN6R4vhGgo0mwy7Scwm80OG0tyZgYn4mOJTUnmx23/OGwclUm0BrmNdY12lSz7JsoiQbsQQgiHS87MIDs/D71OR0RgcL0eWzLtQoiGJjWrKGjPzM3hRHysw8ZyPuWC9v9l/6xrsMvQFZXHN87O8SotaJc57aIYCdqFEEI43FlraXx4QFCtLOVWFRK0CyEakgKjkay8PAAubdEScOy89vPJRUF7WnYWv+3a5rCxVKR4I7rGTGtEJ5l2UYwE7UIIIRxOnc/eIrh+m9BBUdCempWJyYElqEIIAZbAGMBJr2fgJV0B2H3SkUF7EgC+Hp4AfLPxTwobYFM6dQ54429E5wdY7o8s9ydUErQLIYRwOLVzfH3PZwfw8/RCp9NhVhTSc7Lr/fhCCFGcWhrv7+lNrzbtAdh3+iRGk8kh44mxlsffdOUQArx8SExPY82+XbWy7+iEODYd2l/j/RQajVrH/cbfiM6Sac8rLGjQjf9E/ZKgXQghhMOdvWBtQlfPneMBnJ2c8LNmkJIzpFuvEMKx1KDdz8uLNmHh+Lh7kFuQz5HzZx0yHrU8vnVoM266cjAAX29YWyuVSbO+WcyzXy3kdGJ8jfaTnJmBoigYnJy0ioDGytXgot2HRJnXLqwkaBdCCOFwRWu013/QDjKvXQjRcKjl8QFe3uj1enq0bgfAHgeUyCuKopXHRwQGcW2ffni7e3DuQhIbDv5bo33nFRRoq4YUnzdfHdp8dl8/dDpdjfbVEGjz2iVoF1YStAshhHCorLxcLmRaMtyOmNMOECBBuxCigUhRM+2eXgBa0O6I9dpTsjLJLShAr9MR5h+Ih6sbE/oOBGDputU1mnMdYz0ZAJCcWbMqJ61zfCNvQqcqWvbN9nHJLyyUee4Xqfpt0SuEEEKUcM6aaQnw8sHb3cMhY1Az7bJWuxDC0dRMu7+XNwA921iC9gNno8kvLMTVYKi3sagZ8BA/f21lj/F9B/Dtpr85ER/LtmOHuaLDJdXat7pqCMCFjJq996rBbWNvQqdSTz6oJyPMZjMLflvBj9v+wUnvRIivH6F+/oT4+jGie2+t94FouiTTLoQQwqHUzvGOmM+uCvS2lCJKpl0I4WhaIzpr0N4iKIRAbx8KjEYOnjtdr2M5n2ItjQ8I0i7z8fBkeLeeAOyJPlHtfau9TAAu1LCfSFGmvXGv0a4qyrSnYTabeePHZSzfshGT2UyBsZCY5CR2nTzG77u3M/ubJRQ0wG7+onZJpl0IIYRDacu9BTmmNB6KzWnPkqBdCOFYRd3jLeXxOp2Onq3bsWbfLvacPE5Pa7l8fVAz7RGBQTaXRwQGAzU70XnuQlF5/IUalserDduaTKbd13LyISEtlTdWLuPXXVvR63Q8Nf4WukS1JjE9lYT0VD5e9QspWRlsO3aIAdblAUXTJJl2IYQQDnW2QWTaZU67EKJhSLWWx6tz2sFx89rVoL25NUhXae+ZNciQFy+Pr+nKHWojusa+3JtKLY/fdfKYFrA/c+NtXNWzDxGBQfRo3Y6revRhRPdeALW2BJ9ouCRoF0II4VBaebwD1mhXFc1pz3TYGIQQAiAtq6h7vEqd13445gwZOdn1NhYt0x5gm2kPquGJTkVRSmTaazinvYk2ogPQ63Q8N/F2RnTrVWq74dbLthw5KGu6N3EStAshhHCYQqOR2JRkAFo4MGgP8LZ8OVbX+hVCCEcwm82kZqvrtBcF7c38A2kbFo7JbOaXnVvqZSyKohTNaS9RHl/TFTcuZKSTW5Cv/Z6WnUVhNedlG00mbRxNpTw+1NcfdxcXnPR6np94O8O69ixzu3bNIogKDqXAaKzxEnyiYZOgXQghhMOcT7mAyWzG3cXVoQ2E1Ex7gbFQshVCCIfJysvFZDYDtuXxABP6DwJg+ZaNGE2mOh9Lek42WXl56HQ6wktk2tX3zKy8XPILC6q8b7UJXfPAYAxOTkDRUndVlZKViVlRcNLrtT4AjZ2biwvvTn+Yj+/7D0PLCdjB0u9AzcCv2buzvoYnHECCdiGEEA5zJtHahC44BJ1O57BxuBpc8HJzA2ReuxDCcdT57F5u7toSa6phXXsR4OVNUkY66w7srfOxqKXxwT6+pZaZ83Jz1y6rznvmWetSny2CQwi0nrCtbgf52BTLOEP9/NHrm05o0z68Oe3Cm1e6nVoivyf6hDZNQDQ9TeeVLYQQotE52wDms6sCZK12IYSDFS33Vjpj7OLszLjL+wPw/T/r63wqz/kUtXN8cKnrdDqdlm2vzhrrZy8UrRoS5F2zoP10YjzQMD5HHKFZQCCdW7RCURT+2r/H0cMRdUSCdiGEEA7TENZoV8la7UIIR0vNUjvHe5d5/bg+/XFxdubI+bMcPHu6TsdyPrn0Gu3F1eQ985yWaQ8l0Mca/Fdz2beiz5Gwat2+KRiulchLF/mmSoJ2IYQQDlO0RntDCNpl2TchhGOpmfbineOL8/fy1gK0ZZvX1elYylujXVX0nln1YPucdU57ZLFMe3WXfVOnWbVsACd/HWVIl+446fUcj4vRKg9E01JnQfuGDRsYO3Ys4eHh6HQ6Vq5caXO9oijMmTOH8PBw3N3dGTx4MAcPHrTZJj8/n4ceeoigoCA8PT259tpriYmJsdkmNTWV22+/HV9fX3x9fbn99ttJS0urq7slhBCilliW/Cma1+hokdYS0J0njpa7zbkLiXy78a96aQIlhLj4aJ3jK2ioNqGfpSHdxoP/EpeaXGdjibFm2ptXGrRX7URnXkEB8WmpgOW9P0jLtFfvhKkapLYMvngz7X6eXvRp1xGAtbJme5NUZ0F7dnY23bp147333ivz+nnz5vHWW2/x3nvvsWPHDsLCwhgxYgSZxdbInTFjBitWrODbb79l06ZNZGVlMWbMGEzFvixNmjSJvXv3smrVKlatWsXevXu5/fbb6+puCSGEqCWWJX8KcNLryy2/rE+jelyGTqdjx4mj2smE4sxmM88uXciHq36SL0VCiDpR1hrtJbUJC6dXm/aYFYXlWzbW2ViKMu2l57QDWrBd1aBdPRng4+6Br4enVmZfnTntmbk52vEduWxoQ6BWYKzdt1uWLm2C6ixov/rqq5k7dy7jx48vdZ2iKMyfP59nn32W8ePH07lzZz7//HNycnL4+uuvAUhPT2fhwoW8+eabDB8+nB49erB06VL279/P2rVrATh8+DCrVq3is88+o2/fvvTt25dPP/2UX375haNHy8+U5Ofnk5GRYfMjhBCifqlf3ML8AjCU6JLsCM0CArmifScAftz2T6nrNx0+oJXzH409V69jE0JcHNRlz/zKaERX3MT+gwH4dedWcvLzan0cGTnZZOTmABAeEFjmNgFaI7qqBdvqcm+R1lVD1OU+qzM1SX1PDvb1w9O6AsjF6spOXXB3cSUuNZn9Z6IdPRxRyxwypz06Opr4+HhGjhypXebq6sqgQYPYvHkzALt27aKwsNBmm/DwcDp37qxts2XLFnx9fbn88su1ba644gp8fX21bcryyiuvaOX0vr6+REZG1vZdFEIIUYlzF6yll0FlZ3Ec4brLrwTg993byC3I1y5XFIWv1q/Vfj8ZF1vvYxNCNH1p1iXf/MtpRKfq064jLYJCyM7PY3UdrM99PsVSdh/o7YO7i2uZ26hz0au64oa6akhkkGVaVE2WfNPms1/kWXawrO0+uHM3AH7aUX4cJBonhwTt8fGWuSehobZ/YKGhodp18fHxuLi44O/vX+E2ISGl50GGhIRo25Rl5syZpKenaz/nzknGRAgh6lvRfMmGE7T3adeRiIAgsvLyWLtvt3b5rpPHOHL+rLaW/Mn4WCk/FELUOnVOu38F5fEAer1eK4euiy7y5+14f67unHb1hG0La9CuBv9ZebnkFRRUaV/acm8XcRO64sb1sSwJuG7/Hu0EkGgaHNo9Xv3yo1IUpdRlJZXcpqztK9uPq6srPj4+Nj9CCCHqV4z1i1tkA8q06/V6bR3klVs3aoG5mmUf27svTno9WXm5JKanOWqYQogmqqJ12ktqExYOwKmEuFofR2Wd46EoaM/IzSG/sNDufRct92YJ2j1cXXF3cQGqvuybttzbRdyErriOzVvQPrw5hSYTv+/e7ujhiFrkkKA9LMzyh1UyG56YmKhl38PCwigoKCA1NbXCbRISEkrtPykpqVQWXwghRMNyLtnyxa0hZdoBru7ZBxdnAyfiYzlwNppD506z+9RxnPR6bhs8Qmt2dDJeSuSFELUnv7CAnHzLtJyKuserWoU2Ayzl5rW9osX5lMqDdm93D1ys/UhSsuzLtiuKUjSn3Zpp1+l0RWu+V7HP1Bm1c/xFvEZ7cTqdTsu2/7x9M2az2cEjErXFIUF7q1atCAsLY82aNdplBQUFrF+/nn79+gHQq1cvDAaDzTZxcXEcOHBA26Zv376kp6ezfXvRmaRt27aRnp6ubSOEEKLhMZnNxFrnTDakOe0APh6eDOvaA4AVWzdpWfaR3XsT6udPW2t2S4J2IURtSsvOBsDg5ISXm3ul2zfzD8DdxYUCo1ELsqur5HQfLdMeUP77s06n05rR2RtsW1YNyS+1akjRsm/2Z9pz8vO1peOkPL7IsG498XJz43zKBXaeLL8xt2hc6ixoz8rKYu/evezduxewNJ/bu3cvZ89a5gTOmDGDl19+mRUrVnDgwAGmTJmCh4cHkyZNAsDX15dp06bx2GOP8eeff7Jnzx5uu+02unTpwvDhwwHo1KkTV111FdOnT2fr1q1s3bqV6dOnM2bMGDp06FBXd00IIUQNJaSlYDSZcHF2JsTXv/Ib1LPrrxgAwLoDe9l0+AA6nY5JA4cB0FoL2s87bHxCiKanqHO8d6XTRcEynUfNMJ+Kr36J/Bsrv+PGeXP45/AB7TJ1TntFmXYomo9u77x2NcvezD/QZtWQ6iz7pi7N6e/pha+Hp923a+rcXVwZ1aMPUPZKKKJxqrOgfefOnfTo0YMePSzZiv/85z/06NGDWbNmAfDkk08yY8YM7r//fnr37s358+dZvXo13t5FjTfefvttrrvuOiZOnEj//v3x8PDg559/xsnJSdvmq6++okuXLowcOZKRI0fStWtXvvzyy7q6W0IIIWqB2oQuPCAIJ71D26uUqUNEJJdERmGylhYOvKSrVhbftplk2oUQtS9Nnc9uR2m8Si2Rj67mvHajycQfe3aSlJHOM0s/473fVpCWnUWqtYlZ8Wx4WdR57fZmyM8m2ZbGq4KqsexbURM6KY0v6do+lorjzUcOkpiWWsnWojGos4VxBw8eXGFnXZ1Ox5w5c5gzZ06527i5ubFgwQIWLFhQ7jYBAQEsXbq0JkMVQghRz7Tl3hrYfPbirrv8Sg6dOwPArYOGa5e3CbUE7TEXksgvLMDV4OKQ8QkhmhY1UK6sc3xxra1Be3Wb0Z29kEiBsRC9TodZUfj+n/VsOmTJuPt7elW69nmgT9U6yKvZcbUJnSqoGsu+qfPZo2S5t1JahoTRvVVb9kaf4OcdW5g2YrSjhyRqqOGlN4QQQjR52nJvDWw+e3FDuvRgaNce3DpoOB0iIrXLA7x98PXwxKwoRCeUv7yoEEJURaoDMu3HYi3LHneOasXLt92Ft7sHcamWfiMRdpxUreqyb+oa7S1KZtq1/dgftJ9W12iXTHuZrrv8SgB+2bm11hsVivonQbsQQoh6py331oAz7S7Ozsy+aTJ3jxxjc7lOp6NtswhASuSFELVHXaPdryqZdmuPjfMpF6q8xjnA8dgYANqHN6d/p84sfPAJukS1slwW0bzS22tBu50ZcjXTHlki0x5ozbQnVSXTnqQG7ZJpL8uAS7oQ4OVDSlYGGw/td/RwRA1J0C6EEKLeNYZMe0Vah1myWxK0CyFqS1qWpTw+oApBe4CXN36eXiiKogWxVXHMGrS3C7cE6KF+/syf9iDzpz1Q6oRlWarSiC6voICE9DSgrEx70ZJvFU2vVeUXFhJr7Zgv5fFlc3ZyYkzvKwBYvXeHg0cjakqCdiGEEPWq0GgkPjUFaNiZ9oq0DVMz7dJBXghRO7Tu8VUoj4eiEvlTCVU7iWg2mzkea3kPax9eNAXI2cmJHq3b4e7iWuk+AqpQHh+TnISiKHi7e5S6j2rGPq+wgOz8PLv2ZVYUvNzctTGI0nq2aQdQrRM6omGRoF0IIUS9ik1NxqwouLu4NtovW0XLvsXZlRUSQojKpGVXPdMOxZrRVXHZt/MpF8gtyMfVYCiV+baX2kAuPSebQqOxwm1X790JQKvQsFJL2rm5uGhr09vTjE5tQtcypPS+RBG1+398aorMa2/kJGgXQghRr2KKdY5vrF+2WoaE4aTXk5mbU6U5mEIIUZ5Ua3l8dTPtVW1Gp5bGtwkLx7nYcspV4ePugcF6W7VSoCynEuL43+b1ANw6cHiZ21Rl2Te1CZ2UxlcsyMcXF2dnTGYzSdapCaJxkqBdCCFEvdIaETXS+exgaVKnZqZOxlWtRN5kNrN23y5W790pWXohBGApVU/PqfqSb1D9Zd+OaU3oIivZsnw6nU6rmCovQ64oCvN/+h8ms5krO3Xhig6XlLldYCX7Ke50krpGuwTtFdHr9YT5BwCWygrReNXZOu1CCCFEWbQmdI10PruqdVg40YnxnEyIpW/HS+26zYGz0bz783KOWpdZWn9gH0/fcAve7h51OVQhRAOXkZuDyWwGqpNptyx5lpyZQXpONr4ennbdrnjn+JoI9PYhIS213Az52n272Hf6JK4GAw9dc325+wnWMu32lMfLcm/2iggI4mxSorVxXwdHD0dUk2TahRBC1KtzFxp353hV22bWee1xlTd/Ss5I56Xvl/LAx+9wNPYcnq5uGJyc2HR4P3d/8CbHzp+r6+EKIRowdT67j7tHlUvVPVzdtGyqvSXyiqKU6hxfXYHe5QfbWXm5fPD7jwDcPnikNs4y92MN2i9kVFwebzSZtJO/Uh5fuXDrvPbzKckOHomoCQnahRBC1KvzTSXTHqo2o6s4aD8Rd57b5r/M6r070el0XNPrCr76z7O8d/cjhPkHEJuSzAOfvMNP2/+RcnkhLlJa53ivqmXZVa2rOK89Pi2FzNwcnJ2caFXDbHVQBR3kF639nZSsTCKDgrnpyiGV7EcN2ivOtJ9PuYDRZMLdxYUQX7/qDfoiEh4QCKAtkScaJwnahRBC1JvcgnytcVtjntMO0LaZZdm3cxcSyS8sKHe7/21eT05+Pm2bRfDhvY/y5Pib8ffypmPzFnz2wOP079iZAqORN3/8nt92bauv4QshGpA0a9Be1c7xqlZV7CCvlsa3Dm2Gwblms2UDywnaT8SdZ8XWjQDMGDsBl0qOE+RjndNeSXm82jm+RXAoer2EMpVRO8jHJkvQ3pjJK10IIUSt2HBwn1ayWJ7z1i8NPu4e+Ng577KhCvT2wdfDE7OiaJ2MSzKaTGw+chCAB0ZfR6fmLWyu93b34KXbpnGzNQP1/eb1km0X4iJUtEZ79YL2qjajq63SeKDcRnSfrv4Vs6IwpEt3eretfC61VmZfSab9jHSOr5LwwKLyePl8abwkaBdCCFFjB85E8/zXi3nok3fJyMkud7umMp8dLF2T21jXaz9RTgf5/WdOaY2huka1Lnc/tw0egavBQHRCHAfPna6rIQshGih1Trt/FZvQqVpb34uiE+LsCsyO1VITOihaqi2lWKb9QkY6248fBuCu4ddUaT8XMjMqvA9nkqxBu3SOt0sz/0B0Oh25Bfna60w0PhK0CyGEqLEj588ClmzR+7+tLHe7ptI5XqUG7acSyp7XvvHQfgD6dry0wuZS3u4eDOncHYBfdmyp3UEKIRo8dY32qi73pooMDMZJryc7P4/EStbjVhRFa35ZG0G7tlRbsaB97b5dmBWFLlGt7D5Jq04NMJpMpFdw8vdskmXZUMm028fF2VnrzC/LvjVeErQLIYSoseLzKFft2cG2Y4fL3C5GW6M9pF7GVdfaWDvIHzp3ptR1iqKw6bAlaB94SddK9zX2sn4A/LV/D1l5ubU4SiFEQ5dqLY/3r2YjOoOzMy2sQWxlzeiSMzNIzc7CSa/XTjzWhJohT8vOwmgyoSgKq/bsAGBk98vs3o/B2Vlb7q685eMUReHsBUumvYUE7XZTO8jHSgf5RkuCdiGEEDUWnWj5kqhmPt78cRk5+XmltouxzmlvCuXxAL1at8dJr+fQuTMcKlHWfiw2hoS0VNxdXOjdtn2l+7q0RUtahYSRX1jImr276mjEQoiGKDW7ZnPaoWi99vIqf1RqaXyL4FBcDS7VPp7Kx90DJ2tDuJSsTI7HnSc6IQ4XZ2eGdOlepX0FlTM/XpWUkU5uQQFOer3WYE1UTprRNX4StAshhKgRs9lMdIKlm+8zE24lPCCQhLRUPv7jl1LbnrNm2ptKeXyInz8juvcG4Mt1a2yu23DwXwD6tO9k1xdjnU7HmMv6AvDLjs3SMEiIi0iStaRdLTWvDnUZylPW9+PyHIutvdJ4AL1erzWjS85IZ7U1y96/U2e83T2qtK8gHz+g/KD9rHU+e0RAUJXXs7+YhQdaln2T8vjGS4J2IYQQNZKQlkpuQT4GJyfaNovgietuAmDltk3siz6pbZeZm6PNU2wqQTvArQOHodPp2HzkoM2a7RsPWYL2AXaUxqtGdu+Ni7MzJ+JjOWKdcyqEaNoycrK1pTBr0lxN6yAfX3Gm/XgtNqFTqRnyhPRU1uyzVAqNqkJpvCrQp+JMuzqfvUVw05hiVV+kPL7xk6BdCCFEjahLDLUIDsXZyYmebdozprclY/zS/5byyR8/89P2f1i9dydgySR5uLo6bLy1rUVwqNZEbqk12342KYEzSQk4OznRt8Mldu/Lx8OTQZd2A+DnHZtrfaxCiIZHfQ8N8w/Ay8292vtpH94cnU7HyfhY/tq/p9ztanO5N5VaIfD7ru2kZWfh7+nFZe06Vnk/QdZl3yrLtMt89qrRyuMl095oSdAuhBCiRtT57GqWB+C+q68l2MeXhLRUvtrwJ2/++D3v/rIcgMgmMp+9uNsGjwDg7wN7OZuUoHWN79m6XZW/hGsN6f7dXWZfACFE06JW6LQJrVlTuGBfP24dOByA11d8y/ky5i+nZWeRmJ6GTqejXbOIGh2vOHWN9a3HDgEwvFuvapWvR1jXFI9OLLvE/+wFybRXR3iApTw+JSuTnPx8B49GVIcE7UIIIWpE7RzfqljQ7uXmzsf3/Yf7rx7H9VcMoG+HS2kV2owALx+u6tnHUUOtM23CwunX8VIUReGrDX9WqzRe1bVla1oEhZBbUMDafbtre6hCiAZGC9proZP7ncOuoktUa3Ly85nz7RIKjEbturyCAt75+QfAskSch6tbjY+nKjkXf1SPqpfGA3SIiAQsJfxGk6nU9VqmPUgy7VXh7e6Bj7W/QFyqlMg3Rs6OHoAQQojGTV1eqHjQDhDo48tNVw5xxJAc4vbBI9h85CBr9u7EZDaj0+m48pIuVd6P2pDug99/5NedW7m2T786GK0QoqFQ56C3roWg3dnJiVk33cFd773OsdgYPlz1I4+MuYH41BSe+2oRx+NicNLruXP41TU+VnHqsm9gqbpqW80sfmRQCO4uruQW5HP2QqJNBVdOfp42918y7VUXHhBExvmznE++UCsniET9kky7EEKIajOaTFq5YusSQfvF5pLIlvRq0x6T2QxA5xYtCfCq3vJN6rz243Ex2v6EEE2PqdjqG23Cauc9NMTXj2cm3ArA8i0bWbj2N+7+4E2Ox8Xg5+nF21MfYGiXHrVyLFXxTPuoHpeh0+mqtR8nvZ4OEZa59kfPn7W5Tm1CF+DlU+Wu9KKog7zMa2+cJGgXQghRbecuJGI0mXB3cSXUz9/Rw3G4261z26F6pfGqYF8/nPR6TGYzyZkZtTE0IUQDFJeSTF5hAS7OBiJqcVWNKzpcws0DhgLwxd+rSc/Jpn14cz65/zG6tWpTa8dRqZl2vU7HiG69arSvDhEtADgSY7uChsxnrxm1GZ0s+9Y4SdAuhBCi2opK48OqnVlpSrq3akv/jp3xcfeoUSbLSa8n2PolODEttbaGJ4RoYNT57K1Cw3DS1+7X8ukjrqFLVCvA0hhuwfSH6+zkapuwcMb3HcADo68jsFipfHWo89pLZ9rVzvEStFeHLPvWuMmcdiGEENWmlnW2rmHX46ZCp9Mx99apKFDjL+ChfgHEp6USn5ZCZ+sXbyFE01KbTehKcnZy4q2pD3AmMZ62zSLq9MSqTqfjkTE31Mq+Oloz7SfjYyk0GjE4W8IVtTw+SpZ7qxZZ9q1xk0y7EEKIajuVUJQlEhZ6vb5WMmYh1oxYYrpk2oVoquoyaAdwcXamnXX99sYiPCAQLzd3CoxGrZoLJNNeU+qybwlpqWV25hcNmwTtQgghqq0o035xN6GrC2HWoD0+VYJ2IZoq9cRnbXSObyp0Op1WIn/kvGVeu9FkIiY5CZDl3qor0NsHF2cDJrNZTgY3QhK0CyGEqJbcgnxireu9yhfO2hfiK5l2IZqynPw8bX6xnPi01VGb124J2uPTUig0mXA1GAjx9XPgyBovvV6vZdvP18K8dlnZpH5J0C6EEKJaTicmoCgK/p5e+Hl6OXo4TY7aMCpBGtEJ0SSdspZ+B3n7yntoCR2bWzvIW5vRqfPZI4NC0Ndyw76LiRq0xybXbF77qYQ4Jrw2h5e+X1obwxJ2kFe9EEKIainqHC8ZorogQbsQTdupeLU0Xt5DS1KXfYtOiCO/sEDms9eS2mhGl52Xx6yvF5GSlcHGQ/+iKEptDU9UQIJ2IYQQ1VI0F1O+cNYFNWjPzs8jKy/XwaMRQtS2k/GWE5911YSuMQvx9cPP0wuT2czJ+NiizvEyn71GwrW12ssvj1cUhU9X/8pHq34iv7Cg1HXzVnzLuQuW/gK5BQWkZGXW3YCFRoJ2IYQQ1aI2oWsVIkF7XXB3ccXXwxOQbLsQTVFdd45vzHQ6nbb025GYc5y9IJn22qCVx1eQaT+fcoGl69fwzca/eODjd222/WHLBtYd2IuTXo+nq5tl+xqW2gv7SNAuhBCiWqQ8vu6pzegkaBeiaVEUpVh5vATtZemgNaM7q2XaW8ga7TVSPGgvr6z90Lkz2v+Px8Uw/f032XLkIAfORPPB7z8CcP/V47S+A+dTkup41AIkaBdCCFEN6TnZJGdmALJGe10K9fMDJGgXoqlJSEslOz8PZycnWgRJ9rgsatC+48RR0nOy0el0NA8MdvCoGrcw/0B0Ol2FZe1q0D6kS3cuiYwiKy+Xp7/8lKe++AST2cyQLt25oe9AIgKtpfaSaa8XErQLIYSoMjXLHuYfgIe1RE7UvlC/AAAS0lIcPBIhRG1SS+OjgkMxODs7eDQNk7rsm3qCONTPHzcXF0cOqdFzcXbWmtEdsy6nV9Jha9B+ZacuvHvXQ1x/+ZUAZOXl0iIohCevv9nmBIoE7fVD3iWEEEJUmVYaL/PZ65TWQV7WaheiSZHS+MoF+vgS7ONLUkY6gFQk1JJurdoQk5zE3ugT9O14qc11+YWFnIg/D8ClkS0xODsz49oJdGnZmvUH93HX8NHaiXo1+JegvX5Ipl0IIUSVnbJ2PZbO8XVLndOemJbm2IEIIWrVyQRpQmcPtUQeLFUJouZ6tGoLwJ7oE6WuOxF3HqPJhJ+nF2H+Adrlw7r25MVb7rTpKaCVx6ckybJv9UCCdiGEEFUWl2pZLiYySOYX1qUwba12KY8Xoikp6hwvJz4roq7XDtI5vrZ0swbtx2NjSi0nejjGUhrfqXkUOp2uwv2oTe2y8vJIz8mug5GK4iRoF0IIUWWp2VkA+Ht6O3gkTVuINWi/kJmB0WRy8GiEELUhv7CAGOs6121CJdNekY7NizLt0jm+doT4+hERGIRZUdh/+pTNdWoTuksioyrdj6vBhWBfP0BK5OuDBO1CCCGqLC3LGrR7SdBel/w9vXBxdkZRFJIy0hw9HCFELTgVH4dZUfDz9CLA28fRw2nQ2odHotPp0Ol0ErTXou7WbPveEiXyWqbdjqAdis1rr2Ddd1E7JGgXQghRJYqikJZjCdr9PL0cPJqmTa/Xa5kMWfZNiKbht13bAOjasnWlJcgXOz9PL54efwtPXHcTAXKSuNb00IL2k9pladlZxKZYpr51LNZLoCJFy77JWu11zaFBe2ZmJjNmzCAqKgp3d3f69evHjh07tOsVRWHOnDmEh4fj7u7O4MGDOXjwoM0+8vPzeeihhwgKCsLT05Nrr72WmJiY+r4rQghx0cjKy9VKtf08PR08mqYv1Fed1y5BuxCNXVp2Fqv2WL7rTug7yMGjaRyu6tmHa3pf4ehhNCnqvPZjsefIzssDikrjWwSH4O3uYdd+msta7fXGoUH7XXfdxZo1a/jyyy/Zv38/I0eOZPjw4Zw/b1lqYN68ebz11lu899577Nixg7CwMEaMGEFmZqa2jxkzZrBixQq+/fZbNm3aRFZWFmPGjMEkc/+EEKJOpFnns3u4uuJqkDVz65q27JsE7UI0ej9t30yBsZAOEZF0bdna0cMRF6kQXz8iAqzz2s9Y5rWr67Nf0ty+0niAiADrWu1SHl/nHBa05+bm8sMPPzBv3jwGDhxI27ZtmTNnDq1ateLDDz9EURTmz5/Ps88+y/jx4+ncuTOff/45OTk5fP311wCkp6ezcOFC3nzzTYYPH06PHj1YunQp+/fvZ+3atY66a0II0aSlZkkTuvokQbsQTUN+YSErtm4EYGL/wVIaLxyqe4ml3w7FqE3oWtq9jwjJtNcbhwXtRqMRk8mEm5ubzeXu7u5s2rSJ6Oho4uPjGTlypHadq6srgwYNYvPmzQDs2rWLwsJCm23Cw8Pp3Lmztk1Z8vPzycjIsPkRQghhHzXT7iul8fUi1M+yVm5iugTtQjRmf/67m5SsTIJ9/RjcubujhyMuct1bW+e1nzqB2WzmSBWb0AGEWxvRpedkk5mbU/uDFBqHBe3e3t707duX//73v8TGxmIymVi6dCnbtm0jLi6O+Ph4AEJDbTtFhoaGatfFx8fj4uKCv79/uduU5ZVXXsHX11f7iYy0r9mCEEIISMu2TFGSTHv9UDPt8bJWuxCNlqIoLPtnHQA39B2Is5OTYwckLnrdW7YBLPPaj54/R1ZeHq4GA61Dm9m9Dw9XVwK8LCsgqE3sRN1w6Jz2L7/8EkVRiIiIwNXVlXfffZdJkybhVOyNrGTpkKIolZYTVbbNzJkzSU9P137OnTtXszsihBAXEbU83s9LOsfXB7URXWJaGoqiOHg0Qojq2HnyGNEJcbi7uDJGmqqJBiDEz1+b1/7dP38DliX2qnpCSTrI1w+HBu1t2rRh/fr1ZGVlce7cObZv305hYSGtWrUiLCwMoFTGPDExUcu+h4WFUVBQQGpqarnblMXV1RUfHx+bHyGEEPZJzZY57fVJXfItr7CADCk/FKJRWrbJEhRd0/tyuztzC1HX1Hnt6w/sA+CSKpTGq2Ree/1oEOu0e3p60qxZM1JTU/njjz8YN26cFrivWbNG266goID169fTr18/AHr16oXBYLDZJi4ujgMHDmjbCCGEqF3p2eoa7TKnvT64Ggza+sQJqVIiL0Rjcyohju3Hj6DX6bih70BHD0cITbdWlhJ5s7WKq1MVOsermlvntcdIB/k65ezIg//xxx8oikKHDh04ceIETzzxBB06dODOO+9Ep9MxY8YMXn75Zdq1a0e7du14+eWX8fDwYNKkSQD4+voybdo0HnvsMQIDAwkICODxxx+nS5cuDB8+3JF3TQghmiw10+7nJZn2+hLi609KViYJ6am0j5A+LEI0Jv/7Zz0AAy7pqjXuEqIhUDPtKsm0N1wODdrT09OZOXMmMTExBAQEcMMNN/DSSy9hMBgAePLJJ8nNzeX+++8nNTWVyy+/nNWrV+PtXfRF8e2338bZ2ZmJEyeSm5vLsGHDWLJkic28eCGEELUnLUttRCdz2utLqL8/R86flWXfhGhkUrIyWbNvJwATrxzs2MEIUUKonz/hAYHEpiQT4OVDiHU6VlVEBFrXapegvU45NGifOHEiEydOLPd6nU7HnDlzmDNnTrnbuLm5sWDBAhYsWFAHIxRCCFGSNqddMu31Rm1GJ0G7EI3Lyq2bKDAauSQyis4tWjl6OEKU0r1VW2JTkrkkskWlzb7LEh4QCEBKVgY5+fl4uLrW9hAFDWROuxBCiMbBZDaTkZMNgJ+HzGmvL+qybwmyVrsQjUZ+YQErt20CYGL/IQ4ejRBlu7H/YDq3aMXEK6v3GvV298DX+n0gVua11xkJ2oUQQtgtMzdHa1jjK+Xx9UYL2lMlaBeisVi9dxfpOdmE+Qcw4JIujh6OEGVqHdqM9+95hG7WddurQ+a11z0J2oUQQtgt1Tqf3cfdo8pruYrq09Zql0y7EI2C2WxmmXXt6wl9B8r7pWjSIqwNFs+nyFrtdUWCdiGEEHYr6hwvWfb6FOofAFiaWuUXFjp4NEKIymw/foSzSYl4uroxutcVjh6OEHVKzbTHSKa9zkjQLoQQwm5p2hrtErTXJx93D9wMLgAkpac5djBCiEot+2cdAGMu64unm5tjByNEHZMO8nVPgnYhhBB2S8uydo73lM7x9Umn0xHi5wdIMzohGroTcefZdfIYTno9N/Qd6OjhCFHnisrjJWivKxK0CyGEsFtqtmVOu2Ta61+Yn6VEPi4l2cEjEUJURM2yD+rcTWsiKURTppbHJ6WnkV9Y4ODRNE0StAshhLCblmmXOe31Ti0/jEmWRj9CNFSZuTn8+e9uACb2G+zYwQhRT3w9PPGyTgOJlRPLdUKCdiGEEHZLy5E57Y7SXBr9CNHgxaWmYDSZCPDyplNklKOHI0S90Ol0hFtL5CVorxsStAshhLBbapYatMuc9vrWXDLtQjR46rKY/l7yHikuLkE+vgAkZ2Y4eCRNkwTtQggh7JaWrX4hlUx7fYsMCgEs3XnNZrODRyOEKEtqtgTt4uIU4OUDQEqWBO11QYJ2IYQQdivKtEvQXt9C/fxx0uspMBaSlJHu6OEIIcpQtMKGvEeKi0uAt+VEVUpmpoNH0jRJ0C6EEMIuhUYjWXm5gATtjuDs5ER4QCAgJfJCNFSp2dYTm1KNJC4yRZl2CdrrggTtQggh7JKekw2AXqfDx93DwaO5OGnz2i9I0C5EQ6TNaZe+H+IiE+htCdqTM6USrC5I0C6EEMIu6pdRP08v9Hr5+HAEaUYnRMMmjejExUorj5dMe52Qb11CCCHskpYt89kdTdZqF6JhU98nZU67uNgEquXxmZkoiuLg0TQ9ErQLIYSwiwTtjtc8SIJ2IRqyojntkmkXFxc1015gLNT634jaI0G7EEIIu0iDJcdrHhgEQGxKMkaTycGjEUIUpygKadqcdnmfFBcXV4MLXm5ugJTI1wUJ2oUQQtglTRosOVyIrz8uzs4YTSYS01MdPRwhRDFZebkUWk+m+cvJTXER0jrIZ8pa7bVNgnYhhBB2SZW5mg7npNcTHmDJtttTIq8oCqcS4iQrL0Q9UKcQebi64mpwcfBohKh/0oyu7kjQLoQQwi7qF1JfCdodSi2Rj7lwodJtV+/dyZ3vvsZDn75LsmQ+hKhTqVnqiU2pRhIXJzXTLp83tU+CdiGEEHbRuiJL2adDVWXZt7/+3QPAoXNnuOfDtzgWG1OnYxPiYqYtiynvkeIipa7VLuXxtU+CdiGEEHaRLFLDYO+yb3kFBew+dRyAEF8/ktLTeOiTd9lw8N86H6MQF6PUbOn7IS5uUh5fdyRoF0IIYZe0bMkiNQT2Lvu2N/oEBcZCQnz9WPTQk1zWtgN5hQU8//Uivtv0d30MVYiLSlqWVCOJi5s0oqs7ErQLIYSoVF5BAbkFBYCs0+5oanl8fGpKhQ3mthw9BMAVHS7B292DV++4m/F9BwDw4aqfSEpPq/OxCnExKWrWKZl2cXFSM+0yp732SdAuhBCiUup8doOTE56ubg4ezcUtyNsHN4MLJrOZuNTkMrdRFIWtxyxBe98OlwLg7OTEI2NuoGNECxRFYdfJY/U2ZiEuBuqcdn8vCdrFxSnQ2xeQ8vi6IEG7EEKISqkZJD8vb3Q6nYNHc3HT6/VEaB3kyy6RP5OUQHxqCi7OzvRo3dbmut5tOwCwU4J2IWpVqkwhajAUFApRHD2Mi06A9YRVek62LDVayyRoF0IIUak0NYMkpfENQmUd5NXS+O6t2uLu4mpzXa+27QHYdeIYiiJfaoWoLeqcdiXAhySMDh7NxcuEwnek8TIJxFHo6OFcVHw8PHHS61EURavQqwqz2cw7v/zA4j9/r4PRNW4StAshhKhUWo410y5Be4OgrdWeXPZa7VuLzWcvqXOLVrgZXEjJyuBUQlzdDVKIi0xqdhauvt5sDPdkMSmYapDpTcHIIlI4Rn4tjrDpU1D4iQwOkY8J2Euuo4d0UXHS67XvCdWZ137k/FmWb9nIkr/+ICc/r7aH16hJ0C6EEKJS6nJvErQ3DBUt+5aVl8v+M6cA6FtG0O7i7EzXlq0B2HniaB2OUoiLR6HRSGZuDr6tWmDWQRZmEmqQbd9ANqcpYAvZtTjKpm8tWewpFqhX5aRHAWY2kEUGUtZdEzVZq33LkUPa/+PTUmttTE2BBO1CCCEqpZa5SYOlhqGiZd92njiKyWymRXAI4QFBZd5endcuzeiEqB3ae2TLFtpl0RRUa18FKBzEkmVMkQDSblvIZqP1JMdVeOMEJGPigp0nTzaTw1qy+ANpolYT2rJv1WhGt/noQe3/cSllN1q9WEnQLoQQolJqV2TJtDcM6pz2hLRU8gtt52xqS721L51lV6lB+77okxQYZe6tEDWlNetsVRS0n6lm0H6EPPKtpfVpmDA24YZqeZhrJbP9L7n8bg22h+FFPzyJwgWAo3Zm29Xn6xQFKE34Ma9r1V32LSk9jRNx57Xf49NSanVcjZ0E7UIIISqlZpEkaG8YAry88XB1RVEUm2XfzGYz246qS72VH7S3Dm1GgJc3eYUFHDwbXefjFaKpS83KxODhjluQv3bZGQowVyP4Kz4PWwFSm2i2XUHhC1J5hyTSq3Ef8zCzkxw+JZn/kQ7A5XgwEE8AOmJpwmlP0G5G4by1aV02ZhKlkWC1aZn2Kgbt6glnVXlLml6sJGgXQghRKa30U4L2BkGn0xV1kC+27Nux2BhSs7PwcHWlS1TrCm/fq421i7yUyAtRY6nZmfhENQcgECdc0JGLUuXgLwMTJ60ZXy/r1/TkBhBAriGTX8mo1Qx0LEZiKKQQiK1Cl/d0TPxAGq+TyE9kcI5C9MBluHM13uiwLEva3hq0n6WAXMwV7vMCJvKK3bfqTm1Qx3eIvIs2W6/NabejPP4CRr4jjXMUsMVaGh/i6wdAXIpk2ouToF0IIUSliq/TLhqGspZ9U7vG927bAYOzc4W3V5d+k2Z0QtRcWlYWvtagvRUutMAAwOkqBn//WkPHFhhoaS3vTnZwpj0NExvJZhs5NWquV1LxioKqVBOsI4t95FEIBOHECLx4jGDG4oveGrADBOBMMM6YgROVZNtjSjxP1Q3aEzHyEcl8SxonahD4N2ZqeXxKVuWZ9i1kc5A8liqpHEhJAODaPv0BKY8vqeJPdCGEEBc9RVFknfYGSA3a/zlygPjUFI7FxXA8NgaoeD67qncby7z2o+fPkZmbg7e7R90NVogmLjU7C99LIwGIwgVfTJyggNMUcIW1XLsyCooWyHbHnTRrIJvi4Ex78RMPpykgzHpCoiZMKBygaEmvqgTtahn7WHzojbuWWS9LB1xJwshR8umCe7nbnbPusyUunLY+b2YUm5MAlUnEyGJSyLZm9WMopJ0129/YnCAfPdC6GuNXy+PtmdN+xvq45+oU2t88jnPf/ET/Tp35bM2vxEt5vA3JtAshhKhQTn4+hSbLFyqZ095wRARZOsP/e/oUK7Zt4uDZ0xQYjYT6+XPlJV0qvX2wrx9RwaGYFYXdJ4/X9XCFaNJScrPxCg8FLEG7miU/Q6HdZdLxGEnEiDNwKW4EWnNrjs60Fw/aa1I2XtwJ8rXgFuwP2o0oJFlPYrTFpcKAHSxBO8Bx8jFV8DyoQfvleOBqndpQlaqCJIwssQbsTtbLEqpQ8p+GieWkVek2dSUTE0tJ5UtSyazGa0/LtGdmoijlP+a5mLXnUpdXgGdoMJ1vuo5Qf0tfiKy8PDJzc6pxD5omybQLIYSo0AFrozI/Ty/cXFwcPBqh6t+xM91btQF0dIiIpF14czqEN6d5YDB6vX3n5Hu1bc+ZpAR2njzKoM7d6nbAQjRhGe4GXJ2ccCkw4uuixws9zliaml3ARLAdX7nV9cU74oY7egKt4Z+j57RHl8i0VzUDXZZ91ix7CM4kYrQ7aE/CiAlwR4efFh6XrzkG3K1B+DkKtZMpxeUVCx5bYKAFLhwnn1MU0MyOqoIka4Y9CzNhODMAT74nvUpB/+9kcJh8TMCN+Nl9u7pwigLtdMoechlI1U7Wq5n2vMICcgvy8XB1K3O7cxSiAIGKE7u+/4UWN1+LsVkgmynE39OL1Ows4lJTpArMSjLtQoh6s/7APmZ/s4TsvLzKNxYNxqrd2wEY2rWHg0ciivN29+Cdux7inbse5P6rxzGiWy9aBIfaHbBDUYn8rhPSjE6ImigIsGQXA3NN6NDhjI5Ia4Boz7x2Ewr7rYFsNyxBjpppT8dsDW/qXzomUjGhAwzVbK5XUh5mjljv62Dr1IE0jHZVJMRZM9FhGCrNsgM4odNK1I+VM6/9vPXR9UOPN060tj5v9lQVZGJiiTVgD8WZyQTQynr7FEzFwt/yJWLksHVstdkzoLpOFbvfu8mtckM9D1dX3F0sj3lKZvnN6NQl9vxzjZw5coyTP/4BwEayierTE0BK5IuRoF0IUW+++PsP1h3Yy44TRxw9FGGnzNwcNh3eD8DVPfo4eDSitvVo3RYnvZ7zKReIS5EvR0JUly4kEIAIc1H2t2UVgna1XNwTPW2tQaYHOtysgWldzmtPpJDDlH0yXR17OAairFnnmpbIHyQPIxCMEx2t97AQyLIjwI2zPg5hVSgW7qAt/Vb2fVRL49WTLK20qQ0FFZbUA/xKBpmYCcaZKQTgiR4vnPBEjwIk2VFBsIks7f8XMGJ0YNd5BYVTxU5upGCq1vNtz1rtZ637zTxnWZs9KsfEldaTOL4DL0On1xOXKs3oVBK0CyHqhaIoxFrPmKZmZVWytWgo/vp3DwVGI61Dm9EuvLmjhyNqmYerG5dERgGwU5Z+E6JajIoZ92YhALTRF5UCtyzWQb6ybOVua2l8V9xwsgbqOnQEaCXydTOv3YjC56TyDWmcLCMTrQZsLTFowWxNg/Z91vvaDXec0eFjDUfsKZFXM+32lK2r2uKKHksAXdbJjxjrPptb9xmGM27oyEepcCm6g+RxyNqw7UZ88SwWVoVaTyrEVzJHPQ0T/1pPJjgBZiyBe1lMKKRgxFyHQX0qJtKt8/LVio/dxbr820trRldOB3kjitZQ8MiefwHo2+FShuOFKzpwMeARHChBezEStAsh6kVGbg45+ZYvBOnZErQ3Fqv2WErjr+rZB52uZnMYRcPUtWUbAI7EnHXwSIRonKLzs3FydaEwN482HkXLYjbHBScgEzMpFQSkJ8jXyqN7luhwXtSMrm4y7QfII9Oa4d5VRnB2WgvaXWwy0PYEjoXWILP4CYs0TJy2BmtdrffV33ofKwvazSjEWx+HZlXItLujJ8o69pIl8gqKttxbpDVo16Or9ARFNmZ+wRKQDsCzVEd9NWivrNz9H2s7vta4aCcNyrvNBrKZzwXe4wK7yamTjLxaGt8cg7bqwSHyyLGjCqI4ba32cjLtcRRiBNwV2H/AUs3Xt8Ml6NFpVRRe4aHES9CucWjQbjQaee6552jVqhXu7u60bt2aF198EbO56IWhKApz5swhPDwcd3d3Bg8ezMGDB232k5+fz0MPPURQUBCenp5ce+21xMTE1PfdEUJUoHjpbZoE7Y3C6cR4Dp07g5Nez4juvR09HFFH2oaFA3Ay/ryDRyJEw2I2m1m7bxcpWeXPywU4brR0uM4+F4uboWiJLAM6IipZrz0fMz+RDlg6l4eWCP7UZnQVBf3VpaCwlWzt98MlgrMMTKRY57NH4UIzDFXqrP47GcznAp+QwlHyUFC0LHtLXLRGcv7WfysL2lMxUYCCMxBUxV7a7a0l8vus41ClYCLHus/igXdlQfvvZJCNmRCcGVRGozZ7gvYsTOzC8toZgKf23MeXcxu1D8AFTKwkg7dJYiNZ5FUxoK6IGrS3xpVwnAnDGSPwbxkndCqqHilaq73svx11qTf3jFwURaFNWDghfpau8WoVhVezUJnTXoxDg/bXXnuNjz76iPfee4/Dhw8zb948Xn/9dRYsWKBtM2/ePN566y3ee+89duzYQVhYGCNGjCCzWGODGTNmsGLFCr799ls2bdpEVlYWY8aMwWRy7BIZQogixUuc0nOyK9hSNBR/7NkBwOXtOxHg5V3J1qKxatMsAoBTCXGYzLX35U+Ixm71vp38d9mXfPDbygq3O6ezBCDG+AulrqtsXvtaskjDjB96hpcR/NVlpv0chcRal5gLxAkTtsGZOuZmOOOGHid0tKhCifwJa1b7PIV8RRofkcxOa5DanaJpBPYG7ep89hCctSkE9uqKGwZ0nKeQg8Xmtp8rVm7vXGyfatB+lsJSGe0j5PEveeiA6/CxuZ0qTMual7/k3xZyMAIRGGiNS7FAv3RJfUGxEyWD8MQHPZmYWUMWn5JCfi0E7mYU7XltbV1Or5e1GmJXiYZ00RTwBkmssJ5wKqmytdrV+ew55+IA6N22g3adFrSHhxKXmlLhsnEVqawfQWPj0KB9y5YtjBs3jmuuuYaWLVsyYcIERo4cyc6dOwFLln3+/Pk8++yzjB8/ns6dO/P555+Tk5PD119/DUB6ejoLFy7kzTffZPjw4fTo0YOlS5eyf/9+1q5d68i7J4QoJi5VMu2NiclsZvUey3vx1T2lAV1T1jwwGFeDgfzCQmJTSgcdQlysjpyzTBk5dO5MudsoKCS6Wr5OO6eUDlBaFispL+k0BWyzBrHj8LXOvLYVWIdz2rdaj90Vd67AsqxW8eAsulhpvKqVnc318jCTZg0kr8ADF3TEYSQdM87AJdUK2qs+n13ljZPW5Gw1mVo3/nMlSuNVwTjjiZ7CYnOvwbK2+M/Wsvh+eNK8jCXk1NvrgByUMhvs5WFme7Esuw5dhdn5WAoxA97oGYY3MwjmenzwQk8SRn4mo8pd3ktKwkg2ZpsKka6442wdU6x1XPvI5QtSyMTMPnLLPGFQUXm8gqIF7RdOWZaUbR3WTLtenfrg1SyEPGNBtRI9SRh5kyTWklnjx6WhcGjQfuWVV/Lnn39y7Jil+c2+ffvYtGkTo0ePBiA6Opr4+HhGjhyp3cbV1ZVBgwaxefNmAHbt2kVhYaHNNuHh4XTu3FnbpqT8/HwyMjJsfoQQdUvK4xuXnSeOciEzHV8PT/p2uNTRwxF1yEmvp1WI5QvTibhYB49GiIYjOjEegNjUZK0nS0nJmCh01mMuNOKdUzpDGokBPZBWbC1wsGROV1qzlL1wpw2upW4LRZn2TMx2LR9mr3RMHLJmnC/Ho8zg7HQlQXtF89rVZeG80TMaHx4lmAF44o2e/njiViwEKQraK64mqEnQDtDfmqFOw8wW67SAc1oTOtvgW49Ou9/RFJCLmY1k8T4XyMRMIE4MrWD9cgM67YRLWUH4dnLIR7F20Lc89yHFnuuSc8hLNstzRkcPPLgJP/TAv+SxsxoN44o7aX2+o4pVHbij51LrCZad5PA3WfxAunZ6xUxRqXtxanVeWeXxycWmJJw8ZFlNSP0MAssJD2fA2c0NN3+/UiubFKLwPWnaSY+y7CKHLMwkYrRracDGwKFB+1NPPcUtt9xCx44dMRgM9OjRgxkzZnDLLbcAEB9vebMMDQ21uV1oaKh2XXx8PC4uLvj7+5e7TUmvvPIKvr6+2k9kZGRt3zUhRAm2mXYpj2/o1LXZh3XricG59NzBfMzamXLR+LVpJvPahSgpnkKaX9kHF18fTifGlbmNmkHPiInD38Oj1PWu6Am3BlrvcYGPuMCfZPIrGaRgwgc9oyh/+pE7ejy0Zd9qL9u+wxoWRmGgGQbc0dNJ6xaeQyYmkovNZ1eF4YwrOvKKNYUrixq0q9ljT/SM4P/svXd8XPWZvn2dqdKo9+Iu9wY2tik2xRTTWwgtlPQsCWmk7maTzfJ7d0N2s0vChmRJA5YECARC7zbFdDDGxr1X2epdGk0/7x+n6MxoRjOSRv258vEnSHNm5sxo5pxzf5/7uZ8cfkAp58a8XkO0txPpM1xtICF0VlworNGf+026aCZkCurYSjv0LFB8iJc7aWAtnbQTIQcbV5OPM4kY7EmQj36fIqimw+J0srHpj5OBzezzjxX61ZaAOCvTcHGe/ppeoL3PtPtkHLT0s1s5yeLCeF0fT7eKLJbq1vmDcaYOFPZRaTeuHcrCNlo7OlAUhWklPVrPjmIuYGRXlFHTGh1GtwsfW/HxIu10xPlOhFDZrC9gLIsJdhzLjKhof/TRR3nwwQd5+OGH+fjjj3nggQf47//+bx544IGo7WITi1VVTZpi3Nc2P/rRj2hrazP/HT16dHAvRBCEpET3tHcOuEdJGHpSmc3+PO38iWa2DnJlXxgdzCrX+tql0i5MdHxE2ICX34brmfvlzzDzonOYfdkaDtTGF+1GNbrt8FEKsuKL73PJpgwHKnCcEOvpYpN+7LyM3KiqczwKzb729Ij2IKrZW36abhmHnuT6LfjYqwuxchxkWvbPjmKK+L762uss/efJyMaGE1DBUsONpoMwnURQoFdYX39YTAaTcBJA5a+0ogK52MjTxbKVKv11dhIhgEopDj6luwYmpbAPxn7WxwjpQwToIEImCostbQLafeL3tVcncAQArMTDXNyEgUdpHVAwXRjV/CxXxTzHdJyma8CG9pm9gBxm9vE5KNIr7a1dnb2yUozKfFa79h0ozy8kwxX9nNa+9tgwOsMREIa47gItUFElFxuzEjhYxiIDW6pKEz/4wQ/4p3/6J66//noAFi9ezOHDh/n5z3/O5z73OcrLywGtml5R0WObqK+vN6vv5eXlBAIBWlpaoqrt9fX1rFy5Mu7zut1u3O7x80cUhNFOJBKhzrJSGo5E6PR1k5PZuyohDI7Wrk6yMzJx2HtfgKRKstnsYVRzPNFmfCweRyvZExWptAsCvE8Xa+nU+p3toIYjKHYb+TOmsm/dR722Vy3BXa0HDpM/f1ncx52Jm6/jpp0w+/GzjwCHCbCQDObGiLZ4FGGnmmDC+d39ZSvdeFHJw8Zci6iZoSe6txLmVb2iOj2OSJyOiz34OUSAVRbRb6XOrLQnF7cKCvk4aCBEC2GzJcCKEUJXhB3XIOzONhQuIoc/0dxnld14rtPw0EqYFXiYqYezpUqiSvs2vS1hARm9QuzKcLAbf1SlvZ0w7fqCRWWc98aGwqfI43c00kKYR2mlEicthGkhTCdhVpFljnCLx3GC+FHJtIxcM1B0h8KbdHIOOWYSv+FEqCFEN5GoxZ387BxsikJEVWnt6jR73KGn0h6q0zJUppeW99ofTbR3a5X2nT3nJRWV/ZbK/ga8nEFW1PtojC5cSma/AwtHMyNaafd6vdhs0btgt9vNkW8zZsygvLyctWvXmrcHAgHWr19vCvJly5bhdDqjtqmpqWHbtm0JRbsgCMNLY0c7wXAYu81Gpr6aKn3t6WfP8Wqu+6//j5t+dQf7awdeMU02m/2ofnIHOIA/reNmhJFhpj72rb6tlXaZ7iBMUN7FSxCVYuxMOtTIe//5G4JdXuxuF0civS3AzbqYUsNh2o8coyDJlI1c7CzFwzXk831KuYjcPrc3MERsOuzxKirv6VX2k/FEiRobiml5Nma3z4gj2qss4Xrx+tpVVLO6XJZifTBZGN1g+9mtTMUVVeFOFCanoHARuXyGAmbh7ndvtPHaGwmZSeYhVDO9flGcBZt4YXTVlvcyXlghgAcb1+rm+v0EeIsutuHjGEHaiPAqnX0mzBuj3mbgMu36VhaQwVcpNgU7aOF+xdhR6R1MaLfZyM/Sev6tFvlOve0CoPGAFvQ4o6y3aI+a1W4p+jQTpo0IdjSHRieRqGkAzYQ4QACFHufIeGFERftll13Gz372M55//nkOHTrEk08+yS9/+Us+9alPAZot/rbbbuOOO+7gySefZNu2bXz+85/H4/Fwww03AJCXl8eXvvQlvve97/Hqq6+yadMmbrrpJhYvXsx55503ki9PEAQdo5+9NK/AvKgR0d4/wqg8QgvPJhivAvDAay/jCwaoaWni1t/dxWtbN/X7eVKZzb7XssodBnbH6WcTxhbZGZmUFxQCDGrBRxBGK10+H+/t2m4WhmKJoNKui4nPUYh3yy6CXV6Uek0wtOdk9GrrMqrsvpp6IsEQBVmJg8kGQ0+C/OAq7RFU1tFJHSGcwDJ6u92WkmlKtth+doNkfe2dRPCioqCFiqVCMtFem0bRDrCGHHPPpqbpMWPJ110BIXoWXA4QoBuVbGxxF0TKTUt9yFwQiQ2hS8RkXHyaPObh5hQ8XEAO15NPEXb8qHxiEbexHLSI9v5g9L8fiGORN8LorGPfjuivpRQHR49XA/Er7eU4QFVx52RT7+8JnDOs8VNwcbL++X3fEkj3sV5lr8JFwcgaytPOiIr2u+++m6uvvppbb72V+fPn8/3vf59bbrmFf/u3fzO3+eEPf8htt93GrbfeyvLlyzl27BivvPIKOTk9q5m/+tWvuPLKK7n22mtZtWoVHo+HZ599Fvsg7KGCIKQPQ7RXFBSaK68i2vvHEQLswM8GuumKs1q+v/Y4b+/ciqIoLJ42A18wwP975AF+//Kz/Zq9ncpsdkO0GxeSO/u4EBDGDrPKDYu8iHZhfKGqKj9+6F7+6S9/5O2d2+Ju00mECJpQzcbGIT05fqaiVUM9Uyt7zZw2hErLfm0kXLJK+0ApSkNPezcRHqKFt/TU9LPIxhNHBuRjN3uVy2L62Q1slr72eGLNqBIXYk8a1maQvNI+uBC6WPKxcwMFXEJOUjE8UGyWQDVj0cHIgVlIRtyKdiF2HGjTBVr19yJRCF08FpGpv65cVpHFAjI4RRe3H9AVd/xZ0DKCLTaELhkz+uhrN8PoLAnyxvNMxcnBOu07Fk+0u7CRH9Heny6Py1xsO6Bff8zExXIysQPHCHKUAGFUMytieZwFqbHOiIr2nJwc7rrrLg4fPkx3dzf79+/n3//933FZwggUReH222+npqYGn8/H+vXrWbRoUdTjZGRkcPfdd9PU1ITX6+XZZ5+VRHhBGEXUNmuVioqCIvI8hmgXC25/2Gs5IdbGSYd98A2tRWj1ohO560vf4PozzgHg4Tdf5Ud/+SOhcPKLvejZ7KfE3aaDMLWEUIBLdGvnXvxpHUUkjAwzzTA66WsXxhcf7t3FpgN7AUwxHosRgJaDDTuKud0JmXkA5E6dxJ66ngUtaz97/Z79AOaidLop1AVtF5EBtSPVEeT3NLGXAA7g0+RxZh/jys4gGxdKn8nbhkV+fxynVV1Mcnwq9DX2zUfErFSXp1Fgz8LNKfqM9KHCancPorJLf7/iWeNBC/orttwnjMox/T1JZONPxhIycaHQQDjuIstRAoTQPvvFcQL5+sIQ7fWE6IxZcOkR7b0r7cW+CG3erl7J8VYmK9oCQmZZCc2dHURQzf2vwkU2drPN4QO87MFPBxGyYrIaxgsjKtoFQZgYRFfatSCUka60t3m7+NljD7Jh3+4R3Y9UsVrSY+2IRxrqeH3bZgBuXn0+Drudr114OT+97rO4nU4+2LOTDXt3JX2O6NnsC/rcj0qczNRDi4LAPhn/NuaZVSGVdmH8EYlE+MMrz5k/x1bLDdp1MZyHndauTlq7OlEUhUUFpeD1YXM42OHruW8DIbqI4FCh/ehx7DYbuUMUrpqBjWz9kr2/fe178fNHmmkmTD42vkwRJybp9Z2Bi59Qxil9BJfNsvS1B2Oqt/X9CKEzKOyj0m6c83KxkTXGpEu5RYDvxY9fDwBMFH4Xe58GXey7UfotqA0ysLFE/5t/EDPbPILKO/rvqvoZtAdaL72xv7HVdiNBvrlDq7R3EzFH0oXre64LY5PjDSpt2u+zK8qoaWniOEF8qGSgmOn9RrjeNnymi2RJnIC/8cDY+uQLgjAmMca9lRcWmZWIthEW7Y+89RqvbP6I377w1IjuRyq0E44KpYmttD+0fh2qqrJq3iIzUAzg3BNO4swFJwCwvy65EDNms5934rK4s9mhp+I/Wz+5L9BXs3eIRX7MY1TaD9XXpuTMEISxwOvbNke5Rxrb4+eCGJX2POxmlb08v5BMl5ucNk3UVDt6qtyGQCnxa0F0eZ7sXuHK6aRwAH3tEVSeo50AKlW4uIVic2b8YCnBQQ42QvRYng3qLH3LqWLMJ+9G7eUmSHc/+3BSqu9zHSG2mgF0mXGt8b3vEzT72Sfh7PM+yTAs8rvxR7kZ3sPLXvw4IOEkgGRUJWiVMCrtxkLZPj0KrwQHjce1EYrTSnpb4w0qrGF0Lc1mP7s1LK8SJ1NxEqGn9z9eVsN4QES7IAhDzmjraQ+GQry48QMADtbVUNfaMmL7kgpGdTsS0i4qd3a2mH3qNc1NrP1kIwA3n31+r/vOKNPGZRq9Y4mwzma/8KT4s9nDllErxuzTBbo1bTd+QnF65YSxQ0WBJlACoRDVTQ0jvTuCMGiCoRD3rn0BgPmTpwLRVl0rRghdLrZevbbTVE1E+Qp6LOWGQMnr1I6JBdlDY403GEhf+x78tBAmE4UbKEhrlVpBMXvf91vEWgSVhgHY492WKnpstT3d/ezDifEetBJmty7aY2ezx2KttB9NMYQuGSU4mIkLFfhQ7/s+SoC1aFXwi8gdcOtBor72SYXFAOw6dgRVVc3Q2rm4ze9YvOR4A2ORJrOogOr2VvNzNjPG+m4dZTcNp9leMN4Q0S4IwpASDIVo0CsbFQVFo0K0v7NrGy2W539/944R25dUMER73WYtQMmX6eIHf/4DzZ0dPPzmq4QjEU6ePc+8KLXSI9pr+nwOYzb7zPJKZldMirtNtW5Ny0QxLyAm4yQHG35Lr5kwNrHZbKZTQ/rahfHA8xvf51hzI4XZOfzD+ZcCie3xbRZ7vFFpNwTFEk8BAM7SIjrDQSKo5ogrZ5N2fhuqfnaD2AT5ABHW0cFvaeRgggkeRqr2MjyDmm2eCEM87bM8fwthgoCTHndAquQnsMinc9zbcOPBRq4ut0Jof8dkiw9llgWaQ/0IoUuGUW3/GC/thHmMViJooXjLBzEebRoubGitG62Wv93Sqtm4HE5qW5rZV1djXsvMxW1+x+KF0Bl4sGH3aa//uD3MUVO0R9vp5+MmT3+Px2MAnYGIdgEgbpqkIKSDurYWVFXF7XRSmJ1jEe0jF0T37Ib3AMzxPO+NYtGuVbe1E1XNhs2EvN3Y7HZ2d7bwpbt/wYsfa46Bm1f3rrJDz0XnkYa6Pi3PyWazQ8/iwSzcpjXNhsJ8vWowVBb5OoJRFwLC0FFVri3ySF+7RgfhuEFbwuinO+DngddeAeCzZ1/ApKISQBPtsaPboMcen4udQ/XaIqchKGbnFeFrakGx2fi4vZE6QnTrfcYhfSRcomkb6cKotDcS5hO6+TWNvEkXdYR4kvY4feVBc171yUMkZAzxVGsJITNauUpw9NvOHa+vvYuIWbkvH6MVVKvjYBEZSfvGs7HhQUGl571Ih2ifg5t87HSj8geaaCVCAXauIHdQYXwZ2My2C2u1PcPlYvmsOQC8fvwg3ah4UJiCs2dhrA/RDpDn015/19QywkAetl6LQXbdSXIZuUldDGMZEe0Cr9PJz6k3e5AEIZ2Y/ez5hSiKQp7R0+7tf6U9FA7z6paP+c69v+W/n3o07oVXMo41NfKRHj73/SuvA+DjA3vwB0fn5/8oQfyoOEJhOo7VorRp79v0ubNp7uwgGA6zZMZMTpheFff+Rk9mMBxOaHmOms1+4rKE+2KI9tkx1jSjr30XPsJpXgDcQjf/SxP30SSLi8PALEmQj+JJ2niAlqggSGFs8Pf33qS5s53KwiIuXX6qKapD4TBt3t6Lxu1mT7uNQ/V1QI9oVxQF6rRz2c5Ql+kqmoaL482NAOQPuT1eEyrHCPJ32mgnQj52srHRSph3iH5NRpV9vi7UhoJs7KaQNt4TQ7T3p5/dIF6l/V26CKNZ44fqdQw11kC+xSlUtBWUqPsUYCc7Da/dhmIu4LQTwQ5cSz4ZaZCDPRb56GPlynnaxK/dtp7rh7bOTjM5fmqC5HiDMv11O6Zo38WZuOMuMFTgZAWeQfX9j3ZEtE9wjhPkDTrxobJDLkqEIaCmWetnrywsArCkx3elLLrbvV08/OY6rr/z3/j/Hv0zHx/Yy7Mb3htQ3+3zH2lV9hWz5rJq/iJK8vLxB4NsPriv3481HBhiwdPcAaqKs0O7ELvgnHO5fMVKyvML+OqFVyS8v6IoZrX9QAKLvDGb/dQ5CxLOGe4gbPYVzoqxpk3DhQcFLyqH02iR34GPJ2hDBVqJ0C2ifciZOY4T5N+is5ew6QsV1Qw22jUCQYudhNP6fZpItAX8fDK/ghO++Bm+cN7FOB0OnA4HeR7t/BNrkQ+j0mGEn3l9ZnK8dRRVQZc+3i3DZlYTK4OwdrOWKbJ85twhfU2F2E054kLhXLL5JsVchHbMfotO05HUTYRP9L7lUwcYLpYqhkXecITV69+Z/iTHG8RW2ruImGnnZ5M9pKPZhhKjCl2GI+XFDGt1Pp1z5JeRaT7aGnLMFPbBYg2jsy6wr9Qn0SiTtO/SXNwc1KvsfSXHG8xwRn9+Y63xEwkR7ROYCCrP0m5+teLNfhaEwVKrh9CVF2ii3ZjTHggF6Q4kvyDdfHAf1/zi//H7l5+joa2VgqxsyvK1/sINe/s3ri0YCvGCHkB3+ckrURSFU+fMB+D9PaPTIm9W+I5r1Zycbk04N9gjfO/Ka3n0B/8at5fdSl997aqqsnazNps9UQAd9FyQVeDoteJvR2GeaZHv3+JfABVvnLnDe/Gb/XYGYpEfeqrKKlEUhaaO9hEfy5hOOgmzlk5epoPuFOdcdxLBp58h98ZciA4HD9PKvTRzQBbU+816byOZpcUUzJxGweJ55u/NudExor2TCCpgB+prtSp7rKCYqWjHuGCOx6wmHtqyg+6Anxml5Zyin0uGChc2ziObk/HwLYo5i2ycKCwig+k4CQIvo72ujXQTRLOTTxviPvCZlnntKuqAZrQb9FTatcd4ly4CqFTgGNNztxfg5mJyuJb8lO9jff/SJawBMrHxGQq4nFxOS2PbxBRc2NEq+I2Wc3VRbh6LFi7EU1KEElGZhZtDdcn72Q3mZOZG/VyFm0gkwrGmRvzBibWoKaJ9ArORbo5ZhHrs7GdBSAeGPb6ioBCATJcLl0M7AaUy9u21LZvwBQNMKS7hnz79Gf72w9u5/OSVAKbNPVXe3bWdlq5OCrNzTMvWqXO0VeD3d+8YkN1+KOkgbH4vvYerASjSv6Z1hFIWEVV9JMgfaaynob0Nl8PJqQlms0Nia7xBT4q8L+X9iqDye5r4T+r5E028RxdthDmIn7/qtZZFZJgXLPHm9wrpxeN2m66Y8WSRtyZupzoyq96yXSvhfqV2D5Yay6in7TJOsV+EUdlm0SKv27r0QVNQHDOCysDoZ8/BzuEEAVlzi0vprK0HIAhkqArPr9V65q874+yEWSDp5AyyuZRcci0LpwoKF5OLAmzHzz78fKg7Sk7FM+TV6Wm4cKCJtRpC5vdkIKLdqLS3Eh43VXbQbOmnkkVJP96Toaq0g5ZLszzNnw0XimmRX0dH1HXA3BVa2124rpEMbCmF0BkU2ByEu7VjoKOtk/965M986j9+yg2//Hd+8tB9adv/sYCI9gmKVnXQxjys1q1TLYR7zcYUhMHSM+5NEwKKolgs8slF+wF9vvjnzrmQi046BZfDwYpZWuVk08G9/Zon/eyGdwG4aNkpOOzaxcFJM+fgtNs53tzE0cb6lB9rODASeStx0NKoOxYcbuyADzXlyrMh2g/EmdX+ycH9ZE8q54RTT8aVYDZ7GNXcl0Sifbq+yt5GJGVxc4gADfqguCMEeZEO7qSBP+t1lrm4+TR5ccOJBkIzIRlLlwJGX/t4sshbhXqqn8+GGHE/nH3tG3VrM2hjuyTPIXV24sfnshPo8kJHF51EeFsXsUVJRHu8fnaDqrIKWvcfNn/2tHXR2NFGUU4u556QOAtkOCjHafYqP0orrUTwoKTUPz1YnChM08Xa+3ShApkoZA9AYuRix4aWsv6yPl9+rFfZB0opTrKwkY1tzKTmX0AONrTvoNV155iqXYMc3rwVXyDQL9GuoECL9n09uGU7r2/dbF47bty/B18Kjs3xgoj2CcrLdODTD4aryTbHUdRJtV1IM7GVdiDlsW+qqprCwRhFBTC7YhJ5niy8fj87jh5OdPfo/WhuYoNemb90+anm7z1uNyfOmAWMvhT5vbolfTZuWjq1RbbirBxztT5Vd4xhjz/e3NTrBLf5yAFO+ML1ZF10RsL09zfopBuVLGwJV/xdKEy12CRTYZv+fAt16+BUnChAGM1yeS352FFMy+Rg7PE78XEXjbyqL1YKiRmPY9+aB1BpN0R7pl6NGi7RHkRli0W0txGRc3OKqKi8qwv04x98TNE+rSXoXd3FY4j2xo62qPsZ497iJccb5GR6UOsazZ/3bdoCwNUrz0y44DmcnEM2HhT8+gLPcjz6EXXoMfrat+rH9DIcA6ri2lHI04/3m/XHGutV9oHiQuGrFHELRcP2dxwsZTg5Qy8EPk87XiJ0E6Hepe1//Y49fLRvd8rJ8QYLO1Xa9x8mr7qBL5x7IXd/5VsUZucSjkTG1XkqGSLaJyAHCfAJPhTgMnKxoVCuX4hLX7uQTrx+vynMK3TLLVhEe5IE+drWZrx+Pw67nanFpebvbTYby2ZqY0RStcg/9eE7ACyfNZfKwuKo207TbeEf7NmZ0mMNB7HV7WZdtBdk55ir7qmK9gJ91J6qqhxuqDN/r6oqe33tODM1a/tTtJm9hAZHCPCmfhF8MTmWKKTe9PQ2Jl/5DqOaiwTL8HAqWXyZIr5HCTeSz40UmBcqBTF9jgPhY10EbeuHfX+iMqti5CrtKipv0Zn24Ldoe3xqiz+GPd6Y+3uIQK+xWkPBDnz4UMnHzhxdDO2WvvaUOKq3FajhMMff/5jpQRtT9X7v1+g0e9pjK+09yfF2s40onqAo86uoYU3g7/9kK5kuN5etWDmEryh1MrFxnh5KZwNWDOO8aiOc1PhmDSSEzsCaED9Rq+wGedjNRYyxwllkU4KdTiK8TAf78BNRwN7hxdfcyvMb3085Od7ghjknctfMU7jrM1/m8+dcyAnTq8wsn53VqRVuxgMi2icYEVSe04NKlpPJZP1AW97Pyp0gpEJtq1Zlz8n0kJ3RY9PLS3FW+4FaveJRUmba2Q2Wz9KSejfs25V0Px59+3Ueees1AK44ufcFltHX/smh/Xj9o6N/tJogPlQyUSgP28wRRUU5uWavW38W2eKF0dW0NKGW9DggfKg8Rps5ts1PhL/r6e0nkpHUamlUWw4SSDr67SABvPrM1hmWNNhc7MwlA4dlcaAghUp7N5GE1nc/EbP630ZEeuOTMG/SFECbNhArboaaAwRYSydP0qZHg6WHaHt8/yrtC8kgFxshNOE+1BjW+JPIZJ6I9rjUEYz7tzCq7F079xPs8lJZUMiFupDdTDeuEm3xODaIzhDtTn+wT0FRVVTKzsefZe8zL+NtaOKyFaeRkzl84jgZJ5HJ2WRzJXnDKvZKcUTZ4Qcy7s3AOoN79QStso9lHChcQR4KsIlu3tC/kzNC2t/13V3bgdSS4/tininajwxuh8cQItonGMcI0kCIDBRzRRawVNpFtAvpwxj3ZrXGAyn3tBuVviqLNd7AEO27qo/Q0e2Ne/9IJMJvX3iK/33xaQCuWXkWZyw4odd2k4tLmFxUQigc5qN9e/rcp+HCEJkz9ZmmAHabjdxMDxX6BVFNP76vPX3tPaL9k0P7yZ+hCbTT8JCBQjVBXkV7vhfpoIUwedi4hNzeDxpDBQ4ydXvmsSQLCoY1fgEZfVbvIVq0x6uSNxHiF9TzGK1x77+PQNQ7dUDGaPVJUW4eC6ZMQ1VV3t6xdVife5f+ue9GTdviiooaZY9vTvA5stJFBC8qClCMw8xy2DfE4rmJEIcIoABLyTQr7ccI0imLTQCEULmPZu6jmadpI6D/LZsJsVP/+xxYr432rCgoYjIuFpOhZWdM1iaP9O5p16rn3pY2/X7xBUVVWQUNW3Zy/INN2G02rl551pC8xoFiQ+FsslkyDL3ssc9bZVl8HUgInYEh2stxmItWwthiKi4zY8FY/Dw9t4zsjAxzm1T62fvCqLTvEtEujFeO6BfS03GRafnzGyKgjmDSCpkgpEpsCJ1Bqj3t8frZDcryC5haXEpEVdl0YG+v24OhEHc8/hB/e+cNAL564eV8/eIrEyb8njpXH/02Svraj+snumk4zX72/KxsbDabucjWSjjl8VXxKu2bDh0gd9pkQBMIV5AHwNt08QLtfEw3CvBp8slI4XShXbhFz+yNRwiVnbpoX0RGwu0McnVZH0QbzRSLVtnXwm9iw8MA87lc+uLAQRHtSTEWt9Zv/2TYnlNFZbfFFn88Te1anUQI6AJcQXOUeJOc5wxrfD52XCjM0j/XQ93XbrRxzMJFHnZysVOBA3UYnnuscJAA3frfbyPd/J5G6gjynv5XnR6y03K8BkVRKNXHg55HNg6gPtNOftU0Gtvbo6aFGEF0rfUNQGJBYT0XnbN4qTl+VMD8jsDgKu3L8bASD9eSL1X2Mcx5ZJOnXzdkojDN7ubk2T1jEVPtZ0/EXN0Rdqy50XQijndEtE8wjugXq1OJXkEu0C9MQkQH9ghjkwgqhwjwLG3cST3P0pb8TkNAj2iPqbTrs9qTjXw70IdoB1g+27DIR/e1B0IhfvSXP7L2k43YbTb++eob+cwZ5/Q5kufUuQsBbV77aBj9Zljfy3Ga/eyF2Vq1OxMb+UnCI7uIsBMfL9HOi7QztUw7QVpF+x5vKw63G0c4QikOFpLBCr1C874+aud0sphO6ha2mSmE0R3QL7qzsaX02A4UMywzXvXVOprrI6JdFyFU9uj7cqYekHNgBGZujxQqKjUDWIw9c6Em2jcf3Ef7MF0Q1ROi1bIoczxNzq8mS7+y8TlKZpE3Fn+M0McqXNiARsKDylboizAqm01rfI/leq5Y5KMw8g6m4yQHGw2E+T1NbNS/+zOatfewOCfXDIgrwMEJ+rGtcPYMAqEgnT5tuxAqXfrnruaYds5JJCimFJeS5dYWGq87/eyheHljltm4ycLGdJwpLfImIhMbF5JL8SCEvzDyuLFxBXk40I5ndhRWzl9k3j5dLyQMlFxPFpOLSgDYfWxiVNtFtE8gVFSz0j41JiTEhmLamWqGMIxuBz4OS5VryOgiwsu080sauI9mNtBNGxE20j0sAUqx1DRrPe3leqXdT4Q6gilV2n2BANVNWtUjnj0eYPlMTbTHhtH94eVn2bBvNxlOFz+/+StcsHRF0n09cfpM3E4nTR3tHBnh0W9dRGgngoJmETSsnAXZ2eY28cIjA6i8RDu/poH/pJ6/0sq7eHkPL94KbeGkob2Njm4v9W2tBIu0yvp0XNj0isaF9PTMV+DgbHqeMxUM0V5N0JyNHMs2XZgsIMN83mT0lSBvFe2bYz7rhwjg0xcITiMLJ9r7G68iP1REdGfBSIzUfIsu7qHJzDJJlclFJcwsryQcifDOrm1DtHfRGNZ4o6M1XZX2Zv1vXYSdIv2znapoNyqGmZbJCfuG6By2Fz8dRMjCFhW+NVd3o2htHhNjsSkREVTzc3I62dxKMbNxEUIbE1aGg0idPh4zZrHYuO7J191FxnG1Q1/ScgBHjx0FEgsKh93Of33+q/z357/K7MrJ6X1xY5wsbNxGMZ+lMPnGwoRgFm5+RBkX6O24p86Zj92mSc/B2uPB0td+VES7MM5oIkwXERxAZZxkz6EOo6sjyCO08gDNgxrdJCRmLR28g5d2IrhRWEIGmShEiBY2w4W10q6i8iAt/JYm1ALtAN5XEN2h+loiqkp+VjaF2Tlxt1laNQu7zcbx5iaON2ujeN7btZ3H3l0PwE+v+yynzJkf976xuBwOpunBQ9WNDam9wCHCWDgrxI4bGy1deqU9p6evvDymrz2AykO08C5eGvXvVykOpujf9Z3OMOW6lfNAXY3ez66d8Gbae/ofnSjcSAGr8PAZCqIC4VKhAAeF2IkQ34Yeslx0p2KN73ncxLPajc+2A60XervFYm1Y4+fhxmkZSzfQvvY6grxBZ7/E07t4+Sut3E9zwoWMoaCBEK/r+QQf093vY8CZukX+ze1bUtq+i0jKIW/xMCrJJ+kV0RqCaXFEGJX2QuwU6Z+jZAny9TGVdmDI+9oNa/yJMUGMFXrIV0B3UI0W3tXbaPrj4vAT4eggnC41hOgggkvvoc7Cxo0UcAE5lOHgInKoazFEe3RblhG8m1VZBjbFDKOzjnszkuOn95FqvXDqdFbMnjeg/R/vuLH1+5whjG+s4+pyMj189/JruHn1GmbrU0oGw/wJFkYnon0CYVjjJ+GMe1Ad6rFvRkBMCFgns5LTjopq9jxeSA4/pJSryGeS/ndNFgyW9v1R1Z4Z7YVF7MHPYX0fAtnaRXlflXZrP3siW7vHncHCqdMBrdre1N7Gz//+MACfPu1MVlmsWKkwuVizWh0d4Uq7IdqN0W7NHYY9Pl54ZJAgKg/TwkECuFC4mjz+iVK+QTHXkA9oFecZVVWAZpH/5OB+8vSKU6xFPR87F5AbNXqnP/Q1+m0ffnyo5GDr5fjpiwJdPMUu+HmJmH3up+r2d8Mib63KzdcXCIyk+oH0tYdReYRWXqPTtOKmcp8P9PTcGkL8Pc2p6ImIoPK03qlrA1TgtX4ed89cdCKgfbeSTVWIoHIfTfyGRrOy3R86CZvHqDPIxo7We56OMLqeSruDQrPS3vfjxlbaoUe0HxiCincHYbONY1nMqC4bihlIt2eUWOQ7CfMyHbyP15zNnQov0cEfaeYV+m6NSoSxCDcbl3kdY0NhFVl8nWKqcPecd/KjK77F2HGjYHM6ySotoVEX7UZyvCek9nsUlSAI/ePSFafx5TWX9NmumCrzzDC6w6OirXGoEdE+geixxsfvIR3qSrt17u4WfBwdRRWD/jBae2EbCdOhOylW4DFXNw1XRbqspqnS5u2iO6BdYJblF/Ca5SJNzdA+g90BP/5g/P06UGckx/fd92RY5D/Ys4ufPf4Qbd4uZpVXcssFl/V7n6cUabPgj454pV37DhoBkS2dvUW7cVs9IR6ihQO6YL+ZAk4gE49+eM/HznT9M1C8WKsOHayrZWdXM47MDOzhiPndTxdVprjpLTCMKvjCfljjIXGlvScwzMZp+qs+QpA6fV5zh+46McR6lUW091c8b8Nnir29KR6/duOnjQgZKDjQLOBrh2HRcgNejhDEhcINFKAAO/D3a/FuRmk5k4tKCIRCSQMad+OngTBhemzu/WEPflSgEgf52M0WjXQsNhp/s6KoSnvi85x1IajYsnBVjoMsbPhROZrm4+l+AkTQXn9JnO+jta99OM5Br9LBb2g0BW0su/S/F8AbdKZUbbcuor1Dl9m/3x8MN8a8Plw6tS1GW1a0aLehmIvYuVMqTXu8EUKndGuPXVlQNKhRVIIgDA+zKyZht9lo6eqkvq11pHdnyBHRPoE4bIbQxa9ulenr1p1E0j5app0wxwmhgFkxeImOYRXAgT7mOKfKdnz8nHo2pFhlG04MgTQFV5QdaaREu2FXL8rJ5aAzEjWeLOiwm31NiVI/9+sz2hOF0Bms0MPo3t65lY3795DhdPHT6z+H25l6Fddgil5pr24aZZX2Tu3i0mqPz9erRmEwBftNFDAtzqLcibrdODRF6yH7+MAeuvO1XvWpOJOOXOsvVXpOewNh84IYIDhAazz09LTHivaewDAnOdjNEUEf0W26e+bgNqtyFThxo+BD7dfIvAgq6y0LT4dSrLYagX4n4+FKPZ3/Hby9AvPSSSth1ur7uoZs5uDmBP39frUfCwaKopiBdG/u6Nsi/77l9Qwk5dwQY0b/ds9xa3CLyNZxb4U4zHCrvsa+GZ+pPGy4LZdJNhRm6d+vdCe5G8fvmQlGXFXhwoH2+W8Y4vayVsK8RRf1hBJ+TndaFuGbCfNJCgK8npAZ+AbwDG39WrxvIUQdIWz0uB7ikSgAFTBzCXKmVNLUoQW0Gvb4QLv23UhHr60gCEOP2+kyrxF3Vh8e4b0ZekS0TxA6CZvVhkSVdhc2cz5muqvtxgXZZJxcTi5OFI4SZPswWf3aCHMnDfyOppRHZMVST5AnaMOHyof9vOA+SID36OI1OniOdh6jlSdpi7qAGSyGFXlmzN/XuPitJzSsYXSG6J5RVmFW2bP0Q45XiZDnSRxGp6pqT3J8Wd+ife6kqWRn9PRkf+vSq8ze9P4yuXjkK+1+IqbIiLXHF1gq7QqKWSE3BHuiJPYFZOAAvJlOsivKONJQb/azz7L0s6eLTGzm584QI0FUXqYDPyp5llCvVDEq7W2Eoyrk9TE25uW6tfgTutmhC4v5lgUCu6XqHs8JkIjt+GgkTCYKHhQCqEkFRy1BDhHAhuZ+OYFMM9jvOdr7TNgfKCoqz+qzq6fiZIX+fpxNNja0MLP+9EWfuVCzyL+/ewf+YPz71RGMajc4TMCcnZ0KQVQz3M1YdEnXYqN13FsBdvL1JaoAKh0Jjr+xyfFWjEXnDXgH1AYQDxXVfP9mJPgOuy2TFnb3w44+EN61nJk+wddrccNHxMyEMPIH3qArabXdOEfNwsU83ISAv9IatbDXF8Yi3FRcppMolkgkQl1rC9B71Cj0iPbcyRVmpd1wE7Q3amJ/eqlY4wVhrDBvUvy+dl8gwL8/9iCH6mtHYreGBBHtEwTDyleKI2o+eywVZp9sekW7NQwqFzur9AvJtXQMSxrum3TSjUo9IR6ltd/jj3xE+CutpuitI5TyhcYRAtxPMy/SwRt08aHeA7iJbh6nNS39rWHLRV9spSYPG54RCKPbX3MMgElLFlFHCDcKZ+g9x51EyM/S/jve2LemjnbavF3YFIVpSaoedpuNk/VQoLMXL+HiZacMeJ8nFxWbz5+sh3eoqNW/EbnYzEWO5jj2eIBT8FCJo0/BDpqINiqY5UsXgULCfvZ0Ye1rP0KAe2g0F7tWktUvazxADjbsQARot4itWNFehYsC7GY/tAOt/9VKf/vatSq75gg5jSxzHnGyFPEP9Nc7Hzd5+qLDarI4kQwiwEO0sI6OtIbTbcHHXgLYgSvIM9/nQhws0wXWun64nOZNmkJpXj7dgQAf7dsTdxujyh45fJxAWwch6NfCwEECBFHJxWYuRBmifbBhdMZidT52HCg4UEzXRqK+9tjPlJUFZDAVJ35UHqOt3+eSeDQTpo0IdhIvqkOPRX4g7Qep0k3EDMRT0Cr7R2IWTvbgJ4zWOnAxuWRjo5Uwm5JU241Fqlm4+TR5lOKgkwh/pSWlBeVdpjU+cZW9ubODQCiETVEoycvvdbsh2j0lxTT7tM+tcS5vqK0DBj+KShCE4cPa127lofXrWLv5I/75L38iHBn+yS1DgYj2CUIya7xBmdnXnj4rtZ+IeXFs9KGdThY52GghHGWrHApaCZsXIQ40K/ELtKd8IRhB5QnaaCJMHjbzQi6VBGFVry6C1qu4gkzOIos1ZONEEzRvMvgZyMcJ4kclA8XsdTZQUMzFmOG0yO+rPQ6KQmDedABOw2NWrrqI9Dn2zQihm1JcmpLN/esXX8l3L7+Gf7zqM4MKN8nJ9FCg79dIJchb57MD+IM984RjRfsiMvkqxSkJ7xP1717ZkoVklZXizPJgD0fiTpJIB4Zo34GPe2mmkTA52LiRfE7TF2/6gw3FFL5Wi3yswLKhsJwe90AV7iiLs/Y7bd8OE0xp0XAnfuoJkYHCKXhM0d5XpdxLhC36cecUy+tVULiCPHNM1Zt0cReNbMA7aAGoopohn2eR3atSfBbZONB6/lPtyY+yyG//pNftXiKmNfqTl1+jcc9+oH8J60bleC5uFH2RoRRHSmF0RpX6r7TEFX9GNbzQ0ptu9LUnqpT3VWm3o3A1+WSicIwgrw4wUM2KcX6cjFNvLImPcf7UshrivycBVDbgTTi6tYMwr9DBfTTFPc9vwEsAlTIc5jEj1vpuVLznk4ELhdP1z/f6PqYqhFDNINKZuHDrxwIPCscJ8XySkYReImaY7vw+RLvRz16al4/D3jtIMxs7nmAExabQ5dEex1gErD6ij3sTe7wgjBnmT5kGwO5j1aY4r25s4K9vvQrAVy+8zGzHHOuMj1chmOzEx0a8vQSpsVIer9/VylBU2vcRIIx2oWSE+riwcZ5uE11PZ1pt4rG8pXfoz8DFteSjABvoNqtgyXibLnbhxw5cTwEL9QuZVFJ8d+HnKEGcwA0UcBl5nEsOZ5DNpXp/6+t0Dtoma1gVqyzztq0Md1+7YW8vXTwfb6aTDBRWkmVWjlMV7cn62Q2Kc/O44pRVZLoSX8ylimmRbxoZ0R4bQme8Pw67nZxMT8L7JWMWbjwoOLI8TD/vDAAmqY6097MbGNkKIbTk8iVk8A2KzYr/QOiZ1a69R11EzGOHNTBsKZnmT/Eu8Ev0QLEgatKgswgqb+jC7FQ8ZGIzFyRqYnp0rXxMN0G08LJpMQsjDr2d4XryKcROFxGepZ3/pYnqQQR0HidEmz4Oa1WchZFc7Jysu5zWmdOpk3PmAs0i/86u7YTC0WJxI15CgKOti/bD1bTsOQCkLtpV1F797KC9R8YicrzjVhiVrXTze5q4n2Z24mcnfvOxDHpC6HoEeM+s9vjCty/RDtrn8Ar9+P02XYMeAddz/O77+JWHnUk4UUlcbX+VDp6lnXto4nc08hFe/ERoIcSztPErGnibLg4R5GFaoj6/IVRzEX0VWWYWxjZ85mJI0DKlZIH+91qBhxxstBFJWG0/qk+5yLIsfBfg4Fp9usVmuhMuRIB2vo2gFRYKEvxdoKefPXbcm5XyiHYeChfmEkQ134OmujoURWFaSWnC+wqCMLqYVlJGpstFd8DPkYY6VFXlrmcfJxgOc/LseZyhjy4dD4hoH0OE9RmtiSrEPiL8jVaepp1tlp63AKp50ZOs0m5YExvT2P+8K04VBbRwrHIc+PWLr6HAWmU/m2zmkcEatGrli3QkDRPaj9+spFxCLpNwmj2Nycb+hFHNlOjTyCI3ZnzWUjI5iUxU4HHaEqb0psL+JBd9wy3aa1ua6Qr6mX7u6YB2AZhhsXt3ESHXFO29nQZmP3tFaqI9nUwZ4bFvvce96SF02TmDchE4UFikX4QXz58NwGzHwBcBUnk+zV1h50byuYr8PltzUiE2Qb4nOd4eVU3Pxs555DAXd9zAO1tUX3vfInk3frO9wxgpl4OdchyoxK+2Ryy5F6fgiTruGSgoLNAXMi4mh0wUGghxL80DDqmzjsNyJliMOYNs3CjUEooK1uuLRdNmUJCVTUe3lw/37jJ/H7a8zkNvvw9Ay/7DqJEIjYRpSWHxt4YQ7URwWv4mBonC6FoJczeNPEYbxwnhoEdg74rp9+6r0h4vQd5HxKy8JhLtoAnWFfr36Qnakoa31hA0FwOspNLPHv282jF+R5y+9hCqWRVX0N63Z2jnv2jgf2hkA92E0Cr6BdhpJcJjlnaxT+imkwi52FhMBjNwkYsNH6q5SH0APwG9laFSf3+cKJyZpNreE7Tnivo+VOFmMk4i0Gea/C5Li11fJEqOtzLdrh0TMivLqPdrz2mPqIS6fVQWFOF2SnK8IIwV7DYbcydNAbS+9je3b2HDvt24HA6+fdmn0zJabrQgon2MEEbllzRwH81xT/ygXXwalw0v0GGuHh8jSAStJzTZ3OUcS/9zoufp737vMfvQoi+ebSjmBfVAZianwpuWKrthIV6Fh6W6WP4brQlthPUEeZRWVLSwHaMftCJq7E/i/d5EN42E8Vjsg7FcQi5lOOiKuXjqD9ZArKoEF33GxVU9oWHJENhXe4zCWTPILC4kE4VT9eqeIdojQG6eloTeZ6U9SQjdUGAmyI+APT6k5y5AT6Xd6GcviLHGD4QTY76DQ9XPbnAeOXyTkkFV163EivZ4s7QNVpHFjRT0ssYbpBJGp1qq7KfgiQq/mmn2tfe+/278tOqhdSdYrPrxcOiLAbdRwnzchIFnaOcp2vq9cGq1LSciCxuXoX331tOVUhif3WZjzZLlADz85jpzHu4ufZydKxThwIcfoygKYb+f7mNab3Cynn/oCSmdFWehIdFi41o6aNaPrWeTzfco5Qr9Ne3BH3WMs457M+ir0m58pnKwJV1kulA/fncS4XHa4mYTRFB5nU7uoYnf09RL3BuJ6k5IKZxxvuWc6Y15vr348aKSjY3vU8IF5FCEnQAqETTB/AUK+AqF3EA+LhQOEGAdnURQeceS22BHwWb5/BqLATssnzGr+D4JD7nYaCfCxjiLTvv7OEcZ59aP6Y5blIgOKuz7WGLOaO9DtFfpi5W5kys45tOdTH7tMybWeEEYexhhdJsO7OXuF54E4DNnnMvkopKR3K20I6J9jGBHMXtcdya4yLJePHYR4UW9R8zoA5sWs8IdD8XyPInEbH84SpBuVDwoTIlzQZLqzGQ/Efbi5xU6+D1N/D9qeTNJlaiFkFllP0e34oP2Gi8jl2l6mND/0dzrtbYR5s+04ENlCk4uIdd876xjf/YkuCgNEOF1ff/OIpuMBF81JwrXkY8bhcME+RPNvEQ7W+imkVBKIXVH9MWaPGxRF6ZW8rGTqY8HqxuGMLr9NccpWTwfgMVkmsLJgUKG/j5mJRDtwVCIww3aRf/M8kr24ec/qBvQTN+BMHkEZ7U3ECIMZFjCsnpC6HL7uGdqTMZpfkYcYM4sHisUmPb46Ep7PNGeDOPYU01Qn5Ddm+OEqCGEE6VXH75xDNgf435SLeJnGZ6EFe9YMrFxHfmcRzYKmoC5lybztSajkRANKYzDAjjB4vL5e4pTLK47/WxcDgdbDx9k08F9ALyvv87g7oOooTDn68K+bqcWWJfKWDRjUXdOnH2OF0ZXS5CtetX1cxRyNtlk6dMIsvWqsBGCZx33Fm2P7+lpjz3GJrPGW3GicC35ONEWzX9LU9R5OKAvxhrngoDFfm5gLFhPxWWOJeyLYhyU4iBC7xYtw5p+IpnkYGcVWXyLYm6hiG9QxOcoZIbueCvDaRlB2MUztNNIGDeKKaJBa2tBf65Owmb+QGzbiVZtN1reuqK+Uz4iZhtKvJF2i/Te+CbCZt+7lX1xqvuJqG1NXmmvwIkajuDKyWZ/RHvPwh3aZ3l6mYh2QRhrzJus9bW/svkjGtpaqSgo4sazzh3hvUo/ItrHEMZJMl4vm2rpMztbv+jbgo/d+FIOoTMwLPLp6Gs3LG1zcMftnbXOTE70fK/Qwc+p5y+08DZdHCNIGHiNzj77Ud/UL0WrcPXq5XegcCMFTMJJd4xw7ybCX2ihnQjF2LmRgl4X3sZFcaKL0vfw0kGEAuzmyKVEFOPgSvKwobki3sXL47Txaxq5i8akoYBWa3yiRRkFZVgt8vvqa00Ldqw92ai2Z+RoF3ht3mjRfqSxnnAkQnZGJsV5ebxCB15Unqe9z57HdGGd1W5UFIcL4zNYjtP8W1rt8YNFsVTOpqQoEkYTsbPaByPaC/XxX8ac+3jssVSBs2JOl1Nx4QQ6iERNZdhAN0f0HIuTk3z3Y7HpwudmCsyArj/TnNLinWGNn4ErpTaEi8mhBDsdRHgihSkWxbl5XLLsVAD+8vG7PEsbhwliU+GjF9cBcNWpZ1BZWETzXq2vPVkLURcR83gUb6HBCKPrtoTRGe1Ki8gwW0hAe+8M67TxXljHvVldZnnYsQMhoicRQP8/UyU4uJEC8vUE9T/TwpO0UUuQe2lmu56HslT/3n2o95gbHEjikopHPIt8J2Hz87rUcsxVUJiEk9I45/9FZJguMGOBewWeqEXmUpxU6IsEz9OOV1+Ej5ePs4xMCrHTSYT3LIsTB/UBgMXYzTBJK25s5nni45hFjZClzWxxTHU/Hj0z2hP3tDtRCDe3AnAkQ2/ZatF+lkq7IIw95usJ8gbfuvSqcdnmIqJ9DGGMezlGsFf/c6M+MsaBZgtdqZ+In6XdHPfW1ygZK0alfT/+hPZMVe+T72tUkYpqGdES39Jmt5z84104dxPhPV1852NnKZlcRR4LcBMBnqQt7kVhCyGz6mCtslvJwMbnKGCyRbgfIcDDtFBPiBxsfJbCuPNgZ+FGQbvAix391kWEt/UK1LlkpySMFpLBNynmSnI5GQ+TceJAqyjeR3OfNnzD3prsom84RXtthoIjM4OMUKTXYpEhfpxZmqCJrbRbQ+gOKkFzMcdvSeIfSioLi1EUhU6fL651Pxk+IjxD24CcAbEhdAAtRqU9Z/CiHbT2kDPJ4mLS83jDiVFp7yBCCLVPe3wyFBSzupsoVNJYlIsnKJ0oZnuBYd1tJmR+RteQk7QdKRGzcPNVislAoZGwufDaF6lY4624sHEt+TiAvQSiRFY8Iqicds5qTvzi9eRcfQEb9M93SX0bnS0tTC8tZ+6kKcyumExnTR32QCjpLPt9+FHRwsViMz8gNowuxBEC7MaPjfjHdeM8sws/EdRe494M7CjmZym2r70/lXaDKtx8nWJOxYOCVvH+X5qoIUQWNj5PIVeQS5E+inCj/t5FLK6AZCF0VowAOK0CrZ2Dt+AjAgkFeiLOI9sMVrSD2cpkxQik224JDIy3CG9HMf8ub9Nl2vdTCdo7yXwOn/5KND7ASyNhsrCZlfxEhK0z2vMTV9oBnK3asb0rU3uvWuo1Z5WIdkEYe5TlF5iTf1bNW8TKeQtHeI+GBhHtY4gc7GbPW2xCrnFxOQ0XLv3EWYiddiL4UXFZLn6SMQsXmfrF4hO09arARFB5lnZ+RxP/RQPP0BbXSt9ImGbC2OkZ/xSPvmYm79bnwZbi4LuU8CnyWEIml5FHFjbq44QpdRLmUVrNHr6+FisysPFZi3D/E80cJkgGCp+lIOFFt0e3Y0J0tV1F5SXa8aNSgSNuCFYiinBwEh4uJZd/oIgfUMoUnPhQeYCWuIFXXURMoZdO0a7q/xsIXT4f9hmTAFigunul2Rui3ebRLtJig+gM0V5VXmnajKv0QUhb8KXUgzsY3E4nZfkFQP8t8mFU/kYrH9HNc7T3e/52bAgdpNceD8bkhhzKxpg1HrTPjhMFFe1z3EUEBc2tMhDmWkR77Ofda7H0JrKbW/vajdGQQVRm4Op3lT2WfOzmpIrNcULHrHQQplrf12RBXVbKcHKR3gu+jo6E2SIB3X30fHaI/JnTUSMRQoeP83kK2Pn0ywBcsHQFiqIwq2ISqKAe14Ic++pr72tRxMB63DLG2S0hM+7fvAoXbhQ69L9dvBA6g8IEfe0DEe2gVYsvJpcvUWhOMijDwT9QyDR9qoeR6P8uXYRRqSGED21UZ3k/nk9LULcTAnN0n7FIuDRJhkIsNhSuIZ8FuLmAnLiLJyfENHj1NXJtERmU6QGzb+nHb+Pc1dd1wBSclOAgCGb7QwdhM1NiDdlJHSSN7W2EIxEcdjtFuXl9bpvdFX0eaWtswibJ8YIwJlEUhWtPX83cSVP41qVXjfTuDBki2scYsfY/g32mjVO73Yli9quB1sua6minbOxcr8vV7fii5tBGUHmKNj7SLxACqHxEN/fQxB9o4kXaeYQW/pdG/oBmU6vSZ7ImomdmcqBXEJth/1sQc5GQhY1L9YvNt+gyhWgTIf5EM8cJ4UHhohSqiYZwN3ru7cBnKEgqauJZ5DfQzSf4UICLyI07fi1VMnUnwExcBFB5iJZeycgH9ecuxUFOkqpeqmF0IVT+TAu/oIEP8aZkzbWyt/44Rbo1/iRn7/ffEO2qW3t/O7q9UWOkjOT4ihnT2EcABbicXLPN4Hna0xam15LgvZhS1P8EeRWVF2g3RUoAle1JxJaViKVFxFppT2cQ3VhHsfT6G9XxfOx9zrbui+l6+Fk7kV7tOdYqcDxLL/QcAw4T4E26OEIQNwpXDvK7b7DEUn0M9PGZNxxNk3HGFV19sZxMFuoBeH+huddn1keEP9PCfgI4UVjis/HRr/7AO3/4M/s3b2Xr4QPYFIU1Jy4DYHaFtmBXv0vre0/UQhRBNc9bqYj2TXRziCB2tBaweDhQzMfaiT/uuDeDeAnyfiL6cu/A3BugOdq+RjGfo4CvUBQ1nuxEMsnWw9q2WhYgp+Pq1+hFbfJAz7VADZojyU7vdqRU8GDjegrM6QixZGM3F6hcKHH70g1sKOaElg/o4igBGgmj0HfwpYJiVtuNILtX6MCPyiSc5nehL4zk+LK8gqRzmUti1q79be1UFEpyvCCMVW448zz+cOv3+syzGOuIaB9jWJNjjSpe0GKxm205KU7HxSm60Jnbj+oLwAzc5hzat+jiY7yEUfk7bWzGhw24mjy+QAGLyMCOFuj0Hl524KeWEH5U7JC0p7sMB5koUaPpQLuAMi7qFsa5EFlIBovIMG3yRwjwJ5ppJkwBdr5CUco2wQxs3EwBZ5Oth/UkP3Eb1tr9et/mEQJm+N8actKSzO3Cxo0UMB83IeARWnmCVj7GSzMhs5+9rwqGgTWMrp7EeQUv08F+AnQR4Tna+T1NZphhKmzqbsPhdqN2euOGDxqiPeR0mKM42rxaRabL52Nn9RHtv6drNsUFuCnEwbl64FQDYd6j95i4/rIRL7+ikWf1v5kVY1Z7dT9mtb+Hlw10o9Dz90g0szgeLYQJoOIgunLc3Kn3tKfJHj/WMWzNuy0LVgPFiWL+rRK5l/oSlMXYycVGCC1jA+BCcvqcI90fpuqjuQKovRZqrRi39VUBTYSCwqfIZ55+jPkbrbyrf7+8RPS2Ic199HkKuCqjlNUz5gLwn0/8FYBlM+dQkpcPoFXagX2bPgFVy0aJl0VxnCBeVNwofeatGKLdCMs7GU/CRRSwZr/4TEEer9IeL0HeGF+XjS1uW1SqOHVhG7uY5LRM0nibLtM2nsr5JhbjWmA3fjbo+z2fjEHtd1+crIvmxWQkDVecjYtpOAkBj9IKaLb9ZJXyJWRiR2uF+BCvuQB+aYqLYD0z2pNftFc4Mwl6e47P/rYOppeINV4QhNGLiPYxRjF2ivTwJMMWd4gAISAXWy9L38XkcCtFpnjvD0vI5Cx95f0Z2vk/mtmKDztwDfmcQCYzcHMt+XyPEs4nh9PwcDE53Eg+36SYf6Ys6YiWRDOTtdE9WkUk0YX5JeTiQaFOr7B3EaECB1+mMG51pS8ysHE22SmL7XJ99FsAlR34eFTPeV6Im1WDtMZacegJxSfqCxSb8fEU7dxFo9kbmUqIkYJi2q4TWeS30M0HlvnSGSjU6O/tE7TSnYLd+2iWdoGc09geNzQoWz/seJUIuZnRfe0Prl9LR7eXadOmcSRL+/sZ+QyZ2Dhfr+C8QVevLIH+cJwgz+tifTu+XtkNPbPaUxPtO/GZvcznk8OnyEMBDhOMOwvaCI60JoMb1viyGFdMc4dhjxfRDj2i3ZiCMBjRDsTta49YRkzNTlIdnGURynNwm9XCdKCgmBXGRBkJPiKmrT3VfvZYXChcTz4n40EFXqKD52jnfotr6QsUMkV/L2486zxsikJQd8hccNLJ5mMV5+aRn5WNv7OLwqB2vIhnkd9rWXDsq8pshNEZ+5msr3k2buxo7VnG+xJvqoY1QR40V9c6c+JH/IpzOliBBxcK9ZZF1/6E0BlMxkmOPnrUOA+kUo0eKHPJ4NsUczHJ23QUFM7Tj9VG0F8qrzELm3m98Jx+fF5KZspTLvoj2otzcumorjF/9re1S3K8IAijGhHtYwzFkpBrWKWtFsNYkWSMcBuoVfMcslmsi8XDujXxevJ7Vb6zsXM6WVxELqeSxVwyKMGR8rijeH3tPdb4xImxmk2+pw2gChdfoDCpVTwd2FDMC/onaKODCCV6EnyyhNv+YkfhKvL4HAWcSRZTcZqvMMMSiJWMvvra6wnytH6hdBZZXEIu36LYFCGb8ZkXUokIECFYpl0wzQnG/xtk6XveRYS8LO3iuK2rk2NNjTz2zhsAnH3VFUQUrdI4xfLaTiSDqTgJ6tkBA6GbCI/SakrpAGqvXt6eWe3J7fHHCfI4bahoVuOVeMjF3me1/R28/IUW/ocGnqaNZn20GERb47sDfroD2vc7XT3tY53YnIl0ifZjBM0Z2jX67GytCtz3d8uoxGeicIVlNGS6OFE/1h4g0CuAFLTFhjBQgn3Avf2gHc8uIYc1uij+EC91hMjGxhcpispZmFxUwnm6Hd7jdnPG/MXmbWZfO+BuaAO0RPDYzIBUnAygLVoa4ain4emV4h9LBjbzfNKtP2d8e7z2uxbCHCXA32lFRavkDzaPoC8ysbHcIq6z4iy2p4INxVykUdHmyqfiuBoMRf04p0/DFTXGL9V9sy56ZVis9qlQa85oT5wcb1CUk0t7tdaKpQaChP0BZkgInSAIoxgR7WMQYyVau1jrGfU2awDWyGQoem/8TD2c7kYKmDvAak5fzND3/YhuNQ+gmjPQ41njrSwigwvJ4WyyuYmChDPRhwLjgjMCuFH4DPl99u8PBkW3XJ5HDl+miH+mjC9SyC0UpfyciUS7nwiP0EoQlSpcZs9oNnauJI/PowWzbcNHYx/W+l0RH4rTQXdTCyfmlcTdxrjo7iJCvp722ert4p6XniEYDrN83kJqijQxvyqm4mVD4VJyUdCSjPs7Ak7VMxlaCJOPjcWmxTTaejxFn9V+rLmRcCSxuyCCypN6+NhMXFxiEW0nWSqk1lyANsLm3OYwsJFufk0jH+kOB6s4MpLj3U4nHnf6v99jkYI0i/Zc7FTgQKWn+mtU3ZNVgUGzY19EDp8bosXCQhxMxYmKFsQYS7IJHf1BQeEMsrlaN6DnY+NLFMZ9j7947kXMqpjE58+5kAxXtCAz+tq7tu3Bgbbga20/6LKE/KVy3rqYHFaTlbTKbrDA8l7EjnszyMWGA+07+GdaCKK5Ki4iJ+0LL7GcZi5dagvWA11Ut7ZDnEhmv/rih4M1uq8qEyVq8bUvZuIiXz9HGC1RqVJjivbklfainFzaD1cD0N2kJc5LcrwgCKOZ9DTeCcPKFJxkYaOLCJ/QTSNhbAzMYpcKTj1JPQxDNte5BDvZ2OgkQjVBvEQIopKvX1AnY+UQ2hn7YpZuxQwDV5E3qEpXf3H2o8JuYITR1ekBbEFUU0Q2EiYXG9eQ3+sisgo383CzCz9v0slV5Md9/I3BdnBD8449TFl5adxtsuOI9je2buatHVuw22ycfeWlfKioFGGPm8VQrs8NPq7bS/tjCX0XLzv1ucnXUYBXD4TahZ9LUM3XXZpfgNNuJxAKUd/WkrBys4lu6giRoScwWy+a55FBJu20E2E/AXOB50XaCaIyFSdryGE9newjYFYFrSnS1hA6o/9/omMV7YNJjrcyBzc1hNiDn6VkplwFBm0h6bQhPv4sIZMjBNlMN6vwmKIyiGouMCxI42LqCWSaPdmJKqsVhUXc+40fxL3NqLTvP3iAqziHt+jiFTp067rC/hRC/qxMwZWy6AMtw0VBq0DHjnszsKFQiIN6PX+lDAfXxnyHh4o87CzDw4d4e4Ws9ofpuMjRrwX6mxo/HJTh5CsU4ST1awcbCjdQwHGC/bb717Zqoj0Ve3x2RiZdh46x99m1dBw9hk1RmCrJ8YIgjGJEtI9BbCjMxc3HdLNWr9hNTiHkZTAoKEP6YVH0vnYjUdcIB1oYx/I/msjUk+dDpHaBP9IU6GF03aj8B/VRidSakM1PWNk4i2x24WcLPlYTMkcmGfiJcNipAgrumiYc9kT2eO3xu1HJy9Ksj+u3fwLA5SevYn+OVv9aRVbCCtQs3BwnxD78SS/sgqg0E+IYQdbqfecXksMknIT0cYgd+ug8o3fSbrMxqaiEQ/W1VDc2xBXtfiLmZIXVZPcKgHKgcAKZfICXTXQzGzd78bNDnzN9GbmU4eSzFFJNgHfowoES1b8p/ey9sVZNC7CnbNfti7m4WU8X+3T3Rn+qwMPBQjJ4gXbq9TaKSpx0EuZp2gmgkostpcXN/tCfCmcssysnA3CgtoaVkUw22rRZ25voZjmefi2KDARjPOpRgnFD6AyKsFOvtwDcSMGQuaTicTE5nIJnQNZ4AzsKX6QQH+qgHmcoSbUf3Uo5TrMlIlVC4TANba1AavZ4RVEoysnl+Psbtf0sKpbkeEEQRjVijx+jGH3tRqLuaLm4HAxGH+JeAqaVMp3Vo6FiBu4xIdihZ3EEMAV7FjYm4eQa8vusZk3CySxcRNCSj2PZjZ+ITcHb2Mw0R+Ke0AwU88CTU5Bv/j4n08NN515gLtj0FaplfN6N+dixBFF5jFZ+ST3/Th2/pYmn9EikRWSYPasOFGbprzl2nN7kor7D6N6ii04iFGKP6oFt7uzgS3f/gntefNqsfu3CRwdhM/zuFDxRIwUn4+I6Cvh0jMvBTI6XfnaTTGxkGI6INAmVSt295EflVTr7VQUeDjItAV2b6WYPfn5LE7t118gF5KRlxFy6mFxUQobThS8YoLGpidW6rf01OvERSSnkb7AY371pfTzHaWQxGzc3UxDXQj+U2FDSIrSLcAxIGI836ttaiKgqLocz5UXOopye46r0swuCMNoZnUuzQlKqcOMEszN5rIjGvjDEpFHlytXFpJBeriSPUwiSjZ28fs64Pots9tHMJro5i2xT1NQS5EW9it2wZSenVVQmfAwbCh69FcKT23Nx9YVzLyTscQOdZKDg6WO/puDEhYJXn21eGfM52Y6PrRYRnoFCEQ6m4ORcsqPcG/PIYAd+duHnXEvokZkg39Q7jK6VsDkW6wJyoqyfj7+7nn21xzncUMfnz72QMpeDOkI8QAvNhMnRpxSkgtHTLpX2aPKxU0sobaLdhsIc3Gyi2wwOHG3H1CVksg0fH+HlfT3/oBQHV5PX76rkUGO32agqr2DH0cPsqznGWSVLeR8vzYT5O20ph/wNhmVkMhlnn+0T03GlZTSnMPIY/ezlBQUptxJZRfv00ooh2S9BEIR0IZX2MYpLDyUD8KCk3Ro5EhTqM48NFpAxqqpH4wUtXdlNCY5+CXbQqlbTcRKmp9peTYD79HF7vtoGjr7zIbPKJ/X5OIb1Nr9I6z2cVlLGFSevMqvsRTj6bIuwo5gZDvvw97rdGI91Gh7+kVJ+RCm3UMTF5PaywM7R+1/rCNFiCdmbYsxqj1NpX0cHIbSL/nkWcdcd8PPMh+8CEAyH2Xb4oFnxq9cf+0JyUg5LNO3xMqM9CmMxL52iz0i6Nnwbo020z8RFlj4THuBUPNxC0agT7AZGX/ve49U4LCPADBdVVQohf4PBmJwyVDkswujCSI4vz0/ez25QGCXay9K+T4IgCOlERPsYxujlXUTmuBC3ikWIwdiwxk9EztKrxBvxsh0fD9CCD5XKsJ2P/vggYZ+fqvK+qxaGaJ88aTI/ufZmfvXFW3HY7TTror2vPlQDq0XeSptlPvOp+oiovhYAPNiYqgsfa8L15ASz2o8SYAs+FDQBbn3slz7+kI5ur/nzR/t2c6IlbWIGLhb143NtDaITeriYXG6lKK32ai0pXkOrAo8uMWxH4SJymI6Tz1LAxeSmpZ9/qJhdofW176s5Bmj5JJMt7+loWxQRxjbVTdpxOpUQOoPiXKtoF3u8IAijmxEV7dOnT0dRlF7/vv71rwOgqiq33347lZWVZGZmsnr1arZv3x71GH6/n29+85sUFxeTlZXF5ZdfTnV19Ui8nGFnARl8gyIu6Mcc09GOMfot2yKkhNFFFS4m4yQEPEorflSm42L50TbCPj/l+QXkZPY959hIkPfaVNacuIyi3DwAmvU6YmqiXRNsRwjip2cs2xY9h30aTgpSdKAY/cK7LKLdqLTXtjYTCGn7paLykt4GsITMKFt+OBLhsXfWA3Di9JmAJtqzsHEqHvKxc1k/53hLT3t8nHoVNZ0hlRnYzP7nVEa9jQQnkMkXKRoTGSbG2Le9NcdQVRUFhfMt5yoR7UI6eX/3DgAWTp2e8n0Me7yWHC+VdkEQRjcjKto3bNhATU2N+W/t2rUAXHPNNQD84he/4Je//CW/+c1v2LBhA+Xl5axZs4YO3TIKcNttt/Hkk0/yyCOP8Pbbb9PZ2cmll15KONy/+c1jlVKco7ra0l8WkcEKMrmc3HHhHhiPKCicZRlxNQsXN1PAoeNaRW1mEms8RM9qt2K1xyejEAeF2ImAWVlXUdms97L3Z1yQYXE/RIBufZ8KsrLJcmegqirHmxsBbYHgKEGcaDOErby7axvHmhvJyfTwo6tvAGBf7XGaOzu4kFy+S0m/x5O1dGrp9GKPHx5OJ4ti7EM+wm0iUFVegU1RaO3qpKlDW3yajotPkctV5I2akD9h7HOsqZEDdTXYbTZWzl2Y8v3K8goALTjR7ZQigSAIo5sRFe0lJSWUl5eb/5577jlmzpzJWWedhaqq3HXXXfz4xz/mqquuYtGiRTzwwAN4vV4efvhhANra2rj33nu58847Oe+881i6dCkPPvggW7duZd26dSP50oQB4kThMvLMyqcweFRVRVV7J6wPhjm4ORUPJ+PhBgpobG7mqQ/eBmBmHyF0BolEe38q7WC1yGuivYYQDYRw0L/2iiIclOgLAMY4KkVRLBZ5LYxugx4AdgKZ5Mbs46NvvwHAFSevoqKgyOzp3bh/T8r7YUVVVUulXUT7cDALN9+ipM/EcSE13E6XWb3ce7zH/bYUT7/nbwtCX7y1YwsAS2bMIteT+oLbCdNn8tnV53Pb5VcP1a4JgiCkjVHT0x4IBHjwwQf54he/iKIoHDx4kNraWs4//3xzG7fbzVlnncW772pBTxs3biQYDEZtU1lZyaJFi8xt4uH3+2lvb4/6JwjjkS6fj+vv/Dd+9Jc/EYlEkt8hRRQULiaXS8ll79EjfO13v+JoYwMleflctvy0pPc3RHunRbQHUWnTf06l0g6ajRl6+tqNALp5ZFg6yVPDWCjaHcciX93USBcRtutV/BVE2/93Hj3M1sMHcNjtfOrU0wFYPmsuoFnkB4LX78cf1CYpSE+7MBYxLPJGX7sgDAVv7dgKwBkLFvfrfg67nS+tuZhlM+cMxW4JgiCklVEj2p966ilaW1v5/Oc/D0BtbS0AZWXRfUZlZWXmbbW1tbhcLgoKChJuE4+f//zn5OXlmf+mTJmSxlciCKOH3ceOUNvSzHu7t/P0h4kXsmIJRyL4AoGk2725fQvfvvc3tHR1MqtiEr/76ncozS9Ier9ss9Le08ZiJLe7k4x7szIDFzagmTCNhMwxbycOwKkxV6/a78FPSM8Qn1GmhRO9tWMLm1QvYaASR68Rc3975w0Azj3hJIr1/nxDtG/ct3tATgdj3Fumy02mS/p/hbGHEUh5qKFuhPdEGK80tbex7chBAE6f3z/RLgiCMJYYNXPC7r33Xi666CIqK6OttbHzNlVVTTqDM9k2P/rRj/jud79r/tze3i7CXRiX1La2mP/9x1ee4/T5iyjJy+/zPuFIhG//6TdsP3KQ2ZWTWT5zDifNnMPiaTPoDgSoaW6ipqWJ3ceO8ug7b6CqKqfOWcC/Xv9ZPO7UxHI8e3xPP7s95YCxDGxMwclhgrxEB11EyMI2oKCuyTjJwUYHEd6mi9Vkc9HSk3ngtVfYfvQQ7wTbwGXvVWWvbWlm/fZPALh21Wrz9ydMm4HL4aChvY3DDXX9TiduMqzx0s8ujFFK9Z7hxvbWkd0RYdzy9s5tAMyfPDXpuU0QBGEsMypE++HDh1m3bh1PPPGE+bvycu0Ct7a2loqKnvFR9fX1ZvW9vLycQCBAS0tLVLW9vr6elStXJnw+t9uN2y2VK2H8U9fabP53l9/Hr59/gn+74Yt93mft5o/YevgAALuPHWX3saM89OarCbe/fMVKvn3Zp3HYUw+Wsop2FS1ZumfcW/8OS7Nwc5gge3Rb+2IyBpT8bUPhAnJ4nDbW08kiMijOzeOyFafxav1hulx23KrCIiV6YeLhN18lHImwbOYcs48dtJ7exdOq2Lh/Dxv37+m3aDcq7ZIcL4xVSnLzAWhobxvZHRHGLUY/+xkLThjhPREEQRhaRoU9/v7776e0tJRLLrnE/N2MGTMoLy83E+VB63tfv369KciXLVuG0+mM2qampoZt27b1KdrHKn95Yy0/f/whaluak28sCPRU2s9ZvBS7zcab27eYFznx8AcD/GndCwDcvHoN/3z1jVy4dAUluuUboDgnj8XTZrBmyXJ+dPUNfPeKa/ol2KFHtIeAgG5F728InUHs6KjBhFwtJoNZuAgDT9NGBJUbzjyXyacsA6Cy3Y/bctjcsG83T3/4DgA3nXVer8dbPkvrlRxIX3tzhyHapdIujE2MVpHG9ra0h2EKQke3l48P7AX6388uCIIw1hjxSnskEuH+++/nc5/7HA5Hz+4oisJtt93GHXfcwezZs5k9ezZ33HEHHo+HG27Qxinl5eXxpS99ie9973sUFRVRWFjI97//fRYvXsx55/W+gB7rvLJ5A0ca6jl/6QrKCwpHeneEMYCxwHPavIVUFBbx0Pp1/M+zf+ekqjlkZfS2sj/27noa2lopyy/g5tXn43Y6uWDpCi3JvKOd7ExPWkbjuLDhQiGAShcR3Nii7PH9oRwHHhS8qJTioGIQhzUFhcvI5Tc0cZggm+hmTm42RfNnAfDJ2tfh6s8B0O7t4j8e1yZZXHnK6ZwUJ8xo+cy5/J7n2HxwH6FwuF+LG7W6S0JEuzBWKc7VXCL+YJBOXzc5mZ4k9xCE1Hl/9w7CkQjTSspkzrogCOOeEa+0r1u3jiNHjvDFL/a27P7whz/ktttu49Zbb2X58uUcO3aMV155hRxLj+evfvUrrrzySq699lpWrVqFx+Ph2Wefxd7Pyt9YoMdq2Dqi+yGMHer0Snt5fiGfO/t8JhUW09Dexp/WPd9r29auTh5ar41K/PKaS6LEuaIoFOXmpXWWbWyCfE+lvX+i24ZiJr8vJTPlfvhEFODgHH0G+8t08CZdYLPRfriaTZs2senAXlRV5b+f/huNHW1MLS7laxdeHvexZlVMIs+ThdfvZ8fRwynvg6qqvL1TS0RePL1qUK9HEEYKt9NFri7UxSIvpJue1HixxguCMP4ZcdF+/vnno6oqc+b0rlIpisLtt99OTU0NPp+P9evXs2jRoqhtMjIyuPvuu2lqasLr9fLss8+O21A5q9VQEJIRjkSobzNEewFup4vvXnENAE++/zaPvv06YcsYuAdefxmv38+cysmcd8JJQ75/1r72UNS4t/4vuF1IDp8hn9NITyXvVDxU4sCHygf6bPbypi4AHnj9FV7evIH12z7BbrPxk2tvJsMVf663zWYzxwn1xyK/r+YYx5oacTmcnDZ34SBfjSCMHD3nrdaR3RFhXOEPBvhgz05ArPGCIEwMRly0C6ljVNob20S0C8lp6mgnHIlgt9kosowhu/zklaiqyv+++DTf/tPdVDc2UN3YwNMfaL3ZX7vwcmy2oT80WEV7C2FUwIVi/r4/ZGBjPhnYBlllN7CjcAV55p5kovDZqsU47HY2HdjLnU89BsAXzrmQuZP6XiQ057XvT120v7FNS6M/Zc58PBKaKYxhDNHeIOctIY18tG8PvmCA0rz8pMdgQRCE8YCI9jGEefEjlXYhBYzk+JK8fOwWEf7dy6/h+1deR6bLzdbDB/nib37BT/96P+FIhFPnLIjbmz0UWO3xTZYQusHa29NFBU5WkQXACjxU5hdy8UmnABAIBVk8bQY3xAmfi8UQ7buqj9DR7U26vaqqvLFtMwCrF504wL0XhNGBudgs5y0hjbypB6qevmBx0jHAgiAI4wER7WOIErHHC/2gtrXHGm9FURQuW3Ea//etf+Skqtn4g0H21x7Hpih89cLLhm3/rJX2ZjOEbsSzMaM4j2y+ShFn6z3uN551Hm6nE4/bzT9ffWPUYkgiyvILmFpSSjgS4Wu/+xXbjhzsc/v9tcepbmrA5XCwcp5Y44WxjbR1CelGVVXe370DkH52QRAmDiLaxxA9lfbWkd0RYUxgJMeX58efNFBeUMidX/gat112NUU5udy8+nxmlFUM2/7FE+39Hfc21CgoVOI0576XFxRy3zd+yH3f/CGVhcUpP84PP3U9xTl5HG1s4Jt/+DX3vPg0/mAg7ravb90MwMmz5+Nx9074F4SxhDjEhHTT0tVJa1cniqKwcMr0kd4dQRCEYWF0lbWEPjEq7S2dHf0eHyVMPAx7fFkC0Q5aUNqnTj2dT516+nDtlkm2RbR3DyKEbriZXFzS7/ssnlbF/337H7n7+Sd5edMGHnn7dd7dtZ2fXvdZZldONreLssYvXpKmPRaEkaNEFpuFNHO0sR7QFqTTOdFEEARhNCOV9jFEfnYOdpuNiKrS3Nkx0rsjjHKMcW9lMfb40UL8Svv4XUfMyfTwz1ffyB03fZnC7FyONNbzwwd+T0Nbq7mN1Rq/SqzxwjhA7PFCuqlubABgygAWUAVBEMYqItrHEHabjcKcXEDG5wjJqdUr7eUFiSvtI4lRaW8nTKvZ0z76K+2DZdX8RTzw7X+kqqyC5s4O/uXh+/AHgwBmlV2s8cJ4oSQvH4DWrk4CodDI7owwLjAq7QNxPQmCIIxVRLSPMSSMTkgFVVXHTKXdh4oKOFFMIT/eyfVk8bObvkROpoed1Uf45TOPiTVeGJfkebJwOTQHTVOHnLeEwWOI9ilFpSO8J4IgCMPHxLhCHkdIqI+QCm3eLvzBIIqiUJo3OkV7ZsxU9dE07m04qCws5l+v/xw2ReGljz/kl888xtFGscYL4wtFUSjKkcVmIX0cNezxJSLaBUGYOIhoH2NIf6CQCjV6cnxRdq5Z5Rpt2FHItIj0iWCNj2XFrLl89cLLAXjmw3cBOHn2PLHGC+MKWWwW0kU4EuFYcyMAU4rEHi8IwsRBRPsYo0QufoQUMJPjC0Znld0gyyLUx3MIXV9cu2o15524zPx59aIlI7czgjAESFuXkC7qWpsJhcO4HA5K9bwEQRCEicDEvEoewxTn5gNy8SP0zWjvZzfIwkaD/t8TsdIOmn34B1deR2N7K82dHayav2ikd0kQ0oo4xIR0YVjjJxWVYLNJ3UkQhImDiPYxRk/FojVtj+kPBmloa5Uk1nGEmRzfx4z20YA1eK5wgop2gAyXi7u+9A0UZeL09AsTh2KZ1S6kCSOEbmqx9LMLgjCxkGXKMUaJpdKuqmpaHvP3Lz/Ljb/6GR/u3ZmWxxNGnrqWsVNpNyia4GuIItiF8YrY44V0YVTapcggCMJEQ0T7GMOoWHQHAnT5fWl5zE8O7QfgjW2fpOXxhJGnboxU2g3R7oQJM+5NECYa0tYlpAtz3JuIdkEQJhhylTzGyHC5yM7IBNJ3AVTb0gTA5gP70vJ4wshj2uMLxoZoL8ARMwBOEITxgrXSni6HmDAxqW7Sx73JjHZBECYYItrHIOlMkO/o9tLp0yr2x5obzQAzYezS6es2/6aj3R4/FSdOFObiHuldEQRhiCjSz1mBUIj2bu8I740wVvEFAuY1isxoFwRhoiGifQxSnMYwuprmpqifNx3YO+jHFEYW46Imz5NFpmt0i+EynPyIUtaQM9K7IgjCEOFyOMjzZAFikRcGjjGfPTfTY36eBEEQJgoi2scgZhJv2+AvfmpamqN+/lhE+5inVv+bjvYqu4FDbPGCMO4xHWJtrSO7I8KYxehnlxA6QRAmIiLaxyBGgnw6xufU6P3shdm5gCbapedwbGNU2kd7P7sgCBMHCaMTBouRHD9Fxr0JgjABEdE+BilO4/gco9J+zglLcNjtNLS1mhY0YWxiJMePlUq7IAjjH5nVLgwWMzm+SCrtgiBMPES0j0HSK9q1Svv00goWTpkOwMf7xSI/lqkZI+PeBEGYOJTkpRag6gsE+M69v+X3Lz87HLsljCFM0S4hdIIgTEBEtI9BSoZAtFcUFHJS1WxAwujGOnUtmj1eKu2CIIwWSlK0x28+uI+PD+zl8XfXEwqHh2HPhLFCtdjjBUGYwIhoH4MU5+UD0NLVOaiLGlVVqdUFXkVBEUstol362scuPfZ4qbQLgjA6SNUhtuvYEUAbDyetWuOfjm4v37v/Hh5+89U+t2vzdpnjAicVFg/HrgmCIIwqRLSPQfI9WTjsdlRVpamjfcCP09zRTiAUxKYolOUXMH/KNNxOJy1dnRyqr03jHgvDhT8YoKWrE4ByqbQLgjBKSFW07z521Pzvg3U1Q7pPwsjz3Efv89G+3dy37gXavV0JtzOs8aV5+WS4XMO1e4IgCKMGEe1jEJvNRnGOlvY+mFAfI4SuJC8fh92Oy+Fg8bQqQEa/jVWM5HiP201OpmeE90YQBEHDaOtq83bhDwYTbieifeKgqiovfPQ+AMFwmHWffJxwW7OfXazxgiBMUES0j1HSMT7H2s9usLRqFgCbDuwb+M4JI4Yh2svyC1EUmX8uCMLoICfTg8vhBKCpI/55q7G9Lco9drBOHF/jme1HDnFEF+MAL2z8IOG2Mu5NEISJjoj2MUo6EuSNSnt5QZH5OyOMbvPBfYQjkUHsoTASmH9TscYLgjCKUBTFrLYnSpA3quw2fcHxQN3x4dk5YUR4fqNWZV85byFOu529NdXsPV4dd9ueEDoZ9yYIwsRERPsYJdnFTyoYlfZKi2ifUzkFj9tNR7eX/TXHBreTwrBjrbQLgiCMJpItNhshdMtnzQXgWFMj/mBgeHZOGFa8fh+vb90EwPVnnMOq+YsBePHjD+Nub9jjJ8uMdkEQJigi2sco6ay0VxT2iHaH3c6J02cCsOmgWOTHGsZCTHmBiHZBEEYXyc5bRqV95byF5GZ6iKgqhxvq424rjG1e37qZ7kCAyUUlnDCtiouXnQLA2s0fEQiForaNRCJUN2mTBKbKjHZBECYoItrHKD0XP60DfowafZxORYzAM0a/fbxfwujGGqaFUKoRgiCMMnocYq29blNV1RTt8yZNpaq8ApAwuvGK0b9+8bJTUBSF5bPmUpKbR3u3l3d2bovatr6tlUAoiMNuFxeZIAgTFhHtY5QSPYhuoPb4UDhMfVsroM1ot7J42gwA9iToLRNGJ6qqcrRJtxBK358gCKOMvirt9W2ttHZ1YrfZqCqvZEapJtoPiGgfdxyqr2XbkYPYbTYuXLoCALvNxgVLTwbgBb3X3bo9aPPZ7Ta5bBUEYWIiR78xivXiR1XVft+/vq2FiKricjgozM6Jum26frHU3Nne59xUYXTR3NmB1+/HpihUFhaP9O4IgiBE0dfUk916P3tVWSVup5MZZVJpH6+8qFfZT5kznyL9WgbgomWaaP9o326zqPD+7h3c8fhDAMyunDy8OyoIgjCKcIz0DggDozhXm9PuDwbp6PaS68nq1/17UsYLscWsXHvcbsrzC6htbeFgfa3Z4y6MboygnvKCQlwO+WoLgjC66CtAdZdujZ87aQqAiPZxSigc5uVNGwDMPnaDyUUlnDC9ii2HDvDCxvcJhsI8uH4tAHMrp3DL+ZcO+/4KgiCMFqTSPkZxO13kZnqAgVnka5r7Diwzqu2HZE7umEHm2AqCMJoxHGJN7W1EYkaK7u4l2ssBzTbf6esexr0UhpL3dm+npauTwuwcTpu7sNfthpC//9WXTMH+qVNO5ze3fJtSGWUqCMIERkT7GGYwCfJmcnxMP7vBdP2C6WC9iPaxQrVeaZc5toIgjEaKc/PIzsggGA7z5o4t5u+jQ+g00Z6T6aEkLx+QxePxxGv6mLfzlyzHYbf3uv2shUvIdLkByHS5+dfrPsttl18t7jFBECY8ItrHMIMT7Vql3TruzcqMUk20HxLRPmYwKu2Ti6TSLgjC6MNht/Pp084CtEpqWK+217Q00dHtxWm3m7Z46DkPHag7Pvw7KwwJe45pAbfLZ8+Le7vH7ea7V1zDuSecxB9u/S7nnHDScO6eIAjCqEVE+xjGqELEG5+TDFO0J7TH66Jd+gnHDEel0i4IwijnmlVnkZ2RwaH6Wt7Ythno6WefWT4Jp6WiWlVmJMjL4vF4wOv3c0wfNTurvDLhducvWc5Pr/ssU0vKhmvXBEEQRj0i2scwJYOotNcmscdPK9VOli1dnbR2dQ5wD4XhIhQOmxdD0tMuCMJoJSfTw7Wrzgbg//Rqe2w/u8EMmdU+rjhQdxxVVSnKyaUgZmqNIAiC0Dci2scwk4u0iuo7O7fR0e1N+X6+QIDmzg4gcaU90+U2Bb1Y5Ec/ta3NhCMR3E6nuZgjCIIwGrl65VnkZHo40ljPq1s+Tijaq0p7RPtARpsKo4v9NVqbw8w+quyCIAhCfES0j2HOWrSEqcWlNHd28Ke1L6R8v9pWrcqe5c4gR0+gj4dhkT8o1sRRT7XZz17Sa4SfIAjCaCIrI4Prz9Cq7Q+89jJ7jBC6yVOjtptWWoZNUWjzdpkLzcLYZV/NMQBmV0wa4T0RBEEYe8jV/RjG5XDwnSuuAeDpD99h59HDKd3PGPdWUVCIoigJtzNG7kilfXgIRyLsrz3Ocxve47+efJQv3f0Lbv39XbR7u5Le1+hnnyz97IIgjAGuOvUM8jxZVDc10OX34XI4mRbTw+x2uphUVAyIRX48sK9WE+0zRbQLgiD0mxEX7ceOHeOmm26iqKgIj8fDkiVL2Lhxo3m7qqrcfvvtVFZWkpmZyerVq9m+fXvUY/j9fr75zW9SXFxMVlYWl19+OdXV1cP9UkaEk6pmc/6S5aiqyp1PP0YoHE56H2PcW3mCfnYDM4yuXi6WhpJQOMzj767nyjt+whfv/gX/9dSjPPfRe+yrPc72I4f4v9deTvoYR4wQOkmOFwRhDOBxZ/CZM881f55dOSnuCDAjTV5E+9gmHIlwoFb7G84S0S4IgtBvRlS0t7S0sGrVKpxOJy+++CI7duzgzjvvJD8/39zmF7/4Bb/85S/5zW9+w4YNGygvL2fNmjV0dPRY5W677TaefPJJHnnkEd5++206Ozu59NJLCacgYMcDt150BdkZmeytqeapD95Oun3PuLf4/ewGMyz2eOknHBo+Obifr/z2v7n7+Sdp7/aS6XKztGo2N5x5LrdccBkAT33wNocb6vp8HMMeL8nxgiCMFa48ZRUFWdlA7352gxlmX7s4vsYyx5oa8AUDuJ1OM49HEARBSB1H8k2Gjv/8z/9kypQp3H///ebvpk+fbv63qqrcdddd/PjHP+aqq64C4IEHHqCsrIyHH36YW265hba2Nu69917+8pe/cN555wHw4IMPMmXKFNatW8cFF1wwrK9pJCjIzuGWCy7lzqcf4951L3DWwhPNcXDxqEmSHG8wtaQMRe8nbOnqpFDSXtNGa1cnv3n+SdZ+orlKcjM9fOX8S7hk+WnYLT3pWw8f4N1d27nnxaf5j8/+Q8LHO9pkiHaptAuCMDbIdLn59mVX86e1z3Ph0pPjbjPDHPsms9rHMvtqtb9fVVlF1DlOEARBSI0RPXI+88wzLF++nGuuuYbS0lKWLl3KH//4R/P2gwcPUltby/nnn2/+zu12c9ZZZ/Huu+8CsHHjRoLBYNQ2lZWVLFq0yNwmFr/fT3t7e9S/sc6ly09jwZRpeP1+7n7hyT637ZnR3rdoz3C5qDQS5MWamFb+84m/svaTjSiKwuUrVvLgd3/M5Sev6nUxc+tFV2C32Xhv9w4+3Lsz7mN1B/w0tLUCUmkXBGFscfbiJTz03R8nrLRX6WPfDtXXEolEhnPXhDRihNCJNV4QBGFgjKhoP3DgAPfccw+zZ8/m5Zdf5qtf/Srf+ta3+POf/wxAba1mhysriw6nKSsrM2+rra3F5XJRUFCQcJtYfv7zn5OXl2f+mzIl/sXCWMJms/G9K67Fpiis3/aJOYc9FlVVo4LokmEmyEsYXdro8vn4cO8uAH71xVv53pXXkufJirvtlOJSrjrtDAB++8LTcTMLDGt8nieL3ASPIwiCMBaZVFiM026nOxCgrrVlpHdH6INnPnyHq/7jp7y1Y0uv23rGvYloFwRBGAgjKtojkQgnnXQSd9xxB0uXLuWWW27hK1/5Cvfcc0/UdrEJ56qq9pl6nmybH/3oR7S1tZn/jh49OrgXMkqYVTHJXMXeWX0k7jYd3V66/D4AylMR7UaCvPQTpo2P9u0mFA4zqaiYpVWzk27/ubMvIM+TxaH6Wp7d8F6v2w1rvCTHC4Iw3nDY7Waq/Ef794zw3giJeOSt17jz6cdo6mjn4Tdf7XW7jHsTBEEYHCMq2isqKliwYEHU7+bPn8+RI5rgLC/XBGNsxby+vt6svpeXlxMIBGhpaUm4TSxut5vc3Nyof+OFeZO0Obe7jsUX7caJszQvn0yXO+njzZBKe9p5b7c2/eC0uQuSbKmRk+nhC+deBMD9r75IR7c36nYzhE7CfQRBGIect2Q5APete4FOX/cI741gRVVV/u+1l7jnpWfM3+04ephqfTEZtAyXxo42oKfdQRAEQegfIyraV61axe7du6N+t2fPHqZNmwbAjBkzKC8vZ+3atebtgUCA9evXs3LlSgCWLVuG0+mM2qampoZt27aZ20wk5k3WRXuCSvv2I4cAWDBlekqP1zP2TRLk00EkEuGDPVpv+qlzF6Z8v8tWnMb00nLavF08uH5d1G09M9olhE4QhPHHp087kynFJTR3dvBACiMwheFBVVV+//Kz3P/qSwB8ec0lrJg1F4B1n/SM7jWKBZOKivG4M4Z/RwVBEMYBIyrav/Od7/D+++9zxx13sG/fPh5++GH+8Ic/8PWvfx3QbPG33XYbd9xxB08++STbtm3j85//PB6PhxtuuAGAvLw8vvSlL/G9732PV199lU2bNnHTTTexePFiM01+ImGI9j3Hj8YN7dl+9BAAC6dOT+nxppaUYVMUOrq9NHeM/cC+kWbP8WqaOzvIdLk5cfrMlO/nsNv5qj4C7ukP3qa1q9O8zRDtU0W0C4IwDnE5HHzrUm2CzN/fe1Nmto8S/vjKc/z1rdcA+MbFV3Lz6jWct2QZoIl2Y6F/v54cP0v62QVBEAbMiIr2FStW8OSTT/LXv/6V1ga3YgAARbFJREFURYsW8W//9m/cdddd3HjjjeY2P/zhD7ntttu49dZbWb58OceOHeOVV14hJ6dn/NivfvUrrrzySq699lpWrVqFx+Ph2WefxW63j8TLGlGmlZThdjrx+v1mr7OBqqrsOHoYgIUpVtrdTieVhcWAWOTTwfu7dwCwfNZcXI7+TVw8de4C5lROpjsQ4PF31wPa3/Roo/S0C4Iwvjl59nxOn7+YcCTCr597QpxfI4w/GOSRt18H4HtXXMM1q1YDcOaCE3A7nRxtbGD3MS0vaK8kxwuCIAyaER+Weemll7J161Z8Ph87d+7kK1/5StTtiqJw++23U1NTg8/nY/369SxatChqm4yMDO6++26amprwer08++yz4yIRfiA47HbmVE4Gelvkq5saaPN24bTbma1vkwpWi7wwON7TRXuq/exWFEXh5tXaaMMn3nuLjm4vbd4us8dzclFx+nZUEARhlPGNi6/E5XDy8YG9vLHtk5HenQnNgboawpEIeZ4sLlvR04rocWewar52jWZY5Pfron1meeXw76ggCMI4YcRFu5B+EoXRGf3scydN7VeVd4aeIH9QEuQHRXNnh/k3OXXO/AE9xunzFzGjrIIuv48n33/btMaX5RfgdrrStq+CIAijjYrCIm4881wAfvviU3QH/CO8RxOXvce1Kvqcysm9JvWsOVELDnx1yya6A34ON9QBkhwvCIIwGES0j0PmTtJcBrGVdkO0p9rPbiCV9h7avV38z3N/H9B78cEerco+p3IyRbl5A3p+m83GzavXAPDYO2+w53g1AJMlOV4QhAnAZ848h/KCQhraWrnrmcfxB4MjvUsTEuPcM2dSb1fjybPnkefJormznSfff4twJEJOpoeSvPxh3ktBEITxg4j2cYgRRrev5jihcNj8vRlCl2I/u8GMMm1Ey6H6mgnfR/jo22/wxHtvcc+LzyTfOIb3dhnW+NRT4+OxetESJheV0N7t5c+vvwJICJ0gCBMDt9PFty7RQule2rSBr97zSzPoTBg+TNEep9XOYbezetESAB7Sp53MqpjUqyIvCIIgpI6I9nHIpMJisjMyCISCHNBTdr1+n5m4299K++SiEmyKQqfPR2N7W7p3d0zx8YE9AHxyaB/BUCjl+wVDITbs2wUMrJ/dit1m46bV2mQEI0VeQugEQZgorJq/iDtu+jIFWdkcqKvhlv+9k0feei3uxBQrb+/Yyru7tg/TXo5fgqEQB/SFkniiHWCNniLf6fMBMEv62QVBEAaFiPZxiM1mY+6k6HntO6uPEFFVyvILKO6nNdvtdDJFr+Ru0y32E5FOX7f5fnYHAqZzIRW2Hj6A1++nICvbbF8YDGtOXE55QaH58xSptAuCMIFYNX8R93/rH1k1bxHBcJh7XnqGf/zzHxIK9y6fj5/+9X5++vB90gs/SA7V1xIMh8nOyKCioCjuNoumzog6R0lyvCAIwuAQ0T5OmWf0tevBZ2Y/ez+t8QZGdfjNHRM3sXfLoQNELO0BG/buTvm+Rmr8KXPmY7MN/mvnsNvNQCaAKVJpFwRhglGQncPPbvoSP/zU9bgcTj7cu6tXAKvBseZGwpEIwXCY481Nw7yn4wvDGj+7ckpCy7uiKJx3wjLzZ0mOFwRBGBwi2scpRl/77uoY0d5Pa7zBmQtPBLS+7Ika/PPxfs0an+fJAuCjfamLdmM++6mD7Ge3cuFJpzB/8lQWT6uiLL8w+R0EQRDGGYqicMnyU1kwRTvnHUsgyGssvz/e3Dgs+zZe2auL9rlJRscaFvlMl4tpeqCtIAiCMDBSn/sljCmMsW8H62vxBQLsGGAIncH8yVMpycunoa2Vj/btNuewTiQ+PrAXgJtWr+G3LzzF7uNHafd2kauL+ERUNzVwpLEeu83Gitlz07Y/LoeDe776HQn3EQRhwlNRUMTmg/ujxLmVmharaJdK+2DYU2NU2vsW7dNLy/n5zV/B43b3a8ysIAiC0BuptI9TSvLyKczOIRyJ8Pq2TbR3e3E5nAPuK7PZbJy54AQA1m+feBb51q5OM6F4zYnLmF5ajqqqppDvCyP46ITpM8nOyEzrfolgFwRBgMrCYiBxFd0q1I81jc1Kuy8Q4G/vvGHOPR8JQuEw+2qOAYlD6KysnLeQJTNmDfVuCYIgjHtEtI9TFEUxw+ieeO8tAOZOmoxzEKvdZ+kW+Xd2butXcvp4YNOBfQBUlVVQkJ3D8llzgNT62t/ZuQ2A0yegO0EQBGE4qCjUAtGsFXUr0ZX2sSna73r2cX77wlP8+rknRmwfjjbW4w8GyXS5mVwkWSqCIAjDhYj2ccy8yVoYnREaM1BrvMGiaTMoyMqm09fNpoPJK8zjCWPU20kzZwOwYtY8AD7av7vP2fXt3i62Hj4AwKp5ItoFQRCGgko9xTyR9b22pdn872NjULS/tnUTL378IQC7qg/3ed5JB9WNDby+dXOv5zGuJ2ZVTEpLqKogCIKQGnLEHccYfe0GAw2hM7DbbJxhWOS3bRnUY401Nuk2+JOqtAr7iTNm4rDbqW1p7vMC8P09OwlHIlSVVZiVIEEQBCG9VOrH14b2NgIxTrBIJBJVaa9rbSEUDg/r/g2G2pZm7nzqUfPnTp8voaMgXfzrX+/n9kf+j7WfbIz6vRFCl4o1XhAEQUgfItrHMUaCvMFgK+0AZy3SLPJv79yalouelzdt4Bt/+DVN7W2Dfqyhor6tlaONDdgUhROmVwGQ6XKzSF8E6StF3rDGT8TgPkEQhOEiPyubTJcLVVWpa22Ouq2po51gOIzdZsPlcBKORKhrbRnQ8zS0tfKrZx7nk4P707HbSQlHIvzs8Qfp9PlYMGWaOTpt7/FjQ/acda0t7NMzXB5av45IJGLeZlTa50wS0S4IgjCciGgfx+RnZVOeXwBAeX4BRbl5g37MJTNmkZvpobWrky267Xug1DQ38d9P/Y2thw/w2tZNg963ocKwxs+dNIWcTI/5++UztST4RH3tgVCID/fuBMQaLwiCMJQoikJFAot8jW6NL80rMCvyA+lrr29t4dt/+g1PffA2//LwfXj9vkHudXIeWr+OLYcOkOly85NrbjYX4w3xPBR8sGen+d+H6mvNMNVIJMLeGqPSPmXInl8QBEHojYj2cc5c/QS/YJDWeAOH3W5Wjd/cNrgU+f957gkCIW3m+0im4SZj037DGj876vfLZ2t97ZsO7I3rOvjk4D68fj9FObnMnSQXOIIgCENJogT54y2N+u1Fpmjvb197XWsL3773N+b92rxd/O2dNwa5x32z7chB/u+1lwD4zuVXM6mo2LSl7zl+dMie1xDtBVnZADy4fi2qqnKsuRGv34/L4WRqcemQPb8gCILQGxHt45wrT15FZWERV5y8Km2PaaTIv7ljS5Rtrj+8s3Mb7+3ebv48WkW7dazb0plzom6bUzmZnEwPXX4fu44d6XVfwxq/ct5CCewRBEEYYnqq6NGV9tpmrdJeXlDIJFPYp94TXtPSxLf+dDfHm5uoLCziaxdeDsCjb79Om7crHbsel3vXvkA4EuHcE07i/CXLAZhdoYn2vcerhySMLhgKme6yf/r0DbgcTnZWH2HTgb2WELpKHHZ72p9bEARBSIwoiXHOSTPn8Nfv/Uta56QumzWXLHcGTR3t7Dh6uN/39wUC/Pq5vwNwsl6tPlw/OkX7seZG6ttacdjtLJ46I+o2u81mpsnH9rWrqso7u/R+drHGC4IgDDmJRPtxPbStoqDIrMYfa2pI6TFrmpv49p9+Q21LM5OKivmfL3+Ta1etZlbFJLx+Pw+vX5fGVxDNkYZ6AK5ZtRpFUQCYWV6JTVFo6eqkqaM97c+57chBvH4/+VnZnDx7HpcsPxWAB9evM0W7sXAgCIIgDB8i2oV+43I4WDlvIQDrt/ffIv/g+rXUtrZQmpfPP199I6BZDVu7OtO6n+ngY90av3DKdDJcrl63G33tsaJ9b80x6ttayXC6TGEvCIIgDB1GT3tssrrxc2VhEZOKdNGeYqX9188/QV1rC1OKS/ifL32D0rx8bDYbX1lzCQBPvP82DW2taXoFPQRDIZo6NVFuZNMAZLhcTC0pA3qS3NOJYY1fMXseNpuN608/G7vNxsb9e3h1y8eAJMcLgiCMBCLahQFx5kJt9Ns7O7f1y6J3tLGeR956DYBvXnIVBdk55gXJaLTI94x6iy+8V8zWRPv2I4f4+3tvmu/Fu7o1fvmsubidvcW+IAiCkF6slXbreckIoquw2ONrYrZJxIG6GgB+cOX1lOTlm78/Zc58Fk+rIhAK8sDrL6frJZg0trehqiouh4N8vbfcYLbZ155+0f7h3l2A9vpAaylYc+IyAHNxYo5ktAiCIAw7ItqFAbF81lycdjvHmhs50lif0n1UVeWuZ/9OMBzmlDnzOWPBYgCmlZYDw2uRV1WV377wFNf99//Hxv174m6z+eA+3tyhzaNfNmtO3G0qCoq4bMVpRFSVXz/3BP/x94fxBwM91ngZ9SYIgjAslOUXoigK3QG/2WseCIVo1EeKVhYWU5ZfgE1R8AUDNCexl0ciEfO+FQWFUbcpisJXzteq7S9s/IDqxtTs9qlS16aNpCvJyzet8QZzhki0N7S1sr/2OIqisGLWXPP3nznzXHMfHHY7M/RztiAIgjB8iGgXBoTHnWH2yRvjYJJxuKGOj/btxmm38+1LP21eBEzTrX6HG2qHZmdjUFWVu59/kr+98wa1Lc3881/+xNaY8XXVjQ38y0P3EQqHOXvxEhbF9LNb+d4V13LrRVdgUxRe2rSBr/3uLvYcr0ZRFLONQBAEQRha3E4nxfpoUyNBvq61GVVVyXS5yPNk4XQ4KNXdXcks8i2dHYTCYWyKQmFObq/bT5w+k1PmzCcciXDfqy+m9bXU61XtsryCXrfNrpgEwL6agYn2jfv38G9/+wvVMX39RpV93qQpUdX96aXl5iJ7VVkFTodjQM8rCIIgDBwR7cKAWakHrL2rV5WTsfuYNqJm/pRpZl8hWET7MFTaVVXlD688x9/fexPQLkB8wQD/+MAf2KPvX7u3i3/88x9o7/ayYMo0fvTpG3pVOqwoisJ1p5/Nf3/ha+R5sthfexyARVOn97I1CoIgCEPHpJgwOqOfvbygyDyOT0owGi4WQzgX5eYlTEv/st7b/uqWjwc0+z0Rda1apb00v7don6WL9trWln6n1x+qr+XHD/6JdZ9s5CcP3YcvEDBv+2Cv1s9uWOOtfGXNJcypnMynTzuzX88nCIIgpAcR7cKAMarI2w4fpD2FCwdjrmxsiM20UqPSPvSi/YHXX+bhN18F4HtXXMM9X/0OJ0yvosvv4/v/9zv2HK/mXx6+n+qmBsrzC/jZTV9OuSd92cw5/P7W75oXVGcvXjpkr0MQBEHojRFGZ4h24/8r9d8DKc9qN0R7qaWXPZY5lZPNzJO3dmwd0D7HfW5dtMertOdkeszX0J8wOq/fz08fvp9uXagfrKvhf/RJLqFwmI16oGo80T61pIw/fv37XHjSyf17IYIgCEJaENEuDJjygkKqyiqIqKqZONsX5riYWNGuV9rr21rx+v3p31Gdv771Gve/+hIA37j4Si4/eRUZLhf/cfM/MG/SVNq8XXz1nl+y+eA+PG43P//sP1CYndOv56goKOJ/b7mN397yba485fSheBmCIAhCAipjquhmCF1hYa9tjjUlE+16tbsP0Q492SWpus5SwehpL4tTaYee8+jemmMpPZ6qqvzXU49wuKGO4pw8/vW6z2JTFF7Y+AEvbfqQHUcP0+nzkefJYu6kqel5EYIgCELaENEuDIoei3zffe2RSIS9x7WLi7mV0cmzuZ4sCnQb+ZEhqrZXNzXwu5eeAeAr51/CNatWm7dlZWTwX5+/haqyCsKRCDZF4fbrP09VWcWAnsvtdLJo6gzsNvl6CYIgDCcVhdFj32qae2a0G/TXHl8ap9ptZZV+Htx6+GC/7eoJn7u17wWDnjC6oyk93hPvv8VrWzZht9m4/TOf45wTTuJz51wAwK+efpzH31sPaCGzcu4SBEEYfciRWRgUp81bAMCHe3cSCocTblfd1EB3wI/b6WRKcWmv280E+SES7YYTYMmMWdx01ppet+d6srjzi7dy6fLT+H+f+Xxce6AgCIIwuqksiN/THiXai4qjtklEKvZ40BYKjEXfVFxnqWA+d6JKe4VeaU/BHr/tyEH+98WnAfjahZezeFoVADevPp9lM+fgCwZYv+0TIL41XhAEQRh5RLQLg2L+5GnkZ2XT6fOxJSaB3YphjZ9ZXhk30KcnjG5oEuQ/Mnv15iXcpjA7hx986jrOXHjikOyDIAiCMLQYvd4N7W0EQiGLPb53T3ubt4tOX3fCx0rVHg89Fvm3dw6+r73T102X39fncxv2+OqmRrz6tlaONzfy9Afv8JOH7uP79/+OUDjM6kVLuHrlWeY2dpuNn1x7M4XZPcn4K2YnPkcKgiAII4eIdmFQ2G02Tp2rVdv76uczqgGx1niDoQyjC4XDbD64D4DlM+cm2VoQBEEYq+RnZZPpcqGqKvtrjtHR7QWi56x73BlmS9bxPvraG/Rqd0luftLnXTVfG4n24Z5dBEKhAe69hpEcn+fJItPljrtNYXYOxTl5qKrKvprj5u837N3Fjb/8GZ+589/55TOP8daOLXQH/MypnMwPP3V9r0kohdk5/PS6m3E5HCyfNbffOS6CIAjC8CCiXRg0q/QU+Xd3bUdV1bjb7E4QQmfQM6s9uWj3B4M8/9H7NHd2pLR/O44exuv3k+fJMpPdBUEQhPGHoiimFX7jgT0AFGRl9xK/lbpFPtGs9lA4TFNHO5BapX1u5WSKcnLpDvjZfHDvQHcfsPaz991L3xNGp51fX9vyMf/0lz9S3dSA3WbjxOkz+fJ5F/O7r36H333tu2RlZMR9nKVVs/nbD/6VO2768qD2WxAEQRg6RLQLg2b5rLk47XaONTVypLG+1+2qqrI3wbg3A0O0H29uIpikSvHr557gF08+ws8eezCl/TOs8ctmzsEmATuCIAjjGiMd/uP9mni2WuNjtznW3BD3MZo72omoKg67nYIUqs82m80cg/rOzr6DWZORai99TxhdNc98+A7/39/+Qigc5pwTlvLcT+7g11/5JjeffT7zp0xLGi5XkJ2D2+kc1H4LgiAIQ4coGGHQeNwZLJkxC4D34qTI17Q00enz4bTbma4HzsVSnJtHljuDcCRCdVP8iyjQBPhzH71n/vfuY8mTcz/ar4n25bPEGi8IgjDeMXrWt+o5K9YQOoNJ+jbHm+JX2g3hXJybl/Ji7+m6Rf6dXdsSus5SwRj3liiEzmB2peYce2PrZu58+jFUVeWKk1fxk2tuxuOOX1UXBEEQxiYi2oW00Nfot93HNOteVXklTocj7v0VRTH72g/Vx7fIe/1+/uupRwFMq+NDb67rc786fd3sqj4CiGgXBEGYCBii3egtjyfaeyrt8Xva+xNCZ7C0ajYZThcNba0ppbonwrDHJ5rRbjBHz4jxBQMAfHb1+Xzn8qtlZJsgCMI4RI7sQlowRr9tO3LQ7AM0SGaNN5hq9rXHT5D/49rnqG1ppiy/gDu/8DUA3ty+haNxLPkGmw7sJRyJMKW4JOkFkCAIgjD2iRXp1hA6g2Sz2lOd0W7F7XSa6evv9BHMmgyj0l6WZMGgNC+fcv289o2Lr+RLay7uFTQnCIIgjA9EtAtpoaKgiEVTZxCORHjmw3eibjPGvSUT7X2F0W05dIAn338bgB9ceR0Lp05n5byFqKrKX996LeFjfrRPCyKS1HhBEISJQWVMD3vsz9ATRGeMhosl1b7yWFbNH3xfe7IZ7QaKonDXl77BH279HtesWj3g5xMEQRBGPyLahbTx6dPOAOCZD981L4JUVbWI9vjj3gwM0X4kxh7vDwb4xZN/RVVVLll2qlnJuPHM8wB4edMGczRPLEYInVjjBUEQJgZl+YVRFed49ngjUV5VVWpaeve1D1S0nzZ3ITZFYW9NtTm6rT+EIxHzfJZKlb+isIi5k/o+twqCIAhjHxHtQto4c+GJlOTm0dzZwetbNwHahU+btwu7zcaMsoo+72/0tB9pbCAciZi//+Mrz3O0sYHinDy+dtHl5u8XTZvBCdOrCIXDPPbu+l6PV9vSbI6+WVI1Kx0vURAEQRjluJ1OinPzALDbbJTEEd6KoljC6Hpb5Ht62vvXVpWflc3CqTMAeHP7J/26L2ip9eFIBLvNRlFObr/vLwiCIIxPRLQLacNht3PlqacD8Pd339Sr7Fo/+4zS8qTjZCoKinA5HARCQepamwH4v1dfMgX5d6+4hpxMT9R9jGr7Mx++S7u3K+o2o8o+f/I0sjMyB/nqBEEQhLFCpV5dL80rwGG3x99Gt8gfjTOxxKh2xxP8yVi96EQA7n/1JaobE09DiYfRz16SmyeBcoIgCIKJnBGEtHLp8tNwOZzsPn6UbUcOskdPjp+Tgn3PbrMxpbgU0BLk71v3Ive/9hIAX73wclbNX9TrPqfMmc/M8kq6A36e+iC6l36DaY2fM6jXJAiCIIwtjD72eCF0BjPLKwF6jQ4NhEI0d3YA/bfHA1x5yuksnlZFl9/Hvzx8H75AIOX7GsnxyfrZBUEQhImFiHYhreRnZbPmxGUAPP7umymH0BkYfe33vPQ0D7z+MgC3XnQFnznjnLjbK4rCDWeeC8Bf33qVv7yxlo5uL+FIhI/3ayF0K2bNG/gLEgRBEMYc00rLtf/XzynxWDhlOgA7jh6K+n1jeysALoeTPE9Wv5/bYbdz+/WfozA7hwN1NfzqmcdSnttu9NKX9dOWLwiCIIxvRLQLaefTK88E4K0dW9h25AAAs/sp2o80aGPcvn7xlVx3+tl93mf1oiUsmDINr9/Pn9Y+z7X/9f/4+d8fpr3bS5Y7g3mTpw70pQiCIAhjkMtXrOS2yz7NzWefn3Cb+VOmoSgKx5ubaNEr69AjnEvy8gY8Qq04N4+fXvdZbIrCS5s28NxH76d0v7oBzIcXBEEQxj8i2oW0M7O8kqVVswlHInT6fNgUhVnlk1K6r1EdAfjmJZ/i2hTG2Djsdu7+yrf4yTU3MaOsAq/fz9rNHwGwtGpWwn5GQRAEYXySlZHBp049o88wt+yMTHOheMfRw+bvBzKjPR5Lq2bz5TWXAPDr5/7OnhgbfjzEHi8IgiDEQ0S7MCQY499Aq55nuFwp3W/lvAVcdNLJ/Piam7h65VkpP5/DbmfNkuXc/80f8h83f4XF06oAuGT5af3bcUEQBGHCsGDKNAC2WyzyDQMc9xaPz5xxDivnLSQQCvH/Hv0zEctklHjUtWrPLfZ4QRAEwYpjpHdAGJ+snLeIioIialqaUrbGA7idLv7p0zcM+HkVReG0eQs5bd5CIpEINknfFQRBEBKwcMp0Xtj4QYJKe/6gH99ms/HPV9/Ip37+L1Q3NVDX1hJ3bnzPc0ulXRAEQejNiCqa22+/HUVRov6Vl/fYo1VV5fbbb6eyspLMzExWr17N9u3box7D7/fzzW9+k+LiYrKysrj88suprq4e7pcixGC32fiH8y8hOyODNUuWjcg+iGAXBEEQ+mLB1OkA7Ko+TCgcBqwz2vPT8hw5mR6m6jb8A7U1CbfzBQK06aNLy0S0C4IgCBZGXNUsXLiQmpoa89/WrVvN237xi1/wy1/+kt/85jds2LCB8vJy1qxZQ0dHT2DMbbfdxpNPPskjjzzC22+/TWdnJ5deeilh/eQrjBznnHASz//Lf3Dy7PkjvSuCIAiC0ItpJWV43G66AwEO1dcC6etpt1JVVgHAgbrEot1YLPC43WRnZKbtuQVBEISxz4iLdofDQXl5ufmvpKQE0Krsd911Fz/+8Y+56qqrWLRoEQ888ABer5eHH34YgLa2Nu69917uvPNOzjvvPJYuXcqDDz7I1q1bWbdu3Ui+LEEQBEEQRjl2m435k7W+dmP0W4OZHp+ftuepKjdE+/GE29TJuDdBEAQhASMu2vfu3UtlZSUzZszg+uuv58ABbUTYwYMHqa2t5fzze8a1uN1uzjrrLN59910ANm7cSDAYjNqmsrKSRYsWmdvEw+/3097eHvVPEARBEISJhzGvffvRw1EW9XSOXasqqwTgYB/2eEmOFwRBEBIxoqL9lFNO4c9//jMvv/wyf/zjH6mtrWXlypU0NTVRW6vZ1MrKyqLuU1ZWZt5WW1uLy+WioKAg4Tbx+PnPf05eXp75b8qUKWl+ZYIgCIIgjAWMBPkdRw/R0N4KQKYrvRZ1wx5/pLGeYCgUdxvDHi+VdkEQBCGWERXtF110EZ/+9KdZvHgx5513Hs8//zwADzzwgLmNoihR91FVtdfvYkm2zY9+9CPa2trMf0ePJp+dKgiCIAjC+GO+LtqPNNSzv1azr5fm5Se91ugPJXn5ZGdkEI5EONJYH3ebOqm0C4IgCAkYcXu8laysLBYvXszevXvNFPnYinl9fb1ZfS8vLycQCNDS0pJwm3i43W5yc3Oj/gmCIAiCMPHIz8pmUlExAOu3fQKk1xoPWgFihm6RP1D7/7d35wFRlfsfx78HQRAVXFJJEcUNENwXzOtPU9NwzbJyyaS9rK7aze7Vq6TdDDM1NXNJzWtZKS6lqWluheZSLpmYWyrivqDIIsywzOf3B3eOjCyiDnMWP69/7uXMAZ534Hl4ZuacU/B57c681RwREZmLrhbtVqtVDh8+LA8++KAEBgaKn5+fbNy4UX08MzNTYmNjpW3btiIi0qJFC/Hw8HDY58KFC3Lw4EF1HyIiIqKi2M9r33k097ayzrxyvN3triBvf6Wdt3sjIqJbuWv5zUeMGCG9evWSgIAAuXz5sowfP15SUlIkMjJSFEWR4cOHS3R0tNSvX1/q168v0dHR4u3tLQMHDhQREV9fX3nxxRfl7bfflsqVK0ulSpVkxIgR6tvtiYiIiG6nYc3asmH/HsnIzBQRkSq+vk7/HoH2RXsBF6MDoL7SznPaiYjoVpou2s+ePSsDBgyQxMREqVKlirRp00Z27doltWrlnl/2z3/+UzIyMuT111+XpKQkCQ8Plw0bNkj58uXVrzF16lRxd3eXp59+WjIyMqRz586ycOFCKVWqlFZZREREZCCh/zuv3a5EXmkv4rZvyek3JDM7SxRFkQd8nP+EARERGZumi/YlS5YU+biiKDJu3DgZN25coft4eXnJjBkzZMaMGU4eHREREd0P6vhVF08PD7FmZYlIyZxXbn97/OXk65KakS7ly3irj51NvCIiIpXKlRcPd03/NCMiIh3S1TntRERERK7mXqqUBNcIUD+uUgKL9vJlvNWvG3/J8SK7248cFBGRsFqBTv++RERkfFy0ExER0X2vYZ63yJfE2+NF8l6M7uZb5AGoV61/OKxpiXxfIiIyNi7aiYiI6L7X8H9XkC/nVUa8PT1L5HvYF+15X2k/fuGcnLuWKJ4eHtKmQcMS+b5ERGRsPHGKiIiI7nst6zWQ4BoB0jSwbol9jzp+/7tXe55X2n/+36vs4Q1CSuzJAiIiMjYu2omIiOi+5+3pJZ+9/o8S/R518tz2DYCIiPx8cL+IiHQIbVKi35uIiIyLi3YiIiIiFwioUk1KublJmiVDrqQkS2pGupy9ekVKu7vLQ0GhWg+PiIh0iue0ExEREblAaXd3qflAVREROXnxvPoqe6t6wVLWy0vDkRERkZ5x0U5ERETkIjevIH/h5lXjGzXVcERERKR3XLQTERERuYh90f5z3H5JuHJJ3EuVkrbBfGs8EREVjot2IiIiIhexX0H+6PkzIiLSql6QlPMqo+WQiIhI57hoJyIiInIR+yvtdh3CeNV4IiIqGhftRERERC5SrUJFKVM6937spdzc5G/BYRqPiIiI9I6LdiIiIiIXcXNzk8BqfiIi0qJuA/HxLqvxiIiISO+4aCciIiJyofAGISIi0qtVW41HQkRERqAAgNaD0FpKSor4+vpKcnKy+Pj4aD0cIiIiMrEcm02up6VKZR9frYdCREQaKu46lK+0ExEREblQKTc3LtiJiKjYuGgnIiIiIiIi0iku2omIiIiIiIh0iot2IiIiIiIiIp3iop2IiIiIiIhIp7hoJyIiIiIiItIpLtqJiIiIiIiIdIqLdiIiIiIiIiKd4qKdiIiIiIiISKe4aCciIiIiIiLSKS7aiYiIiIiIiHSKi3YiIiIiIiIineKinYiIiIiIiEinuGgnIiIiIiIi0iku2omIiIiIiIh0iot2IiIiIiIiIp1y13oAegBARERSUlI0HgkRERERERHdD+zrT/t6tDBctItIamqqiIjUrFlT45EQERERERHR/SQ1NVV8fX0LfVzB7Zb19wGbzSbnz5+X8uXLi6IoJfI9UlJSpGbNmnLmzBnx8fEpke/hamwyBjYZA5uMgU3GYcYuNhkDm4yBTcZgxiaRm12nT58WRVGkevXq4uZW+JnrfKVdRNzc3MTf398l38vHx8dUv3AibDIKNhkDm4yBTcZhxi42GQObjIFNxmDGJhERX1/fYnXxQnREREREREREOsVFOxEREREREZFOcdHuIp6enjJ27Fjx9PTUeihOwyZjYJMxsMkY2GQcZuxikzGwyRjYZAxmbBK58y5eiI6IiIiIiIhIp/hKOxEREREREZFOcdFOREREREREpFNctBMRERERERHpFBftRERERERERDrFRTsRERERERGRTnHRfo9sNpts375dzp49q/VQnIZNxsAmY2CTMbDJOMzYxSZjYJMxsMkY2HSHQHdt/vz5qFy5MoKDg1GhQgWMGTMGx44d03pY94RNxsAmY2CTMbDJOMzYxSZjYJMxsMkY2HTnuGi/S7/99htCQ0Mxb948nDp1CnPmzEFoaCj69u0Li8Wi9fDuCpuMgU3GwCZjYJNxmLGLTcbAJmNgkzGw6e5w0X6HbDYbAGDq1KmoXr06MjIy1Me+/PJLNG3aFFFRUVoN766wyRjYZAxsMgY2GYcZu9hkDGwyBjYZA5vuDc9pLyYAIiKiKIqIiKSmpkrDhg0lPT1d3eexxx6T7t27y+LFiyU+Pl6Tcd4JNrFJK2xik1bYZIwmEXN2sYlNWmETm7TCJuc0cdF+G1988YV06dJFXnzxRVmxYoUkJSWJiEjt2rXlt99+k9OnT6v7+vj4SEREhPj5+clXX32l1ZBvi01s0gqb2KQVNhmjScScXWxik1bYxCatsMnJTU55vd6EsrKyMHToUFSpUgVRUVHo3bs3ateujUGDBqn71KpVC6+99hqys7MdPrd79+544403XD3k22ITm7TCJjZphU3GaALM2cUmNmmFTWzSCptKpomL9kLEx8cjJCQE33//vbptwYIFqFu3LsaMGQMg91wFd3d3/Pjjj+o5DQDQp08fREREuHzMt8MmNmmFTWzSCpuM0QSYs4tNbNIKm9ikFTaVTBMX7YU4ePAgfH19sWvXLnVbSkoKoqOj4enpiXPnzgEAunXrhqZNm2Lp0qXIycnByZMnER4ejoULF2o19EKxiU1aYRObtMImYzQB5uxiE5u0wiY2aYVNJdPERXseeZ8V2blzJ0JDQ/H111877HPs2DG0aNECkZGRAIArV65g4MCB8Pb2RseOHVGxYkV07twZly9fduXQC8WmSABs0gKbIgGwSQtsigSg/ybAnF1sigTAJi2wKRIAm7TApkgAJdvERfv/5P3B2DVr1gyDBw/G1atX1W0WiwUffPABWrZsiYSEBABAamoqYmNjMWfOHKxdu9ZlY77VrQ1maLoVm9ikFbM0paWlqf/fLE15sUm/TZyj2KQXbNJvE+eoXGxyLSPMT/floj0zMxPx8fHIzMwEcPMHk5mZiQULFuDgwYMAgOXLl8PDwwMrV65EVlaW+vkLFixAvXr1HH5oWsvOzkZycnK+7UZuSk9Px+jRo7F+/XqH7UZuslgs2L59O06dOuWw3chN9n8/eccJGLvJYrFgxYoVsFqtDtuN3JSRkYEXX3wRjzzyCABzHPcyMzNx9uxZ9WOzNJltfgI4RxmliXOUMZo4RxmjiXOUMZqMMj/dd4v2KVOmIDg4GC1btkTbtm3x66+/qo/98MMPUBQFn332mfpL2KVLF7Rv3x6xsbHqfjNnzkSzZs1w/fp1l4+/IB9//DHCw8PRsWNHDBs2DMePH1cfM2rTxIkT4eHhgQ4dOuD8+fMOjxm1aerUqfDz80OjRo3g6+uL2bNnq1eYNGrTjBkz0L59e/XjvM9MGrUpLS0N9erVg6Io2Lhxo8NjRm368MMPUaZMGVSqVAk+Pj7qs8GAcZsmT56MWrVqoUmTJujRowd27NihPrZmzRpDNplxfgI4RwHGaOIcZYwmzlHGaOIcZYwmI81P982iff/+/WjXrh3q16+PmJgYLF68GN27d0dYWJjDfrNnz3Z4VuzkyZPo0KED6tWrh7Fjx2LSpEmoWrUqoqOjXZ2Qz7Fjx9CpUyfUr18fCxcuxMiRI9GmTRt06dLFYT8jNe3cuRMNGjRAjRo1sGrVKofH8k62RmoCgDFjxiAoKAhr167FX3/9haioKFSoUAE3btxQ9zFS05kzZzB48GBUqVIFiqJgwoQJAJDvNhdGagJyf8fS0tLw+OOPo3HjxmjVqpXDW/UAYzWtXr0aNWrUQO3atbFu3Tps2rQJdevWxe7dux32M1ITkPuHQ+3atbF8+XIsWLAAjz32GB544AFs2bJF3WfWrFmGaTLj/ARwjjJKE8A5yk7PTQDnKDs9NwGco+z03GTE+em+WbR/9tlnGDBgAK5cuaJumz17Njp27IiMjAzk5OTk+xz7BHzixAmMHj0a3bt3R+PGjbFgwQKXjbswOTk5mDJlCrp3765esRAAli1bhiZNmuDw4cMFfp6emwBg1KhR8PDwwLZt2wAA586dw6pVq3DgwIFCL+Kg96bExESEh4dj8uTJ6rZjx46hYcOGDr+Peem96ccff8RTTz2FpUuXYuzYsahUqZL688nJyTHcv6e8/vjjDzRr1gzx8fEoW7YsZs6cWei+em5KTExE3759ERUVpf48kpKSUKpUKaxZswYA1Le35aXnppycHGRlZaFbt24YMmSIw2Pt2rXDo48+ij179uT7PD03AeabnwDOUXnpvYlzVC69N9lxjtJvE+eom/TcZNT5yfSLdvsvUlZWlnpOgl2vXr3wyiuvYOvWrQVecCDv23OA3PPX9MJqteL7779XL3Bg71y3bh2qVauGS5cuFfh5em2yjz89PR2NGzfGkCFDMGTIEPj7+6NVq1aoVKkSWrVqVeAfEHptssvIyECZMmUwY8YMddtTTz2Fzp07Y+bMmTh37ly+3z+9NuU9N9D+Vq8jR46gRYsWePbZZx32uZVem2514MAB9O7dGwDw9ttvw8/PT22yWCwO++qxKe9//7x/8OTk5ODy5cto06YNRo4cWejn67EpL6vVCn9/f8ybNw9A7r8vANizZw/q1KmDCRMm5DvPU69NZp2fAM5Reem1yY5zVC69Nt2Kc5T+mvLiHJVLr02AcecnUy7aV6xYgalTp2LDhg1ISkoC4HiQ2LRpE6pUqYKgoCB07doVAQEB6N27NxITEwHkvn1q8ODBeOqppxzeEqGlL774AsOHD8cXX3yBixcv5nvc3hcTE4NmzZrle7uU3pvy/gOZN28e3N3d0aVLF6xbtw7Hjx/HTz/9hEaNGiEiIkKdlIzUNHr0aFSsWBGPPfYYfHx80LRpU7z11lsICgpCeHg4Vq9eDSD3wKi3pnXr1hX6Rw6Q+0fCvHnzUL58efX+lXkv0KHHn1NRTWvXrkWrVq3Uj2vWrImOHTsiLCwMK1euBGC8JjubzYbw8HD8/e9/BwCHZ8f12FTQsRwAnn76aXTo0EH92N7x6quvomXLluoz50ZpMvr8BHCO4hylHc5RnKO0wjnKGHOUWeYnUy3a9+7diyZNmqBevXp4+OGH4efnh169euXbb82aNepVN61WKxISEqAoClasWKHuM2nSJPTs2bPQt4a5ysWLF9G5c2fUqFEDjz/+OAICAhAcHKxOPEDuL5v9F27YsGHqs8n2g4T9f/XelPciHe+9957DBS4AYPfu3VAUBfv27VO36b1p586d6j7x8fF4+eWX0b9/f/W8OpvNhubNm+Pf//63+oyzXpoOHTqEDh06QFEUvP/++wCQ7y1Q9t+7hIQE9OrVC23bti3w8Y8++sgwTVOmTMHo0aMBANu3b4e/vz8URcHIkSMd/tAz0s8JuHku5/Dhw9G4cWOHx+w/J700FXUst9ls+OKLL+Dv748ffvgBwM1XMs6cOQNFURyOj0ZoystI8xPAOSovzlGuxTmKc5RWOEcZY44y2/xkmkX77t270aZNG7z99ttITU1FcnIyNm/eDC8vL2zatAlA/guQ2OXk5KBWrVoYNWqUK4dcLMuWLUNISIj6jLjFYkGrVq3Qq1cv9Zcu78EvODgYn3/+ufpxfHy8S8dbHEU1bd++HUDuPQ5vdeTIEVSqVAkLFy506XiLo6gm+x9F169fR7NmzbBu3ToANw/ijzzyCLp166bNwAsRHx+PyMhIPPnkkxg2bBjKly+vthX2TPnq1atRuXJlfPnllwCAX375Jd9bibR0uyb78WHatGno2rUrnnrqKZQuXRrDhg1Dq1at8Pjjj+e7ZZDW7ubn9NFHH6Fx48Y4efKkuu12r364UlHH8g0bNgAADh8+jL59+6Jdu3bq59lsNly+fBkBAQEOx0A9MOv8BHCOyotzlOtwjuIcpRXOUY70PEeZbX5yE5MAIA8++KC8+eabUq5cOfHx8ZGQkBAJCwuTEydOiIhIqVKlCvzcDRs2yAMPPCADBw50+HpaAyDbtm2TqlWrSvny5cVms4mnp6dMmzZNLl26JN98841kZmaKm5ub2Gw2OXDggFy/fl0iIiLk2rVr8uKLL0qdOnXk2LFjWqeobtcUExMjmZmZUq5cuXyfu2PHDgkICJCIiAiHr6e12zUtXrxYrFar+Pr6yvXr12Xv3r0iIuLl5SXHjh2TGzduSP/+/R2+ntaqVq0qTZs2lXfeeUdGjhwpgYGB8tZbbxW4r328bdu2lWeeeUZGjRolffv2lf/7v/+TI0eOOOyjpds12Y8P169fl507d4rFYpFdu3bJtGnTZPr06bJy5UpZvXq1ur8RmvKyjzcwMFDOnTsnZcuWVR9TFMVhHy0VdSw/efKkiIgEBwfLoEGDJCEhQUaMGCFZWVmiKIrExcWJp6endOzY0eHrac2M85MI56hbcY5yHc5RnKO0wjnKkV7nKDPOT6Z5pT09Pb3A++P5+/vjxx9/zLf94sWLSEhIwMSJE1G9enW88847sFgsunk2zz6Of/3rXwgJCQHg+CzXv//9b7Rt2xabN29Wty1ZsgStW7fGhAkT4OPjg/bt2+PQoUOuHXgR7qbpwoULSEhIwEcffYQaNWrggw8+QHZ2tuF+TvbbfEycOBGKoqBfv34YOnQoqlatir59+zqcC6W1gi5os3TpUoe3dBX01rarV6+iX79+UBQFPXr0KPTqm1ooTpP9rZ+nTp3Cjh078l0oZtq0aQ5XGdXa3f6cEhIS4OHhoZ77qDfFPZZbrVbExMTA29sbzZs3x3PPPQcfHx+88soryMjI0M0xAjDf/ARwjrLjHOV6nKM4R2mJc5T+5ygzzk+Awd4eX5xfhrz77N69GwEBATh//rzDD+vSpUuYPn06QkJCEBQUpF5gRQuFNdm37927Fx4eHti4cSOAmwe/+Ph4BAYGYtasWernPPfcc1AUBfXr13c4t8TVnNV0/vx5TJo0CXXq1EGDBg0M/XPKe0uWqVOn4pVXXsHjjz+unu+khTv595SSkoKePXuidevWBe53+vRpdO7cGX5+fli/fr1Tx3knnNmkF85u2rdvH55++mlNJyNnHcsBYPPmzZg8eTKef/559TZBWjDj/FQUI89RhTHyHFUYI89RxWG0Oao4jDZHFYfR5qjiMNocVRxmmaPMOD8BBlq0WywWpKSkqB8X9QeS/bGpU6ciPDw83zN5OTk5iIuL0/wXzWKxODx7XVBTYmIinnjiCTRq1EjdZv/H06NHD/Tr1w9A7pVQ//vf/2Lu3LklO+jbcHbTvn378O2335bsoG/DGU1PP/10iY/zThSn6VY7duyAp6enej5gdna2+m/SZrOp5z1pxRlNOTk5BZ6rqhVn/ZyM2lTUsVwvz+gDzmsC9DM/ATfHWti5jIDx5ihnN+lhjnJGk97mqOI03Urvc5QzmvQ2Rznr52TUJqPMUc5qAvQzR5lxfrodQyzax48fj9DQUHTq1AkjRoxwuDhFQew/kD59+mD48OEAci8a89prr6kXWNHaf/7zHzRo0ADh4eF48803i2zavHkzKlasiPHjx6vbrFYrOnfujHfeeccVwy0WNt2+SQ8H8TtpyiszMxPDhw9HzZo1cejQIQwcOBBRUVEOT6ZpxdlNt97uQwtsKvpYrpdXy5zZpJf5Ccj9gy0yMrJY+xrleM4mY8xRd9KUl57nKGc36eF4ziZjzFHObNLLHGXGY3lx6HrRnp6ejgEDBiA0NBQrV67ERx99hIcffhjBwcG3vU+e1WpFWFgYYmNjsXDhQlSuXBmBgYE4evSoi0ZfuH/84x+oW7cuVqxYgbFjxyI8PBxBQUGFNlmtVsyaNQuKouDtt9/GTz/9hBkzZqB69eoO52NoiU3mbLrVnj17oCgKFEVBcHCwLt6+xqb8zNRkpmO5nZ6bDh8+jMceewxly5ZF1apVsXjxYgBFv5qh92Mfm3KZselWejv2salgZmrS6/GcTbn0fty7E7petO/ZswehoaHYvXu3uu2vv/5C2bJl8eabb+LixYuFfu769euhKAp8fX1RoUIFfPXVV64YcpFsNhuuXr2K5s2bY/r06er2pKQk+Pv7IzIyssj7/02aNAnt2rVDSEgIAgICsGzZMlcMu0hsys+MTTabDZs3b4afnx8CAgJ0cV4Wmwr+fLM1mfFYrscmu4ULF6JXr16IiYnB888/j4ceegjp6ekAbv8qrB6PfQCbbmXGJj0e+wA23cqMTXo9nrPJkV6Pe3dCl4t2+3/4jRs3wsfHx2FxHhcXh0qVKsHX1xerVq0q9Gts2bIFZcuWxYQJE0p8vHfiypUrcHd3x44dOwBAvfrn6tWr4enpie+++y7f59x6jozWz0jeik25zNhkl5WVhQkTJmDcuHGuGGqxscmRGZvMdCy302OTfd5NS0tDbGwsAOD7779Hs2bN1LcVFnSl51u36+nYxyZHZmyy09uxj00FM2OT3o7nZmyyj9dMx727oQA6uJmeiHz77bdy48YNCQsLk5CQEPHy8pKNGzfKu+++K127dpX33ntPRETGjh0rVqtV1q9fL3Xr1pUVK1aIzWYTNzfHW86npKRIqVKlHO7z6GqLFi2SEydOSEhIiERERIivr69cu3ZNevfuLWFhYTJnzhz1XoaKokinTp3E09NT1q1bJwDU+1LaFbTN1dh0/zXZPy7o35krsen+axIx57FcD00iBXflHW9SUpJMmDBBfvjhB1m1apXUrVtXcnJyCr1fr16PfWxyZLYmPR/72HSTGZtE9HE8N2PTwoUL5cyZM9K6dWtp165dvrEY8bh3z0rwCYFi2bZtG4KCghAcHIxmzZqhVq1aeOuttwDkPqMSHR0NLy8vPPLII/Dz80O1atXw559/IiYmBhUqVMCNGzc0Lshv69atCAoKQlBQEHr06IFq1aqhR48eAHKvMjxq1Ci0bt0av//+u7oNyH1my83Nrci3/WuFTWzSCpvYpBUzNgEFd/Xs2RPAzVdp7K9ObNu2De3bt8dLL72k2XiLg01s0gqb2KQVMzadOHECLVq0QGBgIB5++GH4+fmha9euSExMVPcxWpOzaLpo37hxI5o0aYLRo0fjxo0bOHv2LGbOnAl/f3/88ccfAHL/CNqyZQuio6Px+eefIysrCwAwf/58NGnSBNeuXdMyIZ/vvvsOderUwbhx42CxWJCamopVq1ahTJky6gUctmzZgg4dOuDll192+Nxdu3bB398fP//8sxZDLxSb2KQVNrFJK2ZsAoruOn78eL79s7KyMGnSJAQFBeGnn34CkNunh6uM27GJTVphE5u0YsYmAJg2bRrCw8ORnp6O9PR0HD58GJUrV8ZLL72EhIQEADcvPGeUJmfRdNG+dOlSvPDCC7hy5Yr6H3jXrl0ICQnB1q1bC/wcm82GnJwcvPrqq3jiiSdue16Gq124cAEff/yxwz0nv/nmGzzzzDMO+02YMAENGjTAnDlz1G2LFi1Co0aNkJyc7LLxFgeb2KQVNrFJK2ZsAorfBdx8NePPP//Ek08+ib/97W/o2bMnFEVBXFycy8Z8O2xik1bYxCatmLEpMzMTnTt3Vl85ty/Oly1bhtq1a2P27NnqvkZpciZNF+1nzpzJd//MxMREVKlSBX/++We+/ePj45GQkICoqCj4+/vr5qqTdvYnHuzvBgCAuXPnwsfHB3Xq1MEjjzyCmTNnAsjtHDduHBRFQc+ePfHyyy+jfPnyGDNmDLKzs3XzLBGb2KQVNrFJK2ZsAorXNWfOHHU/+/9evnwZ7du3h6Io6NOnD+Lj410+9sKwiU1aYRObtGLmpieeeALdu3cH4Nj3xBNPoEuXLvneRaDnJmfT/Jx2wPEy/UuXLkVwcDAsFku+++4tWrQINWvWRMOGDQ1xb72YmBiEh4dj+vTpWLt2LaKjo6EoisOTDV999RVGjhyJvn37YuPGjRqOtnjYxCatsIlNWjFjE1C8rri4OAQFBaFOnTrqVXv1jE1s0gqb2KQVMzUtWrQIlStXxsGDBwHcvFbM3r174enpiV9++UXd1yhNzuKyRfutb2O3P3ti327/3zfeeAP9+/cv8GtYLBasX7++BEd5Zwprsj/ZkJyc7PC2FQBo27YtnnvuOdcM8C6wKRebXI9NudjkemZsApzTZbFYirx9nauxKRebXI9NudjkemZsulVmZiaA3MV5x44d0a9fP/Uxe39YWBjeffdddbvem5zNvaSuSj9nzhxJSkqSwMBA6d+/v3p7B/vl+N3dc7+1fbv9FhB79uyRyMhIEcm9nP+IESPk3XfflVq1aomnp6c8+uijJTXk2ypuk/12A+XKlRM3Nzf1NgMXL14Uq9Uq1atX16zhVmxik1bYxCatmLFJxPldNptNPD09pU+fPpr0iLBJhE1aYRObtGLGpm+//VY6deokFSpUcNhub/Lw8BARkebNm0v//v1l3LhxEhMTI/369RM3Nze5ePGiZGVlSc2aNdXP07rJ5Zz9LMCaNWtQs2ZNtGzZEl27doWPjw8GDRoEwPGZopiYGHh5eWHRokXqtjNnzqBevXo4evQoPv30U1SoUAH169fH2bNnNT0v8F6a7DIzM/HBBx8gPDxcfcuHltjEJq2wiU1aMWMTYM4uNrFJK2xik1bM2BQbG4uGDRtCURT1WjAFiYmJgYeHB1asWIFr167hrbfegre3N2bNmoU//vgDEydORL169XDgwAEXjl5fnLpo37RpE1q0aIEPP/wQOTk5uHHjBmJjY6EoCg4dOgQASEpKQv/+/VGlShVMnjxZPVcByL2IgqIoqFatGh544AEsX77cmcO7K/fSlJmZiZ9++gnR0dEIDQ1FYGAgNm3apGUOADaxSTtsYpNWzNgEmLOLTWzSCpvYpBUzNh09ehQDBw7EkCFD8Prrr6N69eo4e/as+rjNZkNycrJDk9VqVR9/7bXXEBoairp16yIgIABr167VIkM3nLJot78KvnXrVvTs2ROJiYnq9kuXLiE4OBhffvklAMBqtWLJkiW4ePFivq8za9YslCtXDh9//LEzhnVPnNGUkZGBNWvWICIiAlOmTHFtQAHYxCatsIlNWjFjE2DOLjaxSStsYpNWzNhkd/nyZcyfPx8HDx7EjRs3EBAQgGHDhjnsU1BT3qvep6WlYc+ePa4ctm7d06L9+vXr+bblfYYEAK5du4aqVasW6+0Mp06dQkZGxr0M6Z45u8lqtaoXV9AKm9ikFTaxSStmbALM2cUmNmmFTWzSihmbtm3bhoSEBIdteW/b9uWXX6J06dLYu3cvAMe7hxXk1gvw3e/c7uY8+E2bNkloaKh8+umnYrFYHB4rXbq02Gw29ePffvtNKlasKIGBgZKVlVXk161Vq5Z4eXndzZDuWUk1lS5dWr24gquxiU1sch42sUmrJhFzdrGJTWxyHjaxSaumLVu2SJ06dWTQoEHSpk0bGTx4sPz+++8icvNieSIizz77rLRq1UqioqIkKytLFEUp8uvaL8BHue7ov0Z2drbMnz9fhg4dKllZWfLZZ5/J0aNH839RNzfJyckREZHY2Fjx9/eXcuXKqb9M9sf0gE1s0gqb2KQVNhmjScScXWxik1bYxCatmLFJROTs2bMyZswYGThwoGzdulXmzp0rcXFx8s4778jx48dFURSHMU+aNEnWr18va9asEZHcK9tfvXpVq+Ebyh0t2q1Wq1itVhk0aJDs27dPcnJyZNasWZKamlro58TGxkpERISIiJw+fVoGDBggmzZturdROxGbcrHJ9diUi02ux6Zcem8SMWcXm3KxyfXYlItNrmfGJhGRw4cPy++//y6RkZESEBAgPXv2lIkTJ4rNZpMxY8aIiOOr7Q899JAMHjxYxo0bJ5s3b5YePXrIlClTxGq1apVgHHf6fvrTp08jNTUVALB8+XK4u7tj48aNBe574cIFNG7cGPv370dUVBTKlCmDdu3aISkp6Z7e0+9sbGKTVtjEJq2wyRhNgDm72MQmrbCJTVoxY9OSJUvQtGlTHDlyRN2Wk5ODmTNnonbt2vjxxx8BANnZ2erjv/76KxRFgaIo6NKlC65everycRvRXV+Izn5xgIceeghdunQp8Grw33zzDRRFgbe3NwIDAxEbG3v3I3UBNrFJK2xik1bYZIwmwJxdbGKTVtjEJq2YqSkuLg6enp5YuXKlw/YjR46gT58+eO6559Rt2dnZ+Prrr+Hp6YmWLVti9+7drh6uod31ot3+jElcXBwURcHChQvVX0L7Y9999x3KlSuHr7/+2glDLXlsYpNW2MQmrbDJGE2AObvYxCatsIlNWjFbU7du3dChQwf1XQR2Q4cORUREBNLT0wEA6enp+OSTTzB79mwthml493TLN/sv1gsvvIAGDRrg5MmTOHToED755BOkpaU5ZYCuxiZjYJMxsMkY2GQcZuxikzGwyRjYZAxmatq/fz/c3d0xe/ZsWCwWdfv777+PgIAAh9u+0d27p0W7/VmhzMxMlCtXDs2aNYOiKBgwYADS0tJue/89PWKTMbDJGNhkDGwyDjN2sckY2GQMbDIGszWNHj0aDz74IObOnYvU1FQkJyejV69eGDVqlNZDMw33e7mInZubm6Slpcnq1aslMzNTRETWrVsnjz76qFMukqcFNhkDm4yBTcbAJuMwYxebjIFNxsAmYzBb0/jx4yUpKUmioqJk3rx5cvnyZfH29pbo6Gith2Ye97rqX7VqFUqVKoWJEyc640kEXWCTMbDJGNhkDGwyDjN2sckY2GQMbDIGszVZLBbs27cPCxYswFdffaX1cExHAYB7WfQnJyeLt7e3eHh4OOt5BM2xyRjYZAxsMgY2GYcZu9hkDGwyBjYZgxmbqOTc86KdiIiIiIiIiEqGm9YDICIiIiIiIqKCcdFOREREREREpFNctBMRERERERHpFBftRERERERERDrFRTsRERERERGRTnHRTkRERERERKRTXLQTERERERER6RQX7UREREREREQ6xUU7ERERERERkU5x0U5ERERERESkU1y0ExEREREREenU/wNLeNEB0o7q5AAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Step 5 - Rescaling, error metrics and visualization\n",
+    "\n",
+    "# Rescale predictions to the original scale\n",
+    "predictions_original_scale = lastgang_scaler.inverse_transform(predictions.to_numpy().reshape(-1, 1))\n",
+    "\n",
+    "# Rescale actual values to the original scale\n",
+    "y_test_original_scale = lastgang_scaler.inverse_transform(y_test.to_numpy().reshape(-1, 1))\n",
+    "\n",
+    "# Calculate error metrics for the test data (on the original scale)\n",
+    "mse = mean_squared_error(y_test_original_scale, predictions_original_scale)\n",
+    "mae = mean_absolute_error(y_test_original_scale, predictions_original_scale)\n",
+    "rmse = np.sqrt(mse)\n",
+    "mape = np.mean(np.abs((y_test_original_scale - predictions_original_scale) / y_test_original_scale)) * 100\n",
+    "\n",
+    "# Output error metrics\n",
+    "print(f\"Mean Squared Error (MSE) for the last 48 hours: {mse}\")\n",
+    "print(f\"Mean Absolute Error (MAE) for the last 48 hours: {mae}\")\n",
+    "print(f\"Root Mean Square Error (RMSE) for the last 48 hours: {rmse}\")\n",
+    "print(f\"Mean Absolute Percentage Error (MAPE) for the last 48 hours: {mape}%\")\n",
+    "\n",
+    "# Visualization of actual vs. predicted values for the test data (original scale)\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "plt.plot(y_test.index, y_test_original_scale, label='Actual Values', color='#3E7A6F')\n",
+    "plt.plot(y_test.index, predictions_original_scale, label='Predicted Values', color='#7DFFE7')\n",
+    "plt.legend()\n",
+    "plt.title('Comparison of Actual and Predicted Values: Linear Regression over 48 Hours')\n",
+    "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%m-%d %H:%M'))\n",
+    "plt.gca().xaxis.set_major_locator(mdates.HourLocator(interval=3))\n",
+    "plt.gcf().autofmt_xdate()\n",
+    "plt.show()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1e371c71-a43d-47dc-a747-2487d207ea63",
+   "metadata": {},
+   "source": [
+    "## 2 - Linear Regression with Energy consumption data and 2 variables 'Lastgang_Moving_Average' and 'Lastgang_First_Difference'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "b73d653a-f33f-4b5b-a284-c9859874e828",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Step 3 - Data Scaling\n",
+    "\n",
+    "from sklearn.preprocessing import MinMaxScaler\n",
+    "\n",
+    "# Initialize the scalers\n",
+    "lastgang_scaler = MinMaxScaler(feature_range=(0, 1))\n",
+    "features_scaler = MinMaxScaler(feature_range=(0, 1))\n",
+    "\n",
+    "# Apply the scaler to the appropriate columns\n",
+    "dfEnergyAll['Lastgang'] = lastgang_scaler.fit_transform(dfEnergyAll['Lastgang'].values.reshape(-1, 1))\n",
+    "dfEnergyAll[['Lastgang_Moving_Average', 'Lastgang_First_Difference']] = features_scaler.fit_transform(dfEnergyAll[['Lastgang_Moving_Average', 'Lastgang_First_Difference']])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "77202892-f256-4c59-ada3-f6211fb6133a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                            OLS Regression Results                            \n",
+      "==============================================================================\n",
+      "Dep. Variable:               Lastgang   R-squared:                       0.382\n",
+      "Model:                            OLS   Adj. R-squared:                  0.382\n",
+      "Method:                 Least Squares   F-statistic:                 3.242e+04\n",
+      "Date:                Tue, 14 May 2024   Prob (F-statistic):               0.00\n",
+      "Time:                        21:11:16   Log-Likelihood:                 75701.\n",
+      "No. Observations:              104928   AIC:                        -1.514e+05\n",
+      "Df Residuals:                  104925   BIC:                        -1.514e+05\n",
+      "Df Model:                           2                                         \n",
+      "Covariance Type:            nonrobust                                         \n",
+      "=============================================================================================\n",
+      "                                coef    std err          t      P>|t|      [0.025      0.975]\n",
+      "---------------------------------------------------------------------------------------------\n",
+      "const                         0.0615      0.004     15.138      0.000       0.054       0.069\n",
+      "Lastgang_Moving_Average       0.3880      0.002    250.729      0.000       0.385       0.391\n",
+      "Lastgang_First_Difference     0.3617      0.008     45.908      0.000       0.346       0.377\n",
+      "==============================================================================\n",
+      "Omnibus:                     4120.059   Durbin-Watson:                   0.038\n",
+      "Prob(Omnibus):                  0.000   Jarque-Bera (JB):             3489.935\n",
+      "Skew:                           0.377   Prob(JB):                         0.00\n",
+      "Kurtosis:                       2.520   Cond. No.                         29.6\n",
+      "==============================================================================\n",
+      "\n",
+      "Notes:\n",
+      "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Step 4 - Creating the linear regression model and generating predictions\n",
+    "\n",
+    "## Performing linear regression with energy consumption data for the years 2021-2023\n",
+    "# Splitting the data into training and testing sets\n",
+    "# The last 192 data points (48 hours at 15-minute intervals) are the test dataset\n",
+    "train = dfEnergyAll.iloc[:-192]\n",
+    "test = dfEnergyAll.iloc[-192:]\n",
+    "\n",
+    "# Define the target and explanatory variables for training and testing\n",
+    "y_train = train['Lastgang']\n",
+    "X_train = train[['Lastgang_Moving_Average', 'Lastgang_First_Difference']]\n",
+    "X_train = sm.add_constant(X_train)  # Adding a constant column to include the intercept in the model\n",
+    "\n",
+    "y_test = test['Lastgang']\n",
+    "X_test = test[['Lastgang_Moving_Average', 'Lastgang_First_Difference']]\n",
+    "X_test = sm.add_constant(X_test)  # Adding a constant column to include the intercept in the model\n",
+    "\n",
+    "# Create and fit the model with training data\n",
+    "model = sm.OLS(y_train, X_train).fit()\n",
+    "\n",
+    "# Generate predictions for the test data\n",
+    "predictions = model.predict(X_test)\n",
+    "\n",
+    "# Output the summary of the model\n",
+    "print(model.summary())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "5100607a-5cae-4a9e-84fe-97ab1e6eb3bd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean Squared Error (MSE) for the last 48 hours: 0.014205019585883332\n",
+      "Mean Absolute Error (MAE) for the last 48 hours: 0.10027292257737576\n",
+      "Root Mean Square Error (RMSE) for the last 48 hours: 0.11918481273167035\n",
+      "Mean Absolute Percentage Error (MAPE) for the last 48 hours: 21.170930519741667%\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Step 5 - Rescaling, error metrics and visualization\n",
+    "\n",
+    "# Rescale predictions to the original scale\n",
+    "predictions_original_scale = lastgang_scaler.inverse_transform(predictions.to_numpy().reshape(-1, 1))\n",
+    "\n",
+    "# Rescale actual values to the original scale\n",
+    "y_test_original_scale = lastgang_scaler.inverse_transform(y_test.to_numpy().reshape(-1, 1))\n",
+    "\n",
+    "# Calculate error metrics for the test data (on the original scale)\n",
+    "mse = mean_squared_error(y_test_original_scale, predictions_original_scale)\n",
+    "mae = mean_absolute_error(y_test_original_scale, predictions_original_scale)\n",
+    "rmse = np.sqrt(mse)\n",
+    "mape = np.mean(np.abs((y_test_original_scale - predictions_original_scale) / y_test_original_scale)) * 100\n",
+    "\n",
+    "# Output error metrics\n",
+    "print(f\"Mean Squared Error (MSE) for the last 48 hours: {mse}\")\n",
+    "print(f\"Mean Absolute Error (MAE) for the last 48 hours: {mae}\")\n",
+    "print(f\"Root Mean Square Error (RMSE) for the last 48 hours: {rmse}\")\n",
+    "print(f\"Mean Absolute Percentage Error (MAPE) for the last 48 hours: {mape}%\")\n",
+    "\n",
+    "# Visualization of actual vs. predicted values for the test data (original scale)\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "plt.plot(y_test.index, y_test_original_scale, label='Actual Values', color='#3E7A6F')\n",
+    "plt.plot(y_test.index, predictions_original_scale, label='Predicted Values', color='#7DFFE7')\n",
+    "plt.legend()\n",
+    "plt.title('Comparison of Actual and Predicted Values: Linear Regression over 48 Hours')\n",
+    "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%m-%d %H:%M'))\n",
+    "plt.gca().xaxis.set_major_locator(mdates.HourLocator(interval=3))\n",
+    "plt.gcf().autofmt_xdate()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3f4c69db-fd8c-41be-9896-04a908fa69a8",
+   "metadata": {},
+   "source": [
+    "## 3 - Linear Regression with Energy consumption data and 2 variables 'Hour' and 'DayOfWeek'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "0f7252f4-92da-4836-a054-05205802ef05",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Lastgang</th>\n",
+       "      <th>Hour</th>\n",
+       "      <th>DayOfWeek</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2021-01-01 00:00:00</th>\n",
+       "      <td>472.88</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-01-01 00:15:00</th>\n",
+       "      <td>498.83</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-01-01 00:30:00</th>\n",
+       "      <td>480.48</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-01-01 00:45:00</th>\n",
+       "      <td>446.74</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-01-01 01:00:00</th>\n",
+       "      <td>459.55</td>\n",
+       "      <td>1</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                     Lastgang  Hour  DayOfWeek\n",
+       "2021-01-01 00:00:00    472.88     0          4\n",
+       "2021-01-01 00:15:00    498.83     0          4\n",
+       "2021-01-01 00:30:00    480.48     0          4\n",
+       "2021-01-01 00:45:00    446.74     0          4\n",
+       "2021-01-01 01:00:00    459.55     1          4"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Step 3 - Backscaling & Variables\n",
+    "\n",
+    "# Rescale 'Lastgang' data back to original scale\n",
+    "#dfEnergyAll['Lastgang'] = lastgang_scaler.inverse_transform(dfEnergyAll['Lastgang'].values.reshape(-1, 1))\n",
+    "\n",
+    "# Add time variables\n",
+    "dfEnergyAll['Hour'] = dfEnergyAll.index.hour\n",
+    "dfEnergyAll['DayOfWeek'] = dfEnergyAll.index.dayofweek\n",
+    "\n",
+    "dfEnergyAll.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b4d3376e-da82-4a38-b742-0fe862f1e8df",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Lastgang</th>\n",
+       "      <th>Hour</th>\n",
+       "      <th>DayOfWeek</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2021-01-01 00:00:00</th>\n",
+       "      <td>0.287476</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.666667</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-01-01 00:15:00</th>\n",
+       "      <td>0.305140</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.666667</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-01-01 00:30:00</th>\n",
+       "      <td>0.292649</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.666667</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-01-01 00:45:00</th>\n",
+       "      <td>0.269683</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.666667</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2021-01-01 01:00:00</th>\n",
+       "      <td>0.278403</td>\n",
+       "      <td>0.043478</td>\n",
+       "      <td>0.666667</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                     Lastgang      Hour  DayOfWeek\n",
+       "2021-01-01 00:00:00  0.287476  0.000000   0.666667\n",
+       "2021-01-01 00:15:00  0.305140  0.000000   0.666667\n",
+       "2021-01-01 00:30:00  0.292649  0.000000   0.666667\n",
+       "2021-01-01 00:45:00  0.269683  0.000000   0.666667\n",
+       "2021-01-01 01:00:00  0.278403  0.043478   0.666667"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Step 3 - Data Scaling\n",
+    "\n",
+    "from sklearn.preprocessing import MinMaxScaler\n",
+    "\n",
+    "# Initialize the scalers\n",
+    "lastgang_scaler = MinMaxScaler(feature_range=(0, 1))\n",
+    "features_scaler = MinMaxScaler(feature_range=(0, 1))\n",
+    "\n",
+    "# Apply the scaler to the appropriate columns\n",
+    "dfEnergyAll['Lastgang'] = lastgang_scaler.fit_transform(dfEnergyAll['Lastgang'].values.reshape(-1, 1))\n",
+    "dfEnergyAll[['Hour', 'DayOfWeek']] = features_scaler.fit_transform(dfEnergyAll[['Hour', 'DayOfWeek']])\n",
+    "\n",
+    "\n",
+    "dfEnergyAll.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "61e67cd4-5ae7-4840-acf2-73c0b1501d90",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                            OLS Regression Results                            \n",
+      "==============================================================================\n",
+      "Dep. Variable:               Lastgang   R-squared:                       0.274\n",
+      "Model:                            OLS   Adj. R-squared:                  0.274\n",
+      "Method:                 Least Squares   F-statistic:                 1.980e+04\n",
+      "Date:                Tue, 14 May 2024   Prob (F-statistic):               0.00\n",
+      "Time:                        21:14:52   Log-Likelihood:                 67258.\n",
+      "No. Observations:              104928   AIC:                        -1.345e+05\n",
+      "Df Residuals:                  104925   BIC:                        -1.345e+05\n",
+      "Df Model:                           2                                         \n",
+      "Covariance Type:            nonrobust                                         \n",
+      "==============================================================================\n",
+      "                 coef    std err          t      P>|t|      [0.025      0.975]\n",
+      "------------------------------------------------------------------------------\n",
+      "const          0.3011      0.001    312.011      0.000       0.299       0.303\n",
+      "Hour           0.2599      0.001    198.819      0.000       0.257       0.263\n",
+      "DayOfWeek     -0.0104      0.001     -8.825      0.000      -0.013      -0.008\n",
+      "==============================================================================\n",
+      "Omnibus:                     1068.149   Durbin-Watson:                   0.105\n",
+      "Prob(Omnibus):                  0.000   Jarque-Bera (JB):             1190.076\n",
+      "Skew:                           0.209   Prob(JB):                    3.79e-259\n",
+      "Kurtosis:                       3.314   Cond. No.                         4.90\n",
+      "==============================================================================\n",
+      "\n",
+      "Notes:\n",
+      "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Step 4 - Creating the linear regression model and generating predictions\n",
+    "\n",
+    "# Split the data into training and testing sets\n",
+    "train = dfEnergyAll.iloc[:-192]\n",
+    "test = dfEnergyAll.iloc[-192:]\n",
+    "\n",
+    "# Define target and explanatory variables (only Lastgang and time variables)\n",
+    "y_train = train['Lastgang']\n",
+    "X_train = train[['Hour', 'DayOfWeek']]\n",
+    "X_train = sm.add_constant(X_train)  # Adding a constant to include intercept\n",
+    "\n",
+    "y_test = test['Lastgang']\n",
+    "X_test = test[['Hour', 'DayOfWeek']]\n",
+    "X_test = sm.add_constant(X_test)  # Adding a constant to include intercept\n",
+    "\n",
+    "# Create and fit the model\n",
+    "model = sm.OLS(y_train, X_train).fit()\n",
+    "\n",
+    "# Make predictions\n",
+    "predictions = model.predict(X_test)\n",
+    "\n",
+    "# Output the summary of the model\n",
+    "print(model.summary())\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "fff058dd-224f-4e48-a46e-1efb52c0510f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean Squared Error (MSE) for the last 48 hours: 26924.710517054173\n",
+      "Mean Absolute Error (MAE) for the last 48 hours: 123.24100551236056\n",
+      "Root Mean Square Error (RMSE) for the last 48 hours: 164.08750871731272\n",
+      "Mean Absolute Percentage Error (MAPE) for the last 48 hours: 14.094107361496958%\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Step 5 - Rescaling, error metrics and visualization\n",
+    "\n",
+    "# Rescale predictions to the original scale\n",
+    "predictions_original_scale = lastgang_scaler.inverse_transform(predictions.to_numpy().reshape(-1, 1))\n",
+    "\n",
+    "# Rescale actual values to the original scale\n",
+    "y_test_original_scale = lastgang_scaler.inverse_transform(y_test.to_numpy().reshape(-1, 1))\n",
+    "\n",
+    "# Calculate error metrics for the test data (on the original scale)\n",
+    "mse = mean_squared_error(y_test_original_scale, predictions_original_scale)\n",
+    "mae = mean_absolute_error(y_test_original_scale, predictions_original_scale)\n",
+    "rmse = np.sqrt(mse)\n",
+    "mape = np.mean(np.abs((y_test_original_scale - predictions_original_scale) / y_test_original_scale)) * 100\n",
+    "\n",
+    "# Output error metrics\n",
+    "print(f\"Mean Squared Error (MSE) for the last 48 hours: {mse}\")\n",
+    "print(f\"Mean Absolute Error (MAE) for the last 48 hours: {mae}\")\n",
+    "print(f\"Root Mean Square Error (RMSE) for the last 48 hours: {rmse}\")\n",
+    "print(f\"Mean Absolute Percentage Error (MAPE) for the last 48 hours: {mape}%\")\n",
+    "\n",
+    "# Visualization of actual vs. predicted values for the test data (original scale)\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "plt.plot(y_test.index, y_test_original_scale, label='Actual Values', color='#3E7A6F')\n",
+    "plt.plot(y_test.index, predictions_original_scale, label='Predicted Values', color='#7DFFE7')\n",
+    "plt.legend()\n",
+    "plt.title('Comparison of Actual and Predicted Values: Linear Regression over 48 Hours')\n",
+    "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%m-%d %H:%M'))\n",
+    "plt.gca().xaxis.set_major_locator(mdates.HourLocator(interval=3))\n",
+    "plt.gcf().autofmt_xdate()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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": 5
+}