p1_SARIMA_forecasting.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Any, Iterable\n",
    "import yfinance as yf\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from statsmodels.tsa.arima.model import ARIMA\n",
    "from modules.utils import logger\n",
    "\n",
    "class Forecaster():\n",
    "    '''\n",
    "    Object class to retrieve prices, forecast, and determine buy/sell actions\n",
    "    '''\n",
    "    def __init__(self, *args, **kwargs)-> None:\n",
    "        '''\n",
    "        Initialize with any specified tickers\n",
    "        Parameters:\n",
    "            tickers (str) : tickers to store\n",
    "            price_type (str) : type of price during the interval 'Open', 'Close', 'High', 'Low'\n",
    "            period (str) : length of time series - '5y', '1y', 'ytd', '10y'\n",
    "            interval (str) : Interval of prices - '1wk', '1d'\n",
    "            order (tuple) : (p, d, q)\n",
    "            seasonal_order (tuple) : (P, D, Q, m)\n",
    "        '''\n",
    "        self.tickers = {}\n",
    "        for arg in args:\n",
    "            if arg.isupper() and len(arg)<=4: \n",
    "                self.tickers.setdefault(arg)\n",
    "            else:\n",
    "                logger.info(f'Invalid ticker: {arg}, ticker must be in uppercase only')\n",
    "        \n",
    "        self.price_type = kwargs.get(\"price_type\", 'Close')\n",
    "        self.period = kwargs.get(\"period\", '5y')\n",
    "        self.interval = kwargs.get(\"interval\", '1wk')\n",
    "        self.order = kwargs.get(\"order\", (0, 1, 1))\n",
    "        self.seasonal_order = kwargs.get(\"seasonal_order\", (2, 1, 0, 52))\n",
    "\n",
    "    def __repr__(self) -> str:\n",
    "        '''\n",
    "        Shows the main parameters of the class object\n",
    "        '''\n",
    "        return (f'Forecaster(price_type={self.price_type}, period={self.period},'\n",
    "                f'interval={self.interval}, order={self.order}, seasonal_order={self.seasonal_order}, tickers={self.tickers.values()}')\n",
    "\n",
    "    def __getattr__(self, ticker: str) -> Any:\n",
    "        '''\n",
    "        Modified dunder method to call ticker info directly from class object\n",
    "        Parameters:\n",
    "            ticker (str) : ticker to get infomation\n",
    "        Returns:\n",
    "            dictionary containing the data\n",
    "            keys -> ('forecast' / 'ts / 'max_profit' / 'max_profit_history' / 'best_trades' / 'best_trades_history')\n",
    "        '''\n",
    "        if ticker.isupper() and len(ticker)<=4: \n",
    "            return self.tickers[ticker]\n",
    "        else:\n",
    "            raise KeyError('No such attribute, to get Ticker data, input ticker in caps')\n",
    "\n",
    "    def __getitem__(self, ticker: str) -> Any:\n",
    "        '''\n",
    "        Modified dunder method to call ticker info directly from class object\n",
    "        Parameters:\n",
    "            ticker (str) : ticker to get infomation\n",
    "        Returns:\n",
    "            dictionary containing the data\n",
    "            keys -> ('forecast' / 'ts / 'max_profit' / 'max_profit_history' / 'best_trades' / 'best_trades_history')\n",
    "        '''\n",
    "        if ticker.isupper() and len(ticker)<=4: \n",
    "            return self.tickers[ticker]\n",
    "        else:\n",
    "            raise KeyError('No such attribute, to get Ticker data, input ticker in caps')\n",
    "\n",
    "    def add_tickers(self, args) -> None:\n",
    "        if isinstance(args, str):\n",
    "            if args.isupper() and len(args)<=4: \n",
    "                self.tickers.setdefault(args)\n",
    "            else:\n",
    "                raise KeyError(f'Invalid ticker: {args}, ticker must be string and in uppercase only')\n",
    "        elif isinstance(args, Iterable):\n",
    "            for arg in args:\n",
    "                if isinstance(arg, str):\n",
    "                    if arg.isupper() and len(arg)<=4: \n",
    "                        self.tickers.setdefault(arg)\n",
    "                    else:\n",
    "                        raise KeyError(f'Invalid ticker: {arg}, ticker must be in uppercase only')\n",
    "\n",
    "    def forecast(self, *args, **kwargs) -> None:\n",
    "        '''\n",
    "        Forecasts with SARIMA\n",
    "        Parameters:\n",
    "            tickers (str) : tickers to forecast, if none are specified, uses all the tickers stored in object\n",
    "            price_type (str) : type of price during the interval 'Open', 'Close', 'High', 'Low'\n",
    "            period (str) : length of time series - '5y', '1y', 'ytd', '10y'\n",
    "            interval (str) : Interval of prices - '1wk', '1d'\n",
    "            order (tuple) : (p, d, q)\n",
    "            seasonal_order (tuple) : (P, D, Q, m)\n",
    "        '''\n",
    "        price_type = kwargs.get(\"price_type\", self.price_type)\n",
    "        period = kwargs.get(\"period\", self.period)\n",
    "        interval = kwargs.get(\"interval\", self.interval)\n",
    "        order = kwargs.get(\"order\", self.order)\n",
    "        seasonal_order = kwargs.get(\"seasonal_order\", self.seasonal_order)\n",
    "\n",
    "        if not args:\n",
    "            args = self.tickers.keys()\n",
    "\n",
    "        for ticker in args:\n",
    "            logger.info(f'Forecasting for {ticker}')\n",
    "            stock = yf.Ticker(ticker)\n",
    "            # logger.info(stock.info)\n",
    "\n",
    "            # get historical market data\n",
    "            df = stock.history(period=period, interval=interval)\n",
    "            if interval == '1wk':\n",
    "                ts = df[[price_type]].to_period('W')\n",
    "            elif interval == '1d':\n",
    "                ts = df[[price_type]].to_period('D')\n",
    "\n",
    "            model = ARIMA(ts, order=order,seasonal_order=seasonal_order)\n",
    "            model_fit = model.fit()\n",
    "            forecast = model_fit.predict(start=len(df), end = len(df)+seasonal_order[-1], dynamic=False)     \n",
    "            self.tickers[ticker] = {'ts': ts, 'forecast': forecast, 'model':model_fit}\n",
    "\n",
    "    def forecast_validation(self, ticker:str = None, validation_periods:int = 52, plot:bool=True, forecast_period_only = True, **kwargs) -> tuple:\n",
    "        '''\n",
    "        Forecasts with SARIMA\n",
    "        Parameters:\n",
    "            tickers (str) : ticker to validate\n",
    "            validation_periods (int) : periods to validate (from latest period)\n",
    "            plot (bool) : whether to plot out forecast vs validation\n",
    "            forecast_period_only : plot only the forecast period\n",
    "            **kwargs (see documentation on forecast())\n",
    "        '''\n",
    "        price_type = kwargs.get(\"price_type\", self.price_type)\n",
    "        period = kwargs.get(\"period\", self.period)\n",
    "        interval = kwargs.get(\"interval\", self.interval)\n",
    "        order = kwargs.get(\"order\", self.order)\n",
    "        seasonal_order = kwargs.get(\"seasonal_order\", self.seasonal_order)\n",
    "\n",
    "        if not ticker:\n",
    "            ticker = list(self.tickers.keys())[0]\n",
    "        logger.info(f'Validating forecast for {ticker}')\n",
    "        stock = yf.Ticker(ticker)\n",
    "        # logger.info(stock.info)\n",
    "\n",
    "        # Get historical market data\n",
    "        df = stock.history(period=period, interval=interval)\n",
    "        if interval == '1wk':\n",
    "            ts = df[[price_type]].to_period('W')\n",
    "        elif interval == '1d':\n",
    "            ts = df[[price_type]].to_period('D')\n",
    "        \n",
    "        train, test = ts[:-validation_periods], ts[-validation_periods:]\n",
    "        logger.info(f'Train periods: {len(train)}, Validation periods: {len(test)}')\n",
    "\n",
    "        # Forecast for the test period\n",
    "        model = ARIMA(train, order=order,seasonal_order=seasonal_order)\n",
    "        model_fit = model.fit()\n",
    "        forecast = model_fit.predict(start=len(train), end = len(train)+len(test), dynamic=False)  \n",
    "\n",
    "        # Calculate MSE\n",
    "        mse = 1/len(test)*np.sum((test.squeeze() - (forecast.shift(-1)))**2)\n",
    "        logger.info(f'MSE: {mse}')\n",
    "        logger.info(f'AIC: {model_fit.aic}')\n",
    "\n",
    "        # Plot both yhat and y\n",
    "        if plot:\n",
    "            plt.figure(figsize=(14,6))\n",
    "            plt.title(f'Validation for {ticker}')\n",
    "            plt.plot(test.to_timestamp(), color='grey', label='Actual')\n",
    "            plt.plot(forecast.to_timestamp().shift(-1), color='salmon', label='Forecast')\n",
    "            if not forecast_period_only:\n",
    "                plt.plot(ts.to_timestamp())\n",
    "            else:\n",
    "                plt.xticks(forecast.index, rotation=45, fontsize=8)\n",
    "                plt.legend()\n",
    "                plt.grid()\n",
    "        return mse, model_fit.aic\n",
    "    \n",
    "    def plot_forecast(self, ticker: str=None, forecast_only: bool=False):\n",
    "        '''\n",
    "        Plots the forecasts and/or timeseries of prices\n",
    "        Parameters:\n",
    "            ticker (str) : ticker to plot from stored forecast\n",
    "            forecast_only (bool) : whether to plot only the forecast or include past_prices\n",
    "        '''\n",
    "        try:\n",
    "            # Use the init ticker\n",
    "            if not ticker:\n",
    "                ticker = list(self.tickers.keys())[0]\n",
    "            ticker_data = self.tickers[ticker]\n",
    "            ts, forecast = ticker_data['ts'], ticker_data['forecast']\n",
    "\n",
    "            # Use .to_timestamp() to convert period back into timestamp for plotting\n",
    "            plt.figure(figsize=(14,6))\n",
    "            plt.title(f'Forecast for {ticker}')\n",
    "            plt.plot(forecast.to_timestamp(), color='salmon', label='Forecast')\n",
    "            if not forecast_only:\n",
    "                plt.plot(ts.to_timestamp(), color='grey', label='Actual')\n",
    "            else:\n",
    "                plt.xticks(forecast.index, rotation=45, fontsize=8)\n",
    "                plt.grid()\n",
    "            plt.legend()\n",
    "\n",
    "        except AttributeError as e:\n",
    "            logger.info(f'No forecasting done yet for {ticker}')            \n",
    "\n",
    "    def find_max_profit(self, *args):\n",
    "        '''\n",
    "        Finds the maximum profit possible without trading\n",
    "        Parameters:\n",
    "            ticker (str) : ticker to plot from stored forecast\n",
    "        '''\n",
    "        if not args:\n",
    "            args = self.tickers.keys()\n",
    "\n",
    "        for ticker in args:\n",
    "            try:\n",
    "                ticker_data = self.tickers.get(ticker, None)     \n",
    "                forecast = ticker_data.get('forecast', None)  \n",
    "                max_profit = 0\n",
    "                high, low = None, None\n",
    "                last_profit = None\n",
    "                data = {}\n",
    "                for period, price in zip(forecast.index, forecast):\n",
    "                    price = round(price, 3)\n",
    "                    data[period] = dict(current=price) # Saves every period as index\n",
    "                    if not low or not high:\n",
    "                        # Initial assignments\n",
    "                        low = high = price \n",
    "                        low_idx = high_idx = period\n",
    "                        # For edge case, where new_low is the first item\n",
    "                        data[period]['new_low'] = price\n",
    "\n",
    "                    # Find new lows, including the index\n",
    "                    if price < low:\n",
    "                        low, low_idx = price, period\n",
    "                        high, high_idx = price, period # reset the high\n",
    "                        data[period]['new_low'] = price\n",
    "\n",
    "                    # Find new highs, including the index\n",
    "                    if price > high:\n",
    "                        high = price\n",
    "                        high, high_idx = price, period\n",
    "                        data[period]['new_high'] = price\n",
    "\n",
    "                    # Calculate and check profit\n",
    "                    profit = round((high - low)/low * 100, 2)\n",
    "                    if profit > 0:\n",
    "                        if profit != last_profit:\n",
    "                            data[period]['profit %'] = profit\n",
    "                    last_profit = profit\n",
    "\n",
    "                    # Record the new max_profit\n",
    "                    if profit > max_profit:\n",
    "                        max_profit, buy, sell = profit, low_idx, high_idx\n",
    "                        data[period]['new_max_profit'] = profit\n",
    "\n",
    "                \n",
    "\n",
    "                # Create final buy and sell action on the current period\n",
    "                data[buy]['action'], data[sell]['action'] = 'buy', 'sell'\n",
    "                df = pd.DataFrame(data).T\n",
    "                df = df.fillna('')\n",
    "                df = df[['current', 'profit %', 'new_low', 'new_high', 'new_max_profit', 'action']]\n",
    "\n",
    "                # Filter for buy and sell action only\n",
    "                actions = df[(df['action']=='buy') | (df['action']=='sell')][['current', 'profit %', 'action']]\n",
    "\n",
    "                # Save the two dfs\n",
    "                ticker_data['max_profit'] = actions\n",
    "                ticker_data['max_profit_history'] = df\n",
    "\n",
    "            except AttributeError:\n",
    "                raise AttributeError(f'No forecasting done yet for {ticker}')\n",
    "            except Exception as e:\n",
    "                raise Exception(e)\n",
    "            \n",
    "    def find_best_trades(self, *args):\n",
    "        '''\n",
    "        Finds all the trades and returns best n trades\n",
    "        Parameters:\n",
    "            ticker (str) : ticker to plot from stored forecast\n",
    "        '''\n",
    "        if not args:\n",
    "            args = self.tickers.keys()\n",
    "\n",
    "        for ticker in args:\n",
    "            try:\n",
    "                ticker_data = self.tickers.get(ticker, None)     \n",
    "                forecast = ticker_data.get('forecast', None)  \n",
    "                low = None\n",
    "                data = {}\n",
    "                for period, price in zip(forecast.index, forecast):\n",
    "                    price = round(price, 3)\n",
    "                    data[period] = dict(current=price) # Saves every period as index\n",
    "                    if not low:\n",
    "                        # Initial assignments\n",
    "                        low, low_idx = price, period\n",
    "                        first_decline = False\n",
    "                    else:\n",
    "                        if price >= last_price:\n",
    "                            first_decline = True # To reset the memory on whether there has ever been a decline\n",
    "\n",
    "                        elif price < last_price:\n",
    "                            if first_decline:\n",
    "                                # Determine to sell if the current period price is a first drop\n",
    "                                data[last_idx]['action'] = 'sell'\n",
    "\n",
    "                                # Calculations\n",
    "                                profit = round((last_price - low)/low * 100, 2)\n",
    "                                hold_period = (last_idx - low_idx).n\n",
    "\n",
    "                                # Record\n",
    "                                data[last_idx]['profit %'] = profit\n",
    "                                data[last_idx]['hold period'] = hold_period\n",
    "                                data[low_idx]['action'] = 'buy'\n",
    "                                first_decline = False\n",
    "                            # Register the new low for next profit\n",
    "                            low, low_idx = price, period\n",
    "\n",
    "                    last_price, last_idx = price, period\n",
    "\n",
    "                df = pd.DataFrame(data).T\n",
    "                df = df.fillna('')\n",
    "                df = df[['current', 'profit %', 'action', 'hold period']]\n",
    "\n",
    "                # Filter for buy and sell action only\n",
    "                actions = df[(df['action']=='buy') | (df['action']=='sell')][['current', 'profit %', 'action', 'hold period']]\n",
    "\n",
    "                # Get totals\n",
    "                compounding_gains = [float(x)*0.01 + 1 for x in actions['profit %'].to_list() if x != '']\n",
    "                total_gain = round((np.prod(compounding_gains)-1)*100 , 2)\n",
    "                hold_periods = [int(x) for x in actions['hold period'].to_list() if x != '']\n",
    "                total_hold_period = sum(hold_periods)\n",
    "\n",
    "                actions.loc[len(actions.index)] = ['Compound gain', total_gain, '', total_hold_period]  \n",
    "\n",
    "                # Save the two dfs\n",
    "                ticker_data['best_trades'] = actions\n",
    "                ticker_data['best_trades_history'] = df\n",
    "                \n",
    "\n",
    "            except AttributeError:\n",
    "                raise AttributeError(f'No forecasting done yet for {ticker}')\n",
    "            except Exception as e:\n",
    "                raise Exception(e)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Forecaster(price_type=Close, period=5y,interval=1wk, order=(0, 1, 1), seasonal_order=(2, 1, 0, 52), tickers=dict_values([None])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "forecaster = Forecaster('TSLA')\n",
    "forecaster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validating forecast for TSLA\n",
      "Train periods: 210, Validation periods: 52\n",
      "MSE: 11680.7758478105\n",
      "AIC: 1414.3898962817716\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(11680.7758478105, 1414.3898962817716)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABHUAAAIQCAYAAAAPe1L+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAADgZklEQVR4nOzdeXwcdf0/8NfsmXNz31fv+6ItbVOgF9BaiogURCgUFEWleKBf/FnliwryraKi4rciX0VA2nIqIOVoS2nL0YPeTZueaXPf5yabbPaY+f0xO7O7zbnJXklez8cjj0czOzvzSZpsdt7zPgRJkiQQEREREREREdGQogn1AoiIiIiIiIiIyHcM6hARERERERERDUEM6hARERERERERDUEM6hARERERERERDUEM6hARERERERERDUEM6hARERERERERDUEM6hARERERERERDUEM6hARERERERERDUEM6hARERERERERDUEM6hAREdGgFBcXQxAEvPDCC+q2X/ziFxAEoV/PFwQBv/jFL/y6piVLlmDJkiV+PWZ/nT9/HsuXL0dcXBwEQcBbb70VknUQERHR8MegDhER0Qhy0003ISoqCq2trT3us2bNGhgMBjQ0NARxZb4rLCzEL37xCxQXF4d6KV7uueceFBQU4IknnsBLL72EuXPnBuQ8S5YsgSAIfX4oATObzYY//elPuOKKK2AymRAfH4+pU6fi/vvvx5kzZ9TjvvDCCxAEAYcOHer3WubNmwdBEPDMM8/4+8skIiKiXuhCvQAiIiIKnjVr1uCdd97Bm2++ibVr13Z5vL29HW+//Ta+8IUvICkpacDneeSRR/CTn/xkMEvtU2FhIX75y19iyZIlGDVqlNdj27dvD+i5e9LR0YF9+/bhZz/7GR588MGAnutnP/sZvvGNb6ifHzx4EE8//TR++tOfYvLkyer2GTNmAABWr16N999/H3fccQe++c1vwm6348yZM9i6dSsWLlyISZMmDWgd58+fx8GDBzFq1Chs3rwZ3/nOdwb3hREREVG/MahDREQ0gtx0002IjY3Fli1bug3qvP3227BYLFizZs2gzqPT6aDThe5thsFgCMl56+rqAADx8fF+O6bFYkF0dHSX7ddff73X5xEREXj66adx/fXXdyk9O3jwILZu3YonnngCP/3pT70e+9///V80NzcPeH2bNm1Camoqfv/73+PWW29FcXFxlyAbERERBQbLr4iIiEaQyMhI3HLLLdi5cydqa2u7PL5lyxbExsbipptuQmNjI/7rv/4L06dPR0xMDEwmE1auXInjx4/3eZ7ueup0dnbioYceQkpKinqO8vLyLs8tKSnBAw88gIkTJyIyMhJJSUm47bbbvMqsXnjhBdx2220AgKVLl6qlRrt37wbQfU+d2tpa3HfffUhLS0NERARmzpyJF1980WsfpT/Q7373O/zf//0fxo4dC6PRiCuvvBIHDx7s82vOy8sDADz88MMQBMEruHH06FGsXLkSJpMJMTExuPbaa7F//36vYyilT3v27MEDDzyA1NRUZGdn93re/igqKgIAXHXVVV0e02q1g8rK2rJlC2699VbceOONiIuLw5YtWwZ8LCIiIvINM3WIiIhGmDVr1uDFF1/Ea6+95lUi1NjYiG3btuGOO+5AZGQkTp06hbfeegu33XYbRo8ejZqaGjz77LNYvHgxCgsLkZmZ6dN5v/GNb2DTpk248847sXDhQnz00UdYtWpVl/0OHjyIvXv34qtf/Sqys7NRXFyMZ555BkuWLEFhYSGioqKwaNEifO973+tSbuRZduSpo6MDS5YswYULF/Dggw9i9OjReP3113HvvfeiubkZ3//+973237JlC1pbW/Gtb30LgiDgySefxC233IKLFy9Cr9d3e45bbrkF8fHxeOihh3DHHXfghhtuQExMDADg1KlTuOaaa2AymfDjH/8Yer0ezz77LJYsWYI9e/Zg/vz5Xsd64IEHkJKSgkcffRQWi8Wn73N3lGDT5s2bcdVVV/kti+rAgQO4cOECnn/+eRgMBtxyyy3YvHlzl2wgIiIiChCJiIiIRhSHwyFlZGRI+fn5Xtv/+te/SgCkbdu2SZIkSVarVXI6nV77XLp0STIajdJjjz3mtQ2A9Pzzz6vbfv7zn0uebzOOHTsmAZAeeOABr+PdeeedEgDp5z//ubqtvb29y5r37dsnAZD++c9/qttef/11CYC0a9euLvsvXrxYWrx4sfr5H//4RwmAtGnTJnWbzWaT8vPzpZiYGMlsNnt9LUlJSVJjY6O679tvvy0BkN55550u5/KkPP+3v/2t1/abb75ZMhgMUlFRkbqtsrJSio2NlRYtWqRue/755yUA0tVXXy05HI5ez3W53r4foihKixcvlgBIaWlp0h133CFt3LhRKikp6bKvsoaDBw/2ec4HH3xQysnJkURRlCRJkrZv3y4BkI4ePerT2omIiGhgWH5FREQ0wmi1Wnz1q1/Fvn37vEqatmzZgrS0NFx77bUAAKPRCI1GfqvgdDrR0NCAmJgYTJw4EUeOHPHpnO+99x4A4Hvf+57X9h/84Add9o2MjFT/bbfb0dDQgHHjxiE+Pt7n83qePz09HXfccYe6Ta/X43vf+x7a2tqwZ88er/1vv/12JCQkqJ9fc801AICLFy/6fG6n04nt27fj5ptvxpgxY9TtGRkZuPPOO/Hpp5/CbDZ7Peeb3/wmtFqtz+fqiSAI2LZtG371q18hISEBL7/8MtatW4e8vDzcfvvtA+qp43A48Oqrr+L2229XS+2WLVuG1NRUbN682W9rJyIiop4xqENERDQCKY2Qlf4n5eXl+OSTT/DVr35VDSaIoog//OEPGD9+PIxGI5KTk5GSkoITJ06gpaXFp/OVlJRAo9Fg7NixXtsnTpzYZd+Ojg48+uijyMnJ8Tpvc3Ozz+f1PP/48ePVIJVCKdcqKSnx2p6bm+v1uRLgaWpq8vncdXV1aG9v7/ZrnTx5MkRRRFlZmdf20aNH+3yevhiNRvzsZz/D6dOnUVlZiZdffhkLFizoUobXX9u3b0ddXR3mzZuHCxcu4MKFC7h06RKWLl2Kl19+GaIo+v1rICIiIm8M6hAREY1Ac+bMwaRJk/Dyyy8DAF5++WVIkuQ19ep//ud/8MMf/hCLFi3Cpk2bsG3bNuzYsQNTp04N6AX7d7/7XTzxxBP4yle+gtdeew3bt2/Hjh07kJSUFLRAQU9ZMpIkBeX8ntlKgZCRkYGvfvWr+PjjjzF+/Hi89tprcDgcPh1Dycb5yle+gvHjx6sfr776KioqKrpkPxEREZH/sVEyERHRCLVmzRr893//N06cOIEtW7Zg/PjxuPLKK9XH33jjDSxduhTPPfec1/Oam5uRnJzs07ny8vIgiiKKioq8MlbOnj3bZd833ngD99xzD37/+9+r26xWa5cSocuna/V1/hMnTkAURa9snTNnzqiPB0pKSgqioqK6/VrPnDkDjUaDnJycgJ2/N3q9HjNmzMD58+dRX1+P9PT0fj3PYrHg7bffxu23345bb721y+Pf+973sHnzZixdutTfSyYiIiIPzNQhIiIaoZSsnEcffRTHjh3zytIB5GyVyzNTXn/9dVRUVPh8rpUrVwIAnn76aa/tf/zjH7vs2915//znP8PpdHpti46OBoB+9YO54YYbUF1djVdffVXd5nA48Oc//xkxMTFYvHhxf76MAdFqtVi+fDnefvttrx5GNTU12LJlC66++mqYTKaAnR8Azp8/j9LS0i7bm5ubsW/fPiQkJCAlJaXfx3vzzTdhsViwbt063HrrrV0+brzxRvzrX/9CZ2enP78MIiIiugwzdYiIiEao0aNHY+HChXj77bcBoEtQ58Ybb8Rjjz2Gr33ta1i4cCEKCgqwefNmr2a//TVr1izccccd+Mtf/oKWlhYsXLgQO3fuxIULF7rse+ONN+Kll15CXFwcpkyZgn379uHDDz9EUlJSl2NqtVr85je/QUtLC4xGo9qo93L3338/nn32Wdx77704fPgwRo0ahTfeeAOfffYZ/vjHPyI2Ntbnr8kXv/rVr7Bjxw5cffXVeOCBB6DT6fDss8+is7MTTz75ZEDPDQDHjx/HnXfeiZUrV+Kaa65BYmIiKioq8OKLL6KyshJ//OMfu5Sc/eMf/8AHH3zQ5Vjf//73sXnzZiQlJWHhwoXdnu+mm27C3/72N7z77ru45ZZbAvI1EREREYM6REREI9qaNWuwd+9ezJs3D+PGjfN67Kc//SksFgu2bNmCV199FbNnz8a7776Ln/zkJwM61z/+8Q+kpKRg8+bNeOutt7Bs2TK8++67XUqP/vSnP0Gr1WLz5s2wWq246qqr8OGHH2LFihVe+6Wnp+Ovf/0rNmzYgPvuuw9OpxO7du3qNqgTGRmJ3bt34yc/+QlefPFFmM1mTJw4Ec8//zzuvffeAX09vpg6dSo++eQTrF+/Hhs2bIAoipg/fz42bdqE+fPnB/z8ixYtwuOPP473338fTz31FOrq6hAbG4srrrgCv/nNb7B69eouz3nmmWe6PdbatWvx4Ycf4o477uix99C1116LqKgobNq0iUEdIiKiABKkYHX8IyIiIiIiIiIiv2FPHSIiIiIiIiKiIYhBHSIiIiIiIiKiIYhBHSIiIiIiIiKiIYhBHSIiIiIiIiKiIYhBHSIiIiIiIiKiIYhBHSIiIiIiIiKiIUgX6gUMhCiKqKysRGxsLARBCPVyiIiIiIiIiIj8QpIktLa2IjMzExpN77k4QzKoU1lZiZycnFAvg4iIiIiIiIgoIMrKypCdnd3rPkMyqBMbGwtA/gJNJlOIV0NERERERERE5B9msxk5OTlq7KM3QzKoo5RcmUwmBnWIiIiIiIiIaNjpT7sZNkomIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiIiIiIhqCGNQhIiIiom5teP80/rL7QqiXQURERD3QhXoBRERERBR+qlo68Oyei9AIwLcWjYVWI4R6SURERHQZZuoQERERURfVLVYAgCgBbZ2OEK+GiIiIusOgDhERERF1UWPuVP/darWHcCVERETUEwZ1iIiIiKiLular+m9m6hAREYWnQQV1fv3rX0MQBPzgBz9Qt1mtVqxbtw5JSUmIiYnB6tWrUVNT4/W80tJSrFq1ClFRUUhNTcXDDz8Mh4NvFoiIiIjCRW2rZ6YO36cRERGFowEHdQ4ePIhnn30WM2bM8Nr+0EMP4Z133sHrr7+OPXv2oLKyErfccov6uNPpxKpVq2Cz2bB37168+OKLeOGFF/Doo48O/KsgIiIiIr+q9Si/amNQh4iIKCwNKKjT1taGNWvW4G9/+xsSEhLU7S0tLXjuuefw1FNPYdmyZZgzZw6ef/557N27F/v37wcAbN++HYWFhdi0aRNmzZqFlStX4vHHH8fGjRths9n881URERER0aDUeJRfmdlTh4iIKCwNKKizbt06rFq1Ctddd53X9sOHD8Nut3ttnzRpEnJzc7Fv3z4AwL59+zB9+nSkpaWp+6xYsQJmsxmnTp3q9nydnZ0wm81eH0REREQUOF6ZOuypQ0REFJZ0vj7hlVdewZEjR3Dw4MEuj1VXV8NgMCA+Pt5re1paGqqrq9V9PAM6yuPKY93ZsGEDfvnLX/q6VCIiIiIaIPbUISIiCn8+ZeqUlZXh+9//PjZv3oyIiIhAramL9evXo6WlRf0oKysL2rmJiIiIRhqHU0SDhT11iIiIwp1PQZ3Dhw+jtrYWs2fPhk6ng06nw549e/D0009Dp9MhLS0NNpsNzc3NXs+rqalBeno6ACA9Pb3LNCzlc2WfyxmNRphMJq8PIiIiIgqM+jYbJMn9eSt76hAREYUln4I61157LQoKCnDs2DH1Y+7cuVizZo36b71ej507d6rPOXv2LEpLS5Gfnw8AyM/PR0FBAWpra9V9duzYAZPJhClTpvjpyyIiIiKigar1aJIMAK3sqUNERBSWfOqpExsbi2nTpnlti46ORlJSkrr9vvvuww9/+EMkJibCZDLhu9/9LvLz87FgwQIAwPLlyzFlyhTcfffdePLJJ1FdXY1HHnkE69atg9Fo9NOXRUREREQD5dkkGWBPHSIionDlc6PkvvzhD3+ARqPB6tWr0dnZiRUrVuAvf/mL+rhWq8XWrVvxne98B/n5+YiOjsY999yDxx57zN9LISIiIqIB8GySDLCnDhERUbgSJMmzYnpoMJvNiIuLQ0tLC/vrEBEREfnZH3acw592nkdmXAQqW6yYnhWHd757daiXRURENCL4EvPwqacOEREREQ1/SqbOmJQYAGyUTEREFK4Y1CEiIiIiL3WuRsljU6IBAG1slExERBSWGNQhIiIiIi9Kps7YVDlTx8yeOkRERGGJQR0iIiIi8lJjljN1xiTLQR2bQ0SnwxnKJREREVE3GNQhIiIiIpVTlFDfZgMAjHaVXwGcgEVERBSOGNQhIiIiIlWjxQanKEEQgLRYI6INWgDsq0NERBSOGNQhIiIiIlWtq0lyUrQROq0GMRE6AEArM3WIiIjCDoM6RERERKSqNctNklNjjQCA2Ag9AAZ1iIiIwhGDOkRERESkUjJ1Uk1yUCfGqGTq2EO2JiIiIuoegzpEREREpFIyddJiIwAAsa7yK/bUISIiCj8M6hARERGRqrbVVX5lUsqv2FOHiIgoXDGoQ0RERESqGrOr/ErpqWOUe+owU4eIiCj8MKhDRERERColUyfFVX6lTL8ys6cOERFR2GFQh4iIiIhUda6gTtpl5VdtLL8iIiIKOwzqEBEREREAQJIkj+lXrkwdY/c9dapaOrDhvdMob2oP7iKJiIhIxaAOEREREQEAmtrtsDslAEBKjJypY4rovqfOP/eV4NmPL+LZPReDu0giIiJSMahDRERERACgZukkROlh0MlvE2PU6VfePXUqmjoAAAUVLUFcIREREXliUIeIiIiIAAC1ZqWfToS6rafyK2VK1ukqMxxOMUgrJCIiIk8M6hARERERAM/JV0Z1W2xE70GdToeIi/WWIK2QiIiIPDGoQ0REREQA3IGa1Fh3po46/cqjp44kSahxZfUAwEmWYBEREYUEgzpEREREBMA9zjzV5Jmp426ULElyE+XWTgc67E51n1OV5iCukoiIiBQM6hARERERAHej5FSP8iulp45TlNRATk2L1et5zNQhIiIKDQZ1iIiIiAhA942SowxaaAT5322uvjpK6ZUyIauw0gxRlIK4UiIiIgIY1CEiIiIil7q2ro2SBUFQs3XMalBHztSZnRsPg06D1k4Hyprag7xaIiIiYlCHiIiIiAC4J1yZXH10FJ59dQCg2hXUyYqPwqT0WADsq0NERBQKDOoQEREREQB30CbGNfFK4R5rbgcA1LqCOulxRkzNNAFgXx0iIqJQ0PW9CxERERENdzaHCJtDBADEGLoP6ig9dZRMnTRTBDLiIgGUMVOHiIgoBBjUISIiIiJYXFk6ABBt1Ho9pvTUab2sUXJqbATSXOPPT1W2QJIkCIIQjOUSERERWH5FRERERHCXXkXoNdBpvd8iKj11Wl37uMuvIjA5wwStRkB9mw21rZ1BXDERERExqENERERE7n46xq6J3DEePXVEUVKDN2kmIyL0WoxNiQbAvjpERETBxqAOEREREanlV90FdWKN7p46DRYbHKIEQQCSY+TSq2mZcQA4AYuIiCjYGNQhIiIiIrW0Krq7oE6Eu6dOjav0KjnGCL2rTGsKJ2ARERGFBIM6RERERKRm6nQX1FGyd9o63UEdpUEyAEzLYqZOdyRJCvUSiIhomGNQh4iIiIjUoE5st5k6cqNks9WuTr5Ki41QH1cydSqaO9BksQV6qUPCxl0XMOuxHThf0xrqpRAR0TDGoA4RERERqePKu83UiegmUyfOHdQxReiRlxQFACisYrYOAGw9UYWWDjt2nqkN9VKIiGgYY1CHiIiIiGDpdALof08dz0wdAJiUHgsAOFvNzBRJklDSYAEAnGGQi4iIAohBHSIiIiKCxeYqv4robvqVXH7VZu2+pw4AjEuNAQAU1bUFcplDQl1rJ9ptcpDsDINcREQUQAzqEBEREZG7/MrQW6aOR0+dOO9MnbEpclDnQi2DOpfqLeq/L9S2weYQQ7gaIiIazhjUISIiIiK1UXJMN5k6yjaLzYmqlg4AXcuvmKnjVtzgDuo4RImBLiIiChgGdYiIiIjIHdQxars85lmS1dRuB9C1/ErJ1Klvs6G53bcJWAcuNuC+Fw7iRHmzT88LV5fq270+P1PNvjpERBQYDOoQEREREVo7e55+ZdRpYdC63zbqtQISow1e+0Qbdch0lWT5mq2z6UApdp6pxZ1/O4DPLzX6uvSwU+wqv4rQy98z9tUhIqJAYVCHiIiIiDwydboGdQDvbJ3U2AgIgtBln7GpA+ur09Am9+lp63Rg7T8O4NPz9T49P9wo5VeLJ6QAAE5zAhYREQWIT0GdZ555BjNmzIDJZILJZEJ+fj7ef/999fElS5ZAEASvj29/+9texygtLcWqVasQFRWF1NRUPPzww3A4HP75aoiIiIhoQNr6COp49tq5vPRKMdBmyY0WuVwrOyESVruIr794EDtP1/h0jHAhipIa1Fk5LQMAM3WIiChwfArqZGdn49e//jUOHz6MQ4cOYdmyZfjSl76EU6dOqft885vfRFVVlfrx5JNPqo85nU6sWrUKNpsNe/fuxYsvvogXXngBjz76qP++IiIiIiLymaWX8ivAO9iTftnkK8W4AWbqKEGdp++4AiumpsHmEPHtTYdxcQg2Xa5ptcJqF6HVCFg2ORWCII84r3dlIxEREfmTT0GdL37xi7jhhhswfvx4TJgwAU888QRiYmKwf/9+dZ+oqCikp6erHyaTSX1s+/btKCwsxKZNmzBr1iysXLkSjz/+ODZu3AibzbeGekRERETkP31l6lxeftUdNajjQzBGkiQ0uRorp5sisPHO2Zg/OhF2p4R/HSnv93HChTLOPCchEqYIPUYlRQMAzlQxW4eIiPxvwD11nE4nXnnlFVgsFuTn56vbN2/ejOTkZEybNg3r169He7u7+/++ffswffp0pKWlqdtWrFgBs9nsle1zuc7OTpjNZq8PIiIiIvIPh1OE1S4C6KX8yqhX/91Xpk55Uwesdme/zt3W6YDdKQEAEqIM0Gk1uGtBHgDg7WOVEEXJa/9OhxN/3nkeh0ua+nX8YCt2Tb4alSwHcyalxwLgBCwiIgoMn4M6BQUFiImJgdFoxLe//W28+eabmDJlCgDgzjvvxKZNm7Br1y6sX78eL730Eu666y71udXV1V4BHQDq59XV1T2ec8OGDYiLi1M/cnJyfF02EREREfXA0ukOwPRUfmXqR0+dpGgD4qP0kCTgYp2lX+dWSq8i9VpEGuRx6tdNTkOMUYfypg4cLvUO3vxzbwl+v+McHt9a2K/jB1uJq5+OkqEzKV3OWj/NTB0iIgoAn4M6EydOxLFjx3DgwAF85zvfwT333IPCQvmP6v33348VK1Zg+vTpWLNmDf75z3/izTffRFFR0aAWuX79erS0tKgfZWVlgzoeEREREbm12eTSK4NOA4Ou+7eHXo2Seyi/EgTB3Sy5nyVYSlDHc0R6pEGLFVPTAQBvHa1Qt3c6nPj7pxcBABXNHf06frAp5VejlUydDDlThxOwiIgoEHwO6hgMBowbNw5z5szBhg0bMHPmTPzpT3/qdt/58+cDAC5cuAAASE9PR02N9yQD5fP09PQez2k0GtWJW8oHEREREflHm7X3fjqAd0+dtB7KrwBgnI8TsJR+Op5BHQD48hVZAIB3C6pgc8ilYf8+UoEas9xwuKGtEw6n2K9zBJMy+Uopv5qSIb9vvVDbBnsYrpeIiIa2AffUUYiiiM7O7rv5Hzt2DACQkSGPc8zPz0dBQQFqa2vVfXbs2AGTyaSWcBERERFRcPXVJFl+zN1TJ83US1DH1VenqJ+ZOg1tclAn4bKgTv7YJKTGGtHcbseec3VwihKe3ePO/hYloMESXoM2RFFCSYPcU2e0q/wqKz4SMUYdbE5RzeIhIiLyF5+COuvXr8fHH3+M4uJiFBQUYP369di9ezfWrFmDoqIiPP744zh8+DCKi4vxn//8B2vXrsWiRYswY8YMAMDy5csxZcoU3H333Th+/Di2bduGRx55BOvWrYPR2H1tNhEREREFVl/jzAF3pk60Qdtr8EcN6viaqROl99qu1Qi4aWYmALkE6/2TVShuaEd8lF7N6qkxW/t1jmCpMlvR6RCh1wrIjJcDXxqNgInpLMEiIqLA8CmoU1tbi7Vr12LixIm49tprcfDgQWzbtg3XX389DAYDPvzwQyxfvhyTJk3Cj370I6xevRrvvPOO+nytVoutW7dCq9UiPz8fd911F9auXYvHHnvM718YEREREfWPO1NH2+M+SlCnt9IrAGpPnYv1Fjgvm1zVnUaLHQCQGN31Bt/NrhKsD0/X4Omd5wEA9+SPQk5CJACopVjholgZZ54YBZ3W/TbbPQGLzZKJiMi/er7N0o3nnnuux8dycnKwZ8+ePo+Rl5eH9957z5fTEhEREVEA9af8anKGCRoBuCInoddjZSVEwqjToNMhoqyxXe0t05NGixyYSYzWd3lsaqYJ41JjcKG2Dedq2hCp1+LehaNwqtIMoCXsMnXUJslJ3l/z5AxlAhYzdYiIyL8G3VOHiIiIiIY2pVFyb+VXE9JicfBn1+HJW2f0eiytRsAYH5olK5k6l/fUAeRpWkrDZAC4Y14uEqIN6kj12tbwzNTJ6xLUcWXqcKw5ERH5GYM6RERERCOc0lPHc8JVd5JijNBqhD6P50uzZKWnTlI3QR0AuGlmJrQaAQatBt+4ZjQAd6Pm2jDL1FEmX41OjvLaPiFNDupUm63qCHciIiJ/8Kn8ioiIiIiGnzabK1PH4J+3hr6MNW9yBTkSoroP6uQkRuGl++bBqNMgM17upaNk6oRr+dXlJWexEXqMTYlGUZ0Fn19qxBempYdieURENAwxU4eIiIhohOtP+ZUvxqbKQY0LHpk6nQ5nt/sqY8kTe8jUAYCFY5MxJy9R/TzVlakTTo2SnaKEssYOAMCopK59hK4alwwA2FtUH9R1ERHR8MZMHSIiIqIRrr/lV/2llF+drW7Fg1uO4FSlGcUNFtwwLQMb18xW93M4RbR0KNOveg7qXC4t1lV+1Ro+mTqVzR2wOUUYtO6MIk9XjUvGP/eV4LMLDOoQEZH/MKhDRERENMK1dcpZNP7K1BmdHA2tRkC7zYmtJ6rU7R+eroEkSRAEuS9PsyugIwhAXGTX6Vc9SXWVXzVYbLA7Rei1oU8+V/rp5CZFddt3aMGYJGgEoKjOguoWK9L7GA1PRETUH6H/C0hEREREIdXWKQdX/BXUMeq0eOxLU3HTzEz8+AsT8fzXroRGADodIura3CVTStPguEg9dD4EZhKjDNBpBEgSUN8WHiVYyuSr7kqvAPlrnJ4VBwDM1iEiIr9hUIeIiIhohLO4MnVi/RTUAYA18/Pw9B1X4IEl47B0Yioy4uSSpPKmDnWfxn700+mORiMgNVZplhweQR3l68pNjOpxH6WvDoM6RETkLwzqEBEREY1wSk8df2XqdCcroWtQR5l8ldjD5KveuJslh0dfHWUd6XHGHvdRgzpF9ZAkSd1e1tiOtf/4HDtP1wR2kURENOwwqENEREQ0wrWqQR1twM6R7QrqlDW2q9uUyVcJPmbqAO6x5rVhE9SRM4bSTD33ypmTlwCjToMacyeK6izq9se2FuLjc3V4cV9JwNdJRETDC4M6RERERCOcOv3K2P9mxb7KSZDLkvyWqRMbXmPNa1yTuJR1dSdCr8XcUQkA3CVYh0uasKNQztBptITH10JEREMHgzpEREREI5hTlNBuU6ZfBT5Tp7zJnanT2O4K6sQMIlMnTMaa16qZOj2XXwHAwrHuvjqSJOE3H5xRH2uy2AO3QCIiGpYY1CEiIiIawSw2h/rvmIjA9dTJ7iZTp9EvPXVCn93S1ulAmyvbKbWX8isAuNrVV2ffxQZ8dKYWn19qhGvCu/r9ICIi6i8GdYiIiIhGMKX0Sq8VYNQFPlOnoqkDoig3CW4cVE+d8GmUrPT1iTHqENNHs+lpWXEwRejQanXgx2+cAAB89cpcAECH3YkOV9YUERFRfzCoQ0RERDSCtVkDP/kKADLiIqDVCLA5RdS1ydk1Ta7yq6TBNEpuDX2mjpItlNpH6RUAaDUC8scmAZAbRccadfjxiokwaOW35UpJGhERUX8wqENEREQ0gillQ31lmAyWTqtBRpycXaNMwGpsG0SmjqshcaPFBptD9NMqB0bp65PWS5NkT8pocwD41uIxSIg2ICFablLdxBIsIiLyAYM6RERERCOYpVMu9wl0UAfwbJYs99VRGyUPoKdOfJRezW5RMn9CRSkB66tJsmLJhFTotQLSTRH42lWjAQCJ0fJzGxjUISIiHwT+rzcRERERha22TnniUqDLrwB5rPl+NKK8qR0dNiesdjnDZiDTrwRBQEqsERXNHagxW5EVH+nv5fabe/JV/zJ1cpOi8M53r0Z8pEH9vicyU4eIiAaAmTpEREREI1hbUDN13BOwGixyIMSg1SDaMLAGzWpfnRA3S65pVXrq9C+oAwCT0k1Ij3Pvn+DKVuIELCIi8gWDOkREREQjmCVIPXUAd/lVWVM7mixyhlBCtB6CMtPbR2lhMtbc1/Kr7ijNohnUISIiXzCoQ0RERDSCBatRMgDkJLozddR+OtEDD4SEy1jzWjWo0/9MncspzaI5/YqIiHzBoA4RERHRCKYEdYLRU0fJ1Kls7kC9q2RJ6SUzEMoI8VBm6kiSpJ6/v9OvupPoCuqwpw4REfmCQR0iIiKiEcxdfjWwvja+SDNFQKcRYHdKOF1lBuDuJTMQqa4gijJSPBRaOx3osMt9iVIHUX6lBHU4/YqIiHzBoA4RERHRCNZmdQV1IgKfqaPVCMh0Tak6UdECwB3MGAh3o+TQZeoopVdxkXpE6AceGFPGujNTh4iIfMGgDhEREdEIFszyKwDISZSDOif9EtRx9dQJYaaOUnqVGjvwLB3A3VOniT11iIjIBwzqEBEREY1gFlvwGiUDQHa83Cy53SaXLA0qqOMqv2put8PqKoEKtho/NEkG3NOvmtrtEEVp0OsiIqKRgUEdIiIiohFMLb8KVlDH1SxZMZieOqZIHYw6+e1sXWtoSrDUTJ1B9NMBgHjX98EpSjBb7YNeFxERjQwM6hARERGNYMEvv4ry+jxpEJk6giCoGTKhapbsr0wdg06DWNf/QSP76hARUT8xqENEREQ0grV1hjhTZxBBHcDdyyZUY82VYFLaIHvqAEBijPy9YFCHiIj6i0EdIiIiohHM0in3ogleUMc7U2cwPXUAj2bJ5lBl6nR6rWMwlFI0BnWIiKi/GNQhIiIiGqFEUVIbJQer/Co11giD1v0WdDA9dQB3L5vqkAV1rK51DD6ok8gJWERE5CMGdYiIiIhGqHa7E5Jr0FJsRHCCOhqNgCxXCVasUQeDbnBvR9OVnjohKL+SJEk9b9ogGyUD7qBOo4WNkomIqH8Y1CEiIiIaoSyufjpajaBOkQoGpa/OYPvpAEB6nBzUqWrpGPSxfNXSYYfNKQIAUvzRU0cN6oSmPxAREQ09DOoQERERjVDq5CuDFoIgBO28SlBnsP10ACAjTj5WdUvwy6+UfjqJ0QYYddpBH8/dU4eZOkRE1D8M6hARERGNUG1WOagTG6EP6nmVZskJUYM/b4aaqWOFpNSSBYnaT8cPWTqAe7w7e+oQEVF/MahDRERENEIp5VfRxsFnmfhixdQ0TEiLwc1XZA36WEqj5E6HiOb24Ga4KEEdf0y+AtzlaA2cfkVERP0UnI54RERERBR2lPKrYI0zV4xLjcX2hxb75VhGnRbJMQbUt9lQ1WL1S5+e/qpt9V+TZABIjJYzl5oY1CEion5ipg4RERHRCKX21AlyUMfflGbJ1eauzZKfeLcQ33rpEJyi/0uz/J2pkxgtB4cY1CEiov5iUIeIiIhohLKEKFPH39JNcrPkqsuaJXc6nPj7p5ew7VQNTleZ/X5etaeOv4I6rkbJrZ0OdDqcfjkmERENbwzqEBEREY1QrcMkqKM0S758AlZZYweU3snnalr9fl5l+lWanxolx0booNXIU8iC3R+IiIiGJgZ1iIiIiEYoyzArv7o8U6ekwaL++1xNm9/PW+vnTB2NRvAYa84SLCIi6huDOkREREQjlKVTLvEZrpk6JQ3t6r/P+zlTRxQlvzdKBtzNkhnU6b8OmxMdNparEdHI5FNQ55lnnsGMGTNgMplgMpmQn5+P999/X33carVi3bp1SEpKQkxMDFavXo2amhqvY5SWlmLVqlWIiopCamoqHn74YTgcDv98NURERETUb61WV/lVxNAO6rgzdbwbJXtl6tT6N6jT2G6DQ5QgCEByjP+COszU8c35mlYs+u0uXPv73bA5xFAvh4go6HwK6mRnZ+PXv/41Dh8+jEOHDmHZsmX40pe+hFOnTgEAHnroIbzzzjt4/fXXsWfPHlRWVuKWW25Rn+90OrFq1SrYbDbs3bsXL774Il544QU8+uij/v2qiIiIiKhPlc1yECTFj0GJUMiIczdKliT3lKuSRnemTlljh1pu5g9Kk+SkaCP0Wv8lvye6RrI3tTOo05eLdW248+8HUNfaicoWKyqau04/IyIa7nz6C/TFL34RN9xwA8aPH48JEybgiSeeQExMDPbv34+WlhY899xzeOqpp7Bs2TLMmTMHzz//PPbu3Yv9+/cDALZv347CwkJs2rQJs2bNwsqVK/H4449j48aNsNn4h4uIiIgomC7UyX1mxqXGhHglg5Pu6mnTbnOqzZ8BoNSj/AoALtT6r69OratJcqqfmiQrlKBOQxvfG/emtKEdd/5NDugoyhrbe3kGEdHwNODbCk6nE6+88gosFgvy8/Nx+PBh2O12XHfddeo+kyZNQm5uLvbt2wcA2LdvH6ZPn460tDR1nxUrVsBsNqvZPt3p7OyE2Wz2+iAiIiKigWvpsKsXxGOHeFAn0qBFfJTci0bpq+MUJZQ1yRf5eUlRAPw7Aau2VT6PP/vpACMnU+e9gio8vfP8gEqmKpo7cOff96PabMX41BjMzo0HAJQ3MVOHiEYen4M6BQUFiImJgdFoxLe//W28+eabmDJlCqqrq2EwGBAfH++1f1paGqqrqwEA1dXVXgEd5XHlsZ5s2LABcXFx6kdOTo6vyyYiIiIiD0rWSkZcxJBvlAy4s3WUCViVzR2wOyUYtBosGp8CADgfkEwd/0y+UoyEnjodNid++NoxPLXjHO5/6RCsdt+aHD/yZgHKmzowKikKm78xH9Oy4gBADeIREY0kPgd1Jk6ciGPHjuHAgQP4zne+g3vuuQeFhYWBWJtq/fr1aGlpUT/KysoCej4iIiKi4a7IFeAYmzK0s3QU7glYcraGMvkqJzESE9NjAfg3U6euTQ7qpPi5/CopZvgHdT67UA+rXc7Q2X22Dvf843O0Wu39fv7JSjlr//dfmYlUUwRyEuRMLGbqENFI5HNQx2AwYNy4cZgzZw42bNiAmTNn4k9/+hPS09Nhs9nQ3NzstX9NTQ3S09MBAOnp6V2mYSmfK/t0x2g0qhO3lA8iIiIiGrjh0k9Hke7RLBkAShrlyVd5SdGYkCYHdc7XBCBTx8/lV8MlU6fVasfGXRdQa7Z2eWznGfn9f/6YJMQadThwqRF3/f0AmvtRcma1O9WywdHJ8s9udoL8f8+eOkQ0Eg26Vb8oiujs7MScOXOg1+uxc+dO9bGzZ8+itLQU+fn5AID8/HwUFBSgtrZW3WfHjh0wmUyYMmXKYJdCRERERP2klF8N9X46Cnemjiuo0+DupzMhTf4aK5o70OanCVhKT51ANUoe6j11/rmvBL/ddhbr/13gtV2SJOw8LV8LfHvJWGz55gIkROlxvLwFX3vhoNf0su4oQbtIvRYJrj5KOYnM1CGikcunoM769evx8ccfo7i4GAUFBVi/fj12796NNWvWIC4uDvfddx9++MMfYteuXTh8+DC+9rWvIT8/HwsWLAAALF++HFOmTMHdd9+N48ePY9u2bXjkkUewbt06GI1De5QmERER0VCiBHXGDZPyq/Q47546JQ2uTJ3EKMRHGdTgy3k/lWDVtirlV/7tqaMEdRottj4DHOFM+T7vOluLqhZ3sOVkhRm1rZ2IMmixYEwipmfH4bVv5SNSr8XR0mYcuNTY63ErXIGbrIRICIIAwJ2pU9/WiQ6bb/15iIiGOp+COrW1tVi7di0mTpyIa6+9FgcPHsS2bdtw/fXXAwD+8Ic/4MYbb8Tq1auxaNEipKen49///rf6fK1Wi61bt0Kr1SI/Px933XUX1q5di8cee8y/XxURERER9chqd6pNZYdL+VWPmTrJ0QCglmD5o6+OJElqUMffmTpK+ZXdKfktqygULrm+/6IEvH6oXN3+4Wm59Oqa8ckw6rQAgPFpsbj5iiwAwEv7S3o9bkWzfNys+Eh1W1ykXm32rTxORDRS+DTq4Lnnnuv18YiICGzcuBEbN27scZ+8vDy89957vpyWiIhoRKk1W/Gf45X4ypU5MEXoQ70cGoYu1lkgSfLFcLKrMe9Ql6Fm6nRAkiR3UMdVmjM+LQafXqjHOT/01TFbHeoobn83So40aBGp16LD7kSTxY7YIfoaoGRKAcCrB8uwbuk4aDUCPjojl15dO9l7Iu5dC3Lx8uel2HayGrVmK1JN3WdAKZk6mR5BHUEQkJ0QiTPVrShr7MC41Fh/fzlERGFr0D11iIiIyL/+uucifvXuaTz/aXGol0LDlGeTZKWEZahTGiWbrQ6UNLSjw+6ERgCyXZOR/JmpU+fqp2OK0CFCrx308S6nlGA1WDr9fuxgaG63obldnmYVG6FDRXMHPjlfhxqzFQUVLRAEYOnEVK/nTM2Mw5y8BDhECa8c7HnSbXmzHNRRSq4U2eoELGbqENHIwqAOERFRmFEasB4rawrxSmi4Gm79dAAgxqhDrKsE58ClBgByNodBJ7/dVZol+2MClnvylX/76SiGerPkYleWVJrJiNWzswEAr3xepmbpzMyO7zbD6e4FeQCALQdK4XCK3R670hXU8Sy/AuTR9QBQxmbJRDTCMKhDREQUZsxWuY9GQYV5SDdKpfBVVDu8xpkrlGbJ+y/KzXbzkqLUx5SSnGqzFS0d9kGdJ1D9dBQJarPkwa0zVIrr3ePk75iXC0DupfPaITkD57rJqd0+b+X0dCRGG1BttuLD07Xd7lPR7G6U7ImZOkQ0UjGoQ0REFGZarfKFXH1bJ2rMQ7P8gsLbhWEe1DlwUc7UyUuKVh+Li9Qj3ZVZc6F2cCVYgRpnrkhyBXX+96PzeP1QGew9ZK2Eq2JXP53RSdGYmB6LK3Lj4RAlHC1tBtC1n47CqNPi9itzAACbummY7BQlVDXL3/sumTquIE9ZIzN1iGhkYVCHiIgozJg9sghOVrSEcCU0HDmcIi65MimGW1BHaZZc6ZqApTRJVkxIV/rqDK4ESym/8neTZMUts7MQF6lHcUM7Hn7jBJb8dje2HCgdMpl7SqbOKNfkMSVbBwAy4yIwKb3nRsZ3zsuFIACfXqhHUZ33/1NtqxUOUYJOIyDtstI3ZuoQ0UjFoA4REVGYUcqvAKCAQR3ys/KmDticIow6TZdsh6FOaZas8MzUAYAJriDW2erBZerUtSnlV4HpqXPN+BR89pNlWL9yEpJjjKho7sBP3yzA0bLmgJzP35SeOqNc5W83zshQ+x1dOzmt1+bcOYlRWOZqorzlQKnXY8rkq/S4CGg13sfIdvXUaWq3D+lR8EREvmJQh4iIKMwo5VcAM3XI/5TSqzEpMdBohsfkK4WSqaPw7KkDuCdgnShvRrtt4Bf+7kbJgcnUAeTGz99aPBaf/r+lmJkdBwAobRgaWShK+ZWSqRNl0OHbS8YiNkKHr87L6fP5t86Rmyt/dqHea3tFD02SAcAUoUdcpDz+ndk6RDSSMKhDREQURjodTljt7v4ZJysZ1CH/8hxnPtyk9xHUmegq+zlS2oxZv9yBu/5+AH/7+CJa2n1rSKz01AlU+ZWnCL1WbfJc2RL+/WI8x5l7fv/XLR2Hgl+swNTMuD6PMSs3HgBwvrYNVrtT3V7e1HNQB/CYgMW+OkQ0gjCoQ0REFEZaPUqvBAGoMXeqF5BE/jAcx5krPDN1UmKNiDLovB6fkR2H7ywZi+yESNicIj69UI8n3juNX7xzyqfzuKdfBab86nLK11XdEv6vBZ7jzC///vdXuikCyTEGOEUJhVVmdXtlD5OvFNnx7KtDRCMPgzpERERhRAnqxBp1GOu66PalBKvRYsPP3z6pNsIlutxwnXwFABkm98X+qMuydABAEAT8vy9Mwic/XoqdP1qMdUvHAgD2FtX3uwmx1e5Uf0+DkakDuDOQKpvDP6hT0uAeZz5QgiBgWpac0eP5+tdb+RXATB0iGpkY1CEiIgojyuSr2AgdpqsXNebenuLlH59ewov7SvDEu4UBWR8NbZIkoWgYB3VMkTpE6rUAgNzEnoMKgiBgbEoMHlw6HjqNgBpzpzoxqy91riwdo04DU8TAMlF8lRnvytQxh3+wQgkojx5EUAeA+vpXUO4R1GnqI1OHE7CIaARiUIeIiCiMmF1Nkk2RekzNNAHoOgHr759cxPOfXer2+UqpwmcXGrx6URABctlQa6cDGgEYldw1k2WoEwRBLVXqLlPncpEGrfp7drikqV/nUMohU03GXqc4+VO6KwOpaghk6ijjzPMG+fOlZOoor3+SJPU/U6cp/INfRET+wqAOERFRGFHKOkwReo9MHXdQZ29RPX717mn88p1C1Ji7XuCddgV1OuxO7LvYEIQV01CilF7lJUXDqNOGeDWBMdo1cWmCqylyX2bnJQAAjvQ3qGMObj8dwJ2p02CxhX2wVump469MHaVZcnO7He02+WvP7CGow0wdCqVPCi5i+a/ewu7jRaFeCo0wDOoQERGFEc/yq6mui5qqFivq2zohSRJ+t+2suq9nWQIgT52p8igh2XWmNggrpqHkfE0rAKj9moajX9w0FU/eOgPXTU7r1/5zXEGd/mfqKEGd4PTTAYC4SD0i9PLbdiWoFK6K/dBTB5CbQydFy82ST1eZ1Syd5BgjIvTdBySzXWVZrVaHzxPNiAZDFEX8+I3jONemx18+ZPkzBReDOkRERGHEs/wqxqjDGFfWwcmKFuw6W4sjpc3qvpeXZZ2uavX6fOfp2n43f6WRQfkZmZzRvyyWoSgnMQpfmZsDraZ/pVFKUKewyox2m8PrsXeOV+Lnb5+E3Smq24I5zlwhCAIy4+SARTiPNfccZz7Y8j6vZsmVZvc48x766QBAlEGHpGgDAKCM2ToURP/ceQxVnfLPXrnZ0cfeRP7FoA4REVEYcZdfyQ1Yp3k0C/3dtnMA5HG/QNegzplqufTq6nHJMOo0qGjuwHlXuQ0RAJx2/YxMzjCFeCXhIyMuEplxEXCKEo6XuX+n2m0O/ORfJ/DivhJ8WFijbneXXwUvqAO4J2CF81hzpfQqtZtx8gOhlqCWt6jjzLN7KL1SZCcqJVjhG/yi4cXpFPGXj0vUz+s6tRBFsZdnEPkXgzpERERhxF1+pQfgvqh5fm8xCqvMiDXq8MSXpwGQgzqemThKP53ZufHIH5sEQM7WIQIAh1PEmWo5U2cKgzpe1L46pe4SrA9OVsPi6uFy4FKjur2uLfg9dQCPseZhnKmjjDMflTy40ivFtCx3s3il/ErpL9QTpQSLfXUoWJ7bfhi1dgP0cEIDEXZoca68LtTLohGEQR0iIqIwYlYydSLlu9xTXRc1jRYbAOC+a0Zj4dhkaAR5tHKNR38N5YJ9UoYJ105KBQB8dMadYUAj26V6C2wOEdEGLXITh9/kq8Horq/OG4fL1X/v92g6rmTqpJiCm6mjlF+Fc6aOv8aZK5RMxXM1reqxe5p8pchJYKYOBY/d4cSze+XXipVjjEjUy3/DD1+oCuWyaIRhUIeIiCiMtCo9dVyZOspFDQAkROlx39WjEWnQYnyq3BNFKcFyOEWcrVb6pZiw1BXUOVzShOZ2W9DWT+FLGXc/KcMETT/7zYwUczwydURRQnlTO/YWNUCZWH6muhVNrsBqKBolAx6ZOmE81rzEVX412HHmiqz4SCRE6eEQJewtqpe3JfR+bCVTp6yRmToUeH997yAa7AYYBCceuW0hsmLky+tT5Y19PJPIfxjUISIiCiPmDvkun1J+ZYrQq82Sv7NkrLssK9vVa8cV1CluaEenQ0SkXs7CyE6IwsS0WIgSsOcc08DJHdQZzk2SB2pyhgkReg2a2+24WG/Bv49UAAAWjk3CuFR5UtiBS41wOEU0WFyZOkEO6ihlR9Xm8M1A8XemjmezZKtd7lHSZ6aOKwvtXG0rG8VTQNnsDvzjgJyR88XxkUhNiMWYJPnnr6jOErJ1WTo6semjo2huC9/XCvIvBnWIiIjCiHv6lbvJ6BNfno4fXj8B9y4crW6brjZQbgbg7qczMT1WnfqzbLJSgsW+OuSefDUlI66PPUcevVaDmdnxAIDDJY1q6dWtc7KxYEwiAODApQY0WGyQJEAjAEnRQc7UMYV/+VWJn8aZe5qe5f3z2tv0K0DuKWbUaVDW2IFTlWa/rYPoclt2n0CT04AIwYGf3roQADA5Kx4AUBbCCVgb3vgMj2yvxKMvfxyyNVBwMahDREQURtzTr/TqtvyxSfjeteNh0Ln/bLszdcyQJEmdfOWZhbHMVYK1+2wdHE5O4hjpCiuZqdMbpVny3z+5hNLGdsQYdVgxNR0LxshNx/dfbESdq/QqOcbY75Hp/pLhKr+qb7Oh0+EM6rn7o6XdjiY/jTP35BnUiTXqEBep72VvOcvxuslpAIC3jlb4bR1El/vwVCUAYH6GDkkmOZA5a7T8sxfKCVinq+Wpl0X14RsAJv9iUIeIiCiMuKdf9T4OeEqGCVqNgPq2TlSbrWoWhueo6ity4hEfpUdLhx1HSpsDtmYKf7WtVtS3dUIjAJPSOfmqO3Ny5aDO+Vr5gmjV9AxEGXSYN1rO1DlTbcb5Wvn3LDXITZIBID5Kjwi9/Na9pqWzj72Dr9iVpeOvceYKz75ifWXpKG6alQkAeOdEJZwiS7DI/0RRxIk6+SbMdVMz1e0zxmSEfAJWtUUO+jZ08GbOSMGgDhERUZhwihJaO5XpV73fjY7QazHe1eujoLwFZ5QmuB4X7DqtBksmpAAAdp7mFKyRTAn6jUqORqRBG+LVhCclU0dx69xsAPLo8rEp0ZAk4N0TVeq2YBMEARmuCVjhONZcGTme4+fJatkJkYiPkl8P++qno1gyMQWmCB1qzJ04cKmh7ycQ+ejIhQqYnXpoIOKL8yep2yMM+pBPwGrslC/xm+281B8p+D9NREQUJto63TX4fWXqAO6yhE8v1KPS1Wdj0mWlNddNkVPBdzCoM6KdVpskM0unJ4nRBrUp+aikKMz1CPLMd5VgKU3HU2KCn6kDuEuwwrGvTpVrTcoa/UUQBPW1LrOfQR2jTosbpmcAAP5zrNKv6yECgP8cvAAAGB3tRHyM98+lMgGrMAQTsBrMFnRI8vsHq6Rjs+QRgkEdIiKiMKGUXhl1Ghh1fWdTKH113nZdtGTFR3r14gGAxRNSoNcKuFhnQVFdm59XTEOF0k9nCoM6vbp6fDIA4PYrcyEI7p45Sl8du1Mu5QlF+RXgMdY8DDN1qlyZOv4O6gBQe+TMdzWt7g+lBOu9gqqw7EFEQ9u+S/LkyQV5XV9TRyfJQZ4LIZiAdarY+wbO2RCVgFFwMahDREQUJtyTr3ovvVIod69bXMGg7rIwYiP06gXph4XM1hmplEwdBnV69/CKifjb2rm4f9EYr+0LRnsHE1KDPM5ckRkXvhOwqszymtLj+pdN44t7Fo7CiV8sx40zMvve2WX+6CSkmYwwWx3YfZYXtuQ/re1WXGyTb7zcOHdsl8enZMlZfqGYgHWmwrvc8EJl8LOFKPgY1CEiIgoT7slX/WsyOtnVLNn9efdTja53lWB9yBKsEclqd+JivXzHeEomgzq9iY3Q4/opaV0mW6WaItTSLABICUFPHcCdqVMVhkEdJdCUGYBMHQBdshD7otUIuGmmHARiCRb503sHz8EJDWI0dsyflNPl8ZkhnIB1sdbs9XlxnbmHPWk4YVCHiIgoTLgnX/Xv4iVCr8WENHcgp6d+KUrpwuGSJjS0hd/UHAqsczWtcIoSEqMNIcswGQ6UvjpA6MqvMtSgTviVXylBnfQABXUG4kuzsgDIAe1WVyYk0WBtLygHAExL1kKj6Xo5PbObCViiKOIrv38Hy3/1Fjo6A/ezWNbo/dpQ0dQesHNR+GBQh4iIKEyYrf2bfOVpepY7kDMpvftMncz4SEzNNEGUgI/O1A5ukTTkeJZeefaJId8s8OjnErpGyeFZfuUUJVSblUbJ/i+/GqipmSaMSYlGp0PEtlPMVCT/OFYt3xxZNjm928c9J2AdKaoGAPx922F8XqfBuTY9/rP/dMDWVtkqnzdZbwMAVLfaAnYuCh8M6hAREYUJ5U5yf8uvAHdfnUi9FnlJ0T3up2Tr7GBfnRFHaZLcU3ke9c+CMUnQagRE6DVICVHGk5KpU99mC6vmv/VtnXCKErQaIWTfm+4IgoBVrilYe4vqQ7waGg4KS6rR4DBAgISbF0zqcb9M1wSsU2UN6Oi0Y+OnFepjSqZPINS74r3TUw0AgDpL+LxOUOAwqENERBQmzB3yHbb+ll8BwKIJKYjQa7B0UkqXPiCelL46n5yvh9XON3kjyemqVgDspzNYaaYI/N/dc/Ds3XMRoe97Ol0gxEfpEaGX377XtIRPKaXS4yct1tjr61Ao5CRGAQAa2pixQIP39ufnAQDZEXakJvQcKB/jMQFrwxufosWphwB5ep6S6eNvHZ12tInyTaFFE+UsoiZbeP0+UmAwqENERBQm1EydyP5n6uQlRWP/+mvxh9tn9brf1EwTMuIi0GF38o71CCJJklp+1VPPJeq/ayenYfGElJCdXxAEtbwpnMaaK+PMw6mfjiIpWs5YaLQwqEOD91mRPE1qXm5Mr/tNyowHAFxocuDVk/Jr8FcnR0KAhAaHAYUl1X5f2+nSGkgQoIMTi6flAQAsog5WG/tJDXcM6hAREYUJdaS5j1Ne4qMMMOp6zxwQBIElWCPQweImtHY6YNBqMDal94sQGhrSTXLgJJz66iiZOuHUT0eR5Op/xCbxNFhNre041yxnvtxwxehe971ijJwp0+AwoFPSIVlvwy/vXIzsCPnvvJLx40+ny+QbNgl6J/LSEqGFCAkCLlTwRs5wx6AOERFRmFDKr3zpqeML92jzWoiiFJBzUPg4VNyI+144CABYOikFei3f9g0HGfHhN9ZcaZIczpk69RYbJImve9S7fYXFuO9/31OnVnl68LmPYIMWJq0dS2aM6fU4M8dkqOVWAPDQ0tEw6HVqhs+nFxr9u3AARTUtAIDUKA20Wg1itXKp9YWqns8liiJ++s+P8Pz2w35fDwUP/7oTERGFidZOpfzKt0yd/po/JhFRBi3qWjtRVNcWkHNQeNh7oR53P/c5WjsdmD86Eb//yqxQL4n8JBzHmrszdcIwqBMjB3VsDhEWG/uJUe9+9fZx7CyX8NW/forK+hZ1++aPjuGzajlL5xcrx0HbR5BcnoAl/00fE23DHUtmAHBn+JxrEfw+2ry4wQIAyDTJP/OJEXJQ6VJtS4/Pef2Tk9hS2IFffVSJ2qZWv66HgodBHSIiojDhbpQcmEwdo06LnAS5aahyZ52Gh+oWK05WtOCT83X4575ifO2Fg+iwO3HN+GS88LV5iDEG5meKgk8pcQqnTB2lp044ll9FGXSIdDW2ZgkW9UYURVyU29+g0WHAbf/7EcwWK6oazfifD4sBAMuyBdxy9bR+HW/VxHgk6Gx4YvVsaDTyZfeSGWMQKThghxbbDp/z6/orzXLfqLwk+e98SpT8ul/mCvZ059+HSgAATmjw3IfH/LoeCh7+hSciIgoTA+2p44tUkxFna1pRY+bFzXAgSRL+6/UT+NeRriNyr5ucho1rruiz3xINLeGcqROO5VcAkBhtQEVzBxosNuQlRYd6ORSmCktq0CHpoIEIvSCiwmrAbX/8ABE6ARZRj0SdDX/6+sp+H++xu5biscu2abUaTEkUcLgB+OB4GW5eONVv669rlzNzxmckAAAy4yKAOhsqewgAW6w2HK13l4htPVWP9bf5bTkURMzUISIiChOtVldPnQCVXwFAaqx80VXDTJ1hYcvnpfjXkXIIApBmMmJSeiwWjk3Cg0vH4Zm7ZjOgMwwp2TDh0ihZFCX19SQzPjyDOsmuEiyONafe7CqQs1YyjA48dfMEaCHibKsex5t0ECDht6unIzZq8D/jygS9I5X+C8w6nSKaHXK+xpRc+fg5roydOkv3ZYevf3ISNkmLSMEBARIqrAZ8fqbUb2ui4GGmDhERURiQJAnmDjlTJ1DlV4B84Q8AtQzqDHkXalvx+NZCAMBPV07GNxf13riThgclU6e+zYZOhzPkgbt6SyccogSNAKS4Jk2Fm0R1rDkzFKlnh0saAAATk41YNX8y6swd+OXOSkgQ8KVxBlx7xTi/nOfL+ZPw1L7PUGs3oKiyHmMzkwd9zKKqBjihgQAJE7PloM7o1HgAzWi0dt8g/O2j5QC0WJilR4XZhjNmPf6xqxDzJuUOej0UXMzUISIiCgMddiccrolUgSy/SnONQ65t5cXNUNbpcOJ7Lx+D1S7imvHJuO/q3sfr0vARH6WHQSe/ha8Lg9/jqmY5QJwaGwFdmE5YU8aa1zNTh3pxtl7++Zg7OgkAcO/1s/Hrlbm4e1oUfr12qd/Ok5OagAyjfBPnzX1n/XLMwtJaAIBJ64BBL98YGp+ZCAAwO3UQRdFr/+a2DhS4hmJ9NX8cbp2dDQD4pMwKm93hlzVR8ITnKy8REdEIo5ReaTUCogyBu/OuZOqw/Gpo+922syisMiMhSo/f3TYTGo0Q6iVRkAiCgNRY5fc4DII6Yd5PB3BPwGq0MKhD3Wttt6K6U76hsmR6nrr99sUz8PhdSxFh8O/Nliuz5NKoTy7U++V456uaAQApHr3K5QwgCU5oUFrb7LX/lt0n4HCNZ7/2inFYs3QmIgQHLKIer31S4Jc1DVZZbRMsVv7O9odPQZ0NGzbgyiuvRGxsLFJTU3HzzTfj7Fnv6OKSJUsgCILXx7e//W2vfUpLS7Fq1SpERUUhNTUVDz/8MBwORgSJiGjk8iy9EoTAXaCnmpSeOqG/GKSB2XuhHn/75BIA4MlbZ6rZVzRyqBl33QRnT1W2YPUze7HXTxeLfal2NWwO1346AJAUrfTU4esede/jgkuQICBK48CknNSAn+8Ls+TA0ekmAVbb4EebF9fL48gzYt3Bp0ijHtEa+Rr7fIX368G7BdUAgKtzIqDRaBBp1GNhpvzc1z4PfV+df316Etc89Rlm/uIDXP+rt/DISx/hAPv99MinoM6ePXuwbt067N+/Hzt27IDdbsfy5cthsXiPSfvmN7+Jqqoq9ePJJ59UH3M6nVi1ahVsNhv27t2LF198ES+88AIeffRR/3xFREREQ1AwJl8BUO/w17ZaIUnd19lT+JIkCb/dLt9Qu2NeLq6fkhbiFVEo9JZx95/jlThc0oSX9pcEZS1qpo4p/MaZK5Ki5e9XAzN1qAefna0CAIyOhTp+PJCunz0ekYIDNmjx9r7Tgz5eRbMcsMxN8P49TDDIf+eLaprVbXXNbTjdIn+Nd149Ud1+7+JJAICTzRpU1rcMek2D8Y9PigAIcECL8216bDrVgdtfKMDDz38Y0nWFK59+Yj/44APce++9mDp1KmbOnIkXXngBpaWlOHz4sNd+UVFRSE9PVz9MJpP62Pbt21FYWIhNmzZh1qxZWLlyJR5//HFs3LgRNhtfaImIaGQyq5OvAjvDIMUV1LE7JTS1D/7uIAXXoZImHC1thkGrwUPXjw/1cihE1Cl23fTUUXrcnKo0+/28lk4Hypvavc/nCupkhHH5VSKnX1EfCirlTJfpmTFBOZ9ep8UVqXKp9TtHB5+BUm2Re+aMS4/z2p4SJZ+jtL5N3fbSruMQoUGS3oaFU9ylZotmjEGawQYRGvx9x7FBr2mgKuqb1aDTI0vScNfUSIyNlt+vvH62E396e1/I1hauBhWGbGmRI3iJiYle2zdv3ozk5GRMmzYN69evR3u7+8V/3759mD59OtLS3HeWVqxYAbPZjFOnTg1mOUREREOWWn5lDGymjlGnVSfB1Layr85Q8+yeIgDA6jlZ6oU9jTzu8quuQR1l1HlpY7uaAegvP3j1GJb+bjdOVrjv4ivnywjj8qtkNVOH5VfUvYtmOaNl4YSMoJ1z1Uy5OfHRWgecTrGPvXvXaJeDN5Oyk7y2p5vkv/cVze7x6e+fqgMALB4V0yUr6bpxclBo76WmQa1nMJ7bIQed0gw2fOMLc/Gru5dh53/fjBV58lr/tK8e//r0ZMjWF44GHNQRRRE/+MEPcNVVV2HatGnq9jvvvBObNm3Crl27sH79erz00ku466671Merq6u9AjoA1M+rq6u7PVdnZyfMZrPXBxER0XASrEwdAGHVZJX670JtKz48XQtBAL5xDceXj2SeZZSXq2xxX7yd9mO2jiRJ2F/UALtTwr+OlKvbq8zy+YZCpk6jxcayU+ribFktLKIeAiQsmRG819abF06BAU5YRD22Hzk34ONUNZphk+SgztS8dK/HshPkhsy1bXKA941PCnC+Tb55dPfiyV2ONSEjHgDQ3MMY9GD44Iw8lmvFhHiv7X+5fwVmJTggQoP1Wy9iX2Fx8BcXpgYc1Fm3bh1OnjyJV155xWv7/fffjxUrVmD69OlYs2YN/vnPf+LNN99EUVHRgBe5YcMGxMXFqR85OTkDPhYREVE4ag1STx3AfZefE7CGlv/7+CIA4PrJaRibEpwSAQpPPf0Oi6Lktc2fJVh1bZ1o7ZSDz+8XVEMUJYiipGbqpMeFc08dOahjd0pqAJ1IsaugGACQZrDDFB284GR0hAFTXQUvbx28NODjHDhTJh9P03X9eSmxAICGDgkNZgt++b58Tb4oA7hiXHaXY2Umyn9b2hyhmah46GwZKjsNECDhG8tneT2m1Wqw+XtfQG6kDTZo8c1Nx1DdyGQPYIBBnQcffBBbt27Frl27kJ3d9YfB0/z58wEAFy5cAACkp6ejpqbGax/l8/R078iiYv369WhpaVE/ysrKBrJsIiKisGXukC80YoMQ1FHv8jOoM2TUmK1462glAOBbi5mlM9K5GyV7Z9vVWzphd7rvsBdW+e+C51KdezBKtdmKo2VNaLDYYHdKEAT360o4itBrEWOUsyA51pwud+iSPBlqYrIh6OdeMU2+/j1Q0QlR9L0E69DZMvxs63kAwKjYroGYsely1KjZocX3/7ELraIeJq0df/r60m6Pl5Mil1+1i9oBrWew/rFLbscy0eRAbmpCl8ejI4149bvXIk5rR5uox9+3Hw32EsOST0EdSZLw4IMP4s0338RHH32E0aNH9/mcY8eOAQAyMuT6xPz8fBQUFKC2tlbdZ8eOHTCZTJgyZUq3xzAajTCZTF4fREREw4k6/SoI5VdpIRhr/mFhDe5+7oBXLw7qv+c/K4bNKWJuXgLm5CX2/QQa1lJdv8MtHXZY7U51u9IkWeHPTJ2L9d7Tbt89Ua1m6aTGGqHXBn5i0GAkcqw59eBMnfwzMTsEr623XzMNWohodup9Htm9r7AEa184AouoR4rehr/et6jLPpNyUgAANkmLT6vloM/PV45DQmxUt8fMSYkHAIjQoLa5rdt9AsXpFPFxqfyacvOszB73y0g0YeUEOQNp1/nQ9f4JJz69+q5btw6bNm3Cli1bEBsbi+rqalRXV6OjQ66lLSoqwuOPP47Dhw+juLgY//nPf7B27VosWrQIM2bMAAAsX74cU6ZMwd13343jx49j27ZteOSRR7Bu3ToYjeEb4SciIgqkVqWnTlDKr3ruxxEof/vkIj45X487/7Yfx8qag3beoa6l3Y5tp6qx+YA8nvr+RczSIcAUoUOEXn4b79ksucojyAIA52ta0elwdj1AD8qb2nHzxs/w1tGKLo9drJMv8PKS5IvB909Wqc1Xw7n0SpHk6qtTzwlY5MFitaHKKt9MWTwtN+jnT4iNwniT/Dv6+r7z/X7epycv4esvHUO7pEOawYa3vr8UOd1ktiTERsEouEsOr8kAVl89rct+iuhIIwyQ11Na29zv9fjDW/sK0SbqYRCcuHvpzF73veNquR/QRYsu5OPXw4FPQZ1nnnkGLS0tWLJkCTIyMtSPV199FQBgMBjw4YcfYvny5Zg0aRJ+9KMfYfXq1XjnnXfUY2i1WmzduhVarRb5+fm46667sHbtWjz22GP+/cqIiIiGEHX6VUQQGiUHOVNHkiScq5HHxZqtDtz19wM4VNwYlHMPRZIk4Z/7irHq6U8w6/Ht+NZLh9FqdWBsSjSum5zW9wFo2BMEwT0ByyM4W+VqkjwnLwFxkXo4RAnna/p/t/3DwhocK2vG85917e9xyZWpc/eCPMQYdahqseKDk1UAgAxT+DZJVih9dVh+RZ72niqGExpECA7MGB28yVeerpsoZ9N8VtK/39WqRjO+ufkEOiQd0g02vPWDa5GVHN/j/vF6uYzKpLXj6R7KrjxF6+SgTkVDa7/W4y+v7Jdfd65M0yA6svdkj5ljM5Gqt0GCgC17OAnLp3eOfXWLz8nJwZ49e/o8Tl5eHt577z1fTk1ERDSsucuvgtcoOVg9derbbGhqt0MQgCtHJeLzS41Y+4/P8Y97r8SCMUl9H2CE2VvUgEffPqV+PiYlGvljkvCdJWOh0YSmeSWFn9RYI0oa2r2Cs+p48bhITMkwYd/FBhRWmjEtK65fxyxvkoNCp6tbYXeKXiVVF109dSZnmHDt5FS8fawSW0/IQZ30MJ58pUhSxpqz/Io8HDgv/wznxUhdxnsHyx2Lp2LjwU9RYzPg5KUqTOsjuPTfL3+KDkmHJJ0N/3noOqQmxPa6f35uNN67YMVjq8b3WHblyaQHmhxAVVPwyq+qG804Wi/HGtYsHNev51w9Kgb/Pm/DjjN1+K9ALm4ICO/iVyIiohEimOVX7nHInRDFwI8tPe/K0slLjMKLX5uHa8Yno93mxNeeP4jShvaAn3+o+dNOOQX/y1dk4cBPr8VHP1qCJ748XR1NSwR4Zty5g7OValAnAlMz5R6Upyr7X5qglFPZHCKK6twXdHaniNJG+Xd1TEo0bpguX3Q6XK8fmfFDIKjjKr9qYKYOeShz/VxnxQW/SbIiKzkeeVHyjZ1XPzvT674Fl6rwUZmcSfNf143pM6ADAH/8xnKc+tUq3Lxwar/WExehlHZ29Gv/wRJFEd/++244oEWSzoYvzJ3Qr+fdftVEAMD5Vi0aWix97D28MahDREQUBoJZfpXiCuo4RAmN7YG/wDnrCupMSItFpEGLv62diytHJaDD7sRTO84G/PxDyf6LDfj8UiMMWg3+3xcmqVlVRJdLi3UFdTzKr6pd5VcZ8RGYmiUHdXyZgKVk6gDAqQr380ob2+EQJUTqtUiLjcDiCSmINmjVx4dCTx21UTKDOuShplX+eciKD+3P8DVj4gEAB0t7D8I+8trnEKHBuBg77ljSe98ZT3qdtu+dXBJcAxuClc3753cO4FijFgIk/M/NU/qdMTV/Ui4SdTaI0ODljwsCvMrwxqAOERFRGFDKr+KCUH6l12qQ7LprXRuEvjrnXD09JqTJdxQj9Fr8/IvyHcO3j1ei0I8Teoa6P30oZ+ncfmXOkChpodBRG557/A5XNrszdaZkyCVXhZXmfmfkKZk6AHDSI8NHGWc+OjkaGo2ACL0W13r0d8oYAj+ryTHy96vRwvIrcqvvkPvN5CTFhHQd03LkUuS6jp5/Vz84dBbHm3QAJPzi5v4HdHyVrGa12QN2DsXJS1X43311AIAvjzdixdyJPj0/P0cOxm07VeP3tQ0lDOoQERGFmM0hwmqX31gGI1MHAFK7ucsfKEqT5Anp7jTxaVlxuHFGBiQJeHJb7+nmI8Xnlxqx72ID9FoB314yNtTLoTB3eaNkUZTUUqyMuEiMTYmGUaeBxeZESWPfZY7tNodXE2HPcegX6+XA7JiUaHWbUoIlny/8gzrukebM1CG3Zpvcp2x0av/6TgXKxGw5qNNs10EUxS6Pi6KIJ7YWAgDmp0i4etrogK0l1SQHSpqt/Z+cNxA2uwPfeXE/7NAiJ8KGX6/tu4nz5W5bMB4AcLpZgNkSvIme4YZBHSIiohBrtbrvhsUYgxTUUe/yB/ZNkOfkqwlp3ndC/2v5ROg0AnafrcP+iw0BXUeoXaxrw73Pf45Pz9f3uM+fP5KzdG6dkxPyUgAKf0pvLKVRcn1bJxyiBI0gP6bTajDJFUjtTzZcRZN3/4zTHhk+SpPkMSnu3+ElE1OQmxiFvKQopA+BMkGONKfLWW12WET5b+74rOSQrmVidioACU5ouh0l/o/tR1BmNUALEb/66oKAriU9Tu7fZrYFtufej1/8CGVWAwxw4q/35sOg9/39z6Lpo2HS2uGAFq99MnKnYDGoQ0REFGJmV5PkGKMOOm1w/jSr/TgCXH5Vbbai1eqATiNgTLJ3UGdUcjRuvzIHAPCbD870OWVzqJIkCT9+4wR2n63DHz881+0+h0ua8Mn5eug0Ah5glg71w+WNkqtcTZJTYyPU15EpPjRLVvrpjE+NgUGnQWunQ22OrAZ1kt2ZOhF6Ld77/jX44PuLgva6NRjK9KumdltQGsRT+LtY1QAJAjQQkZMSH9K1RBr1iNXI7wVOl9V2efy5fWUAgFVjDBiflRLQtWQmyn+rW+2Bm7b4s39+hLcuyDe0HsxPwdRR6QM6jkajwfxM+Xf7vYJKv61vqAn/V2AiIqJhTsnUCVbpFeDux1ET4EwdpZ/OqORoGHRd33Z8/9rxiNRrcbS0GdsLh2dN/FvHKnCopAkAcKS0Cc3dNKfeuOsCAGD17GzkJHLKFfVN+R1utTrQbnOgytUk2bMX05RMuaTkVD8ydcpd/XTykqIx2ZXhozzvYr2SqRPt9ZwYow6Rhv43YA0lpfzKKUpo6Qh8rxAKfxcqGwEAsVontGEQmEw0ysHG85VNXtvtDidqO+X3B9+8fkbA15GVLAeD20Vtt6VggyGKIn7w9+3YXCi/3twwSovvfSl/UMe8ZZ5cinayAbBYR2YmXuh/eomIiEY4c0fwxpkrUtV+HIHN1DlXLZdeTUzrfuxqqikCX796FADgqe3nhl22TlunAxvek3sGaQRAlICPLyvBqmvtxO6z8p1Z9tKh/oox6hDlCqjUmjvVTB3P8eJTMvo/Aau8Sc7KyU6I9AgGtcBstaO+TX6dGJ0c3ePzw51Bp4HJFTjnBCwCgOJaOYNNCaaEWnqM/PNZ0tDmtf1MWS2c0EALEZNyUgO+jrzUBACACA1qm9v62Lv/RFHEt57Zpmbo3DbRiL98+wuDPu7y2RMQrbHDBi3eGKElWAzqEBERhZgy+coUGcxMHVdQJ+CZOnJQZ3xaz5NF7l80FgatBmdrWtWMgOHizzvPo7a1E6OSonDPwlEAgN1nvFPrPzhZBVECZuXED+mLZgouQRA8miW7gzoZHuPFJ2fEQhDkwGFtH03RlZ462QmRmOoq2zpZaVZLr1JijYgNYuA5EJJcE7Aa2jgBi4CyRvlnOzkqeH97e5PlCsiWN3n/rp64JGexJuodPo0mH6joSCMMkJskl9f1XbrZl1PF1XjkpY9wzS/fxo4yOfPn3hnR+O3Xrhv0sQFAq9VgfoacifefY+V+OeZQw6AOERFRiCl3yJWeD8FweZPVQFGCOj1l6gDyGPd5oxMBALvOdO0lMFQV1bXhH59dAgA8+sUpWDFV7hmw51ydV0+PrSeqAAA3zsjoehCiXrh/j62odJVPeU6iijLo1D44m/aXwtlLLxllnHlWfCSmZbkydSpacLHONflqGAQck1wlWI3M1CG4+1BlmAwhXolslKvvXI3F4bX9jKscKyM6eJfu0TpXUKeh7yy/nhw6W4b8n7+JVX89jE2nOlDRaYAACQ/MjcMv7lzip5XKbp0/BgBQ0ABYOkZe0JZBHSIiohD7/JJc1z87Lz5o51Tu8Ne1dfZ6oTcYoijhfK18QTi+l6AOIE/SAeSAx3AgSRJ++U4h7E4JyyalYtmkNMzJS0CsUYcGiw0FFfLdzxqzFZ8Xy///K6czqEO+8WyWXN1Npg7gHj3+9M7zWP3MXjXQerlyNVMnCpPSY6HVCGiw2LCvSJ5M5zn5aqhS+urUM6hDAOpcwZOsxPAIWI7LkMueGqzeDYqVDNbcxOBNmYt1JeVVNg68/OqZHQWocgVy8iJtuHdGNLZ/dz5+fOvVflql24o5ExDjKsF6/dNTfj9+uGNQh4iIKIREUVKDOvNHJwXtvMkxBgiC3DS0wRKYu1oVzR1otzlh0GowKqn35r9LJsp9Ag5cbISl09HrvkPB/318ER+fq4NBq8GjN04BAOi1Glw9Xh6bu8vVQ+f9gipIEjA7N55jzMlnaa5MHc/yK89GyQDw0HUT8MSXpyHWqMOxsmasevoTPLO7yGsfq92JOld/rayESETotRjraoq87VQ1AKifD2UsvyJPDVb5hkZucu83HYJlSq78d7BN1KGj093Mu7xF/vf4NFPQ1hIfIYcJas0dAz7GpSb59+z+OXHY8/Mv4xd3LgnY5C6tVoP5mSO3BItBHSIioiD45TuncOff9qPd5h2wOFvTCrPVgSiDVu1jEQw6rQbJrguc2h5KsJrbbXjl81JY7c4BneOsq0nymJToPkcej02JRk5iJGxOEXtdmQFD1ZtHy7Hhfbk58v9bOQmjPMpWlrqCV7vOyhlJ7xbIpVerZmQGeZU0HCgZd5XNHeokO89GyQCg0QhYMz8PO364GNdNToPdKeE3H5zxythRSreiDFokRMm36Ke5miWbrfJr1nDo95Qcw/IrcjPb5f40Y9MTQrwSWW5qPLQQIUHA2XJ3KXJdp/z3c1puYEeZe0pw9fir66MXV09EUURlu7zueeOCk4XqWYLV2h7YfoHhhkEdIiKiAHM4Rby0rwR7ixqw87R3zxglS2dOXkKfgQ9/U0Yi99RA9ZndRfjJvwvwF9e4bV+dq3X100nv+y6oIAhqwEOZBDUUfXyuDg+/fgIA8I2rR+O+q0d7Pb7YVWZ2orwZJytacLBY7pVww/T04C6UhoVU1+9wYZUZDlGCRgBSYrrvzZUeF4G/rZ2D/DFyRuAB12sP4N1PRxDk0o8plwWZh1P5VUMbgzojXV1zG2yQgzrjs5JDvBqZRqNBvF4Oop4tl29u1DW3oV2UAyyzxgSvRFcJgDZY7H3s2b3i6kZYJR0ESLhyQrY/l9aj5bPlEiw7tHj9k5FVgsWgDhERUYDVtHbC4epb84GrlEHhLr1KDPq6UmOVfhzdZ+oUuRqk7hxg82JlnPmEPvrpKJS+OrvP1g3J0eYF5S34zqbDcIgSbpqZiZ/eMLnLPmmmCEzNNEGSgJ++WQAAuHJUQpc+KET9oWTqKBOq0kwRvQaHBUHAla7XmsPF7qBOucfkK8VUV6YOAOg0AnIShv7PqFp+FaCSUxo6LlTWAwCMggMJsb2XBwdTcoQcVC2qaQYAHCuqBABEa+xIigtetlyK6/1BU8fAMnUPnKsAACTo7DBFB6cXkFarwYIsORj1zvGKoJwzXDCoQ0REFGDlje3qv3edqVXLmSRJUu+Wzx8TvH46CiVTp6aHseaVzfL2U5Vm1A+gB8W5Gjko1N+gTv6YZBh0GlQ0d+BC7cCbM4aCU5Tw7U2HYbE5cdW4JPz2thnQaIRu91Uykk6Uy82SV7FBMg2QEtRRXN5Ppztz8+RSk0MlTeo2ZZx5lkfgxjNTJzcpKuiZhIGQ5GOmjt0pYuOuCzhTPfAJQBSeiqrln/94vRjilXjLMMnlj6UN8vuGU2Vy8Ck1Irg3OjLi5QCS2Taw8x4vkdedExvc143b5o8FABQ0jqwSrKH/6kxERBTmlLvgANBuc+LT8/KbnYv1FtS3dcKg02BGdlxPTw+YvjJ1qj2CPZ9dqPfp2E5RwoU6JajTv7KNSINWLQ3ZNcRKsE5XmVHR3IFogxZ/vWsOjDptj/suneTuiyAInHpFA6eMNFdk9iPj64rceGgE+XVJCeiWN8kXkFnx7oyFuEg9chPlz8ckD/3SKwBI8rGnzhuHy/HbbWfxy/8UBnJZFAIldXImaWJE98H3UMlJkH/nKl1/l8/XyAHFLFewJ1gyE+Xf+Vb7wL4/52rl7MHxKcHNgrp+9njEauxwQItXPz4Z1HOHEoM6REREAeYZ1AHcJVhK6dUVOfG9BgECRR1r3k1PHavd6XXh8/E534I6JQ0W2BwiIvQa9U1qfyglWLvOhGa0eV1rJ5rbfe+3ofxfzh2ViNiI3t98z8pJQLyrGe2VoxK7ZFsQ9Ve0UYcYo079vD+ZOrERekxMl7NwDruydZSeOtmXlVgpzduHw+QrwN1Tp7HdBqfYdwaCEswurDIPyZJQ6lmFK5CZGhPcYElfxqTKv3N17XIGUalrgtSYIDcqz0qW19EuaiGKvmczlZnljOTpOcHNQtZoNFiQJQe7t56oDOq5Q4lBHSIiogBT7oJf4xpnvaOwBnanGNJ+OoBn+VXXTJ3qFu9Azyfnfetzo0zWGZ8a22MZUneU0qRDJY1otQ6sQeNAdDqc+O22M1iwYSdu/POn6LD51kdA+b+c14//S61GwBemyo2Rb50dnAaSNHwpzZIBIKMfQR3AowTL1ai7vJvyKwB4YMk4XDc5FXctyPPHUkMuMUoO6kgS+gzeSpKE/Rfl3+uWDrs68p2Gh+pW+f8/s5+/M8EyPlP+G9Joky/TqyxyQGVSVnDfJ+Slyq8RIjSobfatHNpitaHeLgfL5k/M8vva+vKVBXIJ1pkmCVZb8N5HhBKDOkRERAFW5grq3DwrC0nRBrR02HHgYqNHICD4/XQAd/lVdTc9dSpb3HfuI/Qa1LZ24qzHCOTeiKKEzQdKAQCTM/rXT0cxKjkao5OjYXdK+OxCcEabHy1two1Pf4qNu4rgFCWUN3XglYOl/X6+JEn43NV0dsGY/r3x/u8bp+C1b+XjtrkM6tDgpMW6L0r723B77ij5gu1wSSPsTlEtw7o8U2d6dhz+fs+VyEkMn0ayg6HTatSR7Q19lGAV1bV59RJTeoTR8FDfLgfus5PCq7Rwcq58Y6NT0qG60Ywmu5yJN2NUalDXER1phAHy96i8rsWn5x45Xw4JAgxwYkJ28MawK669Yhx+ck0KPvvJdYgwhFcmVqAwqENERBRgyl3wvKQoXD8lDQDw3KcXUdHcAZ1GwOy8+JCsKyNevhisb+tUmzcrlEydvKQoLHD1ufmknyVYL+0vwSfn62HUaXD/ojE+r2vxBPlN4J5zge+r8/xnl7D6mb04X9uG5BgDVrsyZ57dcxGdjv5l6xTVtaHRYoNRp8H0rPh+PSfaqMO80Ynq+GiigUrzzNSJ71/WwexcOahzqtKMS/UWiBJg0GmQHN39OPThRCnB6qv5+74i76DyuX4GtWloaOqUX3tHpwa/n11vkkzRiBDkseZbPz8HJzTQQsTEnOAGdQAgWucK6jT41ij8cJFcYp4e6YRGE/xwg0ajwbdXzQvqtLBQY1CHiIgogBxOEVUtyl3wKKyYJpfd7Dor94yZnh2HKIOux+cHUlK0ATFGHSTJXSKmUNacEReJa8bLQZaPz/fd5+ZCbSv+573TAID1KydhXKpvmToA1CDSqcrATpxxOEX8dttZiBJw86xM7HhoMf7nlmlIN0Wg2mzFG4fL+3UcpURjdm4CDDq+taLgSvXoydSfRsmAnJGTZjLCIUp4r6BK3hYf6VOp5FCljDXvq1nyvotyUEfpWXS+lkGd4cLucKJNlP9fx2WGJlO2NwkGueRqZ6H8u5mod0Afgr57sa4kl+omi0/PK6yUM3tGJxj8vSTqAd95EBERBVC12QqnKMGg1SA11oiFY5MQ69HYtD89WAJFEAR1uk1Jw+VBHTm7KCMuAotcvYAOXGrsktHjyeYQ8YNXj6HTIeKa8clYmz9qQOvKS5LXVNbY3seeg3O2phXtNidijTo89ZVZSIg2wKjT4luL5eyiZ3YXwe7su0Gk2hupn6VXRP6kTMDSagSkxPYv00YQBMzNk39e3z4mNxO9vJ/OcJXuCoJd/prnybOfzurZck+Qs9UM6gwXl6obIUGAAAmj08PvdTstSr5EL6iX/95mRIfmkj3eKJ+3usW3v8VFDXIW3OQMk9/XRN1jUIeIiCiAPBuQajQCjDotlk12p1GHqkmyQgmgFF8e1Gl2Z+qMS41BRlwEbA53c+fu/GnnOZysMCM+So/f3TZzwHf9lf4dTe32gDZLPlraDACYlRvvtdavXpmL5BgDyps68NbRil6PIUmST02SifxNmZ6WFmuE1offuTmuZsmX6uW78FnxIyOoM8U10auwl0zAczVySWWkXotb5+QAAM7XtHEC1jBxodKVhaUJTQZMXzLi5OBsmyinyuQmhqaZc0KUfAOquwmZvalql1+Hrhgd/JKxkYpBHSIiogBSgjqeDUhXukqwBAGYkxfaQECuK6hT2uCdXu0uv4qAIAjq5K5PeijBuljXhmd2FwEA/ufL0wc1pjvGqFObmZY1dvSx98ApQZ0rXP1FFJEGLb5xjZyt85fdRb2OPi5r7EC12Qq9VsAVOQk97kcUKLNy4mHQaXwOKirNkhWXN0kerqZnyT1UTlb23Px1v6v0au6oBExIj4FWI6C109FtU3kaei7Vyv/3CcbwDNLlJXn3ghmfFpqMl+QYuXyqwdLzzZWXdx/Hq3tOqJ8XVzeiXdIBkDB/Um6gl0guDOoQEREFkNKrxvOCacnEVFw3OQ33LxqDuMjQTmYY5XrzWNLYQ/mVq/Gq2lenh2bJu8/WQZSA/DFJuGF6xqDXpWTrlDUFrgTraJk8zvmK3Pguj921IA/xUXpcqrdg64nKHo+x/5J88TczOx6RhvC740vDX05iFA4/ch2e+sosn543OcOESL37Z3aklF9NdWXqlDS0o6Wj+4tVpUnygjFJMOq0GOUKfnMC1vBQ3iD/PyZHhedr9ti0eK/Pp+Ykh2QdKa7Jes3W7suui6sb8dMPyvD/3i/FuwfkXnoHzsq96BK0dsTHjIzXlHDAoA4REVEAuTN13COBI/Ra/P2euVi/cnKolqXKS1QyddzBE6vdiaZ2+WInwyS/Kbt6XDIEQe5DU9PN3eoDruDGNRP88+YzJyGwfXWa2224WCdnJ83Kju/yeIxRh69fNRoA8Kt3T6tBrsux9IrCQWyE3udyR71Wg5k57sk/nq9Rw1l8lEENsp/qJltHFCX19Uxp2j4xXW74fp4TsIaFSlcmanpseDbynXRZEOeKsZkhWUd6vHzTp6Wz+4ymN/efgQQBgIBH/nMGZosVJ0rkGz/ZsQwzBBO/20RERAHUXaZOOFHKr8qa2tUyI6X0KsqghSlSrqlPiDZghqtsYc9Z7xIs+SLI1Sx4tH8miWQnyt8vJSjmb0fLmgEAY5KjkRDd/Rv7+64ejYlpsahr7cQ3XjyEdpujyz4M6tBQNtej/HOk9NQB3CVYpyq69tU5W9OKpnY7ogxazMiW9xvvmuLHZsnDQ22bfNMiM0x/5sdnJUOA/Pc4WmMP2WjurMQYAECrvfuAsWfmbpPTgB88/xHO1co3S8Ylj4wgcbhgUIeIiCiAuuupE04y4iKh1wqwOyVUNstrVbJS0l39dBRLJ8lNDz86U+t1jHO1rWhutyNS774IGqxAZ+p4NknuSbRRh7/fMxdJ0QacqjTjh68eh+jRX6eqpQOlje3QCMDcUQzq0NAzx9VXR6cRBtUHa6iZ5grqFFR0zdRRSq/mjkqEXitfKk1Ik4M652pZfjUcNFrl1/G8lPCczhRh0CNWK99ESI0IXd+frGT5+9MuaiGK3pMg7Q4nTjfJa1s1Wi5j+6hcREGDvN+MXP5NDCYGdYiIiALE4RTVrJdwLW3QagS1f02pK4CiTL7KjPMORC1zBXU+OV+HToe7xv6Aa/Tv3FEJ6kXQYAW6p87RUrmfzuzc3psb5yRG4dm758Cg1eCDU9X4/Y6z6mNKls60rDjEeIypJxoq8sckYf7oRNw5P9enyVlDndJXp7tmyUqT5Pwx7qzDCWlyxsKFmlZOwBoGmu3y36kx6fGhXUgvklxNnLNMoeu7l5cq/30UoUF9i/cwhd3Hi2CVdDDAiT98/TrMTxEBCLBK8t/CK8eHpmRspGJQh4iIKECqWqxwihIMWg1SYoyhXk6PlL46Ja6+OsqEl/Q47zv30zLjkBJrhMXmxMFLTep25SJowRj/lF4BQI4rs6msscPvF1GiKOGYq/yquybJl5s7KhG/Xj0dALBxVxHyN+zEqqc/wZMfyAGeeczSoSEqQq/Fq9/Kx2NfmhbqpQSVkqlzqd6Ctk53WaVnKemCMe7f61HJ0dBrBVhsTlQ0B24iHwVeU2s7Ol2BhwlZKSFeTc/GJ8t/fy+fzhhM0ZFGGCDfwCmtbfZ67L2jJQCAifESDHod/ve+pYjRyGVtejgxOTctqGsd6RjUISIiChCl9CorIdLnJqbBlKdOwJLvxCllWJmXBXU0GgFLJ8pvgneeqQEASJJnPx3/BTeyEiIhCECH3YkGi81vxwWAi/VtaLU6EKnXYqKrrKIvt8zOxg+uGw9ADtadqjSrF3fXTAjfCwMi6io5xoiMuAhIElBY6e6rc6ikCS0ddsQadWrfHUBuKj0mWc7WOc8JWEPauQq5D4wBTqTEx4R4NT37/b1L8b9fHoPv3bQgpOuI1slBnfIG7/5TB8vl34Orx8k3c1LiY/DfK8ZAAxET4yVo/ZS1S/3DXGEiIqIACfcmyYrcyyZgVSuTQeK6rnvZpDS8dqgcH52pxaM3TsH52jY0WmyI0Gswo5spUgNl1GmRbopAVYsVZY3tSPZjptORkmYAwIzsOOh8eOP5g+sm4I55uahusaKx3YYmiw1RBh0WjQ/NuFkiGripmXGoarHiZEWL2uj8jcNlAIAbpmd0eW0YnxaDszWtOFvTqvYXo6GnoFjuCZdg6H5Md7iIjYrAjfNDPyEzVg80OYDqJnf5VXWjGRVWuSzs5vkT1O23L56BK8dnIi0xPHsVDWcM6hAREQVId+PMw9Eo15SKYldQRxn3mhHftXHq1eOTodcKKGlox8V6Cw64Sq/m5CXAoPPvnbmchCg5qNPU4dcU9KNlcunYQI6ZZooYUQ1liYaraVkmfHi6BiddzZLbbQ68e6IKAHDr3Owu+8vNkqtwjmPNh7TCCvn1P9fEy+D+iDdqUNoBFNW6M3Xeco0yT9LbMDHHO8A5JpM3OUKBeVFEREQBEu6TrxS5iXL5VWmDBZIkodo1/SojrmvwIsaoU3vnfHS6Fvsv+neUuSdlrLm/J2Apk69m96OfDhENT0p5ldIs+f2CalhsTuQlRWFuXteAr9IsmeVXQ1tRvfz3ZFxKeN9sCRezcuSsmzfPtuPzM6UAgF2n5fLrK9LDt1fgSMOgDhERUYAMlfKrnES5f43SBLSpXW52mNFN+RUALJ0o35nbeaYGBy75v0myui5XhlO5HydgtXU6cNZ1p723ceZENLwpzZIv1Lahw+bEG4fLAQC3zs6GIHTtgaaMNb9Q2wZR5ASsoaqiTR65PTWHDe77479vX4TRUTY4oMUDmw+jua0DJxvk0rXrp3XNaKPQYFCHiIgoQIZK+ZVRp0WGq6RIGU8eZdDCFNF9evq1k+Wgzv6Ljahvs8Go02BmTly3+w6GOta8sfdpMy0ddjT1s5nyibJmSJIcaEuNZRkV0UiVGmtEcowRogRsL6zGvosNEATgljndX6jmJUXDoNOgw+5UX9uHI7vDCavNHuplBERHpx0NdrkXzNxxHLndH3qdFs/fvxhRGgfq7QZ86fcfwCLqoYWIG+dNDPXyyIVBHSIiogBwOEV1NHhOmGfqAEBukhxAUcaTZ8RFdHu3GpAvbsakRKufz85NgFGn9fua1LHmvWTqOJwivvjnT3H9Hz5GS3vfFyJHSgfeT4eIhg9BEDA9Sy4t+c37ZwAAV41NRlZ896/XWo2AsSlyCdbZYdxX54tPvoNZP38PFyvr/X7sivpmmC1Wvx+3v44VVUCCAD2cmJDNqYX9NSo9EU+sGgcBEko6DACAcbFOREey/CpcMKhDREQUAFUtVjhFCQadxq+TmwJllGus+f5LSlCn90DUsonu5ojzxwQmjV3J1Kls7oCzh3KHU5VmlDa2o76tE/86Ut7r8erbOrHlgNwTYA5Lr4hGPKUES2kOf2sPWToKpa/O6Spzr/sNVYUl1Thj1sMq6fDP3Sf9euyzZbVY8ruPsfoPH/j1uL44clHuBZMW4YRGw8tgX3z5qqm4daI7uzV/dHzoFkNd8KeZiIgoAJTskuz4SGg03We8hBMlU0cpdequSbKnZZPdQZ1A9NMB5ElTeq0Au1NSs54ud7C4Uf335gMlkKTugz92p4h1m4+gssWKMcnRWN3HxRsRDX9TM91lo7FGHVZMTe91/7mj5AD27rO1AV1XqLz22Rn133suNPv12FsPnocdWlxo04WsvOt0ZTMAIIeTrwbk12uX4YpEJ6I1dqxdMi3UyyEPDOoQEREFgNJzIWsIlF4BQF5itNfnfQV1rhyViLEp0chNjMKsnPiArEmrEdRSiJ4mYB245A7qFNVZ1Glcl9vw3hkcuNSIaIMW/7d2DmIj9P5fMBENKdOz3UGdG2dmINLQexnp9ZPTAABHy5pR19oZ0LWFgmcgp7hdh6pG/2UkHSuTjy1BwMlL1X47ri8uNcg3B8a7Mq7IN1qtBv/6rxtR8KubOLo8zDCoQ0REFABDpUmyIi/Je50ZPfSVUOi1Grz7vWuw/aFFiND7v5+Owt0suWtQRxQlHHJl6kxz9cbYfKCky35vHa3APz67BAD4/VdmYVxqbKCWS0RDSGZcBNJdTeJvnZPT5/7pcRGYkR0HSQJ2usY6DxdVjWYUt8sZLFEaByQIeO2TU347/oVGdzP7E8WhyXSqaJMzOWfkMiAxUBqNhqVrYcin/5ENGzbgyiuvRGxsLFJTU3HzzTfj7NmzXvtYrVasW7cOSUlJiImJwerVq1FT4/2iV1pailWrViEqKgqpqal4+OGH4XA4Bv/VEBERhYmiujYA4T/OXJF7WVAnvY9MHQCI0GsDGtAB3EGxsm6mzVyoa0NTux2Rei2euHk6AGDbqWqvO+jHy5rxk3+fAAA8uHQcvjCt9/IKIho5BEHAc/fOxT/unYs5ef1rnq5k6+woHF5BnVc/PgkJAlL0NiwbJb/+f3jaP8EXi9WGmk53ydPpyia/HNcXZosVzU55DXPHZwX9/ESB5FNQZ8+ePVi3bh3279+PHTt2wG63Y/ny5bBYLOo+Dz30EN555x28/vrr2LNnDyorK3HLLbeojzudTqxatQo2mw179+7Fiy++iBdeeAGPPvqo/74qIiKiENq0vwTvnqgCAEzP8v+o70AwReiRGG1QP8/so1FysOQkyuso7yZT53NX6dXsvHjMzInHFbnxsDslvHaoDABwsqIFdz93AFa7iMUTUvDQ9ROCt3AiGhKmZsZh2aS0fu9//VR5308v1KPdNnxuSu88UwcAmJ8ThS9fORYAcLpZgKVj8GVme08VQ/S47CxuCP5I+CMXKgAIiBAcyE2ND/r5iQLJp6DOBx98gHvvvRdTp07FzJkz8cILL6C0tBSHDx8GALS0tOC5557DU089hWXLlmHOnDl4/vnnsXfvXuzfvx8AsH37dhQWFmLTpk2YNWsWVq5ciccffxwbN26EzWbr7fRERERh77WDZXjkLXlqyLcWj8E144dOmnduojtbpz+ZOsGQo2bq9BzUudLVvHTN/DwAwMufl+JkRQvueu4AzFYHZufGY+Oa2dAOgYbVRBTeJqbFIjcxCp0OER+f8//Y71BobbfidLP8+njLvLFYOnMMojV2OKDFv/cWDvr4+87JNzk0EAEA5a3BD4YdvaRMvhJZPkTDzqB+oltaWgAAiYnym6nDhw/DbrfjuuuuU/eZNGkScnNzsW/fPgDAvn37MH36dKSluSPiK1asgNlsxqlT/qvbJCIiCrZ/HynH/3OV+nz9qtH4yRcmQRCGTiBB6asTbdDCFBEe00HcPXW87+xKkqQGdeaNlt+H3DgjA3GRepQ3dWD1M3vR3G7HrJx4vPj1eYgxhsfXQ0RDmyAIuH6KfB2zvTA0DX/97c29hXBAixiNHUtmjIFGo8HcdLmZ/HvHywd9/IIKueHytHg5qFPfqYUoioM+ri/OVMrXraMSDH3sSTT0DDioI4oifvCDH+Cqq67CtGnySLPq6moYDAbEx8d77ZuWlobq6mp1H8+AjvK48lh3Ojs7YTabvT6IiIjCyfZT1fiv149DkoC7F+Thv2+cPKQCOgCQlyRPwEqPiwibtee4ehLVtFrR6XCq28ubOlBttkKvFXBFjtwLI0Kvxa2uUeWdDhEzsuPw4tfncdIVEfmVEtT56EwtHM7gBicC4f0TFQCAOel6NYvlhply4+hjdSLsHq+9A3GxWc7MuWlWFgRIsEOLoqqGQR3TV5ca5TKyCWlslE/Dz4CDOuvWrcPJkyfxyiuv+HM93dqwYQPi4uLUj5ycvrvTExERBcv5mlY89OoxiBLwlbnZ+OVNU8MmKOKLCa4xr6OSovvYM3gSow2IMmghSUCFR7NkZZT59Kw4rzHEa/PzEG3QYmZ2HF76+nzERTKgQ0T+NTcvAfFRejS323GoJPhNf/3J7nDiWJ0cmLpxVq66/aYFk2GAEx2SDjuOnB/w8RtaLGhwyK/D180ag3idHQBwrCi4WU5VrgremaNSgnpeomAYUFDnwQcfxNatW7Fr1y5kZ2er29PT02Gz2dDc3Oy1f01NDdLT09V9Lp+GpXyu7HO59evXo6WlRf0oKysbyLKJiIj8rqXDjm/+8xAsNicWjEnEE1+eDs0Q7d2yYmo6HvvSVDxy45RQL0UlCIJHXx13UOeg0k/HVXqlyEuKxuc/uw7/fuAqxEUxoENE/qfTarBsUiqAoT8Fa/vhc+iQdDDAiS8umKRujzTqMdX18vriJ+fxxKsf46bfvI1ZP3sLv3plT7+Pv6fgEgABsRo7RqUnIiNK/vt4uqLRn19GrxpaLGgV5b8HnHxFw5FPQR1JkvDggw/izTffxEcffYTRo0d7PT5nzhzo9Xrs3LlT3Xb27FmUlpYiPz8fAJCfn4+CggLU1rpH5O3YsQMmkwlTpnT/JtJoNMJkMnl9EBERhZpTlPD9V46iuKEdWfGR2HjnbOi1Q7cBo16rwdr8URidHD6ZOoB7AlZJg3va5ufF8gXB/MuCOgAQbdSxKTIRBdTyKe7R5pIkhXg1A/fvg5cAANOSgAiDdyB8xVT5hvuBOg3+drQVJ5p0aHbq8dap/gdkPi+Sg16jTPJrcm6C3IT/Qm3boNfe7zWckxMCojV2pCfyOpKGH5/eea5btw6bNm3Cli1bEBsbi+rqalRXV6OjQ75zFhcXh/vuuw8//OEPsWvXLhw+fBhf+9rXkJ+fjwULFgAAli9fjilTpuDuu+/G8ePHsW3bNjzyyCNYt24djEaj/79CIiKiAHlqx1nsPlsHo06DZ++eg6QY/h0LhEnp8pvwJz84i4/O1KC21YpL9RYIAjAnr2tQh4go0K4ZnwKDToPSxnacrWkN9XIGpKK+GR+XK/1usrs8fts1UxGrsUMDEaOibFiWLQdmmuw6OPvZS6iwSg7eTEmXy3snpMs9bcpagjf1+HixPK49I6qPHYmGKJ9GQTzzzDMAgCVLlnhtf/7553HvvfcCAP7whz9Ao9Fg9erV6OzsxIoVK/CXv/xF3Ver1WLr1q34zne+g/z8fERHR+Oee+7BY489NrivhIiIKIjOVrdi464iAMBvVs/AtKy4EK9o+PrmojE4WNyIA5cacd+Lh7Bsolz2MCndxJ45RBQS0UYd5o9OxCfn63HgYqMafO5JWWM7/vvtk3hgyTh1Yl+oPfb6PtihRZrBhruXzeryeJIpGkce+yJsDieiIwyw2R2Y+N8fwAkNzlfUYVJuWteDXuaSWc5imj9O3nd6bgpwoBm11uBlU56rloNunHxFw5VPQZ3+pBZGRERg48aN2LhxY4/75OXl4b333vPl1ERERGHldJU8ifHKUQm4+QrW6AdSXKQeL903Hz//z0m8/HkZdp6RS7i7K70iIgqWuXlyUOdIaRPuWTiq133/7+OL2H22DpIEzBs9LzgL7EVxdSM+LHEA0ODBxaOg7aF0WK/TQq+Tm9Eb9Dok6OxodBhwsqS2z6BOcXWjq5eNhMXT5bYds8ZmAjgPi6hHXXMbUuJj/PhV9bCO5k4ABkxM580XGp6GbuE/ERFRCFW1WAFAbeJLgWXQafA/X56On39xCpR2OQvGMKhDRKEzJy8BAHC4jwlYkiThI1cw+khpE0Qx9D14fvn6PjihQZbRhjVLZ/b7eamuRsdn+tHo+OOTxQCAJJ0dSXFyr7aU+BhEa+QJWEcuVPi4at+JooiqdvmSdxYnX9EwxaAOERHRAFS1yP3k0uMiQrySkUMQBHztqtF45f58/GTlJFw/pfupmUREwTAzJw6CAJQ3daDWbO1xv7M1raholv9mtFodKKoLXpPgbtdTVos9FXJPnB9cOw4aTf8vCbNMcgnTpXpLH3sChy7JvWzGxHsXh6S6/myeLK3v93kH6lhRJTokHTQQMX9Sbt9PIBqCGNQhIiIaACVTJyM+MsQrGXnmjU7EtxeP5YQrIgqp2Ag9JqbJjX+PlPacrbPzdK3X531l9gTaY//6HCI0yIu0YfXVU3167pgUuVyqwtx3o+MzNXIga3qWd7+h3Hi5F9q5GrNP5x6IrYfk3nd5UU6YonkThoYnBnWIiIgGoFoJ6pj4JpGIaKTqTwmWUnqVZpInJPYWAAq0k5eqsLda/vePlk/0KUsHACZmyl9vTXvvJWROp4hSixx4z5+Q4fXYWFdgqLSp06dzD8S+S/L3el5ubMDPRRQqDOoQERENAMuviIhodm7vQZ1Gi00N4jy4bHyv+wbDX7efgAQBY6PtuCl/is/Pnz5Kbo7c7NDDZnf0uN+7n5+BVdLBACcWTh3l9diUbLkfWrUlsL2FrDY7Lpjly92VV4zqfWeiIYxBHSIiIh91Opyob5NTzzNZfkVENGIpmTonK8zodDi7PL77bC0kCZicYcKq6XLGSlGdBc3tfZcvBcLBinYAwBenpw7o+eMyk6GFCAkCCktretzvtQMXAQCzUgRER3iPEr9irPx9aHbqYbEG7vuw/fB52KFFpODANdNGB+w8RKHGoA4REZGPas1yyrhRp0FClD7EqyEiolDJS4pCUrQBNqeIkxVde8QopVfXTkpFYrQBY5LlKVBHS5uDuUwAwLnyOtTYDAAkrF44eUDH0Go1SNDLGTqnSuq63cdqs+NQjRzgWj03r8vjo9MToYcTEgScuFg1oHX0x/aCMgDApAShx5HtRMMBf7qJiIh8VOmaYpIRFwFBYLNeIqKRShAEXOEqwTpyWVmV3Slizzk58LFsspwZM7ufY9AD4V/7zgAAsiPsyElNGPBx0qPlS8jz1c3dPv7m3kJYJR0iBQe+vLBriZdGo0GKUQ76FJTUdnncX464spKuHpcUsHMQhQMGdYiIiHxU7Rpdy346RESklGBd3gD5UHETWq0OJEYbMDM7vtd9g+Hj8w0AgAW5MYM6Tnac3PC5p7Hm/z5UCgC4Ml0Hg17X7T5ZsfL2rScq8dSbn+Hpt/fh5d3HYe+mhG0gqhrNqOyUM2lvmj/BL8ckClfd/5YRERFRjyqbXZOv4thPh4hopFMCNYdKmiBJkprB+dEZuefMkokp0GrkbUpj5WNlzXA4ReiCVBZk6ejEeVfT4Jvmjh3UscakxAAlLagw27s9z/F6uQHyrfN67mMzNiUKB+utONGkw4kDza6tjahptuAHNy8c1PoA4J0DZwEISNbbMD4rZdDHIwpnzNQhIiLyUXWLu/yKiIhGthnZcdBpBNS1dqK8qUPdvlPtp5OmbhufGoNYow7tNifO1rQGbY1v7z8DB7SI1thx9bRRgzrWpCx5elVtR9fHXt5TABu0iNHYsWrepB6PsW7lbMxPETHZZMeEGDvitXKA6FBx46DWptjtCqjNTDP65XhE4YxBHSIiIh9VtSiZOgzqEBGNdBF6LaZmmgC4y6rePFqOi3UW6DQCrpmQrO6r0QiYlRsv7xvEvjrbCsoBALNSdNBoBncJOGN0OgCg1anrMr3qneMVAICF2cZemxPnpCbg1R99Ee//9GZsf+Rm3DdfPmZxc9fsH1+JooiCOrmZ87IpmYM+HlG4Y1CHiIjIR+6gDsuviIgIarPkvRca8NM3C/DQq8cBAF+alQVThPeUxDlBbpYsiiKO1sjBkuunDT7IkZsar06vOlVcrW5vam3HySb58vKrC8f7dMy54+SgTo1VC1EUB7W+Y0WVaBX10EDEqnkTB3UsoqGAQR0iIiIfKUEdNkomIiLAHah59VAZthwohSAA3102Dr9ZPb3LvkpfnSNBGmt+8Fw5zE49tBBxc/7ARpl70mg0SDLIDY1PlbrHmm/adQJOaJCgtWHJjDE+HfOKcVnQQIQdWpwuHdxErK2HigAAeVFOxMfw5gsNfwzqEBER+aDT4UR9WycAIDOebxaJiMgd1AGApGgDXvzaPPxo+cRuGyHPyo2HIAClje2oa+0M+NrePHAeADAmxn9BDvdY8xZ121vH5ayda/KifC7xijDokayXS6YOnq8c1Nr2XZIzoOblxg7qOERDBYM6REREPqg1y2/ADToNEqL0fexNREQjQWZ8JNbMz8UXpqbjve9fg0UTep64ZIrQY2KaHHAIxmjzfcVmAMA1YxP62LP/chPkTNWShnYAwH/2FaLIoocACfdd2zU7qT9yTFoAQEFZw4DX5Tnla9XsnqdvEQ0nDOoQERH5wLNJsjK2loiI6IkvT8df756DNFPfpblTXI2VL9S2BXRN1Y1mlHbINyBuWTDBb8cdkyoHpSpa7RBFEb/ddhYAsDAdmDl2YH17JqRGAwDO17UPeF3/OeC/KV9EQwWDOkRERD6o4jhzIiIapOyEKABARXM3c8H9aP+ZMkgQYNLaMW10ht+OOzk7CQBQZxWw6aNjKLMaoIWIx76yYMDHnJEnTwkrbx14o2RlytdMP0z5Ihoq+JNORETkA06+IiKiwcpOkP+GlDcFNqhT2yJnvcTpJb8ed8YYOUBkEfX44+4SAMD1eXqMzUzu7Wm9mjchCwDQ5NCjtd3q8/NFUcTRateUr6n+C2ARhTsGdYiIiHxQ7VF+RURENBDZrkb7FU0DLzXqjzqzHDSKNfi3XDgj0QSjIDc2bnQYYBCc+MXtCwd1zNHpiYgQHJAg4OC5cp+ff+R8BVqc8ihzf0z5IhoqGNQhIiLyQWUzy6+IiGhwlPKr8qYOSJJ/s2g8NbimNcZFaP1+7GSju0zq5olRSE80Dep4Go0GGZHyMY9erPH5+W99Lk/5Gh3tREJs1KDWQjSUMKhDRETkg2qznKmTzvIrIiIaoPS4CAgC0OkQUd9mC9h5mtrlY8cHYFpjRowcKIrW2PHIbVf75ZijEgwAgMLKlj727OqzS/KUr6vGxPllLURDBYM6REREPqhsZvkVERENjkGnQbprSlYgmyU3dzgBAEnRBr8f+4szs2EUHPju1ZkwRfvnb+LkDDkgc6mp06fnNbRYUNyuA+DfKV9EQ4Eu1AsgIiIaKmwOEfWuVHYGdYiIaDCyEyJR1WJFeVM7ZuXEB+Qc5k4RgBZJsf7/m3XP9bNx97Wz/DplavaYNOBQC6rafTvmv/YWQoKABJ0Ns8Zm+W09REMBM3WIiIj6qcZVemXQaZAYgLueREQ0cmSpzZIDl6nTZpf79aSaAtNjxt9jw+dNzAEgoUPSobi6sdt9nE4R//f+QewrLFG37SysBgBckW7063ooPIkFR+D49yZILU2hXkpYYKYOERFRP1V5TL4SBP9OEiEiopHFs1lyoFgc8t+qtPjogJ3Dn0zREUjQ2tHkNODA2XKMSk/sss/Pt+zGplMdEFCDazJOYsOaq1BQLwLQYOWMnOAvmoLOufM9oKUJjqLz0H7lHmjyxoR6SSHFTB0iIqJ+qmqR33grfRCIiIgGKitBztQpD9BYc1EU0SHKzYwzEmMDco5AyI6VL1ELSuu7PHa2rBavnGoDAEgQ8HEVsOR3H6Nd0kEPJ26cPymoa6XgkzraASVDp70Nzn/+FeLhfaFdVIgxqENERNRPSqZOZjwnXxER0eBku4I6gWqU3GKxwum63MtMGty48WAamyx/X87WWLo89sNN++CAFjkRNjx1Yx5S9DbYIQeuJsRJiDT6f8oXhRepplL+hykOwtSZgOiEc+sbcG57O7QLCyEGdYiIiPqpukUZZ85MHSIiGhylp055UwckSfL78Ssb5BHfWoiI89N0qmCYli2XXJWaHV7bX9xxBKdadBAg4de3zcItV0/DZ49+EV+fGYOx0XY8fMO0UCyXgkyqqQIACBnZ0K6+G5plNwAQIO7/GFJlWWgXFyLsqUNERNRPSvlVJoM6REQ0SErWZ7vNieZ2OxL83IC/qrEVABCpcfq9oXEgXTk+E9hdg3qbDja7Awa9Ds1tHfjdrlIAeizP0+KqqaMBAAa9Do/esTi0C6agkqrlTB0hLROCIEB7zbWQ6qohFRyB88An0H35zhCvMPgY1CEiIuqnKjVTh+VXREQ0OBF6LVJjjaht7UR5U4ffgzo1zXL5UrTO/1lAgTRtVDp0cMIBLa74+VaMihXgECW0inrEauz4zd0rQr1ECqUad1BHoVmwCM6CI5BOHoN03Y0QYodOuaE/DJ2QLRERUYh5Tr8iIiIarEA2S641y8eM0Q+taY1arQbX5uohQIJF1ONUiw5nW+VeOQ8vy0V8DG+sjFSS6IRUK4+vF9Iy1O2azBwIOaMA0Qnx0N4QrS50mKlDRETUDzaHiPq2TgAM6hARkX9kJ0ThaGlzQJolN7TKNyJMxqF3H//ZB1bCbLFi94mL2H++GqeqWjE+JQprr5sd6qVRKDXUA04HoDcAiUleD2nmL4KzrBjioX3QXHMtBN3IaZrNoA4REVE/VDZ3QJKACL0GiX5OkSciopHJs1myvzVYbACA/9/encdHWZ/7/3/dM5NMErKH7AmBsO8gCEZxQVDAvbWtC7ZqcWu1rfo97am/2trlnOM5rd1s1e5a69JqF1s3rIICyiIgyA5hTUJWErKSZTL35/fHJBNiWBIyk0nI+/l45CHM3PO5r7vNTSbXXJ/rio90BnztvhA7JIJr8iZwTd6EUIci/YTxb71Kx7I6Jyut8ZMgNh5qqzHbNmFNmxWCCENj4KVtRUREQqCwrTR+WGIUljWwStlFRKR/ykoIXlKn+pgHgIQofRAhZ4fjmyR/kuVw4ph1AQDetauCMlGuv1JSR0REpBsKqnxJneyEqBBHIiIiZ4tg9tSpabYBSIp2B3xtkVBor9ThBEkdAMc554ErDMqKMYf292FkoaWkjoiISDf4kzqJSuqIiEhgZLcldQ4HoVKnri2pkxyrxsJydjBlJUDnJsnHsyKjcEydCYC9bmWfxRVqSuqIiIh0Q1GV7w23kjoiIhIomfG+nyl1za3UNHoCunZ9q++/KXH6uSUDnznWAHU1wMmTOgCO2Rf6jq+swLQG9p7qr9QoWUREpBvaK3WGKakjIiIBEhnuJGlIOJUNLRQdPUZcZFzA1j7m9X1+nxofHbA1RULFv/UqIQnLffIppFZyKs4lX8XKzO7STPlspaSOiIhINyipIyIiwZCVEEllQwuHjzYyMSMwSZ0WTyvNxverXubQ2ICsKdJTpqEeU3QQU3jI999jDTivuQFHVk7P1zpFk+RPOpP1BzIldURERE6jptHjL4tvn1QiIiISCJkJkXxcVBPQCVilR+v8f05LiAnYuiLdZe/civflP8InplB5//Rr+PzdPU68mPJT99MZzAZHPZKIiEgvFLZV6QyNDmeIW5+HiIhI4GS1TVU8XB24pE5JlS+p47ZaCQ/Tzy3pe/aGD3wJnYQkrOmzcF79OayckdDSjPe532AfLujRej2p1BlsepzUWblyJVdffTUZGRlYlsUrr7zS6fnbbrsNy7I6fS1cuLDTMVVVVSxevJjY2Fji4+NZsmQJ9fX1vboQERGRYCnU5CsREQmSzPjAjzVvT+pEOe2ArSnSXaahDnNgLwCuz9+N65obcJwzG+fNS7BycqG5Ce+fft3txI7xeqGiFAArTUmdT+pxUqehoYGpU6fyxBNPnPSYhQsXUlJS4v968cUXOz2/ePFitm/fzttvv81rr73GypUrueuuu3oevYiISB8obHujnZ2gpI6IiARW+7beQG6/Kq/x/dyKVpGOBJCprsLet/u0x9k7t4IxWBnZWAlJ/setcDfOm+/AGtaR2PE3QD6VynLweiHcDfEJvbmEs1KPb/NFixaxaNGiUx7jdrtJS0s74XM7d+5k6dKlrF+/npkzfTPkf/GLX3DFFVfw2GOPkZGhzJuIiPQvapIsIiLBEoztVxW1vrViwq2ArSmDm/F6af3jU1BdhXXn/VgZ2Sc/dvtmAKyJU7s8Z4W7cS6+A+9zv8EUHqT1ud/iWvIVrPjEk69X1tFPZ7BMtOqJoPwv8t5775GSksLYsWP50pe+RGVlpf+5NWvWEB8f70/oAMyfPx+Hw8G6deuCEY6IiEivFFT53hwrqSMiIoGW2VapU33MQ31za0DWrGpoBiAuwhmQ9aT/Mt5WvP/+V7cqaHp1ni0boLoKALu48OTH1ddiDu4HwDGha1IH2hI7Ny2BlDSor6X1ud9gGk7ejsUUHvS9Tv10TijgSZ2FCxfy7LPPsmzZMv7v//6PFStWsGjRIrxeLwClpaWkpKR0eo3L5SIxMZHS0tITrtnc3ExtbW2nLxERkb5S1Fapk5WoyVciIhJY0W4X8VFhQOD66lQ1+CY2tq8rZy+zdRP2mhV4X30Z84lJUwE7h+3Fu2pZxwPlJ/69HcDesQUwWFk5p6y+sSKjcC2+C+ISoLIC7wu/w7Q0dz13RSn2xrW+14wae8bXcDYLeFLnxhtv5JprrmHy5Mlcd911vPbaa6xfv5733nvvjNd89NFHiYuL839lZ5+81EtERCSQvLbx9zlQpY6IiARDe8+2wqrAbMGqafJV/CQOCQ/IetJ/2fvbKnRqjkLVkaCcw2zbDEc7dt+YI2UnP3b7xwBYJ6nSOZ4VG4frljshMgpTXIj3L89gWj0daxkb76svg+3FGjMBa8zEM7+Is1jQN6Tl5uYydOhQ9u71db9OS0ujvLy80zGtra1UVVWdtA/PQw89RE1Njf+rsPDk5V4iItL/ebw2f1x9sNv9Aw5VNvgnUPW1stomWrw2LodFepwqdUREJPCy2ypBCwL0s66myTf1amhMREDWk/7JGBuzL9//d3t//imOPsNz2DbeVe8AYI2b7Hus/MRJHVNbgyk4AIDjBP10TsQamorz5jsgLByzfw/ePz/tT+zYG9b4tl6Fu3Fe8WksSz2iTiToSZ2ioiIqKytJT08HIC8vj+rqajZu3Og/Zvny5di2zezZs0+4htvtJjY2ttOXiIgMXM+uOcQj/9rOV1746LTHHmtp5donPuDaJz7gWEvPeg0YY1i97wir8ivONFR/MikzIRKnQ28mREQk8LIT2yt1ApPUqff4tuGkxKrC9KxWWgzHOnrRmAN7An4Ks3MLHCmHiEicV3zK92BDHeZYQ5dj7R0fAwYrezhWbHy3z+HIysG5uC2xs2+3L7FTWYH9zuu+5+ddgRWnqVcn0+OkTn19PZs3b2bz5s0AHDhwgM2bN1NQUEB9fT1f//rXWbt2LQcPHmTZsmVce+21jBo1igULFgAwfvx4Fi5cyJ133smHH37IBx98wH333ceNN96oyVciIoPE61t84ys/KqhmU8HRUx67r7yB6mMeqhpaWJXf/bLijYequOHXa7n5t+v4/O8/ZM2+ytO/6AQ0+UpERIKtY/tVYJI6Da2+DyFS44cEZD3pn+z9bUmctgSKObAXY9sBW98YG+9KX5WOY/aFWDFxvh44nHgLltnRtvVq4rQen8uRM7JTYqf11z+BlmasrBwc555/5hcxCPQ4qbNhwwamT5/O9OnTAXjwwQeZPn063/nOd3A6nWzZsoVrrrmGMWPGsGTJEmbMmMGqVatwu93+NZ5//nnGjRvHvHnzuOKKK5gzZw6/+c1vAndVIiLSb5XUNPJRQbX/709/cPCUx+8/0vEJ1Ns7Tr6Hu13R0WPc8ccNXP/UGj48WOV//L/f2IFt97yBYPsb7PaRsyIiIoHW/sFBYQAaJdu2TaPtm3qVlhDd6/Wk/zL7fEkdR97F4I6ApkZMSVHg1t+9A8pLINyNY/aFAFjJqb7nPrEFy9QcbZtSZeGYMOWMznd8YgdPCzicOK/+nMaYn4arpy+45JJLTtlV+6233jrtGomJibzwwgs9PbWIiJwFlm7zTUzIjI/kcHUjb2wt4aErxp20X82+io7y3uW7yvHa5qTboLy24Y4/bmBXaR0OCz43M5tbzsvhpt+sZdvhWv6x6TDXz8jqUbyFapIsIiJB5k/qVDVijOlV75Cahia8bZ/dZw6NC0h80v8YTwumoG10+KixmEP7Mbu2+hI9mcMCcg57q69limPm+ViRvu9RKzkNs3cXVHwiqdM2Ut3KzvFV9JwhR85IWHwH9lv/wjEzDyvlxH13pYNSXiIi0qfebEvq3H7BcM7LTaTVNjy75tBJj99X0VGpU9XQwken2K710oZCdpXWERcZxr8fuIj/vX4KkzLjuPfSUQD86K3dNLZ4T/r6VzYd5pwfvM3KPR09eLT9SkREgi0jPhLLgkaPlyP1Lb1aq7iyFgAnNnFD1Cj5bGUO7Qev17f1KikFK3eM7/EA9dUxxrRV3oA1ZoL/cX+lTkXnseb2IV+CyRoxutfnduSMxHXXAzjOOa/Xaw0GSuqIiEifKa9rYn3blqhFk9P54gUjAHhhXcFJky372yp1hkb7tvG+c5ItWPXNrfz4375Pib46bzSjUmL8z912/nAy4yMprW3it6v2nzS+59YeoqqhhR+81rFVq337VftkEhERkUALdznIiAvMBKzSo74PQyIdXhwO/bo3EJnGY9hbNmK8Jx8Q0b71yho5BsuycOT6kimm8CCmpbn3QdQchbpacDiwMrI7HvcndTrejxljMAf3+eLJye39uaVHdJeLiEif+ff2MoyBqVlxZMZHMm98KsMSo6hp9PD3TV33gNu24UBbT53bLxgOwNs7T5zUeeq9vRypb2HE0CF8/rycTs9FhDn5z0XjAPjVin2U1zZ1ef2xllY+LqoGIL+8nje2ldDY4qW8zvfGSJU6IiISTFkJvqROb5sll1X7fm4OcfW8j5yEnmlppvWPT+H9xwvYbU2KT8Te7/sgyzFyrO+BxKG+JsZer3+seK/iaK/SScvECgvzP95eqUN9Laax7Xu1ugpqq8HhxMoe3utzS88oqSMiIn3mzW0lgK9KB8DpsLjt/OEA/OH9A10aGZfUNtHksQlzWiyePYwwp8X+ioZOW7LA1xz5t6t8b2AeWjSOcFfXH29XT0ln+rB4jrV4+fG/u5Ymbzh4FI+34/yPL8v3f1oa43YRFxnW5TUiIiKBMixAY83La3yvjw478748EhrG2Hj/8QKU+aaE2us/OGHVjamrgfJSwPJvd7IsC6u9Wmd/77dgmSLf1vhPJmksd0THtK22ah1/lU5mNlZYeK/PLT2jpI6IiPSJqoYW1u5v23o1qaPp3WdnZhHtdrGvooFVezuPLN9X7kve5CQNIT4qnLyRQ4GuW7B+uHQ3La025+UmctmE1BOe37IsvnXFeAD+vqmI2iZPp+fX7PeNPL9sQioxES72lNX7t2plJ0b1qmmliIjI6WS3JXV6u/3qSJ2vGjXWrV/1Bhp7+VLMrm3gdEJ0DDQew968vstx/q1XGVlYUR1j6x1tfXXsQCR12it1TlB546/WaUvq2Ifat16N7PV5ped0p4uISJ94e0cpXtswIT2WnKSONyAxEWFcOy0DgOWf2Fq1v60iJ3eo7/jLxqe0rdVx3Lu7yvnXx8VYFjx85YRTJl9mDk9kVEo0Hq9h+c7yTs+t2edL6iyYmMbtbb1+/rrRtyVMW69ERCTYAjXWvKrB12g5PtLZ65ik79hbNmK/vwwA59Wfw3HhfN/ja1dibLvzsW1br9qbI7fzNykuK8HU151xLKalGVPqqxaysnK6PG8l+z6ca2+WbNqbJA9XUicUlNQREZE+8cZW3w/+KyZ3HU15flsFzvqDnSdb7T/ia5KcmxwNwPy2KpyNBUcpq23iR2/t4ot/9H2C9dkZWUzKPP0IzfYqoTe2lvgfq29uZevhGgDyRiax5IIRxLhd/ufVJFlERIIt+7ix5r1xtNHXXDchSttgBgpTWoz3Xy8B4LjgUhxTZ+KYdi5ERMLRSszubR3HtjRj9uUDYLX302ljDYmGNN8HZWbvzjOPp7gIjA2xcVhxCV2et45rlmyqq3w9dSyH+umEiJI6IiISdDWNHlbv822tWjgpvcvzM4f73jDsKq3ttC2qvXdObrKvUic9LpJJmbEYA1c+/j5PvLsPY+DGc7P53jWTuhXLorbzr9hTQUOz743v+gNVeG3DsMQoMuMjiYsK47a2xsygSh0REQm+9g8QSmoaaWm1T3P0ydU2+aZJJrVNjZT+z7viLfC2Yo0ej2PeIgCscDeOcy8AwF79HuBL6Hif/x0cq4ch0VjZXatoHKN8W829r76M9+3XzmgS1qm2XgGdJmD5q3QysrDC9T0XCkrqiIhI0O0qqcXjNWTGRzIqJbrL86mxEQxLjMI2sKmg2v94+zjzkckdr5k/3vdG4kh9MzERLn5583T+9/opRIZ3r8x8fHoMw5OiaG61eXe3bwtWe8IpLzfJf9ySOSOIbqvWGT50SNeFREREAig52k1EmAPbQHH1mVfr1Lb4EkLJsaoyHQhMRZmvjw4WzsuuxrI6fkV3zLoAnE5M0SHsvbvwPv9bTMF+cEfgvGkJltPVZT3HnEuxxk0G28Ze/S6tT/4Ie8+OnsVUdBAAK2v4CZ/399Spq8Hevd33mPrphIySOiIiEnTtTR9HnCI50l6ts+Ggr5lyQ3MrJTW+Zo8jkzte96npmUS7XZw7PIE3vnohV03J6FEslmX5p2+92bYlrL1Jct7IjqROfFQ4Tyw+h69eOooL2raHiYiIBItlWWQn9L5ZcoPH11suJU5VpgOB94PlAFjjJnUkS9pY0bFYk2f4jnvx975R5e4InJ+/G0fmsBOuZ7kjcN1wG84bb/dNqao5ivfF32Mf2NuteIwxp63UsSIiIca35d2XkFI/nVBSUkdERIKu/c3psKSTv8GcmZMIwPq2pM6Btn46iUPCiT+uL0BO0hA2fecyXr7nfH//gZ66om0L1vJd5ZTVNrG9uBbonNQBuHhMMg9ePhaHQ5OvREQk+ALRLLnB6/uZlRrftTJW+hdTcxSz9SPAV2FzIs68i31/sG2IiMT5hXtOmtA5nmPsJFz3fgNrnG97ur35w+4FVXUEGo+By4WVdvIPzvwJKGODZWENG9G99SXglNQREZGg8yd1TpGEObetUmdzYTUer+3vp3N8lU67MGfvfnxNyowlKyGSRo+XHy7djTG+CVupsRG9WldERKQ3ejvW/GhDM83Gtx05a2hswOKS4LBXrwDbxhox6uSVNylpOM45D+IScH3+bhwZ2d1e3wp348i7BACzezum1XPqFwCm8IDvtRnDTri9y792csfgCys9C8ut91ChoqSOiIgEXXeSOiOTo4mPCqPJY7O9uNbfTyd3aOA/abQsyz8F628f+caWf7JKR0REpK+1J3WKznAC1js7SgGL9EhD5tDTT4SU0DEN9dgfrQXAMWfeKY91Xv1Zwu5/GKsHCZ12VnaOb6tUcxNm3+7THm8XHup43anWPW6rmJWT2+O4JHCU1BERkaAr7EZSx+GwmJnT0VenY5x5cJoUt/fVaaekjoiIhNqwXlbq/HtnBQCfPX8MDod+1evP7A/fh1YPVkY21ojRQTuPZTlwTJjiO+eOLac93t9P5yRNkv1SjkvqDB91puFJAOhOFxGRoGpobuVIfQtw6p46ADOHd/TV2VfePs48OD0BpmXFkx7XUSp8Xq6SOiIiElrtY83PJKnT0NzKyj2+pE57Nar0T6al2ZfUARwXXIplBbd3nzVhqu+8p9mCZZoaoaLM95rTVuqkgcvl672jfjohpaSOiIgEVXuzx/ioMGIjwk557Ln+CVhH/Y2ST9RTJxAcDouFbW96x6RGMzTaHZTziIiIdFf79KuaRg81jafvf3K893ZX0Nxqk5MUxbi0mGCEJwFi9uyApkZISPI3Mg6m7m7BMgUHAAOJQ7GGnPp7yIqIxLn4Tpy33O2bhiUho6SOiIgE1aHK02+9ajcpM45wl4PKhhYaPV5cDuuMJ1x1x+3nj2BKVhxfukRjOEVEJPSGuF0kDfFNfCzsYbXOm9tKAFg4KS3olR/SO/aurQA4Jk7D6oNtct3ZgmW8XrzL3/TFlTumW+s6ho/CoX46IaekjoiIBFX7m9LuJGfcLidTszoaOw5Liur1pKtTGZYUxb/um8OnpmcF7RwiIiI94W+W3IOx5k0eL+/uKgdg4URtverPTKsHs2cnANb4yX123tNtwbLXrICyYoiMwnHJ5X0Wl/SekjoiIhJU3Zl8dbz2vjrgm4glIiIymJxJs+T384/Q0OIlPS6CqVnxQYpMAsHs2wOeFoiNx0rvuw+VTrUFy1RWYK94CwDngmtPu/VK+hcldUREJKja35TmdDOp095XB4I3+UpERKS/am+WXNiDseZvbisFYMHENBwObb3qz/xbr8ZP7tNtcifbgmWMwfvaX6G1FSt3DNaUGX0WkwSGK9QBiIjI2a2nlTozhh1XqTNUlToiIjK49LRSx+O1eWenb2LRQk296teM14vZvR3o261X7awJU2HdKsyOLXjDwrGGjcDU12IO7gVXGM6rPqN+TAOQkjoiIhI0tm0oavuksbsNj+OiwpiZk8BHBUeZPiw+iNGJiIj0P+0TsLYUVfP//WMrxhgsy+JzM7OZlh3f5fi1+yupafSQNCScc4/bwiz9jzm0DxqPQVQ0VnbfjwG3snMgKRkqK7A3roGNa/zPOeYuxEpI6vOYpPeU1BERkaAprW2ixWvjclikx0V0+3W/+vwMymubGZ2qPd0iIjK4jEyJxrLg6DEPL6wr8D++/kAV/37goi6VFEvbtl5dPjEVp7Ze9Wtmp2/rlTVuUp9Mvfoky3LguvN+zP58TMEBTOEBTEkRVvZwHOdd2OfxSGAoqSMiIkHTXjqemRCJqwdTrIZGuxka7Q5WWCIiIv1WamwETy2ewc6SWhyWhWXBL9/dS355PTtL6piQEes/trnVyxtb20eZp4cqZOkGY2zsXdsAXz+dULHcEb6tX20xGK8XHA5tuxrAlNQREZGg6Wk/HREREfH1xjm+P86O4lqWbi/lnx8f7pTUWbaznKPHPKTGupkzamgoQpWTsA8XYHZswRo7ESt7OKaoAOprwR2BNWJUqMPzs5zOUIcgvaSkjoiIBE2hkjoiIiK9du20DJZuL+XVzcX854Jx/glXL28oBOD6c7K09aqf8b76MpQVw+p3ITUDK8r3XsgaMwHLqV/DJXA00lxERIJGlToiIiK9N3dcCjFuF8U1TWwsOApAaU0TK/ZUAPCZGVmhDE8+wdQc9SV0sMDlgrJizIG9QGi3XsnZSUkdEREJmkOVSuqIiIj0VkSYkwVt27H+ufkwAH/fVIRt4NzhCeQmR4cyPPkEO38X4Js25XrwERyXXwNDU7Eyh2GNGhfi6ORso6SOiIgEjX/7VZKSOiIiIr1x7bQMAF7fUkJLq81fNxQB8NkZ2Sd9jWk8huepx/C+8fc+iVF8TP4OAKxR47Eio3DmXUzYvd/AdcfXsMLCQxydnG20mU9ERIKivrmVyoYWALJVqSMiItIreblJDI0O50h9Cz9ftof9RxqIDHNyxZSTT70ye3dBeQl2eQmOWXOwhqb0YcQnZ4zB7N+DKSrAlJdgykuhpQnXTUuw0jJDHV6vmFZPx1arMeNDHI0MBqrUERGRoGiv0kmICiM2IizE0YiIiAxsLqeDq6b4qnWefG8fAFdOSSfaffLP6U3hQf+f7fWrgxpfT9jvL8f73G+w31uK2fExHCmD2hrsLR+FOrReMwf3gacFYuIgNSPU4cggoKSOiIgEhZoki4iIBNY1bVuwjPH9/bOnaZBsig75/2xv/hDT3BS02LrLVJRhr3gLAGv8FBzzr8Jx3kW+50oKQxlaQJg9bVuvRo/HsjSRTIJPSR0REQmK9kodbb0SEREJjOnZ8WQnRgIwPCmKWSMST3qs8bRgyop9f4mOgZZm7C0b+yJM3/nLS7CPqxQCMMbG++pL4PVijRqH87NfwHnBXBzTZvmeLy7CGLvPYgw0Ywz2Xl+TZMdobb2SvqGkjoiIBEX75KscNUkWEREJCMuyuGV2DgC3nT/8lJUgprgQbBtiYnHMmQeA/eEHmPYynyAyLc20/uGXeP/wC7z/fhVje33nX7/atyUs3I3zqs90xJ+cAmHh0NIMRyqCHl/QVJbD0UpwOrFyR4c6GhkklNQREZGg0PYrERGRwLvrolze/Y9LuPX84ac8zhT6tl5ZWcNxTDsXwt1wpAxzID/oMZr8XdC21cte8x7eZ3+NfbgAe9kbADjmXYEVl+A/3nI4sdLatpYVD9wtWPaenQBYw0dihbtDHI0MFkrqiIhIUGj7lYiISOBZlsWIoUNO26/FFB30HZ+Vg+WOwDF1JgD2h+8HO0TsHZt95x4xCsLdmEP78P7u59DSjJU9HMe553d5jZUxzBf3AE7qmPy2pM7oCSGORAYTJXVERCTgGppb/ZU6w5OGhDgaERGRwcUY42+SbGX7tms5Zl3ge27PDkxFKcbjCUr/GtPSjGmrWHFedjWuO++H5DTfk04nzms+h2V1/TXUysz2vX6AJnVMUyOmYD+gfjrSt04+/05EROQMrTtQSattyEqIJD0uItThiIiIDC7VVdBQDw4nVrpvQpY1NBUrdzRmfz6tT/6o49ioaFy33Ok/rrdM/k5o9UBCEqRlYlkWrju+ir12FVZ6JtbQ1BO+zspoS+qUHsZ4vVhOZ0Di6Stm/x5fD6OkZKzEoaEORwYRVeqIiEjArco/AsCFo4dqnKeIiEgfM21Tp6z0TCxXmP9xx0WX+3rrHO9YPfbOrQE7t739Y9+5Jkz1vwewwt04L5p/6gqWxCRwR0BrK1SUBiyevtI+WcwxRluvpG+pUkdERALu/bakzpxRySGOREREZPDxb73KGt7pcUdOLtY3/xtsL7S2Yq9fjb3sdUx5SWDO29KMyd/hO9fEqT16rWU5sDKyMQfyMYcLsdIyAxJTIPkmh5ku28fM0UrM7rbrPmd2CCKTwUyVOiIiElClNU3kl9djWXD+yKRQhyMiIjLo2J/op3M8y7KwnC4sdwRWZltz4rIAJXX27PBV2iQOhTNIylgZvi1gdj/sq2NaW2l96jG8v/05xuPp9Jy9/gPAYI0cc9LtZSLBoqSOiIgE1Pt7fVU6kzPjSBgSHuJoREREBhfT0gylxYBv8tWpWKltDYyrqzBtI8h7w97RdetVT/TnCVimpBAqSjElRdjvL+t4vKUZe9OHADhmXRiq8GQQU1JHRET8bNtwrKW1V2u8n18BwJxRahIoIiLS10xxERgbYuKw4hJOeawVFQ3Rsb7XVZT17rzNTf6R3o6J085ojfYJWJSXYFo9pz64j7X3KQKwP1iOqfS93zFbP4KmRkhIwho9LkTRyWDW46TOypUrufrqq8nIyMCyLF555ZVOzxtj+M53vkN6ejqRkZHMnz+f/Pz8TsdUVVWxePFiYmNjiY+PZ8mSJdTX1/fqQkREpPe+/PxHnPODt/nHpqIzer0xhvf3VgIwZ7SSOiIiIn3NFB0ETrz16kT81Tq93ILVaetVavqZLRIbD1HRYNuYtmqj/qK9TxFOF3i9eN/8O8YYvOveB8Bx7gUnHNUuEmw9/q5raGhg6tSpPPHEEyd8/oc//CGPP/44v/rVr1i3bh1DhgxhwYIFNDV1lPMtXryY7du38/bbb/Paa6+xcuVK7rrrrjO/ChER6TXbNqzYU0GTx+aBv3zMo2/sxGubHq2xq7SOI/XNRIY5mZFz6k8HRUREJPBO1iT5ZKwUXwLGlPUuieLfejVx2hlPvrQsy1+t05+2YBljMIW+/12dV14PThdm3x7sN/7um9QVFo5j+qwQRymDVY+nXy1atIhFixad8DljDD/72c94+OGHufbaawF49tlnSU1N5ZVXXuHGG29k586dLF26lPXr1zNz5kwAfvGLX3DFFVfw2GOPkZGR0YvLERGRM1Vc00ijx4tlgTHw65X72VNWx89vmk5sRNjpF6Bj6tWsEYm4Xc5ghisiIiKf4Es+HARO30+nnT+pU37mY8SNpwWzdzcAjvGTz3gdwDcBK39nv0rqUHMU6mvB4cCaNB1HzVHsFf/G3rAaAMfUmVgRkSEOUgargNaHHThwgNLSUubPn+9/LC4ujtmzZ7NmzRoA1qxZQ3x8vD+hAzB//nwcDgfr1q074brNzc3U1tZ2+hIRkcDaV9EAwKjkaH5x03TcLgfv7q7ghl+vpcnj7dYaq9qaJF+orVciIiJ9r77OtwXK6cRKz+rWS6zU9qROSdvI7p4z+/dAqwfiEs5o6lWneDLaKnUO95+kjj9RlpaJFRaG44JLIaFjwqdj1gUhikwkwEmd0lJfdjc1tfMYt9TUVP9zpaWlpKSkdHre5XKRmJjoP+aTHn30UeLi4vxf2dnZgQxbRESAveW+3mYjk6O5emoGf73nfJKGhLOzpJYn39172tc3ebx8eED9dERERELFionF9Z//hetLX8dydXNTxtBUsCxoPOarRjkD9q7tADjGTjzjrVft2pM6HCmn9V8v0frqy3hf+yv2ji29Wrc3PrmlzQoL823DshxYYydiJaeFLDaRAdHJ6aGHHqKmpsb/VVjYf7K2IiJni/akzqiUaAAmZ8Xxg+smAfDUin3sKas75es/OnSUJo9NcoybsakxwQ1WRERETshyOLCSkrt/fFgYtB1vzqBZsrFtX5NkwBo7scev7xJPdExbFYzBbFqH+Wgt9sY1eP/2HMbT0uv1z4Q/qXNc82nHyLG47n8Y52c+H5KYRNoFNKmTlubLUJaVdR6HV1ZW5n8uLS2N8vLyTs+3trZSVVXlP+aT3G43sbGxnb5ERCSw9lW0VeqkDPE/tmhSGvPHp+LxGr75ty3YJ2mc3OTx8o9NhwHfKPPefkonIiIifaejr84ZJHWKDsGxeoiIxMoZGZB4XDfchuPSK3DMXYRj7kKIiATbG5KJWMbjwZT63uN8sk+RFRuH5epe30GRYAloUmfEiBGkpaWxbNky/2O1tbWsW7eOvLw8APLy8qiurmbjxo3+Y5YvX45t28yePTuQ4YiISA/sa6/USe6osrEsix9cN5Fot4uPCqp5bt2hTq85VNnA/7yxk7xHl/HyRt8Y9EvHdd5iKyIiIv1bxwSsM0jq7N7mW2P0OCxnYIYkWKkZOC+ch/Oi+Tgvugwre7jvXCFonmyKC8G2ITrW1zNIpJ/p8fSr+vp69u7t6K1w4MABNm/eTGJiIsOGDeP+++/nv/7rvxg9ejQjRozg29/+NhkZGVx33XUAjB8/noULF3LnnXfyq1/9Co/Hw3333ceNN96oyVciIiFytKGFygZfSXNu8pBOz6XHRfKNhWP5zj+388Olu4mNCGNzYTVr9lWy+7gtWZnxkdx2/nCumpLep7GLiIhI71ipvh0TZ1KpY+9u76czKaAxHc9Kz/JNxCopCto5TsbfJDk7R5XI0i/1OKmzYcMG5s6d6//7gw8+CMCtt97KM888wze+8Q0aGhq46667qK6uZs6cOSxdupSIiAj/a55//nnuu+8+5s2bh8Ph4Prrr+fxxx8PwOWIiMiZaN96lREXwRB31x8Nt8zO4ZVNh/mooJr7/7LZ/7hlwcVjkrlldg5zx6XgdOjNjoiIyEDTXqlDRTnG9mI5uldxY46UQWUFOJxYo8YFL74M3ySvkCR1ig76YmhrkizS3/Q4qXPJJZecctSdZVl8//vf5/vf//5Jj0lMTOSFF17o6alFRCRI/JOv2pokf5LDYfHDz0zh87//kMhwJxeMHMr5I5OYnZtE4pDwvgxVREREAi0hEcLCwdMClUcgOfX0r6Fj6pU1YhSWO+I0R585K71tIlZFGaalGSvcHbRzHc8Yc8ImySL9SY+TOiIicvbxN0lOPnFSB2BUSgxrHprXVyGJiIhIH7EsB1ZKGuZwAaa8BKubSR1/P50gbr0CICYWomOgvg5TVoyVPSK452tXXQUN9b5KpPSsvjmnSA8NiJHmIiISXJ8cZy4iIiKDTA+bJZv6OkxRAQCOAIwyPxXLsvxJFVPcd1uw/P100jM15Ur6LSV1RESEvRVK6oiIiAxmVmrPxpr7qnQMVkY2VmxcECPzsTJ8W7D6sq+OP6mjfjrSj2n7lYjIINfk8VJ0tBE49fYrEREROXv1ZKy5aWnGu2qZ73UTpgQ1rnZ9Waljqquw16/G3rLRd27105F+TEkdEZFBbn9FA8ZAXGQYQ6PV9FhERGQwah9rTnUVpr4OKzrmpMfaq5ZBzVGIS8Axa07fxNc2AYsjwWuWbOpq8b75d8yubdA+HGhoCtbIsQE/l0igKKkjIjLIdTRJHoJlaSS5iIjIYGRFRUNsHNTW0PqLR3HMvhDHeRdhRQ3pdJyprMBe/R4AzoXXYYX1zQdCVkwcRMdCfS2mtBhrWOCbJXvf/Adm51bf+XJH45h1Idbo8VgOdS2R/kvfnSIig5yaJIuIiAiA87qbITUdWpqxV71D68//G+/yNzHNTYBvxLf3zb+D7fUlO4LcIPmT2qt1gtFXx7S2YvbtBsB5y124Pn8PjrETldCRfk+VOiIig5yaJIuIiAiAY8QorLsfxOzajnflv6G0GHvVO9gb1+K45HKsyCjMvj3gdPmqdPq4wtdKz8Ls2YEpLgz42qZgP7Q0Q3QMVu7ogK8vEixK6oiIDHL7ytu3XympIyIiMthZlgNr/GSscZMwu7bhXfY6VFZgv/F3/zGOC+ZiJQ7t+9iCOAHL5O/ynWPUOCxL1TkycOi7VURkEPPahv1HGgBV6oiIiEgHy7JwjJ+M60tfx7HoU9DeWyc+EceceaGJKb29WXI5pqX5hMeYsmK8a1ZgvK09WtveuxMAx+jxvYpRpK+pUkdEZBA7fLSRllabcJeDrISoUIcjIiIi/YzldOKcNQfHlBmYHR9jjRiNFRYWmlhiYiEmFupqMaWHsYbldjnG++rLmMMF4PHgvGh+t9Y1RyvhSDlYDqzcMYEOWySoVKkjIjKI7a2oAyB36BCcDk2+EhERkROzIiJxnHMeVkJSaONoq9YxxV23YJnmJn+/HXv1u5jGY91a0873VelYw0ZgRUQGKFKRvqGkjojIILZX/XRERERkADlVXx1TeBCM8f2luck/ev10zN62fjqjxwUiRJE+paSOiMggll/WltRRPx0REREZAKzMYQCYg/sw7QmcNubQft8f4hMBsNetwjTUnXI94/FgDuQD6qcjA5OSOiIig9iWohoAJmbEhjgSERERkdOzcnLB5YLaaigv7fScObQPAOdF830VPZ4W7FXLT7meObgXWlshLgGS04IVtkjQKKkjIjJI1Te3sqfc9+nV9Oz40AYjIiIi0g1WWDjWiNEA2Pk7/I8bjwdz2NdPx8oZiePSRb5jNqzG1FZjmpvwrluF59c/ofWvf8LU+T7YMm39dByjxmFZ6i8oA4+mX4mIDFJbi2owBtLjIkiJjQh1OCIiIiLdYo2ZgMnfidmzA9rGq5vDh8D2+qZjJSRhJSRh5eRiDu2n9fnfQvVRaBuDbkoP07p3F87LrupokqytVzJAqVJHRGSQ2lxYDcA0VemIiIjIANLe+8YUHcIca/D9ua2fjpWTi2VZWJblr9ahvNSX0BmaiuOyq3x9eZqb8L72V6iuAqcTa8SokFyLSG+pUkdEZJDaXHgUUFJHREREBhYrLgFS06GsBLN3F9aUGR1JnWEj/cc5huVi5i7EVFbgmHYu1vBRWJaFOe9i7A/fx17+JnhafI+Hu0N1OSK9oqSOiMggpUodERERGagcoydgl5Vg5+/AmjjVN84ccOTkdjrOedFlXV5rORw4z7sIx7hJ2Fs+wjHlnL4IWSQotP1KRGQQKq1poqy2GafDYnJWXKjDEREREekRa0zbFqy9uzFFBdDqgcgoSE7p/hrxib5JWW0j0EUGIiV1REQGofatV2NSY4gKV9GmiIiIDCxWZo4vidPUiP2Bb2y5lTMSy9KvuDK46DteRGQQ2qStVyIiIjKAWQ6Hf2JV+1hy6xNbr0QGAyV1REQGoc0F1QBMy9bWKxERERmYHJ8YQ/7Jfjoig4GSOiIig4zXNmw9XAPAtOyEEEcjIiIicmasUeOgfbtVuBtSM0IbkEgIKKkjIjLI7Cmr41iLlyHhTkalRIc6HBEREZEzYkVEYuWM8P152Agsh369lcFH3/UiIoPMx239dKZkxeN0WKENRkRERKQXHOde4Pvv1JkhjkQkNDTyRETkLOa1Dc+tPURmfCTzJ6QCsLm9SfKw+NAFJiIiIhIAjglTsb7zGJalD6pkcFJSR0TkLPbYv3fz1Hv7ALjlvGF8+6oJHUkdTb4SERGRs4ASOjKYKakjInKW+ufmw/6EjmXBc2sL+Liwhj1ldYCSOiIiIiIiA5166oiInIW2Ha7hP/+2BYB7Lh7J07edS3xUGFsP12AbSI+LIDU2IsRRioiIiIhIbyipIyJyljlS38xdz26gyWNzydhkvr5gLJeMTeG1r8xhSlYcALNHJIY4ShERERER6S1tvxIROYvUNXm469kNFNc0kTt0CD+/cbp/wlVWQhQv35PH8p3lzM5NCnGkIiIiIiLSW0rqiIicJaoaWrjt6Q/ZUlRDTISL33xhBnGRYZ2OcbucLJqcHqIIRUREREQkkLT9SkTOas2tXl78sICy2qZQhxJUZbVN3PDrNWwpqiFxSDgv3nkeo1JiQh2WiIiIiIgEkZI6InJW+9HS3Tz09638zxs7Qx1K0BRUHuMzv1pNfnk9qbFuXrr7PCZlxoU6LBERERERCTJtvxKRs1ZxdSPPrj0EwNr9lRhjsCwrxFEFVn5ZHbf8fh1ltc3kJEXx3JLZZCdGhTosERERERHpA6rUEZGz1s/fyael1QagrLaZw9WNIY4osLYUVfO5X6+hrLaZManRvHx3nhI6IiIiIiKDiJI6InJW2ldRz8sbCwEYGh0OwMZDR0MZUkCt21/Jzb9dx9FjHqZmxfGXu/JIiY0IdVgiIiIiItKHlNQRkbPST/69B9vA/PGpXDstE4ANBwd2UscYw8eF1fzPGzv5wh8+pL65lfNyE3n+zvNIGBIe6vBERERERKSPqaeOiJx1thbV8PrWEiwLvr5gLPsq6vn9+wf6daXOK5sOs3rfERZOSuOi0cm4nL6cuzGGbYdreW1rMa9vKaHoaMcWsnnjUnhi8TlEhDlDFbaIiIiIiISQkjoictb54Vu7ALhuWiZj02KIjwoDYFdpLfXNrUS7+9c/fUfqm/nPv22hudXmpQ1FpMS4+dQ5mTgsi9e3lFBQdcx/bFS4k3njU7lycjqXTUjF6Ti7Gj+LiIiIiEj3BXz71Xe/+10sy+r0NW7cOP/zTU1N3HvvvSQlJREdHc31119PWVlZoMMQkUHqyff2sir/CC6HxQPzxwCQGhtBVkIktoFNBf2vWudPaw7R3GqTHhdB4pBwyuua+fWK/Tz13j4Kqo4RGebkyinpPLX4HDY+fBm/uGk6CyelKaEjIiIiIjLIBeXj6okTJ/LOO+90nMTVcZoHHniA119/nZdffpm4uDjuu+8+Pv3pT/PBBx8EIxQRGSSMMfx8WT4/eycfgP93+ViGJXVMgpqZk0DR0UY2HjrKhaOTQxVmF00eL39qG7v+8JUTuGxCKst3lfOvjw/jsCwWTUpn7rhkosL7V3WRiIiIiIiEXlB+S3C5XKSlpXV5vKamht///ve88MILXHrppQA8/fTTjB8/nrVr13LeeecFIxwROcsZY3js37t54t19AHxj4Vi+dMnITsfMyEnglc3F/a6vzt8+KqKqoYWshEgWTEzF5XSwcFIaCyd1/TdURERERETkeEGZfpWfn09GRga5ubksXryYgoICADZu3IjH42H+/Pn+Y8eNG8ewYcNYs2bNSddrbm6mtra205eISLsfvdWR0Hn4yvF8+ZJRXY6ZkZMIwKaCary2CXpMR+qbOf/RZcz78Xu8sbUEY7qe07YNv1t1AIAlc0b4myOLiIiIiIh0R8B/g5g9ezbPPPMMS5cu5amnnuLAgQNceOGF1NXVUVpaSnh4OPHx8Z1ek5qaSmlp6UnXfPTRR4mLi/N/ZWdnBzpsERmgNhdW8+R7voTO96+dyB0X5p7wuLFpMUS7XdQ3t7K7tC7ocS3dVkpxTRP7Khr48vMfcd2Tq1mzr7LTMe/sLOPAkQZiI1x8bqb+XRMRERERkZ4JeFJn0aJFfPazn2XKlCksWLCAN954g+rqal566aUzXvOhhx6ipqbG/1VYWBjAiEVkoDLG8D9v7ATg+nOy+ELe8JMe63RYTB8WD8DGQ1VBj235rnLAt+0rKtzJx4XV3PTbtdzw6zW8s6OsU5XO4vNyGNLPJnKJiIiIiEj/F/TfIuLj4xkzZgx79+7lsssuo6Wlherq6k7VOmVlZSfswdPO7XbjdruDHaqIDDDLdpbz4YEq3C4H/+/yMac9fkZOAqvyj7Dx0FE+35YA2nCwisqGFhZMDFwPmyaPl9X7jgDwX9dNIik6nF8s28uLHxaw7kAV6w5UkZ0YSWFVI2FOi9vOHx6wc4uIiIiIyOAR9AYO9fX17Nu3j/T0dGbMmEFYWBjLli3zP797924KCgrIy8sLdigichZp9dr879JdAHxxzggy4iNP+5oZOQkAbDh0lNomD9/82xY+86s13P2njazbX3maV3ffmn2VNHlsMuIiGJcWQ0pMBD+4bhIrvzGXuy/OJSbCRWFVIwDXTM0kNTYiYOcWEREREZHBI+CVOv/xH//B1VdfTU5ODsXFxTzyyCM4nU5uuukm4uLiWLJkCQ8++CCJiYnExsbyla98hby8PE2+EpEeeXljEXvL60mICusy6epkpmXH47Cg6Ggjl/1kBWW1zf7n/vlxMbNzkwIS27JdZQDMHZeCZVn+xzPiI3lo0Xi+culoXlpfyLbDNXxj4diAnFNERERERAafgCd1ioqKuOmmm6isrCQ5OZk5c+awdu1akpOTAfjpT3+Kw+Hg+uuvp7m5mQULFvDkk08GOgwROYsda2nlJ2/vAeCr80YTGxHWrdfFRIQxNi2WnSW1lNU2k5MUxfXnZPGTt/ewdFsp379mYq8nUBljeHdXBQCXjks54THRbhdfnDOiV+cREREREREJeFLnz3/+8ymfj4iI4IknnuCJJ54I9KlFZJD47coDVNQ1MywxisWzc3r02mumZrCnrI7Pn5fDNxaOJdzp4I+rD1LZ0MLqfZVcNCa5V7HtLqvjcHUjbpeD80cO7dVaIiIiIiIip6JxKyIyoBRUHuOpFXsB+PqCsYS7elZZ86VLRvLFOcNxu5z+xxZOSuP5dQW8tqW410md9qlX549MIjLceZqjRUREREREzlzQGyWLiASKMYZv/3MbTR6b80cmcdWU9DNa5/iEDsBVUzIAWLqtlJZWu1cxLt/pS+pcOj61V+uIiIiIiIicjpI6IjJgvL61hBV7Kgh3OvjBdZM6NSHujVkjEkmOcVPb1Mr7eyvOeJ2jDS18VHAUOHk/HRERERERkUBRUkdEBoTaJg/fe3UH4NtCNTI5OmBrOx0WV072Vf289nHJGa+zMr8C28DY1BgyuzFiXUREREREpDeU1BGRAeGxt3ZTUdfMiKFDuj3CvCeubNvK9e8dZTR5vGe0xjL/1itV6YiIiIiISPApqSMi/d7GQ0f509pDAPz3dZOICAt8A+IZwxJIi42gvrmVFXt6vgWrptHDu7vbkjraeiUiIiIiIn1ASR0R6dd2FNey5I/rMQY+PT2T80cFZ0y4w2H5q3Ve29LzLVi/WJZPXVMro1KiOWdYQqDDExERERER6UJJHRHpt3aX1nHL79dRfczDtOx4vnftxKCer32a1js7yqg55un26/ZX1PPM6oMAfPuqCTgdgWngLCIiIiIicipK6ohIv7S3vI7Fv1tLVUMLU7Li+OMXZxETERbUc07LjmdcWgyNHi8vri844TEeb9eR5//zxk5abcPcsclcPCY5qDGKiIiIiIi0U1JHRPqdVfkV3PTbdRypb2FiRizPfnEWcZHBTegAWJbFkjkjAHjmg4O0tHZO4LywroBx317KfS98xJH6Zn+s7+wsx+WwePiqCUGPUUREREREpJ2SOiLSb5TUNHLv8x/x+d9/SEVdM+PSYnhuyWzio8L7LIZrpmWQHOOmtLaJ17cW+x8vrm7kv17fgdc2vLalhPk/WcHLGwr5wWu+MetfyBse0DHrIiIiIiIip6OkjoiEnNc2/G7Vfub9eAWvby3BYcEXLxjBy/fkkTCk7xI6AG6Xk1vzcgD43aoDGGMA+N6r2znW4mVyZhwT0mOpPubh63/dwp6yehKiwvjavNF9GqeIiIiIiIgr1AGIyOCWX1bHf/x1Cx8XVgMwIyeBH1w7iQkZsSGLafHsHH757l62F9eyZn8lTR4vb20vw+mweOyzU8lNHsJvV+3nZ+/k09Jq8+DlY4mLCv72MBERERERkeMpqSMiIeHx2vxm5X5+/k4+LV6bmAgX37piPJ+bmY0jxNOjEoaE85kZWTy3toAn393HwcoGAJbMGcHYtBgAvnzJKK6eksHeinouUXNkEREREREJASV1RKRP2LZh6+Ea1h+sYv3BKjYcPEplQwsAl45L4X8+NZm0uIgQR9lhyZxcnl9XwPt7jwCQERfRZYtVdmIU2YlRoQhPRERERERESR0RCa7mVi+vbDrMr1fuZ39FQ6fnEqLC+M7VE7huWiaWFdrqnE8aMXQI88en8vaOMgC+c/VEhrj1T6aIiIiIiPQf+g1FRIKiudXLH1cf5PfvH6Cs1jf+O9rtYvaIRGYOT2TWiAQmZcbhdjlDHOnJ3Td3FCt2V3DZxFQWTEwNdTgiIiIiIiKdKKkjIgFX0+jh7j9tYO3+KgBSY90smTOCm2YNIyZi4DQUnpodz0ffuYzIMGe/qyQSERERERFRUkdEAqq4upHbn17P7rI6ot0uHr5yPJ86J7NfV+ScSrS2XImIiIiISD+l31ZEJGB2ldZy2x/WU1rbREqMm6dvP5eJGXGhDktEREREROSspKROiNQ3t/K3jUV8/ryckI9vFgHf9+SafZVsOFTFyORoFk5KI7abW6X2ltfx7JpDvLyhiEaPl9Ep0TzzxVlkxkcGOWoREREREZHBS0mdEDDG8LUXN7FsVzkfHqzix5+dSkTYwNyaIgNbbZOHv24o4u0dZWw4VIXHa/zPffuVbcwfn8rVU9PJSogiNiKM6AgXTsuipLaRkuomDlc38sbWElbvq/S/Li83iV/dMoO4qIHTO0dERERERGQgUlInBCzLYsGkNFbmV/D6lhKKjjby2y/MICUmItShyVnohXUF/P79/UzLTuCiMUO5cHQyDc2tPP3BQf6yvoCGFq//2JykKGaPSOSjgmr2ltfz+tYSXt9actpzOCy4bEIqt+YNJ29kkpoKi4iIiIiI9AHLGGNOf1j/UltbS1xcHDU1NcTGxoY6nDO2dn8l9zy3kepjHjLiIvjdrecyIaPjeowx7Cmr573d5azZX4nL4SArIZLM+EhS4yKwbUOjx0tjixenw2L6sHgmpMficjpCeFXSn2w4WMUNv1mL1+64zS0LLKD9odEp0dw0axiXjkth+NAhgO97b3txLa9sOszK/Aqqj3moa2ql0eNLACVEhZEWF0lGXAQTMmK54dxsshKi+vryREREREREzjo9yXkoqRNiB440sOSZ9ew/0gD4Ju2kxLhJjnFTUHWMkpqmHq0X7XZx7vAExqTFYGFh8P3fmxoTweSsOCZmxBIVrgKtweBoQwtXPL6Kkpom5o9PJTd5CCv3VLCrtA6AC0cP5Y4Lc7lo9NBuV9Z4vDZe22i7oIiIiIiISJAoqTPA1BzzcP9fNvHu7oouz7ldDvJGJnHR6GTCXA4OH23kcHUj5bVNhLscRIQ5iQhzUt/kYcOho9Q1tZ7yXA4LRiZHMzYthtEpMYxOjWZ0SjS5ydE4P9Gwuay2iZV7KqhtaiU5xk1ytJvkmHAy4iNPmhgyxmjrTT9g24Y7nt3A8l3ljBg6hFe/Msc/mrustolW26iJsYiIiIiISD/Uk5yHSjb6gbioMJ6+fRZ1TR7K65opr22mvK6JhKhwZo1I7HZVhNc27CypZd2BKoqrG7HwbbWxDRyqbGDr4RrKapvJL68nv7we6OiVEhnmZFJmLJMz43GHOVixu4IdJbUnPdfQaDc5SVGkx0VQ0+ihrLaJ0pomXE4HD142hsWzhym5E0K/XbWf5bvKCXc5eOLmc/wJHYDUWPVuEhERERERORuoUmeQKa9rYvvhWvLL68gv8yV38svqOjXLbWdZMCUzjqzEKI7UNVNR30xFXfNpq4HA1zT3/66fQuKQcLy24YO9R3h9SwnuMAeXjE0mL3cokeH9YwtPXZOHTQXVbDhYxYcHqyiubuK66ZncfVEuQ9x9l/c80yonYwz7jzSw7XAN+WX17C6rY/mucry24X8+NZmbZw8LQrQiIiIiIiISDNp+JT1i24b9R+rZUlTDlqIa6ptbOX9kEheNSWZotLvL8TXHPByqaqCg6hilNU3ERYaRFhdBWmwEK/ZU8MOlu2nx2iTHuLlqSjpvbi2ltLZzbyC3y8H5I5O4adYwLpuQ2mdVPcYYSmqa+KjgKBsOHmX9wSp2ltRin+AuSIlx8/UFY7n+nCwsC6oaWiiubqKuyUOrbfAagzGG3KHR/gbDPVXf3MqynWW8vqWEFXsqcFgWSdHhDI12Ex8Vhtc2NLfaNLfauJ0OxqfHMDkrnsmZcVQfa+HtHWW8vbOMQ5XHuqz96emZ/PhzU1UxJSIiIiIiMoAoqSMhtb24hq/9eTN7y+v9j8VHhXH1lAxsY3h3VznFxzWAPmdYPP+5cByzc5N6dV6P16a4upHCqkbKaptoavXS7PElRMpqm9hZUsuu0jpqGj1dXpudGMm5wxM5d3gibpeDn76zh8KqRsC31ay+2UOTxz7puYcnRXHxmGQuGpPM5Mw4kmPc/mSKx2uzqaCa9/ce4VBlA00eL00em2MtrXxcVENL68nX7a5wl4NJGbGMTYtlTGo049NjmT0iUQkdERERERGRAUZJHQm5xhYvP3l7N0VHG7lmagaXjk/B7fJtt2of1f6PTYd5ZvUBf7Jk7thklszJ5fyRSTgcp05GlNc1saWwhu3FtWwrrmFnSS3F1Y0nrLj5JJfDYkxqDLNGJDJzeAIzcxJJi+vcZ6a51cszHxzkl8v3Utfcsd0sJcZXQeOwLJwOC2NgT1kdrZ84cWyEi5Ep0US7XXx06OgJt7e1yx06hCsmp7NwUhoxES6O1LdQ1dBC9bEWXE6LcKeTcJeD+mYP2w7XsvVwDdsP1xDmcnDp2BQum5DKRWOS+3SrmIiIiIiIiASHkjoyYJTXNvHzZfn8eX0h3rbESGZ8JNfPyOKaqelkJUT5G0XXNXl4c1sp//joMGsPVHKi79yIMAfZCVGkxUUQGebEHeYk3OkgISqMcemxjE+PYVRKtD/BdDrVx1rYU1ZPaqybtLiIE76ursnD6n2VrNhTwZp9lRyqbOiSXEocEs75I5OYkhVHVLirbWqZg1Ep0YxNjelxRU37batKHBERERERkbOLkjoy4Bw40sDv39/PPzcXd2nEHB8VRmpMBAcrG2g+bqvSmNRoJmXGMSkjjokZsYxIHkJytDvkiY4mj5eDlQ3sLa/naEML5+QkMD4t9rTVRyIiIiIiIiJK6siA1eTx8tb2Ul7eUMT6g1WdkjgAI5OH8OlzsrhmagbZiVEhilJEREREREQkOHqS81ATDulXIsKcXDstk2unZWKMobaxlbK6JkprmkgcEs7EjNiQV+KIiIiIiIiI9AdK6ki/ZVkWcVFhxEWFMSY1JtThiIiIiIiIiPQrjlAHICIiIiIiIiIiPaekjoiIiIiIiIjIAKSkjoiIiIiIiIjIAKSkjoiIiIiIiIjIAKSkjoiIiIiIiIjIAKSkjoiIiIiIiIjIABTSpM4TTzzB8OHDiYiIYPbs2Xz44YehDEdEREREREREZMAIWVLnL3/5Cw8++CCPPPIIH330EVOnTmXBggWUl5eHKiQRERERERERkQEjZEmdn/zkJ9x5553cfvvtTJgwgV/96ldERUXxhz/8IVQhiYiIiIiIiIgMGCFJ6rS0tLBx40bmz5/fEYjDwfz581mzZk2X45ubm6mtre30JSIiIiIiIiIymIUkqXPkyBG8Xi+pqamdHk9NTaW0tLTL8Y8++ihxcXH+r+zs7L4KVURERERERESkXxoQ068eeughampq/F+FhYWhDklEREREREREJKRcoTjp0KFDcTqdlJWVdXq8rKyMtLS0Lse73W7cbndfhSciIiIiIiIi0u+FpFInPDycGTNmsGzZMv9jtm2zbNky8vLyQhGSiIiIiIiIiMiAEpJKHYAHH3yQW2+9lZkzZzJr1ix+9rOf0dDQwO233x6qkEREREREREREBoyQJXVuuOEGKioq+M53vkNpaSnTpk1j6dKlXZoni4iIiIiIiIhIV5YxxoQ6iJ6qra0lLi6OmpoaYmNjQx2OiIiIiIiIiEhA9CTnEbJKnd5oz0PV1taGOBIRERERERERkcBpz3V0pwZnQCZ16urqAMjOzg5xJCIiIiIiIiIigVdXV0dcXNwpjxmQ269s26a4uJiYmBgsywp1ON1WW1tLdnY2hYWF2jYmgu4JkRPRfSHSme4Jkc50T4h0djbeE8YY6urqyMjIwOE49dDyAVmp43A4yMrKCnUYZyw2Nvas+WYTCQTdEyJd6b4Q6Uz3hEhnuidEOjvb7onTVei0O3XKR0RERERERERE+iUldUREREREREREBiAldfqQ2+3mkUcewe12hzoUkX5B94RIV7ovRDrTPSHSme4Jkc4G+z0xIBsli4iIiIiIiIgMdqrUEREREREREREZgJTUEREREREREREZgJTUEREREREREREZgJTUEREREREREREZgJTU6aFHH32Uc889l5iYGFJSUrjuuuvYvXt3p2Oampq49957SUpKIjo6muuvv56ysrJOx3z1q19lxowZuN1upk2bdsJzvfTSS0ybNo2oqChycnL40Y9+FKzLEjljgbgnPv74Y2666Says7OJjIxk/Pjx/PznP+9yrvfee49zzjkHt9vNqFGjeOaZZ4J9eSI91lf3RElJCTfffDNjxozB4XBw//3398XlifRYX90Tf//737nssstITk4mNjaWvLw83nrrrT65RpGe6Kt74v333+eCCy4gKSmJyMhIxo0bx09/+tM+uUaRnujL3yfaffDBB7hcrpP+Lj6QKKnTQytWrODee+9l7dq1vP3223g8Hi6//HIaGhr8xzzwwAO8+uqrvPzyy6xYsYLi4mI+/elPd1nri1/8IjfccMMJz/Pmm2+yePFi7rnnHrZt28aTTz7JT3/6U375y18G7dpEzkQg7omNGzeSkpLCc889x/bt2/nWt77FQw891On7/cCBA1x55ZXMnTuXzZs3c//993PHHXfoDbv0O311TzQ3N5OcnMzDDz/M1KlT+/QaRXqir+6JlStXctlll/HGG2+wceNG5s6dy9VXX82mTZv69HpFTqev7okhQ4Zw3333sXLlSnbu3MnDDz/Mww8/zG9+85s+vV6R0+mre6JddXU1X/jCF5g3b16fXF/QGemV8vJyA5gVK1YYY4yprq42YWFh5uWXX/Yfs3PnTgOYNWvWdHn9I488YqZOndrl8Ztuusl85jOf6fTY448/brKysoxt24G9CJEA6u090e7LX/6ymTt3rv/v3/jGN8zEiRM7HXPDDTeYBQsWBPgKRAIrWPfE8S6++GLzta99LaBxiwRLX9wT7SZMmGC+973vBSZwkSDpy3viU5/6lLnlllsCE7hIkAT7nrjhhhvMww8/fNLfxQcaVer0Uk1NDQCJiYmAL0Po8XiYP3++/5hx48YxbNgw1qxZ0+11m5ubiYiI6PRYZGQkRUVFHDp0KACRiwRHoO6Jmpoa/xoAa9as6bQGwIIFC3p0X4mEQrDuCZGBqq/uCdu2qaur030j/V5f3RObNm1i9erVXHzxxQGKXCQ4gnlPPP300+zfv59HHnkkCJGHhivUAQxktm1z//33c8EFFzBp0iQASktLCQ8PJz4+vtOxqamplJaWdnvtBQsW8MADD3Dbbbcxd+5c9u7dy49//GPA10dh+PDhgboMkYAJ1D2xevVq/vKXv/D666/7HystLSU1NbXLGrW1tTQ2NhIZGRnYixEJgGDeEyIDUV/eE4899hj19fV87nOfC1j8IoHWF/dEVlYWFRUVtLa28t3vfpc77rgj4NchEijBvCfy8/P55je/yapVq3C5zp5UyNlzJSFw7733sm3bNt5///2Ar33nnXeyb98+rrrqKjweD7GxsXzta1/ju9/9Lg6HCqykfwrEPbFt2zauvfZaHnnkES6//PIARifS93RPiHTWV/fECy+8wPe+9z3++c9/kpKScsbnEgm2vrgnVq1aRX19PWvXruWb3/wmo0aN4qabbupN2CJBE6x7wuv1cvPNN/O9732PMWPGBCrcfkHZgTN033338dprr/Huu++SlZXlfzwtLY2Wlhaqq6s7HV9WVkZaWlq317csi//7v/+jvr6eQ4cOUVpayqxZswDIzc0NyDWIBFIg7okdO3Ywb9487rrrLh5++OFOz6WlpXWZIldWVkZsbKyqdKRfCvY9ITLQ9NU98ec//5k77riDl156qcu2XZH+pK/uiREjRjB58mTuvPNOHnjgAb773e8G+lJEAiKY90RdXR0bNmzgvvvuw+Vy4XK5+P73v8/HH3+My+Vi+fLlQb22YFJSp4eMMdx333384x//YPny5YwYMaLT8zNmzCAsLIxly5b5H9u9ezcFBQXk5eX1+HxOp5PMzEzCw8N58cUXycvLIzk5udfXIRIogbontm/fzty5c7n11lv57//+7y7nycvL67QGwNtvv31G95VIMPXVPSEyUPTlPfHiiy9y++238+KLL3LllVcG54JEeimUPyds26a5uTkwFyISIH1xT8TGxrJ161Y2b97s/7rnnnsYO3YsmzdvZvbs2cG9yGAKZZfmgehLX/qSiYuLM++9954pKSnxfx07dsx/zD333GOGDRtmli9fbjZs2GDy8vJMXl5ep3Xy8/PNpk2bzN13323GjBljNm3aZDZt2mSam5uNMcZUVFSYp556yuzcudNs2rTJfPWrXzURERFm3bp1fXq9IqcTiHti69atJjk52dxyyy2d1igvL/cfs3//fhMVFWW+/vWvm507d5onnnjCOJ1Os3Tp0j69XpHT6at7whjj/9kxY8YMc/PNN5tNmzaZ7du399m1inRHX90Tzz//vHG5XOaJJ57odEx1dXWfXq/I6fTVPfHLX/7S/Otf/zJ79uwxe/bsMb/73e9MTEyM+da3vtWn1ytyOn353ul4Z8v0KyV1egg44dfTTz/tP6axsdF8+ctfNgkJCSYqKsp86lOfMiUlJZ3Wufjii0+4zoEDB4wxvqTOeeedZ4YMGWKioqLMvHnzzNq1a/vwSkW6JxD3xCOPPHLCNXJycjqd69133zXTpk0z4eHhJjc3t9M5RPqLvrwnunOMSKj11T1xsvdWt956a99drEg39NU98fjjj5uJEyeaqKgoExsba6ZPn26efPJJ4/V6+/BqRU6vL987He9sSepYxhhzZjU+IiIiIiIiIiISKuqpIyIiIiIiIiIyACmpIyIiIiIiIiIyACmpIyIiIiIiIiIyACmpIyIiIiIiIiIyACmpIyIiIiIiIiIyACmpIyIiIiIiIiIyACmpIyIiIiIiIiIyACmpIyIiIiIiIiIyACmpIyIiIiIiIiIyACmpIyIiIiIiIiIyACmpIyIiIiIiIiIyACmpIyIiIiIiIiIyAP3/BVF8lJmVt98AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1400x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "forecaster.forecast_validation(period='5y', validation_periods=52, forecast_period_only=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-01-14 00:40:25,242 - root - INFO - Forecasting for TSLA\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "forecaster.forecast()\n",
    "forecaster.plot_forecast(forecast_only=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ticker = 'TSLA'\n",
    "# plt.figure(figsize=(14,6))\n",
    "# ax = plt.subplot()\n",
    "# ax.set_title(f'Forecast for {ticker}')\n",
    "# ax.plot(forecaster.TSLA['forecast'].to_timestamp(), color='salmon', label='Forecast')\n",
    "# # ax.plot(forecaster.TSLA['ts'].to_timestamp(), color='grey', label='Actual')\n",
    "# ax.minorticks_on()\n",
    "# ax.set_xticklabels(forecaster.TSLA['forecast'].to_timestamp().index.strftime('%Y-%m-%d'), rotation = 45, minor=True, fontsize=8)\n",
    "# # ax.xaxis.set_tick_params(which='major', bottom=False)\n",
    "# ax.grid(which='minor')\n",
    "# ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"simpletable\">\n",
       "<caption>SARIMAX Results</caption>\n",
       "<tr>\n",
       "  <th>Dep. Variable:</th>               <td>Close</td>             <th>  No. Observations:  </th>    <td>262</td>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Model:</th>           <td>ARIMA(0, 1, 1)x(2, 1, [], 52)</td> <th>  Log Likelihood     </th> <td>-926.625</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Date:</th>                  <td>Fri, 12 Jan 2024</td>        <th>  AIC                </th> <td>1861.249</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Time:</th>                      <td>01:44:55</td>            <th>  BIC                </th> <td>1874.619</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Sample:</th>                   <td>01-13-2019</td>           <th>  HQIC               </th> <td>1866.655</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th></th>                         <td>- 01-14-2024</td>          <th>                     </th>     <td> </td>   \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Covariance Type:</th>              <td>opg</td>              <th>                     </th>     <td> </td>   \n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "      <td></td>         <th>coef</th>     <th>std err</th>      <th>z</th>      <th>P>|z|</th>  <th>[0.025</th>    <th>0.975]</th>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>ma.L1</th>     <td>    0.0464</td> <td>    0.063</td> <td>    0.740</td> <td> 0.459</td> <td>   -0.076</td> <td>    0.169</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>ar.S.L52</th>  <td>   -0.7538</td> <td>    0.070</td> <td>  -10.706</td> <td> 0.000</td> <td>   -0.892</td> <td>   -0.616</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>ar.S.L104</th> <td>   -0.5522</td> <td>    0.067</td> <td>   -8.275</td> <td> 0.000</td> <td>   -0.683</td> <td>   -0.421</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>sigma2</th>    <td>  324.2618</td> <td>   33.832</td> <td>    9.584</td> <td> 0.000</td> <td>  257.952</td> <td>  390.571</td>\n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "  <th>Ljung-Box (L1) (Q):</th>     <td>0.00</td> <th>  Jarque-Bera (JB):  </th> <td>4.05</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Prob(Q):</th>                <td>0.99</td> <th>  Prob(JB):          </th> <td>0.13</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Heteroskedasticity (H):</th> <td>2.51</td> <th>  Skew:              </th> <td>0.03</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Prob(H) (two-sided):</th>    <td>0.00</td> <th>  Kurtosis:          </th> <td>3.68</td>\n",
       "</tr>\n",
       "</table><br/><br/>Warnings:<br/>[1] Covariance matrix calculated using the outer product of gradients (complex-step)."
      ],
      "text/latex": [
       "\\begin{center}\n",
       "\\begin{tabular}{lclc}\n",
       "\\toprule\n",
       "\\textbf{Dep. Variable:}          &             Close             & \\textbf{  No. Observations:  } &    262      \\\\\n",
       "\\textbf{Model:}                  & ARIMA(0, 1, 1)x(2, 1, [], 52) & \\textbf{  Log Likelihood     } &  -926.625   \\\\\n",
       "\\textbf{Date:}                   &        Fri, 12 Jan 2024       & \\textbf{  AIC                } &  1861.249   \\\\\n",
       "\\textbf{Time:}                   &            01:44:55           & \\textbf{  BIC                } &  1874.619   \\\\\n",
       "\\textbf{Sample:}                 &           01-13-2019          & \\textbf{  HQIC               } &  1866.655   \\\\\n",
       "\\textbf{}                        &          - 01-14-2024         & \\textbf{                     } &             \\\\\n",
       "\\textbf{Covariance Type:}        &              opg              & \\textbf{                     } &             \\\\\n",
       "\\bottomrule\n",
       "\\end{tabular}\n",
       "\\begin{tabular}{lcccccc}\n",
       "                   & \\textbf{coef} & \\textbf{std err} & \\textbf{z} & \\textbf{P$> |$z$|$} & \\textbf{[0.025} & \\textbf{0.975]}  \\\\\n",
       "\\midrule\n",
       "\\textbf{ma.L1}     &       0.0464  &        0.063     &     0.740  &         0.459        &       -0.076    &        0.169     \\\\\n",
       "\\textbf{ar.S.L52}  &      -0.7538  &        0.070     &   -10.706  &         0.000        &       -0.892    &       -0.616     \\\\\n",
       "\\textbf{ar.S.L104} &      -0.5522  &        0.067     &    -8.275  &         0.000        &       -0.683    &       -0.421     \\\\\n",
       "\\textbf{sigma2}    &     324.2618  &       33.832     &     9.584  &         0.000        &      257.952    &      390.571     \\\\\n",
       "\\bottomrule\n",
       "\\end{tabular}\n",
       "\\begin{tabular}{lclc}\n",
       "\\textbf{Ljung-Box (L1) (Q):}     & 0.00 & \\textbf{  Jarque-Bera (JB):  } & 4.05  \\\\\n",
       "\\textbf{Prob(Q):}                & 0.99 & \\textbf{  Prob(JB):          } & 0.13  \\\\\n",
       "\\textbf{Heteroskedasticity (H):} & 2.51 & \\textbf{  Skew:              } & 0.03  \\\\\n",
       "\\textbf{Prob(H) (two-sided):}    & 0.00 & \\textbf{  Kurtosis:          } & 3.68  \\\\\n",
       "\\bottomrule\n",
       "\\end{tabular}\n",
       "%\\caption{SARIMAX Results}\n",
       "\\end{center}\n",
       "\n",
       "Warnings: \\newline\n",
       " [1] Covariance matrix calculated using the outer product of gradients (complex-step)."
      ],
      "text/plain": [
       "<class 'statsmodels.iolib.summary.Summary'>\n",
       "\"\"\"\n",
       "                                     SARIMAX Results                                     \n",
       "=========================================================================================\n",
       "Dep. Variable:                             Close   No. Observations:                  262\n",
       "Model:             ARIMA(0, 1, 1)x(2, 1, [], 52)   Log Likelihood                -926.625\n",
       "Date:                           Fri, 12 Jan 2024   AIC                           1861.249\n",
       "Time:                                   01:44:55   BIC                           1874.619\n",
       "Sample:                               01-13-2019   HQIC                          1866.655\n",
       "                                    - 01-14-2024                                         \n",
       "Covariance Type:                             opg                                         \n",
       "==============================================================================\n",
       "                 coef    std err          z      P>|z|      [0.025      0.975]\n",
       "------------------------------------------------------------------------------\n",
       "ma.L1          0.0464      0.063      0.740      0.459      -0.076       0.169\n",
       "ar.S.L52      -0.7538      0.070    -10.706      0.000      -0.892      -0.616\n",
       "ar.S.L104     -0.5522      0.067     -8.275      0.000      -0.683      -0.421\n",
       "sigma2       324.2618     33.832      9.584      0.000     257.952     390.571\n",
       "===================================================================================\n",
       "Ljung-Box (L1) (Q):                   0.00   Jarque-Bera (JB):                 4.05\n",
       "Prob(Q):                              0.99   Prob(JB):                         0.13\n",
       "Heteroskedasticity (H):               2.51   Skew:                             0.03\n",
       "Prob(H) (two-sided):                  0.00   Kurtosis:                         3.68\n",
       "===================================================================================\n",
       "\n",
       "Warnings:\n",
       "[1] Covariance matrix calculated using the outer product of gradients (complex-step).\n",
       "\"\"\""
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "forecaster.TSLA['model'].summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>current</th>\n",
       "      <th>profit %</th>\n",
       "      <th>action</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2024-05-13/2024-05-19</th>\n",
       "      <td>169.757234</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-10-28/2024-11-03</th>\n",
       "      <td>294.798677</td>\n",
       "      <td>73.66</td>\n",
       "      <td>sell</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                          current profit % action\n",
       "2024-05-13/2024-05-19  169.757234             buy\n",
       "2024-10-28/2024-11-03  294.798677    73.66   sell"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "forecaster.find_max_profit()\n",
    "forecaster['TSLA']['max_profit']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>current</th>\n",
       "      <th>profit %</th>\n",
       "      <th>action</th>\n",
       "      <th>hold period</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2024-01-22/2024-01-28</th>\n",
       "      <td>220.744556</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-01-29/2024-02-04</th>\n",
       "      <td>239.695939</td>\n",
       "      <td>8.59</td>\n",
       "      <td>sell</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-02-26/2024-03-03</th>\n",
       "      <td>189.102926</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-03-25/2024-03-31</th>\n",
       "      <td>219.780777</td>\n",
       "      <td>16.22</td>\n",
       "      <td>sell</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-04-01/2024-04-07</th>\n",
       "      <td>213.103979</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-04-08/2024-04-14</th>\n",
       "      <td>221.918873</td>\n",
       "      <td>4.14</td>\n",
       "      <td>sell</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-05-13/2024-05-19</th>\n",
       "      <td>169.89439</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-05-20/2024-05-26</th>\n",
       "      <td>187.697599</td>\n",
       "      <td>10.48</td>\n",
       "      <td>sell</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-05-27/2024-06-02</th>\n",
       "      <td>184.23273</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-06-17/2024-06-23</th>\n",
       "      <td>210.387466</td>\n",
       "      <td>14.2</td>\n",
       "      <td>sell</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-06-24/2024-06-30</th>\n",
       "      <td>209.235346</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-07-01/2024-07-07</th>\n",
       "      <td>213.050867</td>\n",
       "      <td>1.82</td>\n",
       "      <td>sell</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-07-08/2024-07-14</th>\n",
       "      <td>210.262153</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-07-22/2024-07-28</th>\n",
       "      <td>226.004599</td>\n",
       "      <td>7.49</td>\n",
       "      <td>sell</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-07-29/2024-08-04</th>\n",
       "      <td>223.286852</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-08-05/2024-08-11</th>\n",
       "      <td>226.24414</td>\n",
       "      <td>1.32</td>\n",
       "      <td>sell</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-08-12/2024-08-18</th>\n",
       "      <td>212.085661</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-09-09/2024-09-15</th>\n",
       "      <td>242.51722</td>\n",
       "      <td>14.35</td>\n",
       "      <td>sell</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-09-30/2024-10-06</th>\n",
       "      <td>227.702622</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-10-28/2024-11-03</th>\n",
       "      <td>294.925674</td>\n",
       "      <td>29.52</td>\n",
       "      <td>sell</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-11-04/2024-11-10</th>\n",
       "      <td>256.574361</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-11-11/2024-11-17</th>\n",
       "      <td>277.305597</td>\n",
       "      <td>8.08</td>\n",
       "      <td>sell</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-12-09/2024-12-15</th>\n",
       "      <td>238.354834</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-12-16/2024-12-22</th>\n",
       "      <td>257.400227</td>\n",
       "      <td>7.99</td>\n",
       "      <td>sell</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-12-30/2025-01-05</th>\n",
       "      <td>244.290872</td>\n",
       "      <td></td>\n",
       "      <td>buy</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2025-01-06/2025-01-12</th>\n",
       "      <td>247.729578</td>\n",
       "      <td>1.41</td>\n",
       "      <td>sell</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>Compound gain</td>\n",
       "      <td>222.34</td>\n",
       "      <td></td>\n",
       "      <td>25</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                             current profit % action hold period\n",
       "2024-01-22/2024-01-28     220.744556             buy            \n",
       "2024-01-29/2024-02-04     239.695939     8.59   sell           1\n",
       "2024-02-26/2024-03-03     189.102926             buy            \n",
       "2024-03-25/2024-03-31     219.780777    16.22   sell           4\n",
       "2024-04-01/2024-04-07     213.103979             buy            \n",
       "2024-04-08/2024-04-14     221.918873     4.14   sell           1\n",
       "2024-05-13/2024-05-19      169.89439             buy            \n",
       "2024-05-20/2024-05-26     187.697599    10.48   sell           1\n",
       "2024-05-27/2024-06-02      184.23273             buy            \n",
       "2024-06-17/2024-06-23     210.387466     14.2   sell           3\n",
       "2024-06-24/2024-06-30     209.235346             buy            \n",
       "2024-07-01/2024-07-07     213.050867     1.82   sell           1\n",
       "2024-07-08/2024-07-14     210.262153             buy            \n",
       "2024-07-22/2024-07-28     226.004599     7.49   sell           2\n",
       "2024-07-29/2024-08-04     223.286852             buy            \n",
       "2024-08-05/2024-08-11      226.24414     1.32   sell           1\n",
       "2024-08-12/2024-08-18     212.085661             buy            \n",
       "2024-09-09/2024-09-15      242.51722    14.35   sell           4\n",
       "2024-09-30/2024-10-06     227.702622             buy            \n",
       "2024-10-28/2024-11-03     294.925674    29.52   sell           4\n",
       "2024-11-04/2024-11-10     256.574361             buy            \n",
       "2024-11-11/2024-11-17     277.305597     8.08   sell           1\n",
       "2024-12-09/2024-12-15     238.354834             buy            \n",
       "2024-12-16/2024-12-22     257.400227     7.99   sell           1\n",
       "2024-12-30/2025-01-05     244.290872             buy            \n",
       "2025-01-06/2025-01-12     247.729578     1.41   sell           1\n",
       "26                     Compound gain   222.34                 25"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "forecaster.find_best_trades()\n",
    "forecaster.TSLA['best_trades']"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}