arima.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import stats\n",
    "from keras.metrics import MAE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lag_view(x, order):\n",
    "    \"\"\"\n",
    "    For every value X_i create a row that lags k values: [X_i-1, X_i-2, ... X_i-k]\n",
    "    \"\"\"\n",
    "    y = x.copy()\n",
    "    # Create features by shifting the window of `order` size by one step.\n",
    "    # This results in a 2D array [[t1, t2, t3], [t2, t3, t4], ... [t_k-2, t_k-1, t_k]]\n",
    "    x = np.array([y[-(i + order):][:order] for i in range(y.shape[0])])\n",
    "    \n",
    "    # Reverse the array as we started at the end and remove duplicates.\n",
    "    # Note that we truncate the features [order -1:] and the labels [order]\n",
    "    # This is the shifting of the features with one time step compared to the labels\n",
    "    x = np.stack(x)[::-1][order - 1: -1]\n",
    "    y = y[order:]\n",
    "\n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ma_process(eps, theta):\n",
    "    \"\"\"\n",
    "    Creates an MA(q) process with a zero mean (mean not included in implementation).\n",
    "    :param eps: (array) White noise signal.\n",
    "    :param theta: (array/ list) Parameters of the process.\n",
    "    \"\"\"\n",
    "    # reverse the order of theta as Xt, Xt-1, Xt-k in an array is Xt-k, Xt-1, Xt.\n",
    "    theta = np.array([1] + list(theta))[::-1][:, None]\n",
    "    eps_q, _ = lag_view(eps, len(theta))\n",
    "    return eps_q @ theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pearson_correlation(x, y):\n",
    "    return np.mean((x - x.mean()) * (y - y.mean())) / (x.std() * y.std())\n",
    "\n",
    "def acf(x, lag=40):\n",
    "    \"\"\"\n",
    "    Determine autocorrelation factors.\n",
    "    :param x: (array) Time series.\n",
    "    :param lag: (int) Number of lags.\n",
    "    \"\"\"\n",
    "    return np.array([1] + [pearson_correlation(x[:-i], x[i:]) for i in range(1, lag)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bartletts_formula(acf_array, n):\n",
    "    \"\"\"\n",
    "    Computes the Standard Error of an acf with Bartlet's formula\n",
    "    Read more at: https://en.wikipedia.org/wiki/Correlogram\n",
    "    :param acf_array: (array) Containing autocorrelation factors\n",
    "    :param n: (int) Length of original time series sequence.\n",
    "    \"\"\"\n",
    "    # The first value has autocorrelation with it self. So that values is skipped\n",
    "    se = np.zeros(len(acf_array) - 1)\n",
    "    se[0] = 1 / np.sqrt(n)\n",
    "    se[1:] = np.sqrt((1 + 2 * np.cumsum(acf_array[1:-1]**2)) / n )\n",
    "    return se\n",
    "\n",
    "\n",
    "def plot_acf(x, alpha=0.05, lag=40):\n",
    "    \"\"\"\n",
    "    :param x: (array)\n",
    "    :param alpha: (flt) Statistical significance for confidence interval.\n",
    "    :parm lag: (int)\n",
    "    \"\"\"\n",
    "    acf_val = acf(x, lag)\n",
    "    plt.figure(figsize=(16, 4))\n",
    "    plt.vlines(np.arange(lag), 0, acf_val)\n",
    "    plt.scatter(np.arange(lag), acf_val, marker='o')\n",
    "    plt.xlabel('lag')\n",
    "    plt.ylabel('autocorrelation')\n",
    "    \n",
    "    # Determine confidence interval\n",
    "    ci = stats.norm.ppf(1 - alpha / 2.) * bartletts_formula(acf_val, len(x))\n",
    "    plt.fill_between(np.arange(1, ci.shape[0] + 1), -ci, ci, alpha=0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ar_process(eps, phi):\n",
    "    \"\"\"\n",
    "    Creates a AR process with a zero mean.\n",
    "    \"\"\"\n",
    "    # Reverse the order of phi and add a 1 for current eps_t\n",
    "    phi = np.r_[1, phi][::-1] \n",
    "    ar = eps.copy()\n",
    "    offset = len(phi)\n",
    "    for i in range(offset, ar.shape[0]):\n",
    "        ar[i - 1] = ar[i - offset: i] @ phi\n",
    "    return ar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def least_squares(x, y):\n",
    "    return np.linalg.inv((x.T @ x)) @ (x.T @ y)\n",
    "\n",
    "class LinearModel:\n",
    "    def __init__(self, fit_intercept=True):\n",
    "        self.fit_intercept = fit_intercept\n",
    "        self.beta = None\n",
    "        self.intercept_ = None\n",
    "        self.coef_ = None\n",
    "    \n",
    "    def _prepare_features(self, x):\n",
    "        if self.fit_intercept:\n",
    "            x = np.hstack((np.ones((x.shape[0], 1)), x))\n",
    "        return x\n",
    "    \n",
    "    def fit(self, x, y):\n",
    "        x = self._prepare_features(x)\n",
    "        self.beta = least_squares(x, y)\n",
    "        if self.fit_intercept:\n",
    "            self.intercept_ = self.beta[0]\n",
    "            self.coef_ = self.beta[1:]\n",
    "        else:\n",
    "            self.coef_ = self.beta\n",
    "        \n",
    "    def predict(self, x):\n",
    "        x = self._prepare_features(x)\n",
    "        return x @ self.beta\n",
    "    \n",
    "    def fit_predict(self, x, y):\n",
    "        self.fit(x, y)\n",
    "        return self.predict(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pacf(x, lag=40):\n",
    "    \"\"\"\n",
    "    Partial autocorrelation function.\n",
    "    \n",
    "    pacf results in:\n",
    "        [1, acf_lag_1, pacf_lag_2, pacf_lag_3]\n",
    "    :param x: (array)\n",
    "    :param lag: (int)\n",
    "    \"\"\"\n",
    "    y = []\n",
    "    \n",
    "    # Partial auto correlation needs intermediate terms.\n",
    "    # Therefore we start at index 3\n",
    "    for i in range(3, lag + 2):\n",
    "        backshifted = lag_view(x, i)[0]\n",
    "\n",
    "        xt = backshifted[:, 0]\n",
    "        feat = backshifted[:, 1:-1]\n",
    "        xt_hat = LinearModel(fit_intercept=False).fit_predict(feat, xt)\n",
    "\n",
    "        xt_k = backshifted[:, -1]\n",
    "        xt_k_hat = LinearModel(fit_intercept=False).fit_predict(feat, xt_k)\n",
    "\n",
    "        y.append(pearson_correlation(xt - xt_hat, xt_k - xt_k_hat))\n",
    "    return np.array([1, acf(x, 2)[1]] +  y)\n",
    "\n",
    "def plot_pacf(x, alpha=0.05, lag=40, title=None):\n",
    "    \"\"\"\n",
    "    :param x: (array)\n",
    "    :param alpha: (flt) Statistical significance for confidence interval.\n",
    "    :parm lag: (int)\n",
    "    \"\"\"\n",
    "    pacf_val = pacf(x, lag)\n",
    "    plt.figure(figsize=(16, 4))\n",
    "    plt.vlines(np.arange(lag + 1), 0, pacf_val)\n",
    "    plt.scatter(np.arange(lag + 1), pacf_val, marker='o')\n",
    "    plt.xlabel('lag')\n",
    "    plt.ylabel('autocorrelation')\n",
    "    \n",
    "    # Determine confidence interval\n",
    "    ci = stats.norm.ppf(1 - alpha / 2.) * bartletts_formula(pacf_val, len(x))\n",
    "    plt.fill_between(np.arange(1, ci.shape[0] + 1), -ci, ci, alpha=0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def difference(x, d=1):\n",
    "    if d == 0:\n",
    "        return x\n",
    "    else:\n",
    "        x = np.r_[x[0], np.diff(x)]\n",
    "        return difference(x, d - 1)\n",
    "    \n",
    "def undo_difference(x, d=1):\n",
    "    if d == 1:\n",
    "        return np.cumsum(x)\n",
    "    else:\n",
    "        x = np.cumsum(x)\n",
    "        return undo_difference(x, d - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ARIMA(LinearModel):\n",
    "    def __init__(self, q, d, p):\n",
    "        \"\"\"\n",
    "        An ARIMA model.\n",
    "        :param q: (int) Order of the MA model.\n",
    "        :param p: (int) Order of the AR model.\n",
    "        :param d: (int) Number of times the data needs to be differenced.\n",
    "        \"\"\"\n",
    "        super().__init__(True)\n",
    "        self.p = p\n",
    "        self.d = d\n",
    "        self.q = q\n",
    "        self.ar = None\n",
    "        self.resid = None\n",
    "        \n",
    "    def prepare_features(self, x):\n",
    "        if self.d > 0:\n",
    "            x = difference(x, self.d)\n",
    "                    \n",
    "        ar_features = None\n",
    "        ma_features = None\n",
    "        \n",
    "        # Determine the features and the epsilon terms for the MA process\n",
    "        if self.q > 0:\n",
    "            if self.ar is None:\n",
    "                self.ar = ARIMA(0, 0, self.p)\n",
    "                self.ar.fit_predict(x)\n",
    "            eps = self.ar.resid\n",
    "            eps[0] = 0\n",
    "            \n",
    "            # prepend with zeros as there are no residuals_t-k in the first X_t\n",
    "            ma_features, _ = lag_view(np.r_[np.zeros(self.q), eps], self.q)\n",
    "            \n",
    "        # Determine the features for the AR process\n",
    "        if self.p > 0:\n",
    "            # prepend with zeros as there are no X_t-k in the first X_t\n",
    "            ar_features = lag_view(np.r_[np.zeros(self.p), x], self.p)[0]\n",
    "                                \n",
    "        if ar_features is not None and ma_features is not None:\n",
    "            n = min(len(ar_features), len(ma_features)) \n",
    "            ar_features = ar_features[:n]\n",
    "            ma_features = ma_features[:n]\n",
    "            features = np.hstack((ar_features, ma_features))\n",
    "        elif ma_features is not None: \n",
    "            n = len(ma_features)\n",
    "            features = ma_features[:n]\n",
    "        else:\n",
    "            n = len(ar_features)\n",
    "            features = ar_features[:n]\n",
    "        \n",
    "        return features, x[:n]\n",
    "    \n",
    "    def fit(self, x):\n",
    "        features, x = self.prepare_features(x)\n",
    "        super().fit(features, x)\n",
    "        return features\n",
    "            \n",
    "    def fit_predict(self, x): \n",
    "        \"\"\"\n",
    "        Fit and transform input\n",
    "        :param x: (array) with time series.\n",
    "        \"\"\"\n",
    "        features = self.fit(x)\n",
    "        return self.predict(x, prepared=(features))\n",
    "    \n",
    "    def predict(self, x, **kwargs):\n",
    "        \"\"\"\n",
    "        :param x: (array)\n",
    "        :kwargs:\n",
    "            prepared: (tpl) containing the features, eps and x\n",
    "        \"\"\"\n",
    "        features = kwargs.get('prepared', None)\n",
    "        if features is None:\n",
    "            features, x = self.prepare_features(x)\n",
    "        \n",
    "        y = super().predict(features)\n",
    "        self.resid = x - y\n",
    "\n",
    "        return self.return_output(y)\n",
    "    \n",
    "    def return_output(self, x):\n",
    "        if self.d > 0:\n",
    "            x = undo_difference(x, self.d) \n",
    "        return x\n",
    "    \n",
    "    def forecast(self, x, n):\n",
    "        \"\"\"\n",
    "        Forecast the time series.\n",
    "        \n",
    "        :param x: (array) Current time steps.\n",
    "        :param n: (int) Number of time steps in the future.\n",
    "        \"\"\"\n",
    "        features, x = self.prepare_features(x)\n",
    "        y = super().predict(features)\n",
    "        \n",
    "        # Append n time steps as zeros. Because the epsilon terms are unknown\n",
    "        y = np.r_[y, np.zeros(n)]\n",
    "        for i in range(n):\n",
    "            feat = np.r_[y[-(self.p + n) + i: -n + i], np.zeros(self.q)]\n",
    "            y[x.shape[0] + i] = super().predict(feat[None, :])\n",
    "        return self.return_output(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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>Day</th>\n",
       "      <th>Price</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>19970107</td>\n",
       "      <td>3.82</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>19970108</td>\n",
       "      <td>3.80</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>19970109</td>\n",
       "      <td>3.61</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>19970110</td>\n",
       "      <td>3.92</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>19970113</td>\n",
       "      <td>4.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Day  Price\n",
       "0  19970107   3.82\n",
       "1  19970108   3.80\n",
       "2  19970109   3.61\n",
       "3  19970110   3.92\n",
       "4  19970113   4.00"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.read_csv('./data/daily.csv')\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_acf(data.Price)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA5gAAAHSCAYAAACJlGSeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACsi0lEQVR4nOzdd3hc1fHw8e/drpW0q94lS66yLfeCMcVgG1NDSyBASEgDEhLSkze9kvZLI5VAICSQ0EPvYMCAMe5ytyRLsnpvK20v9/3jrIpxk2TJsqz5PA+P7Lt37z0rY3lnZ86Mpus6QgghhBBCCCHEiTKM9QKEEEIIIYQQQpweJMAUQgghhBBCCDEiJMAUQgghhBBCCDEiJMAUQgghhBBCCDEiJMAUQgghhBBCCDEiJMAUQgghhBBCCDEiTKNx0ZSUFD0/P380Li2EEEIIIYQQYgxt3bq1Vdf11CM9NioBZn5+Plu2bBmNSwshhBBCCCGEGEOaplUd7TEpkRVCCCGEEEIIMSIkwBRCCCGEEEIIMSIkwBRCCCGEEEIIMSIkwBRCCCGEEEIIMSIkwBRCCCGEEEIIMSIkwBRCCCGEEEIIMSIGFWBqmvZVTdP2aJq2W9O0hzVNs432woQQQgghhBBCjC/HDTA1TcsGvgQs1nW9CDAC1432woQQQgghhBBCjC+DLZE1ATGappkAO1A/eksSQgghhBBCCDEeHTfA1HW9DvgtUA00AF26rr862gsTQgghhBBCCDG+DKZENhG4AigAsoBYTdNuPMJ5t2iatkXTtC0tLS0jv1IhhBBCCCGEEKe0wZTIrgYqdV1v0XU9CDwJLP/gSbqu36Pr+mJd1xenpqaO9DqFEEIIIYQQQpziBhNgVgPLNE2za5qmAauAfaO7LCGEEEIIIYQQ481g9mBuBJ4AtgG7os+5Z5TXJYQQQgghhBBinDEN5iRd138E/GiU1yKEEEIIIYQQYhwb7JgSIYQQQgghhBDimCTAFEIIIYQQQohTRFuPn3BEH+tlDJsEmEIIIYQQQghxiljxm7f42fN7x3oZwyYBphBCCCGEEEKcAnr8IXr8ITKctrFeyrBJgCmEEEIIIYQQp4Amlw+AdId1jFcyfBJgCiGEEEIIIcQpoKmrN8CUDKYQQgghhBBCiBPQGM1gZkiAKYQQQgghhBDiRDS5/IBkMIUQQgghhBBCnKAml494q4lYq2mslzJsEmAKIYQQQgghxCmgsctH+jjuIAsSYAohhBBCCCHEKaHR5RvX+y9BAkwhhBBCCCGEOCU0u3zjev8lSIAphBBCCCGEEGMuEtFp7vaP6xmYIAGmEEIIIYQQQoy5VrefUEQnQ/ZgCiGEEEIIIYQ4Ec2nwYgSkABTCCGEEEIIIcZcY5cPkABTCCGEEEIIIcQJanSpAFO6yAohhBBCCCGEOCHNLh8GDVLiLGO9lBMiAaYQQgghhBBCjLFGl4/UeCsm4/gO0cb36oUQQgghhBDiNNDo8o/7/ZcgAaYQQgghhBBC9Clr6uaWB7awu67rpN63qcsnAaYQQgghhBBCnE7W7m/m1b1NXPW39dy9rpxIRD8p923q9o37Bj8gAaYQQgghhBBC9Gns8mG3GFlVmM4vX9rP5/6zddTv6QuG6fQEyXBKgCmEEEIIIYQQp43mbh8ZTht33biQT59VwKt7m+j0BEb1nk3RESVp8dZRvc/JIAGmEEIIIYQQQkQ1dqlSVU3TOHd6CgD7G7tH9Z5NLj+AZDCFEEIIIYQQ4nTS5PL37YWcE97Ht00PUdIwug1/GqMZTNmDKYQQQgghhBCniUhEp7nbR1o00Es68CSfMz1Pyu77RvW+TV0qwEyXDKYQQgghhBBCnB7aPQGCYZ0Mh9oLqbnqALig4W5o3jdq9210+YgxG4m3mkbtHieLBJhCCCGEEEIIgdp/CQP2QrrqqI4toluPQX/yFgiNTrOfJpdqLKRp2qhc/2SSAFMIIYQQQgghUB1kgb4SWbrq8CYX8d3gZ9Aad8I7vx2V+za5fKRHs6Y07wNvx6jc52SQAFMIIYQQQgghgMauaDdXhw383eDvIjZ1Eq9EltCUcyFs/DuEgyN+3/pOH5nOGNB1+McqWPd/I36Pk0UCTCGEEEIIIYRA7YXUNEiNt0KX2n+ZnD0ZgK2O1eDrguoNI3rPUDhCo8tHdkIM+Doh6AZnzoje42SSAFMIIYQQQgghUN1cU+KsmI0GcNUCEJM8ieyEGF4PzAajFUpeGtF7Nrp8hCM6OYkx0KXuKQGmEEIIIYQQQoxzTd0D9kJGM5g4synMiGdXcwgmr4CSF1Up6wip6/ACkC0BphBCCCGEEEKcPhq7fGr/JUSDPQ3iM5mREU9Fq5vg1Iug4yC0lIzYPWujAWZOor0/wHRIgCmEEEIIIYQQ45rq5to/ooT4DDCaKcx0EI7oVCadrR4reXHE7lnXqQLMTKdNBZhGC8Smjtj1TzYJMIUQQgghhBATnj8UpsMT7A8wu2rBkQ1AYUY8AHt6YiFrwYjuw6zr8JIab8VmNvbf0zB+w7Txu3IhhBBCCCGEGCHNrgEjSkBlMJ0qwCxIicVs1Njf2A0zLoHazdDTPCL3re30qAY/oALMcbz/EiTAFEIIIYQQQggaXT4A0p021cSnq65vL6TZaGBKahwljd0w42JAh9JXRuS+dR1eNaIEJMAUQgghhBBCiNNBU2+A6bCCtwNC3r4MJsCsLAe7arvQ02arwHMEymQjEZ36Tp/qIBsOQXe9BJhCCCGEEEIIMd41dqkAM8NhG9DNtT/AXJKfRJs7QGWbR2Uxy9+AoPeE7tnS4ycQjqgOsj2NoEckwBRCCCGEEEKI8a7J5cNqMuCMMav9l3BIsLckPxGALQc7VIAZ8kLl2yd0z74RJQmnxwxMGESAqWnaDE3Tigf859I07SsnYW1CCCGEEEIIcVI0uvxkOG1omnbEDOaU1DgS7WY2H2yH/LPBEn/C40pqOzwAqsnPaTADEwYRYOq6XqLr+nxd1+cDiwAP8NRoL0wIIYQQQgghTpYml4/0+AEdZA1miEvve1zTNBZNSmJLVQeYrDB1FZS8DJHIsO/ZOwMzOzEGumrUwQH7PsejoZbIrgLKdV2vGo3FCCGEEEIIIcRYaHL5VAdZiHaQzTxsHuWS/EQqW920dPvVuJKeRmjYPux71nV4SbSbsVtM6p62BLDGn8CrGHtDDTCvAx4+0gOapt2iadoWTdO2tLS0nPjKhBBCCCGEEOIk0HWdxi4fGQ6rOuCqO2Kp6uL8JAC2VrXDtAtAM55QN9naDq9q8APRESW5w77WqWLQAaamaRbgcuDxIz2u6/o9uq4v1nV9cWpq6kitTwghhBBCCCFGlcsbwh+KkO7ozWDWHrFUdU62E6vJwKbKDrAnQd6ZQwow//h6Gdfds4FgWJXV1nV+cAbm+C6PhaFlMC8Gtum63jRaixFCCCGEEEKIk62xbwamTe2pdNUf0uCnl8VkYH5uAluq2tWBGRdD027orD7uPf721gH+8Hop71e08/LuRnRfFz0djWr/Jag9mOO8gywMLcC8nqOUxwohhBBCCCHEeHWwzQ1Em+24myESPGqwtyQ/iT31Ltz+kAowQTX7OYYH36/i/14u4fJ5WUxKtnP/+kqCj9/MI9oPyE2wgL8HfJ0TJ8DUNC0WuAB4cnSXI4QQQgghhBAnV3FNJ2ajxqxMh2q2A0fMYAIszk8kHNEprumE5Clq32TtpsPOC4YjvLG/iS8/tJU/PPMeqwrT+N2187jpzHxqqisxlb9GvqGJeZ73B8zdHP97ME2DOUnXdTeQPMprEUIIIYQQQoiTrri6k5mZDmxmI7ii8yiPsh9y4aRENA02H2znrKkpkDEHGncdck5Nu4er/vYerT1+ro3ZzGbbnwld8BZmo4FrFufQ8tpGDETo0OOYfvC/MDlDPfEoQe14MtQuskIIIYQQQghx2ghHdHbWdrIgN0EdaDugviZMOuL5DpuZGenxbK3qUAcy5kBrKQS9fefsrO2itcfPrz88h18u1zDqIawb/gBAvM3MJ+zvszNSwN9DHyK2/j0oe009caKUyAohhBBCCCHE6aisuRt3IMz8vAR1oL4YEgsgJuGoz5mT7WRvvQtd11WAqUegeW/f43WdHgAunpOJsSvaAGj3k9BSCs37yPSW8lTkbF4wrQaTDTbfB5oB4jNH50WeRBJgCiGEEEIIISas7dWdAMzPTVQH6osha/4xn1OU7aTNHVDdZ9OL1MEBZbJ1HV7irSYcNjN0HIT0OWCOgXd+BzseAc2IZ9pVZGVlw9xrVVOh+CwwDmoH4ylt/L8CIYQQQgghhBim4upOEuxm8pPt4G6DrmpY+tljPmd2lgOAPXUuMgsngdUBjbv7Hq/r9PWPH+msUt1mJ6+A9/8GMYkwdRU/++j5RHQd2uJh2wOnxQxMkAymEEIIIYQQYgLbXtPB/NwENE2Dhu3qYOb8Yz5nZqYDTYPd9V1gMKgs5sAMZqeX7IQYCLjB3aL2cy7/Ehgt4GmDuR/FYjKopkIZRTDvBpi2ZhRf5ckjAaYQQgghhBBiQur2BSlr7mHBwPJYgMx5x3xerNXE5JRYdte51IGMOdC0GyIRAOo6PGQlxEBndP9lYj7Ep8PSm8GeAjMuOfSCV90F535jZF7UGJMAUwghhBBCCDEh7artQtcZ0OBnOyRNPmaDn15F2U721Hep32TMgUAPdFTS7Qvi8oVUiWzHQfV4Yr76uvon8OVisNhH9oWcQiTAFEIIIYQQQkxI22s6AZifk6AONOyArAWDem5RlpOGLh9tPX4VYAI07qK+0wegSmQ7qtTx3pEnBiNY40do9acmCTCFEEIIIcS4Vt/pxR8Kj/UyxDi0vbqTyamxOO1mcLdCV81x91/26mv0U++C1ELQjNC4q29EiSqRrQKzHWJTRuslnHIkwBRCCCGEEONWOKJz4Z1v8+CGaKao/A0IBcZ2UWJc0HWd4miDH6B//+UgM5izs5xAtNGP2QapM6BpN3XRDGZOb4lsYj5o2oiu/VQmAaYQQgghhBi3PIEQ3b4QtR1eaK+EB6+C/c+N9bLEOPB+RTutPQEWTYo2+OnrIDt3UM932s3kJsWwZ2Cjn8Zd1HV4MRs1UuOsqkS2tzx2gpAAUwghhBBCjFvegCqNdfmC4O1QBz3tY7giMR74Q2G+9/QucpNiuHpBjjpYXwzJU8HmHPR1irKcKoMJKsB01dHZ2kCmMwaDhiqRTZQAUwghhBBCiHHB3RtgeoNq5iCAv3sMVyTGg7+/VUFFi5ufXVFEjMWoDtYXD3r/Za/ZWQ6q2jzqA45oox9b217V4MfTrjrL9naQnSAkwBRCCCGEEOOWJxACoGtggBnoGcMViVNdeUsPf33zAB+al8V5M9LUwZ4WcNUOev9lr9nZKtu5t94FGXNBM5Dv2nroiBIpkRVCCCGEEGJ88EQzmCrAjAaWfgkwxdH98Jnd2MwGfnDZTHWgcTf852r160nLh3Stot5GP3VdYE8ikr+C88PvkOW0QedBdZKUyAohhBBCCDE+ePpKZEOSwRTH1dztY/2BNm45dzJp8TZ49w9wz3nQ3QAf/Q9kLxzS9VLjrUxKtrOutAWAzimXM0lrZo5WfvgMzAlCAkwhhBBCCDFuefxHKJGVPZjiKLYeVI2gzpqaAm3l8PqPYdoFcNtGmPmhYV3zoqIM3itvo8Md4EDy+fh1E7PaXlMlsvYUsMaN3AsYByTAFEIIIYQQ41Zvkx9vMEyotzRWMpjiKDYf7MBmNqgZlo071cEV/w9ik4d9zUvnZBKO6Ly2t4lqj5l1kXmk17wIHZUTrjwWJMAUQgghhBDjmDfa5Acg4IlmLiWDKY5iS1U783MTsJgM0LQHNAOkFp7QNedkO8lJjOGFXQ3UdXh5Nrwck7sRDq6fcB1kQQJMIYQQQggxjvVmMAEC3t4AUzKY4nBuf4g99S6W5CepA017IXkamG0ndF1N07h0TibrD7Syt6GLHfZlYLaDHp5w+y9BAkwhhBBCCDGOeQYEmGFfNMCUEllxBMU1nYQjOov7AszdkD5rRK59yZxMQhGd1/c1k5SYCDMuUQ9IiawQQgghhBDjR2+TH4Cwr3dMiZTIisNtqmzHoMHCvAT1/0hnFaTPHpFrz81RZbLhiE5OQgzM/ah64ATLb8cjCTCFEEIIIcS45Qn2ZzD1gU1+dH2MViROVVuq2inMcBBvM0PzPnUwbWQCTE3TuGROJgDZiTEwfQ18/j3IPWNErj+eSIAphBBCCCHGLY8/hN1iVL/pHVMSCUHIP3aLEqecYHcLpdX1LMlPVAea9qivI5TBBNVNFiA3Mab/2po2YtcfL0xjvQAhhBBCCCGGyxMIk+G0UdHixhB09z8Q6Dnh5i3i9BF84MP8QjfiL/ivOtC0ByzxkJA3YveYl5vAvZ9YzLIpwx95cjqQDKYQQogJa+2+Jipb3cc/UQhxyvIEwjhjzMSYjRhDnv4HZB/mhPeLF/dx3m/e5H9barC0lbDSsJ2lyUH1YPNe1eBnhDOMq2elE2ed2Dk8CTCFEEJMSLqu86WHt/OXNw6M9VKEECfAEwgRazHhjDFjCnsgJtohVALMCe+tkmZqOrz88ol3MEV8GDWdtKrn1P7cpt0jWh4r+kmAKYQQYkLq8YdwB8KUt8g4AyHGM08gTIzFiCPGhCXshfgM9YCMKpnQAqEIFS1ubjl3Mn+6SO27DGsm2PkIuOrB1wVpIzOiRBxKAkwhhBATUnO3agBS0dKDLt0mhRi3PIEwsRYjCTYjFt0HcenqAb8EmBNZZaubUESnMCOe5clqK4Rx4cehcRfselydlF40his8fUmAKYQQYkJqcvkAcPlCtLl64P5LofKdMV6VEGKoPIEQdquJFFsEA/qADKaUyE4U3b4gL+5qOORYaZP685+WFg8dB9XBs78KmhHe/b36fbpkMEeDBJhCCCEmpJbu/hEGdQfLoOpdKF87hisSQgyH2x/GbjaSYg2pA70BpmQwJ4zHttRy23+3UdLY/6FCaVM3RoPG5NRY6KyC2FRInARTV6vyWGcu2JxjuOrTlwSYQgghJqRmV3+A2VZfqX7R+ym3EGJciER0vMGwymBaot1B42QP5kRT0ugCYPPB9gHHuslPtmMzG6GjChImqQfmfVR9lQY/o0YCTCGEEBNSk8uHzWzAYjLQ3VKlDnZUje2ihBBD4g2GAbBbjCSaVIAZiU1TD0oGc8Ioa1Z/1lsGBJilTd3MyIhXv+ms7p93OeMStU83b9nJXuaEMbGHtAghhJiwmrv9pDtsWE0GQh216mCnBJhCjCeegAowYy1GEk0BdcwQS5wpRvZgThC6rnOgSQWYmw92QPN+gtWbqGpP5or52RAJQ1ctzL5SPcEcA18qBpNtzNZ8upMMphBCiAmpudtHWryVySlxGHuizSE8bTI7T4hxxBNQ+y5jLCYSjCrA7NGtYI2Tv8sTRKPLR7c/xOTUWOo6vbjX/RHz87cTr7tVBtNVD5Fgf4ksgMUOBgmDRot8Z4UQQkxIzS4/aQ4bk1NjifU39z8gZbJCjBsDM5iOaIDpClvBEiclshNEaTR7ecNSVQLrb9gLwALDAaanx/dXpiROOuLzxciTAFMIIcSE1NztVxnM1DjSaSMck6wekDJZIcaN/gymkThNNe7qCltUBlOa/EwIZdFxJJfPzyLWYiCmqxyAJcYy8pPt/R8aJkiAebJIgCmEEGLC8QRC9PhDpMWrDGam1k5r0kL1oGQwhRg3+jKYVhOx0QCzM2QFS7xkMCeIA809JMdaSIu3cX6OTkxYBZxnWcsxGQ3RDw01NZZEnBQSYAohhJhwekeUpMVbmZJoIRkXNebJ6k2pjCoRYtxw+/u7yNrxAdAeMoM1Xpr8TBClTd1MS48DYGVSBwAV5DAzUgrhkOog68gCk2UslzmhSIAphBBiwmlyqTei6Q4bznAbBk2nMpio9uhIiawQ44Y3qEpk7RYTNt1LRNdo9xujTX4kg3m603WdsuYepqWpcSTzbY0A/De4AlvEC817D52BKU4KCTCFEEJMOM3d0Qymw6o6DAL7PXHqTYiUyAoxbvRmMGMtRkxhDx5sdPlCqsmP7ME87TW5/HT7Qn0ZzNxwNZ16LK9ElqgTajaqDw2lwc9JNagAU9O0BE3TntA0bb+mafs0TTtztBcmhBBCjJa+ADPeCq46AHZ2xUJivnozoutjuDohxGANbPKjBdx4NRsuX1CVyEoG87RX1qzKoHszmOb2MurNk6jVUwnFpsPBd9SHiJLBPKkGm8H8I/CyruuFwDxg3+gtSQghhBhdzS4fFpMBZ4x5QAYzHm9sDgQ94G4Z4xUKIQajt8mP3WKCgBufFkOXN6gymEE3RMJjvEIxmnpHlPRmMGnZTyh5OilxNox5Z0Dpq4AuGcyT7LgBpqZpTuBc4D4AXdcDuq53jvK6hBBCiFHTO6JE0zRw1RMyxdJNDHVamjpBymSFGBc8gTBWkwGjQYOAm4AxBpc3qPZggpTJnuYONHeTaDeTHGsBdyt42pg1dwmvffVctNwzIORVJ0oG86QaTAazAGgB7tc0bbumafdqmhY7yusSQgghRk1zt0+VxwK46ojEZwIa5aEUdUw6yQoxLngCIWKtJvWbQA8ho70/gwlSJnuaK23qYVp6vPqwsGU/AKb0QhJjLZB7Rv+JCXljtMKJaTABpglYCNyl6/oCwA18+4MnaZp2i6ZpWzRN29LSIqVFQgghTl1NLj/pDpv6jaseU0IOFpOBYpdDHes8OGZrE0IMnscfJsZsVL8JuAmZogGmNT56TALM05Wu65Q1dTMtrbc8tkR9TS1UXzPngtEKBrMaUyJOmsEEmLVAra7rG6O/fwIVcB5C1/V7dF1frOv64tTU1JFcoxBCCDGiml0DM5gNGJzZzMyIp7gxALFpUiIrxDjhCYSJtfYHmLo5NloiGw0wJYN52mru9uPyhQ4NMC1x4MhWvzdZIWsBJOSCwTh2C52Ajhtg6rreCNRomjYjemgVsHdUVyWEEEIMktsf4tv/20lrj39Q5/uCYVy+EGkOm2oA0t0A8ZnMznayu74LPTFfSmSFGCfcgZBq8AP9AaYvhG6J7uYKdI/d4sSo2tfgAmB6evTDhJb9kDoDNK3/pIt/DR/60xisbmIbbBfZ24H/apq2E5gP/GLUViSEEEIMwaaD7TyyuYZniusHdX6za8CIkp5m0MPgyKIoy0m3L4THnq1GlQzD3evKeb+ibVjPHYrmbp/6RXslPHqjZGnEhOUNhLFbejOYPWjWWMIRHQ8x6pj83Thtbapsx2jQmJeboA60lPSXx/bKmg8F55zspU14gwowdV0vjpa/ztV1/Upd1ztGe2FCCCHEYFS3eQB4t2xw+/97g7M0h61vRAmObGZnqf2XDYYM6KqDcHBI6wiGI/zmlRIe2VQ9pOcNVVlTN2f8Yi1vl7ZA+VrY9xzUbh7VewpxqnIHwodkMI3R7rEuPbrH2i8ZzNPVpsp25mQ7VZMnbwf0NKoMphhzg81gCiGEEKekqmiAubGynUAoctzzm7sHZDBddeqgI4sZGfEYDRplwSSV1eyqHfI6QhGd+k7f0F7AEG2v6UTX4a2Slv41Nst4ajExeQMhlcEMBSASxGiLBpjhaIApTX5OS95AmB21nZxRkKQOtJSqrx/MYIoxIQGmEEKIca2qzQ2oZh/bqo9fYNPkimYw462HZDBtZiPT0uIo7k5Uxxp3DWkd5S3qjWxdp3dIzxuqkkaVkdl0sG1AgCmtEcTE5O5t8hMNJM0xKsDsDEebeEkG87S0vbqDYFjnjMnRALNhh/oqGcxTggSYQgghxrWqdg/LpyRjNGisP9B63PObu/2YjRqJdovKYBqtYFdvUoqynTzXlqUa/bz+IwgOPljsDTAbXT7Cfg/89QwofWVYr+lYegPMvfUuQh3RclzJYIoJyuMPEWM2QUB90GSxq1L3joARNKNkME9T71e2Y9BgcX40wNzzFKRMh4RJY7swAUiAKYQQYhyLRHSq2z0UZTuZl+Nk7/798OK3IHj0MtVml5/UOCsGg6YymI6svq6DRVkO6t3Queo30F4B63496LWUN6s3uOGITkf5ZtXRsOq9E3uBR7C/sZu8JDsRHULt0QCzZT/o+ojfS4hTma7reIK9GUz19y82zglAqzsA1jhp8nOa2lTZxqwsBw6bGTqrofo9mHPtoR1kxZiRAFMIIcS41dTtIxCKkJdk5+xpqeQ3vwab7lbNb46iudtHqiO6P6s3wIyana3enG4zzoP5N8L6Pw26VLa8pQezUb258R6MNt0Z4j7O42nr8dPa4+faxTnEGHUsniY1tzPQA101I3ovIU51vmAEXYcYS3+AGe9IwGjQaOzygSVeMpinIX8ozPbqTs4oSFYHdj2hvs75yNgtShxCAkwhhBDjVm+Dn0nJds6ZlsIUogFd2atHPD8c0dlT72JySnRGnqvukABzZqYDTYPddS5Y8zNVOvvMF9W8zGPQdZ3ylh4WTVL7N7X67f3XH0G95bHzchM4LyuEgQhMu0A9KGWyYoLxBEIAxFpMfYGk0RZHeryV+i5vNIMpezBPNztquvCHIiwtSFKVGzsfg9wzIKlgrJcmoiTAFEIIMW71NviZlBTL/NwECo3Rpj1lrx2xZLS4ppN2d4DzC9OgrVzNu0wv6ns8zmqiICWW3fVdKrhc/WNoKIa6bcdcR0uPn25fiHOmparrtEWzniOcwdwfDTBnZMRzTpoqA/blr1QPSoApJhhPQH3wY7cYIag+bMISS2ZCDA2dPrDESQbzNLQxOmt4aX4SNO2Gln0w55oxXpUYSAJMIYQQ41ZVmweTQSMrwYbZoDHDWI+LOJU5bNp92Plv7G/CaNBYMS0VdjwCmgHmXnvIOUVZTvbWu9RvpqxSX+u2HHMdvfsv5+UkkG3zk+CtArNdleAeJ/s5FCWN3STHWkiNs7LQod447wrmQHzWkAPMSET2bIrxrT/A7G/ygyWOTKeNBslgnrY2HWynMCOexFiLyl4aTDD76rFelhhAAkwhhBDjVlW7h+zEGExGA7hbiI10859QNKN3hDLZtfuaWTwpEafNqALMyecdUiILMDvLQV2nl3Z3AByZ4MiG2s3HXMeBaAfZKWmxnBsXLYudukrN0+xuHPbre25HfX+wC+xv6mZGRjyapjHZokayrG+xQtrMIY0q6XAHWPzz13ly28hmWIU4mdzREln7gDElWGLJSoihocuHbpEmP6ebYDjC1qoONf8yElH7L6euhtjksV6aGEACTCGEEONWdZuHScnR/ZQtJQBsiMymKbYQSg8NMOs6vexv7GbVzDSoehe6qmH+xw67ZlG00c/uui51IHsR1B4vg9mD3WIkw2FjkfmgOlj4IfX1BMpkv/PkLr795E50XScS0SltVAEmgMVdT5fmYH21VwWYraWDzpb+b1st7e4AL+8efvArxMmkH6Hk3dubwTQbB2QwY8l02vCHIviNsVIie5opaezGEwir8SS1m6G7XspjT0ESYAohhBiXdF3nYJubSUl2daBlPwCJk4p40TcHvXYTeNr7zn9jfzMAKwvTofghsDqg8NLDrjsnx4mmwfbqTnUgZ4naq+k++ozN8pYepqTGoWkaM/UDVJMOGXPUg67hBZjeQJgef4idtV1sq+6gut2DNximMBpg0lWLJyaTHTVdBJNnQMgHHQePe11d13lokxpvsrGynbCUyopT3L3vVHDxH98hGI4cctztjzb5sQ4okTWrABPArcdIiexpZk+9+uBvTrYTGneqg5OWj+GKxJFIgCmEEGLUvLy7kfKW0ckgdHqCdPtCTEruDTBLwBLPqqXzecYzB02PQPkbfee/sa+JScl2pjh12PsszL4KzDGHXddhMzMjPZ6t1aoElZzF6usxspgVLW6mpKpMap53PzvCBfTYMtSDw8xgtvb4+379z/UHBzT4cfRd15SURyAcYWcgWuY7iDLZjZXtVLS4OWdaCl3eIAdKdsGfF0HDzmGtU4jRVtrUzf7Gbl7Z0wjuNuhRHxZ5gyqDqcaU9IDJBkYTmU7199oVsarjMiP2tLG7zkWc1URekh2a9oDNCfGZY70s8QESYAohhBgVvmCY2x/exg+fObzZzkioalddI/N6M5itJZA6gwuLMqm0TqfH6ITSVwA1zmB9eRsrC9PQ9j4LQfcRy2N7LchLZHt1h2qEkzkfNONR92F6AiHqOr1MSY2Dnhbi/Y3siEyhwWdWWdKu4Y0qae5WAeaM9Hhe313LrBevZoVhB9PT49QJXbUkZhZgMxt4qdEZfdLxG/08tLGaeJuJO65U3XMj7/wB2g7ArseHtU4hRps7Wgp7//qD8PyX4bFPqON+dTy2t8mPRX3Ik5mgMpgdYStEQhDyH35RMS7tru9iVpYDg0FTP+/SZoOmjfWyxAdIgCmEEGJU7G1wEQzrrD/QxsFW94hfv29EycA9mKkzsJmNXDovh9eDc9H3vwAvf4d9659ndriEz7rvgdd+AEmTIXfpUa+9aFIi3b6Qat5jsUP6rKN2kq1oUeuYmhYH0fmXOyOTqev0qgZBJ5jB/MrqaaTrbeR59nBTzLuqY6a3E/wuTIl5nD01hZfLutET848bYPbuu/zwwhwmJceyODnA1Prn1IMHXh/WOoUYbb17LbdWdeBuq4fGXaDrfXMwVZOf/gAzJdaK2ajRGrCoC8g+zNNCOKKzr8FFUZZTZaWb96n95+KUIwGmEEKIUbGzphMAgwaPbKyAF74OTYPvdHo81W0DMpjeDuhpgtQZAHxkUQ5/CF5FY8ICIpvuZdG6m3jK+iOyyh6GvDPhI/885qfeiyYlAuoNLaD2YdZtU10LP6C8r4NsHNRvQ0djj55PfacPnDnD3oPZG2DOz0vgsgK11jP0naqRT2/Q6sxhZWE6tR1e3M7pxw0wn9haQyAc4YYz8gC4PfZ1DHqI8KJPqfLaEZ7bKcRIcPtDzMp0EGsx0tnVpQLG7sb+MSXmaImsRWX3DQaNDKeN5oBJXUD2YZ4WKlp68AUjzM5yqFFU/i714Z845UiAKYQQYlTsqO0iNd7KmlkZ7N76Lmy+F9757Yhd/2Cbh3SHVe2/ailVB1MLAViQm4AxZQqrm26nyPN3vmn8FtuX/Abtm2Vw3X8ha8Exr52fbCcp1tIfYGYvBr8L2soOO7e8xY1BQ+0Frd8OqTPwGezUd3rBeQIZzO4AAMmxVq6cZgQgNtIN9cUDAsw8VhamAVASyVWdZI+xV/SxLbUsnpTI9PR48HWxvP1pXoosZX/u9eoEyWKKU5A3GCbdYeWaxbmEfNFgsa0MdyCExWRQY4oGZDABMp0xNHqjAaZ8cHJa2B1t8FOU7ez/sDJNAsxTkQSYQgghRsWO2k7m5SRwwxl5TPfvUQf3v6DKO0dAdbubSUm95bGqgywp0wHQNI1Pn1WA1WzkixfN46f/79ssuPQW1RBiEDRNY2FeAtsOa/Rz+D7M8uYe8pLsWI0GqNuKlrWADIctGmDmgKcNgt4hv76WHh8JdjMWk4FpMQNKjMvXQleN+rUzhwynjdlZDu72ng8JufDg1Srb+gGtPX4ONPewZna6OrDlfsyhHu4OfYi32pPAkQNlr/U/oXk/vPfnIa9biJHm9oewW0zctDyfGKL7KVtL8QbC2C3qw5cPBphZThvrfZMgJgke/Zh8eHIa2F3nwmoyqIZqvQ3NpET2lCQBphBCiBHn8gWpaHEzL8fJ2VNTOMdWjl+zqlEae54akXtUtXnIG9hB1hQDCXl9j9+4bBLbfnABt503VWU5h2jhpEQqWty0uwOQPA2sziNmB/fUdzEtPR7aK8DdArlLyU6IobbTC85cddIwGv20dgdIibMCoPU0gsEMmfNUZ9yuWjBaIDYVgFWFabxea6Dro09BTAI8eKXKdA5QHB27Mj83EcJBeP8uKDiXYPo83qtog2mroWIdhAIQDsH/PgOvfv+QUS9CjAVvIEyMxUhBSizxBpXZDzSV4vaHVYMfiAaYcX3PyXDGsLs7jshn31B/D/97DWz461gsX4yQPfVdzMx0qIx1816Iz4KYxLFeljgCCTCFEEKMuF21qpRpXm4CBg2WGkt5KbSIQOI02PHwCV/fGwjT3O3vn4HZWgIp08Aw9EDyaBblqTcu26s7wGCA7IVQs+mQjpT1nV4Otnk4oyAJajaqg7nLyEqIZjAd2erYMPZhtvb4SYmLNinpboK4dJi6Wq2hea+6tkH9M75yZjoRHd5qtMInn1fB8BOfPuR622s6MBo0NT/u4DvQ0whLb2H5lBS2HOxgu3UJBLr51h/+gXf936Ap2v3XNbwuuEKMFE8wTKzFCLqOTVfVAPXlu/AGQ/0fHgV6Ds1gJtgIhnVaLZnwmVfV351Xvqf2a4sxo+s6DV1e3ixpVmNnBikS0dlT51L7L0H9DJT9l6csCTCFEEKMuB21nQDMzXFCZxWxgVa2RmbwvuMiFYi1lZ/Q9Ws6og1+BmYwow1+RsrcnARMBq2/TDbvTGjeA7/MgX+shG0PsqG8DYDlU1Kg+n1VgptaSFZCDI1dPsKOHPXcYewBa+3xkxqvxi3Q3QDx6TBlFehhOLBWld/2rjXbSUqchbX7mlUWd+nN0F6uZgZGFdd0UpgRr96Q730WzLEwdTVnTknGH4pw4xs2grqRZa4Xsbz9K0iYNOy1CzGSPP4wMRYThHxoqJmWpo4DNHT5VOAJR9yDCdDQ6VPHZ18F6BJgjqHKVjdLfr6WM3/5Bnf862naHv48pdUNg3puTYeHbn9I7b8Mh9S+eymPPWVJgCmEEGLE7ajpZFKynQS7RQVeQE/6Yu7vXgqaAYofOqHr10RnYOYm2cHfo/YkjnCAGWMxMivL0d/o56wvw7UPwLLPqzezL3yN7WVVJNrNFGbEq8A5ZykYDGQlxBCK6LSQpJ47jBLZlu4BGcyeJjVMPGeJKgPUw4eUAxsMGufPSOOtkmbCER2y5qsHGtTYlHBEZ0dNFwvyElQX2v3Pw7QLwBzDiumpfO2C6fzppnMI5SzlauO7EAnCVXdH1y4Bphg7wXCEQDiiAsmA2oscsiWSpbewt7p5QAbzgwGm+nCmoSu6/9kazXz5XCdt7eJQ71e00drj59sXF/L3RXXcYHoD03NfUCNHjmN3nfpzK8pyqu0IYb+agSlOSRJgCiGEGHE7a7uYl5OgflP9PlgdFMxczFsNRgL558HOR4848mOwqtsHjChpjXaQTRnZABNgYV4iO2q6eGxLDY/taOE9y1lwwU/hQ3+EcABT+Wssm5yMwdehGg3lLQMgO0FlT+p6Iqq0tbcpzyB5A2HcgXDfHky6G9R1TBYoOFcdG5DBBDhzSjIuX0iNTcmcpw5G92GWt/TQ4w+p/Zc1G9Ve0VmXA2AxGfjSqmmsmpmOpfBCADZmfxJyz1D7PqVEVoyh3lEkMQMCTFP2AgyaTr7WqPZg+lwQ9KjS8Kis6N/B+k6fOmCLBph+CTDHSkljN3aLkVvOmcw0QyMRNCa3rIV3/3DE80ubuilrUl2D99R3YTJoTM+IU5UkIBnMU5gEmEIIIUZUs8tHQ5dPlcdCNLO3hHMLM9B12Jl8iQq4TqCrY3W7hxizkeRYS3+5bfLUEVj9oc6ZloI3GOZbT+zkW0/s5GP3beRAczfkLCVsT2Opbz1nTklW+yKhL8Dsf3Mb7SQ7xCxg7wzM1Dir2vPp7VAZTIApK9XXDwSY83ITAFUKi80JSZOhoRiI7iMFlcHc+ywYrTBtzWH3NS66ibtMN/K0/SNqf6cjUzKYYkx5owFmrNWkgkjo+wBlqqFBBZ7lb6jj+Wf1PS/RbsZqMkgG8xSyv9HF9PR4DAYN2g5QHb+Q5yLL0df+FMoO/ffAHwpz3T3vs+bOt/nKw9vI2PU3rkqqwmoyqnm/mmHEq1bEyJEAUwghxIjaEW3wMz83QY0kad4HecuYk+0k0W7mUfd8Vd755h2DKo06kpp2L3lJdjRNU+VSAEkFI7L+gVbNTGfT91bx7v87n5e/cg5Wk4G711WAwUBFyvmcZ9jBWXl2qHkfDCbIWgioBiMAdb2NfoaYBWzpDTDjrao8FtQeTIDCS9Xst9xlhzynIDmWeKuJndH9r2TOh/odgAo6HTYTBUl22PecClKt8Yff2J7Em6k3crArml125g6rvFeIkeIOhADUOJJoBpOMuQB8bnaEm5bnQ+krqptoztK+52maRqbTRn3XBzOY3Sdr6WIAXdcpaexW2wl0HdrKsGXM4JuBm+lxToenbun/8wVe3t1IuzvAJUWZmPc9wSfc/+bn7h/BwfXQtEd9gGaOGcNXJI5FAkwhhBAjamdtJ0aDxuwsZ3RupA55yzAaNM6ZlsqbZV1EVnwHGnbA3meGdY+ado/afwmqmY0jZ9TebKTF28hJtFOY4eCji3N5ansd9Z1eXtWXYtf8TO56X5UBZ84Di1pTvM1Mot2s9oo6c1UWcAjBdEu3CjBT4qzQHe202JvBdGTBbRsgdfohzzEYNObmOtlRowJ8suZDVzW429he3cn8vEQMDdtVR9toeeyR5CTGUBttoqSCY8lgirHTm8G0W0z9AUhcGjiymWNrYUmeE8pehakXgNF0yHMznTE0dH4ggyklsmOipdtPhyfIjIx4NfrI10VK/iwMFjsPp31VzQsesDf/oY3V5CXZ+fOV+fw69hEaY2eiO3PhoWuheoP6kE2csiTAFEIIMaKKazqZnh7tVlr9PmhGyF4EwIrpqbT2+NmbchGkFsIbd6iOgEOg6zo1HR5yk6IBZVs5JE8e6ZdxRDefOxkd+Mc7FTzYkIPb4EDb/T+o26a6zA6Qm2RXe0Wd2aq0bwjdK3tLZFPiLf0BZlz6cZ83NyeB/Y0ufMGwymACvuqtlDZ1q4zyvmdUpnXGxUe9Rk6inUaXj0AootbualCNgYQYA27/gAxmb4msJVaVxLeWQt1W8LTC9AsPe25mgo3G3gymlMiOqf2NKnM8IyMe2g4AYEqdzvIpyTxYl46eswQ2/AUiYQ4097Cxsp3rluZiWPtjDL5OMj7+D6yffg5iU1QwKgHmKU0CTCGEECPG7Q+xsbJdzYUEtf8yc25fd8dzp6cCsO5AO6z8PrSVwc5HhnSPNncATyCsGvyAymAmTRmx13AsOYl2rpiXxYMbqmjsCdOUtVJlYcN+1RRngNwkO7Ud3v69kkPYy9jarYbJJ8cOzGBmHPd583KcBMM6+xpcffvUmkveJ6LDgpx42PO0ahJ0jOHkOYkxRHTUG3Nnjuoo29M86LULMZI8wcOb/GCOVXNv2w5AyUvqQ6ypqw57bpYzhqZuv+qsbLKAyQb+rpO5fBFVEg0wCzMcfQEmyVNZMT2VmnYvzUU3Q8dB2P8CD2+qxmTQuD6jHrb9W3Xuzpijqjc+8SxMPv+YH5KJsScBphBCiBHzTlkLgVCEC2dnQNCrSmQHZPZS460UZTtYV9IChZdB1gJ461dq1Mgg9Y0oSbSrUitvBySfnAAT4NYVUwhFVLlr3PzobD3oa/DTKzfRTm2Hh7AjVx3oqBz0PVp7/CTYzVhMBuhpVG+g7SnHfV5vo5+dtV0QkwCJBQRr1aiSJd73oLMKFnz8mNfISVSZ4doOjyo9BukkK8aMxx9t8jOwRNZih5Tpqtx1xyMwafkRPzTJTLARjug0dw/IYkoGc0zsb+wmNd5KUqxFBZgGEyTksWJ6GgAvhRZBwiQi6//E/7bV8qmpbhJf+oL6GXTed/ovlDgJPvF0/ygmcUqSAFMIIcSIeWVPE4l2M0vyE6HybQj5YOrqQ85ZMT2VrdUduPwhWHOHCl4e+ziEAoO6R9+IkmT7gAY/Jy/AnJERz0WzM5icEkvqvAvBEg+JBWpf2AB5SXaCYZ1G22QwWqL7UQdHzcDsHVHSqMpjDcf/JzvDYSM13sqOmk51IGs+zs49FCTbidvyZ9UYY9YVx7xGbqLKDKvsa7Y6KJ1kxRjxHKnJT2+JLEB3/RHLY0H9fQD6y2RtDmnyM0ZKmlyqwQ+oADMxH4xm8pLtFKTE8vyuZsqmfAJD3WZuDjzIt+tuh3AAPvoAWOPGdO1i6CTAFEIIMSKC4Qhr9zWxamY6JqMBSl9WpWz5Zx9y3srCNMIRnbveKlePXXanGjPwzG2Dmo1Z26GaduQkxgwYUXLyAkyAO6+bz5O3LUczx8DqH8G53zzsnN49ojWusMrUVm8c9PVbe/xqRAmoAHMQ5bGgOmfOy0lgR7STbJtjNimhJr6UsRvqt8PyL4HBeMxrZDhtGLTeDKYEmGJsefqa/Bgh+IES2V7TLzricxPsZgBcvug+b2u8NPkZA6FwhLKmHmak9waY5YeMlVpVmMaWqg6uWF9Al27nC6ZnMWTNg1vX9e3fF+OL6finCCGEEMe3qbIdly/EmlnpqmNq6asw5XwwWQ85b2FeItcvzeWut8opynJy6aKbVJOOtT9VmboLf37M+1S3eUiJs6quku3lah5aYv4ovrLD2cxGbOZooLb05iOe07tHtLrdw7LcM2Dj3yHoA7PtuNdv7fEzJydB/aa7UZWFDdK8HCev72vC5QvyUE0StwNX1P9BfW/nXX/c55uNBjKdMSqQj0lUb+alRFaMEc8hXWQ9qrTSZFGlk6YYNav1KDNwHbZogOkNqgNSIjsmDrZ58IciFGY61IeI7eXq34aob1w4g0vnZqID7eW/xByoxr7q2+rPWYxLksEUQggxIl7d04jNbOCcaalqTpmr9oila5qm8ePLZ7MwL4FvPL5DNaQ5+2uw4EbVRdB37CYc1e0e8gZ2kHXmHBbEngqyEmJUJrDdoxoAhQPQUDyo57b2BEiJi7656hl8BhP692H+b2st/yhXGQODtw2W3Tao4BYgOzEaYGqaKpOVDKYYI95ACE0Dm9mgSmSjDcMwGGDRTbD8dvX/6RE4YnozmNEA0+aQDOZJUtvhUZ2oGdjgJ159WBXyHVJ1YjMbWZCXyMK8RArO/yT2C38oweU4JwGmEEKIE6brOq/ubeLcaamq22Ppy+qBaWuOeL7VZOTvNy7CEWPilge34A1GYGZ0NmPT3mPeS40oOfkdZIeqNxNY3RtgghrbchzeQJgef0jtwQwFVEv+uMEHmHNznAD88qX9RCxOwgn5YHXC4k8P+hq9DYoAVSYrAaYYI+5AGLvZiKZpqkTWHNv/4MW/Pub/1/0ZzN4SWadkME8CfyjMRXe+w2cf2EI4olPS6MKgwdS0uEM6yIrTlwSYQgghTtiuui4aunysmR0NhEpfUfsOj5F5S3PY+MnlRdS0eymu6YT0IvVA0+6jPicYjlDf6VXlp7oObRUnff/lUOQl2anp8EJcqgqEazYd9zm9MzBT463Q06QOxh9/BmavBLuF/GQ7gVCEz5xdgHHNT+GKv6jszSDlJMYMmIWZIyWyYsx4AmHs1uiOroCnP4M5CDazAbNR+0AGU5r8jLZ9Dd30+EO8XdrCb14pYX9jN/kpsWpbgQSYE4IEmEIIIU7Yi7saMRo0VhWmgbtNdUydduTOjgMtmqRGC+yp71IzzmwJxwwwGzp9RPTeESVtaqbdKZrBBNXop7frLblnqLmgun7M57T0BphxAwPMzCHdd9GkJBLsZj5zToHqGjvr8iE9/7BZmD1NEPIP6RpCjARPIKQa/EC0RNY+6OdqmobDZh6wBzMeAt0QCY/CSkWv7dUdAFw0O4O/ryvn7bKWAR1ky8FsH/LPNDG+SIAphBDihJQ0dvPP9ZVcODudxFgLHHgN0I86OmCg1HgrGQ4be+pdah9Vxhy1f/MoeoO13CT7mHWQHYq8JDst3X68gTDknaGaGfWOVjmK1m4VyKXEWaG7QR2MG3wGE+CHl83i+dvP7isRHKqcvlElAzrJuuqHdS0hToQnECamt6FW0HNoiewgOGLMdA1s8gOSxRxlxTWdZDhs/On6BazM1XhW+zpX8rZ6sO2A+pl9lH2z4vQgAaYQQohh84fCfPmR7ThsJn56RbTEteQlFRBlzh/UNWZnOdhdF23skz5b7cE8yriSmo6BMzCjAeYpncEcEKgNch9my8AS2e5GdXCIn/Y77ea+IHE4chKjI1Y6PCqDCVImK8aEJxAitq9EtmdIJbIADpupf0xJb5m4NPoZVdurO1mQl4DFZODO+XVMN9RxQfnP1aimtgNSHjsBSIAphBBi2H4b3V/zfx+ZqzJuHQdh//Mw+yrV5XEQZmc7KW/pUQPV04tUI4+OyiOeW93uwWzU1AD1tnLQjEMa4XGy5Q4YVULKDLA5VZnsMbR2BwBIjrOoAFMzQGzKqK91oEynDaNBU51kewPMLgkwxcnnCYQHlMh6hlQiCyqD6fpgBlMa/Yyath4/1e0e5ke7WTsqXwFnLpozBx77OHRWSYA5AUiAKYQQYlg2lLfxj3cquXFZHisLoyWcb/9WBURnfXnQ1ynKchDRVWMI0merg0fZh1nT7iE7IQajQVMZzIQ8MA6vDPRk6J2FWdPuUQF37z7MY2jt8ZNgN2M2GtSIkrh0MBhPxnL7mIwGMhw2FWD2lcgOo5NsewX891p5Qy+GzeMfEGAOp0TWZj60yQ9IiewoKq7pBGBBXqL6e1+5Tu0Dv/5h8PeAHpEAcwKQAFMIIcSw3PduBWnxVr53ySx1oL0SdjwMiz6pGvYM0uxsNVZjb30XpM1UAepR9mHWtA8YUdJWfkrvvwRIjrUQYzZS3e5VB3KXQst+8LQf9TmtPX6VDQbobhry/suRkpMYo0p7LXaISRr0qJJAKMLvXi2h0xOAA2uh7BWo2zrKqxWnK08whN1yAiWyMaYBY0qkRHa0Fdd0YjRozMl2Qtmrav5v4WXqZ/vV96g/g+xFY71MMcokwBRCCDFkHe4Ab5W0cMX8LDX3EuCd36qS1bO/NqRrZTltJNrN7K5zgTlGfbrdeHgGMxiOUNHqVgGmrqvs2Cm8/xJUF0s1qiTaSXbSWepr1XtHfU5Nh4e0+N4As/GYo15GU06iXWUwAZzZgy6R3XywnT+/cYAXdjWoDx2gfzSBEEN0SAZzOCWyAzOYUiI76rZXd1KYEa/+Xdj/PMSmqg/WAGZeBv+vClKmje0ixaiTAFMIIcSQvbS7kVBE54r50fLJ9goofhgWfwocQ2tIo2kaRdlOdtcPbPRzeIC5/kAr3b4Q501PVVnAQA+kTj/RlzLqcpNiVIksQPZi1aK/ct0Rz61u87C7zsU501IhHILO6iFlg0fSIbMwHTmDzmCWNqnyw911rv69tL0df4UYor49mOEQhP1giRvS8x0xZgKhCL5geECJbNcorFREIjo7ajrV/suQH8pegxmXHFriP8i9+WJ8G9SfsqZpBzVN26VpWrGmaVtGe1FCCCFObc8U1zElNZbZWdE3bG/+Qu2FPPurw7re7CwnpU3dKphJL1KNID6QZXimuB6HzcSKGamw7QEwmGHmFSf6UkZdbpKd6nYPuq6DyQJ5Z0Ll20c897mdahTIh+ZlQtW76o3wlJUnc7l9shJs6Do0d/vUXtfO6uPO8AQoa+4BoiXPvRnMdgkwxdBFIjreYFiVyAbd6qB56E1+AJXFlDElo6q8pYduf0jtv6xYpz4EnPmhsV6WGAND+RjhfF3X5+u6vnjUViOEEOKUV9/pZdPBdq6Yn42maVD+Jux6HJbfPuxyztlZDoJhXWW/0qPjTpr39j3uDYR5ZU8jl8zJxKoHofghVW4VlzoSL2lU5Sba8QTCtLtVd1gmr1AZ2N4RJFG6rvP09jqW5CeqESN7n1UNTaauHoNVQ4ZTjSpp7PJBUoEaUO9uPe7zDjSpAHN/Yxd6x0F1UEpkxTB4g2EAlcEMRKsAhlwiq/ZvurwhVYJvMEmJ7CjZHm3wMz83AfY/B5Z4KDh3TNckxobkqYUQQgzJ8zvr0XW4fF4WBL3wwtfUXshzvjHsaxZFG/3sqe+CjGiA2bir7/HX9zXhCYS5fH4W7HsWfJ2qmdA4kDdwVAn0v+H6QBZzX0M3Zc09XD4/GyJh2PccTLtAvSkeAxkOGwCNLh8kTVYHjzI+ppeu65Q2d5NgN5MQakcLecGeDB1VEAr0n9hSqhoACXEMnsDAADOawRxGiSxEM5iaBtZ4afIzSrZXd+KwmZicbFfzkKddACbrWC9LjIHBBpg68KqmaVs1TbtlNBckhBDi1PZMcT3zchPIT4lVY0naK+CyP4DZNuxrTkqyE2c1qX17jmw1L3JAJ9lniuvIcNg4oyAZttwPiQWQPz4+GZ+Wrt4Q76qL7vvKmAu2BFVCNsAzO+owGTQunZMJ1e+Du1m19x8jGc5ogNk1IMBsrzjmc1p7AnR6glw2N5NJWpM6OHU16GFV9txr7U/g4euP2U1XCE9AdX89oRJZWzTAHDgLUzKYo2J7dQfzchMwdFSAuwUmnzfWSxJjZLAB5tm6ri8ELga+oGnaYf+qa5p2i6ZpWzRN29LS0jKiixRCCHFqONDczZ56F1fMy4Lm/bD+jzDvelX2eQIMBo1ZmQ7V6EfTIH0O7HkS7l1N6O8rOP/Ar7hulhVjWylUv6eyl+OkWURekp28JDtvl0b/bTQYoeAc1egnuqcxEtF5rriec6enkhRrgb3PgMkG09aM2bodNhN2i5GGrugeTM1wWID58u5GShr797OVRRv8rJmVwTRz9PVOvUB97S2T1XWo2aQathQ/NOqvQ4xfh2Ywh1ci64yJlsj6oqNKbA7JYI6CLk+QkqZuluQnQV20XUuO7KqbqAb1r7Ou63XRr83AU8DSI5xzj67ri3VdX5yaeurviRFCCDF075SpPXgXFWVEG+0YYc3PR+TaRdlO9tS5eGVPIyz5jMr0WeJoCdq41vAmt+/5KDx9m2ruM/9jI3LPk0HTNM6bkcp75W34Q+oNMwUroKumr+R0S1UH9V0+rpifBZGIKgOeuhqsQysHHOl1ZzhsKoNpsoIz55AAs8Md4IsPbeOXL+3rO9bb4KcwI54F8Z2EMfRlMbrr9vPY5hrC7QdVdlYzwJZ/HtI46OXdjTy/sx6vxwOP3QR7nj4ZL1WcovoymFbT8EtkD8tgOqXJzyjYfLAdXYczCpLU3FtzLKQWjvWyxBgxHe8ETdNiAYOu693RX68BfjrqKxNCCHHK2dfgIjnWQqbTBo07IWMOxCaPyLU/e04Bmw62ceuDW7l+6VSuXfkgL+1u5ImqWorimvl39jNQ+grMvmpcNPcZaMX0VB7YUMWWgx2cNTWlv3SsYh16YgH3vlNBjNnI6pnp6tP/7gaYdeVYLhlQZbKNLp/6TWJBf1dY4MXdDYQiOu9XtOELhrGZjZQ2deOwmUiNtzLD3EqdnkqOPQWDPZkdO7bwrabpuPL28FmAZbfBhr+ovaiTV1Db4eELD20jHNG50fI2dxieJrzvOZ7e46IqcVnffRM0N1fMyyA5LkaVS5osJ/ebIk6aQzKYnhHoIgsqg9lZM2JrPJX4Q2Ge3FbHNYtyMBlPboXHxso2LCYD83IT4PUtkLXg0PEkYkI5boAJpANPaZrWe/5Duq6/PKqrEkIIcUra39jNzEwHGqgAs+jDI3btrIQYnvz8Wfz+tVLufruchzfVYDJorJieypdXL0HL+RjUb4fE/BG758mybHIyFqOBdaUtKsBMngrxmVC5jnt6zuH9vRX8+Ox4Yg++DtsfBKMFpl841ssmw2ljY0V0n2TSZFW6G/VMcT1nmkpxhDvZtSuVJfMXUtbcw/T0eDRNI0tvZE8kjVCbmxznZEx1FczJdmKq34LXbMO39Oskbv8PbL0fJq/gH29XYNDgzzfMZ9EL36HMn0swbOCiPd/g+sD3MRPiy6YnOde4C95Va9DNdrR518HSWyFNsiWnG7d/QIDZ2VsiGzuka1hNBixGg+oiC9EmP6fnHMxnttfznSd3keG0cX5mGPY+DWd8Tm07GGUbK9uZn5uAjaBq0HbmbaN+T3HqOm6Aqet6BTDvJKxFCCHEKSwUjlDS2M3Hl01S5Z2+LpXBHEEWk4FvX1zIBbPSqWjpYfXMdBJjB2SoshaM6P1OlliriSUFiawraeG7l8xUb/gKVhDZ/T8+tvslbrX5YAvqP4A51/QPhR9DmU4bTS4f4YiOMWkyeNvB20G938bWyhb2xv4f1rAHnr0T/eU4MoNfwD7nMgCcvlqq9UV01rtwh9LI197jbx9bSPyD9exom8wP/7WL5+dch2XrvbQ11fDI5hquWpDNJdZd4K8i/ap71N7e+y7g2e471J5Newrts77K61VBSuo7WWRq4OLt/0Xb8k9Y8lm49Hdj/B0TADXtHqrbPerDlBPgDQ5o8hNQ5ddDDTA1TcMRY+rPYJ7GTX7W7leNtUoauzm//G7YdLcqtU+ZNqr37fGH2F3XxRfPn6qCy0gQsmX/5UQ2PjokCCGEGHMH29z4QxFmZjr6R4hkzB2Vey2alMg1i3MPDS7HuRXTUylp6qahywtA/YxP8GpkMa9Z1xBY9VO45l/w2bXw9RK4+h9ju9ioDIeNUESnrcc/oJNsJc/uqGemVoU17OEJx038zvZFIpY4Lg+9yrS0ePB2YPJ3UqtlsPVgO2+2OsnQOsi1ekjo2kd20bmUt7j5acMyiITY//yfCYQj3HLuFHjvz+DIgaKr1VzVjz8NectgzR3wlZ0kXfZjrv3Cz8m79Jvc1vMZDt60BQovg63/hnBoTL9fQrnz9TJufXAr+oD9tcPRm8GMtRghGM1gDrFEFtQ+zL49mDaH2oN5gms71fhD4b498qUNnbDnKfVAS8mI36uu08s7Zf0NPbccbCeiwxmTk6XBjwAkwBRCCDFI+xpUY4zCzHgVYGoGSJs1xqsaP1ZMTwPg7dIWGrt8fPQFP982fI1Ft96N5Zwvq72lOYtVUHUSStoGI8OpZnCqWZgF6mB7Bc8U13NlUjUAgTnX8+fO5ZSnXcjZhl0UJul9ezUjCfk8vKmGvX712tn9JERC5M5dwfcvncl/Dlg44DyTs2ru5t+pDzO1ZwtUvQvLPg9GtXeO5Clw07Ow/PZDsldzctTs1PIeK8y4RGVNBo5CEWOmtKmbHn+Idnfg+Ccfgze6BzNm4BzMYQSY8THm/i6yVocam9MbsJ4mNla04wmEibOaMNe8pxppAbTsH9H7dLgDXHfPBj7xz03sjo5e2ljZjsmgsSAvQTX4ic8CR9aI3leMLxJgCiGEGJR9DS5MBo2paXEqwEyaMuSRARPZ9PQ4Mhw2nt1Rz8fv20h7T4B/f2opecmn7vcwMzoLs6HL17f3tbWmhH0NLlbHVoAzj6XzigC4u2U2Vi3ErJ6Nfd1xYzOmEghH0FKmqgvuiI4lyVnCJ5fn8+GFOVzWdAv3hC7lnO4X4IErVJfPRTcdd22TU1SwebDNDSnT1cHW0hF65WK4IhGdA9FuwjUdXth8L2z467Cu5R44BzPgVsHlMMYTOWymQzOYcNqVyb6xvxmb2cBHFuWwwPUmujkWYtNG9O9EKBzh9oe309TlJ95q4ucv7EPf8Dem7fwtc7Md6s+pdgvkLBqxe4rxSQJMIYQQg7K/sZspqXFYTcb+DrJi0DRNNSxaf6CNqnYP9960RHVcPIVlRAPMxi6fyh7GZ9JYuReDppPr3gl5y5iSGkd2QgxPtmTRQgLOgy/3ZTDTJ80EYPVZ0S6wvU2a4lLRNI2fX1XE3IJMts34OtpnXoecpbDiW6oRy3Ek2C0k2s1UtLqhN4CVAHPM1XV68QZV5rGm3QMb/qbG0QyDNxDGajJgNGgq4ziM7CWoTrKH7MGE02oWpq7rrN3fxFlTUpifbedCw0a6J61WP6NHMIP565f38+6BVu64qohvXDgDd+UmeOV7XO15nE86t4K7TX24JPsvJ7zBdJEVQggh2NfgUjPOvJ3QWQ2LPjXWSxp3rpifxYu7G7jzo/M5c8rIjHcZTUl2C2aj1j+qJGky1FZweV4AY1Mz5C1D0zTOnZ7Kw5u8bI1ZzkVlr6ny1tg0Ll40la6whQ8tKoD3clVzqJwlfde3mY08essytR3OoMFnXxvS+gpSYqlscUNM4ohna8TwlDb1z5hsammC9nIwWtV81yFmH92BkOogCyqDOcQGP73UHswBJbJwWmUwy1t6qGn3cuu5U1gYLCZR62FjyhrOYA9see+o3/vddV04Y8zkJh0/cH99bxP/eKeSm86cxLWLcwkG/Jz12n00h5006ElcXP072J+gTs6WDOZEJxlMIYQQfXbVdtHc7TvseKcnQEOXj8JMBzTtVgdHqcHP6Wz51BR2/HANq2amj/VSBsVg0Eh32FQGEwg4JpEWqudiR3SvY96ZgGpgBFCbvhqCbtj7LCQV4Iwxc+uKKVhMBrWXElSWcgBN0zAYhrfntCAljsrW6N68lOnQWjas64hjC4YjfPy+jby5v/m455ZFy2NjzEb0hmgzsLAf3C3HeNaReQJhVXYJJxZgDuwiazt1MpgVLT186M/vUttxYvtB1+5Tfy4rC9PIrn8Jl25nvT4XUmdAyKs+2PkAXzDMx+7dyHee3HXc6+u6zp1rSylIieX7l6l99+aNf2FK5CDfD36Kr4duwxQJwIvfVHvzx2m3bzFyJMAUQggBQEOXl6vvWs/Vf3uvr9Npr94GP4d2kJUS2eEYbjA1VjKdtr7/H+oMGaRpnSwIbgObE1LV7MmzpiaTaDeTOHulOh72Q2LBoRdK6g0wR658bnJqLI0uH25/SI1iaCk57bqDngreLWvlnbJW3hhMgNnUQ7rDyrT0OOxtA4KXzuoh39cbCPdnMIOeE8pgBkIRfMHwKVUi+3RxPbvqunh4UzV0VMG636hs4xCt3d/MzEwHWbEaxpIXeM9yJnub/X1/P4/USfaFnQ10eYNsqmzH7fHAwzfAvuePeP13D7Syu87F51ZMxmw0QFs5vPVr9JmXE5l+CWn5RWirf6T+3qfOBGvckF+DOL1IgCmEEAKAe9+pJKJDpyfIjfduVKMpovY1qDdjMzOiHWRj0yB+fGThxInJcMb0ZTD3+tRcw9Ta1yB3WV/ZXbzNzMbvrubqxfmqoyv0d53tNXW12ps1gh9MFHyw0Y+vE9ytI3Z9oTxTXAdEv8/HUdbczbS0eHIT7aT1lIAWDRCH0eHXHQhjtw7IYJ7AHkxAZTFPoSY/b0TnVj65rY7IW7+EN++A6veGdI3WHj9bqzpYVZgG5W+A30V52hr2N3b3N786wj7MhzZVYzUZCIQj1L36Jyh5ATYfeTzS394sJ91h5coF2SoQ/s+HwWxDu+Q33P3xRTz4maWw9FYo+gjMv2Fo3wRxWpIAUwghBB3uAA9vqubyeVncd9NiWjs62fWna/Bu+S/oOvsbXSTHWkiNt0KDNPiZSDIcVhpdPnRdZ0OnGg2ihbxqNuUAFpMBTdNg5uXqQO/czF6Fl8DNa/vHj4yA3gCzstUNqdJJdjR4AiFe3asCoer2Y5dy9naQnZoWR05SDJODZeiTzlIPHqFM83i8gRB2c+8ezBPJYKog1eUN9TeQGuMMZmOXj911LublOHF3taLvflI9sOfpIV3nnrcr0HVdBX/7XwCrE61gBbUdXnqMjuje5EMzmCWN3Wyt6uBLq6aRafaQu+sv6oOAg+sPC7y3V3ewoaKNm8+ZjLWzAu6/GLztcOOTEJ+ByWjAZDSoD5s+ch8s/+KJfFvEaUICTCGEEDywoQpPIMznVkzhjMnJPLVgO+cF1hHz/G14H/00VXWNzMx0oIWD6tNwCTAnjAxnDL5ghHZ3gLWNA97gfyDA7DP9Qrj8zzDzQ6O+tvzkaIDZIqNKRsvr+5rxBMIsnpRIXYeXUPjoJZx1nV48gTDT0+PJj4cCGujJWAoxScMqkXX7B5TIBnpOYA/mgAymJR7QxjyD+WaJKjf+2ZVFXG97H2M4WtK671mIhAd1jWaXjwc2HOTK+dlMTbZByYsw/UKmZSUBKpAkdcZhJbIPbazCYjJw/dI8fpbwPJawGy7+tZolW/HmIef+fV05zhgz108NqeAy5IdPvjCipe7i9CMBphBCTHCeQIh/vVfJ6plpzMiIh+4mJu//B605F/CnyLWY9z/N79tv48uBe+Dd36s3IRJgThi9szDfKWulwW/Bb0kEowWyFh75CQYjLPwEmGNGfW0xFiNZTpvKYDpywBQjjX5G2DPb68h02vjwohxCEZ2m2gp49Ea1D+8DeudfTkuPo5BKDJpOQ2whJOQNbw9mcECJ7ImMKbFFA0xvUGXarPHg7z7Os0bX2n3NZCfEMCfLwads69itT8az/OvQ0wTVGwZ1jb+9VU4wrPOlVdOgZqPKLBZeSmGGytKqALPwkL3J3kCYJ7fXcUlRBkmeg6zseY6HQ+dzMP9atX+69JW+61e2unl1bxM3nTmJ2OJ/qqD8Uy/Jz39xXBJgCiHEBPfo5ho6PEE+f160Cctbv4Swn5Srfs3KW3/LzcafU6unML/tRfUYSJfACSTdoQLMF3Y1ABBJnak6wZptY7msPgWpsWoWpsGg5mFKBnPEdLgDrCtt4fJ5WeQnx+Kgh4Qnr4N9z0HJS4ed3zuiZFpaHLk+9edwwDgFEnKhc+glsm7/yJTIOmOiJbK+AaNKxrBE1hcMs/5AK6tmpqHVbyPDV85/Q+fzgneu+pDkKGWyNe0eDra6Qdfx/ucG2jc9xjWLcshPiVXlsUYrTF1FdkIMsRYjJY0ulcH0u6Bb/f19bmc93b4QH1uUDi98Dcx2fh+6hnUHOmDqBSrAjDYaWruvCV2H65bkqj2ak8/rL0UX4hhkDqYQQkxw/3m/isWTElk0KQma98O2f8OSmyF5CkXAT7/wSf713nkUrpyC01enPvnvHTkhTnu9Gcx1pS0kx1qwXXe/GkVwiihIieXZ4np0XUdLmQ61W8Z6SaeNF3c3EIroXD4/iyRrmHstv8PmOgjmWGjed9j5Zc09pMZbSbBbCHfto1lPoMwTDwmToOx1lUXTBt9F2RsIY7ca1fNOpER2YAYTVKMfX9ewrjUSNlS04Q2GWVmYBlt/gm6OZU/8BZQUt3HNtAtg7zOqZNVgPOR5N/1zExWtbi7MdHN3xwv8xBiH98yb1fdn//MqALTGYwCmZ8SrRj9zZ6gnt5QQis3gH29XsDBVZ/Hbn4SaTRiu+CuO1zNYV9rCTQsvgt1PQP02yFnMhvI2ClJiyfJXqAz0OV8/2d8qMU6dOv9CCCGEOOlq2j2Ut7i5ZE6mOvD6j8ESByv+X985uUl2fnDZLJx2q2rckjlvbBYrxkRqvBWDBoFQhIWTEtHiMyAubayX1acgJQ6XL0SHJ6j2YXZWQ9B7/CeK43q2uJ6paXHMynSQ8fpXWKyV8vTkH6n9d817Dzu/rKmb6elqRIWxcQelhinUdHhUiWzIO6QOv7qu4w6E1B7MkA/QR6aLLERLZEcng9ns8vFWSXPffx3uwGHnvLGvmRizkWVZZtj9JNqcj3Dp4ulsq+6kOe8ScDcfVibb6QlQ0ermnGkpTAmoPZWJWg9ZW38DTXtUl97CS/vOL8yIp6SpGz2lP8B8ZHMNnuZKHuAHaPXb4Zp/wYKPcd6MNDaUt+HLP199eFT6MqFwhE2V7Zw5JVnt7USD6RePyvdMnH4kwBRCiAlsXakafr5iRir0NEPpS3DG5yA2eYxXJk4VZqNBdQ8GFuYljvFqDje5r5Nsj5qFiX7E/YFiaHRdZ3ddF2dPTUHzu9D2PcPj1it5RT8T0merZl8DZjbquk5Zcw/T0uJVOWtrCQ326dR2eMCZq07qGvw+TH8oQkQHu8WkrgfDzmBaTQYsRoPqIguqRHYUmvw8vb2OVb9bxyfv39z335ce2Q7hIOx/Edyt6LrOG/ubOWtqCrbdD6m9pYs+yaVz1Yd8T3uKjlgmu6derfeWcyfzraIeIqYYwktuga3/hjd/AWgwoz8AnJOdQKcnyMN7fBCTSKBxL+tffYKX7D8kNtAKH38KZl8JwIrpqXiDYTY36Wr8UOnL7K530e0PcebkZJUdzVkio6nEoEmAKYQQE9i60hZyEmPUm/SyV9XBWZeP7aLEKScjug9z0aRTL8DsHVVSIZ1kR1SXN4g7ECYnMQa6GwHodMxUo0rSZqrAqPNg3/m9HWSnpcdB027QI3QlzKam3asymDCkRj+egOqkarcYVXksDDvA1DQNR4yJroElsiPY5MflC/Klh7fzlUeLKcyM5+Gbl/Hkbcu5ZXkWkyoeJnjnfHjkenj6NjZWtlPX6eWCGYmw4W8w6SzIXkhOop15uQk8u7cTpq+BPU+Bv6fvHrvrVEnv7Cwn1G7BkLUA46ofqGqCkhcg94xDKgs+siiH82ak8r1ndtMWU0B411P8NfwzLM50tM+uhfyz+85dNjkZq8nAi7saVRfoxl3s3KMy1MtTfNCwQ40ZEmKQJMAUQogJKhCK8N6BVlZMT1XzC0teAkc2pBeN9dLEKSbDacNk0Jib4xzrpRwmJzEGk0FTnWSTpgCaBJgjoLZDlRlnJ8SAqx4AS1I2VW0e9LRZ6qQB+zDLejvIpsVDfTEA4Yx5NHR5CcZnq5OGFGCqbGOsxaSCWRh2iSyofZh9JbI2p6rYiAbOJ+rXL+3nhV0NfGPNdB45r4szN93OwmfX8J3iC7jDfD8NYSfMuwHKXuGV5x8nNd7KVZZN4KqFs77cd51L52Swu85F4+ybwdOqunZH7a53kZ0QQ5JVh8adkLNIBcprfq5OGFAeC2ou7V0fW8SS/CReaUkkJuxie8JqbJ9/67BGPTEWI1fMz+Lp7XV0T1oDwIwdv6QwLYbkurXqpBmHXl+IY5EAUwghJqgtVe24A2FWTE9Vs83K31SfXg+hCYeYGK5ZlMuXV03DZjYe/+STzGQ0kJdsVwGmxa46ln5g7p8Yut4AMyfR3teB1Jk2CW8wTKutQJ3U1L8Pc3etyrBNS7XD7v9BfCaJ6flEdGjwWVVQN4ROst5oBjPGYoSAWx20xA379cTHmPub/My/EfQI3H8JdNUN+5oA4YjOK3saubgogy+unIZx7U+g5n1ImY525he4O/+PrOn+Pp0rf4XPnslVrX/nCysKsGz8C6TOVJ1boy4uipbJtmbB3I/Ce3+BjoMA7KnvYnaWAxp3QzgA2dE5lHM+Atc/CktvPmxtMRYj9920mJdTPsnNke+Q/akHj5oF/tRZBXiDYR6qsBJa9VPO8L7Nb41/UXM5k6dK91gxJBJgCiHEBLWutAWTQWP51BQ4+C4E3dLEQRzR6lnp3L5q2lgv46gmp8SqEllQI3QOvqP2vYlhq+uMZjAT+zOYyZmTADjYo6nOsAMa/by+v5l5OU4Sy/6nAqzzv0dOsso49jX6GUIG031IiWxvgHkiGUxT/5iSnEXw8SdVFvP+i6GjatjX3V7dQWtPgDWzM9T1WvbB8tvhuv/CBT9hxUVX4wvqPFLcyt3GG5hrqOTG5t+oMuLlt6vxOlG5SXbm5Th5cVcDrP6x6iL76g/o8YeobHWr8ti6aJfknGiAqWkw46Kjzp2Nt5m557ZL+enXv0xGwtFn087MdLBschIPbKhic9aN/Dx4A0Uda6HybZgh5bFiaCTAFEKICWpdSQuL8xOJs5rU7DNTDBScM9bLEmLIZmY6KGvuViWQ864Hd0v/nmIxLHUdXmLMRhLtZpXBtCWQm5YEQFWbRzX6iZbINnb52FHTyYemx8BrP1D7Aed/jNxEFRDWdnhUQDqMEln7SJXIxpjp9g740CFvGXziGfB1wjNfGPZ1X93bhNmocf6MVPXBBkDBuX2PF2Y4WD4lmT++XsadLQtojy/EtPNhiM+EOdccdr1L5mSys7aLmlACnP012PcstdteRdehKNuhxvDEZajtDINkMxvJdB49uOz1qbMKqOv08osX93Fv5DK85/0YTDYo+vCg7yUESIAphBATUpPLx/7GblZMT1Mz1EpfVjPUjvIpuBCnsrOmphDRYUN5myo5jEuHbQ+O9bLGtdoODzmJMWp/tqsBHFnkJNoxaFDd5laNftrKIBTgtb1qL+M1nf8Ebydc+nswGMh02jAatP5GP53V6ufNIHj8R8pgDr9E9pA9mL1yFsGca9We0UGuayBdV+Wxy6ekEG8zq2yf1QEZh45y6i0/zU6MJf5Dv1QHz/wCmCyHXbN3ZNSLuxpg+RfBmUf6+h9gIkRRdjSDmbN4VLYyrJ6ZTm5SDLvqVDluzHlfhW9XQ9b8Eb+XOL1JgCmEEBNQ33iS6alq3EBnldp/KcQ4tDAvEbvFyLtlrWA0qSxm2asj1sRlIqrr9KryWFAZzPhMLCYDWQkxVLV7IG0WRELQVsare5u4JLEOx97/wrLPQ4ZqFGYyqiCzpndUSdAN3o5B3d8TVAFmrHWESmRjTLi8IfQPBpKpMyDQ3VcGPBSlTT1UtXlYMzs6vqPybdUV1mg65LyVhWlcPi+Ln1w+G/P0lfC5d2HZbUe8Zm6SnTnZTp7f2YBussHFvyKx5wBfsr9GmskD7RWQvWjIax0Mo0HjpjPzAdR4EgCTdVTuJU5vEmAKIcQE9NKuBtLirczMjFfZS5AAU4xbFpOBMwqSWH+gVR1Y8HHQw7Dj4bFd2DhW1+lVI0pABZgOlVmblGznYFs0wAQ8tbvYUN7Kt03/RYtLg/O+fch18pLsarRJ36iSY+93rO3wUN7So7KkQMwIdpENhCP4gpFDH0gtVF9b9g/5mq/uUR9gXDAzHbpqVfA3oDy2l9Gg8afrF7BqZjQQzZij9lcexTWLc9hV18VbpS1QeCnrzcu4VX8Mbc9T6oTe/Zej4NoluawsTOPqhTmjdg9x+pMAUwghJpiSxm7eLGnhhjPy0MJB2PkYZMwFR9ZYL02IYTtragoVrW7VnCZlKuQth+3/GVbp40TX4w/R6QmSnWCHcAh6mtSeQSAvKVYFf8lTwWCitmQLZ1NMXncxnPtNsMYfcq0pqXEcaO5BT8hVB46xD/OdshbO/vWbrPrdOv7w6j6mGOqJtw6cgzn8Etmpaeq575W3HvpAX4A59M7Dr+5tYkFeAmkOG1Qevv9yuK5bkkdBSiw/f2Efbn+I/+e+EU0zwsvfBjTInH/C9zgah83MPz+5hJmZjlG7hzj9SYAphBATzN/XlWO3GFUp1Bs/U50gV3xrrJclxAk5Z1oqAO+WqfJvFtwIbQegesMYrmp8qusY0EHW3axGesT3ZzA7PEFcIQ2Sp+Gv3cV3LY+hJ+bDwpsOu9a09Di6fSGaDdHs3TFGlby0u5FYi5E/XjefZxbvYq3lGzgeXKNKTw2mI+5ZHKyVhWmkxFl5aOMHAtzYFIhJGnIGs77Ty666LtbMylAHKt9W1+mdEXoCLCYD37m4kAPNPfzo2T3URpI4UPQVNZ4ktVDNvxTiFCYBphBCTCA17R6e3VHP9UvzSGx4B977Eyz+NMz80FgvTYgTMj09jrR4K+8eaFMHZl+pMl47HxvTdY1HtR2qJDUnMUY1+IG+CodJSapMdXt1J+7EGcxyb2Q6B9HO//4RA8DezGFpl0E1wDlKiayu67yxr5lzp6dyxfxsilzvqk6pPpcK3k4gewlgNhq4dnEOb5Y0Ux8dwQKoZjmphUPOYP7nffU61sxOV1nyg++oLtyGkXlrfcGsdJZNTuKJrbUAxJ97m2rENvvKEbm+EKNJAkwhhDgNBUKRIx6/950KDBrcsjAOnvqcGvR94S9O8uqEGHmapnH21BTWH2glEtHVQPncpVC7eayXNu70zsDMSYhR+y+hL4M5OVUFejf9cxN/22PBqOn0JBQedZTF9HRVMlvW7IbMeVDx1hHLlvc2uGh0+VhZmKYaAdVsVM2avrgFrn8ErrzrhF/X9Uvz0IFHNn8gi5pWqDKYgyyn3lrVzt/XlXP1wmympMZBRyV01YxIeWwvTdP4/qWz0DQ1wzMnOU6NVfnAHlchTkUSYAohxGmmrKmboh+9wpslzRD0QfkbALT2+Hlkcw1Xzs8mfeMvwO+Cj/xTRpOI08ZZU1NodwfY2+BSB7IXqxLw3i6kYlDqOrxYjAZS4qz9AWY0gzk9PY6/37iQX109h8XLVwEQe8nPjpq5S461kGg3U9bcrYLQ1lJo2HHYeW/sa0bT4LwZaVD+pmrSNG2Nuu6Mi6HwkhN+XblJds6Zlsqjm6sJhQd8CJdaqOZh9jQf9xo9/hBfebSYrIQYfnL5bHWw9BX1NX/kAkyAomwnt503hWsW56pxMUKMExJgCiHEaeb9ijYC4Qg/e34v4e3/gQevgqr3+PPaMgLhCJ9bngl7n1HZgfQT3y8kxKni7GkpAP3dZLMXqf2DRwhoxNHVdqgRJQaDpsZ3GExgV99bTdO4qCiT65bmcf4lH4Uv70Cbvuao19I0jWnp8ZQ19cCsK8Bghl2PH3be2v3NzM1JIDXeCmWvQUziqHRLvWFpHk0uP2/sHxBMps5QXwexD/Mnz+6hrsPLnR+dT7y3Hh7/lGq+kzYbUqaN+Hq/eWEhP7hMfk6L8UUCTCGEOM3squvCaNCoaHFTUfw2AI3r7uXfG6q46cx8prS/rdr+z7lmjFcqxMhKd9iYnh7HuwMDTIDaLWO3qHGottNLdsKAESVxGUfOUGoaJOYf93rT0uIobepGj0lUWcldT0Ak3Pd4S7efHbWdrCpMg0gEDrwGU1Ydc5THcK2amUZavJWHNg1o9jPITrJbq9p5fGstt503lcXsg78sgZKX4NxvwWdeVd8PIYQEmEIIcSyHDeUeB3bWdnH21BSWT0lGr98OgLPieeamGvj2xYUqe+DIhrwzx3ilQoy8Mycns7Wqg2A4AnGpav5i3daxXta4UtcxIMB01ffNwByu6enxuHwhWrr9MPca6GlUTXGi3ippRtdVp1caisHdogLRUWA2GrhmcQ5vl7bQ2uNXB+PSweY8bgZzQ7lqIHXzuZNh9xNgtMDtW2Hl98B6Yk2IhDidSIAphBBH0eTyseI3b/GdJ3eppiFHEg5Ca9nJXdgx+IJhypp7mJvj5PsX5jNFr2EDc4jBz10LqrEFu+DAWii6esS6HQpxKllakIwnEGZXXZc6kL0I6raN7aLGEV8wTGuPX3WQBehu7GvwM1zTejvJNvXA9IvAEg87o2WyndWkvPN9zomrY3aWQ5XHosHUVSd0z2O5dE4WER1e2dOoDgyyk2xxTSdTUmNxxpihZrMq4XVmj9o6hRiv5N2FEEIcgT8U5tYHt1LX6eXhTdXc8dxO9G0PQFct9Z1e/rW+Ep/PC4/eqMqkTpE9XnsbXIQjOkXZTmZp1Rg1nfsDq+mwF5Bd+STsexYiQSj6yFgvVYhRsbQgCYBNle3qQPYi6KoeVAMX0d9BNjtxQIlstMHPcE1NVwFmWXO3aio263L1s2jbA+h3Lef8rqe5L/x9tF1PQNmr6s8sNuWE7nksMzPjKUiJ5cVdDf0HU2ccM4Op6zrbqzuZn5sI/m5o3gO5Z4zaGoUYzyTAFEKID9B1nR88vZvimk7+cv0Cbj8jgTVbb0V79nY8fzqTn/zud9zx3E7q770BSl9W+4S2PTDWywZgV63K2szNcUK0PPbaK67EufxTUPM+rP8TJE9T4wKEOA2lxluZkhrLxoroPMzsaKMYKZMdlLqO6IiSRDv4e1S36fiME7pmapyVBLtZZTBB7f/2u+DZ29kZzOGqwE/xpc6FJz8LdVtGrTy2l6ZpXDIngw3lbbT1lsmmFoKnFdytR3xObYeXNneABXkJ6v8lPQK5S0Z1nUKMVxJgCiHEB/xnYzWPbanl9pVTuTi1la8dvJVFxnJ+FryRimASdxt/w+txP2Jy6xsEL/iFar2/83EIeMZ66eyq6yIlzkKGw6YCzNg0Vi+dh2HedaAZob0c5nxEmlGI09oZk5PZcrCDcESHzLnq/30JMAeltmNABrNvBuaJZTA1TWNaWhwHmrvVgYJzKUtdw69D1/NF88/47i0fx3HrS7DkZrWvceaHTuh+g3HJnMxomWyTOtDXSfbIZbLbqjsAmJ+bADWbAK3/wwshxCEkwBRCiAG8gTC/eXk/Z09N4asrcuGBK9AiIQyffpkpl/8/rLe+Dks+S36okl8Fr+NR42Ww8BPg71KjP8bYrtou5mQ71cy0+mLIWqCCyfh0mH6hOknKY8Vp7oyCJLr9IfY1uMASC2mzpJPsINV1ejAaNNLjrarBD5xwkx+AaenxlDb1oOs6a0tauaDmk1TPuoUXvnoeS/KTwGiGS38L3645KeOTZmU6yE+295fJ9nWSPXKZbHFNJzazgcKMeBVgphZCTMKor1OI8UgCTCHE6atm05Czii/sasDlC/GF86diKHsJPG1w5V0Ycxdxwxl5TMtOhUt/h/7/DrIh6xPc83YFoZwzIWnKmJfJegNhypq7mZPtVKVtrSUqwOy1+idw2R8gZerYLVKIk+CMgmRAzYQFIGcR1G9TIzDEYara3Ny9rpy/ryvHsuthvmJ/BZPRoBr8wAlnMEE1+unyBqlu9/DDZ/YwPT2OP1w7H4fNfOiJZtsJ32swVJlsJhsq2mh3B1RnbUscNO464vnbqzuZm52ASQNqN0Hu0pOyTiHGIwkwhRCnjSaXjw/9+V1++txewrufgvsugP9eA0HvoK/x0MYqJqfGsmxyEux4RL3pKDj3sPO0mEQ+v2IK1e0eXtzTpLKY1e+NaUfZvQ1dRHSYk5Og3iTpEcia339C6nRY/OmxWp4QJ02G08akZDsbBzb68XVBe8XYLuwU9ce1Zfzypf386qX9rHE9ye2hf0HVe9AdzWCe4B5MUKNKAL78SDF1nV5+cdUcLKaxfRt6yZxMwhFddZPVNLX3c8cj0Fl9yHn+UJi99S61/7KtTP2/JAGmEEclAaYQ4rTQ4Q7w8fs2sr/RxbPri/E++SV0Zy5UrYfHP6nGiRzH/kYX26o7uWFpHlpPsxrnMfejRx32vWZWOlNSY7nrrXLCc68Dg+nIWUxv55CC3OHqbfAzJ9upZskBZM4f9fsKcSpamp/E5oPtasRQ9iJ1sE7KZI+kpLGbc6alsO8nayi0RLvtPns7tFeC1TEiMx57R5UU13Ry/dI8FucnnfA1T9TsLAeTku08tb1OzTy+4Kcq0Hz5O4ect7feRSAcie6/3KgOSgdZIY5KAkwhxLj0yxf3cemf3uFvbx2gtKGDT/9zAwfbPPz7U0v4X97jmMNevmz8Hp4L/k91en3qcxAJH/OaD22sxmIy8OGFObDrcdDDMO+6o55vMGjcvnIa+xpcfOGZOsLTLoJN98CjN1L3+t+off3v8MCV8H+T4X+fHeHvwOF21nWRGm8l3WFVDX7iM0dk75QQ49EZk5Pp9AQpbe5W++XMsX2dlUW/cESnrLmHwox4Yjz1aCEfzL4K2g5A8X9PeAZmr9R4K84YMylxVr59UeGIXPNEaZrGJ87MZ1NlO2+VtkBCLpz7Tdj/PJS93ndecU0nAAvyEtXWi5hESJatBkIcjWmsFyCEEEO1saKNu9+uIDshht++vI+z3/gB92kteKZfQk7tDmh+g/1zvsnL2xNo3VvAgyt/iPGNn6pM5BV/A+PhP/o8gRBPbavjkqIMEmMtqkwqa2F/Z8GjuHJBNq09fn7+4j5uy76WnxfYMZS+SXb4OQAiiZMxZC+CkpdU+/tRnO12aIOf7YfuvxRigjkjOg9zY0U7hRkO1U1WAszDVLW5CYQiqoS1NdpBdektKiAv/s+IfUilaRq/uGoOGU4rTrv5+E84ST6+bBIPbjjIz1/YxzlTUzCd+UUVWL/0TSh4H0xWtld3kuGwkeG0qQAzZ6l04hbiGCSDKYQYV/yhMN99ahc5iTG8/rUVbL6slbmGSsiYQ07NC/DWLyFnKYVXf4c7ririvfI2fuG6GFZ+H3Y+Cv/7NIQCh1332eJ6uv0hbjhjktq/2LQL5t8wqDV99pzJ/OX6hbzZYGHxris5N/QXflHwby7y/4pXzn9BNdbRw7D36RH+bvTbUN5GeUsPRdlONQS8tUzKY8WElptkJ9NpY0uVGi9B5nz1dzscGpkbdFRByD8y1xpDvbMpZ2TEQ2upOpgyHS68Q2UvU479IdtQXDo3k0WTxr40diCLycB3LpnJgeYeHt5cAyYLXPx/ar/uX8+A575CcuWzXJtyEA6+q4JwmX8pxDENOoOpaZoR2ALU6bp+2egtSQghju7udRWUt7i5/1NLiNECxGz6DWQtJOnml9Q+x4PvqMydwci1i3PZW+/ivncrmX3t9Vx9oR1e+a4KMD/6HzCaiER0/rm+kndfeZy/O7aw5MAmaNoNBjPMvnrQ67p0biYZTivvlLXy8WWTSLBbeOZXa3l8Wx0X37QYUmfCridgyciWygZCEX7/Wil3v11OQZKdTyTvh/s/A+iQJ3uExMQ2J9vJnnq1N5msBbDxLhVEDXMMxnee3MWCvASunZMIf1sGK38AZ942gis++UqbutE0mJoWB9tLVfmnPVll6L6wEUwnp6vrWFozK51lk5P4w2ulXDonk9b4pfQs/AXOihfI2vYoP9I9UA/8K/qEvOVjuFohTn1DKZH9MrAPcIzSWoQQ4pgqWnr4y5sHuGxuJufPSIP1fwJXHVx1t3ozZLH3z3qM+t6lM9nX4OLbT+5i9hc/wYxLLPDiN2D9nbQsuJ2vPVZM5YG9vG77PVbdgLbhDYiE1KzI2OQhrW/RpKRDPp2/emEO97xdQXO3n7Q5H4Y37oDOGrXPZwT4Q2Guv+d9tlV38qlFiXy/6ycYn30fEvPhqntg8nkjch8hxquibCev7Wuixx8irrejckPxsALMcETnia011HZ4uDarDYIeaN47ousdCyVN3eQm2rFbTKryIWV6f/mnzTm2iztJNE3j+5fO4kN/eZdFd7yGrgPkYzJ8kWkpMaxMbuMzixJIModUM7dJEmAKcSyDCjA1TcsBLgV+DnxtVFckhBBHEApH+OYTO7GaDPzwslng7YB3fgdTL4CCc476PLPRwF8/tpA1f3ib7zy5kyc+91kMVevR3/oVvyrOZHNLIm9mPYy124x22wZw5qgW9NYT/yztI4tyuOutcp4uruOWoo+oAHP3/+Dsr5zwtQF+83IJ26o7ufPaOVy592tQvxUu/b0amWI8dfY4CTFWZmc50HXY1+BiSd5UNeewfvugy98Hqu/0EgzrlDX1QGt0jEXHwZFd8BgobezuGyFCa6ka1TEBFWU7uePKIqrbPczMcDAjI54pqXFjPkpFiPFosH9r7gS+BRx1QrGmabdomrZF07QtLS0tI7E2IYToc9db5Wyt6uCOK4tIc9jgzV+qQHD1j4773JQ4K9+7ZCbbqjt5aFM1XPI7vMZ4Pt36ax6dv4fMto1oa36mMouaBjEJYDjxNxVTUuNYmJfAE1tr0RPzIWeJKpMdAesPtHLvu5V8fNkkrmz/Jxx4DS75P1jyGQkuhYgqylYZuD11XarJV8ZcqC8e1rWq2jwANLp8+Br3q4MdVSOxzDETCEWobHUzIyNOjVNyN0PKtLFe1pj52BmT+M7FM7lyQTYzMx0SXAoxTMf9m6Np2mVAs67rW491nq7r9+i6vljX9cWpqakjtkAhhCiu6eTOtWVcPi+LK+Znw+b7YNPdqtNhxpxBXePqhdksn5LMr1/ez+tVIb7m+SSzDVXM23WHKiVd9MlRWftHFuVS2tTDrroumHONah60/T/w8nfhH6tg3W8g6BvSNTs9Ab7+2A6mpMbyg/z98O4f1PoXf3pUXoMQ41VavJWUOCu7613qQNaCYTf6Odjm7vu1p36f+oWrdlAzdgdq6PKysaKNTs/hzcZOtspWN6GIrjKYbQfUwZTpY7soIcS4N5iPZs4CLtc07SDwCLBS07T/jOqqhBAiyu0P8ZVHtpMeb+VnVxapcR8vfgOmXwQX/mLQ19E0jTuuLMIfivDZB7awM+5sAkXXgdUJH/rTqLWcv3RuJlaTgR8/u4e3TGehawZ45guw+V4I++HNO+CuMw+Zudarxx9iQ3kbzd0+9JKXCLzxK57fcoCb7t9Ma4+ffy+qwPLc5yF3GVz8m1FZvxDjmaZpFGU72F3X2+hnPoS8/eM4hqBqQICptZWpX+gR6KoZ9DXWH2jlgt+/zUfveZ/5P32NZb9Yy5PbalWp7du/gfbKIa9rKCIRnZ21nX2/L2nqBoiOKBnQQVYIIU7Acfdg6rr+HeA7AJqmnQd8Q9f1G0d3WUIIodzzdgUH2zw8fPMynO274PFPqXEDH/nnEedZHsvk1Di+vGoav3+tlN9eOw/L5JXgd41qIwtnjJnvXzqTO18v45OPd/Ih27eYnhZLJP9cpuWms9q6B8sr34b/fhgu/7PaPxn1g6d389T2OpLp4i3b14nHw5zIfUyyfo5fz2og561/QP45cO0DqrW+EOIws7McvFPWii8YxtY7G7Z+O6TPHtJ1Kls9TEuLo7ajh7ieg+rnUEOxCg6TJh/3+U9vr+ObT+xgckoc31qZQ2t9BRu2bCHn9TvB+64KVn0uWPOzIb7CwXu6uI6vPbaDv9+4iItmOOks34LRYGJyaizsKVXdsxMnjdr9hRATw9DenQkhxEnk9of494aDrJ6ZzpmTk+C+69T+yBseBUvssK75hfOncsPSPBJjowHZSeiS+PEz87luaR7vHmjluR3ZPFPbRcU7dUT0Os6bkco9t7yL5dGPwgvfUG9aM+dS1tTN08V1fHhhDrd0PY69zs+Tud/h4s6H+VP3T+EAsPAmuPR3sudSiGMoynISjuiUNHYzL3sKWOJVgLlgaJ+VV7W5KUiJJdfQgrkzANMuiAaYx9+H+eS2Wr722A6WTU7igZT/YHlKFYJ9FOj2xMJZX1JzcnvLVEfJU9vrAPjDa6Vc2PAmN+78A+8k/hGryag6yCYVyM8TIcQJG1KAqev6W8Bbo7ISIYT4gEc219DpCfL586ZAxZtQu0kFVHFpJ3TdvuDyJDIbDZw/I02NVwF8wTCPbanhh8/s4Wv/28sfr7oX4z3nwmMfh1vW8YfXy7GbjfxwUQDng0/DmV/g6gu/DcEvw3t/gdgUte9ylEp7hThd9DX6qXcxLzcBMucNudFPJKJT1e7h/MI0koLt0AkUnAvr/3h4J9lQ4LCKggc2VFGYEc+/PzYTy+8fh6mrYe5HeWh/mF8VW9m28kpMbQegZeilu4PV0u1n/YFWZmY6KGtox+97ABs6t2hPAzepElkpjxVCjABpjyWEOCUFQhHufaeCpQVJLMpLgLd+DY5sWPDxsV7aiLCZjXzizHy+e0khz+9s4HuvNhD+yL+gq5buhz5J1e4NfHZ5Ls43v6uCyRXfUk80x8CKb8LiT0lwKcQg5CTG4LCZ2F0/YB9m464hNedpdPkIhCJMSrZTZG0EoNsxBRLyDg0wD66HX+ZAa38mssMdYEdtJxfOzsBauVbtvT7n6zD3WkyTz8YVsVLb4VXBXUflkJsGDdbzO+uJ6HDnR+dzY9J+bP5WdkQms6jnLRXYtldO6A6yQoiRIwGmEOKU9ExxHQ1dPm47bwpUvg0178PZXwWTdayXNqJuOXcKXzx/Ko9sruHSp/yULPgu8TVv8oL1e3xly0qVtV394wkz8FyIkaZpGrOznGpUCahOsmE/tOwf9DV6O8jmJ8cySW+gS7dT1hMDCZMODTAPvKauXfZK36F3DrSi63DejFTY+yzEpkHuGQAUpKhS/8o2twruIqFRm635THE9MzPVfMfbHOtp1BO5JfA1dIMJnv8qRIKSwRRCjAgJMIUQp5xIROfv68qZmelgxfRUWPdriM88bbKXH/T1NdP58/UL8AXDXLi+kOW+P/HyjJ+jLfwELL0V5g19KLwQol9RtoN9jd0EwxHIXaoO7ntu0M/vnYE5KdlOqr+KCj2LsuYeSMyHzgF7MKs3qq8V6/oOrStpIcFuZm66Fcpeg5mXqZmcqIAV4GCrG5Kj2cPWsuOuxxcMs626g61V6r9u37GznlVtboprOrlifhZ01ZHa9A5vxayhiSR6Zt8AVevViRJgCiFGgDT5EUKcFL0z3xLsx9//+M/1lZS3uPnT9QvQyl5Vb34u/j8w20Z7mWNC0zQ+NC+Li4oyeHRzDe9XtHH21XPBKj+ihRgJRdlOAqEI5S09FGbkwYxLYNM/4KyvgMV++BM87eDtgOQpgMpgWowGMp0xGLoqqGQaZU3RANPbAd5OMNuhfhtoBjj4LoSDRDQT60pbOGdaKsaKNyDohpmX990mJc5CnNWkAsyFU9XBtuMHmL9+eT/3rz/Y9/tJyXZe+NI5xB3lZ8azxfUAXD4vC4r/gqZHmH3ZF/jwXohb+XXY8x+VPU2eOphvpxBCHJNkMIWYgHbXdfG1x4p5t6x1VO8TCEV4dkc9n/nXZu76xVdo+e1SIv++HB7/JFS8dcTnrD/Qyi9f2s+Fs9O5LLUFnvgMpM1SHVNPc2ajgRuXTeIvNyw86htFIcTQzc5SJeY7a6Nlssu/BN52KP5v3zl76rv42fN7CUd0eOFrcO/qvv2QVa0ecpNiMAa60bobcNnzKW3u6Rvpcc+zb9JyYDOEfFD0YRVI1m5hX6OL1h6/qsTY9yzYEiD/7L57appGfoqdyjYPxCRCbOqgMphlTT1MS4vj359eygtz3uF21+/52TM7jniurus8XVzH0oIkshxW2P4ATD6POUXz+N218zAm5qnxSMlTVZduIYQ4QRJgCjGB9JaeXvW39Ty1vY4b79vI7Xe/QMOLv4Y9T0FbOUQiI3IvXdf56mPFfOnh7dTW1/E18/8whHx0dLnUnsrHP6Vmvg1Q0+7hiw9tY3JKLL9fk4ThoWvA5oCPPXHaZi+FEKOvICWWDIetL5NH3jLIWQIb/gKRMAD3vVvJfe9Wsrb4AOx/UQWgB98BVAYzPzm2b4xIOHkaB5q60RNUgLltRzEb3nxRXfucb6gsZsVbvFXSAsC5UxxQ8jIUXnrYGJD85FiVwQRVJjuIALOq3d23hWB2+2t8xPg283b+jJd21h9ynq7r/OWNA5S3uLlhhhGe/jx0Vh8ybxeAi38Dt74zuG+mEEIchwSYQkwQ/lCYT/xzE796aT+rZ6bz/ndWcceaTL7W8A0yN/1CZRX/vBD+ulSVhw1XyA91W/nftjpe2NnAV1dP56XlpVh1H7+M/y4fi/wU/YbH1Zu39+/qe1qHO8DND2zBGPHzn3PaiH3sWpUNuPF/4Mw+8W+AEGLCMho0Pn7mJN490EppU7fqwLz8S6qhzr5nCUf0vmBw1xsPqUY9aLDvOXRdp6rNw6Tk2L7gLyazkPouH48eUHspi+wdmBs2E3LkQlqhmmdb8RbrSluYneUgrWUj+LsOKY/tVZASS22Hh0Aoohr9HKdENhiOUN/pY1KyXY1Eaa9Ed2Rxg+lNqp/8ATXtHtB1Qq5m7vrvo5St/RcPZP6PK965DPY8qV73zCs+8A0yHblUWAghhkECTCEmiOd2NPDugVZ+/KFZ/O1jC0m3hrix/Bvkm9r5gvFHfMlxJ+GLf6PecD19G+j68G606R/wj5VseubvnFGQxBfPzcGw+R6YegEXrVzJ/sZu3urJhcLL4L0/g6edmnYPn7zrFW5t/w3vm24l/YVPgacNrnsY0maO6PdBCDExXb80D6vJ0L93sfBSSJoM6/9EcXUH7e4A50xLYWHXWnz2LNWMZ/+LtLi8eINh8lPsKvjTjKTmFQLw3Zeq6dHiuKlQZ6FWwj5T9OfV5PPQ67ZQUlXPimnJsOGvYHXAlPMPW1d+ciwRHWo6PCrA9LQd80O+hk4f4YhObpJdjTXRw2irfoRr5nXcyhN471yM+yeZmH4/jdsO3MqfLH/hnM6n0Io+DLdvhTU/UwGlEEKMEgkwhZgAdF3n/vWVTEuL46bl+WiREDz2CagvRvvI/VxyxfU825zG/YHVsOYOKH0J3v/boK/f5Q3yg6d385c3yujc+gQAPzbcw59W2zDufATcLXDWl7l8XhZZTht3vVUOK78PgR5aXv4VX/jb0/yh5/9xhel9THM/rLKWXy+B/LNG61sihJhgkmItXDk/m6e216qmYwYjLL8d6rdR+97DGA0af7gsl3OMu3nVcJbKNvY00rr/PYBoBrMUEicxNSsZALvFhCV1MvENG0jXOnmqNYcOdwAmn4cWCbGQfVwXfAoq3oTVPzrimKX8lCN0km07cNh5varaVTltXpJdza8ESJ2B4yN/paPo01hTC9iaeAn3xd3CuoV/hts2on2nDq66S83tFEKIUSYfYQkxAWw+2MGeehc/v6oITdNg0z1QvhYu/zMUXsIlus7KwjR+/1opF3/1E2QffAde+5HqithRSejgexj0MIbkKeoT/ykr1Rw3TQPg0c3VPPh+Fal08EXbdh4IXcC1sdtIf/Fm0CNq7lz+2Vg0jc+eM5mfPr+XO3cms9i+isU7/sn9WiwJFh3DDU8d0gBDCCFG0qfOzufRLTU8vKmGz583RY0+2vYA55X9ilU5fyel5mUgzN/bFlBgP4M5BhOGkueBC8hPskHTHkiZTl6SnZWFaVy7OAfL3sn8//buO06q8t7j+OeZ2V3YXZZdFpDeQUCKIEWwEI0Se4ktGJOoUbEkRk25Kd6bYnpyvdEYoyYqlqDGYCxRCWLBigioIF16x8Wll63n/jGDEKQs6+wu7Hzer9e8ZubMmcPvrI9n+fKUw6ynAHi7rCsNX19IVJ7PDVEmN2WPpd17s+GIc2HgFXus6ZN7Ya7dAkfsuFXJvJ23U9nN0uKdt0xh2rzExqbdIJ5Bkwv+QBOgAzAsJT8xSTpw9mBKaeCBtxaRn53Jef3bJpbUf/V30OWkTxZ6CCFwyzm9iCK46qGp/CRcS3G8KTx7I2Vv3sn7yzYwaWUZxXNeJ3r1d3D/KYm5mm/dQVS2nTFTl3NU+wJePyfxF58jzr6JhiMehOIFiccx3/okjI4Y3I4mOZnc9uKH3FF5AZmxiILGecSvGm+4lFSjerRszNDOTXl44mLKKyohnslHJ99Ow8pt3Fx5N3zwBJWFXVneoAs/f3Elm1sfQ4uV48mIQbv3bk30LPY4k3gscP9lgzi1d6vErUoAshrRtvtA/jxhAXe9sYJlef3oWzGDUNAOzv7jJ9fA3TXJyaRxwwwWf7wFCjpALHOfC/0sLd5KVjxGi7yGif0at4EGjWrgpyVJ1WMPplTPrVi/jXEz13Dl8Z3IzorDC7fC9g0w/Jb/2K9tkxx+cW5v/m/8PF5YGDEt/IzDcz+mss1RdGrVnAVFmxk3YzVR6RZ+33MBZ5SNhxf+m7UrFzFvzUn86ot9aDj391DYhYGDjkn8Zer038OHL/7HwhY5WRk8NnIoW0rL6d+ugPBRX8hrBTmFtf2jkZSGLj+2IyMfnspdExZw/UndeOGjAhaWj+DHax+GtRA74Yd8t0EPbvnXLH4duvLLzNf4Se4/ib05BgZcBv2/8p8HTN6qhDYDuHF4Tz7a8gHfPLEr3TZdCC9MhwsfgIb5e60nhECnZrksXrs1MTeysPM+h8gu/XgrbQuzicVCoqezWbfP/kORpBQyYEr13EMTFwPwtaEdYd0SmHQP9PsytOz9qX3PH9CW8we03euxtp1bwY+e/IAbpmXT86br6DzxhxS++wDdM3pxZvfBMO51GPrNnf9SP+jKxGM33Vvm7XzTotdnOT1JOiAn92zBOf1ac+v4eRTkZPLK3CIWNP4i/9NiEWHxG9D7fL7WrCNn9m3Ny5MPo3LCKL5aNgY6HJu4ncfuPZE7ejDbD+GI1o156hvJueOVV0KfC6v0j2cdm+UyZfG6xJtm+75VydLirXQozEksxLb2Q+h3cTV+CpJUcxwiK9Vj5RWV/H3yMk7p1YI2Bdnw8s8hxOHEm6t1vOysOD86vScNMmL8euwcth//I7aRxf8WPEHjJS9BZTn0PCvFZyFJqROLBf73wiM5uedh/M/TM3ltXhEn9mxJuPAhuPixT3oEC3OzuOCEgcQ6DUsMXb3oYcjI+vQBW/WDFn0+fe2Lxas8MqNj01xWbtjG9rKKxJ9fvBAqyj+1XxRFLP14a2KBn02roXQTNDv8QH8EklSjDJhSPTZj5UbWby3j9D6toHgRfPAPGHLtZ7qvZPO8Blx3YlfGz1rDL1/9mD+VnUOfzW/ChN9AXmtofVQKz0CSUi8zHuNPXz6KoZ2bUl4ZcVLPwyC3KXQ/7dM7j3gEvvFO4vM9ySmEa9+Aln2qXU+nZrlEEYl7WDbtBpVlsH7Jp/Zbv7WMTSXliVuUrE2uIGvAlHSQMWBK9dhbC9YCMKRzU5jzXGLjgEs/83GvOK4TbQqyefjtJYzNPZeooEPifmw9zoCYlxVJB7+GmXHuvXQgoy4fxHFdm+19xwaNILNhjdbScdeVZHcExin3f6oXc+cKsrk7h9EaMCUdZPyboFSPTVzwMd1b5NGsUQOY+zy06L1zvtBn0DAzzvdPS9xo/MwBnQin/DLxQe/zP/OxJam25DbI4MTuhyVu31SHOjVNBMwZKzdCm6Ogz0Uw8U/wwOmJ0SdJOwJm+8KcxAI/WXmQ17JOapakvTFgSvVUaXklkxcXM7RLU9jyMSydCN1PT9nxz+rbittH9OPqz3VJzD367nzoMDRlx5ekdJGfk8nnDm/OwxMXs7ksgvP/CufdCx/NgbuPh/XLgJ0Bs11h9s4VZOs4HEvS7gyYUj31/rL1bC+rTATMef+GqBJ6pC5ghhA4p18bGjfMTGxo1Dxlx5akdPPt4YezbmsZo95I9lj2vRCuGJdYyGfWU0DiFiXN8xqQk5WRGCLbvHvdFSxJe2HAlOqptxasJQQY0qlpYnhs4zaJ1Q4lSQedI9sVcHLPFvz19YVs2FaW2HhYz8QKtck59EuKtySGx5Zsgo0rvAempIOSAVOqpyYu+JherRuTn1EG819KDI91KJUkHbS+PfxwNm4v577XF+7c2OMMWPo2bC5iWfG25PxLF/iRdPAyYEr10LbSCt5bup5jujSDhROgfFtKh8dKklLviNaNOaNPK+5/czHFW0oTG3ucAUSUzxnLyg0GTEkHPwOmVA9NXbKO0ork/Mu5z0GDfOhwXF2XJUnajxtP7sbmknIenpi8D2bLPpDfnpIZzxBFyRVkP5oFIQ5NOtVtsZK0BwZMqR6auHAt8VhgULs8mDsWug2HjKy6LkuStB/dWuRxQvfm/G3SEkrLKxNTG3qcQfbSV8lhO90yVsM7f4XOJ3hdl3RQMmBK9UwURbwyp4gj2+bTaNE42Pox9LmwrsuSJFXR5cd2omhTCc99sDKxoccZxCpLOTn2Lj3fuAEyGsDZd9RtkZK0FwZMqZ7594zVzFq1kQsHtoMp90N+u0QPpiTpkDCsWzO6NM9l1JuLiaKIRbl9WR814ncN7iWzaAacexfkt6nrMiVpjwyYUi3657vL+cq9k1i1YRuUbIZt6z/T8Z5+fwVfu/8d1m0phVXTKZ0/gV+PnUOPlnlc1KkUFr0KAy6FWDw1JyBJqnEhBC47thPTl2/gnUXF3PiPGbwaBtAw2g5DroPup9Z1iZK0VwZMqZaUVVTyu3/P5Y35aznvzjfZOupc+GN/WPFutY4XRRG3v/Qhr80r4or736LysS+TMfo8Wq2bys1n9CT+3gMQy4D+X03peUiSat75R7WhccMMRj48lWnL1tPk8zfB0dfAyT+t69IkaZ8MmFIt+feM1azeuJ3vndKd4ysmkbN6MhVlJfDg2bD4jQM+3nvL1rOwaAvn9GtNhzUvENuwjI1RNn/NvoPjCzfCe6MTy9vntayBs5Ek1aScrAxGDG7Phm1lnHdUG4YNOxFO+21i/qUkHcQMmFIteeCtxXRomsO1x3fgl43/yZJYW4aX/IZt2S3gb+fD+49CZWWVj/ePKcvJzozzy3N787PCF5hb2ZaLSn9Kbrwc/vp52FYMA79eg2ckSapJ136uC98efjg/O7tXXZciSVVmwJRqwfTl65m6ZB2XDu1IbPpjZK6bT8GZt0B+e76w/gdsLTwCnroG7hoKM56Ale8nbi/y3mjYtPpTx9teVsGz01ZyWu+WNFr6Mo03fkjJ0dcz8vzTiJ//V9i+Hgq7QMdhtX6ukqTUaJKbxbdO6kZew8y6LkWSqiyjrguQ0sGoNxfTqEEGFx7ZFP76a2gzkPz+5/Fw5+1ceNdbDFv7A/527Cq6zbmT+Jjdeh0zc2DItXDMtyC7AIBxM1ezqaScCwa0hdd+APnt6HvqFfSNZwJtYcQj0KglxPw3JEmSJNUeA6ZUwz7auJ1np6/kkqM7kDf9Adi4Ar54D4RAm4Js/nbl0Vx0z9uc+lJzYvyY8/Lm0KlJBo0Pa0+nFgUcs3o0sddvTdxy5GvPQKu+jJm6nDYF2QzJ+BCWToRTfwvxXf6Fu8cZdXa+kiRJSl8GTKmG3fPaQioqI74+oAk8fCt0OQk6Hf/J552bN+LFbw9j6pJ1zFm9iTmr2/L06o0sfHcL5ZXb+cqQm/jF1TfCIxfBmMtZPWIcb8xfy3eHtSD2r2sgtzkc5UqxkiRJqnsGTKkGLVq7hYcmLuZLg9rRfs69ibmRJ//kU/sV5GRxUs8WnNSzxSfbSsor+M3YOYx6czEn9RjEief9lejBs/jwgWvJ5Ct8feVPYd1iuPQZyMqttXOSJEmS9sYJWlIN+s3Y2WTFY3xnaD5M/DP0vgBaHVml7zbIiPOD03rQo2Ue3xszjY+aDWJs4Vc5fssLvNniVrKXvQ5n3Q4djqnhs5AkSZKqxoAp1ZCJCz5m3Mw1XHdiV5pNvQ0qy+DzNx/QMRpkxLl9RH82bi/n1Nte5/qVw1mV35/m66fBsTdA/0tqpnhJkiSpGhwiK6VIZWXEvAXz2UI2lZk5/OK5WXRtXMlVhe/Daw8m7klZ2PmAj9u9ZR4/PK0HP/vXLL55YndaHTcGPhwPfb+U+pOQJEmSPoMQRVHKDzpw4MBoypQpKT+udDBatHYLj09ZxrR3J/FgyU1khgpWRE1ZG+XTJ76UWFQOea1g5KuQ12L/B9yDKIpYWryV9oU5hBBSfAaSJElS1YUQpkZRNHBPn9mDKe0miiI+3lJKs0YN9rtv8ZZSzvzj62wvr+QvheOJlcdZ0vt6sjcuokvJR8S6nANdT4a2gyEjq9o1hRDo0NSFfCRJknRwM2BKu/nvp2bw98nLeHTkEAY1KobihXD4F/a476PvLGVLaQVjr+5Dz0degr4X0eHcn9VyxZIkSdLBYb+L/IQQGoYQ3gkhTAshzAwh+Ldn1VujJy1h9KSlxGKBsaNvI7rneHjkwsQKsLspq6jk4YlLOK5rM3qu/heUbYWjR9ZB1ZIkSdLBoSo9mCXA56Mo2hxCyATeCCGMjaLo7RquTapVUxYX89NnZnLy4fn8quFoDpv3CAty+tKlS3sY90OIZcDgq2D+S/D2n1lKa9ZuHM4vz+kJL46EdkOqfAsSSZIkqT7ab8CMEqsAbU6+zUw+Ur8ykFSHijaVcM3f3qVtkxz+1G4CDd98hMltvsaIBcP51bBenFlSRu7Y71H59t3E1i2AnKZ02foSj+e8T7/S62DdYjjpJ3V9GpIkSVKdqtIczBBCHJgKdAXujKJoUo1WpYPKO4uK+de0lQyKz2PY8nvIL5pKyC6A7MLE3MSTb4HYZ7+lakl5BZWVkF1SBI9eDLnN4KzboXHrz34S+3HHyx+yfmspj17Wh4ajL4PuZ9DvotvpffdEvv/UHP6bS7gtcx1d1q1hefefkjvgS/zjgdv5fYP7iD19LeS1hp5n1XidkiRJ0sHsgG5TEkIoAJ4Ero+iaMZun40ERgK0b99+wJIlS1JYplJt9KQltC/M4fhuzfe6T1lFJbe9OI8nJkzmV5n38/nYuxRF+bwYP57zehfSYMsKWPASDLoKTv89VOf2GRtXQdEcptKTG8bMovG2FTza8Dc0rlhHIIJ4Fpz5B+h93mc4231bsX4bJ/5+AucPaMuvW78B//4BXDEe2g1mw7YyXp1XRBRFVEYRz01fzYuz1wDQqEEGk77aiNx/XQPHfisxfFaSJEmq51J2m5IoitaHEF4BTgVm7PbZX4C/QOI+mNWsVbXg8cnLuPnJGTTJKOWZ4Rto9/Fb0PNs6HnmJ/t8vLmEyx+YzMzlxbxceDftyxaxZcjNvN/0Av7n8Tm8V9mG332lL4z/Mbz1R2jQCE7+6af/sJJNkNXoP8JnFEWs3VxKfNEECp6/mtj2dXSKGvGdzOM4If4OldtKuSLzx4w8pT9D3v8hjLkc1syEk/6nRn4ef3r5QwCu/1wHeOhiaH8MtBsMQH52JmcfubMH9Yv92zJ1STF3vDyf47o2I7drZ7jpgxqpS5IkSTrU7DdghhCaA2XJcJkNDAd+W+OVqUa8t3Qd//3UDP632XOcufkfNHyllCijIWH643Dab+HoqwH4/bi5zF61kX/3n0iH2TPg/PvI7XMBw4ErV5Vy96sLOO+otgwZfguUboY3/gBrP4TOJ1Deqj/xlVMJ0/8OK6ZC5xPg1N/CYT34eHMJ3x8znQ4fjuJHGY/wYdSGO8sv4fJmszh3yyuEnEKmnfgIK14t48pn1zP2+qdo9+aP4PX/hYJ2MOCylP48Vs6byr+mLOXio7vRevnzsGEZnHHrPr8zoEMhD1w+OKV1SJIkSfXBfofIhhD6Ag8CcRK3NXk8iqJb9vWdgQMHRlOmTElZkUqNjzZu56w/vUFhfDvPl1zK5pZDuHrpyWS07ccDjf9CbN7zcPx3mNX9G5xx59v8tO8GLp33Deg7Ar541yfH2VZawRdue5XMeIyxNxxPg1iAF39C5fR/ENu8auefl9OVjC6fo2DeGELpZlZ3OJsFS5bQq3IeTcJmlrYczqS+P6f1Yc05tmsz2L4h8cWG+Sxft5XTbnud7i3z+PtVg4g/NgIWvAKX/AO6nlSl842iiIrKiIz4f84PLSmvYEtJBVlznqTRv0ayMcoho/8Icpa/CbE4XPtW9Yb7SpIkSWlgX0NkD2gOZlUZMA9OVz88hdfmrWX86RtoO24kXPYc/yzuyLcfn8ZZfQ7jtkYPEX/vIUpCA2ZEnenfaB2xzGy45nVokPcfx5ow9yMuGzWZE7s3p0PTXErKK3lu+gryS1ZxWcePWRi15dEleVRGUMhGvpvxOBfEX2VlvDUFhx9LQa/h0Pv8fQa5p95bwY1/f5/vndKdbww9DEadBuuWwDHfhA7HQtuBkJm9x+/OXrWR7z36Dj0r5vLToyNyN8yHtoOY3eJMvnLfOzTeuoR/Zd3M/Kg1Gc260nvDBKgohS/eA0eOSOWPXZIkSapXUjYHU4euzSXlvDKniK8M6UDbtfdAVh60Hcx5HbNYu7mEXz0/h6JOF3PD4EHMeut5zi5cRqyiAs6/71PhEuCE7odxxXGdGDN1Oe8uXQ/AoI5N+c4XjuGI1o0BuHFTCa/M/YhtpRWUMZSnMgNn92tLw8x4lWo+p19rXprzEX8YP4+WjRty+oWPkv3UFTDhN0AEGdkw9Btw3E2JOaBAZWXE/W8u4tZ/z+KxzFs4krnwMkSZuYSpo1gUHqNZxtd5tOk9ZJQ0ZNGxdzN86ACo2JgYztular2jkiRJkj7NHsw08dz0VXzjkXf5+1VHc/QzJ0CrI2HE6E8+f/r9FXz3H9Moq4jo3DyXcTcOIzP+2W898llt2FbG+Xe9xfyPNpObFeeUXi05r1ceQ+Nzic98AmaMgbxWcPLPoO9F3PLs7ETAbP0y5xffy7z+N3PppDa0bduB4cWjubL8UcjIJla+FS4ZA92G1/UpSpIkSYeUffVg1n2CUK14YdZqCnOzGNhobWIhm93mMZ7Trw0PXj6Yzs1zueXs3gdFuITEKq7jbhzGI1cdzZl9WzN+9hq+8rc5HP1EFj9v+B22ffXfiftkPjmSosev56G35nNT33LO2/AQHHEOh5/9PX70pROZsmwDd5Sdy5LTRxPLKYQTfmS4lCRJklLMHsz6qGw7rP4A2gyAWIzS8koG/GI8p/Vuye/avAHjfgQ3TIcmHeq60gO2vayCCXOLePr9FYybuZqhXZpy39cGkPnKLcQn/pG3wlEc3aKC+MYV8I1JkNsMgLfmr6VpowZ0b5kHUeQiPpIkSVI1OQcznUQRPHEFzHkWmh0OQ65jcu7JbNpezheOaAlTX0xsPwTDJUDDzDin9m7Jqb1b8sTU5XznH9O4/rFp9G9/KUvLtvKrrFHEVlfAhQ9+Ei4Bjum687XhUpIkSaoZBsx6ZP3WUhY/9Qv6zXuWp2MncwpraPjsjfTKbEG/zG9zXMdh8MSbMOjKui41Jc4f0JbNJeX85JmZjJ+1hpN7XkwYdi4UzYFe59Z1eZIkSVLaMWAeQoo2lTB35XpavvpdWuRnk9f1GGg7GJp14+/vrmLsM49xX+yPvJx5HL/gGn6xHp45t5L4U9fwWMZPafjaUqgoqfJ9JA8Flx7Tka2lFYyetISfndOLUJANnY6v67IkSZKktOQczENAFEVcOmoyr80r4uzYm/wx6042R9k0CtsAqAgZLKhoQZv4euIFbWhwzcvMXw8X3TORCMja+hHjWtxJkw2zErf2+P5iyGxYl6eUclEUERz6KkmSJNU452Ae4ibMK+K1eUVcPrQd31vwb0oyunNt9m0sXziLL+QvI3/zQoY1KSa7WQaxM/8PGuTRrQU89PWjufivb7MpVki4/Hl45UeQ27TehUvAcClJkiQdBAyYh4C7JiygdX5Dbu44j4z3FsAFo3jwiKHc/2ZLbn1hHlcN+zK9hh/+qZDVp20+f796CMuKt1FQ0AS+eFcdnYEkSZKkdGDAPNhUVkLZFmiQB8DUJcW8s6iYH5/Rg4w3bobmPeCIc4nFAlce35nLj+1EPLb33rterfPp1Tq/tqqXJEmSlMZidV2AdhFF8PhX4fYjYcNyAO6asJCCnEwuaTwNimbDsO9BbOd/tn2FS0mSJEmqTQbMg8DYD1Zx1h1vMPXpPyXuX7m1GP45krkr1/Pi7DVcN7ARDV79OTTtBr2+WNflSpIkSdIeGTDr2LLirfzXmOlsXrOQw9/7JdPjvXix+09gyZu8Mer7dMlaxxXzroNNa+Cs2yEWr+uSJUmSJGmPnINZhyoqI779+PtAJWM7PErGmsCvMr/F29Py+HP2MC4ve5xLcl4ivq0UvvoktD+6rkuWJEmSpL0yYCbNXrWRRg0yaFeYU2t/5t2vLmDy4nU8238yDWe/BWffweh+X2Lz9nLy48PgnmE03LYevvYMtO5Xa3VJkiRJUnUYMIFX5xVx5YOTiSK4eHB7rj+pK4fl1ey9It9buo4/jJ/Hf3VeQq/ZtyXmVvb/KvEQyM/JBDLhqpcTq8rmNq3RWiRJkiQpFdI+YE5eXMzVD0+h62F5HNW+gEffWULHd39D3zb59Dr2dHK6HANl22HTStiyFuKZkJkDTTpCXsuq/SHbN0A8CzKzAfho43au+dtUjm68lmvX/orQsjeccyfsdh9Lspuk9mQlSZIkqQalXcCcvWojK9ZtA2BzSTn/8/QMWudn8/AVg2nWqAFXD2pC+3u/DKuAMX/b+4Eyc+DaN6Gw8973qayEt++El26BynJo0omK5j2YtqSca7dn8OWCmYTyBjDiUcjKTe2JSpIkSVItS7uA+fDbS3hk0tJP3rcpyObhK4+mWaMGALTP2gTA8s/dysOzK4iteJdNZLMqKuTjKJ+bPt+Rz7XPgscvhddvTfQ87smG5fDkNbD4deh+BrTsQ+WamaxdNJ2+2zdwYmYpGeXZ8KW/QUG7Gj9vSZIkSappaRcwrzuhCxcPag9Aq7d+TH5mBZkFn9+5w6bVALTt1JMfnngsC4s2s6WkAoAfPzODm97eykvHfI4mAy6DKffBsO8lhsvuaukkeHQEVJSy9dTbeLfwTJ6fuZrn5w1g/dYyrjuhC/91ao9aOFtJkiRJqj1pFzDbNsmh7Y6pjVs+/CRQfmLzmsRzcn5l5+aNPvno1+f14cw/vsGvnp/N70+5EaaOSvRinn3Hzu/Peobon1exNtaU66JbmPxUIfAO2ZlxvtCrBef2b8MJhzevsfOTJEmSpLqSdgHzP1SUwsaVEEU7F9jZETgbtfjU7j1aNubK4ztz96sLOO+othx91KWEqaOYd/jVdGhRSMN37yV6/f/4IBzOldu+zdA+3flhq8Z0b5nHoI6F5DZI7x+3JEmSpPotvRNPRSmUb4Pt63eu2Lp5DWQ1ggaN9viVG07qxnMfrGTkQ1NoWtmfcbFRZD1yHrGwFkIFT1ccw935N3L/lUPo3Sa/9s5FkiRJkupYmgfMssTzxpU7A+am1XvsvdwhOyvOrRf2488T5tO5WTsWF19C5+X/5INmF/Jkxqlkt+rBkycfTnZWvBZOQJIkSZIOHmkeMEsTzxtXQYteideb1+z3/paDOxUyuNPgxJvoduB2jgqBo2quUkmSJEk66MXquoA69UnAXLFz2356MD8lhJ3zNyVJkiQpjaV5wEwOkd20aue2KvRgSpIkSZI+zYAJiTmYACWboXTzgfVgSpIkSZIAA2bieUfA3O0emJIkSZKkqkvzgJmcg7ljiOw+7oEpSZIkSdo3AybsXORnczJg2oMpSZIkSQcsfQNmZQVEFZDRELatg7JtsCk5RNYeTEmSJEk6YOkbMHfMvyxon3jeuDLRgxnPguwmdVeXJEmSJB2i0jhgJofHFnRIPG9alejBbNTC+1pKkiRJUjWkccBM9mA2SQbMHT2YDo+VJEmSpGpJ44C5Ww/mxpWJHkwX+JEkSZKkaknfgFmZ7MHMKYQGjRNDZO3BlCRJkqRqS9+AuWOIbDwL8lpB8aLEarL2YEqSJElStaRxwEwOkY1nQuPWsOr9xHt7MCVJkiSpWgyY8axEwNycvAemPZiSJEmSVC1pHDB3GyK7gz2YkiRJklQt+w2YIYR2IYRXQgizQggzQwg31EZhNW73IbI72IMpSZIkSdWSUYV9yoHvRFH0bgghD5gaQhgfRdGsGq6tZu0+RBYgxCC3ed3VJEmSJEmHsP32YEZRtCqKoneTrzcBs4E2NV1YjdsxRDa2Sw9mbnOIxeuuJkmSJEk6hB3QHMwQQkegPzCpRqqpTZ/MwcyEvGTAdP6lJEmSJFVblQNmCKER8ARwYxRFG/fw+cgQwpQQwpSioqJU1lgzdh0im9M0udiP8y8lSZIkqbqqFDBDCJkkwuXoKIr+uad9oij6SxRFA6MoGti8+SEwj3HXVWRjMWh1JLTsW7c1SZIkSdIhbL+L/IQQAnAfMDuKov+r+ZJqya6ryAJ8/QUIoe7qkSRJkqRDXFV6MI8Fvgp8PoTwfvJxeg3XVfN2HSILiV5MA6YkSZIkVdt+ezCjKHoDqH/Ja9chspIkSZKkz+yAVpGtV3YfIitJkiRJ+kwMmAZMSZIkSUqJNA6YDpGVJEmSpFRK34BZWQYhBrF4XVciSZIkSfVC+gbMilJ7LyVJkiQphdI4YJYZMCVJkiQphdI4YJa6wI8kSZIkpVCaB0x7MCVJkiQpVdI4YJbZgylJkiRJKZTGAdMeTEmSJElKpfQOmDF7MCVJkiQpVdI4YDpEVpIkSZJSKc0DpkNkJUmSJClV0jhgOgdTkiRJklIpjQOmQ2QlSZIkKZXSOGDagylJkiRJqZTGAdM5mJIkSZKUSmkcMEsdIitJkiRJKZTmAdMeTEmSJElKlTQOmC7yI0mSJEmplL4Bs9KAKUmSJEmplL4B0yGykiRJkpRSaRwwXUVWkiRJklIpjQOmq8hKkiRJUiqlZ8CMIofISpIkSVKKpWfArCxPPNuDKUmSJEkpk54Bs6I08WwPpiRJkiSlTHoHzJg9mJIkSZKUKmkaMMsSzw6RlSRJkqSUSfOA6RBZSZIkSUqVNA2YzsGUJEmSpFRL04DpEFlJkiRJSrU0DZj2YEqSJElSqhkwJUmSJEkpkaYB0yGykiRJkpRqaRow7cGUJEmSpFRL84BpD6YkSZIkpUqaBkyHyEqSJElSqqVnwKzcETAdIitJkiRJqZKeAdM5mJIkSZKUcmkaMB0iK0mSJEmplqYB0x5MSZIkSUq1/QbMEML9IYSPQggzaqOgWmHAlCRJkqSUq0oP5gPAqTVcR+1yiKwkSZIkpdx+A2YURa8BxbVQS+3Z0YMZM2BKkiRJUqo4B1OSJEmSlBIpC5ghhJEhhCkhhClFRUWpOmzNcIisJEmSJKVcygJmFEV/iaJoYBRFA5s3b56qw9aMirLE8NgQ6roSSZIkSao30neIrMNjJUmSJCmlqnKbkkeBiUD3EMLyEMIVNV9WDasoc3isJEmSJKVYxv52iKLo4toopFbZgylJkiRJKZemQ2TLDJiSJEmSlGJpGjBLHSIrSZIkSSlmwJQkSZIkpUSaBkyHyEqSJElSqqVnwKx0FVlJkiRJSrX0DJiuIitJkiRJKZemAdMhspIkSZKUamkaMF3kR5IkSZJSLY0Dpj2YkiRJkpRKaRowXeRHkiRJklItTQOmPZiSJEmSlGrpGzBj9mBKkiRJUiqlacB0iKwkSZIkpVoaB0yHyEqSJElSKhkwJUmSJEkpkaYB0/tgSpIkSVKqpXHAtAdTkiRJklIp/QJmZQVEFQZMSZIkSUqx9AuYFWWJZ4fISpIkSVJKpWHALE08GzAlSZIkKaXSMGDu6MF0iKwkSZIkpVIaBkx7MCVJkiSpJqRfwKy0B1OSJEmSakL6BUyHyEqSJElSjUjDgOkQWUmSJEmqCWkcMO3BlCRJkqRUSsOA6RBZSZIkSaoJaRgwHSIrSZIkSTUhfQNmzIApSZIkSamUhgHTIbKSJEmSVBPSOGDagylJkiRJqZSGAdNVZCVJkiSpJqRhwHSIrCRJkiTVhDQMmK4iK0mSJEk1IY0Dpj2YkiRJkpRKaRgwHSIrSZIkSTUhDQPmjh7MjLqtQ5IkSZLqmTQOmPZgSpIkSVIqpWHAdIisJEmSJNWE9AuYlWUQYhCL13UlkiRJklSvpF/ArCi191KSJEmSakAaBswyA6YkSZIk1YAqBcwQwqkhhLkhhPkhhB/UdFE1qqIU4pl1XYUkSZIk1Tv7DZghhDhwJ3AacARwcQjhiJourMbkt4XWR9V1FZIkSZJU71SlB3MwMD+KooVRFJUCjwHn1GxZNei4m+ArY+q6CkmSJEmqd6oSMNsAy3Z5vzy57T+EEEaGEKaEEKYUFRWlqj5JkiRJ0iEiZYv8RFH0lyiKBkZRNLB58+apOqwkSZIk6RBRlYC5Ami3y/u2yW2SJEmSJH2iKgFzMtAthNAphJAFjACeqdmyJEmSJEmHmoz97RBFUXkI4ZvAOCAO3B9F0cwar0ySJEmSdEjZb8AEiKLoeeD5Gq5FkiRJknQIS9kiP5IkSZKk9GbAlCRJkiSlhAFTkiRJkpQSBkxJkiRJUkoYMCVJkiRJKWHAlCRJkiSlhAFTkiRJkpQSBkxJkiRJUkoYMCVJkiRJKWHAlCRJkiSlhAFTkiRJkpQSBkxJkiRJUkqEKIpSf9AQioAlKT9w6jQD1tZ1ETok2XZUXbYdVZdtR9Vl21F12Xa0Px2iKGq+pw9qJGAe7EIIU6IoGljXdejQY9tRddl2VF22HVWXbUfVZdvRZ+EQWUmSJElSShgwJUmSJEkpka4B8y91XYAOWbYdVZdtR9Vl21F12XZUXbYdVVtazsGUJEmSJKVeuvZgSpIkSZJSrN4EzBBCQQhhTAhhTghhdghhaAjhwhDCzBBCZQhh4G77/zCEMD+EMDeEcMou209NbpsfQvhB7Z+JatuBtJ0QQscQwrYQwvvJx927fDYghPBBsu38MYQQ6uaMVFv20nZ+n3w/PYTwZAihYJf9ve4IOLC243VHu9pL2/l5st28H0J4IYTQOrlvSLaL+cnPj9rlOJeGED5MPi6tuzNSbTnAtnNCCGHDLtedH+9yHH9nad+iKKoXD+BB4Mrk6yygAOgJdAcmAAN32fcIYBrQAOgELADiyccCoHPyGNOAI+r63HwcVG2nIzBjL8d5BxgCBGAscFpdn5uPOmk7XwAyktt+C/w2+drrjo/qth2vOz7213Ya7/L5t4C7k69PT7aLkGwnk5LbC4GFyecmyddN6vrcfBxUbecE4Nk9HMPfWT72+6gXPZghhHxgGHAfQBRFpVEUrY+iaHYURXP38JVzgMeiKCqJomgRMB8YnHzMj6JoYRRFpcBjyX1VT1Wj7eztOK1IXKTfjqIoAh4Czq2JmnVw2EfbeSGKovLkbm8DbZOvve4IqFbb2dtxvO6kmX20nY277JYL7Fhg4xzgoSjhbaAg2W5OAcZHUVQcRdE6YDxwaq2diGpdNdrO3vg7S/tVLwImid6AImBUCOG9EMK9IYTcfezfBli2y/vlyW17267660DbDkCn5L6vhhCOT25rQ6K97GDbqf+q0na+TqL3ALzuaKcDbTvgdUcJe207IYRfhhCWAZcAO4Yzet3RDgfadgCGhhCmhRDGhhB6JbfZdrRf9SVgZgBHAXdFUdQf2AI4JlxVcaBtZxXQPrnvt4FHQgiNa75MHYT22XZCCDcD5cDouilPB7EDbTted7TDXttOFEU3R1HUjkS7+WbdlaiD1IG2nXeBDlEUHQncATxV6xXrkFVfAuZyYHkURZOS78eQ+J9ob1YA7XZ53za5bW/bVX8dUNtJDm/8OPl6Kol5CIeTaCe7Dmez7dR/e207IYTLgDOBS5JDF8HrjnY6oLbjdUe7qMrvrNHA+cnXXne0wwG1nSiKNkZRtDn5+nkgM4TQDNuOqqBeBMwoilYDy0II3ZObTgJm7eMrzwAjQggNQgidgG4kFkqYDHQLIXQKIWQBI5L7qp460LYTQmgeQognX3cm0XYWRlG0CtgYQhiSXMXxa8DTNVu96tLe2k4I4VTgv4CzoyjaustXvO4IOPC243VHO+yj7XTbZbdzgDnJ188AX0uuJjsE2JBsN+OAL4QQmoQQmpBYYGpc7ZyF6sKBtp0QQsvkdYUQwmASmeFj/J2lKsio6wJS6HpgdLKxLwQuDyF8kUS3fnPguRDC+1EUnRJF0cwQwuMkgkQ58I0oiioAQgjfJHGRjQP3R1E0sy5ORrWqym2HxAT5W0IIZUAlcE0URcXJ41wHPABkk5g7NRbVd59qOyR++TYAxid/N78dRdE1Xne0myq3Hbzu6D/tqe3cmwwOlcAS4Jrkvs+TWEl2PrA1uS9RFBWHEH5Oos0B3LJLm1L9dSBt5wLg2hBCObANGJEcVVHu7yztT9g5ekuSJEmSpOqrF0NkJUmSJEl1z4ApSZIkSUoJA6YkSZIkKSUMmJIkSZKklDBgSpIkSZJSwoApSZIkSUoJA6YkSZIkKSUMmJIkSZKklPh/A/xzcnTHb0kAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1152x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "q = 1\n",
    "d = 0\n",
    "p = 3\n",
    "\n",
    "y = data.Price[:6100]\n",
    "data.reset_index(inplace = True)\n",
    "x = data.Price[6100:]\n",
    "m = ARIMA(q, d, p)\n",
    "m.fit(y)\n",
    "\n",
    "pred = m.predict(x)\n",
    "\n",
    "plt.figure(figsize=(16, 8))\n",
    "res = pd.DataFrame(data={'Actual': x, 'Prediction': pred})\n",
    "plt.plot(res)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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>Actual</th>\n",
       "      <th>Prediction</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>6102</th>\n",
       "      <td>2.58</td>\n",
       "      <td>0.043323</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6103</th>\n",
       "      <td>2.55</td>\n",
       "      <td>2.553246</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6104</th>\n",
       "      <td>2.52</td>\n",
       "      <td>1.986901</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6105</th>\n",
       "      <td>2.52</td>\n",
       "      <td>2.496404</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6106</th>\n",
       "      <td>2.43</td>\n",
       "      <td>2.522909</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Actual  Prediction\n",
       "6102    2.58    0.043323\n",
       "6103    2.55    2.553246\n",
       "6104    2.52    1.986901\n",
       "6105    2.52    2.496404\n",
       "6106    2.43    2.522909"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def smape(A, F):\n",
    "    return 100/len(A) * np.sum(2 * np.abs(F - A) / (np.abs(A) + np.abs(F)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.203267888287358,\n",
       " <tf.Tensor: shape=(), dtype=float64, numpy=0.14919213549814733>)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(smape(x[3:], pred[3:]), MAE(x[3:], pred[3:]))"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "71f6806d83c72a69b7fd946e78e1222f74dd82b556e49667c928aecd25e7a77c"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}