examples/quick-starts/metrics/BinaryClassificationMetrics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# `metrics.BinaryClassificationMetrics`"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "import slickml\n",
    "\n",
    "print(f\"Loaded SlickML Version = {slickml.__version__}\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Loaded SlickML Version = 0.2.0\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "from slickml.metrics import BinaryClassificationMetrics\n",
    "\n",
    "help(BinaryClassificationMetrics)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Help on class BinaryClassificationMetrics in module slickml.metrics._classification:\n",
      "\n",
      "class BinaryClassificationMetrics(builtins.object)\n",
      " |  BinaryClassificationMetrics(y_true: Union[List[int], numpy.ndarray, pandas.core.series.Series], y_pred_proba: Union[List[float], numpy.ndarray, pandas.core.series.Series], threshold: Optional[float] = 0.5, average_method: Optional[str] = 'binary', precision_digits: Optional[int] = 3, display_df: Optional[bool] = True) -> None\n",
      " |  \n",
      " |  BinaryClassificationMetrics calculates binary classification metrics in one place.\n",
      " |  \n",
      " |  Binary metrics are computed based on three methods for calculating the thresholds to binarize\n",
      " |  the prediction probabilities. Threshold computations including:\n",
      " |      1) Youden Index [youden-j-index]_.\n",
      " |      2) Maximizing Precision-Recall.\n",
      " |      3) Maximizing Sensitivity-Specificity.\n",
      " |  \n",
      " |  Parameters\n",
      " |  ----------\n",
      " |  y_true : Union[List[int], np.ndarray, pd.Series]\n",
      " |      List of ground truth values such as [0, 1] for binary problems\n",
      " |  \n",
      " |  y_pred_proba : Union[List[float], np.ndarray, pd.Series]\n",
      " |      List of predicted probabilities for the positive class (class=1) in binary problems\n",
      " |      or ``y_pred_proba[:, 1]`` in scikit-learn API\n",
      " |  \n",
      " |  threshold : float, optional\n",
      " |      Inclusive threshold value to binarize ``y_pred_prob`` to ``y_pred`` where any value that\n",
      " |      satisfies ``y_pred_prob >= threshold`` will set to ``class=1 (positive class)``. Note that\n",
      " |      for ``\">=\"`` is used instead of ``\">\"``, by default 0.5\n",
      " |  \n",
      " |  average_method : str, optional\n",
      " |      Method to calculate the average of any metric. Possible values are ``\"micro\"``, ``\"macro\"``,\n",
      " |      ``\"weighted\"``, ``\"binary\"``, by default \"binary\"\n",
      " |  \n",
      " |  precision_digits : int, optional\n",
      " |      The number of precision digits to format the scores dataframe, by default 3\n",
      " |  \n",
      " |  display_df : bool, optional\n",
      " |      Whether to display the formatted scores' dataframe, by default True\n",
      " |  \n",
      " |  Methods\n",
      " |  -------\n",
      " |  plot(figsize=(12, 12), save_path=None, display_plot=False, return_fig=False)\n",
      " |      Plots classification metrics\n",
      " |  \n",
      " |  get_metrics(dtype=\"dataframe\")\n",
      " |      Returns calculated classification metrics\n",
      " |  \n",
      " |  Attributes\n",
      " |  ----------\n",
      " |  y_pred_ : np.ndarray\n",
      " |      Predicted class based on the ``threshold``. The threshold value inclusively binarizes\n",
      " |      ``y_pred_prob`` to ``y_pred`` where any value that satisfies ``y_pred_prob >= threshold``\n",
      " |      will set to ``class=1 (positive class)``. Note that for ``\">=\"`` is used instead of ``\">\"``\n",
      " |  \n",
      " |  accuracy_ : float\n",
      " |      Accuracy based on the initial ``threshold`` value with a possible value between 0.0 and 1.0\n",
      " |  \n",
      " |  balanced_accuracy_ : float\n",
      " |      Balanced accuracy based on the initial ``threshold`` value considering the prevalence of the\n",
      " |      classes with a possible value between 0.0 and 1.0\n",
      " |  \n",
      " |  fpr_list_ : np.ndarray\n",
      " |      List of calculated false-positive-rates based on ``roc_thresholds_``\n",
      " |  \n",
      " |  tpr_list_ : np.ndarray\n",
      " |      List of calculated true-positive-rates based on ``roc_thresholds_``\n",
      " |  \n",
      " |  roc_thresholds_ : np.ndarray\n",
      " |      List of thresholds value to calculate ``fpr_list_`` and ``tpr_list_``\n",
      " |  \n",
      " |  auc_roc_ : float\n",
      " |      Area under ROC curve with a possible value between 0.0 and 1.0\n",
      " |  \n",
      " |  precision_list_ : np.ndarray\n",
      " |      List of calculated precision based on ``pr_thresholds_``\n",
      " |  \n",
      " |  recall_list_ : np.ndarray\n",
      " |      List of calculated recall based on ``pr_thresholds_``\n",
      " |  \n",
      " |  pr_thresholds_ : numpy.ndarray\n",
      " |      List of precision-recall thresholds value to calculate ``precision_list_`` and ``recall_list_``\n",
      " |  \n",
      " |  auc_pr_ : float\n",
      " |      Area under Precision-Recall curve with a possible value between 0.0 and 1.0\n",
      " |  \n",
      " |  precision_ : float\n",
      " |      Precision based on the ``threshold`` value with a possible value between 0.0 and 1.0\n",
      " |  \n",
      " |  recall_ : float\n",
      " |      Recall based on the ``threshold`` value with a possible value between 0.0 and 1.0\n",
      " |  \n",
      " |  f1_ : float\n",
      " |      F1-score based on the ``threshold`` value (beta=1.0) with a possible value between 0.0 and 1.0\n",
      " |  \n",
      " |  f2_ : float\n",
      " |      F2-score based on the ``threshold`` value (beta=2.0) with a possible value between 0.0 and 1.0\n",
      " |  \n",
      " |  f05_ : float\n",
      " |      F(1/2)-score based on the ``threshold`` value (beta=0.5) with a possible value between 0.0 and\n",
      " |      1.0\n",
      " |  \n",
      " |  average_precision_ : float\n",
      " |      Avearge precision based on the ``threshold`` value and class prevalence with a possible value\n",
      " |      between 0.0 and 1.0\n",
      " |  \n",
      " |  tn_ : np.int64\n",
      " |      True negative counts based on the ``threshold`` value\n",
      " |  \n",
      " |  fp_ : np.int64\n",
      " |      False positive counts based on the ``threshold`` valuee\n",
      " |  \n",
      " |  fn_ : np.int64\n",
      " |      False negative counts based on the ``threshold`` value\n",
      " |  \n",
      " |  tp_ : np.int64\n",
      " |      True positive counts based on the ``threshold`` value\n",
      " |  \n",
      " |  threat_score_ : float\n",
      " |      Threat score based on the ``threshold`` value with a possible value between 0.0 and 1.0\n",
      " |  \n",
      " |  youden_index_ : np.int64\n",
      " |      Index of the calculated Youden index threshold\n",
      " |  \n",
      " |  youden_threshold_ : float\n",
      " |      Threshold calculated based on Youden Index with a possible value between 0.0 and 1.0\n",
      " |  \n",
      " |  sens_spec_threshold_ : float\n",
      " |      Threshold calculated based on maximized sensitivity-specificity with a possible value\n",
      " |      between 0.0 and 1.0\n",
      " |  \n",
      " |  prec_rec_threshold_ : float\n",
      " |      Threshold calculated based on maximized precision-recall with a possible value between 0.0\n",
      " |      and 1.0\n",
      " |  \n",
      " |  thresholds_dict_ : Dict[str, float]\n",
      " |      Calculated thresholds based on different algorithms including Youden Index\n",
      " |      ``youden_threshold_``, maximizing the area under sensitivity-specificity curve\n",
      " |      ``sens_spec_threshold_``, and maximizing the area under precision-recall curver\n",
      " |      ``prec_rec_threshold_``\n",
      " |  \n",
      " |  metrics_dict_ : Dict[str, float]\n",
      " |      Rounded metrics based on the number of precision digits\n",
      " |  \n",
      " |  metrics_df_ : pd.DataFrame\n",
      " |      Pandas DataFrame of all calculated metrics with ``threshold`` set as index\n",
      " |  \n",
      " |  average_methods_: List[str]\n",
      " |      List of all possible average methods\n",
      " |  \n",
      " |  plotting_dict_: Dict[str, Any]\n",
      " |      Plotting properties\n",
      " |  \n",
      " |  References\n",
      " |  ----------\n",
      " |  .. [youden-j-index] https://en.wikipedia.org/wiki/Youden%27s_J_statistic\n",
      " |  \n",
      " |  Examples\n",
      " |  --------\n",
      " |  >>> from slickml.metrics import BinaryClassificationMetrics\n",
      " |  >>> cm = BinaryClassificationMetrics(\n",
      " |  ...     y_true=[1, 1, 0, 0],\n",
      " |  ...     y_pred_proba=[0.95, 0.3, 0.1, 0.9]\n",
      " |  ... )\n",
      " |  >>> f = cm.plot()\n",
      " |  >>> m = cm.get_metrics()\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |  \n",
      " |  __init__(self, y_true: Union[List[int], numpy.ndarray, pandas.core.series.Series], y_pred_proba: Union[List[float], numpy.ndarray, pandas.core.series.Series], threshold: Optional[float] = 0.5, average_method: Optional[str] = 'binary', precision_digits: Optional[int] = 3, display_df: Optional[bool] = True) -> None\n",
      " |  \n",
      " |  __post_init__(self) -> None\n",
      " |      Post instantiation validations and assignments.\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |  \n",
      " |  get_metrics(self, dtype: Optional[str] = 'dataframe') -> Union[pandas.core.frame.DataFrame, Dict[str, Optional[float]]]\n",
      " |      Returns calculated metrics with desired dtypes.\n",
      " |      \n",
      " |      Currently, available output types are \"dataframe\" and \"dict\".\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      dtype : str, optional\n",
      " |          Results dtype, by default \"dataframe\"\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Union[pd.DataFrame, Dict[str, Optional[float]]]\n",
      " |  \n",
      " |  plot(self, figsize: Optional[Tuple[float, float]] = (12, 12), save_path: Optional[str] = None, display_plot: Optional[bool] = False, return_fig: Optional[bool] = False) -> Optional[matplotlib.figure.Figure]\n",
      " |      Plots classification metrics.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      figsize : Tuple[float, float], optional\n",
      " |          Figure size, by default (12, 12)\n",
      " |      \n",
      " |      save_path : str, optional\n",
      " |          The full or relative path to save the plot including the image format such as\n",
      " |          \"myplot.png\" or \"../../myplot.pdf\", by default None\n",
      " |      \n",
      " |      display_plot : bool, optional\n",
      " |          Whether to show the plot, by default False\n",
      " |      \n",
      " |      return_fig : bool, optional\n",
      " |          Whether to return figure object, by default False\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Figure\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __annotations__ = {'average_method': typing.Optional[str], 'display_df...\n",
      " |  \n",
      " |  __dataclass_fields__ = {'average_method': Field(name='average_method',...\n",
      " |  \n",
      " |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...\n",
      " |  \n",
      " |  __hash__ = None\n",
      " |  \n",
      " |  average_method = 'binary'\n",
      " |  \n",
      " |  display_df = True\n",
      " |  \n",
      " |  precision_digits = 3\n",
      " |  \n",
      " |  threshold = 0.5\n",
      "\n"
     ]
    },
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "/Users/atahmassebi/Desktop/AmirStuff/GitHub/slick-ml/.venv/lib/python3.9/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Example 1: `BinaryClassificationMetrics` for `breast-cancer` data set and a RandomForest model"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "data = load_breast_cancer()\n",
    "\n",
    "X, y = data.data, data.target\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X,\n",
    "    y,\n",
    "    test_size=0.3,\n",
    "    shuffle=True,\n",
    "    stratify=y,\n",
    ")\n",
    "clf = RandomForestClassifier()\n",
    "clf.fit(X_train, y_train)\n",
    "y_pred_proba = clf.predict_proba(X_test)[:, 1]"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "bcm = BinaryClassificationMetrics(y_test, y_pred_proba)"
   ],
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "#T_c9ed9 th {\n",
       "  font-size: 12px;\n",
       "  text-align: left;\n",
       "  font-weight: bold;\n",
       "}\n",
       "#T_c9ed9 td {\n",
       "  font-size: 12px;\n",
       "  text-align: center;\n",
       "}\n",
       "#T_c9ed9_row0_col0, #T_c9ed9_row0_col1, #T_c9ed9_row0_col2, #T_c9ed9_row0_col3, #T_c9ed9_row0_col4, #T_c9ed9_row0_col5, #T_c9ed9_row0_col6, #T_c9ed9_row0_col7, #T_c9ed9_row0_col8, #T_c9ed9_row0_col9, #T_c9ed9_row0_col10, #T_c9ed9_row0_col11, #T_c9ed9_row0_col12, #T_c9ed9_row0_col13, #T_c9ed9_row0_col14 {\n",
       "  background-color: #f0f0f3;\n",
       "  color: #000000;\n",
       "}\n",
       "</style>\n",
       "<table id=\"T_c9ed9\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_c9ed9_level0_col0\" class=\"col_heading level0 col0\" >Accuracy</th>\n",
       "      <th id=\"T_c9ed9_level0_col1\" class=\"col_heading level0 col1\" >Balanced Accuracy</th>\n",
       "      <th id=\"T_c9ed9_level0_col2\" class=\"col_heading level0 col2\" >ROC AUC</th>\n",
       "      <th id=\"T_c9ed9_level0_col3\" class=\"col_heading level0 col3\" >PR AUC</th>\n",
       "      <th id=\"T_c9ed9_level0_col4\" class=\"col_heading level0 col4\" >Precision</th>\n",
       "      <th id=\"T_c9ed9_level0_col5\" class=\"col_heading level0 col5\" >Recall</th>\n",
       "      <th id=\"T_c9ed9_level0_col6\" class=\"col_heading level0 col6\" >Average Precision</th>\n",
       "      <th id=\"T_c9ed9_level0_col7\" class=\"col_heading level0 col7\" >F-1 Score</th>\n",
       "      <th id=\"T_c9ed9_level0_col8\" class=\"col_heading level0 col8\" >F-2 Score</th>\n",
       "      <th id=\"T_c9ed9_level0_col9\" class=\"col_heading level0 col9\" >F-0.50 Score</th>\n",
       "      <th id=\"T_c9ed9_level0_col10\" class=\"col_heading level0 col10\" >Threat Score</th>\n",
       "      <th id=\"T_c9ed9_level0_col11\" class=\"col_heading level0 col11\" >TP</th>\n",
       "      <th id=\"T_c9ed9_level0_col12\" class=\"col_heading level0 col12\" >TN</th>\n",
       "      <th id=\"T_c9ed9_level0_col13\" class=\"col_heading level0 col13\" >FP</th>\n",
       "      <th id=\"T_c9ed9_level0_col14\" class=\"col_heading level0 col14\" >FN</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_c9ed9_level0_row0\" class=\"row_heading level0 row0\" >Threshold = 0.500 | Average =\n",
       "                Binary</th>\n",
       "      <td id=\"T_c9ed9_row0_col0\" class=\"data row0 col0\" >0.959000</td>\n",
       "      <td id=\"T_c9ed9_row0_col1\" class=\"data row0 col1\" >0.955000</td>\n",
       "      <td id=\"T_c9ed9_row0_col2\" class=\"data row0 col2\" >0.987000</td>\n",
       "      <td id=\"T_c9ed9_row0_col3\" class=\"data row0 col3\" >0.991000</td>\n",
       "      <td id=\"T_c9ed9_row0_col4\" class=\"data row0 col4\" >0.963000</td>\n",
       "      <td id=\"T_c9ed9_row0_col5\" class=\"data row0 col5\" >0.972000</td>\n",
       "      <td id=\"T_c9ed9_row0_col6\" class=\"data row0 col6\" >0.990000</td>\n",
       "      <td id=\"T_c9ed9_row0_col7\" class=\"data row0 col7\" >0.967000</td>\n",
       "      <td id=\"T_c9ed9_row0_col8\" class=\"data row0 col8\" >0.970000</td>\n",
       "      <td id=\"T_c9ed9_row0_col9\" class=\"data row0 col9\" >0.965000</td>\n",
       "      <td id=\"T_c9ed9_row0_col10\" class=\"data row0 col10\" >0.937000</td>\n",
       "      <td id=\"T_c9ed9_row0_col11\" class=\"data row0 col11\" >104</td>\n",
       "      <td id=\"T_c9ed9_row0_col12\" class=\"data row0 col12\" >60</td>\n",
       "      <td id=\"T_c9ed9_row0_col13\" class=\"data row0 col13\" >4</td>\n",
       "      <td id=\"T_c9ed9_row0_col14\" class=\"data row0 col14\" >3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x1119b8fd0>"
      ]
     },
     "metadata": {}
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "bcm.plot()"
   ],
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABH0AAAPwCAYAAACsnwI8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3xN9xvA8c+9Nzc7EXvEiBl7byUERa2SVhWh1N6qVlV18KsWbW1Vo0ZiU7VrU7v23iu2RCI7d/3+uHK5khAkOTfxvF+v++o537Oee5uXc+9zvt/nqzKZTCaEEEIIIYQQQgghRIaiVjoAIYQQQgghhBBCCJHyJOkjhBBCCCGEEEIIkQFJ0kcIIYQQQgghhBAiA5KkjxBCCCGEEEIIIUQGJEkfIYQQQgghhBBCiAxIkj5CCCGEEEIIIYQQGZAkfYQQQgghhBBCCCEyIEn6CCGEEEIIIYQQQmRAkvQRQgghhBBCCCGEyIDslA5ACJE0f39/Dh06ZNWmUqlwdnbGy8uLTp060bJlywTHbd++ncDAQE6dOkV0dDS5c+embt26fPbZZ+TOnTvRa23evJlly5Zx7tw5oqKiyJs3Lx988AEdO3bE1dX1lbE+efKEBQsWsHnzZoKCgnB0dKRYsWJ06tQJX1/fN/sAhBBCpFuJ3cO0Wi3ZsmWjXr16DBw4kEyZMr31de7du8fgwYM5efIkrq6ubN++HScnp7c+b0rx9vamb9++9OvXL8l9oqKimDNnDhs3biQoKAitVkvRokXx8/Pjo48+QqVSpWHEts/X15fbt2+/dJ/4zzw5n39qGj58OIcOHWL79u1vdZ6DBw/SsWNHFixYQLVq1ZLcT+n3K4SwPZL0EcLGlSxZktGjR1vWDQYD9+7d488//2To0KF4eHjg4+Nj2f7dd98RGBhI06ZN+eGHH3B3d+fy5cssXLiQ1atXM3nyZKpXr27Z32g0MmTIEDZt2oSfnx+ffvopLi4uHD9+nDlz5rB161b+/PNP3N3dk4zxypUrdOvWDaPRSMeOHSlevDhRUVGsXbuWXr16MWDAAHr37p06H5AQQgib9eI9TKfTcebMGX755RfOnTvH4sWL3zqhMX/+fI4fP8748ePJmTOnTSV8ksNkMtGzZ0+uXr1K9+7dKVq0KLGxsfz777+MGjWKS5cu8dVXXykdpk2ZOnUqcXFxlvW+fftSsmRJq+8auXLlUiI0IYSwOZL0EcLGubq6Ur58+QTtderUoUaNGqxatcqS9AkICCAwMJBx48bRqlUry77Vq1fnww8/pFu3bgwcOJB169aRLVs2AGbPns26deuYOnUqDRs2tBxTo0YNqlatSvv27Zk2bRojRoxIND6dTsfAgQPRarUEBgaSNWtWy7YGDRowatQoJk2ahK+vL8WLF0+Jj0QIIUQ6kdg9rEqVKkRGRjJ58mROnDiR6D3udYSGhpIjRw4++OCDtzqPUo4cOcLBgweZO3cutWrVsrTXrVsXtVrNokWL6NatG9mzZ1cwSttSsmRJq3V7e3uyZMny1n9LQgiREUlNHyHSKQcHB+zt7S1PSA0GAzNmzOC9996zSvjEc3V1ZcyYMTx+/JiAgADAnLCZO3cuderUsUr4xKtUqRL9+/enSJEiScaxa9cuLl68yIABA6wSPvH69+9Phw4d0Ov1gLmb84vDvYKCgvD29mbVqlWAuQuzt7c3S5YsoV69elSsWJHVq1fj7e3NxYsXrY7dunUr3t7enD17FjB/+f/mm2+oWbMmZcqUoU2bNuzfvz/J+IUQQqS90qVLA3Dnzh3APBTsyy+/pH///pQvX57OnTsDEBsby88//4yPjw+lS5emefPmbNiwwXIeX19fVq1axZ07d/D29mbKlClA8u4F3t7eTJ06ldatW1O2bFmmTp3KqlWrKFmyJMuXL6dWrVpUrVqVy5cvA+b7TevWrSlTpgy1atVizJgxREVFWZ3z0KFDfPLJJ5QrV45GjRqxb9++V34WDx8+BMw9b1/Url07Bg0aZNUb6urVq/Tt25eqVatSpUoVevTowZUrVyzbw8PD+fHHH2nQoAFlypShWbNmrFixwuq8vr6+/O9//6NTp06ULVuWkSNHJvtz27t3L23atKFChQpUqVKFXr16WV3/RY0aNaJ///4J2lu2bEmvXr0AuHnzJj179qRatWqUK1eOTz75hF27dr3qo0u2iIgIRo4cSdWqValQoQL9+/fn0aNHlu1v+vcHcPr0aTp16kSlSpWoUKECn332GcePH08Qw6pVq2jUqBFlypShRYsWCd7f9evX6d+/P7Vq1aJ8+fL4+/tz5MiRl76v5Py9rVu3jhYtWlC2bFmqV6/Ol19+yf3795P70QkhMgBJ+ghh40wmE3q93vKKjY3l6tWrjBgxgsjISEtNn3PnzvHw4cOX1s8pXLgwxYsXZ9u2bQCcOXOGx48fU69evSSP6d27Nx9//HGS23fv3o1Go7EaYva87NmzM2rUKMsX/NcxdepUhg0bxjfffEOjRo1wdnZm/fr1VvusW7eOokWLUrJkSWJjY+nUqRPbtm1j0KBBTJ06lVy5ctG1a1dJ/AghhA25du0aAPny5bO0bdy4ERcXF2bMmEHXrl0xmUz06dOHJUuW0LlzZ2bMmEGFChUYNGgQf/31F2C+T/j4+JA9e3aWLl3Kxx9//Fr3gpkzZ9K8eXMmT55Mo0aNAPNDlLlz5zJ27FhGjBhB4cKFWbt2LX369KFQoUJMmzaNvn378vfff9O7d29MJhNgvqd26dIFNzc3Jk+eTMeOHfniiy9e+VlUrVoVZ2dnvvjiC8aPH8/BgweJiYkBwMvLi27dull6596/f59PPvmE69ev8+233zJ+/HgePXpEp06dCA0NJSYmhnbt2rF27Vq6du3K9OnTqVSpEiNHjmTmzJlW1w0ICKBMmTJMnz6djz76KFmf261bt+jduzelS5dmxowZjB07lmvXrtG9e/dEk1aAJcERERFhabty5Qrnz5+nZcuWGI1GevToQXR0ND///DPTp0/Hw8ODXr16cePGjVd+fsmxYMECdDodkyZNYvDgwWzfvp3vv//eap83+fuLiIiga9euZM6cmSlTpvDrr78SHR3N559/Tnh4uOXcd+/eZdasWQwYMIApU6agUqno378/wcHBAFy+fJnWrVsTFBTE119/zYQJE1CpVHTq1ClBXax4yfl7O3LkCEOHDuX999/njz/+YMSIERw4cIDBgwenyOcqhEgfZHiXEDbu8OHDlCpVyqpNpVJRrFgxJk2aZEnYBAUFAZA3b96Xnq9AgQLs3bsXMH8JSc4xL3Pv3j0yZ86Mi4vLG58jKe3ataNx48aW9UaNGrFhwwYGDRoEQGRkJDt27KBPnz4ArFmzhvPnz7Ns2TLKlSsHmIfB+fv7M2HCBFauXJniMQohhEha/IOLeGFhYRw6dMjyA/r5BwJarZbvvvsOe3t7wNyjZM+ePfz666+WoVu1a9cmOjqaCRMm0KxZM0qWLEmWLFmwt7e3DO1ZtmxZsu8FlStXtvTqADh16hQAPXv2pG7dupb3MGHCBGrXrs2ECRMs+3p5efHZZ5+xa9cu6taty++//07WrFmZMWMGWq0WgMyZM1vuWUnJmjUrf/zxB8OHD2f27NnMnj0brVZL+fLladGiBX5+fmg0GgD+/PNP4uLimDdvnmW4V/Hixfn00085ceIEt2/f5uLFiyxZsoQKFSpYPjO9Xs/06dNp27YtHh4eAOTJk4cvv/zSEkdyPreTJ08SExNDjx49yJkzJ2CunbNt2zaioqISnfihRYsWTJkyha1bt/Lhhx8C5gc27u7u+Pr6EhwczNWrV+ndu7flAVJ8z6vn6/a8jTJlyvDzzz8D5uHrJ06cSNDT5k3+/i5fvszjx4/p2LEjFStWBKBQoUIsXbqUyMhI3NzcAHMvrmnTplG4cGHA3Fs7vkdQ/fr1mTp1Kvb29ixYsMDyGdatW5dmzZrx888/J+ipBSTr7+3IkSM4OjrSvXt3y/vy8PDg1KlTmEwmKRAuxDtCevoIYeNKlSrFihUrWLFiBdOnT6dYsWJ4eXnx22+/WSVE4p802tm9PJer0WgS7JvU07nk0Gg0GAyGNz7+ZUqUKGG13rJlS27evMnJkycB2LZtG3FxcbRo0QKA/fv3kz17dkqVKmXpGWUwGKhXrx6nT58mLCwsVeIUQgiRuPgHF/GvmjVr8sUXX1C6dGkmTpxo9aOzUKFClh+mYP43XaVS4ePjY9Xj1dfXl4cPH3Lp0qVEr/k694IX7zOJtV+9epV79+7h6+trFUeVKlVwdXW1PEg5cuQItWvXtvwAB3j//fctCZuXqVy5Mv/88w+LFi2iZ8+elClThuPHjzNq1Cj8/f0tPX+OHDlC+fLlrer75MqVix07duDj48OhQ4fw9PS0JHzitWjRgtjYWE6cOJHke0/O51auXDkcHBz46KOPGDt2LHv27KF48eIMGjQoyZk+8+XLR8WKFa2GRa1fv57GjRtjb29PtmzZKFKkCKNGjWLYsGGsXbsWo9HIiBEjKFq06Cs/u+SoVKmS1XrevHl58uSJVdub/P0VLVqULFmy0LNnT7755hu2bNlCtmzZGDJkiFUh6cyZM1sSPvHXByy9gQ4dOkS9evWsPkM7OzuaNm3K6dOniYyMTPCekvP3VqVKFaKjo2nWrBkTJ07kv//+47333qNv376S8BHiHSI9fYSwcS4uLpQpU8ayXq5cOVq0aEGXLl1YtWoVWbJkAcDT0xPglVOY3rp1y7Jvnjx5XnlMSEgIrq6uVl+Enufp6cnOnTuJjIxMsrfPvXv33mgWDWdnZ6v1atWqkTNnTtavX0/ZsmVZv349VatWtZw7NDSUhw8fJugZFe/hw4cpMj2wEEKI5ClVqhTfffcdYO6l6uDgQO7cuRNNELx4DwkNDcVkMll6ULzowYMHiSZtXude8OJ9Jt7z7aGhoYB5dsz49/JiHGDuxZQ5c2arbXZ2dgnakqJWq6lSpQpVqlSxnO/XX39l8eLFrFixgg4dOhAaGvrS3rlhYWGJFnyOHx72fKLjxfeenM+tSJEiLFq0iFmzZrFixQoWLFiAu7s77dq1Y+DAgUkmElq2bMkPP/zA48ePCQoK4saNG/zvf/8DzH8Xc+fOZcaMGWzZsoW//voLrVZLgwYN+O6771Lkvv3ie1Wr1ZYHYPHe9O8vICCAGTNmsHHjRpYuXYqjoyMtW7bk66+/tnx3evH68Z9T/EO3sLAwy/+j52XLlg2TyWQ1NC5ecv7eKlSowKxZs/jzzz+ZN28es2bNIlu2bPTs2RN/f/9E35cQIuORpI8Q6Uy2bNn45ptvGDBgAGPHjmXixImAuShmjhw52LRpE23atEn02Fu3bnH27Fm6desGmJ/yZcuWjd27d9O+fftEj/n66685fvw4O3fuTDTx895777Fw4UL27Nlj1fMoXkhICPXr16ddu3aMHDkSlUqVoGfQi4Uwk6JWq2nevDnr1q2jZ8+e7N2712pMvpubG15eXlbd75/3NsPYhBBCvL4XH1y8Djc3N5ydnVmwYEGi2wsUKJDkcSl5L3B3dwdg6NChVK1aNcH2+KSEh4eHVXFgMPfCfVUv04EDBxIaGsqff/6Z4LzffPMNGzZssBSTdnNzIyQkJME59u/fT968ecmUKVOidXDii0W/LAGV3M/t+aFXR44cYenSpcycOZPixYvTpEmTRI9t0qQJY8aMYevWrVy9ehVPT0+r3jc5c+bk22+/ZfTo0Zw/f55Nmzbxxx9/kDlzZkaPHp1kzKkpuX9/hQoVYvz48RgMBk6ePMmaNWtYvHgx+fPnp2vXrsm6VqZMmRL87YD1/7fr169bbUvu31vt2rUtw9IOHDjAggULGDNmDOXKlaNs2bLJik8Ikb7J8C4h0qHGjRtTu3Zt1q1bZynwp1ar6du3L3v37mXx4sUJjomJieGrr77Czc2Ndu3aWY757LPP2LlzJ9u3b09wzIEDB9i1a5elC3Zi3nvvPYoVK8avv/7K48ePE2yfOHEier2e5s2bA+YfAI8fPyY2Ntayz6tmp3hey5YtuXfvHtOmTUOj0fD+++9btlWtWpW7d++SNWtWypQpY3nt3buX2bNnJ6uLvRBCCNtQtWpVoqKiMJlMVv+mX7x4kWnTplnVCnrxuJS8FxQqVIisWbMSFBRkdb6cOXMyceJEy+yRNWrUYPfu3URHR1uO3bNnDzqd7qXnL1CgAAcOHEh0xqcHDx4QFRVFsWLFAPMwsBMnTlglfoKDg+natSu7du2iSpUq3L59m2PHjlmd5++//0ar1b70R35yPrc///yTevXqERcXh729PTVq1OCHH34Ans3Elhh3d3fq1avHtm3b2Lx5My1atLD0djl27Bg1a9bk5MmTqFQqSpQowaBBgyhWrNhLz5nakvP3t2nTJqpXr87Dhw/RaDRUqFCBb7/9Fnd399eKvUqVKuzYscOqR4/BYGD9+vWUKVMm0e9gyfl7++mnn/Dz88NkMuHk5ES9evUYNmwY8PL/X0KIjEV6+giRTn311Ve0aNGCMWPGsHr1ajQaDZ988glXrlzh22+/5fDhw3zwwQdkypSJq1evMn/+fB4+fMhvv/1mKb4I8Nlnn3H48GH69etHmzZt8PHxQa1Wc/jwYRYuXEiJEiVeOsuDnZ0dP//8M126dMHPz4+OHTtSvHhxQkJCWLVqFXv27GHw4MGWL5r16tVj4cKFjBw5ko8++oiLFy8yb968ZH8JL1asGCVKlCAwMJAmTZpYDRFo3bo1ixYtonPnzvTs2ZPcuXOzb98+/vjjDzp06GA17l0IIYRt8/HxoUqVKvTu3ZvevXtTuHBhTp48yeTJk6ldu7ZlePOLUvpeoNFoGDRoEN988w0ajYZ69erx5MkTpk+fzv379y3Dofr06cPWrVv5/PPP6dq1KyEhIfz222+vvF6XLl3YunUrnTt3pl27dlSrVg0nJycuXrzI3LlzKVq0KK1btwbM9+y//vqLrl270qNHD7RaLTNmzCBXrlw0b94ce3t7AgMD6dOnD/379ydv3rxs376dlStX0rdvX0uvpTf93KpXr86ECRPo06cPHTp0QKPRsGTJEuzt7V86EyiY6wr1798fg8FgmXkUoGTJkjg6OjJ06FD69etHtmzZ2LdvH+fOnaNjx47J/d+U4pLz91exYkWMRiN9+vShe/fuuLi4sHHjRsLDw60eSr1K37592b17Nx07dqR79+5otVoWLVrErVu3mD17dqLHJOfvrXr16sybN4/hw4fTokULdDods2fPxsPDg+rVq7/1ZySESB8k6SNEOlWoUCH8/f2ZO3cuixcvpkOHDoA5GVS7dm0CAgL49ttvefLkCblz56Zu3bp06tTJUscnnlarZfr06SxdupQ1a9awYcMG4uLiyJcvH71796ZDhw5J1jyIV6JECVasWMG8efNYvHgx9+/fx9nZGW9vb2bPnk3t2rUt+9aqVYthw4axcOFCNm/eTKlSpZg6dSpt27ZN9ntv2bIl48aNsxRwjufs7ExAQAATJ05k/PjxhIeH4+npyeDBg+nSpUuyzy+EEEJ5arWaWbNmMWnSJH7//XeCg4PJmTMnnTt3tszamJjUuBd8/PHHuLi4MHv2bJYuXYqzszMVK1ZkwoQJlmnnvby8WLRoEePGjWPQoEFkzZqVYcOGMW7cuJeeO1OmTCxdupQ//viD7du3s3jxYnQ6HZ6enjRr1ozu3bvj6OgIQO7cuQkMDGT8+PEMHz4ce3t7qlWrxq+//moZZrZw4UImTpzIpEmTiIiIoFChQowdO5aPPvropXEk53MrXrw4M2fOZNq0aXzxxRcYDAZKly7N3LlzKVSo0EvP7+Pjg5ubG/ny5aNgwYKWdgcHB+bOncvEiRMZO3YsT548wcvLi++//96S7FJCcv7+cuTIwezZs5k0aRIjR44kOjqaokWLMmXKlNdKqhQtWpTAwEB++eUXRowYgUqlomzZsixYsIDKlSsnekxy/t58fHyYMGECc+fOtRRvrlSpEgsWLLDM4iaEyPhUphermAkhhBBCCCGEEEKIdE9q+gghhBBCCCGEEEJkQJL0EUIIIYQQQgghhMiAJOkjhBBCCCGEEEIIkQFJ0kcIIYQQQgghhBAiA5KkjxBCCCGEEEIIIUQGZDNJn3v37lG5cmUOHjz4yn3XrVtH06ZNKVu2LE2aNGH16tVpEKEQQggh3pbc74UQQggh0o6d0gEA3L17l88//5zw8PBX7rt582a+/PJLOnbsSO3atdm6dSvDhw/H3t6epk2bJut65cqVIy4uDrVaTdasWd82fCGEEOKtBQcHYzQasbe358SJE0qHkyrkfi+EEOJd9i7c64XtUTTpYzQa+euvv/jpp5+Sfcwvv/xC48aN+eqrrwCoXbs2YWFhTJo0KdlfAuPi4jAajRiNRu7fv/9GsQshhBCpIS4uTukQUpzc74UQQohnMuK9XtguRZM+Fy5cYPTo0bRr146aNWvSvXv3l+4fFBTE9evX6d+/v1V7o0aN2LhxI9evX8fLy+uV11Wr1RiNRtRqNdmzZ3+btyCEEEKkiIcPH1ruTRmN3O+FeLfcvXsXg8GARqMhd+7cSocjhM3IyPd6YbsUTfrkzp2bLVu2kCtXrmSN7b9y5QpAgi96BQoUAODatWvJ+hKYNWtW7t+/T/bs2dm9e/drx50hHTkCy5aBXq90JEII8e6oWhXatAGVijp16nD//v0MOQzJJu732zbDsUXw+Prrhi+UolJB5oKQqyzkLAn2LkpHJJIpb9683L59G09PT/muLd4pG07d5eiNx0luX/l9V6LCgjPkvV7YLkWTPh4eHq+1f0REBACurq5W7S4uLlbbXxQXF2fVhc5kMr3WdTO8uDho3BgePVI6EiGEePfkzw81aigdRaqyifv90YWwcchrxSFsiQqyFoZcZSBnaXMiKFdpcMttTg4JIYTCNp66S++Aoy/dxz5Wj/yLJdKaTRRyTi6j0fjS7Ul1k/v999+ZOnVqaoSUMYSGSsJHCCGU4OwMnp5KR2FzUuV+n6UQqNRgevm5ha0yQfBl8+vMc7O4OWdNmAjKVgw0WuVCFUK8c8KidHzz9xmlwxAiUekq6ePm5gZAZGSkVXtSTwTj9ejRg86dO1vWmzRpwoMHD1IpynSuVi14jUKbQggh3kKpUvCavWDeBalyvy/aAAadgdCbqRCxSBX6GHh4Ae6dMr8enANDrPU+UcFwdaf5FU9jD9mLP00ClTEngnKWBiePNAxeCPEuGbvhLA/Dzf8+1fXOTt96RRLdr+8eex7HpGVkQqSzpE/BggUBuHHjBiVLlrS037hxA4DChQsnepy9vT329vaWdZV0A7ZmMDxbzprVnPgRQgghFJJq93v3POaXSD8K1X22bNBD8KVnSaD4V9QLvZUNcXDvpPn1vEz5IW9lqPcVZCua6qELId4Ney8/Ytl/QQC4OtjxY+sy5M7klOi+9hop4CzSXrpK+hQoUIC8efOyefNmmjRpYmn/559/8PLyIm/evApGl05t3Qr9+j1b12iUi0UIIYRA7vciCRo7yFHC/CrbxtxmMkHEfbh32pzkuX/anAgKvpxwKF/YTfPr6g5ovxLyVkr79yCEyFCi4wyMWHXKsj6sSfEkEz5CKMWmkz4RERFcvnyZ/PnzkyVLFgD69OnDiBEj8PDwwNfXl23btrFx40Z+/fVXhaNNZ27ehC++gJUrn7WpVOZZZIQQQog0JPd78cZUKnDLZX4VbfCsPS7KPBzsfnyPoNPmhFBcBEQ/hvnN4dNA655EIsUsWrSI2NhYHBwclA7lpWJ0BkIi4169oxBJ+GPPVW6GRAFQ1SsL7avmVzgiIRKy6aTPmTNn6NixIz/++COtW7cGoHXr1sTFxTF37lxWrlxJvnz5+Omnn/jggw8UjjadiImBiRNh7FiIjn7WXr06TJsGFSsqF5sQQoh3ktzvRYqzdzb35Hm+N0/ME1jSDq7vAV0kBHwMH82FEs2VizODqlu3rtIhvNKRG4/xn3OQqDjDq3cW4hXs7dT86FcGtVrKiAjbozK9g/OX16lTh/v375MzZ052796tdDhpZ/16GDAArlx51pYjB/z8M/j7QxKzoQghhEh97+y9KRXJZyoS0MXAis5wYYN5XaWG5pOhor+ycYk0FaMz0GTSHq49inz1zkIkw5BG3vRJonjz8+S+JJRg0z19RAq5cgUGDoR16561aTTQty989x1kyqRYaEIIIYQQaUbrCG0Wwt994cRic92fv/tCTBjU7Kt0dCKNTNp2yZLw8crqTKk88l1YvLkSud3oUaeQ0mEIkSRJ+mRkUVHw448wfjzEPjfFqY8PTJkCZcooF5sQQgghhBI0dtByOjh6wMEZ5rZ/Rppr/fh+ba4TJN7Kzp07LTV9bG2o1+nbYczafRUwz6Q0u1NliuRwUzgqIYRIPZL0SWtpMZrOZIK//oJBg8wFm+PlyWOu5/PJJ/KFRgghhBDvLrUaGv8Izllgx1hz254JEB0CH0wwD/sSCSXz+2OHDh24ffs2np6eBAUFpXJQyac3GBm+6iQGo/n7eF/fIpLwEUJkeJL0SUsTJsA331gXUE4LWq15pq6vvwZX17S9thBCCCGELVKpwGcoOGWGDV+a2/6ba36JhHKUhJZTwTP9TnU/+99rnL79BADvnG709CmscERCCJH65DFGWho/Pu0TPu+/D6dOwbhxkvAR4h02ePBgvL29mTs34Y+Z4cOH4+vrm+Sx/v7++PsnLHJ67do1vv32Wxo0aEDZsmWpW7cuX3zxBefPn0/R2F/077//4ufnR7ly5fD19WXOnDm8ak6CuLg4Jk6ciI+PD2XLlqVVq1asX78+wX7//fcf7dq1o2LFitStW5cxY8YQERFh2e7v74+3t3eSLyFEOlS1G7SeDWp5FvpSD87C/BZwdZfSkbwWk8nE9UeRLDpwg1+3XARArYKfPiqLvZ38FBJCZHxyd0tL8XV1HB2hQoXUvZa7O3TvDq1ayVAuId5x4eHhbN26lWLFirF06VI6d+6M6i3/Xfjnn38YOnQoRYsWpVevXuTNm5d79+4xf/582rRpw4wZM6hVq1YKvYNnjh8/Ts+ePWnSpAkDBgzgyJEjjB8/HoPBQPfu3ZM8btCgQezcuZMuXbpQo0YNTp8+zciRIwkJCbEktC5dukTnzp2pVKkSv/32G/fv32fChAkEBQUxc+ZMAEaPHm2VBAK4efMmw4YNo02bNin+foUQaaTsx+CaA/ZPhehQpaOxPZEP4PF1iIuAgI/go3lQopnSUSXpXlgM+648Yu/lYPZfecSdsBir7Z1rFaR8Pg9lghNCiDQmSR8leHnBvn1KRyGEeEesezpz38iRI+nUqRMHDhygRo0ab3y++CRH7dq1+e2339BoNJZt77//Pp9++inDhg1j+/bt2Nvbv3X8z5syZQolSpRg/PjxgHnqU71ez8yZM+nYsSOOjo4Jjjl79ixbt25l4MCB9OrVC4CaNWvi7OzMxIkTadmyJe7u7qxduxaVSsW0adNwcXEBwGAwMHr0aEttiiJFrKdjNRgMjBkzhuLFizNy5MgUfa9CiDRWyMf8EgnpomF5Z7i4EQxxsMwfWkyFCu2VjgyAkMg4DlwNZu/lR+y/EszVl0zFXsUrM4PfL5aG0QkhhLIk6SOEEBncypUrqVGjBtWrV6dAgQIsWbLkrZI+CxcuJC4ujq+//toq4QPg5OTEsGHDOHDgAGFhYWTPnj3B8atWrWLEiBFJnr9v377069cvQXtcXBwHDx6kf//+Vu2NGjVi9uzZHDlyJNHeRVeuXAGgXr16Vu3VqlUjKiqKQ4cO0aBBA2JjY7Gzs8PJycmyj4eHBwChoaF4enomOPeSJUs4c+YMS5cuTfEElxBC2AytE3yyENb0hZNLzFPdr+kNMaFQo0+ahxMeo+Pw9RD2Xg5m35Vgzt19kuS+jlo1VbyyUKNwVmoWzkYZz0xo1NILXgjx7pCkjxBCZGCXLl3i1KlTTJo0CYAPP/yQ6dOn8+jRI7Jly/ZG59yzZw8lS5YkZ86ciW6vUaPGS5NKdevWZenSpUluz5UrV6Ltt27dQqfT4eXlZdVeoEABwFxjKLGkT+bMmQG4c+cOxYsXt7TffDq74a1btwDw8/Nj+fLl/Pjjj/Tu3ZtHjx4xbdo0ihUrZnVcvMjISCZPnkzLli0pW7Zsku9HCCGScjb4LPNOzyPGEPPqnRWW1zUvnRp+Sy7HTHDod3Pj5q8gKiTVp7qP0Rk4euMxe688Yt+VYE4GhVlm4HqRnVpFhfwe1CicjZqFs1IhvwcOdppE9xVCiHeBJH2EECIxy5ebZ9sLD1c2Djc3+OEH+OijNzp85cqVeHh4WAo1t2rViilTprBixQp69uz5Rue8d+8eJUqUeKNjAbJkyUKWLFle+7jwp/8vXF8oSh8/FOvFWjvxqlatSr58+RgzZgxOTk6UKVOG8+fPM2HCBFQqFVFRUQAUK1aMIUOG8P3337NgwQIAPD09CQgISNCjCcyf7ZMnT+jRo8drvxchhLgedp3uW7oTFhumdCjJtvLSSj4v/Tmf+QzFYdfP5sY9EyD6sXmqe3XKFEbWGYycDApj32VzkufIzcfE6Y2J7qtSQek8mahZOCs1i2SjcoHMuDjITxwhhIgn/yKmhuvX4cSJhO06XZqHIoR4Q+PHQyrPQpVs48e/UdJHp9Px999/06BBA2JiYoiJicHFxYVKlSqxbNkyunfvjlqtfu2izhqNBoPB8NrxxDOZTC89Xq1Wo07kh4PRmPgX/uePS4y9vT1z5szhq6++4rPPPgMge/bsfP311wwcONAynGvWrFlMnDiR9u3b07BhQx4/fsyMGTP47LPPCAgISNAzKiAgAF9fXwoWLPjSuIQQ4kWPYx7TZ1ufdJXwAYjWRzP1+FRWu3ry5Xs9qP/v76gA/ptjTvyUMd+rTDrzbLVxOj0HrgYn69xGo4kzd56w78ojDl0LITIu6ftE0RyuliRP9YJZyeSsfdu3JoQQGZYkfVLayZNQvjy8YvpgIYSNGzoURo2yjZ4+Q4a80aE7d+4kODiYFStWsGLFigTb9+zZg4+PD05OTsTFxSV5nri4OEttG4A8efJw586dJPfX6XSEhYUlOXxs9erVb1TTx83NDTAPq3pefA+fF3sAPa9AgQIEBAQQHBxMaGgoBQoU4O7du5hMJjJlyoRer2f69Ok0b96cb775xnJctWrVaNCgAXPmzGHYsGGW9vPnz3P9+nUGDRqU5DWFECIxsYZYBuwYwM1w8xDTIh5FmFZ/Gg4aB4UjS1qsIZY/z/zJsgvLMJgM3I64zaCI21QrU4ehFw5SLC4WzqzCeGYV612dCdaZa+w8iQvmyPJGPHpSjS3GygSZcrzR9fNlcaJmoWzULJKVGoWzksMtYdF+IYQQiZOkT0r7999XJ3xKl06bWIQQb+6jj954SJWtWLlyJfny5WPs2LFW7SaTib59+7JkyRJ8fHzIli0boaGhxMXFJVqM+N69e1azVr333nvMnz+fhw8fJlqoedeuXfTp04epU6fSsGHDBNvr1auXaBIqXo4cif8oyJ8/PxqNhhs3bli1x9fmKVy4cKLHxcTEsHnzZipWrEi+fPnImjUrAGfOnAGgVKlShISEEB0dTcWKFa2OzZo1KwULFuTSpUtW7Tt37sTJyYm6desm+T6EEOJFRpORUf+O4tiDYwBkc8rG9PrTye2aW+HIXu2ral/xcbGP+enwTxy8exCAgxHX+dgzF23CI2kQEc7kzB6cdHSg6K/Pkv4ziaVKpn+YE7wUY2wuthgrscVQmVOmgkDiPU2zuzlQs3BWahXORo3CWcmXxTkt3qIQQmRIkvRJTR9/DC/8gMDDAz75RJFwhBDvjocPH7Jnzx66du1KtWrVEmxv3Lgxq1at4v79+1StWpVJkyaxZcsWmjZtarXfiRMnuHfvHtWrV7e0tW/fnsDAQMaOHcvEiROt6t1ERUUxefJkMmfOTJ06dRKNLXPmzJbiyq/DwcGBypUrs2XLFj7//HPLsLTNmzfj5uaWZDFlrVbLDz/8wKeffsrgwYMB0Ov1LFq0iPz581OsWDFMJhMeHh4cOXKEdu3aWY4NCQnh+vXrlCtXzuqcx48fp2TJkolOES+EEIkJjwvnlyO/sPH6RgCc7JyYWn9qukj4xCuauSh/NPyD7be2M/7weG5H3MaIiSVuzixxs07MZIqzJ8ze3Iv0sJMjbTxzkdNgAA4BhyiCBr3aAZ3aAYPaAROQ26kQfcv3pX7h8q899Ph17bu9j3ln5pHZITOjaozCzd4tVa8nhBBKkaRPamreHPz9lY5CCPEO+uuvv9Dr9QmSOPE+/PBDli9fzrJly+jXrx++vr589dVXXL16lcqVK6NWqzl79iyzZ8+mUqVKfPDBB5Zj8+bNy7fffsvIkSNp3749bdu2JXfu3Ny8eZN58+Zx69Yt5syZg4NDyg9V6NWrF507d2bAgAH4+flx7Ngx5syZw+DBgy21eSIiIrh8+TL58+cnS5YsaDQa2rVrx/z588mVKxcFCxYkICCAo0ePMm3aNEstoH79+vHDDz/g4uJCkyZNePz4Mb///jsajYYuXbpYxXHx4kXee++9FH9/QoiMx2gysubyGn47+hshMSEAqFDxU+2fKJW1lMLRvT6VSkX9/PV5z/M9FpxZwB+n/iBaH23ZbojNQez9ZnxQwpdGVYIZf+h/BEXdx6hScdfuxZ8eceaX0TyU+krkIwbv+4yPHn5E3wp9yez4+g8IXuXmk5uMPzyenUE7LW1hcWFMrT8VrVpqAwkhMh5J+qS0F4YACCGEElatWkXRokUpVqxYotsrVapE3rx5Wb58Ob1792by5MnMmzeP9evXM2/ePIxGI56enrRr146uXbsmmL2qVatWFChQgPnz5/Pbb78RHBxM9uzZqVixIlOmTElyqNXbqlGjBlOmTGHy5Mn06dOHnDlzMnToUKukzJkzZ+jYsSM//vgjrVu3BswJHZVKxR9//EFYWBjFixdn1qxZVombDh064Obmxrx581i1ahWZM2emcuXKTJ06lXz58lnFERwcjLu7e6q8RyHeRVfDrrInaA8647NJL7RqLbXz1qZQpkKKxPQk7gmbr29+62LLW29s5UzwGcu6g8aBEVVHUC9/vbcNUVEOGge6le1Gi8ItmHp8KvuCjnHzehl0j2uQw82Zr5qWJJOTlvfyvseCswv46/JfRMaGgyEG9LFgiIPnKiLEqFVEqNUYTUaWXVzGxstr+KTIh7i45kqxmO9H3mflpZVWf2cA++7sY+yBsYyuMTrVexgJIURaU5lM717F4Tp16nD//n1y5szJ7t27k9zPZDIRHBxNREQcrq72ZM3q9PIbwfLl0KbNs/Vz56B48RSMXAghREaV3HuTSD75TG1fWGwY049PZ+mFpRhMCWdr0qg0fOL9Cb3L9yaTQ6Y0iclgNLD68mqmHJti6ZmTUhoWaMjgyoPxdPVM0fMqLSQyjga/7CIk0jycq3b4TrI7GMiUKROjR49O/KDYcLi8Dc6vh0ubiYsJY2EmN2Z5ZCIqhaZ+f5kcTjn42PtjZp2cZUkCfVHpCzqX7pzq1xbvLrkvCSVIT59EhIbGMH/+caZMOcSVK48t7YULZ6Zfv6p06lQeD48X6jgcPgydOj1bHzdOEj5CCCGEsDkmk4lwnbIzE5pMJjZd28TU41MJjQ1Ncj+DyUDg+UA2XNtA3/J9aVywcar2xLgQcoHxh8dzLuRcip63aOaiDK8ynKq5q6boeVOTyWTiysNIdl18yJ5LD7n/JDbJfcOi4iwJnyalc7F2+GJu376Np6dn0kkfBzco9aH5ZdBhf2Mfn1/YQPML65lkF8HfbknPyPg2tGotn5X6jK5luuKsdSafWz6G7xkOwC9HfsHT1ZP3vd5PlWsLIYQSJOnzgs2bL+Pnt4yoKF2CbVevPmbQoM2MHLmdlSvb0KjR09lsgoKgZUuIfjqeuVMn83TPQgghhBA2wmQysfnGZiYdmURQRJDS4VhxsnOic6nOeGfxtrRdCLnAvDPziNZHExobypiDYxhzcEyaxtXYq7E50ZTELFPJ4WbvRoUcFbBT2/7X7ohYPfsuP2LXxYfsuviQoMfRrz7oOe6OdnzXohRrh7/mhTVaKOQDhXzI0XgcY++dotvpJVy9th1Cryd+jL0r5KkAnpUgdzmwe3UdORUqSmUrRQ7nZ7NENi3UlFvht5h2fBoAX/37FXcj79KueDu0GqnxI4RI/2z/7pOGNm++TNOmgZhMpkRnXY9vi47W0bRpIOvXt6PRe7mhRQu4e9e8sXZt+P13kPHAQgghhLAR50POM+7QOI7cP6J0KAl8UPADBlUaRC4X69otvvl9aVW0Fb8e+ZUN1zakaUzFsxRnWJVhVM5VOU2vm9ZMJhPn74WbkzwXHvLfjRB0hsQrP9hr1C/9euvmaMfYVmXI4f6WsxqqVJC7LF65y+IFEHoTLmw0DwO7sReMevN+UdEQ+g+c/QfsHKFQXfD+ALybgGuOpM+fiB5le3Ar/BZ/X/mbWEMsE/6bwIqLKxhWdRjveUrRfiFE+iZJn6dCQ2Pw81uGyWTCaHz5vkYjqNUm/PyWEeRzFI9jx8wbChWCVasgFWasEUIIIYR4laDwIALPB/Io6pGlLUofxZ7bezCann3BKZ21NJkc06ZGTlLc7d35tPinVMhRIcl9crnk4qc6P9G2eFsWn1/Mk7gnqRqTVq2lXr56tCzcEo1a8+oD0qGwKB3/Xn7ErosP2HUx6WFb9ho1VQpmxqdYdup656BoDldlihx75IdqPcyv6MdwaYs5AXR5K8RFmPfRx8DFTebXWhXkq2pOABVvCtmKvvISKpWKb2t8i6PGkeUXl2PCxPUn1+m1tRc+eX0YUmUIBdwLpPIbFUKI1CFJn6fmzz9OVJQu0R4+iTEaISoyjgUbgugP4O4Oa9dCtmypGaYQQgghRAJRuijmnJ7Dn6f/JM4Yl+R++d3yM7TKUOrkrZOuZimqkKPCS5NDImlGo4nTd8LYdeEhOy8+5NjNxxiT+L6bL4sTdYvloK53dqoXyoqLg439VHDKDGXbmF/6WLi2B86vM/cEirj3dCcT3Dpofm0dDVmLmpM/xZuCZ2VIoki0VqNlVI1RtC7WmnEHx3H84XEAdgXtYu+dvfiX8Kd72e642qdOrSEhhEgtNvYvuTJMJhNTphx6kyOZTDX6qQ6jWrYMSpZM8diEEEIIIeLpjXrOh5wnWv+s1kpQeBBTj0/lQdSDJI9z0brQvWx3OpTogL3GPi1CFQoKjohlzyVzbZ7dFx8SHJl4ItDBTk2NwlmpWyw7Pt458MrqnH6SgXYOULSB+dX0F7hzDC6sN/cCenj+2X7Bl2Dvb+aXSw7IWtj6PJ6VoMF3oDH/LCqVtRQLmixgw7UN/HLkFx5EPUBv1DPvzDzWXl3LgIoDaFG4BWpV6s8wJoQQKUGSPkBwcLTVLF3JZULNFbIQ8uNvZG3UKBUiE0IIIYQw23d7Hz8d/omrYVeT3MdObYd/CX8+KvaR1fCk7E7ZJdmTgekNRk4EhVp685y6HZZk7/XC2V2o650Dn2LZqVowC47aDDCMTa2GvJXMr/rfQPAVuLABzm+AWwcgfmhj5APz63k39z8bQvaUSqWiaaGm1MtXz6oH3aPoR4zaO4ql55cyvNpwymUvl4ZvUggh3owkfYCIiKS7QSdH+Cf+ZE2hWIQQQgghnnfryS1+/u9ndt7a+dL9fPL68GXlL/HK5JUWYQmF3X8SYynAvOfSQ57E6BPdz8VeQ60i2fDxzk6dotnJl8U5jSNVQNbCULOf+RX5yFzr5/wGuLoDdFEJ99/1M5RvZ55G/jnOWmf6VehHqyKtmPjfRLbe3ArA6eDTdNjQgeaFmjOw0kCr2cCEEMLWSNIHcHV9uydfbm7y5EwIIYQQLxccHcy3+77lZvjN1zruVvgtdEadZb1s9rJUzvlsVimNSkO13NWolrtaisUqbE+c3siRG4/ZefEBuy485Py98CT3LZHbHZ9i2fEplp1KBTJjb/cOD0VyyQYVOphfRuOzXj8Aq7rBmVUQ9Qj2TYV6IxI9RV63vPxa71cO3j3IuEPjuBx6GYC1V9ey9eZWcrvktuyrVqlpWqgpXct0TdW3JYQQySVJHyBrVicKF87M1auPk13IGcwzShYqlJksWZxSLzghhBBCpHvR+mj6be/HqUen3vgcOZxyMLDSQJoVapZ+6q6It3IrJMrcm+fiQ/ZdfkRknCHR/dwd7aj9NMnjUyw7Od922vS35OPjw6NHj8hmaxOcqNXAcwkw36/h3N/maeD3TYEqn790uvdquauxvPlyll1YxrTj03gS94RofXSCIZeTjk7Cyc6J9iXap9IbEUKI5JOkD+Zxu/36VWXQoM2vfWz//tXki5cQQgghkmQ0GRn570hLwsdObYejJvk/yp3tnGlRpAXdynTDWfsODM15h8XoDBy8FsKuCw/ZdfEBVx5GJrqfSgVlPTOZkzze2SmX1wM7je305gkICFA6hOTJWhgqdYbDf4Au0jzMq+mElx5ip7ajXYl2fFDwA6Ydn8Y/N/4hzvCsVESEzjyN/M+Hf8bT1ZO6+eqm5jsQQohXkqTPU506lWfkyO1ER+swGl+9v1qtwsnJjo4dpYCbEEIIIZL225Hf2HJjC2BO4CxosgDvLN4KRyVsgclk4tqjSEtvngNXg4nRJf5FNKuLPXWe9uSpXTQbWV0d0jjaDMpnKBwPNCd9jsyD6r0SzvCVCA9HD0ZWH8nI6iOt2icdncTsU7MxmowM3T2UPxv/ScmsMsOvEEI5kvR5ysPDkZUr29C0aSBqtemliR+12vyEZdWqT/DwULb7rBBCCCFs17ILy5h3Zh5grvUxwWeCJHzecZGxevZfCbYkem6GJFJYGFCroGL+zJbePKXzZEKtlt7lKc41h7ng865x5mFeO8bCR3Pf+HT9KvQjKDyITdc3Ea2Ppu+2viz8YOFLiz3bqexk5IAQItVI0uc5jRoVYf36dvj5LSMqylww8fkaP23alOTQods8fBjFqlWf8P77r34KIIQQQoh3097be/nfwf9Z1r+q+hW189ZWMCKhpJvBUfy27SLrTtwlzpD408Wc7g5P6/Lk4L0i2cjkrE3jKN9RNfvC4dnmgs6nV0L2ElCjD9i//nBKtUrNmPfGcC/yHscfHudh9EMar2z80mNyOOWge9nufFTsIzRqzZu+CyGESJQkfV7QqFERgoK+YMGCE0weu5UrD8zTX7q52bN06cc8eRKFSqXBzU261AohhBAicRcfX2TwrsEYTObCux1LduST4p8oHJVQwt2waCZvu8zy/26hN1rPGKLVqKhcIAs+3uZhW8VzuWWIHh++vr7cv3+fnDlzsn37dqXDeTUHN/Mwr41Dzes7xpiTQPVGQPkOoHm9n0wOGgcm+U6iw4YO3Aq/9cr9H0Q/YMzBMSy7uIzhVYdTJVeVN3kXQgiRKEn6JMLDw5H+/avRL9N5Qj7rRTgOeEyaDoBOF427u7vCEQohhBDCVj2IekCfbX2I1JmL8NbPX5/BlQcrHJVIaw/DY5m+8zIBB28Sp3/WsyeTk5ZmZXPjUyw7NYtkw9Uh430dv3jxIrdv3yYsLEzpUJKvSlcIuQaHZoHJABH3YO0A2D8N6o+G4k3N9R2SKYtjFn5v8DsTj0zkcczjJPfTGXWWIu8XH1+ky+YuNCzQkC8rf0ke1zxv/baEECLj3WVSkEqlIivRZCUacmYCoF69eixatIiSJUtiZycfnxBCCCGeidJF0XdbX+5F3gOgdNbS/Fj7R9Qq25lZSaSu0Kg4ft99lT/3Xida92yKdVcHO7rWLkiX9wri7ijDtmyOWgNNxkHlLrDtOzi/ztz+6CIsbQ/5qkPD7yB/9WSfMp97Pn6r99sr9zv24Bg/HvyRcyHnANhyYwu7g3bzWanP6FK6i8zaJ4R4K5K1SC43N+Li4jh9+jQ+Pj78888/VKhQQRI/QgghhADAYDQwbM8wyw+3PC55mFJ/Ck52TgpHJtJCeIyOuf9eZ/aeq4TH6i3tjlo1n9UsSI86hcjsYq9ghCJZsheDtgFw8yBs+QZuHTC33zoAcxuBd1NoMBqyp1xB9go5KrC46WLWXFnDpKOTCIkJIdYQy+8nf+evy3/Rv2J/CmUqlOzzqVDhlckLF61LisUohEi/JGORXG5u3LlzB5PJRGhoKL6+vmzcuJEaNWqg0UjBNSGEEOJdN+G/Cey8tRMAV60r0+pPI5tTNkVjEqkvOs7Agv3XmbnrCo+fTgQCYK9R065afnrXK0wON5ntNd3JXw26bIILG2Drt+YePwAX1sPFjVDBH+qOAPfcKXI5jVpD66KtaVigIb+f+J2AcwHoTXruR91n5L8jX32CF+RwysH8JvPJ65Y3ReITQqRf0tc4mUyurly5csWyHhERwfvvv8+OHTswGAwvOVIIIYQQGV3AuQAWnVsEmKdf/qXuLxTJXEThqERqitUbmL/vOnXG7+DHjectCR+NWsWnVfOxY0hdvm1RShI+6ZlKZa7l02s/NJ8Mbk8TPCYjHJ0PkyvAtu8hJuVqF7nZu/FllS9Z1XIVtT3ffLa/B9EP6L2tN2Gx6aiukhAiVUhPn2TSubhw9epVq7bo6GiaNWvGypUrady4sfT4EUIIId5Bu27t4ufDP1vWR9UYRY08NRSMSKQmvcHIyqNBTN52mduh0ZZ2lQo+LO/JgPpF8comw2oyFI0dVOoEZT6GgzPg398g9gnoo2HPRPhvHtQZAlU+B7uUmeG3YKaCTG8wnX2397Hn9h7LTIDJ8e/tf7kVfotrYdcYvHMwMxrMQKuROlJCvKsk6ZNMKjc3bty4kaA9NjaWVq1aERgYSOvWrVGrpfOUEEII8a44F3yOIbuHYDSZZ2fqWqYrrYu2VjgqkRoMRhPrTt7h1y0XuR4cZbWtSelcDGpYjGI53RSKTqQJe2eoPRgqfgZ7JsChP8Cog+gQ2DzCnBDy/QZK+0EK/Sao6VmTmp41X+uYW09u0X5Dex7HPubgvYN8f+B7vq/5ParXmH1MCJFxSIYiOZyd0bq6cv369UQ363Q62rZtS2BgIEajMdF9hBBCCJGx3Iu8R99tfYnWm3t7NPJqRL8K/RSOSqQ0k8nEptP3aDJpNwOWHLdK+NTzzs66fu8xo0MlSfi8S1yyQuMfod9/UKbNs/bQm7CqK8zygSvbFQsvn3s+JvtOxl5tLhz+1+W/+OPUH4rFI4RQliR9kqNAAYBEe/rEMxgMdOrUiblz56ZVVEIIIYRQSKQukj7b+vAg+gEA5bKXY0ytMTI1ewZiMpnYeeEBLabupeeiI1y8H2HZVr1QFlb0rMG8zlUp7ZlJwSiFojJ7gd8f0GM3FPZ91n7vJCxsBQs+hDvHFQmtfI7yjK091rI+5dgUNlzdoEgsQghlyfCu5PDyAkiyp088o9FI9+7diYqKon///qkflxBCCCHSnN6o58tdX3LxsXk2n7yueZnsOxlHOynYm1EcuBrMxH8ucPj6Y6v2Cvk9GPK+NzWLyKxsL/PNN98QERGBq6ur0qGkjdzlwH81XNlhnub93klz+9UdMGuHuRaQ79fmJFEaauzVmKDwICYdnQTA13u/JpdLLirmrJimcQghlCVJn+Tw8kKv03Hnzp1X7moymRgwYADR0dEMGzYsDYITQgghRFoxmUyMOzSOf2//C4C7vTvTG0wni2MWhSMTKeHYzcdM/Oci/15+ZNVeMrc7XzYqRj3vHFIXJRm6d++udAjKKFwPCu6CM6vMs3qFPh0lcGo5nPkLqnQ1F3x2yZpmIX1e+nNuhd9i1aVV6Iw6BuwYQMAHAeR3z59mMQghlCV9kJOjQAHu3L79WvV6hg8fzqRJ5qy6yWRKrciEEEIIkYYWnF3A0gtLAbBT2/Fbvd8omKmgwlGJlDBtx2VaTd9nlfApnN2Fae0qsq7fe/gWzykJH/FqajWU+Qj6HobGP4Hz0wSPUWcu9Dy5POweD3GRaRKOSqXi6+pfUz13dQBCY0Ppva03oTGhaXJ9IYTypKdPMpi8vLjywnTtSXFzc6N169Z06NABX19fS6JIviQIIYQQ6cu+2/vYfXu3ZWauWEMsqy+ttmz/vub3VMlVRanwRAo6cSuUif9csKznz+LMwAZFaVneE41avsOJN2DnANV7Qvl2sHcS7J9mnuI99glsHwOHZkO9EVC+g3lK+FSkVWv5pe4v+G/w50rYFW48uUH3Ld0pn6O8ZZ/MDpnxK+ZHDuccqRqLECLtSdInGfReXlw7c+aV+33zzTeMHDkSrVaLwWCQ6duFEEKIdOpCyAV6betlSfi8qFe5XjQv3DyNoxKpQWcwMmzlSYxPO2Z3r1OIIY280Wrke9ybunv3LgaDAY1GQ+7cuZUOR1mO7lB/lHlo165xcHQhmAwQcQ/WDjAng+qPhuJNIRUfErvZuzGtwTTar29PcEww50LOcS7knNU+887Mo3vZ7viX9MdB45BqsQgh0pbczZLBVKDAK4s4A5QsWRKNRoNKpcLOTvJpQgghRHpkMpn46fBPSSZ8WhZuSa9yvdI4KpFaft91hfP3wgFz7R5J+Ly9KlWqkC9fPqpUkZ5wFu65ofkk6H0Aijd71v7oIixtD3Mbwc0DqRqCp6snU+tPxVWbeIHtaH00k45O4sO/PmTbzW1SokKIDEIyE6/i6Ih9rlyWpE+5cuVo164dTZs2pXPnzhw+fNiya2BgIJ988olCgQohhBAiJWy7uY3D98z393xu+fi5zs+oMD+Bd7RzpFCmQjJsO4O4/CCCydsuA6BWwU9+ZSXhI1JX9mLQNgBuHjTP9HXraaLn1kFz4se7KTQYDdm9U+XypbOVZpPfJoLCgyxtRpORv6/8zbKLyzCajARFBDFwx0Cq567O8KrDKexROFViEUKkDUn6vEqBAgA0adKEkSNH4u3tjV6vR6VS0adPHz777DPLrps2beLJkye4u7srFKwQQggh3kasIZYJ/02wrA+uPJjS2UorGJFILUajiRGrThJnMPfo6la7EGXyZlI4KvHOyF8NumyCCxth67fw6GlNqQvr4eJGqOAPdUeYewilsEwOmcjkYP23XiZ7GT72/pifDv3EoXuHADhw9wB+f/vRtnhbepXrleAYIUT6II8yXiWrueJ+m9atKVq0KAB2dnZoNBo+/vhjHB0dLbvGxcWxZMkSdDqdIqEKIYQQ4u0sPLuQ2xG3Aaiaqyq++XwVjkikloCDNzh8/TEABbI6M7BBMYUjEu8clQqKfwC99kHzyeD2NMFjMsLR+TC5gnnq95iwNAmnWOZizH5/Nr/U/YU8LnkAMJgMBJwLoNnqZuy9vTdN4hBCpCxJ+rzKwYNQty6aBQsSFGZ2dnameXPrIo4BAQFotdq0jFAIIYQQKeBh1EP+OPkHAGqVmqFVhsowrgzqTmg04zaet6z/2LoMTvYaBSMS7zSNHVTqBP2OQv1vwOHpqAF9NOyZCJPKw/7poI9N9VBUKhUNCzRkzYdr6Fu+L052ToB5qvehu4cSpYtK9RiEEClLkj6vYjDArl2g1yfYpNPp6NChg1Xbnj17uHv3rhQ+E0IIIdKZKcemEKU3/6DxK+qHd5bUqakhlGUymfj6r9NExhkAaFslHzULZ1M4KiEAe2eoPRj6H4fqfUBjb26PDoHNI2BqZTi5DIyJF5lPSY52jvQo14O/P/ybyjkrA/Ak7gnrr61P9WsLIVKWJH3eglarpUmTJmTOnNnSZjKZWLhwIfpEkkRCCCGEsE1ng8/y1+W/AHDTutG3Ql9lAxKp5u8Td9h+/gEAOdwcGPFBCYUjEuIFLlmh8f+g739Qps2z9tCbsKobzPKBK9vTJJRcLrn4ssqXlvXAc4HycFuIdEaSPm9Jo9Hw0UcfWbXJEC8hhBAi/TCZTPx06CdMmH/I9CjXgyyOWRSOSqSGkMg4vlt71rL+fcvSZHKS72zCRmUuAH5/QI/dUPi5+mL3TsLCVrDgQ7hzPNXDKJW1FBVyVADgcuhlS6FnIUT6IEmft2QymejYsaNV28mTJzl//jzGNOh6KYQQQoi3s/nGZo4+OAqAl7sX7Yq3UzgikVrGrDtLSGQcAE1K56Jx6VwKRyREMuQuB/6rwf8v83K8qzvMvX5WdoXH11M1hPYl2luWA84FpOq1hBApS6Zsf0sajYb33nuPvHnzEhQUZGlfsGABP/zwg4KRCSGEEOJVYvQx/PLfL5b1Lyt/iVYjPT+UZjCauHg/nFh9yj1Au3g/nFXHzDOzuTva8V2LUil2biHSROF6UNAHzqwyz+oVesPcfmo5nPkLqnSFOkPMw8NSmG9+X3I65+R+1H123trJrfBb5HPLl+LXEUKkPEn6pACDwcCnn37K+PHjLW2BgYH873//UzAqIYQQQrzK/DPzuRt5F4AauWtQJ28dhSN6tz2KiGXZf7cIOHCT26HRqXadkU1LkMPdMdXO/67btm0ber0eOzv5qZHi1Goo8xGUaA7/zYPdP0NUMBh1cHAGHA+AWv2hem+wd0mxy2rVWtoWb8uko5MwYWLJ+SUMqTIkxc4vhEg9MrwrBahUKjp16mTVduPGDfbv34/BYFAoKiGEEEK8zP3I+8w5PQcAjUojU7QrxGQyceRGCAOXHKPmj9v5edOFVE341CyclTaVpYdCavL29qZUqVJ4e8sMeKnGzgGq9zTP9FVnCGidze2xT2D7GJhZGyIepugl/Yr6Ya82zyi2+tJqmb5diHRC0u8pQK1WU6pUKUqVKsWZM2cs7QsXLqRatWoKRiaEEEKIpEw6OolovTm58HGxjymSuYjCEb1bImP1rDl+h4UHbnDu7hOrbSoV1CmanYLZUq6nAoC7k5YutbwkuScyDkd38P3aPLRr549wdCGYDBByBZZ3go5rIIWGrGZ2zEzTQk1ZfXk14bpwFp9fTOOCjZN/vENmnOOTU0KINCNJnxSi1+tp164dI0eOtLQtW7aMyZMno1ZLhyohhBDCllwIucDaq2sBcLd3p0/5PgpH9O64/CCcRQdusvJIEOGxeqttmZ21tKmSj/ZVC5A/q/w4FCLZ3HJB80nmYV3zW0DEPbixFzYNh6YTU+wy7Uq0Y/Xl1QD8dvQ3fjv6W7KPtVfb41/Sn25lu+GiTdmErhAiaZKNSCEajYaOHTtaPTkKDg7mn3/+Qa/Xv+RIIYQQQqS1w/cOW5Y/L/M5Ho4eygXzDtAZjKw/eZdPZx2gwS+7+XPfdauET/l8Hkz8uBz7R9RnRJMSkvBJ5wIDA5k9ezaBgYFKh/Luye4NbQNAYx6GxeHZcGR+ip2+eJbiVMlV5Y2OjTPGMef0HJqvbs7aK2sxmmSmYyHSgvT0SSEqlYq8efNSs2ZN9u7da2lftGgRH3zwgYKRCSGEEOJFEboIy3IRDxnWlVruhcUQeOgmSw7d5EF4rNU2R62aD8t70qF6AUp7ZlIoQpEahg4dyu3bt/H09KRdu3ZKh/PuyVsZmv0Ka572YFw/GLIXh/wpU3bih1o/MPfUXMLjwpN9jM6oY1fQLnRGHQ+jH/LVv1+x5MIShlcZTpnsZVIkLiFE4iTpk4J0Oh3t2rWzSvqsWbOG6OhonJycFIxMCCGEEM+L0j8rQOpkJ/folGQymdh3JZiF+2+w5dx9DEaT1fZC2VzoUL0AfhXzksk5ZWqNCCFeUKED3D0Jh343z+y1zB+67wT3PG99ak9XT0bVGPXax916covx/41nx60dAJx8eJJ2G9rRsnBLBlYaSDanbG8dmxAiIRnelYK0Wi3t2rWzmp4yKiqKlStXotPpFIxMCCGEEM97ftYZKSyaMsKidcz99xr1f9lF+9kH2XTmniXho1GraFwqFwFdq7FtsA9d3isoCR8hUlujseBV27wccR+WdgBdjGLh5HPPx2Tfyfze8HcKZSpkaV9zZQ3NVjdj7um56Azym0mIlCZJnxTm4eFBo0aNrNoCAgLQauWLjRBCCGEr4mftAnC2k6TP2zh9O4zhK09S/X/b+H7dWa4+jLRsy+7mQP/6Rfl3WD1m+leiVpFsMnOWEGlFo4WP/4RM+c3rt4/A+i/AZHrpYamtZp6arGixgmFVhuGmdQMgUhfJr0d+ZdDOQeiNUg9ViJQkSZ8UFj/E63lbt27l8ePHCkUkhBBCiBdF6p4lJmQWmdcXozOw6mgQrabvpdmUf1ly+BbROoNle/VCWZjWriL7hvvyRcNi5M4kQ+iEUIRLNnNh5/hhrMcD4NAsZWMCtGotHUp2YF3rdXxc7GNUmJPBu4J28dOhnzApnJgSIiORmj4pTKvV0qpVK1xcXIiMNH+h1Ov1BAQE0KNHD+nxI4QQQtgAq+Fd0tMn2W6FRLHo4A2WHb7F4yjrYRiuDnb4VTQXZi6a002hCIUQCeQuCy2nwsrPzeubRkCOElCwjrJxAVkcs/BNjW9oWKAhvbf2Rm/Ss+TCEgq4F6BDyQ5KhydEhiA9fVKBk5MTH374oVWbDPESQgghbIcUck4+g9HE9vP36TzvEHXG7+D3XVetEj7Fc7kxtlVpDn5Vn+9alpaEjxC2qMxHUGuAedlkgGWd4PENZWN6To08NRhdc7Rl/efDP7P95nYFIxIi45CkTyrQ6/X4+/tbtR04cICbN29KV0UhhBDCBsQnfRw1jmjUGoWjsU3BEbHM2HkFn/E76PLnf+y48NBSCkSrUdGyfB5W9KzBxgG1aV+tAC4O0oFcCJtWfzQUaWBejg6BJe0hLvLlx6ShD4t8SPey3QEwYWL4nuGceHhC4aiESP8k6ZMK7OzsaNCgAdmzZ7dqX7BgAQaDIYmjhBBCCJFW4od3ycxd1kwmE0duPGbQ0uPU+HE7P206T9DjZ0WvPT2cGNLIm/0j6jOpbQUqe2WRwsxCpBdqDfjNhixPZ866fwrW9FW8sPPz+pbvywcFPwDMBfc7bezEuEPjCIsNUzgyIdIvxZM+//77L35+fpQrVw5fX1/mzJnz0t4wer2eWbNm8f7771O+fHlatmzJhg0b0jDi5FGpVLRp08aqLSAgwGo6dyGEEOJdYWv3e0vSR+r5ABAVp2fxoZs0nfwvfjP2sfrYbeIMRst2n2LZmd2xMruH1qNPvSJkc3VQMFph63LlyoWnpye5cuVSOhTxIqfM0HYx2Lua18+sgr2/KRrS81QqFT/U+oFKOSsBYDAZCDgXQLPVzVh2YRmPoh8RHB2c5MtglAfsQrxI0QzE8ePH6dmzJ02aNGHAgAEcOXKE8ePHYzAY6N69e6LHTJkyhVmzZtGnTx8qVarEli1bGDRoEBqNJsFU6UoymUx07NiRadOmWdrOnz/PqVOnKFWqFGq14vk2IYQQIk3Y4v0+fnjXu97T5/KDCBYduMHKI0GEx1pPk+zhrKVN5Xy0r5afAlllhjORfP/995/SIYiXyVEcWs+CJU9nHN76HeQsDUUbKhvXU/Yae35v+DvzTs9jzqk5xBhiCI0N5YcDP/DDgR9eemwWxyz0Ltebj4p9JEN3hXhK0aTPlClTKFGiBOPHjwegTp066PV6Zs6cSceOHXF0dExwzMqVK2nWrBl9+/YFoEaNGpw5c4ZFixbZVNJHo9FQtWpVChYsyLVr1yzt8+fP56efflIwMiGEECJt2dr9Xm/UE2uIBd7Nnj46g5GtZ++z8MAN9l0JTrC9XD4P/KsXoFnZ3Dhq5UeTEBlS8aZQdwTs/BEwwYrPoesWyO6tdGQAOGgc6FmuJx8W+ZBfjvzCxmsbk3VcSEwIYw6OYdnFZQyvOpwquaqkcqRC2D7FupvExcVx8OBBGja0zig3atSIyMhIjhw5kuRxrq6uVm0eHh6EhoamVqhvTK/X065dO6u2xYsXy9h3IYQQ7wxbvN9H65/VqHmXevrcC4vh1y0Xee+n7fQKOGqV8HGwU9Omcl7W9n2PNX1q8VGlvJLwESKjqzMUijczL8eGwbwP4M5xRUN6US6XXPxc52fmN55P80LNqZuvbpKvqrmqWo67+PgiXTZ34ctdXxIeF67gOxBCeYr19Ll16xY6nQ4vLy+r9gIFCgBw7do1atWqleC4jh07MmfOHOrVq0fFihXZvn07e/bs4YsvvkjyWnFxccTFxVnW02oGLbVaTadOnRg7dqyl7c6dO+zZs4f33nsPjUa+TAkhhMjYbPF+H6l7NluNizZjD1symUzsvxLMwgM3+OfsfQxG68+kYDYX2lfLz8eV8pHJWatQlEIIRajV0GomzGsC905B1COY3xw+XQJeCf9dVlLFnBWpmLPiK/c79uAY4w6N42zwWQA2X99MaEwoMxrMQKuRf+PEu0mxpE94uDnj+uJTPBcX85eviIiIRI/77LPPOH78ON26dbO0+fn50bVr1ySv9fvvvzN16tS3Dfm1qdVqihYtSvny5Tl+/LilfeHChdSuXTvN4xFCCCHSmi3e7+Pr+QA42Tm9cv/06EmMjlVHglh44AZXHlpPyaxWQYMSOfGvUYBahbOhVksPZJGyevToQUhICFmyZOH3339XOhzxMg5u0GkdBH4Ctw5A7BNY1BraLIBitlM6I7kq5KjA4qaLWXN5DRP+m8CTuCccvHeQHw78wHc1v5MRF+KdpFjSx2g0vnR7YoWO4+LiaN++PQ8fPuS7776jUKFCHDt2jBkzZuDs7MzXX3+d6Ll69OhB586dLetNmjThwYMHb/cGkkmn09G+fXurpM+KFSuYMWOGFHMWQgiR4dni/T5a99zwrgxW0+fMnTAWHbjBX8fuEK2znsUmm6sD7armo23V/OTxyJjJLmEb1q9fz+3bt/H09FQ6FJEcTh7gvxqW+cPlraCPMRd5/nAGlG3zysNtjVqlplXRVhTMVJDPN39OnDGO1ZdXk989P13LJP3gQIiMSrGkj5ubGwCRkdZPn+Kf+L34RBBg8+bNnD9/nnnz5lGzZk0AqlatiqurK99//z1t2rShWLFiCY6zt7fH3t7esp6WGV47Ozv8/f0ZNmyY5YtvWFgY69ato1mzZmi10s1QCCFExmWL9/vne/pkhJo+MToDG0/fZeH+Gxy9GZpge7WCWfCvUYD3S+bC3k4eOAkhEmHvbJ7KfXUP8zTuRj2s6gbRoVAt8VkWbV35HOUZW3ssQ3YNAWDS0Ul4unrSpGAThSMTIm0plvTJnz8/Go2GGzduWLXfvHkTgMKFCyc45s6dOwBUrGg9nrNKFXNV9suXLyf6JVBJKpWKnDlz4uPjw44dOyztAQEBtGrVSsHIhBBCiNRni/f7jFLT51ZIFAEHb7Lsv1uERMZZbXN1sKN1RU86VC9AsZxuCkUohEhX7OzBb7a5589/c81tG4dATCjUGQLpcGhUY6/GBIUHMenoJAC+/vdrcrnkokKOCgpHJkTaUexxj4ODA5UrV2bLli1WhRY3b96Mm5sbZcuWTXBMoUKFAPjvv/+s2o8ePQpA3rx5UzHiN6fT6RLM4rVu3bok6xgIIYQQGYUt3u+jdM/19Elnw7sMRhM7zj+gy5+HqTN+BzN3XbFK+BTP5caYD0tz4Kv6fN+ytCR8hBCvR62Bpr9A7cHP2naMhU0j4BXDdW3V56U/p3XR1gDEGePov70/N5/cVDgqIdKOYj19AHr16kXnzp0ZMGAAfn5+HDt2jDlz5jB48GCcnJyIiIjg8uXL5M+fnyxZsuDr60u5cuUYMmQI/fr1o1ChQpw8eZIZM2bg6+ub6BdHW6DVavnkk0/o27cvsbGxAMTGxrJs2TL8/f1liJcQQogMzdbu9+lxeFdIZBzL/rtFwMEb3AqJttqm1ahoUjo3/jUKULlAZilUKoR4OyoV1P8GnDLDP09rqB2cYU4INRr78mNtkEql4uvqX3M74jYH7x4kNDaUPtv6sOiDRWRyyKR0eEKkOkUHdteoUYMpU6Zw7do1+vTpw9q1axk6dKhlpo4zZ87wySefsHPnTgA0Gg1z587lgw8+YPr06XTr1o2//vqLXr16MWnSJAXfyau5ubnxwQcfWLUFBgZKwkcIIUSGZ2v3+/TU0+dWSBRfLD1O9R+3MW7jeauET55Mjgxp5M2+4fWZ/GkFqnhlkYSPECLl1OwHLaaC6ulPxoO/Q1SIsjG9Ia1ayy91f6FwJvOQ4utPrjNgxwDiDHGvOFKI9E/Rnj4ADRs2pGHDholuq1atGhcuXLBqc3V1ZdSoUYwaNSotwksx8bN4rV692tK2Y8cOHjx4QPbs2eVLmhBCiAzNlu73kfpnNX1suadPRKyej2fu596TGKv2OsWy41+9APW8s2OnkcLMQohUVNEfHpyFA9PBqIOzf0HlLkpH9Ubc7d2Z1mAa7de3JzgmmCP3jzB632j+997/5LeYyNDkm0Ia0Wq1NG/eHHd3d0ub0Whk0aJF6PV6BSMTQggh3i3pZcr2GTsvWxI+mZy0dKtdkJ1f1mVBl6o0LJlTEj5CiLRRru2z5ZPLlIsjBXi6ejLFdwqOGkcA1l1dx8wTMxWOSojUJd8W0pBWq8XPz8+qLSAgQIZ4CSGEEGkoPdT0CXocxR97rgFgr1Hzd99ajGxaEq9s6Xe2MSFEOpWrLGQvbl6+uR8eX1c0nLdVJnsZxtUehwpz757pJ6az9spahaMSIvVI0icNGQwG/P39rdqOHj3KlStXrGY0EUIIIUTqSQ81fcZvvkCc3jxTzme1vCiQVZI9Iv349NNP+fzzz/n000+VDkWkBJUKyrZ5tn5quXKxpJD6BeozuPKzGcq+2fcNh+8dVjAiIVKPJH3SkJ2dHT4+PuTOnduqff78+RgMBoWiEkIIId4tkbpnNX1ctLaXTDl28zFrjt8BIIuLPX3qFVE4IiFez/jx45k9ezbjx49XOhSRUsp8/Gz55DLIAA+sO5bsyCfenwCgN+oZuGMg18KuKRyVEClPkj5pzGQy0bZtW6u2wMBA7OwUr6kthBBCvBNseXiXyWTih3VnLeuDGhQlk5MMAxdCKMwjP+SvaV5+dBHuHlc0nJSgUqkYXnU4tTxrAfAk7gm9t/bm8L3DHHtwjGMPjnHi4QliDbEKRyrE25GkTxpTqVR06tTJqu3KlSv8999/0ttHCCGESAPPJ33ii3naivWn7nL0ZigARXK48mnV/MoGJIQQ8Z4f4nUy/Q/xArBT2zGhzgSKZS4GQFBEEF02d6Hjxo503NiRDhs60G59O3RGncKRCvHmJOmTxtRqNeXKlcPb29uqfcGCBTJVoBBCCJEG4mv6ONk5oVFrFI7mmRidgXEbz1vWR35QQmboEkLYjlIfgsbevHx6BRgyxgzErvauTKs/jRxOORLdfvHxRbbd2JbGUQmRcuSbhAL0ej3t2rWzalu6dKlC0QghhBDvlvikj60VcZ639zpBj83Tydcumo263tkVjkiIN1O8eHHc3d0pXry40qGIlOSUGYq+b16OuA/XdikbTwrK5ZKLPxv/Sbcy3ehUshOdSnaiVZFWlu0B5wIUjE6ItyNJHwVoNJoEQ7wePHjAtm3b0OszRsZcCCGEsFXxw7tsqZ7Po4hYpu24DIBaBSOblpAewCLdioiIIDw8nIiICKVDESmt7CfPlk9mrIfW+dzz0b9if76s8iVfVvmS72p+RxEPcyH94w+Pc+bRGYUjFOLNSNJHASqVigIFClC1alWr9oULF0pBZyGEECKV2WJPn1+3XCQi1vzg55Mq+Smey13hiIQQIhFF3wfHTOblk0thqT8EX1E2plSiUqloX6K9ZT3wfKCC0Qjx5iTpoxCdTkf79u2t2lavXk1MTIxCEQkhhBAZn86oI84YB9hOT58L98JZfOgmAK4OdnzRsJjCEQkhRBK0jlCt57P1c3/DtGqwaQREhSgXVyppWqgp7vbmJPzGaxt5FP1I4YiEeH2S9FGIVqulffv2aDTPCkhGRESwZs0adDqpDi+EEEKkhmh9tGXZVpI+Yzecw2gyL/euV5jsbg7KBiSEEC/jMxyaTwKXp4WPjTo4MB0ml4d9U0GfcaY4d7Jzwq+YH2B+aLDi4gqFIxLi9UnSR0FZs2alfv36Vm0BAQFotVqFIhJCCCEytvihXWAbw7t2XnjA7osPAfD0cKJLrYIKRySEEK+gVkOlz6D/UagzBOyczO0xYfDPSJhWFc78BSaTklGmmLbebVGrzD+bl11Yhs4gD+hF+iJJHwUlNsRr06ZNhIaGKhOQEEIIkcHZUtJHbzAydv05y/qwJsVx1NrOFPJCCPFSDm7g+zX0OwLl2gFPi88/vg7LO8HcRnDrsJIRpog8rnnwzecLwMPoh2y5sUXhiIR4PZL0UZBWq+Wjjz7CycnJ0qbT6ViyZIkM8RJCCCFSQfzMXaD88K7Fh29x6YF5dqMK+T1oXja3ovEIIcQbyeQJrWZAj13gVftZ+62DMKcBLO9sTgSlY88XdA44L9O3i/RFkj4Kc3Z2pkWLFlZtgYGBMsRLCCGESAXP9/Rx0booFseTGB2/brloWR/VrKRM0S6ESN9yl4NOa+HTpZDtuYL0Z1bB1Crwz9cQHapYeG+jUs5KeGf2BuDkw5Msu7BM4YiESD5J+ihMr9fToUMHq7Z///2XO3fuYMog42CFEEIIWxGpi7QsKzm8a9qOy4REmmcRa14uDxXzZ1YsFiGESDEqFXg3hl77oOlEcM5mbjfEwb4p5mLPB2aCPk7RMF+XSqWie9nulvWxB8eyJ2iPghEJkXyS9FGYnZ0djRs3JkuWLJY2k8nEggULMBgMCkYmhBBCZDy2MLzrZnAU8/69DoC9nZphjb0ViUOI1DJz5kyWLVvGzJkzlQ5FKEWjhSpdzcWe3/sCNE9nJYx+DJuGwfTqcG5tuir2/L7X+3Qu3RkAo8nIl7u+5ELIBYWjEuLVJOljA9RqNR9//LFVW2BgIHZ2dgpFJIQQQmRMVkkfhXr6/LTpPHEGIwBd3ytI3szKzyImREpq1qwZH3/8Mc2aNVM6FKE0x0zQYLS52HOZNs/aQ67A0g7wZ1O4fUS5+F7TwIoDaVigIWC+n/Te1pv7kfcVjkqIl5Okjw0wmUz4+/tbtZ06dYpz585hNBoVikoIIYTIeJ6v6eOkdXrJnqnjv+shrD91F4Bsrvb0qls4zWMQQog055EP/P6AbjugQK1n7Tf2wh++sLIrhN5ULr5kUqvU/O+9/1E2W1kAHkQ9oN/2fsQaYhWOTIikSdLHBmg0GmrVqkX+/Pmt2ufPny91fYQQQogUZFXI2S5tCzkbjSZ+WHfWsv5FQ2/cHGXiBiHEO8SzIny2Hj4JgCzPJb1PLYcpleHMauViSyZHO0cm+U7C09UTgHMh59h+c7vCUQmRNEn62AiDwcCnn35q1bZ48WI0Go1CEQkhhBAZj5I1ff4+cYcTQWEAFM/lxidV8qXp9YVIK0eOHGH//v0cOZJ+hu2INKRSQYlm0OcgNPkZnJ7WNjXEwtqB5ro/Ni6bUzaGVRlmWT8fcl7BaIR4OUn62AiVSkWnTp2s2m7evMm+ffukoLMQQgiRQp7v6ZOWNX2i4wz8tOnZj4KRTUugUcsU7SJjatmyJTVr1qRly5ZKhyJsmUYL1XpA/2NQrLG5LSYU/v1NyaiSrUTWEpbly6GXFYxEiJeTpI+NUKvVlChRgtKlS1u1L1iwAJVKvhQKIYQQKUGpnj6z91zlblgMAPW8s1O7aPY0u7YQQtg0Jw/4YDxo7M3rB2fCkzuKhpQcOZ1z4qp1BeDyY0n6CNslSR8botfrad++vVXb8uXLpZizEEIIkUIidZGWZRdt2tT0efAkhhm7rgCgUasY2bTEK44QQoh3jEd+qNrdvKyPgZ0/KhtPMqhUKop4FAHgTuQdIuIiFI5IiMRJ0seGaDQaOnbsaNWzJyQkhM2bN6PX6xWMTAghhMgYlJiyfeI/F4mKMw/Vbl8tP0VyuKXJdYUQIl2pPRgc3M3LxxbBwwvKxpMMRTIXsSxfCbuiYCRCJE2SPjZEpVKRJ08eatWqZdW+cOFC7OzsFIpKCCGEyDiiddGWZUc7x1S/3tk7T1h25BYAbo52DKhfNNWvKYQQ6ZJzFnhvoHnZZIRt3ysaTnLE9/QBGeIlbJckfWyMTqdLMMTr77//JioqKokjhBBCCJFc8T19nOycUKtS92uQyWRizPqzmEzm9X6+Rcjq6pCq1xRCiHStWi9wzWVePr8Obh5UNp5XKOrxLJF/KfSSgpEIkTRJ+tgYrVZL27Zt0Wq1lrbo6GhWrFiBTqdTMDIhhBAi/Yuv6ZMW9Xy2nXvAvivBAOTP4kynml6pfk0hhEjX7J2h3ohn60s+hV3jbXYa9+eHd0lPH2GrJOljgzw8PGjUqJFVW2BgoFUiSAghhBCvL76nT2rX89EZjPxvwznL+ogmxXGw06TqNYUQIkMo3wGyFzcvRwXDjjHwSynY9BWEBSkb2wuyOGYhi2MWQHr6CNslSR8bpNPp6NChg1Xb1q1bCQ4OVigiIYQQImOI0j1N+qTydO2LDtzg6iNzr6IqXplpXDpXql5PCCEyDI0ddFgFpf0gfhiuLhIOTINJ5WB1L3hwXtkYnxM/xCskJoTgaPm9JmyPJH1skFarpWXLlri6ulraDAYDAQEBMsRLCCGEeEM6gw6d0XwfTc2ePqFRcfy29dkT36+blrSamVMIIcQrZPKEj+ZCv6NQpSvEF9436uFEIEyvBoFt4eYBZePkhRm8QmUGL2F7JOljoxwdHWnVqpVVmwzxEkIIId6c1XTtqdjTZ8r2y4RFm5NLrSt4Ui6fR6pdSwhbdO7cOcLCwjh37tyrdxbiZbIUhKYTYeBpqDMEHD2ebbu4EeY2gjmN4MJGMBoVCfH5GbxkiJewRZL0sVF6vT7BEK+DBw9y/fp1TPHTgAghhBAi2eKHdkHq9fS59iiSBfuvA+CoVfNlI+9UuY4QtszNzQ13d3fc3NyUDkVkFK7ZwfdrGHQGGv0P3D2fbbt1ABa3hRk14FgA6OPSNDSradtDpZizsD2S9LFRdnZ2NGjQgBw5cli1L1iwAIPBoFBUQgghRPqVFj19ftxwDp3B/HCme+1C5PFwSpXrCCHEO8nBFWr0gf7H4cOZkL3Es20Pz8Oa3jC5POybCrHhaRKSVdJHZvASNkiSPjbuk08+sVoPDAzEzs5OoWiEEEKI9Cu1e/rsvxLMP2fvA5DDzYEePoVT/BpCCCEAO3so/yn02gefLoX8NZ5te3Ib/hkJv5aCnePAkLo1UV3tXcntkhsw9/SRURnC1kjSx4aZTCb8/f2t2i5cuMCJEycwKjRmVQghhEivnu/p46J1SdFzG40mxqw/a1n/spE3Lg7ykEa8m3755Re+/fZbfvnlF6VDERmdWg3ejaHLJujyD3h/8GxbTBjs/BE2f5XqYcT39onQRXA/6n6qX0+I1yFJHxum0WioUqUKhQtbPymcP3++ZJCFEEKI1xSpi7Qsp/TwrpVHgzhz5wkAJXO741cxb4qeX4j05JdffuG7776TpI9IW/mrwaeLoc8hKN8B1E8T74dmwcXNqXrp52fwuvRYijkL2yJJHxun1+tp166dVduSJUtk6lchhBDiNT3f08fJLuVq7UTF6Rm/+YJl/etmJdCo5T4thBCKyO4NH06DJj89a/urF4TfS7VLFvUoalmWYs7C1kjSx8ZpNBo6duxo1Xb37l12796NXq9XKCohhBAi/Umtmj6/77rKg/BYABqWzEnNwtlS7NxCCCHeUOXPnw33igo2J35SqUSGzOAlbJkkfWycSqWiSJEiVKxY0ap9wYIFaDQahaISQggh0p9ofbRlOaVq+twLi+H33VcAsFOrGNGkeIqcVwghxFtSqaDFVHDNZV6/sh0OzkiVSxXMVBC1yvzTWoZ3CVsjSZ90QKfT0b59e6u2lStXotOlbiV6IYQQIiNJjZo+P28+T4zO/OTYv0YBCmV3TZHzCiGESAEuWaHVzGfrW0bD3RMpfhlHO0fyu+UH4GrYVQxGQ4pfQ4g3JUmfdMDOzo4OHTqgVj/73/XkyRPWrl0riR8hhBAimVJ6eNfJoFBWHb0NQCYnLQPqF33FEUIIIdJc4XpQs7952aiDlV0hLvLlx7yB+CFesYZYgiKCUvz8QrwpSfqkAyqVihw5clC3bl2r9oCAALRarTJBCSGEEOnM84Wc37anj8lkYsz6c5b1AfWL4uFs/1bnFEIIkUp8R0HucublRxdTZRr352fwuvxY6voI2yFJn3QisSFeGzZsIDw8XKGIhBBCiPTFKunzlj19Np+5x6FrIQAUzOZCh+oF3up8QgghUpGdPfjNhfiE/5E/4dzaFL3E88WcL4VKXR9hOyTpk05otVratGmDg4ODpS02NpalS5fKEC8hhBAiGVKqpk+s3sCPG89b1kc0KY69nXylEkIIm5atiPU07n/3g7DbKXb6wpkKW5avhV1LsfMK8bbkG0o64urqStOmTa3aAgMDZYiXEEIIkQzRumezd71NT5+F+29wI9jca6hGoaw0LJnzrWMTIiOpWLEi1atXTzD7rBCKq+APJVual6Mfw+oekEJFl/O757fM4CVJH2FLJOmTjuh0Ojp06GDVtmvXLu7fv4/JZFIoKiGEECJ9iB/epUKFo53jG50jJDKOSdvM3fZVKhjZtAQqlSrFYhQiI/j777/Zv38/f//9t9KhCGFNpYLmk8A9r3n9+h7YOylFTm2vsSevq/m8159cx2gypsh5hXhbkvRJR7RaLc2aNcPDw8PSZjQaWbhwIXq9XrnAhBBCiHQgfvYuJzsny9PY1zVp60XCY8z33I8q5qW0Z6YUi08IIUQacMoMrWcBTxP2O8ZC0JEUOXXBTAUBiNZH8yDqQYqcU4i3JUmfdEaj0eDn52fVJrN4CSGEEK8WqTfX9HHRurzR8ZcfRLDo4E0AnO01fNnIO8ViE0IIkYa8akGdL83LRj2s/Bxi336CnPikD8DVsKtvfT4hUoIkfdIZk8mEv7+/Vdvx48e5dOkSRqN0IRRCCCGSEt/T502LOI/beA6D0TycuqdPYXK6v9kQMSGEEDbAZxh4VjYvP74GG4e99SmfT/pIXR9hKyTpk85oNBpq165Nnjx5rNrnz58vSR8hhBDiJeJr+rxJEee7YdFsPWfuqp/L3ZFutQulaGxCZCQtWrSgRo0atGjRQulQhEiaRgt+s8Hezbx+PABOrXirUxbK9OzeIEkfYSsk6ZMOmUwmPv30U6u2wMBA7OzsFIpICCGEsG06gw690VyLx8nO6bWP33z6nmW5bdV8ONlrUiw2ITKao0ePcuDAAY4ePap0KEK8XJaC0HTis/V1X8DjG298Oi93L8vy9bDrbx6XEClIkj7pkEqlomPHjlZt165d4+DBgxgMKTPloBBCCJGRROoiLctvUtNn05lnSZ/GpXOlSExCCCFsQLlPoEwb83JsGKzqDoY3myTHw9GDLI5ZAOnpI2yHJH3SIbVaTdmyZSlevLhV+8KFC2XaWCGEECIR8UO74PVr+gRHxHLoWggABbO54J3TLUVjE0IIobCmE8CjgHn51gHYM+GNTxXf2+dB9AMi4iJSIDgh3o4kfdIpvV5P+/btrdqWLVuGyWRSKCIhhBDCdsUXcYbXr+mz5ex9ntZvplGpXPKARQghMhrHTOb6PqqnQ3d3/QQ3D7zRqZ4v5nz9yfUUCE6ItyNJn3RKo9EkGOL18OFDtmzZgl7/Zt0RhRBCiIzqbXr6bHyunk8TGdolhBAZU76qUHe4edlkhJXdICbstU8j07YLWyNJn3RKpVKRP39+qlevbtW+aNEiKegshBBCvMAq6fMaPX3ConXsu/IIgDyZHCmbN1OKxyaEEMJG1B4M+Wual8NuwrpB8JojKWTadmFrJOmTjul0ugRDvP766y+io6MVikgIIYSwTc8Xcn6dnj7bz99HZzB/4W9UWoZ2CSFEhqbWQOtZ4PA0wX96JZxY8lqnkKSPsDWS9EnHtFot7du3t+rZExkZyerVq9HpdApGJoQQQtiWN63ps+m5oV2NS8nQLiGEyPA88kHz356tbxwGcVFJ7v6iPC55sFfbA5L0EbZBkj7pXObMmWnQoIFVW0BAAFqtVqGIhBBCCNsTrX/WCza5PX2i4vTsuvgQgGyu9lT2ypIqsQkhhLAxpVtDyZbm5dgwuLkv2Ydq1BoKZDLPBHYz/CY6ozyMF8qSpE86l9gQr3/++YfQ0FBlAhJCCCFs0PM9fVy0Lsk6ZteFh8TojAA0LJkLjVqGdgmRHF988QWjR4/miy++UDoUId5cyQ+fLV/Z8VqHFnQ3D/HSG/XcDr+dgkEJ8fqk4m86p9Vq8fPzo0ePHkRFmb/Q6vV6AgMD6datm/T4EUIIIYBI/XM1fZI5vGvTGZm1S4g3IckekSEUqguoABNc3fVah75Y18crk1dKRibEa5GePhmAk5MTLVq0sGqTIV5CCCHEM9G61xveFas3sP3cAwDcHe2oXihrqsUmhBDCBjlngdzlzMv3T0HEg2QfapX0eSJ1fYSyJOmTAej1evz9/a3a9u/fT1BQEKbXnGJQCCGEyIhKZy8NgLu9O8UyF3vl/vsuBxMeqwegQcmc2NvJVyYhhHjnFK73bPk1evvIDF7Clsg3mAzAzs6O999/n6xZnz2FNJlMLFiwAIPBoGBkQgghhG1o7NWYpc2W8veHfyerps/G03efHSuzdgnxWsLDw3ny5Anh4eFKhyLE2yn0fNIn+XV9vNy9LMuS9BFKk6RPBqFWq2nTpo1VW0BAgNV07kIIIcS7rGTWkmR1evUwLb3ByJaz9wFwttdQp1j21A5NiAylRIkSZMqUiRIlSigdihBvJ391sHMyL1/ZAckcReGsdSa3S27AnPSR0RdCSZL0ySBMJlOCIV5nz57l9OnTGI1GhaISQggh0p9D10J4HGWeYreedw4ctRqFIxJCCKEIOwcoUNO8HH4HHl1M9qHxQ7yexD0hJCYkNaITIlkk6ZNBaDQaatSoQYECBazaFyxYIJllIYQQ4jU8P2tXI5m1Swgh3m3P1/V5janbpa6PsBWKJ33+/fdf/Pz8KFeuHL6+vsyZM+eVSYqdO3fy0UcfUbZsWerUqcOYMWMs05W/ywwGA+3atbNqW7x4MSqVSqGIhBBCCLP0cr83Gk1sOm1O+thr1PgWz5Gq1xNCCGHjCtV9tvwadX0KussMXsI2KJr0OX78OD179qRQoUJMmTKF5s2bM378eP74448kj9m+fTu9evWiaNGi/P7773Tv3p1Vq1YxatSoNIzcNqlUKjp16mTVFhQUxN69e6WgsxBCCMWkp/v9sVuhPAiPBaB20Wy4OkhtPCGEeKflKAUuT2u7Xf8XDLpkHfZ8T5+roVdTIzIhkkXRbzJTpkyhRIkSjB8/HoA6deqg1+uZOXMmHTt2xNHRMcExP/74I40aNeLHH38EoEaNGhgMBhYuXEh0dDROTk5p+h5siVqtxtvbm7Jly3Ly5ElL+4IFC6hVq5aCkQkhhHiXpaf7/ebnhnY1lqFdQggh1Gpzb59TyyEuAoIOP6vz8xKebp6W5YfRD1MxQCFeTrGePnFxcRw8eJCGDRtatTdq1IjIyEiOHDmS4JizZ89y8+ZNOnToYNXeqVMntm7d+k4nfOLpdDrat29v1bZy5Urp6SOEEEIR6el+bzKZLFO1a9QqGpTImSrXEUIIkc4Uev26Ps52zpblaH10SkckRLIplvS5desWOp0OLy8vq/b4QsTXriUc93ju3DkAHBwc6NGjB2XLlqVq1aqMHTuWuLi4VI85PbCzs8Pf39+qjs/jx4/ZsGEDer1ewciEEEK8i9LT/f7s3SfcCjF/Ma9RKCuZXexT7VpCCCHSkeeLOSezro+T3bMHFJL0EUpSLOkTHh4OgKurq1W7i4sLABEREQmOCQkxT3XXt29fihQpwqxZs+jWrRtLly5lxIgRSV4rLi6OiIgIyysjz2alUqnInTs3tWvXtmpftGgRdnZSl0AIIUTaSk/3+/gCziCzdgkhhHiOex7I5m1evn0Eoh+/8hAHjQMqzA/io3WS9BHKUSwLYDQaX7pdrU6Yj9LpzEWzGjZsyJAhQwCoXr06JpOJiRMn0rdvXwoWLJjguN9//52pU6emQNTpQ/wQr927d1va1q1bR2RkpOVLthBCCJEW0tP9Pj7po1JBo5IytEsIIcRzitSHRxfAZIQDM6Fe0g8hwPww3snOiSh9lPT0EYpSrKePm5sbAJGRkVbt8U/8XnwiCM+eCtatW9eqPb5XS3x38Bf16NGDI0eOWF45cmTs6Ve1Wi1t27bF3v5Zt/SYmBiWL19u+SIthBBCpIX0cr+//CCCSw/MMVXKn5kc7gmLSwshkmfNmjXs27ePNWvWKB2KECmnSldQP+0zsW8KRDx45SHxQ7wk6SOUpFjSJ3/+/Gg0Gm7cuGHVfvPmTQAKFy6c4Jj4egAvjuePT2Q4ODgkei17e3tcXV0tr+fr3WRU7u7uNG7c2KotICAArVarUERCCCHeRenlfi+zdgmRcipVqkSNGjWoVKmS0qEIkXKyFoZKnc3LukjY9fMrD5Gkj7AFiiV9HBwcqFy5Mlu2bLEac79582bc3NwoW7ZsgmMqV66Ms7Mz69evt2rfvn07dnZ2VKhQIdXjTi90Ol2CWU+2b9/Oo0ePFIpICCHEuyi93O/jZ+0CaFRKkj5CCCES4TMUtE/LZRyZB8FXXrq7k1aSPkJ5ilb27dWrF507d2bAgAH4+flx7Ngx5syZw+DBg3FyciIiIoLLly+TP39+smTJgouLC/3792fcuHG4u7vz/vvvc/ToUWbPnk3Hjh3JkiWLkm/Hpmi1Wlq0aIGbmxvh4eGUL1+edu3aodVq0ev1UtRZCCFEmrH1+/2tkChO334CQGlPd/JlcX7FEUIIId5JrjmgZl/Y9RMY9bB9DHw8L8nd43v6xBhiMJpeXuNOiNSi6C//GjVqMGXKFCZPnkyfPn3ImTMnQ4cOpUuXLgCcOXOGjh078uOPP9K6dWsAOnfujLu7O/PmzWP58uXkyJGDfv360a1bNyXfik2yt7dn7ty5lC1blmLFiqHT6bCzs3snhrcJIYSwHbZ+v39+aFeT0rlT/PxCvGvWrVtHdHQ0Tk5ONGvWTOlwhEhZNfrC4TkQ9QjOrIJa/SFP4j1Qn5+2PUYfk1YRCmFF8e4eDRs2pGHDholuq1atGhcuXEjQ7ufnh5+fX2qHlu4ZDAY+/PBDy8woUs9HCCGEUmz5fm81VbsM7RLirfXs2ZPbt2/j6elJUFCQ0uEIkbIc3c3DvDYONa9v/RY6Jl60/PmkT5Q+Kg2CEyIhxWr6pAvP1R5Ij+zs7LCzs0t0OlwhhBBCwIMnMRy5+RiAojlcKZIj4WxiQgghhJVKncGjgHn56k64dSjR3Z5P+khdH6EUyQa8zP37z5YzZVIuDiGEEEKkis1n71ue8cisXUIIIZLFzt48zCve3ROJ7uZs96xGXJROevoIZUjS52We72ru7a1cHEIIIYRIFZtPy1TtQggh3kCWgs+WI+4nuov09BG2QJI+L/N80qdYMeXiEEIIIUSKexwZx/6rwQDky+JEydzuCkckhBAi3XDN+Ww5/F6iu0jSR9gCSfq8zPnz5v/myQNubsrGIoQQQogUtfXcfQxG89iuJqVzy+yWQgghks/tud6h0tNH2LA3SvqsXLmS8PDwlI7FtgQHm18AxYsrG4sQQgghUpzM2iWEEOKNOWcDlca8LD19hA17o6TPn3/+Sa1atejVqxfr1q0jOjoD/gFLPR8hhBAiw4qI1bPn0iMAcro7UCGfh7IBCSGESF/UanDNYV6Wnj6pQqfTMWXKFOrXr0/p0qWpW7cuP/74IxEREal63eHDhzN8+HAATCYTo0aNonz58tSvX58pU6bg7+//ynO8uN/GjRsJju9Uksbs3uSgtWvXcuXKFTZu3MjMmTMZNWoUPj4+NG3aFB8fH+zt7VM6zrQnSR8hhBAiw9p98SFxBiNg7uWjVsvQLiGEEK/JNSeE34XIh2A0gFpjtVmSPm9nwoQJ7Nu3jzFjxpAvXz5u3brF2LFjuXHjBjNnzky1644cOdKyfP78eZYtW8asWbPw9vbGzc0tWUmfLl26WPa7ffs2AwcOZNu2bakW88u8UdIHoHDhwvTt25e+ffty5coV1qxZw5AhQ7Czs6Nhw4Z8/PHHVKxYMSVjTVuS9BFCCCEyrLthMZblSgUyKxiJEBmPq6srbm5uuLq6Kh2KEKnLLRfcBUxGc+LHzXqosCR93s7q1av53//+R40aNQDImzcv3377Le3bt+fBgwfkyJEjVa7r9lw93/iyNnXq1Hmt2n8uLi6WZZPJlHLBvYG3KuR8//59FixYwOjRo5k7dy4lS5Zk4MCB5MiRg169ejFx4sSUijPtSdJHCCGEyLD0T3v5ANhrZF4LIVLS+fPnefLkCefjJ0URIqN6PsmTSF0fJ60kfd6GSqXiwIEDGI3P7tkVKlRg/fr1ZM6cGV9fX/7880+aN29O+fLl6d69Ow8fPrTse/HiRfz9/SlbtiyNGjUiICDA6vxr1qyhcePGlCtXjrZt23L27Fng2fCugwcPWnrrFC9enClTpiQYtrV7925atWpFuXLlaNGiBfv37wesh3fVr1/f8t/AwEAqVqzIP//8YzmHTqejWrVqlmNT2hvX9Pn000+pV68eq1atwsfHhy1bthAYGEiHDh0YNGgQw4cPZ9GiRSkdb9qJT/o4OED+/MrGkgqGDx+Ot7d3kq+DBw9ajWVMi3je9FpBQUF4e3sTFBSU6PZVq1bh6+v7NuFZOXv2LB9//DHlypXDz8+P06dPv3T/gIAA6tatS8WKFenfvz+hoaGWbadOnaJt27aUK1eORo0a8ddff73VtYQQQiSP3vjsqZudJH2EEEK8CdeXz+AlPX3eTseOHVm4cCG+vr6MHj2azZs3ExMTQ5EiRdBqtYA5udK1a1eWLl1KdHQ0/fr1AyAmJoZu3bpRqVIl/v77b4YNG8b06dMtv7f27NnDyJEj6dSpE3///TelS5emR48exMXFWa5foUIFpkyZAsC///5Lly5drOK7dOkSvXr1omHDhqxZs4ZmzZrRu3dvq8QTwPLlyy3/bd26NQ0aNGDz5s2W7fv27cPOzo6qVaum7Af41BsN71q8eDFNmzZlzJgxFC5cONF9SpYsyddff/1WwSlGr4fLl83LRYuCRvPy/dOhkSNHMnjwYAA2bNjA3LlzWbFihWV7pkyZWL16tVLh2ayoqCi6d+9O8+bNGTduHIsXL6ZHjx5s2bIFZ2fnBPtv2LCBn3/+mZ9//pmCBQsycuRIvv/+e3755RfCw8Pp1q0brVq1Yvz48Rw7doyvvvqKfPnyUalSpde+lhBCiOTTG55L+kg9HyGEEG/CLeez5cR6+tho0mf9ybv8suUCkbGGNLumi4OGwe9780GZ3Mk+pk+fPuTLl4/AwECWLVvGkiVLcHFxYeTIkfj5+QHg5+dHy5YtAfjf//5HgwYNuHjxIidOnCBr1qwMHDgQAC8vL27fvs2CBQv48MMPWbp0Kc2aNePTTz8FYOjQoWi1WsLCwizXt7e3J1OmTABkz549QXwrVqygYsWK9O7dG4Du3bsTFRXFkydPrPbLkiWL5b+Ojo40bdqUQYMGERsbi4ODA5s2baJx48ZoUinv8EZJn+bNm/P555/j5ORk1R4REcHUqVOtepGkS9eugU5nXs6g07W7ublZxiq6ubmh0WgS/UMW1jZs2ICDgwNDhw5FpVIxcuRIdu/ezaZNm2jdunWC/f/44w+6detGo0aNAPM/Jt999x0Gg4G7d+9Sp04dy7ny5cvHvHnzOHr0KJUqVXrtawkhhEg+/XNdxe00kvQRQgjxBl6np4/OdpI+s3Zf4crDyDS/7u+7r75W0gegRYsWtGjRgsePH/Pvv/+yaNEiRo4cack1PF9HOF++fHh4eHDlyhWuXr3K+fPnqVChgmW7wWCwJFauXbtG27ZtLdvs7e0ZNmzYa8V27do1SpUqZdUWn2R6mVq1amFvb8+ePXvw8fFh69atqVqYOtlJn6tXr1qmGJs2bRrFixe3ZL3iXbx4kSVLlqTZkKBUI/V8LCIiIhg0aBDbt28nc+bMDB48mObNmwPg6+tLkyZNWLNmDdmyZWP16tVcunSJH374gRMnTpA7d246duxI+/btAXjy5AkjR45k//79qFQqfHx8+Pbbby1F/l52rdjYWCZPnsy6desICwujevXqjB49mty5E/6jcf/+fUaOHMl///1HwYIF8fHxSfL9TZkyhalTpya67cLzfwdPnThxgkqVKlmKeKlUKipWrMjx48cTJGIiIiI4e/Ys48aNs7RVqVKFdevWAVCsWDF+/vlnAIxGIzt37uTatWtUqVLlta8lhBDi9Tw/vEsjPX2ESFFDhgzh8ePHZM6cmfHjxysdjhCpx6qnz90Em221p08Pn8JM/Cfte/r0qFMo2fufP3+ev/76y5JbyJw5M82bN6dRo0a8//77HDhwAAA7O+uUhsFgQK1Wo9frqVGjBt98802i53/xuDfxpuews7OjUaNGbN68Ga1Wi6ura6pOgpXsKB88eMBnn31mWe/bt2+CfZycnOjUqVOKBKYoSfpYbNmyhSFDhvDFF18QGBjIV199Rd26dS29hNauXcucOXMwmUzExsZahiv98MMPXL16lVGjRuHi4sKHH37I5MmTefjwIYsXL0av1zNkyBCmT5/O0KFDX3mt0aNHc/ToUX766Sc8PDyYMGECvXv3ZuXKlQliHjBgAM7OzixfvpxLly4xcuRIMmdOfGaWLl26WGV4X+Xhw4cUKVLEqi1r1qxcunQpwb63bt0CICQkhLZt2xIUFEStWrUYOXIk7u7ulv3i4uKoWLEiOp2Otm3bUr58+de+lhBCiNfzfCFnrdT0ESJFLV68mNu3b+Pp6SlJH5GxPd/TJzxhTx9nu2clGWwp6fNBmdyv3eMmrRkMBubNm0eLFi0oWbKkpd3e3h5HR0fLkKnz58/ToEEDAG7cuEF4eDje3t4EBwezbds28ubNa+nds2bNGk6dOsXXX39NgQIFrIrNGwwGGjZs+Fr/ZhUoUIBz585ZtbVt2zbBlO6JzfrVvHlz+vTpg7OzM40bN36tmcFeV7KTPtWrV7d8KL6+vqxYscLyQWc4kvSxqFChAl27dgWgd+/ezJ07l6tXr1KuXDnA3N0uvmvd8uXLXzpu8vbt27i4uJA3b16cnJyYNGlSsq7l5eXFmjVr+OOPP6hevToAEyZMoG7duuzdu5eCBQtaznHp0iWOHTvGjh07yJMnD0WLFuX06dNs2rQp0ffn4uJiNZ3eq0RHR2Nvb2/VZm9vb1XwK15kpLnL5Pfff8+XX36Jh4cHY8eOZejQoQm67y1dupSrV6/y/fff4+XlRefOnV/rWkIIIV6PVSFn6ekjhBDiTbjmAFSACSIS1vRxtHO0LNtS0ic9KFWqFHXr1qV3794MHjyYChUq8OjRI1b/n737Dm+yauM4/k33ZJUls8wqo2UPmVb2KAgqKENANgoiQ5YgCIKAIBRkIzJcIKCAyHxFUUFFplKUvfcshY4k7x+hoaEFSkmb0vw+15WryTPvPISep3fuc86KFcTExFCvXj2mTZvGwoULeeaZZ8ibNy/vv/8+1apVIzAwkOzZszNt2jSGDx9Op06dOHnyJGPGjKFjx44AtGvXjk6dOlGhQgXKlSvHokWLMJvNlCxZ0jrw8sO88sorNGrUiE8//ZTQ0FB++OEH/vvvPypUqMDhw4et28UPixMREUHWrFnx9fWlfPnyeHt7s2LFCj7//HP7X8AEUlSPtHnzZnvHkb4o6WOVP39+6/P46p7o6Gjrsrx581qfP6zfZPv27enZsydVq1alatWq1K9f39p960HnOnr0KCaTyZpoAsiSJQuFChXi0KFDNkmfgwcPkiVLFvLkyWNdVrp06fsmfWbOnMmsWbOSXLdz585Eyzw9PRMlXWJiYvDy8kq0bXy5X9euXa3T9I0ZM4bmzZtz7tw5cuWylIN6eHhQsmRJSpYsyfnz51m0aBEdO3Z8pHOJiMijsR3IWZU+IiKSAq7u4BMAUReTrPRxMbjg5erFbeNtouKiHBDgk+3jjz9m5syZTJs2jdOnT+Pj40P16tVZvHixdYiQF154gUmTJnH69Glq1arFyJEjAfDz82POnDl88MEHNG/enCxZstCmTRu6desGWIbdGDFiBNOnT+fChQuUKlWKmTNnPtLfWgUKFCA8PJyPPvqISZMmUaxYMWbOnGn9Oy9etmzZCAsL46233qJ///506NABg8FAgwYN2Lx5M6VKlbLTFUtaspM+zz//PMuWLSNr1qyEhoY+sPxo06ZNdgnOYeLLvHLlgnvGLXI2SY0gbjbfvVH29PS0Pn9Yv8mqVauyZcsWNm3axI8//sjw4cPZunUrEydOfOC5Ep4jIaPRiCnBQJxJxQdYp/NLSuvWrWnYsOF9198rV65cXLx40WbZxYsXyZkzZ6Jt4wfGLlz4bt/V+ATV2bNniYmJ4ejRo9SoUcO6vmjRoly5cuWRzyUiIo/Gdsp2VfqIiEgK+ee2JH0iz4HZDPf8nezt5s1t421V+qSAt7c3ffv2pW/fvvfdJigoiMGDBye5rmTJkixZsuS++7744ou8+OKLiZYnHJO1cuXKNmO9xk8JH++5557jueeeS3SMe7ebMGFCoq5jFy5coEmTJveNz16SnfR54403rN1g7n0DGcrVq3D+vOW5k1f5PKpChQo9sN/kggULCAoK4oUXXuCFF15gzZo19/0PmlD+/Plxc3Nj165d1gTJlStXOHbsmE2VD1gGR7527RrHjh2jYMGCAIn6WSaUJUsWsmTJkuz3GBISwpw5czCbzRgMBsxmM3/99Rfdu3dPtG2ePHnImTMnERER1iqlQ4cOYTAYyJMnD7///jsjRoxg69at1ozyvn37rEmiRzmXiEhquHHjBt999x1HjhyhZ8+e7N69myJFilCgQAFHh/bYEo7po+5dIiKSYn654Nw+MMVC1GXwDbBZ7e3mzZXoK0r6iNWuXbv4+++/2bRpk3WSn9SU7HrmF154wTq+SPxo0/F/vN/7eKIl7NqVQadrTy1hYWHcvn2b4cOHc+jQIbZs2cKYMWMICLD84jt79iyjRo1i165dHD16lHXr1tkMynU/vr6+vPTSS7z//vts376diIgIBgwYQO7cualWrZrNtkWKFKFq1aoMGTKEiIgINm7cyOLFi+32Hhs0aMD169cZM2YMBw8eZMyYMdy6dctaLXT79m0uXLgAWAbs6tChA1OnTuWXX34hIiKC9957jzp16pAjRw7rINXDhw/nyJEjrFq1irlz59KjR49knUtEJDX9+++/1KtXj2+++YYvv/ySmzdvsn79epo1a8bvv//u6PAem22lj7p3iYhICvknnLY98bg+8TN4Kekj8X7++WcmTpxI3759yZcvX6qfL0V3ORMnTuTZZ5+ld+/erF+/3maMlyeexvNJsfh+k0ePHqV58+YMGzbMpt9knz59KFeuHD169KBZs2ZERUUle3T0d955x/qZe+WVV/D09GTBggWJBjoGmDx5MlmzZqV169ZMmjQp0ejpj/seZ82axY4dO2jRogW7d+9m9uzZ+PhYRub//vvvqV69unX7Tp060aZNGwYOHMgrr7xCgQIFGDt2LGBJZs2dO5fz58/TokULJk+ezJAhQ6yjzz/sXCIiqWn06NG88sorLF++3NpNduzYsbz66quMHz/ewdE9Pg3kLCIiduGXcNr2xEkfH3fLvfvtuNtpFZHT2Lx5My1atHB0GI/szTffZOfOnWk287nBfO8AKMm0c+dO1q9fz/r167ly5QqhoaE0atSIGjVqPHAMlfSgZs2a1oF0f/rpJ9uVQ4fCBx9Ynq9eDY0bp32AIiLidB7YNjlA2bJl+fbbbylQoABly5blu+++I3/+/Jw4cYKmTZuya9cuR4f4UA+6pj0W72DtPsvN+W+DQ3kqs7cjQhTJkPLly2edsv3kyZOODkckdW2fDWsHWJ43nwFlXrVZ/fq61/n9rKVCNsu8LJw/dz7dtPXiHFJcz1y2bFneeecdNm3axKJFi8iTJw8DBgywqXJ4IqnSR0REhGzZsnHkyJFEy//66y9rt90nmW2lj7p3iYhICvk/uNInvnsXJJ5wRiQtpGjK9nhRUVH8+OOPrF+/nq1bt5IrVy4aNWpkr9gcIz7p4+4OgYEODUVERMRRunTpwrBhw+jevTtms5lt27axYsUKPvvsswfOovGk0EDOIqmncePGXL58mWzZsjk6FJHU55dwTJ/E07bbJH1Q0kfSXoqSPitWrGD9+vX8+uuvZM+enUaNGrF48WKeftIHPjYa4b//LM+LFgW3x8qJiYiIPLFat25Nzpw5mTdvHl5eXowfP55ChQrx/vvvP/lf8KAp20VS06xZsxwdgkjaUaWPpHMpympMnjyZBg0asHDhQutU1BnCsWMQPyi1unaJiIgTmzt3Lk2aNGHJkiWODiVVxBnVvUtEROxAlT6SzqUo6bNlyxYMhgz4rZimaxcREQFg5syZ1K9f39FhpJo4U4LuXar0ERGRlHL3Aq/McPsa3DiTaLUqfcTRkp30ad++PdOmTSNTpkwPnVps4cKFjx2YQ2gQZxEREQCaNGnCjBkz6Nq1K3ny5MHDw8PRIdmVpmwXERG78ct9J+lzDsxmSFAgoUqflIuNjWXmzJmsXLmSc+fOkT17durXr8+bb76Jn59fqp03PDyc33//nUWLFgGwdu1aKlWqREBAQKJ197N8+XKmTZvG5s2bAfjtt9/ImTMnRYoUSbW47yfZSZ9KlSpZp2KvVKlSqgXkUEr6iIiIAPDTTz9x+vRpVqxYkeT6/fv3p3FE9hXfvcvVxZAxq5dFHKhChQqcPXuW3Llz8+effzo6HJHU558LLh6AuFsQfd1S+XOHkj4pN3HiRH799VdGjx5N/vz5OXHiBGPGjOHYsWPMnDkz1c7bqVMn2rVrB8CpU6d466232LRpU6J1D9KoUSNq165tfd2hQwcWLlyYvpM+b7zxhvV5vnz5aNSoUaJv/aKioli2bJn9oktrSvqIiIgAMG7cOEeHkKriK31U5SNif2fPnuXUqVOODkMk7SQc1+fGOdukj7u6d6XUihUr+OCDD6hatSpgyUO89957tGnThvPnz5MzZ85UOa+vr6/1+b3/ZgnXPYiXlxdeXl52jSulkj1y4eXLlzl9+jSnT59m8ODB/Pfff9bX8Y9t27YxceLE1Iw3dcUnfbJnB00xKSIiTqxSpUpUqlSJnDlzcuPGDa5du0a2bNmsy5908VO2K+kjIiKPLeEMXpG2M3ip0iflDAYD27Ztw5RgHL6yZcuyZs0asmbNSkxMDKNHj6Zy5cpUrlyZ/v37c/XqVQBOnjxJUFAQ69evp06dOpQuXZpu3bpZ18fGxjJs2DAqV65M2bJl6d69O+fOWQbiDg8Pt1bzPP/889afy5cvt64zmUzUqFGDb775xhqb2WymZs2afPvttyxfvpzQ0FAA68/27dsTHh5OvXr1+PTTT23ea9OmTVm6dKn9LyKPkPT5/fffCQ0Ntb7pF198keeff976CA0NpWfPnjRo0CBVAk1116/D6dOW56ryERERJ3f9+nV69epFgwYNGDJkCIMHD6Zp06a0b9+eGzduODq8x2at9HHVzF0iIvKY7q30SUADOadc+/btWbRoEaGhoYwYMYJ169Zx+/ZtihYtiru7O5MmTWLfvn3MmTOHhQsXEhkZSZ8+fWyOMXPmTCZNmsTixYvZu3evNdmyZMkS/vjjD+bPn8+yZcu4efMmH3zwQaIY4hMxS5cupVGjRtblLi4uNGjQgA0bNliX7dq1i6tXr1pzJvHie0OFh4fTqVMnGjduzLp166zrDx06xJEjR6hXr95jXrGkJbt7V4MGDdi8eTMmk4k6deqwdOlSsiWohjEYDHh7e5M1a9ZUCTTV/fvv3edK+oiIiJMbPXo0Z8+e5fvvv6dw4cIAHDx4kEGDBjF27Ngkb4yeJPGzd6nSR0REHpt/wmnbn4BKn79XwP8+gOjItDunpx88NxRKNk/2Lr169SJ//vx8/vnnfP3113z55Zf4+voydOhQGjVqxOLFi/nmm28IuvP3+/jx46lcuTIHDhywdsPq3bs3wcHBgKWaZu/evYClEsjT05O8efOSJUsWxo0bZ60CSig+55EtW7ZE3bUaN25Mu3btiIyMxM/Pj3Xr1lGrVq1Eg0zHHyNz5sz4+vpaJ8uIH/ts7dq1VK9encyZM5MaHmnK9jx58gAQERGRKsE4lKZrFxERsdq8eTOffvqpNeEDULRoUYYPH06XLl0cGJl9xA/krOnaRUTksSVM+tywTfr4uPlYn6ebSp9fpsLFfx++nT3dAH6d+khJH4CwsDDCwsK4cuUKW7duZfHixQwdOpT8+fMTGxtL69atbbY3mUwcPXqUkiVLAlCwYEHrOj8/P2JjYwFo1aoVa9asoXr16lSqVIk6derQokWLR4qtTJky5MiRgy1bttC4cWPWr1/PgAEDHrpfkSJFCAoK4ocffqBDhw6sXbuWbt26PdK5H0WKpmxv3779A7d9Iqds1yDOIiIiVp6enri4JO76ZDAYMBqNDojIvu4O5KzuXSIi8pgSdu+KfED3rvRS6VOtD/xvTNpX+jzbO9mbR0REsHLlSgYNGgRA1qxZadq0KfXr16devXrs2bMHgM8//xwfHx+bfQMCAqxVO/EzkN+rWLFibN68mR9//JEff/yRSZMmsXr1apYsWfJIb6tRo0asW7eOggULcuXKFZsZux4kPklUo0YNTp48mahLmD1pyvZ4SvqIiIhYhYaGMnLkSCZOnEiBAgUAOHr0KKNHj6ZWrVoOju7xWQdyVqWPiIg8roQDOd94Arp3lWz+yBU3ac1oNPLpp58SFhZGiRIlrMs9PDzw8vLC09MTV1dXrl69yjPPPAPApUuXGDp0KIMHD8bV1fWBx1+5ciUeHh40atSIhg0bsmvXLlq1asWlS5dstjMYHnyf0LhxY9q2bUvBggUJDQ3F29v7gdvHa9KkCVOmTGHlypXUqlUr2bOCpUSKpmxP+Dze5cuXyZo160MvSroVn/Rxc4MEpewiIiLOaMCAAfTq1Yt69epZ+5hfu3aNmjVr8u677zo4usdn7d6lMX1ERORxefqDuy/E3nxwpU966d71BChZsiS1a9emZ8+e9OvXj7Jly3Lx4kVWrFhBTEwML7zwAgcPHuS9995j1KhRBAQEMHbsWE6fPk2+fPk4c+bMA49/48YNZs6cSdasWcmXLx+rVq0id+7cicYojk/iREREJDl+8TPPPEPOnDlZvHgxEyZMuO/5fHx8+O+//yhRogT+/v7kyZOH4OBgPvvsswfuZw+PNKZPvHPnzjFu3Di6du1K4cKFef3119mxYwdPPfUUn3zyCU8/aWPimEx3B3IuXBjuUwImIiLiLDJlysSiRYs4cOAAhw4dwtPTk0KFCtmM8fMkU/cuERGxK/9ccPnwg2fvSi+VPk+Ijz/+mJkzZzJt2jROnz6Nj48P1atXZ/Hixfj5+TFo0CA+/PBDevfuTWxsLBUrVmT27NkPrfIBaNOmDWfPnmXAgAFcu3aNUqVKMWPGjET7ZsuWjbCwMN566y369++f5LEaNWrEZ599Rs2aNe97vnbt2jF+/HiOHz/OkCFDrPsdOHAg2V3CUspgTkG6sUePHkRFRTFu3Dh+/PFHJk+ezJw5c/juu++IiIh45H5waa1mzZqcO3eOXLly8dNPP8GxYxAYaFnZtCl8951D4xMREeeTqG1ysJiYGD7++GPy5s1LmzZtAGjRogXPPvssffr0uW8f+fTkQde02NDviTWaKZknE2t613BQhCIZ0+eff05UVBQ+Pj68+uqrjg5HJG3MbwjHf7U8H3IGPCzjzBhNRsosKgOAebqZ2Gux6aatF8eaPHkyZ8+e5cMPP0zV86So0mfbtm0sX76cp556io0bN/L8888TEhJCtmzZaNKkib1jTH0az0dERMTG6NGj2bFjB6NGjbIu69mzJx9//DG3b99m2LBhDozu8d2t9FH3LhF7U6JHnFLCcX0iz0I2S2Wsq4srHi4exJhiVOkjgKWr2P79+/n888+ZMWNGqp8vRTXNnp6eREdHc+3aNbZv324tRzp58mSqzS2fqjRdu4iIiI3169czceJEypcvb11Wp04dxo4dy/fff+/AyB6f0WQmvs7ZzVXdu0RExA4SzuB1bxcvd0sXL43pIwD79u1j5MiRvPTSS1SoUCHVz5eiSp86derw1ltv4eXlRebMmalduzbff/89H3zwAS+88IK9Y0x9qvQRERGxYTabiY6OTnJ5bGysAyKynziTyfpclT4iImIX91b6JODt5s216Guq9BEAXnzxRV588cU0O1+Kkj7vvfceixcv5tSpU7Rq1QpPT09iYmLo3r27td//E0VJHxERERv169fn3XffZcSIEdapUiMiIhg9ejR169Z1cHSPJ37mLtCU7SKp4cCBA8TFxeHm5kaQ7q3FWTyo0sdNlT7iOClK+ri5udGhQwebZc2bN7dDOA5y6pTlp68vZM/u2FhERETSgcGDBzN06FBee+01THcqY1xdXWnWrJl11oknlU3SR7N3idjd888/z6lTp8ibNy8nT550dDgiaeMhlT6g2bvEMVKU9Ll+/Trz589n7969xMXFJcpYLly40C7BpRlrx343MOgbPxERcW4XL14ka9asTJo0ievXr3P06FH++OMPPD09adGiBT4+Po4O8bGoe5eIiNhdMip9RBwhRUmfgQMHsnfvXpo2bYqfn5+9YxIREREHuHnzJv369WPLli2sXr2aIkWKsGnTJoYOHUru3Lnx9PTk008/ZcmSJeTOnfvhB0yn4mfuAnXvEhERO/FP0C7ep9JHxBFSlPT59ddfWbx4McHBwfaOR0RERBwkPDycU6dOsXjxYgoXLkxUVBSjR48mODiYRYsW4e7uzogRI5g4cSITJ050dLgpZpv0UfcuERGxA++s4OoBxhhV+ki6kqI7nVy5cuGiPvAiIiIZyvr16xk6dCjly5fHYDCwdetWbt68Sbt27XB3dwegRYsWbN261cGRPp44o7p3iYiInRkMd7t4qdJH0pEUZW4GDhzIe++9x08//cSxY8c4ffq0zUNERESePBcuXKBAgQLW17/++iuurq5Ur17duix79uzcunXLEeHZjU2lj77EEhERe4kfzDnqEsTFWBcr6fN4li9fTlBQEEuXLnV0KE+kFHXvevPNNwHo2rUrAIY7gx+bzWYMBgP79++3U3giIiKSVnLlysWJEyfIkycPZrOZLVu2EBISQubMma3b7Ny5k6eeesqBUT4+29m7VOkjIiJ24pdgBq+b5yFzPgB83J7sCRAcbc2aNRQoUIBvv/2Wl156ydHhPHFSlPTZtGmTveMQERERB2vWrBljxoyhT58+bNu2jTNnztCvXz/r+oiICCZNmkRYWJgDo3x8sQm7d2kgZxERsRf/e2bwupP0UaVPyl26dInffvuNDz74gEGDBnHixAny58/v6LCeKCmqac6bNy958+YlKiqKf/75h6xZs2IymciTJw958+a1d4wiIiKSBnr06EHVqlUZMmQIq1atonfv3jRp0gSADz/8kObNm1O8eHF69Ojh4Egfj9GkSh8REUkFfknP4KWkT8r98MMP+Pv7ExYWRs6cOfn222+t66Kiohg+fDiVK1emcuXKvPvuu0RHRwOWZNFbb71FuXLlqFatGpMmTcJsNnPy5EmCgoI4efKk9Tjh4eG0a9cOsHQla926Nb169aJ8+fJ89913REZGMnjwYKpWrUqpUqVo0KABGzdutO5/v3MNGzaM7t2727yf999/nwEDBqTmJUskRZU+165do0+fPvz+++8ArFu3jjFjxnDixAlmz56txI+IiMgTyM3NjcGDBzN48OBE65o3b07Tpk0pUaKEAyKzrzhTwkofjekjIiJ24p+ge9cNJX3sYc2aNdSuXRsXFxdCQ0NZuXIlvXr1wmAwMGzYMA4cOMAnn3yCl5cXAwYM4OOPP+add96hV69euLq6snjxYm7evEnfvn3JmTMntWvXfug5d+7cSffu3Xn77bfJmjUrY8aM4ciRI8yfPx9vb2/mzp3L0KFDqVmzJh4eHvc9V+PGjenatSuRkZH4+flhMplYt24do0ePTv0Ll0CKkj6jR4/G29ubbdu2UatWLQA++OADBgwYwOjRo5kxY4ZdgxQRERHHCgoKcnQIdmMzpo+6d4nY3R9//IHRaMTV1dXRoYikLZtKn7vTtnu7p6+kz7qj65i+azo3Y2+m2Tl93X15o8wb1Ausl+x9zpw5w19//UXHjh0BqFevHl988QU7duygWLFi/PDDD3z66aeUL18egFGjRrF//34iIiLYuXMnGzdutHYFe++994iKikrWeQ0GAz169MDLywuAihUr0rFjR4oXLw5Ap06dWLp0KZcuXeLatWv3PVflypXJnDkzmzdvJiwsjD///JPY2FiqVauW7GtgDylK+vz8888sWrSITJkyWZdly5aNwYMH07p1a7sFJyIiImJvcereJZKqnvTB3kVS7Amp9FmwbwFHrh1J+/P+veCRkj5r1qzB09PTOotopUqVyJw5MytWrKBVq1YYjUZKlixp3b5ChQpUqFCBtWvXkiVLFpuxf+rUqQNg063rfgICAqwJH7BUO2/cuJGvv/6aw4cP8/fffwNgNBo5cuTIfc8F0LBhQ3744QfCwsJYu3YtdevWxd3dPdnXwB5SlPQBrH3lErp8+TJubik+pIiIiEiqsxnIWVO2i4iIvdyv0iedJX06lurItF3T0rzSp0PJDo+0z5o1a7h9+7a1kgcsiZYffviBF1988b77PSipEj/zeEJxcXE2rz09PW1eDxw4kJ07d9KsWTNeeeUVcuTIQatWrR56LoAmTZrQrl07IiMj2bBhAxMmTHjg9qkhRRmaJk2aMGbMGEaNGoXBYCAqKopt27YxYsQIGjVqZO8YRUREROxGAzmLiEiq8M0OBhcwm9J1pU+9wHqPVHHjCEeOHOGff/5h2LBhVK5c2br84MGD9O3bl2PHjuHq6kpERAQVKlQAYOPGjUyfPp3x48dz9epVzpw5Y608XLhwIdu2beO9994D4ObNuwmvB1X/REZGsnr1ar7++muCg4MB2LJlCwBms5mCBQve91yffPIJISEh5MqVizlz5mA2m6lUqZL9LlIypejrrYEDBxISEkKLFi2IioqiefPmdO7cmapVqzJw4EB7xygiIiJiN7E2Y/qo0kfE3mbPns2kSZOYPXu2o0MRSVsuruCb0/I8HVf6PAnWrFlDlixZaNWqFcWLF7c+GjVqRNGiRVm1ahXNmzdnzJgx7Nmzh7179zJ58mSqVKlCsWLFqFKlCkOHDuXAgQNs376d2bNnU61aNbJnz85TTz3FvHnzOHHiBMuXL+fHH3+8bxweHh54e3uzfv16Tp48yc8//8yoUaMAiImJeeC54jVq1IhPP/2UBg0aOGSss0e+07l48SKurq4MGjSIP/74g0WLFtG/f38GDx7MwIEDbfq+iYiIiKQ3CSt93DWQs4jdjRo1in79+ln/MBJxKvHj+kSeB5MRUNInJdasWUPTpk3x8PBItO6VV17h119/pVevXjz99NN07NiRLl26ULlyZfr27QvAhAkT8Pb2plWrVvTr149WrVrx6quv4uLiYk0UNWrUiB9++CHRtOoJeXh4MGHCBNatW0fjxo0ZN24cPXr0IEeOHOzfv/+B54rXqFEjoqOjHdYrymA2m80P38xS/tSvXz+2bNnC6tWrKVKkCCtWrGDo0KHkzp0bT09PYmJiWLJkCblz5374AR2oZs2anDt3jly5cvHTTz/BM89ARARkzgxXrzo6PBERcUKJ2iZ5bPe7pt/uOkWfL3cBMKJpCTpWK+SgCEUypnz58nHq1Cny5s2brEFTRTKUJS/Df+ssz/v9C/65OHvzLHWX1SUmPAZuoLbeyfzyyy+8++67bNq0KckxhVJbsit9wsPDOXXqFIsXL6Zw4cJERUUxevRogoODWbduHWvXrqV69epMnDgxNeMVEREReSxx6t4lIiKpJeEMXpGWcX1U6eOczp8/z9q1a5kwYQIvvviiQxI+8AhJn/Xr1zN06FDKly+PwWBg69at3Lx5k3bt2llHrG7RogVbt25NtWBFREREHlecKeHsXereJSIidpRwBq8blnF9fNx8HBSMONKNGzcYMmQIWbNmpWPHjg6LI9mzd124cIECBQpYX//666+4urpSvXp167Ls2bNz69Yt+0YoIiIiYkc2Azkr6SMiIvaURKWPu6s7bgY3YohxUFDiCEWKFGHnzp2ODiP5lT65cuXixIkTgGVqsi1bthASEkLmzJmt2+zcudM6TZmIiIhIemQzZbsGchYREXtKotIH1MVLHCfZSZ9mzZoxZswYNm3axAcffMCZM2dsRqSOiIhg0qRJNGjQIFUCFREREbGHWGPC7l0a00dEROzIP0HS506lDyjpI46T7O5dPXr0IDIykiFDhmAwGOjduzdNmjQB4MMPP+TTTz+ldu3a9OjRI9WCFREREXlcmrJdRERSjV+C7l03EiR93JX0EcdIdtLHzc2NwYMHM3jw4ETrmjdvTtOmTSlRooRdgxMRERGxt7gESR9XVfqIiIg9JUz6RKp7lzhespM+DxIUFGSPw4iIiIikOpvuXar0EbG74sWLkzlzZnLlyvXwjUUyGjcP8M4Gty5rTB9JF+yS9BERERF5UtgM5KzZu0TsbvPmzY4OQcSx/J+yJH0iz4LZDAaDkj7iMKppFhEREadiO2W7boVERMTO4qdtN8bArSuAKn3EcRx+p7N161ZatmxJSEgIoaGhzJs3D7PZ/PAdgbi4OF588UXatWuXylGKiIjI40hP7b3RpO5dIiKSihJO235nXB8lfcRRHJr02bVrF927d6dw4cKEh4fTtGlTJkyYwJw5c5K1/+zZs9m7d28qRykiIiKPI72197aVPkr6iIiInfknnsFLSR9xFIeO6RMeHs4zzzzDhAkTAKhZsyZxcXHMnDmT9u3b4+Xldd99IyIimDVrFjly5EircEVERCQF0lt7bztlu8OLnkUynDZt2nDx4kWyZ8/OkiVLHB2OSNpTpY+kIw6704mJiWH79u3UrVvXZnn9+vW5efMmO3bseOC+AwcOpF27dhQqVCi1QxUREZEUSo/tfVyC7l2uqvQRsbstW7awfv16tmzZ4uhQRBxDlT6Sjjgs6XPixAliY2MJDAy0WV6wYEEAjhw5ct99p0+fTlxcHL17907WuWJiYoiMjLQ+kjuGgIiIiDye9NjeJ+ze5a4xfURExN5U6SPpiMO6d924cQMAPz8/m+W+vr4AREZGJrnfnj17mD9/PkuWLMHDwyNZ55o1axbTpk17jGhFREQkJdJje5+we5erZu8SERF7U6WPpCMOu9MxJSitTopLEjdh0dHRDBo0iNdee43g4OBkn6tbt27s2LHD+siZM+cjxysiIiKPLj2297HGBLN3qXuXiIjYmyp9JB1xWKWPv78/ADdv3rRZHv+N373fCAJ8/PHHmEwmevbsSVxcHIC1dDsuLg5XV1cMhsQ3bx4eHjbfEia1jYiIiNhfemzvNZCziIikKg8f8MwE0dfvVvq4K+kjjuGwpE+BAgVwdXXl2LFjNsuPHz8OQJEiRRLts27dOk6dOkXZsmUTrStZsiRjx46lRYsWqROwiIiIPLL02N4nHNNHAzmLiEiq8MtlSfrcqfTxcfNxcEDirByW9PH09KRChQps2LCB119/3fpt3Lp16/D390+ynHvGjBnExMTYLBsxYgQAI0eOJF++fKkfuIiIiCRbemzvjQm6nGkgZxERSRX+ueHSfxATCdGR6t4lDuOwpA9Ajx496NixI3369KFly5bs3LmTefPm0a9fP7y9vYmMjOTgwYMUKFCAbNmyERQUlOgY8QNBli5dOq3DFxERkWRIb+19nEmVPiIiksr8EgzmHHlOSR9xGId2ZK9atSrh4eEcOXKEXr16sWrVKgYOHEiXLl0A+Pvvv2nVqhU//vijI8MUERGRx5De2vuEAzlrTB8REUkV/gkGc75xVkkfcRiHVvoA1K1bl7p16ya5rnLlyhw4cOCB+y9atCg1whIRERE7Sk/tvVGVPiKpqkuXLly7do3MmTM7OhQRx7Gp9DmLd/ZCjotFnJrDkz4iIiIiaSnhQM6asl3E/uLH4BJxaqr0kXRCNc0iIiLiVOIrfdxcDPed1l1EROSxJKz0Ob0Lb/P9NxVJTar0EREREacSP6aPunaJiEiqyZTn7vO9X+P57w8Y8EG5H0lrqvQRERERpxI/e5cGcRYRkVQTUBQK1bS+NERfx99kesAOIqlDdzsiIiLiVOK7d6nSRyR15MuXD4PBQL58+RwdiojjGAzQ7lvosAbKtAUPP7xNqvORtKekj4iIiDiV+O5d7q5K+oiISCpycYHA6tB8OvT/F7yzOjoicUJK+oiIiIhTuTuQs26DREQkjXj4grtm8JK0p7sdERERcSrxU7are5eIiIhkdEr6iIiIiFMxmtS9S0RERJyDkj4iIiLiVOJU6SMiIiJOQkkfERERcSqx1kof3QaJiIhIxqa7HREREXEqmrJdREREnIWSPiIiIuI0zGazdSBnN1X6iIiISAanux0RERFxGneKfABwV6WPiIiIZHBujg5AREREJK3EGk3W5+reJZI6Fi9eTHR0NJ6eno4ORUTE6SnpIyIiIk4jLkGpjwZyFkkdtWvXdnQIIiJyh+52RERExGkYjXeTPqr0ERERkYxOSR8RERFxGvHTtQO4uyrpIyIiIhmbuneJiIiI0zCaVOkjktp+/PFH65g+6uolIuJYSvqIiIiI00g4kLOmbBdJHW3btuXUqVPkzZuXkydPOjocERGnprsdERERcRoJK300ZbuIiIhkdEr6iIiIiNOItRnIWbdBIiIikrHpbkdEREScRpwGchYREREnoqSPiIiIOI04TdkuIiIiTkRJHxEREXEacQnH9NFAziIiIpLB6W5HREREnIYxQfcuN1X6iIiISAanpI+IiIg4DZuBnDWmj4iIiGRwSvqIiIiI00g4po+7Zu8SERGRDE53OyIiIuI0Es7epYGcRUREJKNzc3QAIiIiImnFptJH3btEUsXJkycdHYKIiNyhSh8RERFxGgln73JV9y4RERHJ4HS3IyIiIk4jYfcuVfqIiIhIRqekj4iIiDgNY4JKH03ZLiIiIhmdxvQRERERp2E7Zbu++xJJDSNHjuTatWtkzpyZESNGODocERGnpqSPiIiIOI04Y4LuXar0EUkVc+bM4dSpU+TNm1dJHxERB9NXXCIiIuI0bAdyVtJHREREMjYlfURERMRp2FT6qHuXiIiIZHC62xERERGnkbDSx02zd4mIiEgGp6SPiIiIOI04zd4lIiIiTkRJHxEREXEatlO26zZIREREMjbd7YiIiIjTiE0wpo+runeJiIhIBqekj4iIiDiNOOPdSh93VfqIiIhIBqe7HREREXEamrJdREREnImbowMQERERSSu2U7Yr6SOSGmrVqsXFixfJnj27o0MREXF6SvqIiIiI07Cdsl0FzyKpYcmSJY4OQURE7tDdjoiIiDiNONPdSh9N2S4iIiIZnZI+IiIi4jQSDuTspu5dIiIiksEp6SMiIiJOw6Z7lyp9REREJINT0kdEREScRsKBnN00ZbtIqggNDaVkyZKEhoY6OhQREaengZxFRETEaWjKdpHU9++//3Lq1CmuXbvm6FBERJyevuISERERp5FwTB93zd4lIiIiGZzudkRERMRp2E7ZrkofERERydiU9BERERGnoSnbRURExJko6SMiIiJOw3bKdt0GiYiISMamux0RERFxGqr0EREREWeipI+IiIg4DZtKHyV9REREJINT0kdERESchqZsFxEREWeipI+IiIg4jfjuXW4uBgwGJX1EREQkY3NzdAAiIiIiaSW+e5emaxdJPcOHDycyMhI/Pz9HhyIi4vSU9BERERGnEd+9y81Fxc4iqaVr166ODkFERO7QHY+IiIg4jTjjne5dqvQRERERJ6Ckj4iIiDiNu5U+SvqIiIhIxqfuXSIiIuI0rGP6qHuXSKo5c+YMRqMRV1dXnnrqKUeHIyLi1HTHIyIiIk7DWumj7l0iqaZixYrkz5+fihUrOjoUERGnp6SPiIiIOI2EU7aLiIiIZHRK+oiIiIjTuDtlu26BREREJOPTHY+IiIg4DVX6iIiIiDNR0kdEREScxt1KHyV9REREJONT0kdEREScgtlsTjBlu26BREREJONz+B3P1q1badmyJSEhIYSGhjJv3jzMZvN9t4+JiWHmzJk0aNCAMmXKUL9+faZNm0ZMTEwaRi0iIiKPIj2090bT3fOpe5eIiIg4AzdHnnzXrl10796dhg0b0qdPH3bs2MGECRMwGo107do1yX1Gjx7Nd999R8+ePSldujR79+5l+vTpnD59mg8++CCN34GIiIg8THpp7+MSJn3UvUtEREScgEOTPuHh4TzzzDNMmDABgJo1axIXF8fMmTNp3749Xl5eNttfuXKFr7/+mv79+9O5c2cAqlatCsBHH31E//79yZYtW9q+CREREXmg9NLe2yR91L1LREREnIDD7nhiYmLYvn07devWtVlev359bt68yY4dOxLtExkZSevWrQkNDbVZXrhwYQBOnDiRegGLiIjII0tP7X2c0WR9rkofERERcQYOq/Q5ceIEsbGxBAYG2iwvWLAgAEeOHKFatWo26/Lnz897772X6FibNm3C3d090bHixcTE2IwB8KAxBERERMR+0lN7H6cxfUTSxKZNm4iLi8PNzaGdCkREBAcmfW7cuAGAn5+fzXJfX1/A8i1fcmzYsIEVK1bQtm1bMmfOnOQ2s2bNYtq0aY8RrYiIiKREemrv46drB3XvEklNQUFBjg5BRETucNgdj8lkeuB6l2TcjK1fv563336b8uXLM2DAgPtu161bN3bs2GF95MyZ85HjFRERkUeXntr7OJO6d4mIiIhzcVilj7+/PwA3b960WR7/jd+93wjea8GCBXz44YdUqlSJ6dOn4+nped9tPTw88PDwsL42GHSjJyIikhbSU3tvW+mjewERERHJ+ByW9ClQoACurq4cO3bMZvnx48cBKFKkSJL7mc1mxowZw6JFi2jSpAljx461ucETERGR9CM9tfe2lT7q3iWSWj7//HOioqLw8fHh1VdfdXQ4IiJOzWF3PJ6enlSoUIENGzbYDLS4bt06/P39CQ4OTnK/SZMmsWjRIjp27MjEiROV8BEREUnH0lN7r4GcRdLGwIED6dKlCwMHDnR0KCIiTs+hQ+r36NGDjh070qdPH1q2bMnOnTuZN28e/fr1w9vbm8jISA4ePEiBAgXIli0b+/fvZ86cOZQuXZoGDRqwe/dum+MVLVr0oWXiIiIikrbSS3tv071LY/qIiIiIE3Bo0qdq1aqEh4czdepUevXqRa5cuRg4cCCdOnUC4O+//6Z9+/aMHTuWFi1asH79esxmM3v37qVVq1aJjrdw4UIqV66c1m9DREREHiC9tPe2lT7q3iUiIiIZn0OTPgB169albt26Sa6rXLkyBw4csL7u06cPffr0SavQRERExE7SQ3sfZ0wwpo+6d4mIiIgT0NdcIiIi4hRsKn00kLOIiIg4Ad3xiIiIiFPQlO0iIiLibJT0EREREacQazNlu5I+IiIikvEp6SMiIiJOwahKHxEREXEySvqIiIiIU4izqfTRLZCIiIhkfA6fvUtEREQkLdhO2a5KH5HUkjt3bpufIiLiOEr6iIiIiFPQQM4iaePPP/90dAgiInKHaptFRETEKcQa1b1LREREnIvueERERMQpGNW9S0RERJyMkj4iIiLiFGITJn1U6SMiIiJOQGP6iIiIiFMwJuzepUofkVTTrVs3Ll++TLZs2Zg1a5ajwxERcWpK+oiIiIhTsJm9y1VJH5HUsmbNGk6dOkXevHkdHYqIiNNTbbOIiIg4Bdsp23ULJCIiIhmf7nhERETEKcSpe5eIiIg4GSV9RERExCnEGtW9S0RERJyLkj4iIiLiFIzq3iUiIiJORnc8IiIi4hRiTQm6d6nSR0RERJyAkj4iIiLiFIwJune5K+kjIiIiTkBJHxEREXEKCWfvclX3LhEREXECuuMRERERpxBn0uxdIiIi4lzcHB2AiIiISFqI0+xdImnilVde4cqVK2TNmtXRoYiIOD0lfURERMQp2EzZru5dIqlmwoQJjg5BRETu0B2PiIiIOAWjuneJiIiIk1HSR0RERJxCrEndu0RERMS5KOkjIiIiTsF2ynbdAomIiEjGpzseERERcQoJZ+9yVfcukVTz9NNPkylTJp5++mlHhyIi4vSU9BERERGnkHAgZ3cN5CySaiIjI7lx4waRkZGODkVExOnpjkdEREScgjHBmD6uGtNHREREnICSPiIiIuIUYo2avUtERESci5I+IiIi4hQSVvoo6SMiIiLOQEkfERERcQoJp2zXQM4iIiLiDJT0EREREadgvDN7l7urAYNBSR8RERHJ+JT0EREREacQd2f2LlX5iIiIiLNQ0kdEREScQvxAzpquXURERJyF7npERETEKcQP5Kzp2kVERMRZuDk6ABEREZG0EHune5ebKn1EUtXMmTO5desW3t7ejg5FRMTpKekjIiIiTiG+0sddlT4iqapJkyaODkFERO7QV10iIiLiFOLuzN6lgZxFRETEWSjpIyIiIk4hvnuXu6tuf0RERMQ5qHuXiIiIOAXrQM6q9BFJVTt27CAmJgYPDw/Kly/v6HBERJyakj4iIiLiFOKnbHdT0kckVTVr1oxTp06RN29eTp486ehwREScmuqbRURExCnEV/q4ZcCBnAcNGkRQUNB9H9u3b2fQoEEMGjQozeJJ6blOnjxJUFDQfZMFy5cvJzQ09HHCs/HPP//w0ksvERISQsuWLdm3b999t7127Vqia1u5cmXr+r1799K6dWtCQkKoX78+K1euTPG5RERE7EFJHxEREcnwzGYzcaaMO2X70KFD2bp1K1u3bmXIkCHkzp3b+nrr1q2ULVvW0SGmS1FRUXTt2pUKFSqwfPlyypYtS7du3YiKikpy+4MHD5IlSxaba/v9998DcOPGDbp06ULZsmVZvXo1vXr1YtiwYezYsSNF5xIREbGHjHfXIyIiInKP+CofyJhTtvv7+5MjRw5y5MiBv78/rq6u1tc5cuTAw8PD0SGmS99//z2enp4MHDiQIkWKMHToUHx9ffnhhx+S3P7w4cMUKlTI5toGBAQAcObMGWrWrMnAgQPJnz8/YWFhFCtWjL/++itF5xIREbEHJX1EREQkw4tLkPRx5oGcIyMj6du3LyEhIdSuXZtVq1ZZ14WGhjJhwgSqV69O8+bNMZvN/Pvvv7Rr147g4GDq16/PkiVLrNtfv36dN998kwoVKlCxYkX69+9PZGRkss4VHR3NhAkTqFWrFmXKlKF79+6cOXMmyZjPnTtH586dKVOmDC+88ALHjx+/7/sLDw+/bxe3pOzevZvy5ctjMFg+EwaDgXLlyrFr164ktz948CCBgYFJritevDjjx4/HYDBgMpnYvHkzR44coWLFiik6l4iIiD0o6SMiIiIZXvwgzuDcU7Zv2LCBkiVLsnr1aho2bMiQIUO4ceOGdf2qVauYN28e48aNIzo6mi5dulC+fHm+++473nnnHT755BPrODVTp07lwoULfPHFFyxcuJCIiAg++eSTZJ1rxIgRbNiwgQ8//JAvv/ySuLg4evbsiclk4l59+vTBZDKxdOlSunTpwmeffXbf99epUyebrlcJH0m5cOECOXPmtFkWEBDA2bNnk9z+0KFDnD17lhdffJEaNWrQt29fzp8/b7NNTEwMwcHB9OjRg2bNmlGmTJkUncsR4uLiHB2CiIjYmWbvEhERkQzPqEofAMqWLUvnzp0B6NmzJ/Pnz+fw4cOEhIQAEBYWZq2KWbp0KQEBAbz11lsABAYGcurUKRYuXEjz5s05deoUvr6+5MuXD29vb6ZMmZKscwUGBvLtt98yZ84cqlSpAsDEiROpXbs2v/zyC4UKFbIe47///mPnzp3873//I0+ePBQrVox9+/bdt0uUr68vvr6+yb4et27dStT1zcPDg5iYmCS3P3z4MNmyZWPw4MGYzWYmT55M9+7dWbp0Ka6urtbtvvrqKw4fPsyoUaMIDAykY8eOj3wuRzCZTJhMJoxGI+7u7o4OR0RE7EBJHxEREcnwYo13kz4ZcSDn5MqfP7/1ub+/P2DpahUvb9681ueHDx8mIiLCZhBoo9FoTW60b9+enj17UrVqVapWrUr9+vVp2rTpQ8919OhRTCaTNdEEkCVLFgoVKsShQ4dskj7xAyfnyZPHuqx06dL3TfrMnDmTWbNmJblu586diZZ5enomSrrExMTg5eWV5DHWrFmDwWCwrp86dSrVq1dn9+7dlCtXDrAkckqWLEnJkiU5f/48ixYtomPHjo98Lkc4evQoYWFhvPvuu7zyyitK/oiIZABK+oiIiEiGl9EHck6uhNUo8czmu9fG09PT+jwuLo6qVasyfPjwJI9VtWpVtmzZwqZNm/jxxx8ZPnw4W7duZeLEiQ88V8JzJGQ0GpPs3pUwPuCBSYjWrVvTsGHD+66/V65cubh48aLNsosXLybqhhXP29vb5nVAQABZsmTh3LlznDhxgqNHj1KjRg3r+qJFi3LlypUUnctRDhw4QNu2bXn//feV/BERyQCc96suERERcRoJx/Rx5u5dj6JQoUIcOXKEfPnyUbBgQQoWLMiuXbtYtGgRAAsWLODvv//mhRdeYMqUKYwdO5b169c/9Lj58+fHzc3NZgDjK1eucOzYMZsqH7AMjnzt2jWOHTtmXbZ///77HjtLlizWWO99JCUkJISdO3daE0tms5m//vrLpgopXmRkJBUrVmTbtm3WZefOnePKlSsULlyYPXv20LdvX27fvm1dv2/fPgoXLvzI50oP4pM/JUqU4Ouvv8ZkMhEbG+vosERE5BEp6SMiIiIZnm2lj25/kiMsLIzbt28zfPhwDh06xJYtWxgzZox1ivKzZ88yatQodu3axdGjR1m3bh0lSpR46HF9fX156aWXeP/999m+fTsREREMGDCA3LlzU61aNZttixQpQtWqVRkyZAgRERFs3LiRxYsX2+09NmjQgOvXrzNmzBgOHjzImDFjuHXrlrVa6Pbt21y4cAEAPz8/ypcvz9ixY9mzZw9///03ffv2pUaNGgQFBVG7dm38/f0ZPnw4R44cYdWqVcydO5cePXok61zpVcLkz9KlS5OV/Nm/fz/Xrl17YIJORETShu56REREJMOLM6nS51H5+fkxZ84cjh49SvPmzRk2bBht2rShW7dugGVWrXLlyllnqYqKimLChAnJOvY777zDs88+S+/evXnllVfw9PRkwYIFiQY6Bpg8eTJZs2aldevWTJo0iXbt2tn1Pc6aNYsdO3bQokULdu/ezezZs/Hx8QHg+++/p3r16tbtP/zwQ0qUKEHXrl1p164defPmtXZn8/X1Ze7cuZw/f54WLVowefJkhgwZQp06dZJ1rqQYjUZu3LiRZo8///zzvrEcOHCANm3aJKvyx9/fn0yZMlnHchIREccxmO/tKO0Eatasyblz58iVKxc//fQTPPMMRERA5sxw9aqjwxMRESeUqG2Sx5bwms76ajUNp/wMwCuV8jO2RbCDoxN5uLVr19KoUSNHh5GkoKAgjfkj8ojU1osjqNJHREREMjxN2S5iXxrzR0TkyaDZu0RERCTDSziQszNP2S5ibzExMdy6dctmlrVJkyZx/fp1MmXKxNtvv+3A6EREREkfERERyfA0ZbuIfRUqVIghQ4bQoUMHzGYzrq6uuLq6Apakz6lTp8ibN6+SPiIiDqakj4iIiGR4scaE3btU6SNPhueff57z58+n2flWrVrF66+//sBt7k32uLnpzwkRkfRMv6VFREQkw0s4e5cqfeRJ4eHhQY4cOdLsfAlnKrtXYGAgQ4cOVbJHROQJo9/WIiIikuHFaSBnkRRRskdE5Mmm39oiIiKS4cUZE47po+5dIg+jZI+ISMag394iIiKS4RkTdO9SpY/I/SnZIyKSsei3uIiIiGR4CQdydlPSRyRJgYGB/Pfff0r2iIhkIPptLiIiIhme7ZTt6t4lkhQXFxcle0REMhjd9YiIiEiGF2tU9y6Rh1HCR0Qk49FvdhEREcnw4mwqfZT0EUlN5cqVI3/+/Gk63byIiCRNSR8RERHJ8GynbFehs0hq+u677xwdgoiI3KG7HhEREcnw4hJ071Klj4iIiDgLJX1EREQkw0s4kLObKn1ERETESeiuR0RERDK8hFO2ayBnERERcRYOT/ps3bqVli1bEhISQmhoKPPmzcNsNj9wn9WrV9O4cWOCg4Np2LAhK1asSKNoRUREJCUc3d6re5dI2gkLC6Nq1aqEhYU5OhQREafn0KTPrl276N69O4ULFyY8PJymTZsyYcIE5syZc9991q1bR//+/alWrRrTp0+nUqVKDBo0iDVr1qRh5CIiIpJc6aG9tx3IWUkfkdT0119/sW3bNv766y9HhyIi4vQcOntXeHg4zzzzDBMmTACgZs2axMXFMXPmTNq3b4+Xl1eifSZNmkSDBg0YMmQIADVq1ODatWtMmTKFxo0bp2n8IiIi8nDpob2PMyWs9HF4obOIiIhImnDYXU9MTAzbt2+nbt26Nsvr16/PzZs32bFjR6J9Tp48ydGjR5Pc59ixYxw9ejQ1QxYREZFHlF7ae1X6iIiIiDNyWNLnxIkTxMbGEhgYaLO8YMGCABw5ciTRPocOHQJ4pH1ERETEcdJLex+XYCBnjekjIiIizsJh3btu3LgBgJ+fn81yX19fACIjIxPtE7/sUfYBy7eMMTEx1teJBo6MLytPorxcREREUi69tPduCRI9Ph4O7d0uIiIikmYcdtdjStC3PikuLomLkFKyD8CsWbOYNm3a/Xfs2xeGDoV+/R54fBEREXk06aW9f6FsXjb8fY6g3P48ndv/gccXERERySgclvTx97fccN28edNm+f2+3UvpPgDdunWjY8eO1tcNGzbk/Pnzdzdo397yEBEREbtKL+3907kzsbl/7RS8AxEREZEnl8PG9ClQoACurq4cO3bMZvnx48cBKFKkSKJ9ChUqBJBon/jXSe0D4OHhgZ+fn/VhMKgvv4iISFpQey8iIiLiOA6r9PH09KRChQps2LCB119/3Xpjtm7dOvz9/QkODk60T8GCBcmXLx/r1q2jYcOG1uXr168nMDCQfPnyJevcly5dAuDChQvUrFnTDu9GRETk8Vy4cAG420ZlFGrvRZyPt7c3hQoVwtXVVf/3RBLIqG29pG8OHcmwR48edOzYkT59+tCyZUt27tzJvHnz6NevH97e3kRGRnLw4EEKFChAtmzZAOjVqxeDBw8mS5YshIaGsmnTJtauXcvkyZOTfd74sQJMJhPnzp1LlfcmIiKSEg8bz+ZJpPZexLm4uLhYx97S/z2RxDJiWy/pl8GcaCqrtLVhwwamTp3KkSNHyJUrF23atKFTp04AbN++nfbt2zN27FhatGhh3efLL79k/vz5nDlzhvz589O1a1eaN2+e7HOGhIQQExODi4sLAQEBgGWGj/Pnz5MzZ06Vgz8GXUf70bW0H11L+9G1tJ97r+WlS5cwmUx4eHiwe/duR4dnd+mhvdfn1350Le1H19I+dB3tR9fSfpytrZf0yeFJn/QiMjKS8uXLs2PHjvsOECkPp+toP7qW9qNraT+6lvaja5n2dM3tR9fSfnQt7UPX0X50Le1H11LSA4cN5CwiIiIiIiIiIqlHSR8RERERERERkQxISZ87PDw8eOONN/Dw8HB0KE80XUf70bW0H11L+9G1tB9dy7Sna24/upb2o2tpH7qO9qNraT+6lpIeaEwfEREREREREZEMSJU+IiIiIiIiIiIZkJI+IiIiIiIiIiIZkJI+IiIiIiIiIiIZkNMkfbZu3UrLli0JCQkhNDSUefPm8bDhjFavXk3jxo0JDg6mYcOGrFixIo2iTd8e9VrGxMQwc+ZMGjRoQJkyZahfvz7Tpk0jJiYmDaNOn1LyuYwXFxfHiy++SLt27VI5yvQvJdfxxx9/5MUXXyQ4OJiaNWsyevRooqKi0iji9OtRr2VcXByzZ8+mXr16lClThmbNmvH999+nYcTp39mzZ6lQoQLbt29/6LZqdx6P2nr7UVtvP2rr7Uftvf2ovbc/tfeSXjlF0mfXrl10796dwoULEx4eTtOmTZkwYQJz5sy57z7r1q2jf//+VKtWjenTp1OpUiUGDRrEmjVr0jDy9Ccl13L06NHMnDmTFi1aMGPGDFq2bMmcOXN477330i7wdCgl1zKh2bNns3fv3lSOMv1LyXXcvHkzPXr0oFixYsyaNYuuXbuyfPly3n333TSMPP1JybUMDw9n8uTJhIWFMWPGDMqXL0/fvn1Zt25dGkaefp05c4ZOnTpx48aNh26rdufxqK23H7X19qO23n7U3tuP2nv7U3sv6ZrZCXTq1Mn84osv2iwbP368uWzZsuZbt24luU+9evXMffr0sVnWp08fc926dVMrzCfCo17Ly5cvm4OCgsxz5syxWT5r1ixz8eLFzZcuXUrVeNOzlHwu4+3fv98cHBxsrlatmrlt27apGWa6l5LrWKdOnUT/vxcsWGB+/vnnzVFRUakVarqXkmtZrVo1c//+/W2Wvfzyy07/uTQajeZvvvnGXKlSJXOlSpXMxYsXN2/btu2B+6jdeTxq6+1Hbb39qK23H7X39qP23n7U3suTIMNX+sTExLB9+3bq1q1rs7x+/frcvHmTHTt2JNrn5MmTHD16NMl9jh07xtGjR1Mz5HQrJdcyMjKS1q1bExoaarO8cOHCAJw4cSL1Ak7HUnItE+47cOBA2rVrR6FChVI71HQtJdfxn3/+4fjx47Rt29Zm+WuvvcbGjRvx9vZO1ZjTq5R+JmNiYvDz87NZliVLFq5evZpaoT4RDhw4wIgRI2jevDnjx49/6PZqdx6P2nr7UVtvP2rr7Uftvf2ovbcvtffyJMjwSZ8TJ04QGxtLYGCgzfKCBQsCcOTIkUT7HDp0COCR9nEGKbmW+fPn57333rPe+MXbtGkT7u7uiY7lLFJyLeNNnz6duLg4evfunZohPhFSch33798PgKenJ926dSM4OJhKlSoxZswYpx57IqWfyfbt27Ny5Up++uknIiMj+e677/j5559p1qxZaoecrj311FNs2LCBwYMH4+Xl9dDt1e48HrX19qO23n7U1tuP2nv7UXtvX2rv5Ung5ugAUlt8v8p7M9O+vr6A5dupe8Uve5R9nEFKrmVSNmzYwIoVK2jbti2ZM2e2b5BPiJReyz179jB//nyWLFmCh4dH6gb5BEjJdbx8+TIAb7zxBk2aNKFjx47s3buX8PBwLl++zEcffZTKUadPKf1MdujQgV27dtGlSxfrspYtW9K5c+dUivTJkCVLlkfaXu3O41Fbbz9q6+1Hbb39qL23H7X39qX2Xp4EGT7pYzKZHrjexSVxsVNK9nEG9rgu69evp1+/fpQvX54BAwbYK7QnTkquZXR0NIMGDeK1114jODg4tUJ7oqTkOsbGxgJQt25d62ewSpUqmM1mPvroI9544w2nLKVPybWMiYmhTZs2XLhwgZEjR1K4cGF27tzJjBkz8PHxYdiwYakVboajdufxqK23H7X19qO23n7U3tuP2nvHUtsjjpDhP1X+/v4A3Lx502b5/bKsKd3HGTzudVmwYAF9+vShXLlyzJo1C09Pz9QJ9AmQkmv58ccfYzKZ6NmzJ3FxccTFxWE2mzGbzdbnziYl1zH+m5TatWvbLK9RowZwtxzc2aTkWq5bt46IiAgmTpxI69atqVSpEt26dWPAgAEsWrSIf//9N/UDzyDU7jwetfX2o7beftTW24/ae/tRe+9YanvEETJ80qdAgQK4urpy7Ngxm+XHjx8HoEiRIon2ic/637tP/Ouk9nEGKbmWAGazmdGjRzN27FgaNWrEnDlznP4XWkqu5bp16zhy5Ahly5alZMmSlCxZkj/++IM//viDkiVLsmLFijSJPT1JyXWM70N9b3/++G8EnfUPlJRcy9OnTwNQrlw5m+UVK1YE4ODBg6kRaoakdufxqK23H7X19qO23n7U3tuP2nvHUtsjjpDhkz6enp5UqFCBDRs22Hw7sm7dOvz9/ZMsnS1YsCD58uVj3bp1NsvXr19PYGAg+fLlS/W406OUXEuASZMmsWjRIjp27MjEiRPVP52UXcsZM2awbNkym0f8DeGyZct47rnn0vItpAspuY4VKlTAx8eHNWvW2CzfvHkzbm5ulC1bNtXjTo9Sci3jB239888/bZb/9ddfAE77uzIl1O48HrX19qO23n7U1tuP2nv7UXvvWGp7xBEy/Jg+AD169KBjx4706dOHli1bsnPnTubNm0e/fv3w9vYmMjKSgwcPUqBAAbJlywZAr169GDx4MFmyZCE0NJRNmzaxdu1aJk+e7OB341iPei3379/PnDlzKF26NA0aNGD37t02xytatKjTfhP4qNcyKCgo0THiS5dLly6d1uGnG496HX19fenduzfjxo0jU6ZM1KtXj7/++ou5c+fSvn176+8AZ/So1zI0NJSQkBAGDBjAm2++SeHChdmzZw8zZswgNDRU41E8gNod+1Nbbz9q6+1Hbb39qL23H7X3aUdtj6QLZiexfv16c5MmTcwlS5Y0h4aGmufNm2ddt23bNnPx4sXN33zzjc0+X3zxhblu3brmUqVKmRs2bGhesWJFGkedPj3Ktfz444/NxYsXv+9j27Ztjnob6UJKPpcJtW3b1ty2bdu0CDVdS8l1XLZsmblx48bmkiVLmp977jnzzJkzzUajMa1DT3ce9VreuHHDPGrUKHO1atWsvytnzZpljo6OdkT46VL8dUv4+07tTupQW28/auvtR229/ai9tx+19/an9l7SK4PZ7KQjwomIiIiIiIiIZGAZfkwfERERERERERFnpKSPiIiIiIiIiEgGpKSPiIiIiIiIiEgGpKSPiIiIiIiIiEgGpKSPiIiIiIiIiEgGpKSPiIiIiIiIiEgGpKSPiIiIiIiIiEgGpKSPiIiIiIiIiEgGpKSPyBMiJiaGJk2asH379sc+1sKFC2nUqBGlSpWiWrVqDBkyhAsXLtghygcLDw+nXbt2Nq/Lly9PhQoVWLhwIaGhoQ89xvLly222++233zh06FCqxCsiIpKeDBo0iKCgoPs+QkNDGTRoUJrFktJznTx5kqCgIE6ePJnk+nvbehERSTklfUSeANHR0bz99tv8999/j32shQsXMm/ePPr3788PP/xAeHg4R48epXPnzphMJjtEe3+dOnUiPDwcgGvXrjFt2jTeeecdvv32W15++WWWLVv20GM0atTIZrsOHTpw8eLFVItZREQkvRg6dChbt25l69atDBkyhNy5c1tfb926lbJlyzo6RBERSWfcHB2AiDzYwYMH6devH2az2S7HW7FiBR07drR+g5YvXz4mTZpErVq12LNnD2XKlLHLeZLi6+trfR4ZGQlA1apVyZs3LwBeXl4PPYaXl1eythMREclo/P398ff3tz53dXUlR44c1vXu7u6OCk1ERNIpVfqIpHO///47lStX5quvvrLL8QwGA3/++ScxMTHWZblz5+b777/n6aefBqBdu3ZMmzaNV155hZCQEF599VWbLlRnzpyhe/fuhISEEBoayrRp0zAajdb1P/30Ey+88AIhISGEhYXx22+/AXe7d508edKadKpTpw6DBg1KVMq9Z88e6/nr16/PmjVrANuS7/if7du3Jzw8nHr16vHpp5/avN+mTZuydOlSu1w7ERGR9C4yMpK+ffsSEhJC7dq1WbVqlXVdaGgoEyZMoHr16jRv3hyz2cy///5Lu3btCA4Opn79+ixZssS6/fXr13nzzTepUKECFStWpH///tYvbR52rujoaCZMmECtWrUoU6YM3bt358yZM0nGfO7cOTp37kyZMmV44YUXOH78eCpcGRER56Skj0g69+qrrzJkyBC8vb3tcrz27duzYcMGatWqxeDBg/n222+5evUqRYoUsamgmTVrFvXr12f58uXkypWLrl27EhMTg9ls5o033iAgIIAVK1YwduxYVq1axcyZMwH477//6NGjB3Xr1uXbb7+lSZMm9OzZ02bMoKeeesqaiFm6dClDhw61ifHSpUt06tSJZ555hhUrVtCtWzfeeecdIiIibLaL7+YVHh5Op06daNy4MevWrbOuP3ToEEeOHKFevXp2uXYiIiLp3YYNGyhZsiSrV6+mYcOGDBkyhBs3bljXr1q1innz5jFu3Diio6Pp0qUL5cuX57vvvuOdd97hk08+YeXKlQBMnTqVCxcu8MUXX7Bw4UIiIiL45JNPknWuESNGsGHDBj788EO+/PJL4uLi6NmzZ5Jdyfv06YPJZGLp0qV06dKFzz77LHUvkoiIE1H3LhEn07x5c7Jmzcpnn33GqlWrWL58OR4eHvTs2ZMePXpYt6tZsyYdOnQA4P3336dGjRr88ssveHl5cfr0aZYuXYqLiwuFCxfmnXfeYfDgwfTq1Ytly5ZRrlw5evbsCUDXrl2Jiori+vXr1mO7urqSLVs2ALJly2YtVY+3Zs0aMmfOzLBhw6znuHbtGrdv37bZLv4YmTNnxtfXlyZNmjBjxgzOnj1L7ty5Wbt2LdWrVydz5sx2v44iIiLpUdmyZencuTMAPXv2ZP78+Rw+fJiQkBAAwsLCCAoKAixfvAQEBPDWW28BEBgYyKlTp1i4cCHNmzfn1KlT+Pr6ki9fPry9vZkyZUqyzhUYGMi3337LnDlzqFKlCgATJ06kdu3a/PLLLxQqVMh6jP/++4+dO3fyv//9jzx58lCsWDH27dvHDz/8kKrXSUTEWSjpI5KBNG7cmNOnTwOQJ08ea5eoe9WqVYtatWoRGRnJtm3b+PLLL/n4448pWrQodevWBaBcuXLW7f38/ChUqBCHDh3Cy8uLq1evUr58eet6k8nE7du3uXLlCkeOHKFkyZI254u/mUyuI0eOUKJECVxc7hYjduzYEYDDhw/fd78iRYoQFBTEDz/8QIcOHVi7di3dunV7pHOLiIg8yfLnz299Hv+lSnR0tHVZ/Dh6YGlTIyIibAaANhqNuLq6Apbq4J49e1K1alWqVq1K/fr1adq06UPPdfToUUwmkzXRBJAlSxbrvUTCpM/BgwfJkiULefLksS4rXbq0kj4iInaipI9IBjJ79mzi4uIAcHNL/N/7zJkzzJw5k6FDh+Lh4YGfnx916tTh+eefp3Xr1vz666/WpM+9+xuNRlxcXIiLi6Nw4cI25d3x/P39kzzvo3qcYzRu3Jj169dTo0YNTp48yfPPP//Y8YiIiDwp4hM2CSWcDMLT09P6PC4ujqpVqzJ8+PAkj1W1alW2bNnCpk2b+PHHHxk+fDhbt25l4sSJDzxXwnMkZDQak+zede9kFRqQWkTEfjSmj0gGkjdvXgoWLEjBggVtvsmL5+HhwdKlS/npp59slhsMBvz8/KzdpQCb8XNu3LjB8ePHCQoKolChQpw+fZps2bJZz3Xy5EmmTp2KwWCgYMGCicbead269X2rjpISGBjIgQMHbG4C33rrLebOnfvQfZs0acLu3btZuXIltWrVspkxTERERO4qVKgQR44cIV++fNY2fdeuXSxatAiABQsW8Pfff/PCCy8wZcoUxo4dy/r16x963Pz58+Pm5sauXbusy65cucKxY8dsqnwAihcvzrVr1zh27Jh12f79++3zBkVEREkfEWcSEBBA69atGTJkCF988QXHjx/n77//ZsqUKezdu5eWLVtat121ahUrV67k0KFDDB06lDx58lC5cmWqV69O3rx5GTBgAAcOHODPP//k3XffxdvbG1dXV1555RX+/PNPPv30U44dO8asWbP477//qFChQrLjbNq0KVevXmX8+PEcPXqU5cuXs2nTJqpVq5ZoWx8fH/777z/rwJF58uQhODiYzz77jMaNGz/+RRMREcmgwsLCuH37NsOHD+fQoUNs2bKFMWPGEBAQAMDZs2cZNWoUu3bt4ujRo6xbt44SJUo89Li+vr689NJLvP/++2zfvp2IiAgGDBhA7ty5E7XlRYoUoWrVqgwZMoSIiAg2btzI4sWLU+X9iog4IyV9RJzMkCFD6NatG59//jlNmzalffv27N+/n8WLF9v0p2/atClffvklLVq04ObNm8yZMwc3NzdcXV2ZMWMGJpOJl19+mTfffJNatWoxbNgwAAoUKEB4eDjffPMNTZo0Yd26dcycOZNcuXIlO8ZMmTIxa9Ys/vzzT5o0acKcOXP46KOPeOaZZxJt265dO8aPH094eLh1WaNGjXBzc6N27dopv1AiIiIZnJ+fH3PmzOHo0aM0b96cYcOG0aZNG+t4eH369KFcuXL06NGDZs2aERUVxYQJE5J17HfeeYdnn32W3r1788orr+Dp6cmCBQvw8PBItO3kyZPJmjUrrVu3ZtKkSbRr186u71NExJkZzPd2ohURp9euXTsqVarEm2++6ehQUmTy5MmcPXuWDz/80NGhiIiIiIiIOIwGchaRDCMiIoL9+/fz+eefM2PGDEeHIyIiIiIi4lDq3iUiGca+ffsYOXIkL7300iONISQiIiIiIpIRqXuXiIiIiIiIiEgGpEofEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfEREREREREZEMSEkfcUrt2rUjKCjI5lGqVClq167NyJEjuXbtWprEMWjQIEJDQ1Nt+8eV1HV6+umnKVeuHC1atODbb79Ns1gSWr58OUFBQZw8edIaZ7t27R66X3R0NAsWLKBly5aUL1+eSpUq0bp1a1auXInZbE7tsEVEnEpatbVnz56lTZs2lC5dmqpVq3Lr1i27HNdegoKCCA8Pf+A2UVFRhIeH06hRI4KDgylfvjytW7dm6dKlap+SEBoamuizde8j/pon5/qnJnvdu23fvp2goCC2b9/+wO0c/X5FJP1xc3QAIo5SokQJRowYYX0dGxvL33//zaRJk9i/fz9ffPEFBoMhVWPo2bMn7du3T7Xt7eHe62Q0Gjl79iwLFixg4MCBZMmShVq1aqVpTClx8eJFOnfuzJkzZ2jXrh3BwcGYTCb+97//MWjQIP7880/ef//9VP83FxFxJmnR1n722Wfs2rWLCRMmkCtXLry9vR837DRlNpvp3r07hw8fpmvXrhQrVozo6Gi2bt3Ku+++y3///ceQIUMcHWa6Mm3aNGJiYqyv33jjDUqUKEHPnj2ty3Lnzu2I0ERE0h0lfcRp+fn5UaZMGZtlFStW5ObNm0ydOpXdu3cnWm9vBQoUSNXt7SGp6wRQs2ZNqlatyvLly5+IpM8777zD2bNn+eqrrwgMDLQur127Nnny5GHSpEk899xzPP/8844LUkQkg0mLtvbq1avkzJmTRo0aPdZxHGXHjh1s376d+fPnU61aNevy2rVr4+LiwuLFi+nSpQs5cuRwYJTpS4kSJWxee3h4kC1btlS/bxMReRKpe5fIPUqVKgXA6dOnAUt5ev/+/enduzdlypShY8eOgKWr0Pjx46lVqxalSpWiadOmfP/99zbHMpvNLFiwgIYNGxIcHEzdunWZN2+etVT73pLfffv28dprr1G+fHnKli1Lhw4d2LVrl3X9vdsbjUaWLFlC06ZNCQ4Opnbt2kycOJHo6GibfTp06MA333xD/fr1KVWqFM2aNeOnn356rOvk6emJh4eHzTe0JpOJ2bNnU7duXUqVKkX9+vVZtGhRon1XrlzJCy+8QEhICLVr1+ajjz6y+cZu48aNvPrqq5QtW5ZSpUrRoEEDlixZkuJY9+/fz9atW3n99ddtEj7xOnToQJs2bfDx8QEgPDycoKCgRNslLJk+efIkQUFBfPrppzRo0ICQkBBmzJhBUFAQ//vf/xKdPygoiA0bNgDJ++yIiGRk9mprQ0NDWb58OadPn7b5HX316lWGDx/Os88+S+nSpXn55Zf57bffbGIICgpi2rRptGjRguDgYKZNm8by5cspUaIES5cupVq1alSqVImDBw8ClrapRYsWlC5dmmrVqjF69GiioqJsjvn777/TqlUrQkJCqF+/Pr/++utDr8WFCxcASxt6r1dffZW+ffvatLWHDx/mjTfeoFKlSlSsWJFu3bpx6NAh6/obN24wduxY6tSpQ+nSpWnSpAnLli2zOW5oaCgffPABr732GsHBwQwdOjTZ1+2XX37h5ZdfpmzZslSsWJEePXrYnP9e9evXp3fv3omWN2vWjB49egBw/PhxunfvTuXKlQkJCaFVq1Zs2bLlYZcu2SIjIxk6dCiVKlWibNmy9O7dm4sXL1rXP8693sPu3eItX76c+vXrU7p0acLCwhK9v6NHj9K7d2+qVatGmTJlaNeuHTt27Hjg+0rO52316tWEhYURHBxMlSpV6N+/P+fOnUvupRORDECVPiL3OHLkCAD58+e3Llu7di1hYWHMmDEDk8mE2WymV69e/PXXX/Tu3ZsiRYqwYcMG+vbtS0xMDM2bNwdg/PjxfPbZZ3Ts2JFq1aqxd+9eJk6cSFxcHN26dbM5b2RkJJ07d6ZKlSqEh4cTExPDjBkzeP311/nxxx/x9/dPFOvw4cP59ttv6dKlCxUqVOCff/5h+vTp7N+/n7lz51pvEvft28f58+fp3bs3fn5+TJkyhTfffJOffvqJzJkzP/B6mM1m4uLirK+NRiOnTp1i+vTp3Lx5k2bNmlnXvffeeyxfvpxu3bpRtmxZ/vjjDz744AOuX79Or169AFiyZAmjRo3ipZde4u233+bEiROMHz+ea9euMWrUKH788Ud69epF+/btefPNN7l9+zaff/45o0aNolSpUoSEhDzCv6bFzz//DHDfPvWenp4MHz78kY8LlgTR0KFD8fPzIyQkhOXLl7NmzRqee+456zarV6+2doNL7mdHRCQjs1dbO23aND7++GP++ecfpk2bRu7cuYmOjua1117j4sWL9O3bl5w5c/LNN9/QuXNn5s6dS9WqVa3nnDlzJv369aNQoULkzZuXvXv3YjQamT9/PmPGjOHKlSsUKVKEVatW0b9/f5o2bcpbb73FqVOnmDx5MgcPHuTTTz/FYDDw999/06lTJ6pUqcLUqVM5efIkb7/99kOvRaVKlfDx8eHtt9/m5ZdfpmbNmoSEhODl5UVgYCBdunSxbnvu3DlatWpFrly5eO+99/Dx8SE8PJzXXnuN1atX4+XlxauvvsqlS5fo3bs3efPmZePGjQwdOpSLFy/SvXt367GWLFlCx44d6dKlC76+vsm6bidOnKBnz560bNmSt99+m+vXrzNp0iS6du3Khg0bcHFJ/H1yWFgYs2fPJjIyEj8/PwAOHTpEREQEPXr0wGQy0a1bN3LmzMn48eNxc3Nj4cKF9OjRg7Vr11KwYMFH/4DdY+HChTRt2pQpU6Zw6NAhxo0bB8DUqVOt26Tk85fce7czZ84we/Zs+vTpg4+PD5MnT6Z3795s3ryZgIAADh48yMsvv0xgYCDDhg3D3d2dhQsX8tprrzF//nwqVaqU6D0l5/O2Y8cOBg4cSM+ePalYsSJnz55lwoQJ9OvXj8WLFz/2dRWRJ4OSPuK07k1mXLt2jd9//50ZM2ZYK0ziubu7M3LkSDw8PADLt1w///wzkydPtpaT16hRg1u3bjFx4kSaNGlCVFQUCxcupG3btgwYMACAZ599lgsXLvDHH38kSvocPHiQK1eu0L59e8qVKwdA4cKF+eqrr7h582aipM/BgwdZtmwZ/fr1o2vXrgBUq1aNnDlzMnDgQH766Sdrt6sbN26wfPlya/cwHx8f2rZty7Zt26hfv/4Dr9Mff/xByZIlbZYZDAaKFy/OlClTrMmNI0eO8PXXX/P2229b46levToGg4FZs2bx6quvkjlzZqZPn06dOnUYPXq09Xi3bt1izZo1xMbGcvDgQV544QXrt44AZcuWpXLlymzfvj1FSZ8zZ84AkC9fvkfe92EaNmxIy5Ytra/DwsKYP38+t2/fxsvLC7PZzPfff0+DBg3w8PBI1mfHzU2/mkUkY0jttrZEiRJky5YNDw8Pa9eer7/+moiICL7++mtrm1GzZk3atWvHxIkT+eabb6znrFChgrWqA2Dv3r0AdO/endq1a1vfw8SJE6lRowYTJ060bhsYGEiHDh3YsmULtWvXZtasWQQEBDBjxgzc3d0ByJo1K3379n3gNQoICGDOnDkMGjSIuXPnMnfuXNzd3SlTpgxhYWG0bNkSV1dXABYsWEBMTAyffvqptbvX008/zSuvvMLu3bs5deoU//77L19++SVly5a1XrO4uDg++eQTWrduTZYsWQDIkycP/fv3t8aRnOu2Z88ebt++Tbdu3ciVKxdgGTtn06ZNREVFWZM6CYWFhREeHs7GjRutX2ysXr2aTJkyERoayqVLlzh8+DA9e/a03rfEV14lrAJ+HKVLl2b8+PEAVK1ald27dyeqtEnJ5y+5924mk4np06dTpEgRwPJlU3xF0PPPP8+0adPw8PBg4cKF1mtYu3ZtmjRpwvjx4xNVagHJ+rzt2LEDLy8vunbtan1fWbJkYe/evZjNZo1jKOIk1L1LnFZ8MiP+8eyzz/L2229TqlQpPvroI5uGsHDhwtbGEuC3337DYDBQq1Yt4uLirI/Q0FAuXLjAf//9x65du4iLi6NevXo25x02bBhz585NFE+xYsXIli0b3bt3Z/jw4WzYsIHs2bMzYMCAJAcj/P333wFo3LixzfLGjRvj6upqM7tDtmzZbMYDij9e/AwnCd9DXFycTYl5yZIlWbZsGcuWLeOTTz6hePHiBAYG8vHHH9OgQQPrdtu2bcNsNhMaGpromkRHR7Njxw6OHDnCpUuXqFu3rk3Mr7/+OsuXL8fd3Z3OnTszbtw4bt68yb59+/j++++ZNWsWQIpv/uJvlo1GY4r2f5BnnnnG5nVYWBhRUVHWLl5//fUXp0+ftlZEJeezIyKSUaR2W5uU3377jRw5clCyZEnrPkajkeeee459+/bZzBp27+/wpJYfPnyYs2fPJmrfKlasiJ+fH7/88gtg+QO7Ro0a1j/AAerVq2dtgx6kQoUKrF+/nsWLF9O9e3dKly7Nrl27ePfdd2nXrh23b9+2nqNMmTI24/vkzp2b//3vf9SqVYvff/+dvHnzWhM+8cLCwoiOjmb37t33fe/JuW4hISF4enry4osvMmbMGH7++Weefvpp+vbtm2TCByzVXOXKlbPpFrVmzRrrlyHZs2enaNGivPvuu7zzzjusWrUKk8nE4MGDKVas2EOvXXKUL1/e5nW+fPm4fv26zbKUfP6Se++WNWtWa8In/vxg+VIOLPd0zz33nM01dHNzo3Hjxuzbt4+bN28mek/J+bxVrFiRW7du0aRJEz766CP+/PNPqlevzhtvvKGEj4gT0dfJ4rRKlizJyJEjAUvliqenJ0899VSSNy2+vr42r69evYrZbLZ+q3Ov8+fPW28qs2XLlqx4fH19WbJkCTNmzGDt2rV89dVXeHl50axZM4YNG2ZzIwJYj3/vwI5ubm5kzZrVeiMBJJrJJL6hj0/u3FvJ88Ybb/Dmm29a4ypdurR1XUhICGFhYXTq1Inly5db39/Vq1eBxEmoeOfOnSNr1qyA5VvN+7l8+TIjRoxg48aNGAwGChYsSIUKFQBSPG1t3rx5AcvYEUWLFr1vfDlz5nzkm6D4cYDiFSxYkLJly7JmzRoaNmzImjVrKFCggPWzkpzPzv3+CBERedKkdlub1O/Lq1evcuHChURtW7wLFy5Yuzbf+zs8XsLl8e3byJEjre/l3jjA0i7Ht3Px4tvk5HBxcaFixYpUrFjRerzJkyfzxRdfsGzZMtq2bcvVq1cfWLV67dq1JAd8zp49O4BNouPe956c61a0aFEWL17M7NmzWbZsGQsXLiRTpky8+uqrvPXWW/dtQ5s1a8b777/PlStXOHnyJMeOHeODDz4ALJ+L+fPnM2PGDDZs2MDKlStxd3enTp06jBw58qHd0JPj3vfq4uKS6J4ipZ+/5Ny73Xv+e+/Drl27Zv03Sih79uyYzWYiIyMTrUvO561s2bLMnj2bBQsW8OmnnzJ79myyZ89O9+7dadeuXZLvS0QyHiV9xGndm8x4FP7+/vj4+LBw4cIk1xcsWJC//voLsCQxChcubF13+vRpjh8/nuhbJ7B8yzRhwgSMRiN79uzh22+/5YsvvqBAgQJ07tzZZtv4m6ALFy5YkxpgmQ73ypUryb7JBBKVDefMmfO+22bPnp3hw4fTp08fxowZw0cffQRApkyZAMvUuffeOIGljPzy5csA1p/xrly5wj///EPZsmXp378/hw8fZsGCBZQtWxYPDw9u3brF119/nez3c6/q1asDsGXLliSTPnFxcTRr1oxy5crxySefWG/GjEaj9RuzpL5lu5+wsDDGjh3LjRs3+OGHH3jllVes65Lz2RERyShSu629336BgYE2XbESetSuvvHt28CBA5McWyW+Pc6SJYvN4MBg+bIiYWVRUt566y2uXr3KggULEh13+PDhfP/999bBpP39/RO1oWCpSsmXLx+ZM2fm2LFjidbHDxb9oHuD5F63hF2vduzYwVdffcXMmTN5+umnadiwYZL7NmzYkNGjR7Nx40YOHz5M3rx5be6D4scoGjFiBBEREfzwww/MmTOHrFmzMmLEiPvGnJqS+/l7lHu3+8mcOXOizw7Y/rsdPXrUZl1yP281atSwdkvbtm0bCxcuZPTo0YSEhBAcHJys+ETkyabuXSIpUKlSJaKiojCbzZQuXdr6+Pfff5k+fTpxcXEEBwfj7u6eaCan+fPn8/bbbycq9/7hhx+oUqUKFy5cwNXVlbJly/Lee++RKVMm6+wm98YAlhLphNasWYPRaEwyqXQ/Cd9D6dKlrf3076dBgwbUqFGD1atXW7uZxVfjXLlyxeZYly9fZsqUKVy9epXChQuTNWvWRNfk22+/pWvXrsTGxrJjxw7q1atH5cqVrd+Qxc80ltTMJslRrFgxatasyZw5czhx4kSi9bNmzeLKlSuEhYUBWL+BPnv2rHWbh82gkVCjRo0wm81MmTKFS5cuWY8LyfvsiIhIyn9fVqpUiTNnzhAQEGCz3y+//MLcuXOT1d0qocKFCxMQEMDJkycTtZUfffQR//zzD2AZK+ann36ydp0Gy0QCsbGxDzx+wYIF2bZtW5IzPp0/f56oqCiKFy8OWNra3bt32yR+Ll26ROfOndmyZQsVK1bk1KlT7Ny50+Y43333He7u7g/8Iz85123BggU899xzxMTE4OHhQdWqVXn//fcBkrxXiZcpUyaee+45Nm3axLp16wgLC7N+wbJz506effZZ9uzZg8Fg4JlnnqFv374UL178gcdMbcn5/D3qvdv9VKxYkf/97382FT1Go5E1a9ZQunTpRNXekLzP24cffkjLli0xm814e3vz3HPP8c477wAP/vcSkYxFlT4iKVCrVi0qVqxIz5496dmzJ0WKFGHPnj1MnTqVGjVqWLs8tW/fngULFuDh4UGlSpXYvXs3X3zxBQMHDkw0w0W5cuUwmUz06tWLrl274uvry9q1a7lx40aicYEAihYtygsvvMDUqVO5desWFStWZP/+/UybNo3KlStTo0aNVL0GQ4YMISwsjNGjR7NixQqCgoIICwvj3Xff5dSpU5QqVYojR44wefJk8uXLR2BgIK6urrz55puMGjWKgIAAQkNDOXLkCFOnTqVNmzZkzpyZ4OBgVq1aRcmSJcmdOzd//fUXs2fPxmAw2NzYPKqRI0fy2muv8fLLL9O+fXtCQkK4efMmP/zwA2vWrKF169bWMYpq1arF2LFjGT58OK+//jpnzpxh+vTpSVYwJSV+pq7PP/+csmXL2nwbndzPjoiIs0vp78sWLVqwePFiOnbsSPfu3Xnqqaf49ddfmTNnDm3btrUZAyU5XF1d6du3L8OHD8fV1ZXnnnuO69ev88knn3Du3Dlrd6hevXqxceNGXn/9dTp37szly5f5+OOPH3q+Tp06sXHjRjp27Mirr75K5cqV8fb25t9//2X+/PkUK1aMFi1aANChQwdWrlxJ586d6datG+7u7syYMYPcuXPTtGlTPDw8+Pzzz+nVqxe9e/cmX758bN68mW+++YY33njDWrWU0utWpUoVJk6cSK9evWjbti2urq58+eWXeHh42MxamZSwsDB69+6N0Wi0mfmzRIkSeHl5MXDgQN58802yZ8/Or7/+yv79+2nfvn1y/5nsLjmfv0e9d7ufN954g59++on27dvTtWtX3N3dWbx4MSdOnEhyHEhI3uetSpUqfPrppwwaNIiwsDBiY2OZO3cuWbJkoUqVKo99jUTkyaCkj0gKuLi4MHv2bKZMmcKsWbO4dOkSuXLlomPHjtapyQEGDBhAQEAAX375JXPnziVfvny8++67tG7dOtExc+bMydy5c5kyZQpDhw7l1q1bFCtWjPDw8Ps2zGPGjKFgwYJ88803zJkzh5w5c9K+fXt69uyZ5LSp9lS4cGHatWvH/Pnz+eKLL2jbti1jx45l1qxZfPnll5w9e5aAgAAaNWrEW2+9Zf1mtU2bNvj4+DBv3jy++uorcufOTZcuXaxT0o4bN47333/f+s1hYGAgI0eO5LvvvuPPP/9Mcbx58uThq6++4rPPPmP16tXMnj0bDw8PChcuzEcffWSdmQOgUKFCfPjhh8yYMYOuXbtSpEgRm5iSo1mzZmzcuJGmTZvaLE/uZ0dExNml9Pelj48PS5Ys4aOPPmLChAncuHGDvHnz0q9fPzp16pSiWF566SV8fX2ZO3cuX331FT4+PpQrV46JEydap50PDAxk8eLFjBs3jr59+xIQEMA777xjnR78fjJnzsxXX33FnDlz2Lx5M1988QWxsbHkzZuXJk2a0LVrV7y8vAB46qmn+Pzzz5kwYQKDBg3Cw8ODypUrM3nyZGs3s0WLFvHRRx8xZcoUIiMjKVy4MGPGjOHFF198YBzJuW5PP/00M2fOZPr06bz99tsYjUZKlSrF/PnzbbqyJ6VWrVr4+/uTP39+ChUqZF3u6enJ/Pnz+eijjxgzZgzXr18nMDCQUaNGWZNdjpCcz19K7t2SUqxYMT7//HMmTZrE4MGDMRgMBAcHs3DhQmsl9b2S83mrVasWEydOZP78+dbBm8uXL8/ChQuts7iJSMZnMKd0ZFQREREREREREUm3NKaPiIiIiIiIiEgGpKSPiIiIiIiIiEgGpKSPiIiIiIiIiEgGpKSPiIiIiIiIiEgGpKSPiIiIiIiIiEgGlG6SPmfPnqVChQps3779oduuXr2axo0bExwcTMOGDVmxYkUaRCgiIiKPS+29iIiISNpxc3QAAGfOnOH111/nxo0bD9123bp19O/fn/bt21OjRg02btzIoEGD8PDwoHHjxsk6X0hICDExMbi4uBAQEPC44YuIiDy2S5cuYTKZ8PDwYPfu3Y4OJ1WovRcREWfmDG29pD8OTfqYTCZWrlzJhx9+mOx9Jk2aRIMGDRgyZAgANWrU4Nq1a0yZMiXZN4ExMTGYTCZMJhPnzp1LUewiIiKpISYmxtEh2J3aexERkbsyYlsv6ZdDkz4HDhxgxIgRvPrqqzz77LN07dr1gdufPHmSo0eP0rt3b5vl9evXZ+3atRw9epTAwMCHntfFxQWTyYSLiws5cuR4nLcgIiJiFxcuXLC2TRmN2nuRjOXMmTMYjUZcXV156qmnHB2OyBMjI7f1kn45NOnz1FNPsWHDBnLnzp2svv2HDh0CSHSjV7BgQQCOHDmSrJvAgIAAzp07R44cOfjpp5/g1CmYNw+uXXvk9yCSofn7Q1CQ5VG8OPj5OToikQyrZs2anDt3LkN2Q0oP7f2P33/HtWnv4uEXjW8xJYDSBc9MUPpFCCji6EjkEeXLl49Tp06RN29ey720iBMymcx88cdxjly4+cDtnsriTauK+fHzdMvQbb2kXw5N+mTJkuWRto+MjATA754/PH19fW3W3ysmJsamhM5sNttu0LMnfPfdI8Ui4pTy5oWnn76bCAoKsrzOnx/0jYWI3Ed6aO+vfjyEc4v/By5mijU9h5u36ZFiklSyZRw8EwbV34I8ZR0djYhIss3++TDj1kYka9sbt2N5q07xVI5IJGnpYiDn5DKZHnyDdr8yuVmzZjFt2rT77xgU9DhhiTiPU6csj02bbJd7e0OxYneTQAmTQv7+jolVRJ5YqdHex0bd2cdkIOaGG27eGk8hXTCb4J+VlkehWpbkT+HnwGBwcGAiIvd37NJNPt74b7K2NRigUHbfVI5I5P6eqKSP/50/Hm/etC2hu983gvG6detGx44dra8bNmzI+fPn724wfjy89hpcvWrfgEWedBcvQkQEHDhgeUREwOXLibe7dQv27LE87pUnj21VUPzzAgXA1TX134OIPHFSo713yfsMYElYm0JHQ6UQe4ctj8JshuO/wraZcPPOPdmRLZZH7mCo1gdKNAfXJ+pWVUScgNlsZuiKfdyOtXxB0apCfl6qkO++2+fK5EX+bD5pFZ5IIk9US1qoUCEAjh07RokSJazLjx07BkCRIkn3Cffw8MDDw8P62pDUt0clS9oxUpEMpFkz29cXL9omgeKfHzoEcXGJ9z992vL43/9sl3t6WsYJurerWFAQZMqUeu9HHMtkAqPx7iMuzvZnch5xcYmP87BHwu3v3bdCBXj2WUdfGUkgNdp7F5+737KafAtAgSp2jVlSoGBVqNILdn8Ov0yFK0csy8/ugW9eh83vQ1BjyF0acpeC7EHg5vHgY4rcw2w2c+lmDAfPR3L4wk3iTCbcXFxwczXg7mrA1cUFFwO4Ggy4uBhwMRhwdeHOT0Oi5QaD5bkByzYGg6WSw4ABFxfLz/jtXO8cw2C4u238viR47mIw4Op6d/t7t7WcQ9Vv6cWKnafYevAiAHkye/Fu0xL4eT5Rf1aLk3miPp0FCxYkX758rFu3joYNG1qXr1+/nsDAQPLlu3+GVUTsJHt2y6NaNdvlsbFw+HDSCaGLFxMfJzoa9u61PO6VO3fiyqCnn4aCBTNGdZDRaLlesbGWBEZSz+9dlvDn/Z4nXJaSR3xCJTnrk0rY3O9nwuf3jqmWXvz5J5Qv7+go5I7UaO9dfO5+y2qKirJLnGIH7l5QoROUew32fwdbP4YzuyzrrhyFbdPvbuviDjmevpsEyl0acpUCn2wOCFzSG7PZzNnrt/nvXCQHz0fy3/lIDp6/wcHzkVyJinV0eI/NklhKmGi6mzByiX8dv42LATcXFzxcDXi4ueDu6mJNJsUnphLuE38MV5c7iS4XF9xdDHh5uOLj7oqPhyteHq64u1iO4+ZyNxFm2d9yzIRxJUx0Ge68AVeDZV9XFwNurpYYvdxd8HRzxcvdBQ83F2tCznqeO8kuF5f7JNoM8Yk4y093VwNebq64uKROkuzyzRjeX/2P9fXoF0op4SPpXrr+hEZGRnLw4EEKFChAtmyWBr1Xr14MHjyYLFmyEBoayqZNm1i7di2TJ092cLQiTs7d/W6C5l6XLt1NACVMCh06ZElU3OvsWctjyxbb5Z6eULRo4oRQ8eKWdTExlmRSdHTi50k9HrQuqUds7P1/3vs84ePe5ek18eHMdu1S0seB0qK9d/FNUOlzU0mfdMfFFUq+YOnSdeQn+OVjOLTZdhtTLJzba3nsTrA8U767SaD4RFDWQppgIBUtXryY6OhoPD090/zcRpOZk1eiLMmdC5HWn4fORxIZnUTFcQZhNoMZMFnvIXQv8SAebi54ubng7eGKl7sr3u6Wn553kmDurgbc4n/GV365WBJPWX3cye7vSXY/y8Pfyw0/Tzd8PFwZvWa/NYnYOPgpQp/O5eB3KvJw6Trp8/fff9O+fXvGjh1LixYtAGjRogUxMTHMnz+fb775hvz58/Phhx/SqFEjB0crIvcVEGDpPnNvF5q4ODhyxLYqKD4hdOFC4uNER8Pff1se4hgGA7i5WSqu3Nxsnyf8+bBl9z5P6rW9Hi4uSS/7+WeYP9/RV1RIm/bettLnwdPrigMZDFC4luURecHS1evcPji7F87ug4v/gtlou8/1k5bHvz/cXebhB7lK3k0C5Q6GnM+Ah8bVsIfatWun+jli4kwcu3TTWrVjqdyJ5PCFSKLjkj/7Xq5MnhTL6U/RnH4UyemHn6crsUYzsUYTcUYzRpMZkzn+J9bn91tuMpstCRiz2ZqEMZvBZAYwYzLd2dZsxmQyY7yzL+aE21r2NSd4bTSD0WSynMMEZmy3NZltt4//yZ0Y7l0f/x5jjCZi4izHjT9n/LamDJw3iomzvO/rt1MnEZjJy40RTUs8fEORdCDdJH0qV67MgQMHHroMoHXr1rRu3TqtQhOR1OLmZpn1q1gxaNrUdt2VK0l3FTt40FI5k94YDODhYal4iv+ZnIeb28OXxz+PT7Ik9dzd3ZLMuN/r+IRKwtf3Jm3uXRa/bcKkTEb65jwuTkkfB3BUe2+T9FGlz5PBLwcUfd7yiBd7C87vt00EndsH0ddt942JhBPbLY94BhdLIqjeGEtSSdKN67dj2frfRf45ff1OkucGxy5FEfcIWYn82bwpmsOPYrksCZ74RyYv91SM/MkXnygyJkh2xZksCaNbMUZuxxqJirE8jCbzne1MxBrNdwqX45NItokqy7HvJqjMcCcJZibOaLKeIybORHSciduxRqLjLMvj18cZ7ybWsDlWgnMmSL6ZzBBntBzrVqyJ6Fgjt2KNd14brQMv28OQRs+Q09/LbscTSU3pJukjImIja1aoUsXySCguDo4eTdxNzGSydPHy9LQkXeKfJ3zt4ZH8R/z28UmcexM6CZfFJ1jkyfXRR+DjAy+/nKx/S7PZzKVLt4iMjMHPz4OAAG8NspnOufhqTJ8Mwd0b8pazPOKZzXD12N0k0Nk7XcCuHrfd12yyrFvcEl6cByXumahA0tTRizfZFHGeTfvP8fuRy8lK8Li6GCgY4EOxOwkdawVPDj+8PdQOp4R1XB8MuGfwS2gymYkxmqxVXrEmy884o2V5nMlEdKyJyzdjuBgZzcXIGC5FRhMZHcfNGCNR0XFExRipWCgbL1fI7+i3I5JsSvqIyJPFzc0yrk/RotC4saOjkSdZwlkb9++HV1+F4cNh0CBo186S1LvH1au3+eyzXYSH/86hQ1esy4sUycqbb1bitdfKkCWLvvlLj2zG9FHSJ2MxGCBroOXxTIKq0VtX4dzfd5NAJ/6AiwcsmjSCvgAAyZBJREFUYwMt7QBNp0C59o6J+Qn3448/Wsf0SW5XrzijiR3HrrA54jwb95/j0IX7d7P0cHOhcHZfm8ROsVx+BAb44uGWgSpOJU25uBjwcrGM7SPiTJT0ERER51S1Kqxfb0n0bNtmWXbwIHTuDCNHwoABlufe3gCsW3eQli2/JiqJWWAOH75C377rGDp0M9988zL16xdNy3ciyWDbvUtj+jgF7ywQWM3yADDGwaresGuJpernuzfh1hV4tnfax/aEVwa2bduWU6dOkTdvXk6ePHnf7a7dimXLvxfYvP8cP/57gav3mUUrfzZvnn86F88WCaB4Ln/yZ/PBNZVmXxIRcTZK+oiIiPOqWxfq1IH//Q/GjIHNd2YLOnECeveG0aOhcmXWnfSi8c4SlkEwSfyHSPxkKrduxdK48eesWfOqEj/pjKZsF1zdIGwaeGeF36ZZlm0YbnmkKYMlBt/s4JvD8tMnwfP45fHLvLOm6/HUzGYzC387xpo9ZwBLlY6HmwuR0XH8dexKkt22XAxQvmBWQp/ORZ1nclI0p5+6yIqIpBIlfZxQu3bt+P33322Wubu7kz17dp577jneeustMmfODMCgQYNYsWJFomP4+PiQL18+WrRoQceOHR96TpPJRGhoKGfOnOGbb76hVKlSibYJDQ2lUqVKjBs3LsljBAUF8cYbb/Dmm2/aLP/tt99YsmQJu3fv5vr16+TOnZvQ0FA6d+5MQEDAQ2NLjr179zJ+/Hj27duHr68vLVq04I033sAjie4f8UwmE59++ilffvklZ8+eJV++fLRp04a2bdvabLdz504mTZrEnj178PHxoXbt2vTr14/s2bMnedzNmzfTo0ePJAc9FZEUMBggNNTy2LbNkvxZvdqy7vx5rq7aQEvetgwcyYP/8DKZwMXFTMuWX3Py5Nvq6pWOKOkjgCV5Um+0JZGy+X2HhHDR1YAp5hret6/gffHfh9+MG1zAJ+BOIiggQXLoPgkjryxpWkk06Ju9fPXniYdu5+/pRs2gHNR5Jie1iuckm+/976FERMR+lPRxUiVKlGDEiBHW17Gxsfz9999MmjSJ/fv388UXX1i/ccmRIwfTpk2zbms2m7l48SJffvkl48aNw9PTk1dfffWB5/vll1+4ePEihQsX5ssvv2T06NF2eR8TJ05k7ty5NGjQgKFDh5IlSxYOHDjAnDlzWL9+PYsXL+app556rHOcOHGCjh07UqZMGT7++GMOHTrE5MmTuXr1KqNGjbrvfuPGjeOzzz6jdevW1K1bl+PHjzNlyhROnjzJoEGDANizZw/t2rWjSJEijBs3Di8vL+bPn0+rVq1YuXIl/v7+Nsfcvn07/fr1e6z3IyIPUKUKrFoFu3fDBx/AsmV8ZgohCvckK3ySYjJBVFQsCxfupnfvyqkcsCSXwc0Ng6cn5uhoJX2cncEANftDtkKwYwHE3k6T017HxDuuV9nqYjsDpYfJjLfZhLfZjHf8c5MZb7MZH9Od5eY4vGNP4331JD6XzXe2NeFjvvvcur/BBR+vbHj7ZMfVmhx6QMLI0z/FSaIrUbEPTPgUDPDh+TvVPBUCs2k8HhERB1DSx0n5+flRpkwZm2UVK1bk5s2bTJ06ld27d1vXe3h4JNoWoHbt2tSpU4fly5c/NOmzfPlyypYtS40aNZgxYwaDBg3Cz8/vsd7DmjVrmDNnDoMHD6ZDhw7W5VWqVKFWrVq88MILjBkzxiZhlRJz5szB19eXTz75BA8PD2rVqoWXlxfvv/8+3bt3J0+ePIn2uXz5MosXL+all15i5MiR1uVPPfUUPXv25KWXXqJIkSLMmDEDf39/Fi5caK2uqlKlCg0bNmTu3Ln07dsXgMjISObMmcOcOXPw9/cnSn+wiKSukBD46ivM168THjIPjl23zDf7CKZO3c6bb1ZSl4V0xMXHB2N0tMb0EYtSLS2PNHD25ll6bOzBwavnE62LcTEQgyvX7H7W63gYr+F97T+8r95NKPmYbBNFXrjg5eKJp5sPXm6+eLj74+mRGQ/PLHh4ZcPDKzse3tnJnrsSAVny4eXmSnyPrehYIwDurgYmvRxCvZK5iYmLn87bTDZfD/0OFBFxMCV9xEZ8t6vTp08nmehJyN3dHW/vh09TfO3aNTZu3Ejfvn1p0KABkyZN4ttvv6VNmzaPFevs2bMpWrQor732WqJ1gYGBDBgwgFu3bmE2m5OM8X5d1+ItXLiQypUrs3XrVmrVqmXTlatBgwaMHDmSrVu38vLLLyfa9+jRoxiNRp577jmb5ZUrV8ZkMvHzzz9TpEgRDh8+TPny5a0JHwBvb2+Cg4P58ccfrUmfZcuW8fXXXzN8+HAuXLjw2IksEUmeSzFuHDp6/ZH3M5vh0KErXL58i4AAn4fvIGnCxccH45UrqvSRNPXvlX/psbEH56MsCR9TnC/GqEAMLjHgEoPhzgPDnZ8usRgMJruc+9ESStGWh+ky3MbySLCj234zAdcKcejiS5y/frc6yjfr3xQt9hej9x3hr6hGvF7qdfL557NL/CIi8viU9BEbR44cASB//vw2y+Pi4qzPTSYT58+fZ9GiRRw5coThwx88AOKqVaswGo00bdqUHDlyUKVKFb766qvHSvpcuHCBiIgIOnfufN+k08Oqj3r27Enr1q3vu75o0aLcvn2bU6dOUahQIZt12bJlw8/Pz3q97pU1a1bAkjxL6Pjx4wDWmS6yZs2aaBuwdCk7ceJuuXRoaCitWrXC29ub8PDwB74vEbGfyMiYh2/0ADduxCjpk47Ej+ujpI+kBrPZTGRsJJdvX+bSrUtcvn2ZMzfP8MmuT4iMjQTAFBNA1PGOmGOTHrfvzpHAYASXaAyGWJvkEC4xGAz3SxYl3Mayn6vLLVxcou9sF4vRJY5k9lRNJM5g4FyWo/hlnoDB9RYABvcbuORexOEblm2W/buMFf+toEnhJnQJ7kLBTAVTdjIREbEbJX0e1dKllul9b9xwdCTg7w/vvw8vvvjIu5rNZptEzrVr1/j999+ZMWMGZcuWtRlo+dSpU5QsWTLRMQIDAxkxYgSvvPLKA8+1fPlyatasSY4cOQBo0aIFAwYM4K+//qJcuXKPHDvAmTOWGSLy5Uv5N0kFChSgQIECD9zmwoULAEl2RfP19SUyMjLJ/QoVKkT58uUJDw8nd+7cVKlShRMnTvDuu+/i4eFh7Z7VsmVLhg0bxpgxY+jcuTMuLi4sWLCAgwcP2vz7PCxOEUkdfn6PN9Cov78GKk1P4pM+5lu3MBuNGFxdHRyRczGbzdw23iYqNoqouChcDC7k8c2Trrv/xJpiuXr7KpduX+LyrcuWn7cvJ3p9+fZlLt+6TIzp/oliQ3R+oo69htnoR7eahfHzdLPMCHinq5QZM2bznZ6kdxbGr49fd+8ybJYl2D+J/cDyxZ2RWGJNt4njNnHmaOvDaLqFi/EKrqYruBiv42K8DuYbmE03MZgussPjJpEuLpakkXVcorsVSa4GV4xmI0azkW8Pfcuqw6sonLkwxbMWt3nk9MmZav/mscZYrkZf5Ur0Fa5FX+PK7Stcjb5qfdyIuUH5XOVpXrR5qpxfRCQ9UtLnUU2YABERjo7irgkTUpT0+eOPPxIlclxcXHj22WcZNWqUTWOcI0cOZsyYAcD169f55JNPOH78OOPGjaNs2bIPPE9ERAR///03bdu25fp1SxeJKlWq4OPjw1dfffXISZ/4uNzcLB9dkynl5c8mk+mB+7u6uj70+A+6aZk6dSrDhw/njTfeACBTpkwMGDCA8PBwvL29AXjppZeIjIxk6tSpLFy4EIPBQP369WnVqhXffPNNCt6ViNhTQIA3RYpk5fDhKzZ/OD2MwQCFC2clWzbv1AtOHpmLr6/1uenWLVwfc2y5jOz/7N11fNX198Dx1611sWQbNbpTSlJUWlI6RZEURH+gIF9CQEpBKQGTRpBSQFDCIERaQnA0G7CCdd36/XHhsis1xrbP3Xaej8d98LnvT507kXt37nmft9FkJMWQQrIh2Zqksf5pSCZF/4h9Gf582Pnm/zTHKuRYiGr+1ajpX5Ma/jWo6FMRB03uJ0uNJiN7r+/ll6u/EJkcaU3sxKVlT6edIIeanD/XAcwOtK5SmLGtK2TLdXONyUT8jjGs+fc7VnrYLjLRwLMsfQMbUcmvKqvjz7Hin5UkpCdgMpu4EHuBC7EX2H55u/V4T0fPBxJBpbxK4ay1/fcy1ZBKbFqsJXmTdjd5kxprk8T57/Mk/ZP7dW2+sJmIpAgGVRuUPT8bIYSwc5L0eVpjxsD//mc/lT6jR2fp1EqVKlkbDKtUKhwdHQkMDHxoRYuDgwNVqlSxPq9ZsyadO3dm4MCBrF+//oGpTxl9//33AIwdO5axY8fa7Pvpp58YN26ctZ+Ni4sL6ekP/4bs3vi9ZElgYCAqlYrw8PBH3jsuLg6tVotrhg/5GY0bN+6JPX3uVTwlPaTpZ2Ji4gOra2Xk6+vLokWLiI+PJzIykmLFiqFWq5k4caJND5/XXnuN3r17c+3aNQoVKoS3tzdjxozBy8vrkdcWQuQOlUrFW2/VYdSonU997ogRde26gqEgUrtmWLY9KTnfJ33MZjPXE65zOvo0USlRj0/WZEzU6JNJNebOilZ30u7w6/Vf+fX6rwA4qB2o7FuZGv41qOZXDU9HT9QqtfWhUqnQqDSoUNmMq1Vq1GTYr1I9dJ9OrcNJ64RaZVlFKi4tjk2hm1hzbg03kh6cbp0ZapWaQo6F8HH2wdvJG28nb+u2j5MPOrM/o5bFghkctGrGtspjCR8AtRqPVrMZ5BpAn1+nUcRk4g7gYzSx+MQuOLELgCFlmtOnw2bWXNzCjis7uBR3CYPJYHOpuLQ4Dt86zOFbh61jKlQU9yiOs9bZmsBJMaTk2MtZcGIBGrWGN6q8kWP3EEIIeyFJn6f16qtZqqyxN66urjaJnKfh7OzMjBkz6NatG2PHjrVZ3j2j9PR0fvzxR5o3b07v3r1t9oWFhVmTLvdW3vL19SUy8sFVLQBu3bplPQYsvXAqVarEH3/8wejRox96/wULFrB27Vr27t1rPS+j4cOHP7avUEhICK6urgQEBHD16lWbfTExMSQlJVGqVKlHnr9t2zZKlSpF+fLl8fDwAODUqVOYTCYqVqxofX7z5k2aN29uc62zZ89ajxFCKKtfv+p88MEeUlL0ZKa4UI0ZZxcH+vatlvPBiadyb3oXgCk5/63gFZUcxeno05yKPsWZmDOcjj5NfPrTNyLPLjq1DhedCy7au4+72846Z1y0LiTqEzkZddKmmibdlM6xyGMcizyWo7E5a51x1jqTpE8izZj20P33kjbeznf//E8yx9vJG29nb7wcvaxJpId5Y9kR7i5yxcBGIRT1zqN9vlQqaDIaF2cvbptH89AlDUN/xu27vgzssZaBVQeiN+q5HH+Zf+/8a32E3g4lMsX2854ZM1fir2QpLLVKjZejF56OnhRyLGT508nyp5ejl83YkVtHmHd8HgCfHfsMtUrNgMoDsnRfIYTIKyTpI7KkatWqdO3albVr17J582Y6duz4wDF79uwhNjaW7t27U7duXZt9devWZenSpXz33XfWpE+dOnX4/PPPCQsLe6BXz44dO9BoNNSuXds69vrrrzNq1ChWrlxJnz59bI6/cOECGzZs4Pnnn39owgcs/YAy0xOoQYMG/Prrr4wdO9a6gtfOnTvRaDTUq1fvked9/vnnlC1bljlz5ljHvv32W9zd3a0/j7/++ovPPvuMffv2WRND+/fvJzQ0lNdff/2JsQkhcp6XlxMbNnSlTZvVqNXmxyZ+1JhQoWLjxm54eTnlXpAiU1Q2SZ+83cw5Pj2eszFnOR192vqISI7I8vXuJUEyJmcy/umsdX5oAueRx2pd0Gl0T7yvyWzictxljkcetz6uJ1x/4nnPKsWQ8kAlScPghvSq0Iua/jVx0WVPYmZfaDS7/rH8d/F3d2Ro09LZcl1F1RkIRWrDpb33GxIZ9XBgPqQnwLWDsKwt9N6Izs3fOoUrozupdwi9E2qTDLoQewGjyWiTtMmYsPFy9Lr/cLq/7e7g/tikW0Y1/GugVWuZc9Ty2Wzu0bmYzWZeq/xapq8hhBB5jSR9RJa9/fbb/PTTT3zyySe8/PLLD0wN27BhAz4+Po9MjLRr14558+Zx6NAh6tatS+/evVm/fj19+vRh4MCBlClThtTUVA4cOMCKFSt44403CAoKsp7funVrDhw4wNSpUzl58iQtW7bExcWFv//+m2+++YZChQoxderUZ36db7zxBtu2beONN97gtdde48qVK8yZM4euXbta40lPT+fs2bMULlyYwoULA9CnTx8mTpxImTJlqFGjBtu3b2fr1q1MmjTJOi2sXbt2LF26lLfffpvXX3+dGzduMGPGDGrWrEm7du2eOXYhRPZo0aI027b1pHPndSQn6wFsevyoVJYBZwxsrHyW5s0nKRKneDxNxp4+D5m2a69SDCmcv33ektyJOc2Z6DOZqorwcfKhsm9lKvtWpoRHCVx1rg9N0jhpnNColWlqrVapKeVVilJepXi1rKWSOio5iuORxzl3+xzpxnRMmDCbzRjNRkxmy7YJEybz/ce9/Y/bZ8KEwWSwTmG7l/RpFNyInhV6EuL56OnqT2IymQmPTeH8rQT+jUwgNCKR87cSuBB1f8GH91qWx9Uxn3z0DqpueWRUtgWs7AzJ0XDrFHzdAnpvBO8Hf66FnApRJ7AOdQLrWMfMd/9Rzelpsa9Vfg2j2chnxz4D4NNjn/LT5Z8YXmM4TYo0kWm5Qoh8J5+88wglFCpUiJEjR/Lhhx+ycOFC3nvvPeu+iIgI9u/fT/fu3dE8YnWU9u3bM3/+fNauXUvdunXx8PDg+++/Z9GiRXz99ddERkbi5OREyZIlmTp1Kh06dHjgGlOnTqVu3bqsW7eOCRMmkJSURFBQEF26dOH111+3Lp3+LEqVKsXXX3/NrFmzGDFiBIUKFaJ///6MGDHCekxkZCTdunVj+PDhvPXWWwB069aN1NRUVq5cyZIlSwgJCeGTTz6hbdu21vP8/Pz46quvmDFjBsOHD8fDw4NOnToxcuTIR/7chBDKaNGiNOHh73DnTgqffHKQBQvu96MoGeLFiEtr6McJPL3rPuYqQkn2VuljNptJ0CcQlRxFRHIEUclRRKVEEZkcSWRyJFHJUUSmWP40mo2PvZarzpVKPpWo5FuJKr5VqOxTmcKuhfPkL7B+Ln40L9Gc5iWaKx3KA8xmMzfjUjkfkUBoRAL/RiTyb0QCFyITSU5/9H+jakU86VgjOBcjVUBQdRiwA5Z3gPgwuH0JPm8AL4yFukNA8/hfO3Lz7+obVd7AbDZbp3qdv3Oet/a8RRXfKgyvPpz6QfXz5P87QgjxMCqz+WnWI8kfGjduTEREBAEBAfz+++9KhyOEECKP0Ov16HQ6zGYzt2+nkJCQjru7A95uGlROd6dzNW4Mv/321NeW96bs99+facy33xI5YyYAwXM+waN16xyP4cKdC4TGhj40kROZHJmlhsk6tY7y3uWp5FPJWskT4hki01OykdlsJiohjfN3EzuhEQmcj0jgQkQiCWmGJ18A0KhVFPdxoVKQJ//XvCzFfR6+sEReNHnyZOLi4vD09GTixIm2O+PCYEVHiP73/lhAFWg7F4rWxp7sD9/PvOPzOBtz1ma8pn9NRtQcQa2AWgpFJvIrea8XSpBKHyGEECIT9Ho9UVFRXLlyhbp16+Lj44KPz93KkUesPCjsizoXK330Rj0z/prBun/XZfkaKlR4O3nj7+JPee/yVPatTCXfSpT1Kpupfjni6VyOTuLb/Zc5ezOefyMSiUvRZ+o8lQqKebtQNsCdsgFud/90p6SfK47a/Fm1+8UXXxAeHk5wcPCDSR/PIvDGLtg9BQ5/CZgh4hR89TLU6g8vTQTnZ6/Ezg4NghvwfNDz7L2+lwUnFhB6JxSAY5HH6L+jP88HPc/w6sOp4pe1xU+EEMIeSNJHCCGEeAK9Xs+NGzdo0qQJQ4cO5bnnnpMpmHmQOpd6+sSkxPDOr+88dgUqd507/i7++Ln44e/ib9l2vr/t7+KPj7MPOrUkd3LD3vORjFh9/IlVPMFezpQr7E6ZADfK+rtTrrA7pfzccHaQfw9sOHlCm4+hWg/YOtLS4wczHP0Gzm2FFh9BlS53G6IpS6VS0axYM5oWbcrPV39m4fGF1p5ZB24c4MCNAzQr2ozhNYZTplAZZYMVQogskKSPEEII8Rh6vZ6rV6/SpEkTbty4wdWrV9Fq5e0zL8qNSp+zMWcZuXckt5JuAeCgdmBAlQGEeIRYEzx+zn7ZtjqUeDZms5mv9l3mo+3/YMrQ8KCwhxNlC7tT1v9u5U5hd0r7u+GWXxox55YitWDgr/DXUtg7DdITISkKNg6E4yuhzRzwtY8VzdQqNS1LtOSlYi+x7dI2Pj/5OeGJ4QDsub6Hvdf30qZkG4ZWG0pRj6IKRyuEEJkn71xCCCHEI+j1ekJDQ3nhhReIjIwE4MqVK6jV0jslL1K7ZKj0yYGkz7ZL25h4YCJpxjQA/J39+fSFT2VqiJ1KN5iYsOU0aw/fXyK+RaUAZnSqSiFXBwUjy2c0Wqg/FCq2hx3vwT8/WsYv/waf14dG70KDt0HnpGiY92jVWtqXbk/rkNZsDN3Ikr+XEJUShRkzWy9t5afLP1HNrxr1gupRP7A+lXwrSUWeEMKuSdJHCCGEeAiDwcCZM2d48cUXuX37tnX86tWrjz8xKgpSU8HJPn6BEffZVPokZV/Sx2AyMPfoXJafXW4dq+ZXjblN5+Ln4pdt9xHZ50ZsCm+tOc7Rq3esY281K82ol8qiVis/5Shf8gyGbivh/A7YPhriroExHX6dDqfWQ5tPoGRTpaO00ml0dCvfjXal2/Hdue/48vSXxKXFYTQbORZ5jGORx1h0YhEuWhdqF65NvcB61AusRymvUrLylxDCrkjSRwghhPgPg8HA0aNHadGiBXFxcTb7Hpr00WrBzQ0SE+Gff6BRI9i4EYrKFAB7YtPTJ5sqfW6n3mb0b6P569Zf1rFOZTrxQd0PcNBItYg92v1PBO+uP0lssqVRs4NWzexXq9K+ej5fUt1elGsJIY3gt1lwcAGYDBBzAZa3h6AaoM3JhLkKyraABiMz3U/IWetM/8r96Vy2MyvPrmTrpa1cS7hm3Z9sSOa3sN/4LcyyaqOvsy9tS7bl9cqv4+XklRMvQgghnookfYQQQogMjEYj+/fvp02bNiQ9pNlvYmIisbGxeHl53R9Uq2H5cujdG5KT4cgRqFUL1q+HJk1yL3jxWGrXjJU+z97I+UzMGUbtHcXNpJuAZVrI2Dpj6VK2i3zTb4f0RhOzd55n6e+XrGPBXs4s7FWT6kW9lAusIHJwhZcnQ9WusHUUXD9kGb9xPOfvfe0ABFSGMi891WnuDu4MqT6EIdWHcCPxBoduHuLgzYMcunmI26n3q0GjU6L59sy3fP/v97xW+TV6V+gtPbyEEIqSpI8QQghxl9FoZPfu3XTo0IGUlJRHHnft2jXbpA9Ax45w4IDlz8uXLdO8XnoJZs+GkZn/VlnknOxs5LwpdBNT/5xKuikdsHy7P7fpXKr7V3+m64pnYzabuZOs53J0Eleik7gSk2TZjkniSnQyiRlW53q5YgAfv1oNTxfpx6KYgErw2g44vsIyzSvhZu7cd9dEKNXMkrDPgiC3IDqW6UjHMh0xm82Exoby540/OXTrEH/e+JN0UzqJ+kTmH5/P6n9W07NCTxoEN6CCdwXUKukJJ4TIXZL0EUIIIQCTycS2bdvo0qUL6enpjz02NDSUSpUqPbhse7VqcPgw9OgBv/wCBgOMGmVJBn31Fbi75+ArEE+idna2bmc16ZNuTGf6X9P5/t/vrWPV/Koxp+kc/F38nzlGkTmxyenWZM7l6GSuxliSPJejk4hPffyy6zqNirGtKvBagxJSkWUP1Gqo1Q9q9gWTMQdvZIYvX4KbJyDitKWPULVuz3xVlUpF2UJlKVuoLH0r9eVW0i0Wn1zMpgubMJlNxKTGMP/4fOYfn4+Xoxf1AutRP6g+9QPrE+gW+OwvSwghnkCSPkIIIQo8k8nE999/T69evTAYHv8LI1hW8DIajQ8mfQB8fGD7dhg/HmbOtIytXw9//w3Llll6/0RHWx6lSkH16tn7YsQjqbRaVE5OmFNTs5T0uR5/nTG/j+F0zGnrWPdy3RlTeww6jVSLPElKupHoxDRiktKJSUwjMc2Ao1aDs4MGJ60aJ929bQ1ODmq0ajVhd5LvVu0k21Tt3OvHk1lqFQQXcqZ8YQ+Gv1CaajKd65k0adKE6OhofH19s++iKpVlpa+c9PJkS+8ggL1ToVIH0Dpm6y0KuxZm0vOT6FupLwuOL+CXq79Y98WmxbLjyg52XNkBQAmPEtQLrEeTok1oENRAkpBCiBwhSR8hhBAFmtlsZsWKFQwYMACTyZSpc65cufLwhM89Wi3MmAH160O/fhAXB+fPQ716tsep1fDXX5b+PyJXqF1cMKamZrqnT5oxjT3X9rApdBN/3vwTM2YAHDWOTKg/gXal2uVkuHZNbzRxJymd6MR0YpLSiElMt0nqxCSmE52Uzu27+5LTc7KKw5IzCPJ0JsTXlRK+LpTwcb277UrRQi44aGVaTXZZtWqV0iFkTcmmlmldF/dA7DU48jXUG5Izt/IsyZymc7gef50DNw5Y+/8k6hOtx1yJv8KV+CusPb+WKr5VGFVrFLUL186ReIQQBZckfYQQQhRocXFxbNy4EY1Gk+mkz9WrVx+f9LmnfXtLU+fOnS2VPv9lMsGpU5L0yUVqFxeMt28/sdLn3O1zbAzdyLZL24hPj7fZV8StCHNfmEt57/I5GWquM5nMxKXo7ydt7v6ZMaljSeRYtuNSnq7aJrsEeTpRwteV4j6uhGRI7hT1dsFJl4n/L0XB9tIkS9IHLCuIVe8JTp45druiHkXp5tGNbuW7YTAZOB19moM3D/LnjT/5O+pvDGZLdemp6FMM2DmAJkWa8HbNtyldqHSOxSSEKFgk6SOEEKJAc3V1ZcuWLcTFxbFmzRpWrlzJ/v37H3vOlStXMn+D0qXhzz8tDZ2PHgVvb7h2DfbsebbARZbca+b8sKRPfHo82y5tY1PoJv65/c8D+4u4FaFjmY50L98dDwePHI81u9xJSudKTJIlaZN0N4nzkOqc20npGE3mbL9/IRcdPm6O+Lg64OvmiI+bA96uDrg5akk3mkjVm0jVG62PlLvP0w0mAu8meO4ldor7SGJHPKPAalCli6WnT8ptODAfmo3PlVtr1Vqq+1enun91hlQbQpI+if3h+1n892JC74QCWJd/L1uoLA2CGvB88PPU9K+Jg8YhV2IUQuQ/kvQRQghRoOl0ll4snp6evP766wwePJhGjRqxb9++R55z9erVp7uJszNMmHD/+ZIlkvRRiNrVFQBzaipmoxHV3Yqt0DuhvPHzGzZLL4NlGtfLxV+mU5lO1AqolWdW3kk3mNj9TwTrj4bx279R2ZrMcXXQWJI4bg74uDri6+Zg3bb5080BbxcHtJq88TMTBcgLH8CZzWDSw8GFUKmjZSWxXOaqc6V5iea8WOxFfrz0IwuOLyAiOQKAf+/8y793/uWbM9/gpHHiucLPWZNAIR4h0v9HCJFpkvQRQggh7tLpdOj1ek6fPm0zXrx4cUwmE9evXwcgPj6e+Ph4PDzyTrWHsPjvsu0ad3duJd1iyK4hNgmfyj6V6VimI61CWuHukHdWXTtzI471R8LYciKcO5lsdqzTqDIkahzxdXWwbvu4PpjQcXaQSpuCrlmzZkRERBAQEMCevJjA9g6B5wbAX0tAnwzftIJe30PROoqEo1Fr6FC6Ay1LtGTtubXsuLKDszFnrT3EUo2p7Avfx77wfXAYAl0DeT7oeZ4Pep66gXXxdMy56WlCiLxPkj5CCCHEXXq9nm3bthEbG2sdU6vVHDhwgKCgIPbv38+KFStYv349165do3LlysoFK7Lkv0mfZEcYunuo9dv1ij4VmdJgCmULlVUqxKd2OymdLSfCWX8kjLM34x/YH+jpRLPy/gR4ONlU53i7WhI7Hk5aqRoQT+Xff/8lPDycuLg4pUPJumYfQPgRCD8KqXGWVb26rYTSLyoWkpPWif6V+9O/cn9up97mzxt/sv/Gfg7eOEhUSpT1uJtJN9kQuoENoRtQq9RU8a1irQKq7FMZjVoSs0KI+yTpI4QQQtyl0+lYuXKlzVjjxo0JCgoCoF69etSvX5/58+eTlpaGyWRCrZapK3lJxqRPekIco058YO2lUcStCAtfXIivczYuQ51D9EYTe89FsuFYGHvORaI32k7fctCqaVGpMF1qFaFBaV80aknqCGHDyRP6boG1veDyb5aKn9XdoPOXlqXcFebt5E3rkq1pXbI1ZrOZ0NhQDoQfYP+N/RyLOEa6KR0Ak9nEyaiTnIw6yaKTi3B3cKdeYD1eLfsqzwc9r/CrEELYA0n6CCGEEHclJSWxbds2m7FevXqh1+vR6XTWFbvUajUqlQqzOfub3oqcpXa9n/RZ+OccDhkPAeDl6MXnL31u1wkfs9nMmRvxbDgWxg8nbhCTlP7AMdWKetGlVhFeqRqEp4tOgSiFyEMc3aHXevh+AJzbaunx8/1rlsqfWv2Ujs5KpVJRtlBZyhYqS//K/UkxpHA04ij7w/dz4MYBLsVdsh6bkJ7AL1d/4ZervzC78WxahrRUMHIhhD2QpI8QQgiBZWrXunXrSE1NtY45OjrSrVs3a7PnjLRaeQvNi+41cgY4eukPKK7GUePI/GbzKeFZQrnAHiMqIY0tJ8L5/mgY524lPLDf182RTjWDebVWEcoG5J3+Q0LYBa0jdFkGP46EEyvBbIIfR0DKHWj4ttLRPZSz1pmGwQ1pGNwQgFtJtzhw4wD7w/fz580/iU+3TPMct28cPs4+1C5cW8lwhRAKk0+sQgghBJapXatWrbIZa9WqFe7u8kt0fpJxepdTOqhVamY2nkl1/+rKBZVBbHI6Z2/G88/NBP65Gc8/N+M5dyvhgdW3HDRqXq4UwKs1i9CojK+skCXEs9Boof0CcPaCgwssY7smWhI/L00CO+95Vdi1MJ3KdKJTmU4YTUam/DmFDaEb0Jv0jNw7kuUtl1O6UGmlwxRCKESSPkIIIQo8s9lMdHQ0e/futRnv3bu3dWqXyB/OJl/G7+62kx4+qPsBLxbL/catRpOZy9FJd5M695M8N+NSH3tejWJedK4p07eEyHYqFTSfCi7esPtDy9j+TyE1FtrMgTzSHFmj1jC+3ngikyP5I/wPEtITGLxrMKtaryLANUDp8IQQCpCkjxBCiALPYDCwcuVKTCaTdczDw4NXXnlFEj75yB9hf7Ap/CfevPu8VUBTOpTrmuP3jU/Vcy5D5c4/N+M5H5FAqt70xHPVKijp50bzigF0rlWEUn5uOR6vEAWWSgWN3gUnL9j2LmCGo99CSix0+gK0DsrGl0latZaPm3zMaztf42zMWSKSIxiwcwCdynSiUZFGlPEqIyv2CVGASNJHCCFEgfewqV2dO3eWhE8+cinuEu/+9i7VdfcTLY0K5Wyfi9CIBN5df5K/wzK3rLW7k5YKhT2oEOhOhUAPKgR6UDbAHWeHvFFhIES+Uft1y+pemwaByQBnN0NavGVJdwfXJ55uD1x0Lix8cSF9tvchLDGMawnX+PTYp3x67FMCXAKsPYHqBdbDzUGSyULkZ5L0EUIIUaCZzWYuXbrE0aNHbcZ79+6N0WiUhs35xJ5re0gxpJCa4Yt6U0pyjt0vJd3IoJVHuRSV9MA+lQqKe7tYEzuWhzvBXs7y7bsQ9qLKq5bEz3d9wJACF/fA8g7Qax04F1I6ukzxdfZl8cuLGf3baP65/Y91PCI5gg2hG9gQugGtSkuNgBo0KdKEzmU6SwJIiHxIPskKIYQo0IxGI8uXL7cZCwwMpGnTpqjV0hw3v2gV0oq/bv5FLZyBnwEwJ+dc0uej7f9YEz7BXs40LednTfCUL+yOq6N8BBN514QJE0hMTMTNLZ8nCMq8DH02wepukBYHYX/BN62h6wrwzRuNkYt7FGfdK+u4Gn+VfeH7+CP8D47cOkKaMQ0Ag9nA4VuHOXzrMN+c/oaRNUfSvnR71Cp5/xMiv5BPHEIIIQo0rVb7wNSu7t27YzabH3GGyIuC3YJZ2nwpKafPcOVu0seUQ0mfvecjWfHnVQCcdGqWv15HevGIfOXNN9988kH5RfH68No2WNERkqIg8iwseA4qtoMGb0NwTaUjzJTiHsUp7lGcXhV6kWJI4fCtw5YkUNgfhCWGARCTGsOEAxNYe34tY+uMtZtVDYUQz0ZSuEIIIQoso9HIkSNHuHjxos143759ZZpNPqV2vb9kuynpwalXz+p2Ujpjvv/b+vyDNhUl4SNEXle4CgzYCV7F7g6Y4ewW+OIFWPYKXNgNeeiLAmetM42LNGZc3XFs77Sdze0381Kxl6z7z8acpc9PfVj1z6rHXEUIkVdI0kcIIUSBpVKpHpjaVbZsWapXry5Tu/Iptcv9JqzZXeljNpsZu/FvohIs0yZeKOdH77rFnnCWECJP8CkFg/fBixPB1f/++OXfYWUnWNIITn0PRoNyMWaBSqWilFcp5r4wly+bf0lpr/vT1j49+im3km4pGJ0QIjvIJ1ohhBAF2rp162ye9+rVC4Mhb31oF5lnW+mTvUmf9UfC2HkmAgBvVwdmvlpVKsZEvnTz5k3CwsK4efOm0qHkLidPaPQOvH0K2n4K3iXv77t1Cja8DvNrwumNioX4LOoG1mX9K+vpXKYzAKnGVD479pnCUQkhnpUkfYQQQhRIBoOB3bt3ExERYTPet29fNBpZIju/Ujs7W7ezs9LnUlQik348Y30+vVMV/N2dsu36QtiT2rVrU7RoUWrXrq10KMrQOcFzr8HwI9BlGQTVuL8v9ip8/xocmK9cfM9Aq9YyqtYoPB09Adh6aSuno08rHJUQ4llI0kcIIUSBpNVqWbFihc1YnTp1KFGihFRn5GMqjQbV3cRPdvX0STMYGbH2OMnpRgC61y5Ki0qFs+XaQgg7ptZApQ4wcC/0+xFKNbu/7+fxsPvDPNXr5x5PR0+GVBtifT778GxZ3ECIPEySPkIIIQqktLQ0Nm/ebDPWq1cv9Hq9MgGJXKN2sUzxyq5Kn493nud0eDwApfxcmfBKxWy5rhAij1CpIKQx9N4IzcbfH//jE9g6CkxG5WLLoq7lulLCowQAxyKPsevaLmUDEkJkmSR9hBBCFDh6vZ4tW7aQkJBgHdNoNPTq1QudTqdgZCI3ZGfS57d/o/jij8sAOGjUzOtRAxcH7TNfVwiRB6lU0Hg0tP4YuFsxevQbWNsTIs489lR7o1PrePe5d63P5xyZQ7oxXcGIhBBZJUkfIYQQBY5Op2PlypU2Yy+++CI+Pj4KRSRyU3YlfaIS0nh33Qnr8/daladSkOczXVMIkQ/UGQidvgD13QTwvzvg8+dhVRe4sj/PTPlqUqQJdQvXBSAsMYzFJxfLNC8h8iBJ+gghhChw4uLi2LFjh82YTO0qONSulmXbzWlpmLO4UpvJZOb/1p8kOtHyzXfTcn4MaFAiu0IUQuR1VbtA9zXg7H1/LPRn+LY1fPUy/PMjmEzKxZcJKpWK0bVHo7pbtfTFqS/ov6M//975V+HIhBBPQ5I+QgghChS9Xs/atWttEjzOzs68+uqrMrWrgLhX6QNZr/ZZ/PtFfvs3CgBfN0c+7lJNGoALIWyVbQ6jTkPLmeBZ9P542GH4rjcsrAPHloMhTbkYn6CcdzneqPKG9fmxyGN0/bErsw7PIjolWsHIhBCZJUkfIYQQBYpOp2PVqlU2Y6+88gouGRIBIn971qTP4Su3+eRnyzfdKhV81r06vm6O2RafECIfcXCFeoNhxHHLlC//Svf3xYTCD2/BvJoQflS5GJ9gRM0RfP7S5xRzLwaA0WxkxdkVvLDuBZp/35xRe0fx5akvOXDjAHFpcQpHK4T4L+k0KIQQosAwm83cvHmTffv22Yz36dMHg8GAVitviwXBsyR97iSlM2LNcYwmS1+Lt14oTYPSvtkanxAiH9LooGpXqNIFLuyC/Z/BlT8s++LDYFk76L4aSjZRNs5HaBjckI3tN/Lt6W/54tQXpBkt1Uk3k25yM+mmzepeRdyKUNm3MpV8KlHJtxIVvCvg5uCmVOhCFHjy6VYIIUSBYTQaWbFihU0jSm9vb1q2bCkJnwLEJumTlPmkj8lk5t31J7kZlwpA3RBvRr5UNtvjE0LkYyoVlHnZ8gg7Ajs/gOt/QnoirHoVXv0GKrRVOsqHctQ4MqjaINqUbMO68+v4O/pv/on5h2SD7b+jYYlhhCWGsePK/d55JTxK8Fzh53izypsEugXmduhCFGjyCVcIIUSBodVqH5ja9eqrr6JWy2znguReI2cAU1JSps4xm83M2xPKnnORAPi4OjCvRw00aunjIwqe3bt3S3VkdijyHPTdAt+/Bue3gzEd1vWBdvOhRm+lo3ukIu5FeOe5dwAwmoxcjb/KmZgzlkf0Gc7dPkeqMdXmnCvxV7gSf4Vtl7YxrPowelboiU4tffSEyA3yL7UQQogCwWQycf78eU6dOmUz3rdvX1mCtoBRuz7d9K6rMUmM3XiKAxdjrGNzulUnwMMpR+ITwt6VK1dO6RDyD50TdF0BPwyHk2vAbIItwyzLvDcYBUVqKR3hY2nUGkp6laSkV0leKfUKAAaTgUtxlzgTfT8RdP7OefQmPSmGFD4+8jE/XPyB/9X7H9X9qyv7AoQoACTpI4QQokAwm80sW7bMZqxYsWI0aNBAoYiEUjLb08doMvPN/st8/PN5UvX3l1Z+9+WyNCnrl6MxCiEKEI0W2i8CJ084tNgy9s+PlkeJRtBgJJR+yTI1LA/QqrWULVSWsoXK0rFMRwDi0+OZf2w+353/DjNm/r3zL31+6sOE+hPoUraLwhELkb9JPbsQQogCQaPRsGbNGpuxHj16YDQaFYpIKMU26fPw6V3nbyXQ6fMDTN32jzXhE+zlzLIBdXjrxTK5EqcQogBRq6HlDGjzCbgVvj9+5Q9Lr5/FDeHvdWDUKxfjM/Bw8OCDeh+wus1qKnhXsI5/9OdHHIs4pmBkQuR/kvQRQgiR7xmNRg4cOMC1a9dsxvv27Ysqj3xzKrKPbU8f20qfdIOJub/8S9v5f3Dyeixg+XK9//Ml+HlUY6nwEQJYvXo1X375JatXr1Y6lPxFpYLab8Dbf8Mr88Cn9P19Eadh40DL8u5/Lob0zPUjszeVfSuzus1qepTvAYDBbOCdX98hIilC4ciEyL8k6SOEECLfU6lULF++3GascuXKVKxYUZo4F0CPqvQ5cT2WtvP/4LPdoeiNlj5PpfxcWT+oPpPaVcLVUWbFCwEwZswYBg4cyJgxY5QOJX/SOkKtfjDsMHRbCcHP3d8Xdw12vAdzK8Pe6ZAU8+jr2CmtWsuY2mOoW7guADGpMbzz6zukG9MVjkyI/Ek+6QohhMj3TCYT33//vc1Yr169MBgMCkUklPSwnj7nbyXQbclB/o1IBECjVjH8hdJsG9GI50p4KxKnEKKAU6uhwivwxi7ovw1Kv3x/X8pt+G0GzK0E28fAnavKxZkFWrWW2U1mE+QaBMDf0X/z0aGPFI5KiPxJkj5CCCHyNYPBwM6dO4mJuf9tqEqlok+fPmg0GgUjE0pRPSTpM3PHOdIMlt49lYM9+GF4A/6vRTmcdPJ3RAihMJUKSjSE3t/D4P1QpSuo7v7bZEiBv5bAvBqw4Q24derx17IjhZwKMfeFuThqHAHYELqBecfmoc+jfYuEsFeS9BFCCJGvabVaVqxYYTPWoEEDgoODpZ9PAaWx6emTxF+Xb7PnXCQAgZ5OfD/4eSoFeSoVnhBCPFrhytD5Cxh5AuoOBt3dJLbZCKfWWxo+r+wMN44rGmZmVfSpyMT6E63Pvzj1BV23duVE5AnlghIin5GkjxBCiHwtJSWFH374wWasV69e6PXyTWJBZVPpk5TMzB3nrM9HvVRWqnuEEPbPqxi0mglvn4amY8E5wzTUC7vg61YQc1G5+J7CK6VeYWTNkWjuVi9diL1A35/6Mu3PaYQnhmM2mxWOUIi8TZI+Qggh8i29Xs/3339PSkqKdUyn09G9e3d0Op2CkQklqV3uV/pER8Vy9OodAEr7u9GpZrBSYQkhxNNz9YGm78Oo09BqFngWs4wbUmDPFGVjewpvVHmDNW3WWJdzN2Nm7fm1tNzQkhfWvcBbu99i6d9LOXjjIAnpCQpHK0TeIstQCCGEyLd0Oh2rVq2yGWvRogVeXl7KBCTsgtrF2bp989ZtKGnZHt2iHFqNfB8mhMiDHFyh7iCo3gvmVYekKDizCZ5/C4JrKR1dplTwqcDqNqtZ9c8qFhxfQKoxFbCs7vVr2K/8GvYrACpUhHiGUNWvKlV8q1DVryqlvUqjVcuvtkI8jPyfIYQQIt+6ffs2u3btshnr3bs3er1eKn0KMJVajcrFBXNyMqoUSyPnGsW8aF4xQOHIhBDiGTm6QZP3YPv/WZ7/MhH6/WhpBp0HaNVa+lXqx0vFX2Lzhc38HfU3p6JP2VT3mDFzKe4Sl+IusfnCZgCctc5U8K5A8xLN6V6uOxq1TNMV4h5J+gghhMiX9Ho9q1atwmg0Wsfc3Nxo3769JHwEamdnjMnJOBvSAXivZXlp7C2EyB9q9oODC+HOZbjyB1zcDaVfUjqqpxLsFsyw6sMAMJlNXI2/yqnoU9Yk0L+3/8VgNliPTzGkcCzyGMcijxGbFms9VwhhB0mfffv2MXfuXC5cuICPjw+9evViwIABj/zgZTAY+Prrr/n++++JjIykePHiDBo0iNatW+dy5EIIIezZw6Z2dejQAScnJ4UiKtjs7f0+Ue2AM+BkTKNpOT/qlfTJlusKURAULlzY5k9hZ7QO8OL/4PsBlue/TIKSzUCdN6evqlVqQjxDCPEMoV2pdgCkGlI5d/ucNQl0KvoU4YnhACw5uYTqftVpENxAybCFsBuKJn1OnDjB4MGDadWqFSNHjuTo0aPMnj0bo9HIm2+++dBz5s+fz9KlSxk2bBi1atXil19+YdSoUWg0Glq0aJHLr0AIIYQ9MpvNXL16lUOHDtmM9+nTB4PBgFar+HceBYq9vd/fSUonQq+iBOBsSGd0i3LPdD0hCpojR44oHYJ4koodIXAe3DwBEafg9Aao2kXpqLKNk9aJ6v7Vqe5f3Tr21amv+PTYp5gx8/4f77P+lfUUdpXEpBCKfuqdP38+FSpUYPbs2QA0btwYg8HA4sWL6du370O/jd2wYQNt27Zl+PDhANSvX58zZ86wcuVKSfoIIYQAwGg0snz5cpsxf39/XnrpJdR59JvOvMze3u8/2x1KJY0jAA4mA+X9XJ5whhBC5DFqNbw8GZa3tzzf8yEEVgW//Jvkfq3yaxyPPM5vYb8RmxbL//32f3zT4ht0GpnSLQo2xT75pqenc+jQIV5++WWb8RYtWpCUlMTRo0cfeZ6bm5vNmJeXF7GxsTkVqhBCiDxGq9WyevVqm7GuXbsqFE3BZm/v95eiEln551VSNA7WMVNy8jNdUwgh7FLJplDyBct27DVYWAfW9IBrhx57Wl6lVqmZ1nAawW7BAJyMOsmco3MUjkoI5SmW9Ll+/Tp6vZ4SJUrYjBcvXhyAy5cvP/S8vn37snnzZn7//XcSExP54Ycf+OOPP2jfvv0j75Wenk5iYqL1YTabs+11CCGEsC8mk4mTJ09y/vx5m/G+ffvKv/8KsLf3+xk/ncNgMpOqdbSOSdJHCJFvtZoFrv73n5/fDl83h69bwvkdYDIpF1sO8HT05JMmn6BTW6p7Vv6zkl1Xdz3hLCHyN8WmdyUkWJbd+++3eK6urgAkJiY+9Lz+/ftz4sQJBg4caB3r3Lkzb7zxxiPvtWTJEhYsWPCsIQshhMgDzGYzy5YtsxkrVaoUtWvXViiigs2e3u//vBTDz2cjADA7O1vHJekjxNMZNGgQt2/fxtvbmyVLligdjngcv7Iw4hgcXWZZ0SvhhmX82kHLw68CNBgBlV+1NIDOByr5VmJM7TFMOzQNgAn7J1DOuxxF3YsqHJkQylAs6WN6Qlb5YT0X0tPT6dWrF1FRUUyePJmSJUty/PhxPv/8c1xcXBg/fvxDrzVo0CBee+016/NWrVoRGRn5bC9ACCGEXVKpVHz33Xc2Yz169JAGzgqxl/d7k8nMtG3/WPdVLFkYLt6NUZI+QjyVbdu2ER4eTnBwsNKhiMxwdIfnh0OdN+HUetj/GUTfrYaN+gc2D4E906DTUiiRP1a86lauG0cjjrLjyg4S9AmM+W0My1stl/4+okBS7NOvu7s7AElJSTbj977x++83ggA7d+7k3LlzfPPNNzz//PMA1KlTBzc3Nz788EO6du1K2bJlHzjPwcEBB4f7metHLQ8rhBAibzMYDOzbt48bN27YjPfr1w+NRqNQVAWbvbzf/3w2glPhcQCUL+xOWaM/t+/uM/0nNiGEyJe0DlCjF1TrAf/ugP2fwvW7/X3iw2BFR+i6DMq1UjTM7KBSqZhYfyJnY85yLeEap2NOM+foHN6r857SoQmR6xTr6VOsWDE0Gg1Xr161Gb927RpgKcX/r3sf4mvWrGkzfq9k/8KFCzkRqhBCiDxCo9E8sGpXzZo1KV26tCT8FWIv7/dhd+5X84xvUxHN3ellIJU+QogCRq2G8q3h9Z9hwE4o3tAybkyDtb3g5HePPz+PcHNw4+MmH9v099lzbY/CUQmR+xRL+jg6OvLcc8/xyy+/2DRa3LlzJ+7u7lStWvWBc0qWLAnAkSNHbMaPHTsGQJEiRXIwYiGEEPZOr9ezYcMGm7FevXqh1+sVikjYy/t973rFeeflsnzeqyYNy/ii8fSw7ks+9NdTX08IIfKFYvWg72ao0sXy3GyETW/Cn4sVDSu7VPCpwOjao63Px+8fz5W4K8oFJIQCFEv6AAwZMoSTJ08ycuRIfvvtNz799FO++uorBg0ahLOzM4mJiZw4cYLbty0F2M2aNaNatWqMHj2a1atX8+eff7J06VJmzpxJs2bNHvrBUQghRMGg1+vZunUr8fHx1jG1Wk3v3r2ll4/C7OH93kmnYcSLZWhVJRAAt6ZNUTlaVvC6vWoVaY9YRUwIIfI9jQ46LoXa9xvns+M9OPyVcjFlo+7luvNy8ZcBSEhPoOvWrqz/d72s6CkKDEWTPvXr12f+/PlcvnyZYcOG8eOPPzJmzBjrSh1nzpyhW7du/Prrr4ClbP/rr7+mdevWLFq0iIEDB7J582aGDBnCZ599puArEUIIoTSdTsfKlSttxpo2bYq/v79M7VKYPb7f6wID8R5wt+mzwUDkzFnZcl0hhMiT1GpoPRsaj7k/9vtsMBmViymbqFQqJj8/mZKelirSFEMKHx78kKG7hxKZLIv7iPxPZS6AKc7GjRsTERFBQEAAv//+u9LhCCGEyAYJCQn4+fmRlpZmHfvqq6/o06cPOp2drdaxZAkMHmzZ/uYb6N9f3ptywJN+pqakJC62ao3h7gpfRb/8EreG+WPlGiFyUpEiRayrd4WFhSkdjshuq7tZGj0D9P0BSjZRNp5skqRPYvbh2WwIvT8N3MPBg//V+x8tQ1rmSgzyXi+UoGiljxBCCJEd9Ho969ats0n4ODo60rVrV/tL+Ai7oXZ1xf/dd6zPI2fOwGwwKBiREELYgWrd72//vU65OLKZq86VSc9PYuGLC/F19gUgPj2e0b+PZvRvo4lNjVU2QCFyiCR9hBBC5Hk6nY5Vq1bZjLVp0+ahy4ELkZHHK6/gdLdHUFroBe58lz9WrRFCiCwr2xIc3C3bZ7eAPkXZeLJZ4yKN2dRuEy1L3K/u2XFlBx1/6MjvYVJ9I/IfSfoIIYTI08xmMxEREfz22282471795ZVu8QTqdRqCo8ba30ePW8+xthY5QISIg/o0aMHr7/+Oj169FA6FJETdM5Qsb1lOz0Bzv+kbDw5wMvJi9lNZjOr8Sw8HCyrOUanRDNs9zC+PPWlwtEJkb0k6SOEECJPMxgMrFixApPJZB3z9PSkbdu2MrVLZIpz9ep4vPIKAMa4OKIWLlI4IiHs2+zZs/nyyy+ZPXu20qGInFK16/3tfDTF679ahbRiU/tNNAxuaB1bdGIRcWlxCkYlRPaSpI8QQog8TafTsXr1apuxzp07yzLt4qn4v/sOKmdnAO6sXk3axYsKRySEEAoq0RDcgyzbF36BpBhl48lB/i7+LHpxEZ3KdAJAb9Kz+9puhaMSIvtI0kcIIUSeZTKZCA0N5fjx4zbjffv2tan8EeJJdIUL4/PG65YnRiMRM2YqG5AQQihJrYEqr1q2TQY4u0nZeHKYSqWia9n71U3bLm1TMBohspckfYQQQuRZJpOJZcuW2YwFBQXRqFEjNBqNQlGJvMpnwAC0gYEAJP3xB4n/6RMlhBAFStVu97fz8RSveyr6VKS4R3EADt86TERShMIRCZE9JOkjhBAiz9JqtaxZs8ZmrHv37pjNZoUiEnmZ2tkZ/3fftT6PmDETszQDF+IB5cuXx8PDg/LlyysdishJhSuDf0XL9vVDcPuysvHkMJVKReuQ1gCYMbPjyg6FIxIie0jSRwghRJ5kNBr566+/uHTpks14v379UKlUCkUl8jqPNq1xrlEDgPTLl7nzn6SiEAISExNJSEggMTFR6VBETsvY0PnUeuXiyCX3kj4A2y9vVzASIbKPJH2EEELkSSqViuXLl9uMlS9fnqpVq6JWy9ubyBqVSkVAhiXcoxYs5PaqVdxevZrbq1cTu3ETxsQkBSMUQohcVKXL/e2DCyHsqHKx5IISniWo5FMJgLMxZ7kcl7+rm0TBIJ+KhRBC5Elms5l162x7DPTs2RODwaBQRCK/cK5SBc8OHQAwxccTMWUqER9OIeLDKdwcN45rAwZgSklRNkghhMgNnkWgfFvLdmosLG8Hl/J3vzOp9hH5jSR9hBBC5DkGg4Fdu3YRFRVlM963b19p4Cyyhd+oUag9PR+6L/Xvv7nx3vuYZYU4IURB0OFzKN7Qsp2eCKtehX+2KhtTDmoZ0hIVlmni2y9tlz6BIs+TpI8QQog8R6vVsmLFCpuxevXqUbx4cennI7KFLsCfkhs3EDR7FkEzZxA0cwaFJ09G7eoKQMLPPxP5yScKRymEELnAyQN6fw/l7lbAGNNhXR/4dQbEXFQ2thzg7+JPncJ1ALiWcI0zMWcUjkiIZ6NVOgAhhBDiaaWmprJ582absZ49e6LX69HpdMoEJfIdXXAwnsHBtmNBQVwfPBiMRm5/9TUORYtRqHu3R1xBCCHyCZ0zdF0BW4bB32vBbIJfp1sefuUtCaHybSCoJuSDvnptSrbh0K1DAGy7tI3KvpUVjkiIrMv7/0cKIYQoUPR6PZs2bSIp6X4zXa1WS69evSThI3KcW6OGFP7f/6zPb02ZQuIffygYkRBC5BKN1jLVq/5w2/Goc7BvDnz5IsypAD++DaG/gCFNkTCzw4vFX0Sntnym2H55O8n6ZIUjEiLrJOkjhBAiT9HpdKxatcpm7KWXXsLb21uhiERBU6h7N7wHDLA8MRoJf3sUqefPKxuUEELkBrUaWkyDt47Byx9C0XpAhmnVibfg6DeWvj+zSsK6vnDyO0i5o1jIWeHh4EHTok0BuJ16mzlH5ygbkBDPQJI+Qggh8pTY2Fh27txpM9arVy/0er1CEYmCyP//3sX95ZcBMCUlcX3QYPQRkQpHJYQQucSnFDQYCa/vhP/7F9rNh7KtQOt0/5j0RDi7BTa9CbNKwaquEHtduZif0siaI3HWOgPw3fnvOHDjgMIRCZE1kvQRQgiRZ+j1elavXm2zLLuLiwudO3eWqV0iV6nUaoJmzcSpalUADLduETZkCKYM0w6FyK8WL17MunXrWLx4sdKhCHvg5g81+0LPtTDmEnRbBdV6gnOGClyzEUJ3wtctIOpf5WJ9CsU9ijOq1ijr8wn7JxCfHq9gREJkjSR9hBBC5Bk6nY7Vq1fbjLVr1w5nZ2eFIhIFmdrZmaKLFqILCgIg9exZwv9vNGajUeHIhMhZbdu2pUuXLrRt21bpUIS9cXCFCm2h4+fwf6HQf7ulB5B7oGV/fDh80xJuHFc2zkzqVq4bdQPrAhCRHMHMv2YqHJEQT0+SPkIIIfIEs9lMWFgYBw7Yllf36dPHpvJHiNyk9fWl6NIlqN3dAUjcu5eIGfJLgRBCoNFCiQaWHkCDfofCVSzjyTHw7StwZZ+y8WWCWqVmyvNTcNO5AfDDxR/Yc22PwlEJ8XQk6SOEECJPMBqNLF++HLPZbB3z8fGhefPmaLVaBSMTBZ1j6dIUmfcZ3P17eGfFCm4vX6FwVEIIYUfc/KH/Nij2vOV5egKs6JQnEj+BboG8V+c96/PJByeTYkhRMCIhno4kfYQQQuQJWq32galdXbp0Qa2WtzKhPNf69QmcPMn6PGLGDBL27FUuICFy0NGjRzl48CBHjx5VOhSRlzh5Qu8NUKaF5bkxDba+A0b7r9ZtX6o9jYIbAZbVvE5Hn1Y4IiEyTz4pCyGEsHsmk4kzZ85w5swZm/G+ffvaVP4IoSSvzp3xGTTI8sRkIvzdd0n5z99ZIfKD9u3b8/zzz9O+fXulQxF5jYMLdF8FRWpbnkefh5OrH3+OHVCpVDQIbmB9fiPxhoLRCPF0JOkjhBDC7pnNZpYtW2YzVrx4cerXr49Go1EoKiEe5DdyBB6tWwFgTkkhbPAQ9DdvKhyVEELYEY0OXp5y//ne6aC3/+lSQa5B1u0bSZL0EXmHJH2EEELYPY1Gw5o1a2zGevTogVFWSRJ2RqVWEzh9Os41agBgiIri+qDBGBMTFY5MCCHsSPH6UK61ZTvhBhxaomw8mRDoFmjdvpkoyXyRd0jSRwghhF0zGo3s27ePsLAwm/F+/fqhUqkUikqIR1M7OlJk4QJ0xYoBkPbvv4SPegezrDInhBD3vTgBVHd/Hd03B5JvKxvPEwS6Zkj6JEnSR+QdkvQRQghh11QqFcuXL7cZq1q1KuXLl5cmzsJuab29Kbp4MWpPTwCS/viDW1OnSg8qIYS4x78CVOtp2U6Ng31zlY3nCTwcPHDVuQKS9BF5i3xaFkIIYdeMRiPff/+9zVjPnj0xSNWEsHOOJUMoumA+6HQAxK79jtvffKtsUEIIYU9eGAsaR8v2oSUQF/b44xWkUqms1T43E29iMpsUjkiIzNEqHYAQQgjxKHq9np9++ok7d+5Yx1QqFX369JEGziJPcKldm6BpU7kx5j0AImfPRlOoEM7Vq2X6GmoXV3QB/jkVohBCKMezCNQdBAfmWZZw3zIcuq+2rPJlhwJdA7kQe4F0Uzq3U2/j6+yrdEhCPJEkfYQQQtgtnU7HypUrbcYaNWpEUFDQI84Qwv54tmtH+rXrRC9YAGYzN8eOfepruD5fn4CxY3EsUyYHIhRCCAU1HAXHlkNqLFzaCys7Q8+14OSpdGQPCHK7//njZuJNSfqIPEGmdwkhhLBbSUlJ/PjjjzZjvXr1Qq/XKxSREFnjO2wonu3bZfn8pAMHudShI7emTMUYG5t9gQkhhNJcvO9W97hbnl87AN+2gcRIZeN6iIzNnGXZdpFXSKWPEEIIu6TX61m/fj2pqanWMQcHB7p164bubo8UIfIKlUpF4JQpOJQoQfqVq091bvKRI+jDw8Fo5M6qVcRv3Ypj+fL3r61R41K3Ht59+6B2ds7u0IUQIueVaAD9f7RU+STHwK1T8HVL6PItFK4CdrJap80KXrJsu8gjJOkjhBDCLul0OlavXm0z1rJlSzw97a/cW4jMUDk44DtkyFOfZ0pL4/Y33xC9ZCnmlBSMcXEkHzpkc0zSgYPc+W4tAaNH496yJSo7+QVJ5E///PMPZrNZ/p6J7BVUA17bASs6QHw43L4ISxpBoRJQvi2Uaw1F64JGuV9hM07vkkofkVdI0kcIIYRdio6OZs+ePTZjvXv3Rq/XS6WPKFDUjo74Dh6MZ8eORH7yCfE/7YCHTHE03LhJ+Kh3cFm9Bq+uXVFp7zc7dwgJwSlDdZAQz8Ld3V3pEER+5VcWBuy0JH5iLljG7lyBgwssD2dvKNsSyreBUs1yveGzTaWPLNsu8ghJ+gghhLA7er2elStXYjQarWPu7u60a9dOEj6iwNIFBBA8axZB06ZhzvD/hv76dSJmziJp3z4Akg8fJvnw4QfOd2/eHP8xY3AoEpxrMQshxFPzKgoD98KJVXBuG1w9AOa7/+al3IaTqy0PrROUfMGSACrbEtz8cjw0Pxc/tGotBpNBpneJPEMaOQshhLA7D5va1bFjRxwcHBSKSAj7odLpUDs5WR+OZcpQ9IulFPl8EbrixR55XsLPP3OpdWsiP/sMU3JyLkYshBBPyckD6g2B/lth9AXouBQqtAOd6/1jDKnw70/ww3D4uAx81QL+Xp+jYalVagJcAgCZ3iXyDqn0EUIIYVfMZjNXrlzh8H8qFfr06YPRaESrlbcuIf5LpVLh/sILuDZoQMLPv2CIirLuMyUncWfNWozR0ZjT04n5fDG3v/kWtaOjghGD2tOTQj174N2rFyqp4MtT5syZQ3x8PB4eHrzzzjtKhyPyOxdvqNbN8tCnwuXf4fw2OP8TJEbcPcgM1/+0PFQqqPJqjoUT5BZEeGI4CekJJKYn4ubglmP3EiI7yCdnIYQQdsVoNLJs2TKbsYCAAJo1a4ZaLQWqQjyO2sEBz7ZtHhj37teP6EWfc3vFCtDrMaemYsywMp4SjHFxRM6YSey69QSMfR+3Ro0UjUdk3pw5cwgPDyc4OFiSPiJ36ZygbHPLo81cCD9qSQCd2w7R5y3H7J4MFV4Bbc4ktv/b16eMQ5kcuY8Q2UWSPkIIIeyKVqt9YGpXt27dFIpGiPxB4+ZGwJjReHV5lej5C0g9c0bReMyY0V+7DmYz6ZcucX3gm7g2boRThYrWY1Q6HW4vNMW5UiXlAhVC2C+1GorWtjxemgTLO8ClvRB7DY58bZkelgMeSPoUkqSPsG+S9BFCCGE3TCYTJ0+eJDQ01Ga8X79+CkUkRP7iGBJC8JxPlA4DgJRTp4mYNo2UEycASPr9D5J+/8PmmOgFC/Ds1An/UW+j9cv5Jq1CiDzspUmwdK9l+7dZUL0nOHlm+21slm1PlL4+wv5J0kcIIYTdMJvND0ztKl26NDVr1lQoIiFETnGuUpnia1YTv3UrkbM/xhAZ+dDj4jZuJGHnTnyHDsGjdWtLv44sUru4oPHwyPL5Qgg7FlQdKr8Kp7+3rPJ1YD40G5/tt8lY6SPNnEVeIEkfIYQQdkOlUvHdd9/ZjPXs2RODwSANnIXIh1QqFZ6vvIL7yy+TeuYMZr3eui/1n3NEL1qEKSEBU1ISkbM/JnL2x896QwLefw9vqR4UIn9qNh7ObgGTHg4uhNpvgHvhbL1FxkqfW4m3svXaQuQE6YgphBDCLhgMBvbu3cutW7YfoPr164dGo1EoKiFEblA7OeFSqxau9epZHz6v9afUzh14de36TNU9NsxmIqbPIH7Hzuy5nhDCvniHwHMDLNv6ZPhtZrbforDr/SSSVPqIvEC+NhVCCGEXNBoNK1assBl77rnnKFmypEIRCSGUpvX2JvDDyRTq3s2y7Hx8fJavZYyPI/ngnwDceO89dIUDcK5ePZsiFULYjcaj4cQqSE+Eo8ug3jDwLZ1tl3fUOOLj5ENMagw3E29m23WFyCmS9BFCCGEX0tPT2bhxo81Yz5490ev16HQ6haISQtgDp4oVCZzy4TNdw2w2c3PsOOI2b8aclsb1ocMose47HIoUyaYohRB2wc0Pnh8Bv34EZiPsmQJdlz35vKcQ5BZETGoMUSlR6I16dBr5nCLsl0zvEkIIoTi9Xs8PP/xAQkKCdUytVtO7d29J+AghsoVKpSLww8m41KkDgPH2ba6/OQhjXJzCkQkhsl39YeB6d8W/s5sh7Gi2Xv5eM2czZm4lS18fYd8k6SOEEEJxOp2OVatW2Yw1a9YMP1miWQiRjVQODhSZPw+HkBAA0i9dImzESMzp6QpHlrfUrFmTevXqycqKwn45ukGT9+4/3zURzOZsu3zGFbxkipewd5L0EUIIobj4+Hh++uknm7FevXqhz7CSjxBCZAeNpydFly5B4+0NQPKhQ9ycOAlzNv5CmN/98MMPHDx4kB9++EHpUIR4tJr9oJAlwcuVP+DC7my7dKCbLNsu8g5J+gghhFCUXq9n7dq1pGf4pt3JyYkuXbrI1C4hRI5wKFqUoosWonJ0BCBu0yZilixROCohRLbSOsCL/7v/fNdEMJmy5dJBrveXbZdKH2HvJOkjhBBCUTqdjtWrV9uMtW3bFldXV4UiEkIUBM7VqxM0c4b1edSnnxG3dZuCEQkhsl3FjhBY3bIdcRpOrc+Wy2as9LmZJEkfYd8k6SOEEEIxZrOZmzdv8vvvv9uM9+7dG4PBoFBUQoiCwqNlS/zefcf6/ObYsST99ZeCEQkhspVaDS9Pvv98z1QwpD3zZTP29JHpXcLeSdJHCCGEYgwGAytWrLDppeHl5UXr1q3RarUKRiaEKCh83ngDry6vAmDW67nW/zVuffghhjt3FI7MfrVr14769evTrl07pUMR4slKNoVSzSzbcddg94fP3NTZw8EDV52lIlmmdwl7J5+ohRBCKOZhU7teffVVNBqNQhEJIQoalUpF4QkT0N+8RdK+fWAycWf1GuK2bcfvrbfwaNMalUqV9es7O6O+2zsovzh27Bjh4eEEBwcrHYoQmfPSJLi4FzDDwQWWap9WsyyVQFmgUqkIdA3kQuwFbibdxGQ2oVZJPYWwT5L0EUIIoQiTyURoaCgnT560Ge/bt6+soiOEyFUqnY4iixZy+9tlRC9ejDk5GVNcHBFTpxIxdeqzXVynw6tjR/zeHon27ophQohcFljNkuT5abTl+eEvIDUWOnwOmqwtGnEv6aM36bmdehtfZ9/si1eIbCTpSCGEEIowm80sW7bMZqxIkSI0atRIKn2EELlO7eCA75sDKfXTT3i2z8ZpS3o9sevWcbFlK24vX45Zr8++awshMq/um9BxCajufsY4tR7W9oL05CxdLsjt/gpeNxKlr4+wX1LpI4QQQhEajYY1a9bYjHXv3h2j0ShJHyGEYnQB/gTNnEmhHj24vXo1xri4rF/MbCbl6DFMSUmY4uOJ+Gg6d75bR9CM6ThXqZJ9QQshMqdad3D0gPX9wZgGoTthZWfouRacPJ/qUv9t5lzVr2o2BytE9pCkjxBCiFxnNBo5fPgwV65csRnv16/fM/XOEEKI7OJcvTrB1as/83UMUVFEzv2UuI0bAUi/eJFrr79BiTWrcSxV6pmvL4R4SuVbQ+8NsKYHpCfAtQPwbRvovQnc/DJ9mQDXAOt2VHJUTkQqRLaQ6V1CCCFynUqlYvny5TZjFStWpHLlyqiz2FRRCCHskdbPj6CPplFi/TqcKlcGwBQfz/VBgzHExCgcnRAFVEgj6P8juPhYnt86Bd+0hNhrmb6En/P9BFFUiiR9hP2ST9ZCCCFynclkYt26dTZjPXv2xGAwKBSREELkLOcqVSi+7FscK1QAQB8WRtjQYZhSUxWOTIgCKqgGvLYDPIpYnsdcgK9bQtS/mTrdJukjlT7CjknSRwghRK4yGAz88ssvxPznG+6+fftKLx8hRL6mdnWl6OLP0QZYpoWknDzJjffex2wyKRyZEAWUX1kYsAN8Sluex4fDhgGZO9VFKn1E3iA9fYQQQuQqrVbLihUrbMaef/55ihYtqlBEQgiRe3QBARRd/DlXevXGnJxMws6dXHzpZVQODkqH9li6okXxHToElxo1lA5FiOzlVRQG7LRU+cSEWqZ63b4M3iGPPc1N54aTxolUY6pU+gi7JkkfIYQQuSolJYUtW7bYjPXs2RO9Xo9Op1MoKiGEyD1OFSpQZO4crg8ZCiYT+hv2v9xz+pUrJP3xBx7tXmHkwIEkmc14eHgoHZYQ2cPVF6p1gz1TLc8v7X1i0kelUuHn4sf1hOtS6SPsmiR9hBBC5Bq9Xs+GDRtITk62jmm1Wnr27CkJHyFEgeLWpAmB06YRNXcuprQ0pcN5PL0e091/t+N/+JFXXFzwffNNvF/rr2xcQmSnks0yJH1+heeePM3Lz9mS9ElITyDVkIqT1ilnYxQiCyTpI4QQItfodDp++eUXm7HmzZtTqFAhhSISQgjleHXsgFfHDkqH8URmg4E7331H1Lz5mOLiMCcnE/Xpp8Ru2EDAe2Nwe/FFVCqV0mEK8WyCqoOTF6TGwqXfwGQE9eN7Df63r09Rd5mqLuyPNHIWQgiRa4xGI8uWLePAgQMMHjwYHx8fevXqhV6vVzq03FW/vuVPler+thBC2CmVVot3r16U2vEThXr2ALXlVwj99euEDX+LawMGkBYaqnCUQjwjtQZCGlu2U2Ph5oknnpJxBa/olOiciUuIZyRJHyGEELnm3upcderUYeHChdy6dYuuXbsWvKldVavC+fMQGgrlyikdjRBCZIq2UCEKT5iA74oVGGvUIMlkBCD54J9c6tCRW1OmYoyNVTZIIZ5FqRfub1/c+8TDfZ19rduRyZE5EZEQz0ySPkIIIXKdRqNBrVaj1WoL7jLtZctCqVJKRyGEEE+tRvt2VFm7hvZ37qALCrIMGo3cWbWKiy1bcWfNGsxGo7JBCpEVJTMkfS79+sTD/V38rdtS6SPslSR9hBBCKEr6QAghRN6kcnSk5PZt+I0cgcrZGQBjbCy3Jn/I5U6dSfrrL4UjFOIpeYdAoRKW7Wt/QnrSYw/PWOkjy7YLeyVJHyGEEEIIIUSWqJ2c8B0yhFI/bcejTRvreNr581zr24+wt0ehDw9XMEIhntK9ah+THq4eeOyhGSt9ZNl2Ya8UT/rs27ePzp07U61aNZo1a8ZXX32F2Wx+7Dm//vorr776KlWrVqVx48ZMnTrVZvlfIYQQQtgXeb8XIn/TFS5M8CcfU3zVShwrVrCOJ+zYwcXWbYiaN5+Ukycf+zDGxSn4CoS46yn6+kilj8gLFF2y/cSJEwwePJhWrVoxcuRIjh49yuzZszEajbz55psPPWfPnj0MGzaMDh068O6773Lx4kXmzJnDnTt3+OSTT3L5FQghhBDiSeT9XoiCw6VWLULWryd240ai5n6K8fZtzGlpRC9aRPSiRY89V+3pSci673AoXjyXohXiIUo0AlSAGS49Punj4eCBg9qBdFO6VPoIu6Vo0mf+/PlUqFCB2bNnA9C4cWMMBgOLFy+mb9++ODk5PXDO9OnTadGiBdOnTwegfv36GI1GVqxYQUpKCs535xMLIYQQwj7I+70QBYtKo6FQly54tGhB9KLPub1yJRgMTzzPFBdHxMxZFF20MBeiFOIRXLwhqAbcOAaRZyHhFrgXfuihKpUKPxc/whPDJekj7JZi07vS09M5dOgQL7/8ss14ixYtSEpK4ujRow+cc/bsWa5du0bv3r1txvv168euXbvkA6AQQghhZ+T9XoiCS+PhQcD771Hyhy34DBlMob59HvnQ+FmmySTu2UPSgcf3UREix5XK/Cpefs5+AMSlxZFuTM/BoITIGsUqfa5fv45er6dEiRI248XvlnNevnyZBg0a2Oz7559/AHB0dGTQoEEcPHgQJycn2rdvz+jRo3FwcMiV2IUQQgiROfJ+L4RwLFkS/5EjH3uMc6VK3HjvfQAipk8nZNMmVFpFJyWIgqzkC/DH3anEF/dCte6PPNTPxc+6HZUSRbBbcE5HJ8RTUazSJyEhAQA3NzebcVdXVwASExMfOOf27dsADB8+nNKlS7N06VIGDhzId999x9ixYx95r/T0dBITE62PJzWOFEIIIUT2kPd7IURmeLzyCk5VqwKQFnqBO+vWKRyRKNCK1gGdi2X70l4wmR556L1KH5BmzsI+KZY+Nz3mfxwAtfrBfJRerwfg5ZdfZvTo0QDUq1cPs9nMJ598wvDhwwkJCXngvCVLlrBgwYJsiFoIIYQQT0Pe74UQmaFSqwkY+z5Xe/QEIHrefDzbtEHj6alwZKJA0jpaGjqH7oTECDj9PVTt+tBD/1vpI4S9UazSx93dHYCkpCSb8Xvf+P33G0G4/61g06ZNbcYbNWoE3C8H/69BgwZx9OhR68Pf3/+ZYhdCCCFE5sj7vRD5z5YtWzhw4ABbtmzJ1uu61KiBR9u2ABhjY4laKA2dhYLqD72/vWcKGNIeephU+gh7p1ilT7FixdBoNFy9etVm/Nq1awCUKlXqgXPu9QNIT7dtkHXvG0FHR8eH3svBwcFm/r9Kpcpy3EII5bz//vts2rTpkfuXL19u3T9jxoxciSer9woLC+PFF19k9+7dFClS5IH9GzduZMGCBezZs+eZ4wRLY9yJEyfy77//Urp0aSZPnkzlypUfemxcXBx16tSxGfPy8uLQoUM2Y7GxsbRu3Zp169bZvIanuZfI/+T9Xoj8p1atWjl2bf933yFh1y7MqancWb6COytWZt/FVSpcatbEf8xonO9OJRPikUo2hVLN4OIeiL0GR76GekMeOCxj0ic6JToXAxQicxSr9HF0dOS5557jl19+sZlzv3PnTtzd3an6kH+In3vuOVxcXNi2bZvN+J49e9BqtdSoUSPH4xZCKOeDDz5g37597Nu3j3HjxlG4cGHr83379sm/AY+QnJzMm2++yXPPPcfGjRupUaMGgwYNIjk5+aHHX7hwAS8vL5uf7fbt222OiYuLY/DgwcTExDzTvUT+J+/3QoinoQsMxOeNN+4PmM3Z9zCZSD5yhCtdu3Hj/bHoIyOVe6Eib3hp0v3t32ZBatwDh2Sc3hWZLH+nnlazZs0oV66c9VGpUiVatmzJt99+m+33mj9/Pn369Mm24/IKRVviDxkyhNdee42RI0fSuXNnjh8/zldffcW7776Ls7MziYmJXLhwgWLFiuHt7Y2rqysjRoxgxowZeHh40Lx5c44dO8aXX35J37598fb2VvLlCCFymLu7u3WqiLu7OxqNBj8/vyecJbZv346joyNjxoxBpVLxwQcf8Pvvv7Njxw46der0wPGXLl0iJCTkkT/bI0eO8N5771mn4DzLvUTBIO/3Qoin4TPwDQyRkaQ+YipnVhliojHcuAlA3ObNJPz8M75vvYV3/35SGSgeLrAaVH7V0tMn5TYcmA/NxtscIpU+z27cuHG0bt0aAIPBwJ9//skHH3yAl5cXHTp0yLb7DBgwIFPJnMwel1comvSpX78+8+fPZ968eQwbNoyAgADGjBnDgAEDADhz5gx9+/Zl+vTp1l8WXnvtNTw8PPjmm29Yv349/v7+vPXWWwwcOFDJlyKEsCOJiYmMGjWKPXv2UKhQId59911eeeUVwPJtQqtWrdiyZQu+vr5s2rSJ0NBQpkyZwsmTJwkMDKRv37706tULgPj4eD744AMOHjyISqWiSZMmTJo0ydqH5HH3SktLY968eWzdupW4uDjq1avHxIkTCQwMfCDmiIgIPvjgA44cOUJISAhNmjR55OubP3/+I5vVnj9//oGxkydPUqtWLesHWpVKRc2aNTlx4sRDEzEXLlx4YHntjPbt20fnzp1p06YNzZs3f6Z7iYJB3u+FyF+2bt1KSkoKzs7OtL3bgyc7qR0dCfxwcrZf16zXc2fNWqIWLMAUH48pOZnImTMxp6XiO3hwtt9P5BPNxsPZLWDSw8GFUHsguAdYd3s6eqJT69Cb9ESmSKVPVri7u9t82dixY0e2bt3Kzz//nK1Jn4d9Yfksx+UViiZ9wLIyx8svv/zQfXXr1n3oLzCdO3emc+fOOR2aECKP+uWXXxg9ejTvvPMOq1evZty4cTRt2tRaJfTjjz/y1VdfYTabSUtLY+DAgXTs2JEpU6Zw6dIl/ve//+Hq6kqHDh2YN28eUVFRrFmzBoPBwOjRo1m0aBFjxox54r0mTpzIsWPHmDlzJl5eXnz88ccMHTqUDRs2PBDzyJEjcXFxYf369YSGhvLBBx9QqFChh76+AQMG0L1790z/PKKioihdurTNmI+PD6GhoQ89/uLFixgMBl599VUiIiJ47rnnGDt2rLUp7ttvvw1Y+hI9671EwSHv90LkH4MHDyY8PJzg4OCHvhfYK5VOh3ffPni0bUPUvHnErv0OgKhPP0NXpCiebdsoHKGwS94h8NwA+GsJ6JPht5nQdo51t0qlws/ZjxtJN4hOlkqf7KLVatHpdPTp04eyZcvy66+/YjQa2bp1KwkJCUyePJmDBw/i4+NDp06dGDJkCBqNBoDff/+duXPncunSJYoXL87YsWOtX0D99ddfrFixAr1ez+TJk/nll19IT0+nbt26TJ48mYCAAJvjAI4fP86sWbP4559/8Pb2ZuDAgfTo0QOw9Pj09PQkIiKCvXv34uXlxahRo7I1WfWsFE/6CCFEdqtRowZv3O0HMHToUL7++msuXbpEtWrVAGjXrh3lypUDYP369fj4+FgTGSVKlCA8PJzly5fToUMHwsPDcXV1pUiRIjg7O/PZZ59l6l4lSpRgy5YtfPHFF9SrVw+Ajz/+mKZNm7J//36b5aZDQ0M5fvw4e/fuJSgoiDJlynD69Gl27Njx0Nfn6ur6VN9ApKSk2DS3BUvD2/82yb3n0qVLeHt7M3bsWMxmM3PnzmXw4MGsX7/e+maaXfcSQgghcpvW25vASZNwKFKEyI8/AeDm2LHoAgvjkoNNqkUe1ng0nFgF6Ylw9FtoMgbcC1t3+7r4ciPpBnfS7qA36tFpdMrFmsG2v28y55fzJKUZc+2ero4a3m1ejtZVHqxszwy9Xs/evXvZv38/H330EevXr2fjxo189dVXODg44OrqSr9+/ShfvjybNm0iKiqKCRMmoFKpGDZsGKGhoQwZMoRhw4bRunVrfv75Z4YOHcrPP/9sc59Vq1Zx+PBhvv76a5ycnJg0aRIfffTRA5/1L168SL9+/ejfvz/Tpk3j5MmTTJ48GV9fX+uXWatWrWLkyJG8++67LF++nIkTJ/Liiy9av3BWmiR9hBD5TtGiRa3b9/6xTUu7v8xmcHCwdfvSpUucO3fOpjGs0Wi0Jjf69u3L0KFDqV+/PvXr16dFixbW6VuPu9eVK1cwmUzWRBNYVsAKCQnh4sWLNkmfe42Tg4KCrGNVqlR5ZNJn8eLFLFmy5KH7jh8//sCYo6PjA0mX9PR0nJycHnqNbdu2oVKprPvnzZtHw4YNOXnyJDVr1nzoOVm9lxBCCKEU79dfJ/3qNWLXr8es1xM2dBglvluLw2OmOIsCys0PavSGQ4vBbITIszZJH39nf+t2dEo0gW5ZS3hkt6W/X+RiVFKu33fJ75eeKukzceJEpkyZAkBqaipOTk7069ePdu3asX79epo2bWr9DHrw4EFu3LjB+vXrUavVlCxZkvfee4+xY8cybNgwvv/+e2rWrMnQoUMBePPNN0lOTiY+Pt7mnmFhYTg6OhIcHIyXlxczZswgNjb2gdjWrVtHxYoVeeeddwAoWbIkFy9e5Msvv7QmfcqVK2edfj5y5EiWL19OaGjoEz835xZJ+ggh8p2HVaNkXDUo43LPBoOB+vXrM2HChIdeq379+vz222/s3r2bX3/9lQkTJrBv3z4+/vjjx97rUUtKG41GTCbTY+MD0Oke/Q1R9+7dadWq1SP3/1dAQADR0bblxtHR0dbpWv/l7Oxs89zHxwcvLy8iIiKy/V5CCCGEUlQqFYUn/A/9jRsk7d+PMS6Oa4MGUXTBAhzLlFE6PGFvCt3/wo4E289Evs6+1u2olCi7SfoMalKKT37O/UqfQY1LPtU5I0aMsPaJdHR0xM/Pz+YzdsYvbC9evEhsbCy1MlTlmUwmUlNTuXPnDpcvX6ZSpUo2179X0Z9Rt27d2LZtGw0bNqROnTq89NJLD+0/efHixQdWGq1RowZr1661Ps/YC/Ne30+DwZCJV547JOkjhCjQQkJC2L17N0WKFLG+uWzZsoVTp04xfvx4vv32W8qVK0fHjh3p2LEj27ZtY+zYsU+8btGiRdFqtZw4cYJGjRoBcOfOHa5evWpT5QNQtmxZ4uLiuHr1KsWLFwfgn8esWOLl5YWXl1emX2O1atX44osvMJvNqFQqzGYzx44dY/BDmlYmJibywgsvMH/+fOu0tIiICO7cuUPJkk9+A3+aewkhhBBKU+l0BH86l6s9e5EWGor+6jUudehIoR498HtrOBpPT6VDFPYiQ/NmEm/Z7PJ3uf/lVlRyVG5F9EStqwRmeZpVbvLx8bF+Bn6Y/35hW7JkSRYtWvTAce7u7mi1mUtxlClThj179vDrr7/y66+/MmfOHLZu3cqqVaseee97TCYTRuP9RNrDvqz97xe6SlIrHYAQQiipXbt2pKamMmHCBC5evMhvv/3GtGnT8PHxAeDWrVt8+OGHnDhxgitXrrBz504qVqz4xOu6urrSpUsXpkyZwqFDhzh37hyjR4+mcOHCNGjQwObYUqVKUb9+fcaNG8e5c+fYtWsXK1euzLbX2LJlS+Lj45k2bRoXLlxg2rRppKSkWKuFUlNTiYqyfEBxc3OjVq1aTJ8+nb///pszZ84watQoGjVqZO2D9Cz3EkIIIeyNxt2doksWoytezDJgNHJn5UoutmjJnTVrMBtzr0pC2DG3+9O5nlTpI3JOSEgIN27cwNvbm+LFi1O8eHHCwsKYN28eKpWK4sWLc+7cOZtzunfvzrZt22zGNm/ezN69e2nVqhUzZ87kyy+/5OjRo8TExDxwv5MnT9qMHT9+/IEvce2ZJH2EEAWam5sbX3zxBVeuXKFDhw6MHz+eXr16MWjQIMAyL7dmzZoMGTKE9u3bk5yczOzZszN17ffee4/nn3+eESNG0KNHDxwdHfn2228faHQMMHfuXAoVKkT37t2ZM2cOffr0ydbXuGTJEo4ePUqnTp04efIkS5cuxcXFBYDt27fTsGFD6/EzZ86kYsWKvPnmm/Tp04fg4GDrdLZnvZcQQghhj3RBQZTcsgW/kSNQ3Z3mbIyN5dbkD7ncqTNJf/2lcIRCcZmt9JGkT45q2LAhwcHBjB49mvPnz3PkyBH+97//4ezsjEajoUePHhw5coRvvvmGq1evsmTJEkJDQ3nuuedsrpOQkMC0adM4ePAg169f58cff6Rw4cIPrJ7bs2dP/vnnH+bMmcPly5fZtGkTq1evplevXrn5sp+JTO8SQuRJnTp1eui82xkzZjwwlnEp6D179jywv1KlSg+Uct7j7OzMtGnTHrrvSfdydnZm0qRJTJo06YHjihQpYnNsoUKFWLBggc0xw4cPf+h9s6Jq1aps2rTpofv++7P09PRk+vTpT7zmf19DZu4lhBBC2Cu1kxO+Q4bg2bEjkbM/Jv5uZUDa+fNc69sP95YtCRj9f+gy9BcRBUhmK33saHpXfqTRaPj888+ZMmUKXbt2xcXFhZYtW/Lee+8BUKxYMebPn88nn3zCnDlzKFOmDIsXLyYgIMDmOr169eLWrVuMHj2auLg4KleuzOeff/5Av86goCCWLFnCrFmz+PrrrwkKCuL999+nc+fOufaan5XKbE+TzXJJ48aNiYiIICAggN9//13pcIQQQgh5b8oB8jMVImcUKVKE8PBwgoODCQsLUzqcHJN89CgR0z4i9exZ65jK0RGfN97A543XUf9n4QNRAEwvCmnx4F0SRtxfMfV26m2afNcEgIbBDfn8pc8ferq8LwklyPQuIYQQQgghRKa5ubnh7u5uXaUmv3KpVYsS69cROHUKGm9vAMxpaUQvXMjF1m2I377drpq1ilzgdrda5D+VPl6OXmjVlkk0Uukj7E2Wp3clJiZy4cIFDAbDA//Y1a5d+5kDE0IIIYQQQtif/zZJzc9UGg1er76Ke4sWRC9cxO2VK8FgwHDzJuHvvIvzqtU4V6uW4Xg17i+/jPN/lngW+YR7YYgJBX0SpCWAozsAapUaX2dfbiXdkp4+wu5kKemzZcsWJk2aREpKygP7VCrVY5caFkIIIYQQQoi8ROPuTsD77+HVtQsR02eQ9McfAKQcPUrK0aM2x95esZLiy5dJ4ic/csvQFyYhwpr0AfB39udW0i3upN5Bb9KjUz+4jLcQSsjS9K65c+fSpUsXjhw5wrlz52wekvARQgghhBBC5EeOJUtSdOkSiiz+HIfixR96jDk1letDhpIeFp7L0Ykc556hmfN/VvC618zZjJmYFNtlv4VQUpYqfWJjY+nbt2++n8crhBBCCCGEEBmpVCrcmzbFrUEDUs+dx5yeZt0X9elnJB8+jDEmhuuDB1Fi9Wo0Hh4KRiuyVcakT4Jt0sfPxc+6HZ0STWHXwghhD7JU6fPCCy/w888/Z3csQgghhBBCCDs3evRo3njjDUaPHq10KIpS6XQ4V6mMS61a1keR+fNwCAkBIP3CRcJGjsSs1yscqcg2GZdtT7Rt5uznfD/pE5kcmVsRCfFEWar0CQgIYO7cufz0008UL14cnc52vuL06dOzJTghhBBCCCGEfVmzZo11yfbZs2crHY5d0Xh5UXTJYq50647xzh2SD/7J5a7d0BYq9MhzdMFB+Lz+Og4lSuReoCJr3DP29Hl8pY8Q9iJLSZ+4uDjatm2b3bEIIYQQQgghRJ7mUKwYRRYu5Fr//pjT00n75x/SnnBO7OYt+PTri8/gIWjcXHMlTpEFbo+e3nWvpw9ATKr09BH2I0tJH6nkEUIIIYQQQoiHc6lZg6CPZ3PjvfcxP2TF4wfo9cR8+RWxW7bg/867eLZvh0qdpU4cIidlrPT5TyNnB42DdVtvlCl9wn5kKekDsGvXLr788ksuXbqE0WgkJCSE3r1706FDh2wMTwghhBBCCCHyHo/mzXF/4QVMaemPPMasT+f2t8u4/c03mNPTMUZFc3PsWO6sWUPhD8bhXK1aLkYsnsjRA7TOYEixLNmegVZ1/1drg8mQ25HlWc2aNSM8/P5KdyqVCg8PD2rVqsWECRMIDAzMsXu///77AMyYMYP58+fz119/sWLFihy7n1KylPRZu3YtM2fOpHfv3rz55puYTCaOHTvG5MmT0ev1dOnSJbvjFEIIIUQuS0hI4IcffuDy5csMHTqUkydPUqpUKYoVK6Z0aEIIkSeodDo0/+l/assV/1Fv4/VqZyJnzSbhl18ASP37b650645n+/b4vfsOOn//3AlYPJ5KZan2uXPlgUofrTpD0scsSZ+nMW7cOFq3bg2AyWTiwoULTJw4kffee4/ly5crHF3el6Wkz5dffsnEiRNtqnpeeuklypQpw+LFiyXpI4QQQuRx//77L/369SMwMNC6/fPPP7Njxw6WLFlCnTp1lA5RCCHyDYeiRSkyfx5JBw8S8dFHpIVeACBuyxbit29H/TTLvqtUuNatS+D0j1A7ODz5ePF03Apbkj6pcaBPAZ0zADr1/eSeVPo8HXd3d/z87jfCDggIYMSIEYwePZqEhATc3d0VjC7vy9JE0ZiYGKpXr/7AeI0aNbh58+azxiSEEEIIhU2dOpUePXqwceNG6yqd06dPp2fPnsyaNUvh6IQQIn9yrV+fkE2bCBg/HrWnJwBmvR5jTEzmH9HRxG/bxs1xH2A2mxV+RfmQTV+f+1O8NGqNdVuSPs/O4W7CUq1WEx8fz+jRo6lZsyYNGzZkypQppKamWo/9+++/6dGjB9WqVaNFixZs27bNum/9+vW0bNmSypUrU7duXSZPnozRaMz116OkLFX6VKhQgc2bN/P222/bjG/atInSpUtnR1xCCCGEUNCpU6eYOnXqA+Pdu3dn1apVCkQkhBAFg0qrxbt3LzzatCZ60eck/f475qf4JdUQEYFZryd+61YcihXDb8RbORhtAWSzglcEFCoB2GlPnzObYO9HkJaYe/d0dIMXPoBKHbJ8iWvXrrF06VIaNWqEq6srb731Fnq9njVr1pCWlsbUqVP58MMP+eijj4iJiWHAgAG0a9eOadOmceLECd577z1KlSpFfHw8U6dOZfbs2VSsWJHTp08zevRo6tevT/PmzbPvNdu5LCV9Ro8eTf/+/Tl06BDV7jYXO3HiBOfOnWPx4sXZGqAQQgghcp+3tzeXL19+oH/PsWPH8PHxUSgqIYQoOLSFClH4g3HwwbinOi9h1y7C3hoBZjPRixahK1oUr44dcibIgugRK3hl7OljNNtJJcn+eRD9b+7eMwE4MO+pkj4TJ05kypQpABgMBnQ6HS+++CLjxo3j2rVr7Nq1i7/++ss6zWvKlCl06NCBsWPHsm3bNjw9PRk/fjxqtZqSJUsSFxdHamoqLi4uTJs2zZrgKVKkCN988w2hoaGS9HmSGjVqsHHjRtatW8fFixdxdHSkdu3azJ07N0e7awshhBAidwwcOJDx48czePBgzGYzf/75J5s2bWLZsmWMGjVK6fCEEApq06YNt2/fxtvbW+lQxEO4v/QS/u+NIXLGTABuTpiALjAQ13p1FY4sn/hvpc9dGZM+epOdLNneYCTsnZb7lT7Pj3iqU0aMGEHz5s1JSkpi/vz5hIeH8+6771KoUCFOnDiByWSicePGNueYTCauXr3K5cuXqVixImr1/c41r732mnXbycmJefPmceHCBc6fP8/Vq1dp2LDhs73GPCbLS7aXKlWKsWPHZmcsQgghhLAT3bt3x9/fn6+++gonJydmzZpFSEgIU6ZMsa6wIYQomJYsWaJ0COIJvPv1Q3/tOndWrwa9nrARIyixdg2OJUsqHVrel4lKH7uZ3lWpwzNNs8otPj4+FC9eHIDPPvuMV199laFDh/Ldd99hNBpxd3dnw4YND5wXEBCAVvvolMYff/zBsGHD6NChA40aNWLYsGFMnjw5x16Hvcp00qdv374sWLAADw8P+vTpg0qleuSxsqyaEEIIkbd9+eWXtG3bVvr3CCFEHqRSqQgYN5b08DCSfvsdU3w8198cRIl136GVCq1nk4lKH7tJ+uRBDg4OTJ06lW7duvHtt9/SrFkzEhISUKlU1inn58+fZ968eUyfPp0SJUrw22+/YTabrTmKt99+m8qVK/P333/TuXNnJk6cCFimjl27do169eop9vqUkOnVu+rUqWNdvaNu3brUqVPnkQ8hhBBC5G2LFy9Gr7eT8nQhhBBPTaXVEvzJHBwrVABAHxZG2NBhmDKseiSywD1DO5OMlT4qO+zpk0dVrVqVV199lUWLFuHm5kajRo34v//7P/7++2/OnDnD2LFjSU5OxsPDg1deeYXY2FhmzZrFlStX2LhxI7t376ZBgwZ4eXlx/Phxzp8/T2hoKO+//z5RUVGkp6cr/RJzVaYrfYYPH/7Q7Xtu375NoUKFHlsBJIQQQoi8oW3btnz++ee8+eabBAUFWZdOFUIIkXdo3FwpuvhzrnTthiEigpQTJ7jx/liC53yCSp3p7/9FRi7eoNaBSS+VPjlo1KhR7Ny5k9mzZzNr1iymTp1K//790Wq1NGrUiPHjxwPg4eHBkiVL+Oijj1ixYgVFixblk08+oUKFCgwfPpyxY8fSrVs33NzcaNKkCT169OCff/5R+NXlriz19ImIiGDGjBm8+eablCxZktdff52jR48SGBjIokWLKF++fHbHKYQQQohc9Pvvv3Pjxg02bdr00P0F7QOTEOK+5557jlu3blG4cGGOHDmidDjiCXQBAZbET6/emJOTSdixgwgfH9yaNrUeoylUCKdKFeUL/MxQqcAtAOLDbCp9NGqNdVuSPpm3Z8+eh457e3vz119/WZ/PmTPnkdeoUaMG69evf2D8Xm/CR5kxY4Z1+6233spMuHlSlpI+kyZNIjk5GS8vLzZu3Mi///7L2rVr+eGHH5gyZYrM/xdCCCHyuIwfhIQQIqNbt24RHh6udBjiKThVqEDwnE8IGzoMTCburFrFnf/8zub8XC0KjxuHU8WKCkWZh7jfTfokRYPRABqtVPoIu5WlpM+ff/7Jxo0bCQwMZNeuXbz44otUq1YNb29v2rZtm90xCiGEECKX3evRd+XKFS5evIjJZCIkJITSpUsrHJkQQoiscG/alIAPxhExZepD96ccOcrlzq/i1aULfm+PlIbPj2Nt5myGpEjwCLLp6WMwS9JH2I8sJX0cHR1JS0sjLi6OQ4cO8cknnwAQFhaGp6dntgYohBBCiNwXHx/P2LFj2b17N56enhiNRpKSkqhduzYLFy7E3d1d6RCFEEI8Je9evdAFBpJ65uz9QbOJuG3b0F+9BmYzsevWEf/TT/gNH0ahnj1R3V3MR2SQcdn2hJvgEYRKpUKj0mA0G6XSR9iVLCV9XnrpJd5++22cnJzw9PSkadOmbN++nY8++oiOHTtmd4xCCCGEyGVTp07l1q1bbN++nZIlSwJw4cIF3n//faZPn85HH32kcIRCCCGywr1ZM9ybNbMZ8xk8mDsrVhC96HNMSUmYEhKImD6DO+vWEzB2LG4NGygUrZ16zLLtRqMkfYR9yVLL9kmTJtG9e3dq167NsmXLcHR0JD09ncGDB/POO+9kd4xCCCGEyGV79uxh0qRJ1oQPQOnSpZkwYQK7d+9WMDIhhBDZTe3ggM/rr1Nqx094ZvgSP/3iRa6/8QbXhw5DHxHxmCsUMBkrfTIu2363r4/RJEu2C/uRpUofrVZL//79bcY6dOiQDeEIIYQQwh44OjqifshyviqVCqNRPswKIUR+pPXzI2j6RxTq2YOIqdNIOXkSgMQ9e7h+6yYhGzbICl/w2EofkJ4+wr5kOunTt29fFixYgIeHB3369Hns/+zLly/PluCEEEIIoYxmzZoxefJkPv74Y4oVKwZYmjpPnTqVJk2aKBydEEKInORcpQrF16wm/scfiZj9McboaNLO/kPSgQO4NZCpXo+q9NGoLMu2y/QuYU8ynfSpU6cOurtNvOrWrZtjAQkhhBBCeaNHj2bYsGE0b97cukhDXFwcjRs35n//+5/C0QkhhMhpKrUaz/btUTk7Ez5iJAB3VqyUpA88sdJHb9LndkRCPFKmkz7Dhw+32Y6JiSE+Pp6QkBAAtm/fTu3atfHz88v+KIUQQgiRqzw8PFixYgXnz5/n4sWLODo6EhISYtPjRwghRP7n3qwZ2qBADDdukvjbb6RfvYpD8eJKh6UsVz9ABZhtKn10akuRhPT0EfYkS42cDx48yMsvv8yPP/5oHVu+fDmtW7fm6NGj2RacEEIIIZSRnp7OrFmzOHLkCK1bt+bFF1/k//7v//j444/R6+UbTCEKslmzZvHFF18wa9YspUMRuUCl1eLds6flidnM7VWrlA3IHmi0dxM/SE+fZ9SsWTPKlSv3wKNHjx42x33++ee8//77T7xedHQ0Y8eOpX79+lSpUoW2bduyYsWKnAo/T8hSI+eZM2cyePBg3nzzTevY2rVrWbJkCR999BEbNmzItgCFEEIIkfumTp3K0aNH+fDDD61jQ4cO5dNPPyU1NZXx48crGJ0QQkk97yUARIHh9eqrRC1YiDk1lbgNG/EbMRKNm6vSYSnLPQCSIi0PkwnUaunpk0Xjxo2jdevWNmP3WssAbN26lfnz59OuXbvHXsdsNvPmm29SpEgRvvzySzw8PDh+/DiTJ09Gr9czYMCAHInf3mWp0ufKlSu0bNnygfFWrVpx4cKFZw5KCCGEEMr6+eef+fjjj6lVq5Z17KWXXmL69Ols375dwciEEELkNo2XF56vvAKAKSmJuM2blQ3IHtzr62MyQHIMkKHSR5I+T8Xd3R0/Pz+bh5eXFwaDgYkTJzJu3DiKFi36xOucP3+eM2fOMHXqVCpVqkTRokVp164dr7/+OuvWrcuFV2KfspT0KVmyJD/99NMD43v27LGu8CGEEEKIvMtsNpOWlvbQcZneJYQQBU+h3r2t23dWrMBsMikYjR14yApe95I+0tMneyQnJ3P+/HnWrVtHjRo1nni8Wm1Jb+zfv99mvHfv3nzxxRfW51evXuX111+nRo0aNG3a1Gb18YsXL/L6669Ts2ZNGjVqxIIFCzDd/bs+f/58hg4dSq9evahTpw5//fUX6enpTJ06lbp161K3bl3+7//+j9jY2Gx49dknS9O73n77bYYOHcr+/fupVKkSYMmqHTlyhPnz52drgEIIIYTIfS1atOB///sfEydOpGLFigCcO3eOqVOn8vLLLyscnRBCSefPn8dgMKDVailXrpzS4Yhc4lSuLC5165J86BDpV6+StG8fbo0bKx2WctwD728nREDhKjY9fcxmMyqVSqHgLHZe2cnCEwtJ0ifl2j1dda4Mrz6c5iWaP/O1PDw8WLt2baaPL1u2LPXq1ePtt99m6dKlNGrUiAYNGvDcc8/h4eEBQFpaGgMGDKBSpUqsW7eO69ev8+6771K0aFGqVatGz549adasGevXr+fy5cuMHz8eNzc3+vfvD8Du3buZNGkS1atXJyQkhDlz5nD69Gm++OILHB0dmTt3LiNHjmTZsmXP/PqzS5aSPo0bN2bTpk18//33XLp0Ca1WS/ny5Zk8eXKmyq6EEEIIYd/Gjh3LBx98QL9+/azfcGk0Gtq3b8+4ceMUjk4IoaQXX3yR8PBwgoODCQsLUzockYu8+/Yh+dAhAG6MHoPGzzfT5+oCg/AdPAiXDNOG8zS3h1T6qO7/em0wG9CpdP89K1d9e/pbLsddzv37nvn2qZI+EydOZMqUKTZj+/fvx8XF5anvvXTpUr766iu2bNnCkiVLWLJkCUWLFuWTTz6hWrVq7Nu3j9u3b/PRRx/h5uZGmTJlGD9+PGq1mq1bt+Ls7MyUKVPQarWUKlWKqKgoFi5caE36+Pr6WptMp6SksHLlSjZs2GBNgM+aNYu6dety/vx5u0mKZynpA1CmTBnGjh1LXFwcbm5uqNVqxTOZQgghhHh20dHRFCpUiDlz5hAfH8+VK1c4fPgwjo6OdOrUKUsfwoQQQuR9bk2bogsORh8ejjEuDmNcXKbPTb9wkaQ//sCjdWv8R/8fusDAJ59kz9wL399OsJ3eBZa+PveWcFfKa5VfY8GJBble6dO/Uv+nOmfEiBE0b26bJHJ2dn7sOT/88AMTJ060Pp88eTLt2rXD0dGRoUOHMnToUK5du8bevXv5+uuvGTJkCHv37uXy5cuEhITg5uZmPbdz586AJflUqVIltNr7/x1r1KhBVFQU8fHxAAQHB1v3Xb9+Hb1eT/fu3W1iM5lMXLlyJW8nfcxmM4sXL+bbb78lISGBnTt38tlnn+Hi4sL48eNxcHDI7jiFEEIIkcOSkpJ49913+e2339i6dSulSpVi9+7dfPDBBxQuXBhHR0e++eYbVq1aReHChZ98QSGEEPmKSqMh4H/juTX5Q0x3fwnODLPRiDk1FYD47dtJ2LsXn4Fv4DNgAGonp5wKN2e5ZXgfTLQs254x6WMPfX2al2ieLdOscpqPjw/Fixd/qnOaNWtGtWrVbK6xc+dOYmJirCsMFitWjH79+tGwYUNat27N+fPnbRI6/+Xo6PjA2L1qZ6PR+MAx98ZWr179wBdiPj4+T/V6clKWGjkvXLiQH374gRkzZlgTPB07dmT//v3MmjUrWwMUQgghRO6YP38+4eHhrFy5kpIlS5KcnMzUqVOpWrUqO3fu5KeffqJhw4Z8/PHHSocqhBBCIe5Nm1Jm7x7KHT3yVI/CkyejKVQIAHNKCtHz5nOpdRvid+zEbDYr/KqyIGMj57uVPveWbAdZwSunubm5Ubx4cevDzc2NGzdusGjRIlLvJhjvudfPx9vbmxIlSnD16lVSUlKs+2fOnMnUqVMJCQnhzJkzNgtWHD9+HG9vb7y8vB6IoWjRomg0GmJjY23imD59OjExMTnzwrMgS0mfTZs28eGHH/LCCy9Yp3Q1aNCAmTNnPnRVLyGEEELYv59//pkPPviAWrVqoVKp2LdvH0lJSfTp0wedzlKi3qlTJ/bt26dwpEIIIfISlUZDoW5dKbXjJwr17QMaS3JEf+MG4W+/zbV+/Uk9f17hKJ+S24NJH5vpXWZJ+uS2jh07otVqGTBgAAcPHiQsLIwDBw4watQomjdvTpEiRWjYsCG+vr5MmDCBixcvsnv3btauXUvDhg155ZVXSE9Pt+7btWsX8+fPp0ePHg9tZePm5kaXLl2YNGkShw4d4sKFC4wZM4arV69SpEgRBX4CD5elpE9MTAz+/v4PjHt4eJCcnPzMQQkhhBAi90VFRVGsWDHr8wMHDqDRaGjYsKF1zNfX1+bbMSGEECKzNJ6eFB43jpJbNuP6/PPW8eS//uJyx07cXr5CweiektYRnC2VS/9dsh2k0kcJXl5erF69miJFijB69GhatmzJuHHjqFGjBrNnzwZAq9WyaNEiIiMj6dixI9OmTWPMmDE0bdoUNzc3vvzyS65du0aHDh2YMmUK/fr1Y/jw4Y+85/vvv0/9+vUZMWIEXbt2RavVsnTpUjQazSPPyW1Z6ulTr149vvrqKz788EPrWGJiInPmzKFu3brZFpwQQgghck9AQADXr18nKCgIs9nMb7/9RrVq1fD09LQec/z4cQLzevNNIYQQinIsXZqiX31J4p49RMyYif76dTCZiPjoI7T+/ni0bKF0iJnjVhhS7liWbDebJemTBXv27MnUcTNmzMjUcUFBQU9sOVOqVKlHLqlesWJFVq1a9dB9b7311gNjzs7OTJo0iUmTJmUqPiVkqdJn0qRJnD17lgYNGpCWlsbQoUNp0qQJ4eHhjB8/PrtjFEIIIUQuaN++PdOmTWP37t189NFH3Lx509oMEeDcuXPMmTOHli1bKhilEEKI/EClUuH+4ouU3LYV79des47feO89Uk6cUC6wp3Gvr48xDVJjbZdsl6SPsBNZqvTx8PDg+++/5+DBg1y6dAmDwUBISAgNGzZErc5SHkkIIYQQChsyZAiJiYmMGzcOlUrFiBEjaNu2LWBpcvjNN9/QtGlThgwZonCkQggh8gu1gwP+Y0ZjvHOHuM2bMaelcX3oMEp8txaHokWVDu/xMq7glRAhlT7CLmUp6dO2bVsWLFhA/fr1qV+/fnbHJIQQQggFaLVaxo4dy9ixYx/Y16FDB1555RUqVqyoQGRCCCHyM5VKReCHk9HfvEnyoUMYb9/m+qDBlFizGk2GKcZ2J+MKXom3bJdsNyu/ZLsQkMXpXWq12mYZMyGEEELkb+XKlZOEjxACgMOHD3P9+nUOHz6sdCgiH1E5OFBk3mc4lCwJQPqlS1zp0ZPEffsVjuwxpNJH5AFZqvRp2rQpr732Gi+88ALBwcE4ODjY7H9cd2shhBBCCCFE3iXN3EVO0Xh6UnTJYq50647x9m3SL13i+htv4NasGQHvv4dDhhUm7cJ/Kn00uvsrNulNUiQh7EOWkj7nz5+nUqVKREZGEhkZabPvYevXCyGEEEIIIYQQT+JQtCjFl33LzfH/I+XkSQAS9+wh6Y8/cCxXDh7z+6ZjyZL4Dh2CQ/HiuRPsfyp9dL6+1qdS6SPsxVMlfbZs2cIvv/yCr68vL774orW5oxBCCCGEEEIIkR0cy5Sh+JrVxP/4I5Eff4IhKgqzXk/q6dOPPS/11Cnitm/Hp19ffAYPQePmmrOBumdI+iTeQut//7n09BH2ItM9fZYtW8a4ceNITU0lJSWFsWPHMmfOnJyMTQghhBBCCGFnli5dypw5c1i6dKnSoYh8TKVW49m+PSV/+gmfgQNRe3qCWv3oxz16PTFffsXFVi2J3bwZs9mcc0G6S08fYf8yXemzdu1apk2bRocOHQD4+eefGTt2LKNGjZIpXUIIIYQQQhQQH374IeHh4QQHB/Pmm28qHY7I5zRurvi/+w7+777z2ONMSUlEL/2C219/jVmvxxgVzc33x6K/HobfWznUc9bBFRzcIT3B0tNHdb+njyR9hL3IdKXP9evXbZZnb9asGSkpKQ/09BFCCCGEEEIIIXKT2tUV/1FvU3L7NtxeetE6Hr1wIbGbN+fcje81c5ZKnyyLiYlh6tSpvPDCC1SrVo02bdrw1VdfYTDY588wLCyMcuXK2TwqVapEw4YNmTJlCunp6Zm6jtlsZtWqVTkc7VMkfQwGA1rt/b/EWq0WR0fHTL8gIYQQQgghhBAiJzkULUrRBQvwHzPGOnbzfxNI+uuvnLnhvWbO6QlozSbrsMFsnwkLexMREUGXLl24fPkys2fPZuvWrQwbNoxVq1YxZMgQTCbTky+ikPXr17Nv3z727dvHzp07eeedd1i3bl2mp74ePnyYDz/8MIejfIqkjxBCCCGEEEIIkRd4v9Yfrx7dLU/0esLeGkHapUvZf6MMy7Zr05Ot21LpkzkfffQRwcHBLF26lOeee46iRYvSunVrVq5cyZEjR1izZo3SIT6St7c3fn5++Pn5UaRIETp16kT79u3ZtWtXps7P0X5TGTxV0uenn35i8+bN1ofJZOKXX36xGduck6VzQgghhBBCCCHEE6hUKgp/8AGujRsBYIqL4/qgwRhu387eG2VYtl2SPk/nzp077Nr1/+3de1yUZf7/8TfMMCMCSrplKQropqWJZ1vysMWuqWVpaaUpbFh4LMk8H76ah9aU0hRLzfRrWts5Wzuq2Wbr/r7ZZqJmamoCSmqmpuABmMPvD2RkBJPDwH0Lr+fjwcN77rnvuT9zPZAL3nNd1/25EhISZLFYvJ6rW7euevfurbfffluStHnzZjVp0sTrmPHjx2v8+PGex+vXr9ddd92lFi1aqE+fPvqmwOiu2NhYJScnex7nT9E6dOiQJOn06dMaM2aMWrdu7Zmmdf78+RK/J5vN5vVeNmzYoF69eql58+Zq27atnnrqKZ05c0aHDh1SXFycJKlJkybavHmzpLy1lGNiYtSqVSvFxsZqz549Ja7hUsVeyLlu3bpavny5177atWvrtdde89rn5+fnWewZAAAAAAAj+Fmtqjd3ntL691f2nj3KPXhQh4YNV4NXV8jfbvfNRbxG+mR6ts0Q+pz+7DMdW5As15kzFXZN/6AgXTtihGp063rFY3fu3CmHw6GoqKgin2/durVWrVpVrCVldu/erXHjxmnatGmKiorSxo0blZCQoDVr1ig8PPyK50+aNEm5ubl64403lJ2drZkzZ2r69On6+9//fsVzpbxRO998840+/PBDJSQkSJLS09OVmJioKVOm6LbbblNqaqpGjx6tt99+W3FxcUpOTtYTTzyhTZs2qWbNmvriiy+0cOFCzZgxQ5GRkfrggw8UFxendevWqWbNmsWqoyjFDn2++OKLUl8EAAAAAICKZgkOUv0li5X64ENy/PKLzqWk6Ofx41Xv+efl5++D1U4KjvQ5n+XZdrqdZX/tMjq+bLlyymNK25Wuu3x5sUKfkydPSpKCgoKKfD4/6Mg/7vcsW7ZMDz74oO655x5JUlxcnP773//qjTfe8BoNVJT09HR9/vnn+uabbxQSEiJJmjFjhnr16qUJEyZ49l2qR48enjuZ5+TkqFatWoqLi9Ojjz4qSXK5XJo8ebIefPBBSVJYWJhuu+027d27VxaLxfP+rr32WknSK6+8osGDB+uOO+6QJD355JP66quvtGbNGsXGxl6xDS6n2KEPAAAAAABXm4Drr1f9xYuUOiBW7rNnlfnpZzpWv4Gue2pk2V+8wEgfS/bFkT65rtyyv3YZ1X70UR1bsKDCR/rUHjiwWMeGhoZKylvMOSwsrNDzp0+flqTLhi4F7d+/X59++qneeustz77c3Fx17NixWOe6XC517tzZa7/L5VJaWppuueWWIs97+eWXVadOHf3888+aPn26brrpJg0ZMsQzvSsiIkI2m02LFi3S3r17tXfvXu3bt089e/a8bB1JSUmaO3euZ192drZSU1Ov+B5+D6EPAAAAAKBSq9a0qerNfV6Hhg2XXC4df/ll2RrUV2ifPmV7Ya+RPqc922aY3lWjW9dijbgxSrNmzWS1WvX9998XGfps3bpVkZGRql69umdETUEF7zDudDqVkJBQaKmZatWqFXltp9PptR0SEqL33nuv0HF16tQptC9f3bp1FRYWpvDwcC1ZskQ9e/bU7NmzNXnyZEl5U8769eunmJgYtW3bVo888oheffXVy76e0+nUxIkTFR0d7bU/ODj4sucUB3fvAgAAAFBsjRs3VtOmTdW4cWOjSwFKJOT221Vn4kTP48NPT9OZ//f/yviiF0OBgPOnPNtmCH3MrlatWvrrX/+qxYsXy+HIa69Vq1bpscce0zfffKPVq1frgQcekCQFBARIkrKyLk6hy1+EWZIiIyN16NAhhYeHe77eeustffXVV5LyFlg+U2DE08GDB73OzczMlJ+fn+fc8+fPa86cOcVaT0iSGjRooCeeeEKvvfaatm3bJkn65z//qXbt2un555/Xww8/rKioKKWlpXnu2nVpkBUZGakjR454vYfFixcrJSWlWDVcDqEPAAAAgGL74osvtHPnTtb8xFWp1oD+uibuwvooDocOjUhU9t69pX/BaqGSJW9RaOu53zy7zbCmz9Vg0qRJyszMVEJCgr799lvdeuutOnv2rGJjYxUaGuq5w9WNN96oatWqafHixTp48KBeeeUV/fDDD57XeeSRR/TJJ59o5cqVSk9P14oVK7RixQpFRERIkm655RZ9+umn2r59u7Zv364FCxZ4zm3UqJE6deqk0aNHa/v27dq5c6cmTJigs2fPqkaNGsV+L3FxcWrUqJGmT58ul8ul0NBQ7dmzR9u3b9eBAwf07LPPaseOHZ4gKTAwUJL0/fffKzs7W/Hx8Xr11Vf1wQcfKD09XUlJSfr000/VqFGjMrUxoQ8AAAAAoMqoM26cgmNiJEmurKy8W7kfO1a6F/Pz84z2sZy7uOAwI32K57rrrtPbb7+tyMhIjRo1Sn369NGJEyc8iyEPGTJEv/zyi4KDgzVjxgx9/PHH6tGjh3bv3q3+/ft7Xqdly5aaM2eO/vGPf+iuu+7S22+/reeff17t2rWTJMXHx6tp06YaMGCARo0apWHDhnnVMWfOHIWFhemRRx5RfHy8IiMjvdbWKQ6r1arJkyfr+++/13vvvafY2Fi1bNlSjzzyiB5++GH9/PPPGj58uCesatKkiTp06KC+fftq48aNuuuuuzRy5EgtWLBAPXr00P/93/9p0aJFnuCqtPzc+WOLDLJp0ybNmzdP+/btU+3atdW/f38NHDiwyDl7l3I4HOrbt68CAwO1atWqYl+zc+fOOnr0qOrUqeMZ7gUAgJEqe99Efw8AMBPX2bNKGxCr8xf+AK/WvLnCV74q/wujL0rklS7SoW/0dTW7Em7IC4ASmidoROsRXofRL5XM2bNn9dZbb+mhhx5S9erVjS7nqmXoSJ+UlBQNGTJEDRs2VHJysu655x4lJSVp6dKlxTr/5Zdf1o4dO8q5SgAAUBb09wAAs/GvXl1hixfJesMNkqTzO3bo57Fj5Xa5Sv5iIXmLORe8SxIjfcquevXqio+PJ/ApI0Pv3pWcnKybb75ZSUlJkvKST4fDocWLFysuLu6yK21LeSthL1myxHNPewAAYE7090Dl0r9/f/3666/6wx/+oNdff93ocoBSC7juOtVfvFhpDz8s15kzylz/uX5s1166cMttP39/1ezZU3UmjP/9F8oPfQpMonG4CX1gDoaN9MnJydHmzZvVpUsXr/1du3bVmTNntGXLlt89d+zYsYqNjVVkZGR5lwoAAEqJ/h6ofDZu3Kh169Zp48aNRpcClFm1Jo1V74UXPEGP68wZuU6fluv0aTl/+00nXn1V5y7cjemygvOmdFkLLJzCSB+YhWGhz8GDB5Wbm1toUaLw8HBJ0oEDBy577osvviiHw6ERI0Zc9piCcnJylJWV5fkyeBkjAACqDPp7AIDZBXfqqLpzZst+002yRUbKFhkpa90bPM+feO0KI9o807sKjPQh9IFJGDa9KzMzU5IUHBzstT8oKEiSlJWVVeR527dv1/Lly/X666/LZrMV61pLlizRwoULy1AtAAAoDfp7AMDVoObdd6vm3Xd7HrvOn9e+2++Q87ffdPqzz3TdmNEKuO66ok8Ozp/edXEXt2yHWRg20sd1hQWy/P0Ll5adna3x48frb3/7m6Kioop9rcGDB2vLli2er+su958VAAD4FP09AOBq5F+tmkIffDDvQW6ufnvr7csfHJI/vYuRPjAfw0KfkJAQSdKZM2e89ud/4nfpJ4KS9MILL8jlcmnYsGFyOBxyOBxyu91yu92e7aLYbDYFBwd7vopze1gAAFB29PcAgKvVNf36etb6Ofnmm3Ll5BR94IWRPpYC07tyXbnlXh9QHIZN72rQoIEsFovS0tK89qenp0uSGjVqVOictWvXKiMjQ61atSr0XLNmzTRr1izdf//95VMwAAAoMfp7AMDVKuCGGxTSpYsyP/tMzuPHlfnpp6rZs2fhA6vXlvytCmCkD0zIsNDHbrerbdu2Wr9+vR599FHPp3Fr165VSEhIkcO5Fy1apJxL0tWpU6dKkqZNm6awsLDyLxwAABQb/T0A4GpWKy5WmZ99Jkk6sXKVatx7b+GRpP7+UtB1sp494tnldLGmD8zBsNBHkoYOHar4+HglJiaqd+/e2rp1q5YtW6ZRo0YpMDBQWVlZ2rdvnxo0aKBatWqpSZMmhV4jfyHI5s2bV3T5AACgGOjvAQBXq8BWrVStaVOd/+EHnd+5U+dSUlS9iJGoCqkj65mLoY/DzUgfmINha/pIUnR0tJKTk3XgwAENHz5cH374ocaOHauEhARJ0s6dO/XQQw/pyy+/NLJMAABQBvT3AICrlZ+fn66JjfU8PrnqtaIPDL5eFqZ3wYQMHekjSV26dFGXLl2KfO7WW2/Vnj17fvf8VatWlUdZAADAh+jvgcojISFBp06dUs2aNY0uBagQNe7qrl+SkuQ8cUKn161Tre93KvCWZt4HhdTx+uOa0AdmYXjoAwAAAODqkb/GFlBV+NvtuqZfP/364ouSw6GDQ4co8q23FFC37sWDgq/nlu0wJUOndwEAAAAAYHa1ByUosHVrSZLz2K86OGSonFlZFw+4dKQPa/rAJAh9AAAAAAD4Hf52u8JeXKiA8AaSpOwff1RG4pNy5+bmHRB8vfwkz7o+jPSBWRD6AAAAAABwBdZrrlGDJUtkubCe1Zn//EdHZsyU2+2WbHl3mbQS+sBkCH0AAAAAFFtYWJj8/PwUFhZmdClAhbNFRCjsxYXyCwiQJP329ts6t2WLZLVLurhortPlNKhCwBuhDwAAAAAAxVS9bVtdO+opz+Nz27ZJFpukAtO7WNMHJkHoAwAAAABACVRv08aznZOaVmikD9O7YBaEPgAAAAAAlICtQQPPdk5ammS5EPpcGOmT68o1pC7gUoQ+AAAAAACUgKVmTVlCQyVJOenpkjVveldAXubDmj4wDUIfAAAAAABKyBYeLklyHDkiV25e2mMRa/rAXAh9AAAAAAAoIVtEuGc75+dfJEnWCyN9WNMHZkHoAwAAAABACQUUXNfn56OSLq7pw/QumAWhDwAAAAAAJWQLj/Bs5x78WZJkzZ/exUgfmAShDwAAAAAAJZS/po8k5Rw8KPn5X5ze5XbIfWHUD2Akq9EFAAAAALh6vPbaa8rOzpbdbje6FMBQtvAC07tS06Qmds9IHykv+AnwCzCiNMCD0AcAAABAsd1+++1GlwCYgqVGDVmuuUbOkyfzbtvezOYZ6SPlresT4E/oA2MxvQsAAAAAgFLw3Lb96FG53HbPLdsl1vWBORD6AAAAAABQCl7r+pzxHulD6AMzYHoXAAAAgGL78ssvPWv6MNULVV1AwXV9Mq2yus97HjvchD4wHqEPAAAAgGIbMGCAMjIyVK9ePR06dMjocgBDeY30yfT3+gObkT4wA6Z3AQAAAABQCrbwCM92zmnJ6mZNH5gLoQ8AAAAAAKVQ8Lbtub+5WNMHpkPoAwAAAABAKVhCQmSpVUuSlPObU1bu3gWTIfQBAAAAAKCUPLdtz3LKnnMx9HG6nUaVBHgQ+gAAAAAAUEoFF3OuecrPs81IH5gBoQ8AAAAAAKVUcF2fGr9dDH1yXblGlAN4IfQBAAAAAKCUCo70KRj6MNIHZkDoAwAAAABAKQUUCH2CC0zvYk0fmAGhDwAAAAAApVRwpE/QqYt/YjPSB2ZgNboAAAAAAFePQ4cOGV0CYCqW4GBZateW8/hxBbKQM0yGkT4AAAAAAJRB/mgf+1l/z23bCX1gBoQ+AAAAAACUQcEpXtefzPvX4Sb0gfEIfQAAAAAAKIOCt22//iQjfWAerOkDAAAAoNimTZumU6dOqWbNmpo6darR5QCmUHCkzx9O5/1L6AMzIPQBAAAAUGxLly5VRkaG6tWrR+gDXBDUsaOsoUHKycrS7rC8xZy5ZTvMgOldAAAAAACUgSUkRH+cP1T7+53W/rp5oQ8jfWAGhD4AAAAAAJSRn726/G1uz+NcV66B1QB5CH0AAAAAACgrq81r/RRG+sAMCH0AAAAAACgri00B7osjfVjTB2ZA6AMAAAAAQFlZ7LJczHwY6QNTIPQBAAAAAKCsrDZZdTH1IfSBGRD6AAAAAABQVha7rG5CH5gLoQ8AAAAAAGV16ULObkIfGM965UMAAAAAIM+f//xn/frrr/rDH/5gdCmAuTDSByZE6AMAAACg2F5//XWjSwDMyWqXlYWcYTJM7wIAAAAAoKwsLOQM8yH0AQAAAACgrC4Z6eN0O42rBbiA0AcAAAAAgLKy2GRhpA9MhtAHAAAAQLHFxMSoWbNmiomJMboUwFwsNq+FnHNduQYWA+RhIWcAAAAAxfbjjz8qIyNDp06dMroUwFysdgWwkDNMhpE+AAAAAACUlb/Va1SF08WaPjAeoQ8AAAAAAGXl5yeLxeZ56HAz0gfGI/QBAAAAAMAHrP4FQh+md8EECH0AAAAAAPABa4GRPkzvghkQ+gAAAAAA4ANWi92zzd27YAaEPgAAAAAA+IDVGuDZZk0fmAGhDwAAAAAAPuBnqSaLO+++7azpAzMg9AEAAAAAwBcsAbJeCH1Y0wdmYDW6AAAAAABXjylTpigrK0vBwcFGlwKYj9Uuy4VNB2v6wAQIfQAAAAAU26BBg4wuATAvi90z0ofpXTADpncBAAAAAOALVptnZAUjfWAGhD4AAAAAAPgCI31gMkzvAgAAAFBshw8fltPplMVi0Q033GB0OYC5WG2y5mU+hD4wBUb6AAAAACi2du3aqX79+mrXrp3RpQDmY7HLKkb6wDwIfQAAAAAA8AVG+sBkCH0AAAAAAPCFAmv6ON1Og4sBCH0AAAAAAPANq12WC5sOQh+YAKEPAAAAAAC+YAlQQP7du9xOuS9sA0Yh9AEAAAAAwBcKLOQsSQ436/rAWIaHPps2bVLv3r3VokULxcTEaNmyZb+bhubk5Gjx4sXq1q2bWrZsqa5du2rhwoXKycmpwKoBAEBJ0N8DAKoEq02WAt2b08UULxjLauTFU1JSNGTIEHXv3l2JiYnasmWLkpKS5HQ6NWjQoCLPmTlzptasWaNhw4apefPm2rFjh1588UX9/PPP+vvf/17B7wAAAFwJ/T0AoMq4dKQPd/CCwQwNfZKTk3XzzTcrKSlJktS5c2c5HA4tXrxYcXFxqlatmtfxJ0+e1Ntvv63Ro0frsccekyRFR0dLkp5//nmNHj1atWrVqtg3AQAAfhf9PQCgyrDaPbdslwh9YDzDpnfl5ORo8+bN6tKli9f+rl276syZM9qyZUuhc7KystS3b1/FxMR47W/YsKEk6eDBg+VXMAAAKDH6ewBAlWKxeW7ZLrGmD4xn2EifgwcPKjc3VxEREV77w8PDJUkHDhxQhw4dvJ6rX7++nn766UKvtWHDBgUEBBR6rXw5OTleawCwgjoAABWD/h6ofDZs2CCHwyGr1dBJA4A5We1ef2Qz0gdGM+wndWZmpiQpODjYa39QUJCkvE/5imP9+vVavXq1BgwYoJo1axZ5zJIlS7Rw4cIyVAsAAEqD/h6ofJo0aWJ0CYB5XTrSh9AHBjNsepfL5frd5/39r1zaunXr9NRTT6lNmzYaM2bMZY8bPHiwtmzZ4vm67rrrSlwvAAAoOfp7AECVwpo+MBnDRvqEhIRIks6cOeO1P/8Tv0s/EbzUihUrNHv2bLVv314vvvii7Hb7ZY+12Wyy2Wyex35+fqUtGwAAlAD9PQCgSrHYvO7e5XRzy3YYy7DQp0GDBrJYLEpLS/Pan56eLklq1KhRkee53W4988wzWrVqlXr06KFZs2Z5/YIHAADMg/4eqHz+8Y9/6OzZs6pevboefvhho8sBzMVik4XpXTARw6Z32e12tW3bVuvXr/daaHHt2rUKCQlRVFRUkefNnTtXq1atUnx8vJ577jl+AQQAwMTo74HKZ+zYsUpISNDYsWONLgUwHxZyhskYuuT+0KFDFR8fr8TERPXu3Vtbt27VsmXLNGrUKAUGBiorK0v79u1TgwYNVKtWLe3atUtLly5V8+bN1a1bN23bts3r9f74xz9ecZg4AACoWPT3AIAqw2L3Wsg515VrYDGAwaFPdHS0kpOTtWDBAg0fPlx16tTR2LFjNXDgQEnSzp07FRcXp1mzZun+++/XunXr5Ha7tWPHDj300EOFXm/lypW69dZbK/ptAACA30F/DwCoMqw2BRRYyJk1fWA0Q0MfSerSpYu6dOlS5HO33nqr9uzZ43mcmJioxMTEiioNAAD4CP09AKBKsNhlEWv6wDwMW9MHAAAAAIBKxWrjlu0wFUIfAAAAAAB8wWL3umU7oQ+MRugDAAAAAIAvWL0Xcna4CX1gLEIfAAAAAAB8wcL0LpgLoQ8AAAAAAL5gsTG9C6Zi+N27AAAAAFw9rr/+eq9/ARRgCWCkD0yF0AcAAABAsX377bdGlwCYl5+fLH4X/8x2up0GFgMwvQsAAAAAAJ+x+l8MfRjpA6MR+gAAAAAA4CNWf4tnO9eVa2AlAKEPAAAAAAA+Y/UP8Gwz0gdGY00fAAAAAMU2ePBgnThxQrVq1dKSJUuMLgcwnbzpXS5JrOkD4xH6AAAAACi2jz/+WBkZGapXr57RpQCmlBf65EhipA+Mx/QuAAAAAAB8hOldMBNCHwAAAAAAfMQr9HES+sBYhD4AAAAAAPiIxVIw9Mk2sBKA0AcAAAAAAJ8J8Ld5tgl9YDRCHwAAAAAAfMRqKRj65BhYCUDoAwAAAACAz1gLTO9yEvrAYIQ+AAAAAAD4iMVi92w7XEzvgrEIfQAAAAAA8BFrwdDHmWtgJYBkNboAAAAAAFePfv366eTJk7rmmmuMLgUwJav14po+uUzvgsEIfQAAAAAUW1JSktElAKYWYKnm2Xa6GOkDYzG9CwAAAAAAH7FYmd4F8yD0AQAAAADAR7zW9GGkDwxG6AMAAAAAgI9YrRendzlcDgMrAQh9AAAAAJTATTfdpBo1auimm24yuhTAlApO73IS+sBghD4AAAAAii0rK0uZmZnKysoyuhTAlAKsgZ7tXEIfGIzQBwAAAAAAH/Ga3uUm9IGxCH0AAAAAAPARP2s1WdxuSazpA+MR+gAAAAAA4CtWuyx5mY+cbqextaDKI/QBAAAAAMBXLDZZlT/Sh9AHxiL0AQAAAADAV6x2WfOndzHSBwYj9AEAAAAAwFcsAbJe2HS4XYaWAhD6AAAAAADgKxZG+sA8CH0AAAAAAPAVq13WCws5M9IHRrNe+RAAAAAAyLN48WKdO3dOgYGBRpcCmFPBhZxF6ANjEfoAAAAAKLYePXoYXQJgbgVG+jgvTPMCjML0LgAAAAAAfMVik8Uz0ofQB8Yi9AEAAAAAwFcKrunD9C4YjOldAAAAAIpty5YtysnJkc1mU5s2bYwuBzAfi10B+XfvkuR2u+Xn52dsTaiyCH0AAAAAFFvPnj2VkZGhevXq6dChQ0aXA5iP9eL0Lklyup2y+vGnN4zB9C4AAAAAAHzFcnF6lyQ5XA7jakGVR+gDAAAAAICvWAI8t2yXCH1gLEIfAAAAAAB8xc9PVl1cw4fQB0Yi9AEAAAAAwIcsBf7UdrgJfWAcQh8AAAAAAHwowK9A6MNIHxiI0AcAAAAAAB+yEvrAJAh9AAAAAADwIUIfmAWhDwAAAAAAPmTxs3i2nW6ngZWgqiP0AQAAMLHx48erSZMml/3avHmzxo8fr/Hjx1dYPaW91qFDh9SkSRMdOnSoyOfff/99xcTElKU8Lz/88IMeeOABtWjRQr1799b3339/2WNPnTpVqG1vvfXWQsf99ttvuu222wq9h5JcC0DlZy0Q+jDSB0Yi9AEAADCxSZMmadOmTdq0aZMmTpyo66+/3vN406ZNatWqldElmtLZs2c1aNAgtW3bVu+//75atWqlwYMH6+zZs0Uev2/fPoWGhnq17SeffOJ1zKlTpzRkyBAdP368TNe62u3atUunTp3Srl27jC4FMC2v0MeZa2AlqOoIfQAAAEwsJCRE1157ra699lqFhITIYrF4Hl977bWy2WxGl2hKn3zyiex2u8aOHatGjRpp0qRJCgoK0meffVbk8T/99JMiIyO92rZ27dqe57/99lvdf//9RQY5Jb3W1S4kJEQ1atRQSEiI0aUAplUw9Ml1nDOwElR1hD4AAACVQFZWlkaOHKkWLVro9ttv14cffuh5LiYmRklJSerYsaN69eolt9utH3/8UbGxsYqKilLXrl31+uuve44/ffq0nnjiCbVt21bt2rXT6NGjlZWVVaxrZWdnKykpSX/+85/VsmVLDRkyRIcPHy6y5qNHj+qxxx5Ty5Ytdd999yk9Pf2y7y85OfmyU9yKsm3bNrVp00Z+fn6SJD8/P7Vu3VopKSlFHr9v3z5FRERc9vqbNm1S7969lZycXOZrAaj8rP4F1vQh9IGBCH0AAAAqgfXr16tZs2b66KOP1L17d02cOFGZmZme5z/88EMtW7ZMzz77rLKzs5WQkKA2bdpozZo1GjdunF566SV98MEHkqQFCxbo2LFjeuONN7Ry5Urt3r1bL730UrGuNXXqVK1fv16zZ8/Wm2++KYfDoWHDhsnlchWqOTExUS6XS++8844SEhL06quvXvb9DRw40GvqVcGvohw7dkzXXXed177atWvryJEjRR6/f/9+HTlyRH369FGnTp00cuRI/fLLL57nn3zySQ0bNkwWi6XQuSW9lhFcLpfcbrfRZQBVhtXP6tl2OM4bWAmqOuuVDwEAAIDZtWrVSo899pgkadiwYVq+fLl++ukntWjRQpJ07733ekbFvPPOO6pdu7aefPJJSVJERIQyMjK0cuVK9erVSxkZGQoKClJYWJgCAwM1f/78Yl0rIiJC//znP7V06VL96U9/kiQ999xzuv322/Wf//xHkZGRntfYu3evtm7dqn/961+qW7eubrzxRn3//feXnRIVFBSkoKCgYrfHuXPnCk19s9lsysnJKfL4n376SbVq1dKECRPkdrs1b948DRkyRO+8806RQU9ZrmWE3Nxc2e12ORwOWSwWz6ik0pg7d65Onz6tGjVq6KmnnvJhlUDlYfW3Shdu2uXIZaQPjEPoAwAAUAnUr1/fs52/1kp2drZnX7169TzbP/30k3bv3u21CLTT6fSEG3FxcRo2bJiio6MVHR2trl276p577rnitVJTU+VyuTxBkySFhoYqMjJS+/fv9wp98hdOrlu3rmdf8+bNLxv6LF68WEuWLCnyua1btxbaZ7fbC4UuOTk5qlatWpGv8fHHH8vPz8/z/IIFC9SxY0dt27ZNrVu3LvKc0l7LKMuXL9fhw4c1cuRI2Wy2Uoc/c+fOVUZGhurVq0foA1xGwdDH6cz+/YOBckToAwAAUAkUNRql4HQeu93u2XY4HIqOjtaUKVOKfK3o6Ght3LhRGzZs0JdffqkpU6Zo06ZNeu655373WgWvUZDT6Sxyetel040CAgKKPF+S+vbtq+7du1/2+UvVqVNHv/76q9e+X3/9tdA0rHyBgYFej2vXrq3Q0FAdPXrU59cyyvHjxzV58mTNnTtXTz31VJnDHwCXZ/G/+PMs10HoA+Owpg8AAEAVExkZqQMHDigsLEzh4eEKDw9XSkqKVq1aJUlasWKFdu7cqfvuu0/z58/XrFmztG7duiu+bv369WW1Wr0WMD558qTS0tK8RvlIUuPGjXXq1CmlpaV59v3eLcBDQ0M9tV76VZQWLVpo69atnmDJ7Xbru+++8xqFlC8rK0vt2rXT119/7dl39OhRnTx5Ug0bNrzi+y7JtczgxIkTmjx5surXr6/Zs2fr3LlzcjgcrPkD+FCAP2v6wBwIfQAAAKqYe++9V+fPn9eUKVO0f/9+bdy4Uc8884znFuVHjhzR9OnTlZKSotTUVK1du1ZNmza94usGBQXpgQce0IwZM7R582bt3r1bY8aM0fXXX68OHTp4HduoUSNFR0dr4sSJ2r17tz7//HO99tprPnuP3bp10+nTp/XMM89o3759euaZZ3Tu3DnPaKHz58/r2LFjkqTg4GC1adNGs2bN0vbt27Vz506NHDlSnTp1uuzdwUpyLTPw9y/8a3/B8GfOnDmEP4APWS0X1/lyOAl9YBxCHwAAgComODhYS5cuVWpqqnr16qXJkyerf//+Gjx4sKS8u2q1bt1aQ4cOVc+ePXX27FklJSUV67XHjRun2267TSNGjFC/fv1kt9u1YsWKQgsdS9K8efN0zTXXqG/fvpo7d65iY2N9+h6XLFmiLVu26P7779e2bdv08ssvq3r16pKkTz75RB07dvQcP3v2bDVt2lSDBg1SbGys6tWr55nOVtZrFcXpdJbtDZZQQECATp06VeRzJ06c0KRJkxj5A/iQpcBIH6fDPIu6o+rxc1fBn+adO3fW0aNHVadOHX311VdGlwMAAH1TOaBNYWZOp1OzZ8/W66+/XiHXc7vd+vHHH4sVNtWqVcuz5o/dbpe/v7/Xmj9hYWGehZwPHTpUnmUDV61318Rr2slvJUnT/thX93eYRL8EQ7CQMwAAAGCAw4cP64cffjC6jELyp30VXPC5qPAHwOVZ/QtO72KkD4zD9C4AAAAAhZw4cUJz587VypUrZbFYirwDG4CiWS0F7t7FLdthIEb6AAAAAPBy6RQvt9sti8VidFnAVaPgQs5OZ66BlaCqI/QBAAAADDBw4EB16tSpQq7ldrs1f/58/d///d/vHnel9XwkqXXr1qpfv76uvfba8iwZuKpZLXbPNtO7YCRCHwAAAKCC+fn5KSoqSlFRURV2vfT09MuGPsUJe/KtWbOmPEsFKgWrtUDo4yL0gXEIfQAAAIAK5u9fsUtrZmcXvaZIScIeAMXnPdKH6V0wDqEPAAAAUMUQ9gDly1JgTR+Hi9AHxiH0AQAAAKoIwh6gYlit1TzbjPSBkQy/ZfumTZvUu3dvtWjRQjExMVq2bJncbvfvnvPRRx/p7rvvVlRUlLp3767Vq1dXULUAAKA06O8B491zzz06ePCgxo8fr8DAQFksllIFPvfee6+io6N17733lkOVQOUQUDD0YaQPDGToSJ+UlBQNGTJE3bt3V2JiorZs2aKkpCQ5nU4NGjSoyHPWrl2r0aNHKy4uTp06ddLnn3+u8ePHy2az6e67767gdwAAAK6E/h4wnr+/v2688UafjOz57rvvlJGRoXr16vmoOqDysVoIfWAOhoY+ycnJuvnmm5WUlCRJ6ty5sxwOhxYvXqy4uDhVq1at0Dlz585Vt27dNHHiRElSp06ddOrUKc2fP59fAgEAMCH6e8B4AQEBRpcAVCmWAnfvcrqdBlaCqs6w6V05OTnavHmzunTp4rW/a9euOnPmjLZs2VLonEOHDik1NbXIc9LS0pSamlqeJQMAgBKivwcAVEVea/q4HAZWgqrOsNDn4MGDys3NVUREhNf+8PBwSdKBAwcKnbN//35JKtE5AADAOPT3AICqyGoN9GwT+sBIhk3vyszMlCQFBwd77Q8KCpIkZWVlFTonf19JzpHyPmXMycnxPL7SwpEAAMA36O8BAFVR9ep/8Gxb/Ay/fxKqMMNCH5fL9bvP+/sX/o9RmnMkacmSJVq4cGHxiwMAAD5Bfw8AqIrqXN9CvW03aPO5w7r/lkeMLgdVmGGhT0hIiCTpzJkzXvsv9+leac+RpMGDBys+Pt7zuHv37vrll19KWTkAACgu+nsAQFX1dL91RpcAGLemT4MGDWSxWJSWlua1Pz09XZLUqFGjQudERkZKUqFz8h8XdY4k2Ww2BQcHe77KeptKAABQPPT3AAAAxjFspI/dblfbtm21fv16Pfroo55fzNauXauQkBBFRUUVOic8PFxhYWFau3atunfv7tm/bt06RUREKCwsrFjXPn78uCTp2LFj6ty5sw/eDQAAZXPs2DFJF/uoyoL+Hqh8AgMDFRkZKYvFwv8toAQqa18PczMs9JGkoUOHKj4+XomJierdu7e2bt2qZcuWadSoUQoMDFRWVpb27dunBg0aqFatWpKk4cOHa8KECQoNDVVMTIw2bNigTz/9VPPmzSv2dfPXCnC5XDp69Gi5vDcAAErjSuvZXI3o74HKxd/f37O2Fv+3gJKrjH09zMvPbfCtLdavX68FCxbowIEDqlOnjvr376+BAwdKkjZv3qy4uDjNmjVL999/v+ecN998U8uXL9fhw4dVv359DRo0SL169Sr2NVu0aKGcnBz5+/urdu3akvLu8PHLL7/ouuuuYzh4GdCOvkNb+g5t6Tu0pe9c2pbHjx+Xy+WSzWbTtm3bjC7P58zQ3/P96zu0pe/Qlr5BO/oObek7Va2vhzkZHvqYRVZWltq0aaMtW7ZcdoFIXBnt6Du0pe/Qlr5DW/oObVnxaHPfoS19h7b0DdrRd2hL36EtYQaGLeQMAAAAAACA8kPoAwAAAAAAUAkR+lxgs9n0+OOPy2azGV3KVY129B3a0ndoS9+hLX2Htqx4tLnv0Ja+Q1v6Bu3oO7Sl79CWMAPW9AEAAAAAAKiEGOkDAAAAAABQCRH6AAAAAAAAVEKEPgAAAAAAAJVQlQl9Nm3apN69e6tFixaKiYnRsmXLdKXljD766CPdfffdioqKUvfu3bV69eoKqtbcStqWOTk5Wrx4sbp166aWLVuqa9euWrhwoXJyciqwanMqzfdlPofDoT59+ig2NracqzS/0rTjl19+qT59+igqKkqdO3fWzJkzdfbs2Qqq2LxK2pYOh0Mvv/yy7rzzTrVs2VI9e/bUJ598UoEVm9+RI0fUtm1bbd68+YrH0u+UDX2979DX+w59ve/Q3/sO/b3v0d/DrKpE6JOSkqIhQ4aoYcOGSk5O1j333KOkpCQtXbr0suesXbtWo0ePVocOHfTiiy+qffv2Gj9+vD7++OMKrNx8StOWM2fO1OLFi3X//fdr0aJF6t27t5YuXaqnn3664go3odK0ZUEvv/yyduzYUc5Vml9p2vGLL77Q0KFDdeONN2rJkiUaNGiQ3n//ff3P//xPBVZuPqVpy+TkZM2bN0/33nuvFi1apDZt2mjkyJFau3ZtBVZuXocPH9bAgQOVmZl5xWPpd8qGvt536Ot9h77ed+jvfYf+3vfo72Fq7ipg4MCB7j59+njtmzNnjrtVq1buc+fOFXnOnXfe6U5MTPTal5iY6O7SpUt5lXlVKGlbnjhxwt2kSRP30qVLvfYvWbLE3bhxY/fx48fLtV4zK833Zb5du3a5o6Ki3B06dHAPGDCgPMs0vdK041//+tdC/79XrFjh/stf/uI+e/ZseZVqeqVpyw4dOrhHjx7tte/BBx+s8t+XTqfT/d5777nbt2/vbt++vbtx48bur7/++nfPod8pG/p636Gv9x36et+hv/cd+nvfob/H1aDSj/TJycnR5s2b1aVLF6/9Xbt21ZkzZ7Rly5ZC5xw6dEipqalFnpOWlqbU1NTyLNm0StOWWVlZ6tu3r2JiYrz2N2zYUJJ08ODB8ivYxErTlgXPHTt2rGJjYxUZGVnepZpaadrxhx9+UHp6ugYMGOC1/29/+5s+//xzBQYGlmvNZlXa78mcnBwFBwd77QsNDdVvv/1WXqVeFfbs2aOpU6eqV69emjNnzhWPp98pG/p636Gv9x36et+hv/cd+nvfor/H1aDShz4HDx5Ubm6uIiIivPaHh4dLkg4cOFDonP3790tSic6pCkrTlvXr19fTTz/t+cUv34YNGxQQEFDotaqK0rRlvhdffFEOh0MjRowozxKvCqVpx127dkmS7Ha7Bg8erKioKLVv317PPPNMlV57orTfk3Fxcfrggw/01VdfKSsrS2vWrNG///1v9ezZs7xLNrUbbrhB69ev14QJE1StWrUrHk+/Uzb09b5DX+879PW+Q3/vO/T3vkV/j6uB1egCylv+vMpLk+mgoCBJeZ9OXSp/X0nOqQpK05ZFWb9+vVavXq0BAwaoZs2avi3yKlHatty+fbuWL1+u119/XTabrXyLvAqUph1PnDghSXr88cfVo0cPxcfHa8eOHUpOTtaJEyf0/PPPl3PV5lTa78lHHnlEKSkpSkhI8Ozr3bu3HnvssXKq9OoQGhpaouPpd8qGvt536Ot9h77ed+jvfYf+3rfo73E1qPShj8vl+t3n/f0LD3YqzTlVgS/aZd26dRo1apTatGmjMWPG+Kq0q05p2jI7O1vjx4/X3/72N0VFRZVXaVeV0rRjbm6uJKlLly6e78E//elPcrvdev755/X4449XyaH0pWnLnJwc9e/fX8eOHdO0adPUsGFDbd26VYsWLVL16tU1efLk8iq30qHfKRv6et+hr/cd+nrfob/3Hfp7Y9H3wAiV/rsqJCREknTmzBmv/ZdLWUt7TlVQ1nZZsWKFEhMT1bp1ay1ZskR2u718Cr0KlKYtX3jhBblcLg0bNkwOh0MOh0Nut1tut9uzXdWUph3zP0m5/fbbvfZ36tRJ0sXh4FVNadpy7dq12r17t5577jn17dtX7du31+DBgzVmzBitWrVKP/74Y/kXXknQ75QNfb3v0Nf7Dn2979Df+w79vbHoe2CESh/6NGjQQBaLRWlpaV7709PTJUmNGjUqdE5+6n/pOfmPizqnKihNW0qS2+3WzJkzNWvWLN11111aunRplf+BVpq2XLt2rQ4cOKBWrVqpWbNmatasmf773//qv//9r5o1a6bVq1dXSO1mUpp2zJ9Dfel8/vxPBKvqHyilacuff/5ZktS6dWuv/e3atZMk7du3rzxKrZTod8qGvt536Ot9h77ed+jvfYf+3lj0PTBCpQ997Ha72rZtq/Xr13t9OrJ27VqFhIQUOXQ2PDxcYWFhWrt2rdf+devWKSIiQmFhYeVetxmVpi0lae7cuVq1apXi4+P13HPPMT9dpWvLRYsW6d133/X6yv+F8N1339Udd9xRkW/BFErTjm3btlX16tX18ccfe+3/4osvZLVa1apVq3Kv24xK05b5i7Z+++23Xvu/++47SaqyPytLg36nbOjrfYe+3nfo632H/t536O+NRd8DI1T6NX0kaejQoYqPj1diYqJ69+6trVu3atmyZRo1apQCAwOVlZWlffv2qUGDBqpVq5Ykafjw4ZowYYJCQ0MVExOjDRs26NNPP9W8efMMfjfGKmlb7tq1S0uXLlXz5s3VrVs3bdu2zev1/vjHP1bZTwJL2pZNmjQp9Br5Q5ebN29e0eWbRknbMSgoSCNGjNCzzz6rGjVq6M4779R3332nV155RXFxcZ6fAVVRSdsyJiZGLVq00JgxY/TEE0+oYcOG2r59uxYtWqSYmBjWo/gd9Du+R1/vO/T1vkNf7zv0975Df19x6HtgCu4qYt26de4ePXq4mzVr5o6JiXEvW7bM89zXX3/tbty4sfu9997zOueNN95wd+nSxX3LLbe4u3fv7l69enUFV21OJWnLF154wd24cePLfn399ddGvQ1TKM33ZUEDBgxwDxgwoCJKNbXStOO7777rvvvuu93NmjVz33HHHe7Fixe7nU5nRZduOiVty8zMTPf06dPdHTp08PysXLJkiTs7O9uI8k0pv90K/ryj3ykf9PW+Q1/vO/T1vkN/7zv0975Hfw+z8nO7q+iKcAAAAAAAAJVYpV/TBwAAAAAAoCoi9AEAAAAAAKiECH0AAAAAAAAqIUIfAAAAAACASojQBwAAAAAAoBIi9AEAAAAAAKiECH0AAAAAAAAqIUIfAAAAAACASshqdAEAjBMTE6OMjAzPYz8/P9WoUUNt2rTRlClTdMMNN5TbtcePHy9JevbZZ5WcnKxvvvlGq1atKrfrAQBwtRs/frxWr1592efr1aun9u3b69lnn62QWiSV6lqHDh3SX/7yF23YsEFhYWGFnn///fe1cOFCffHFF2WuEwCqOkIfoIqbOHGi7rrrLkmSy+XSvn37NHXqVI0bN04rV640uDoAAJBv0qRJGjVqlCTpk08+0fLly/Xuu+96nq+IsAcAcHUh9AGquJCQEF177bWex3Xq1NGIESM0ZswYZWZmKiQkxMDqAABAvpCQEE+/HBISIovF4tWHBwQEGFUaAMCkWNMHQCE2m02S5O/vr9OnT2vMmDFq3bq1OnbsqBkzZuj8+fOeY7dv365+/fqpRYsW6tq1qz7++GPPc++88466deumW265RbfeequmTZsmp9NZ4e8HAICqIisrSyNHjlSLFi10++2368MPP/Q8FxMTo6SkJHXs2FG9evWS2+3Wjz/+qNjYWEVFRalr1656/fXXPcefPn1aTzzxhNq2bat27dpp9OjRysrKKta1srOzlZSUpD//+c9q2bKlhgwZosOHDxdZ89GjR/XYY4+pZcuWuu+++5Senl4OLQMAVROhDwAv6enpevnll9WpUycFBQVp0qRJyszM1BtvvKGXXnpJO3bs0PTp0yVJx48f18CBA3XzzTdr9erVGjx4sMaNG6fdu3frm2++0cyZM/XUU0/ps88+07Rp0/Tuu+9qw4YNBr9DAAAqr/Xr16tZs2b66KOP1L17d02cOFGZmZme5z/88EMtW7ZMzz77rLKzs5WQkKA2bdpozZo1GjdunF566SV98MEHkqQFCxbo2LFjeuONN7Ry5Urt3r1bL730UrGuNXXqVK1fv16zZ8/Wm2++KYfDoWHDhsnlchWqOTExUS6XS++8844SEhL06quvlm8jAUAVwvQuoIqbOnWqZsyYIUlyOBwKCAjQX/7yF02cOFHp6en6/PPP9c0333iGk8+YMUO9evXShAkT9PHHH6tmzZqaPHmy/P391bBhQ506dUrnz59X9erV9cwzz+jOO++UJIWFhel///d/tXfvXs8+AADgW61atdJjjz0mSRo2bJiWL1+un376SS1atJAk3XvvvWrSpImkvBG5tWvX1pNPPilJioiIUEZGhlauXKlevXopIyNDQUFBCgsLU2BgoObPn1+sa0VEROif//ynli5dqj/96U+SpOeee0633367/vOf/ygyMtLzGnv37tXWrVv1r3/9S3Xr1tWNN96o77//Xp999lm5thMAVBWEPkAVN2LECN155506c+aMkpOTlZGRoVGjRumaa65RSkqKXC6XOnfu7HWOy+VSWlqaDhw4oKZNm8rf/+Kgwfj4eM92tWrVtGDBAu3bt0979uxRWlqaOnbsWGHvDQCAqqZ+/fqe7fwPbLKzsz376tWr59n+6aeftHv3brVq1cqzz+l0ymKxSJLi4uI0bNgwRUdHKzo6Wl27dtU999xzxWulpqbK5XJ5giZJCg0NVWRkpPbv3+8V+uzbt0+hoaGqW7euZ1/z5s0JfQDARwh9gCqudu3aCg8PlyTNnz9fffr00bBhw/TWW2/J6XQqJCRE7733XqHz6tSpI6v18j9C/v3vf2v48OHq1auXOnXqpOHDh2vatGnl9j4AAIA8gU1Bbrfbs2232z3bDodD0dHRmjJlSpGvFR0drY0bN2rDhg368ssvNWXKFG3atEnPPffc716r4DUKcjqdRU7vKlifxILUAOBLrOkDwMNms2nmzJnatWuXVqxYocjISGVmZsrPz0/h4eEKDw/X+fPnNWfOHOXk5CgiIkJ79uzx+mXtySef1CuvvKJ33nlHvXv31vTp0/XAAw+oUaNGSk9PL/SLHQAAMEZkZKQOHDigsLAwTz+fkpKiVatWSZJWrFihnTt36r777tP8+fM1a9YsrVu37oqvW79+fVmtVqWkpHj2nTx5UmlpaV6jfCSpcePGOnXqlNLS0jz7du3a5Zs3CAAg9AHgLSoqSn369NFLL72k4OBgderUSaNHj9b27du1c+dOTZgwQWfPnlWNGjV0zz336LffftOcOXOUmpqq999/Xxs2bFCHDh0UGhqqrVu3as+ePdq7d6/Gjx+vY8eOKScnx+i3CAAAlLe+z/nz5zVlyhTt379fGzdu1DPPPKPatWtLko4cOaLp06crJSVFqampWrt2rZo2bXrF1w0KCtIDDzygGTNmaPPmzdq9e7fGjBmj66+/Xh06dPA6tlGjRoqOjtbEiRO1e/duff7553rttdfK5f0CQFVE6AOgkJEjRyogIEBJSUmaM2eOwsLC9Mgjjyg+Pl6RkZGaO3euJKlGjRpasmSJvv32W/Xo0UNLly7V888/r5tvvlmPP/64ateurYceekjx8fGy2+3q168fn94BAGASwcHBWrp0qVJTU9WrVy9NnjxZ/fv31+DBgyXl3VWrdevWGjp0qHr27KmzZ88qKSmpWK89btw43XbbbRoxYoT69esnu92uFStWyGazFTp23rx5uuaaa9S3b1/NnTtXsbGxPn2fAFCV+bmZawEAAAAAAFDpMNIHAAAAAACgEiL0AQAAAAAAqIQIfQAAAAAAACohQh8AAAAAAIBKiNAHAAAAAACgEiL0AQAAAAAAqIQIfQAAAAAAACohQh8AAAAAAIBKiNAHAAAAAACgEiL0AQAAAAAAqIQIfQAAAAAAACqh/w+3uKYRt39VVgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1200x1200 with 4 Axes>"
      ]
     },
     "metadata": {}
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "print(f\"Accuracy = {bcm.accuracy_}\")\n",
    "print(f\"Balanced Accuracy = {bcm.balanced_accuracy_}\")\n",
    "print(f\"AUC ROC = {bcm.auc_roc_}\")\n",
    "print(f\"AUC PR = {bcm.auc_pr_}\")\n",
    "print(f\"Precision = {bcm.precision_}\")\n",
    "print(f\"Recall = {bcm.recall_}\")\n",
    "print(f\"F1-Score = {bcm.f1_}\")\n",
    "print(f\"F2-Score = {bcm.f2_}\")\n",
    "print(f\"F0.5-Score = {bcm.f05_}\")\n",
    "print(f\"Average Precision = {bcm.average_precision_}\")\n",
    "print(f\"Threat Score = {bcm.threat_score_}\")\n",
    "print(f\"Metrics Dict = {bcm.metrics_dict_}\")\n",
    "print(f\"Thresholds Dict = {bcm.thresholds_dict_}\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Accuracy = 0.9590643274853801\n",
      "Balanced Accuracy = 0.954731308411215\n",
      "AUC ROC = 0.9873685747663552\n",
      "AUC PR = 0.9911669358699267\n",
      "Precision = 0.9629629629629629\n",
      "Recall = 0.9719626168224299\n",
      "F1-Score = 0.9674418604651163\n",
      "F2-Score = 0.9701492537313435\n",
      "F0.5-Score = 0.9647495361781077\n",
      "Average Precision = 0.9902619632721823\n",
      "Threat Score = 0.9369369369369369\n",
      "Metrics Dict = {'Accuracy': 0.959, 'Balanced Accuracy': 0.955, 'ROC AUC': 0.987, 'PR AUC': 0.991, 'Precision': 0.963, 'Recall': 0.972, 'F-1 Score': 0.967, 'F-2 Score': 0.97, 'F-0.50 Score': 0.965, 'Threat Score': 0.937, 'Average Precision': 0.99, 'TP': 104, 'TN': 60, 'FP': 4, 'FN': 3}\n",
      "Thresholds Dict = {'Youden': 0.63, 'Sensitivity-Specificity': 0.53, 'Precision-Recall-F1': 0.51}\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### You can also repeat the process for all `average_methods` and apply your desired formatting to your dataframe"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from IPython.display import display\n",
    "from typing import Dict, Any, List\n",
    "from matplotlib.colors import Colormap\n",
    "\n",
    "\n",
    "def create_colormap() -> Colormap:\n",
    "    \"\"\"Creates a simple color map for pd.DataFrame format.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    Colormap\n",
    "    \"\"\"\n",
    "    return sns.light_palette(\n",
    "        \"blue\",\n",
    "        as_cmap=True,\n",
    "    )\n",
    "\n",
    "\n",
    "def create_df_styles() -> List[Dict[str, Any]]:\n",
    "    \"\"\"Returns simple css styles for pandas.DataFrames.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    List[Dict[str, Any]]\n",
    "    \"\"\"\n",
    "    th_props = [\n",
    "        (\"font-size\", \"12px\"),\n",
    "        (\"text-align\", \"left\"),\n",
    "        (\"font-weight\", \"bold\"),\n",
    "    ]\n",
    "    td_props = [\n",
    "        (\"font-size\", \"12px\"),\n",
    "        (\"text-align\", \"center\"),\n",
    "    ]\n",
    "    return [\n",
    "        dict(\n",
    "            selector=\"th\",\n",
    "            props=th_props,\n",
    "        ),\n",
    "        dict(\n",
    "            selector=\"td\",\n",
    "            props=td_props,\n",
    "        ),\n",
    "    ]\n",
    "\n",
    "\n",
    "def create_metrics(\n",
    "    bcm: BinaryClassificationMetrics,\n",
    ") -> pd.DataFrame:\n",
    "    \"\"\"Creates all calculated metrics with all average methods and thresholds.\n",
    "\n",
    "    Notes\n",
    "    -----\n",
    "    Possible average methods are \"binary\", \"micro\", \"macro\", and \"weighted\"\n",
    "    Possible thresholds are \"youden-index\", \"maximizing specificity-sensitivity\", and\n",
    "    \"maximizing precision-recall\".\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    bcm : BinaryClassificationMetrics\n",
    "        An instance of binary classification metrics\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    pd.DataFrame\n",
    "    \"\"\"\n",
    "    thresholds = bcm.thresholds_dict_\n",
    "    methods = bcm.average_methods_\n",
    "\n",
    "    frames = []\n",
    "    for method in methods:\n",
    "        for threshold in thresholds:\n",
    "            m = BinaryClassificationMetrics(\n",
    "                y_test,\n",
    "                y_pred_proba,\n",
    "                threshold=thresholds[threshold],\n",
    "                average_method=method,\n",
    "                display_df=False,\n",
    "            )\n",
    "            frames.append(m.metrics_df_)\n",
    "\n",
    "    return pd.concat(frames)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "cmap = create_colormap()\n",
    "styles = create_df_styles()\n",
    "df_to_show = create_metrics(bcm)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Now, it is the time to `display` the results"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "display(\n",
    "    df_to_show.style.background_gradient(\n",
    "        cmap=cmap,\n",
    "    ).set_table_styles(styles)\n",
    ")"
   ],
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "#T_e1e77 th {\n",
       "  font-size: 12px;\n",
       "  text-align: left;\n",
       "  font-weight: bold;\n",
       "}\n",
       "#T_e1e77 td {\n",
       "  font-size: 12px;\n",
       "  text-align: center;\n",
       "}\n",
       "#T_e1e77_row0_col0, #T_e1e77_row0_col2, #T_e1e77_row0_col3, #T_e1e77_row0_col5, #T_e1e77_row0_col6, #T_e1e77_row0_col8, #T_e1e77_row0_col11, #T_e1e77_row0_col13, #T_e1e77_row1_col2, #T_e1e77_row1_col3, #T_e1e77_row1_col6, #T_e1e77_row2_col1, #T_e1e77_row2_col2, #T_e1e77_row2_col3, #T_e1e77_row2_col6, #T_e1e77_row2_col12, #T_e1e77_row2_col14, #T_e1e77_row3_col0, #T_e1e77_row3_col2, #T_e1e77_row3_col3, #T_e1e77_row3_col6, #T_e1e77_row3_col11, #T_e1e77_row3_col13, #T_e1e77_row4_col2, #T_e1e77_row4_col3, #T_e1e77_row4_col6, #T_e1e77_row5_col1, #T_e1e77_row5_col2, #T_e1e77_row5_col3, #T_e1e77_row5_col6, #T_e1e77_row5_col12, #T_e1e77_row5_col14, #T_e1e77_row6_col0, #T_e1e77_row6_col2, #T_e1e77_row6_col3, #T_e1e77_row6_col4, #T_e1e77_row6_col6, #T_e1e77_row6_col7, #T_e1e77_row6_col9, #T_e1e77_row6_col10, #T_e1e77_row6_col11, #T_e1e77_row6_col13, #T_e1e77_row7_col2, #T_e1e77_row7_col3, #T_e1e77_row7_col6, #T_e1e77_row8_col1, #T_e1e77_row8_col2, #T_e1e77_row8_col3, #T_e1e77_row8_col6, #T_e1e77_row8_col12, #T_e1e77_row8_col14, #T_e1e77_row9_col0, #T_e1e77_row9_col2, #T_e1e77_row9_col3, #T_e1e77_row9_col6, #T_e1e77_row9_col11, #T_e1e77_row9_col13, #T_e1e77_row10_col2, #T_e1e77_row10_col3, #T_e1e77_row10_col6, #T_e1e77_row11_col1, #T_e1e77_row11_col2, #T_e1e77_row11_col3, #T_e1e77_row11_col6, #T_e1e77_row11_col12, #T_e1e77_row11_col14 {\n",
       "  background-color: #f0f0f3;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row0_col1, #T_e1e77_row0_col4, #T_e1e77_row0_col9, #T_e1e77_row0_col12, #T_e1e77_row0_col14, #T_e1e77_row1_col0, #T_e1e77_row2_col0, #T_e1e77_row2_col5, #T_e1e77_row2_col7, #T_e1e77_row2_col8, #T_e1e77_row2_col10, #T_e1e77_row2_col11, #T_e1e77_row2_col13, #T_e1e77_row3_col1, #T_e1e77_row3_col12, #T_e1e77_row3_col14, #T_e1e77_row4_col0, #T_e1e77_row5_col0, #T_e1e77_row5_col11, #T_e1e77_row5_col13, #T_e1e77_row6_col1, #T_e1e77_row6_col12, #T_e1e77_row6_col14, #T_e1e77_row7_col0, #T_e1e77_row8_col0, #T_e1e77_row8_col11, #T_e1e77_row8_col13, #T_e1e77_row9_col1, #T_e1e77_row9_col12, #T_e1e77_row9_col14, #T_e1e77_row10_col0, #T_e1e77_row11_col0, #T_e1e77_row11_col10, #T_e1e77_row11_col11, #T_e1e77_row11_col13 {\n",
       "  background-color: #0000ff;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row0_col7, #T_e1e77_row1_col13, #T_e1e77_row4_col13, #T_e1e77_row7_col13, #T_e1e77_row10_col13 {\n",
       "  background-color: #5050fb;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row0_col10, #T_e1e77_row8_col5, #T_e1e77_row9_col10 {\n",
       "  background-color: #5252fb;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row1_col1, #T_e1e77_row4_col1, #T_e1e77_row4_col8, #T_e1e77_row5_col8, #T_e1e77_row7_col1, #T_e1e77_row10_col1, #T_e1e77_row10_col8, #T_e1e77_row11_col8 {\n",
       "  background-color: #6060fa;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row1_col4, #T_e1e77_row2_col9 {\n",
       "  background-color: #5a5afa;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row1_col5, #T_e1e77_row4_col5, #T_e1e77_row5_col5, #T_e1e77_row7_col5, #T_e1e77_row10_col5, #T_e1e77_row11_col5 {\n",
       "  background-color: #3f3ffc;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row1_col7 {\n",
       "  background-color: #0d0dfe;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row1_col8 {\n",
       "  background-color: #3a3afc;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row1_col9 {\n",
       "  background-color: #3737fc;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row1_col10, #T_e1e77_row10_col10 {\n",
       "  background-color: #0707ff;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row1_col11, #T_e1e77_row4_col11, #T_e1e77_row7_col11, #T_e1e77_row10_col11 {\n",
       "  background-color: #3b3bfc;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row1_col12, #T_e1e77_row4_col12, #T_e1e77_row7_col12, #T_e1e77_row10_col12 {\n",
       "  background-color: #a0a0f7;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row1_col14, #T_e1e77_row4_col14, #T_e1e77_row7_col14, #T_e1e77_row10_col14 {\n",
       "  background-color: #b4b4f6;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row2_col4, #T_e1e77_row4_col10, #T_e1e77_row5_col10 {\n",
       "  background-color: #7f7ff9;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row3_col4, #T_e1e77_row3_col9, #T_e1e77_row8_col9 {\n",
       "  background-color: #b3b3f6;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row3_col5, #T_e1e77_row9_col5 {\n",
       "  background-color: #6565fa;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row3_col7 {\n",
       "  background-color: #c9c9f5;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row3_col8, #T_e1e77_row9_col8 {\n",
       "  background-color: #9a9af7;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row3_col10 {\n",
       "  background-color: #d2d2f4;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row4_col4 {\n",
       "  background-color: #aaaaf6;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row4_col7, #T_e1e77_row5_col7, #T_e1e77_row10_col7, #T_e1e77_row11_col7 {\n",
       "  background-color: #8686f8;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row4_col9 {\n",
       "  background-color: #9797f7;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row5_col4, #T_e1e77_row10_col4, #T_e1e77_row11_col4 {\n",
       "  background-color: #aeaef6;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row5_col9, #T_e1e77_row10_col9, #T_e1e77_row11_col9 {\n",
       "  background-color: #9e9ef7;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row6_col5 {\n",
       "  background-color: #3232fc;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row6_col8, #T_e1e77_row8_col8 {\n",
       "  background-color: #7d7df9;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row7_col4 {\n",
       "  background-color: #c6c6f5;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row7_col7, #T_e1e77_row8_col7, #T_e1e77_row8_col10 {\n",
       "  background-color: #adadf6;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row7_col8 {\n",
       "  background-color: #6a6afa;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_e1e77_row7_col9 {\n",
       "  background-color: #babaf6;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row7_col10 {\n",
       "  background-color: #a5a5f7;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row8_col4 {\n",
       "  background-color: #bdbdf5;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row9_col4 {\n",
       "  background-color: #cbcbf5;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row9_col7 {\n",
       "  background-color: #d6d6f4;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_e1e77_row9_col9 {\n",
       "  background-color: #c8c8f5;\n",
       "  color: #000000;\n",
       "}\n",
       "</style>\n",
       "<table id=\"T_e1e77\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_e1e77_level0_col0\" class=\"col_heading level0 col0\" >Accuracy</th>\n",
       "      <th id=\"T_e1e77_level0_col1\" class=\"col_heading level0 col1\" >Balanced Accuracy</th>\n",
       "      <th id=\"T_e1e77_level0_col2\" class=\"col_heading level0 col2\" >ROC AUC</th>\n",
       "      <th id=\"T_e1e77_level0_col3\" class=\"col_heading level0 col3\" >PR AUC</th>\n",
       "      <th id=\"T_e1e77_level0_col4\" class=\"col_heading level0 col4\" >Precision</th>\n",
       "      <th id=\"T_e1e77_level0_col5\" class=\"col_heading level0 col5\" >Recall</th>\n",
       "      <th id=\"T_e1e77_level0_col6\" class=\"col_heading level0 col6\" >Average Precision</th>\n",
       "      <th id=\"T_e1e77_level0_col7\" class=\"col_heading level0 col7\" >F-1 Score</th>\n",
       "      <th id=\"T_e1e77_level0_col8\" class=\"col_heading level0 col8\" >F-2 Score</th>\n",
       "      <th id=\"T_e1e77_level0_col9\" class=\"col_heading level0 col9\" >F-0.50 Score</th>\n",
       "      <th id=\"T_e1e77_level0_col10\" class=\"col_heading level0 col10\" >Threat Score</th>\n",
       "      <th id=\"T_e1e77_level0_col11\" class=\"col_heading level0 col11\" >TP</th>\n",
       "      <th id=\"T_e1e77_level0_col12\" class=\"col_heading level0 col12\" >TN</th>\n",
       "      <th id=\"T_e1e77_level0_col13\" class=\"col_heading level0 col13\" >FP</th>\n",
       "      <th id=\"T_e1e77_level0_col14\" class=\"col_heading level0 col14\" >FN</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_e1e77_level0_row0\" class=\"row_heading level0 row0\" >Threshold = 0.630 | Average =\n",
       "                Binary</th>\n",
       "      <td id=\"T_e1e77_row0_col0\" class=\"data row0 col0\" >0.947000</td>\n",
       "      <td id=\"T_e1e77_row0_col1\" class=\"data row0 col1\" >0.955000</td>\n",
       "      <td id=\"T_e1e77_row0_col2\" class=\"data row0 col2\" >0.987000</td>\n",
       "      <td id=\"T_e1e77_row0_col3\" class=\"data row0 col3\" >0.991000</td>\n",
       "      <td id=\"T_e1e77_row0_col4\" class=\"data row0 col4\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row0_col5\" class=\"data row0 col5\" >0.925000</td>\n",
       "      <td id=\"T_e1e77_row0_col6\" class=\"data row0 col6\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row0_col7\" class=\"data row0 col7\" >0.957000</td>\n",
       "      <td id=\"T_e1e77_row0_col8\" class=\"data row0 col8\" >0.938000</td>\n",
       "      <td id=\"T_e1e77_row0_col9\" class=\"data row0 col9\" >0.976000</td>\n",
       "      <td id=\"T_e1e77_row0_col10\" class=\"data row0 col10\" >0.917000</td>\n",
       "      <td id=\"T_e1e77_row0_col11\" class=\"data row0 col11\" >99</td>\n",
       "      <td id=\"T_e1e77_row0_col12\" class=\"data row0 col12\" >63</td>\n",
       "      <td id=\"T_e1e77_row0_col13\" class=\"data row0 col13\" >1</td>\n",
       "      <td id=\"T_e1e77_row0_col14\" class=\"data row0 col14\" >8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_e1e77_level0_row1\" class=\"row_heading level0 row1\" >Threshold = 0.530 | Average =\n",
       "                Binary</th>\n",
       "      <td id=\"T_e1e77_row1_col0\" class=\"data row1 col0\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row1_col1\" class=\"data row1 col1\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row1_col2\" class=\"data row1 col2\" >0.987000</td>\n",
       "      <td id=\"T_e1e77_row1_col3\" class=\"data row1 col3\" >0.991000</td>\n",
       "      <td id=\"T_e1e77_row1_col4\" class=\"data row1 col4\" >0.971000</td>\n",
       "      <td id=\"T_e1e77_row1_col5\" class=\"data row1 col5\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row1_col6\" class=\"data row1 col6\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row1_col7\" class=\"data row1 col7\" >0.962000</td>\n",
       "      <td id=\"T_e1e77_row1_col8\" class=\"data row1 col8\" >0.957000</td>\n",
       "      <td id=\"T_e1e77_row1_col9\" class=\"data row1 col9\" >0.968000</td>\n",
       "      <td id=\"T_e1e77_row1_col10\" class=\"data row1 col10\" >0.927000</td>\n",
       "      <td id=\"T_e1e77_row1_col11\" class=\"data row1 col11\" >102</td>\n",
       "      <td id=\"T_e1e77_row1_col12\" class=\"data row1 col12\" >61</td>\n",
       "      <td id=\"T_e1e77_row1_col13\" class=\"data row1 col13\" >3</td>\n",
       "      <td id=\"T_e1e77_row1_col14\" class=\"data row1 col14\" >5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_e1e77_level0_row2\" class=\"row_heading level0 row2\" >Threshold = 0.510 | Average =\n",
       "                Binary</th>\n",
       "      <td id=\"T_e1e77_row2_col0\" class=\"data row2 col0\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row2_col1\" class=\"data row2 col1\" >0.950000</td>\n",
       "      <td id=\"T_e1e77_row2_col2\" class=\"data row2 col2\" >0.987000</td>\n",
       "      <td id=\"T_e1e77_row2_col3\" class=\"data row2 col3\" >0.991000</td>\n",
       "      <td id=\"T_e1e77_row2_col4\" class=\"data row2 col4\" >0.963000</td>\n",
       "      <td id=\"T_e1e77_row2_col5\" class=\"data row2 col5\" >0.963000</td>\n",
       "      <td id=\"T_e1e77_row2_col6\" class=\"data row2 col6\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row2_col7\" class=\"data row2 col7\" >0.963000</td>\n",
       "      <td id=\"T_e1e77_row2_col8\" class=\"data row2 col8\" >0.963000</td>\n",
       "      <td id=\"T_e1e77_row2_col9\" class=\"data row2 col9\" >0.963000</td>\n",
       "      <td id=\"T_e1e77_row2_col10\" class=\"data row2 col10\" >0.928000</td>\n",
       "      <td id=\"T_e1e77_row2_col11\" class=\"data row2 col11\" >103</td>\n",
       "      <td id=\"T_e1e77_row2_col12\" class=\"data row2 col12\" >60</td>\n",
       "      <td id=\"T_e1e77_row2_col13\" class=\"data row2 col13\" >4</td>\n",
       "      <td id=\"T_e1e77_row2_col14\" class=\"data row2 col14\" >4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_e1e77_level0_row3\" class=\"row_heading level0 row3\" >Threshold = 0.630 | Average =\n",
       "                Weighted</th>\n",
       "      <td id=\"T_e1e77_row3_col0\" class=\"data row3 col0\" >0.947000</td>\n",
       "      <td id=\"T_e1e77_row3_col1\" class=\"data row3 col1\" >0.955000</td>\n",
       "      <td id=\"T_e1e77_row3_col2\" class=\"data row3 col2\" >0.987000</td>\n",
       "      <td id=\"T_e1e77_row3_col3\" class=\"data row3 col3\" >0.991000</td>\n",
       "      <td id=\"T_e1e77_row3_col4\" class=\"data row3 col4\" >0.952000</td>\n",
       "      <td id=\"T_e1e77_row3_col5\" class=\"data row3 col5\" >0.947000</td>\n",
       "      <td id=\"T_e1e77_row3_col6\" class=\"data row3 col6\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row3_col7\" class=\"data row3 col7\" >0.948000</td>\n",
       "      <td id=\"T_e1e77_row3_col8\" class=\"data row3 col8\" >0.947000</td>\n",
       "      <td id=\"T_e1e77_row3_col9\" class=\"data row3 col9\" >0.950000</td>\n",
       "      <td id=\"T_e1e77_row3_col10\" class=\"data row3 col10\" >0.900000</td>\n",
       "      <td id=\"T_e1e77_row3_col11\" class=\"data row3 col11\" >99</td>\n",
       "      <td id=\"T_e1e77_row3_col12\" class=\"data row3 col12\" >63</td>\n",
       "      <td id=\"T_e1e77_row3_col13\" class=\"data row3 col13\" >1</td>\n",
       "      <td id=\"T_e1e77_row3_col14\" class=\"data row3 col14\" >8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_e1e77_level0_row4\" class=\"row_heading level0 row4\" >Threshold = 0.530 | Average =\n",
       "                Weighted</th>\n",
       "      <td id=\"T_e1e77_row4_col0\" class=\"data row4 col0\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row4_col1\" class=\"data row4 col1\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row4_col2\" class=\"data row4 col2\" >0.987000</td>\n",
       "      <td id=\"T_e1e77_row4_col3\" class=\"data row4 col3\" >0.991000</td>\n",
       "      <td id=\"T_e1e77_row4_col4\" class=\"data row4 col4\" >0.954000</td>\n",
       "      <td id=\"T_e1e77_row4_col5\" class=\"data row4 col5\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row4_col6\" class=\"data row4 col6\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row4_col7\" class=\"data row4 col7\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row4_col8\" class=\"data row4 col8\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row4_col9\" class=\"data row4 col9\" >0.954000</td>\n",
       "      <td id=\"T_e1e77_row4_col10\" class=\"data row4 col10\" >0.911000</td>\n",
       "      <td id=\"T_e1e77_row4_col11\" class=\"data row4 col11\" >102</td>\n",
       "      <td id=\"T_e1e77_row4_col12\" class=\"data row4 col12\" >61</td>\n",
       "      <td id=\"T_e1e77_row4_col13\" class=\"data row4 col13\" >3</td>\n",
       "      <td id=\"T_e1e77_row4_col14\" class=\"data row4 col14\" >5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_e1e77_level0_row5\" class=\"row_heading level0 row5\" >Threshold = 0.510 | Average =\n",
       "                Weighted</th>\n",
       "      <td id=\"T_e1e77_row5_col0\" class=\"data row5 col0\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row5_col1\" class=\"data row5 col1\" >0.950000</td>\n",
       "      <td id=\"T_e1e77_row5_col2\" class=\"data row5 col2\" >0.987000</td>\n",
       "      <td id=\"T_e1e77_row5_col3\" class=\"data row5 col3\" >0.991000</td>\n",
       "      <td id=\"T_e1e77_row5_col4\" class=\"data row5 col4\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row5_col5\" class=\"data row5 col5\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row5_col6\" class=\"data row5 col6\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row5_col7\" class=\"data row5 col7\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row5_col8\" class=\"data row5 col8\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row5_col9\" class=\"data row5 col9\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row5_col10\" class=\"data row5 col10\" >0.911000</td>\n",
       "      <td id=\"T_e1e77_row5_col11\" class=\"data row5 col11\" >103</td>\n",
       "      <td id=\"T_e1e77_row5_col12\" class=\"data row5 col12\" >60</td>\n",
       "      <td id=\"T_e1e77_row5_col13\" class=\"data row5 col13\" >4</td>\n",
       "      <td id=\"T_e1e77_row5_col14\" class=\"data row5 col14\" >4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_e1e77_level0_row6\" class=\"row_heading level0 row6\" >Threshold = 0.630 | Average =\n",
       "                Macro</th>\n",
       "      <td id=\"T_e1e77_row6_col0\" class=\"data row6 col0\" >0.947000</td>\n",
       "      <td id=\"T_e1e77_row6_col1\" class=\"data row6 col1\" >0.955000</td>\n",
       "      <td id=\"T_e1e77_row6_col2\" class=\"data row6 col2\" >0.987000</td>\n",
       "      <td id=\"T_e1e77_row6_col3\" class=\"data row6 col3\" >0.991000</td>\n",
       "      <td id=\"T_e1e77_row6_col4\" class=\"data row6 col4\" >0.939000</td>\n",
       "      <td id=\"T_e1e77_row6_col5\" class=\"data row6 col5\" >0.955000</td>\n",
       "      <td id=\"T_e1e77_row6_col6\" class=\"data row6 col6\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row6_col7\" class=\"data row6 col7\" >0.945000</td>\n",
       "      <td id=\"T_e1e77_row6_col8\" class=\"data row6 col8\" >0.950000</td>\n",
       "      <td id=\"T_e1e77_row6_col9\" class=\"data row6 col9\" >0.941000</td>\n",
       "      <td id=\"T_e1e77_row6_col10\" class=\"data row6 col10\" >0.896000</td>\n",
       "      <td id=\"T_e1e77_row6_col11\" class=\"data row6 col11\" >99</td>\n",
       "      <td id=\"T_e1e77_row6_col12\" class=\"data row6 col12\" >63</td>\n",
       "      <td id=\"T_e1e77_row6_col13\" class=\"data row6 col13\" >1</td>\n",
       "      <td id=\"T_e1e77_row6_col14\" class=\"data row6 col14\" >8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_e1e77_level0_row7\" class=\"row_heading level0 row7\" >Threshold = 0.530 | Average =\n",
       "                Macro</th>\n",
       "      <td id=\"T_e1e77_row7_col0\" class=\"data row7 col0\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row7_col1\" class=\"data row7 col1\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row7_col2\" class=\"data row7 col2\" >0.987000</td>\n",
       "      <td id=\"T_e1e77_row7_col3\" class=\"data row7 col3\" >0.991000</td>\n",
       "      <td id=\"T_e1e77_row7_col4\" class=\"data row7 col4\" >0.948000</td>\n",
       "      <td id=\"T_e1e77_row7_col5\" class=\"data row7 col5\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row7_col6\" class=\"data row7 col6\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row7_col7\" class=\"data row7 col7\" >0.950000</td>\n",
       "      <td id=\"T_e1e77_row7_col8\" class=\"data row7 col8\" >0.952000</td>\n",
       "      <td id=\"T_e1e77_row7_col9\" class=\"data row7 col9\" >0.949000</td>\n",
       "      <td id=\"T_e1e77_row7_col10\" class=\"data row7 col10\" >0.906000</td>\n",
       "      <td id=\"T_e1e77_row7_col11\" class=\"data row7 col11\" >102</td>\n",
       "      <td id=\"T_e1e77_row7_col12\" class=\"data row7 col12\" >61</td>\n",
       "      <td id=\"T_e1e77_row7_col13\" class=\"data row7 col13\" >3</td>\n",
       "      <td id=\"T_e1e77_row7_col14\" class=\"data row7 col14\" >5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_e1e77_level0_row8\" class=\"row_heading level0 row8\" >Threshold = 0.510 | Average =\n",
       "                Macro</th>\n",
       "      <td id=\"T_e1e77_row8_col0\" class=\"data row8 col0\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row8_col1\" class=\"data row8 col1\" >0.950000</td>\n",
       "      <td id=\"T_e1e77_row8_col2\" class=\"data row8 col2\" >0.987000</td>\n",
       "      <td id=\"T_e1e77_row8_col3\" class=\"data row8 col3\" >0.991000</td>\n",
       "      <td id=\"T_e1e77_row8_col4\" class=\"data row8 col4\" >0.950000</td>\n",
       "      <td id=\"T_e1e77_row8_col5\" class=\"data row8 col5\" >0.950000</td>\n",
       "      <td id=\"T_e1e77_row8_col6\" class=\"data row8 col6\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row8_col7\" class=\"data row8 col7\" >0.950000</td>\n",
       "      <td id=\"T_e1e77_row8_col8\" class=\"data row8 col8\" >0.950000</td>\n",
       "      <td id=\"T_e1e77_row8_col9\" class=\"data row8 col9\" >0.950000</td>\n",
       "      <td id=\"T_e1e77_row8_col10\" class=\"data row8 col10\" >0.905000</td>\n",
       "      <td id=\"T_e1e77_row8_col11\" class=\"data row8 col11\" >103</td>\n",
       "      <td id=\"T_e1e77_row8_col12\" class=\"data row8 col12\" >60</td>\n",
       "      <td id=\"T_e1e77_row8_col13\" class=\"data row8 col13\" >4</td>\n",
       "      <td id=\"T_e1e77_row8_col14\" class=\"data row8 col14\" >4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_e1e77_level0_row9\" class=\"row_heading level0 row9\" >Threshold = 0.630 | Average =\n",
       "                Micro</th>\n",
       "      <td id=\"T_e1e77_row9_col0\" class=\"data row9 col0\" >0.947000</td>\n",
       "      <td id=\"T_e1e77_row9_col1\" class=\"data row9 col1\" >0.955000</td>\n",
       "      <td id=\"T_e1e77_row9_col2\" class=\"data row9 col2\" >0.987000</td>\n",
       "      <td id=\"T_e1e77_row9_col3\" class=\"data row9 col3\" >0.991000</td>\n",
       "      <td id=\"T_e1e77_row9_col4\" class=\"data row9 col4\" >0.947000</td>\n",
       "      <td id=\"T_e1e77_row9_col5\" class=\"data row9 col5\" >0.947000</td>\n",
       "      <td id=\"T_e1e77_row9_col6\" class=\"data row9 col6\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row9_col7\" class=\"data row9 col7\" >0.947000</td>\n",
       "      <td id=\"T_e1e77_row9_col8\" class=\"data row9 col8\" >0.947000</td>\n",
       "      <td id=\"T_e1e77_row9_col9\" class=\"data row9 col9\" >0.947000</td>\n",
       "      <td id=\"T_e1e77_row9_col10\" class=\"data row9 col10\" >0.917000</td>\n",
       "      <td id=\"T_e1e77_row9_col11\" class=\"data row9 col11\" >99</td>\n",
       "      <td id=\"T_e1e77_row9_col12\" class=\"data row9 col12\" >63</td>\n",
       "      <td id=\"T_e1e77_row9_col13\" class=\"data row9 col13\" >1</td>\n",
       "      <td id=\"T_e1e77_row9_col14\" class=\"data row9 col14\" >8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_e1e77_level0_row10\" class=\"row_heading level0 row10\" >Threshold = 0.530 | Average =\n",
       "                Micro</th>\n",
       "      <td id=\"T_e1e77_row10_col0\" class=\"data row10 col0\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row10_col1\" class=\"data row10 col1\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row10_col2\" class=\"data row10 col2\" >0.987000</td>\n",
       "      <td id=\"T_e1e77_row10_col3\" class=\"data row10 col3\" >0.991000</td>\n",
       "      <td id=\"T_e1e77_row10_col4\" class=\"data row10 col4\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row10_col5\" class=\"data row10 col5\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row10_col6\" class=\"data row10 col6\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row10_col7\" class=\"data row10 col7\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row10_col8\" class=\"data row10 col8\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row10_col9\" class=\"data row10 col9\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row10_col10\" class=\"data row10 col10\" >0.927000</td>\n",
       "      <td id=\"T_e1e77_row10_col11\" class=\"data row10 col11\" >102</td>\n",
       "      <td id=\"T_e1e77_row10_col12\" class=\"data row10 col12\" >61</td>\n",
       "      <td id=\"T_e1e77_row10_col13\" class=\"data row10 col13\" >3</td>\n",
       "      <td id=\"T_e1e77_row10_col14\" class=\"data row10 col14\" >5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_e1e77_level0_row11\" class=\"row_heading level0 row11\" >Threshold = 0.510 | Average =\n",
       "                Micro</th>\n",
       "      <td id=\"T_e1e77_row11_col0\" class=\"data row11 col0\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row11_col1\" class=\"data row11 col1\" >0.950000</td>\n",
       "      <td id=\"T_e1e77_row11_col2\" class=\"data row11 col2\" >0.987000</td>\n",
       "      <td id=\"T_e1e77_row11_col3\" class=\"data row11 col3\" >0.991000</td>\n",
       "      <td id=\"T_e1e77_row11_col4\" class=\"data row11 col4\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row11_col5\" class=\"data row11 col5\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row11_col6\" class=\"data row11 col6\" >0.990000</td>\n",
       "      <td id=\"T_e1e77_row11_col7\" class=\"data row11 col7\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row11_col8\" class=\"data row11 col8\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row11_col9\" class=\"data row11 col9\" >0.953000</td>\n",
       "      <td id=\"T_e1e77_row11_col10\" class=\"data row11 col10\" >0.928000</td>\n",
       "      <td id=\"T_e1e77_row11_col11\" class=\"data row11 col11\" >103</td>\n",
       "      <td id=\"T_e1e77_row11_col12\" class=\"data row11 col12\" >60</td>\n",
       "      <td id=\"T_e1e77_row11_col13\" class=\"data row11 col13\" >4</td>\n",
       "      <td id=\"T_e1e77_row11_col14\" class=\"data row11 col14\" >4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x13c4e3a00>"
      ]
     },
     "metadata": {}
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### More on `pandas.DataFrame` Styling can be found [here](https://pandas.pydata.org/pandas-docs/version/1.1/user_guide/style.html#:~:text=You%20can%20apply%20conditional%20formatting,styling%20is%20accomplished%20using%20CSS)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Feel free to add your favorite `Example` via a `pull-request`.\n",
    "### More details can be found in our [Contributing Document](https://github.com/slickml/slick-ml/blob/master/CONTRIBUTING.md)."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {}
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.9.12 64-bit ('.venv': poetry)"
  },
  "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"
  },
  "interpreter": {
   "hash": "07bad374b921cdabaf2ef6a1d4ae5a7996d892e7452f8d9d13efced363d002df"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}