diff --git "a/LinearRegression.ipynb" "b/LinearRegression.ipynb"
new file mode 100644--- /dev/null
+++ "b/LinearRegression.ipynb"
@@ -0,0 +1,1032 @@
+{
+ "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": 19,
+   "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": 20,
+   "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": 21,
+   "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": 22,
+   "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": 23,
+   "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": 24,
+   "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_1472042/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": 25,
+   "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": 26,
+   "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_1472042/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": 27,
+   "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": 28,
+   "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:                Fri, 03 May 2024   Prob (F-statistic):               0.00\n",
+      "Time:                        13:34:08   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": 29,
+   "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": 30,
+   "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": 31,
+   "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:                Fri, 03 May 2024   Prob (F-statistic):               0.00\n",
+      "Time:                        13:34:09   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": 32,
+   "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": 33,
+   "id": "0f7252f4-92da-4836-a054-05205802ef05",
+   "metadata": {},
+   "outputs": [],
+   "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"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "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:                Fri, 03 May 2024   Prob (F-statistic):               0.00\n",
+      "Time:                        13:34:09   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.0113   5.68e-05    198.819      0.000       0.011       0.011\n",
+      "DayOfWeek     -0.0017      0.000     -8.825      0.000      -0.002      -0.001\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.                         33.9\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": 35,
+   "id": "fff058dd-224f-4e48-a46e-1efb52c0510f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean Squared Error (MSE) for the last 48 hours: 0.012474713729335092\n",
+      "Mean Absolute Error (MAE) for the last 48 hours: 0.08388706616321262\n",
+      "Root Mean Square Error (RMSE) for the last 48 hours: 0.11169025798759305\n",
+      "Mean Absolute Percentage Error (MAPE) for the last 48 hours: 15.012789192315386%\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",
+    "# Calculate error metrics\n",
+    "mse = mean_squared_error(y_test, predictions)\n",
+    "mae = mean_absolute_error(y_test, predictions)\n",
+    "rmse = np.sqrt(mse)\n",
+    "mape = np.mean(np.abs((y_test - predictions) / y_test)) * 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\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "plt.plot(y_test.index, y_test, label='Actual Values', color='#3E7A6F')\n",
+    "plt.plot(y_test.index, predictions, 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
+}