Arima.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "efe39bce",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-1-ce94da36370f>:4: FutureWarning: The pandas.datetime class is deprecated and will be removed from pandas in a future version. Import from datetime module instead.\n",
      "  from pandas import datetime\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from pandas import read_csv\n",
    "from pandas import datetime\n",
    "import matplotlib.pyplot as plt\n",
    "from pandas.plotting import autocorrelation_plot\n",
    "import model, model_utils, preprocessing_utils\n",
    "import torch\n",
    "import torch.nn as nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6c313c8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# if using seasonal ARIMA\n",
    "m = 12 # 60 minutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "268397f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_trunc_dir = \"./data/raw/trunc/\"\n",
    "process_dir = \"./data/processed/\"\n",
    "\n",
    "# overwrite = False means that the processing function will only run if the process data files do not exist\n",
    "# overwrite = True => functions will run regardless\n",
    "preprocessing_utils.processed(raw_trunc_dir, process_dir, overwrite=False)\n",
    "A, X, metadata, cat2index,timestamps, means, stds = preprocessing_utils.load(process_dir)\n",
    "\n",
    "split_line1 = int(X.shape[2] * 0.6)\n",
    "split_line2 = int(X.shape[2] * 0.8)\n",
    "\n",
    "train_original_data = X[:, :, :split_line1]\n",
    "val_original_data = X[:, :, split_line1:split_line2]\n",
    "test_original_data = X[:, :, split_line2:]\n",
    "\n",
    "adj_mat = preprocessing_utils.get_normalized_adj(A)\n",
    "# adj_mat = torch.from_numpy(adj_mat).to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ea8b735",
   "metadata": {},
   "source": [
    "# Finding the road to be used as comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "931aa609",
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "epochs = 500\n",
    "batch_size = 16\n",
    "lr = 0.0005920310461116504\n",
    "patience = 10\n",
    "\n",
    "num_timesteps_input = 7 # Default is 30 minutes\n",
    "num_timesteps_output = 4 # Default is 10 minutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "ff857f65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading model in path : saved_models\\Final_STGCN_Weights\n"
     ]
    }
   ],
   "source": [
    "# loaded_model, loaded_optimizer = model_utils.load_model(path=None)\n",
    "loaded_model, loaded_optimizer = model_utils.load_model(path=\"saved_models\\Final_STGCN_Weights\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "62260917",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_timesteps_input = 8\n",
    "num_timesteps_output = 4\n",
    "test_input, test_target = preprocessing_utils.generate_dataset(test_original_data,\n",
    "                                           num_timesteps_input=num_timesteps_input,\n",
    "                                           num_timesteps_output=num_timesteps_output)\n",
    "adj_mat = torch.from_numpy(adj_mat).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "65572201",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import mean_squared_error\n",
    "import model, model_utils, preprocessing_utils\n",
    "import math\n",
    "\n",
    "loaded_model.to(device)\n",
    "with torch.no_grad():\n",
    "    predicted = model_utils.predict(loaded_model, test_input, adj_mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "f8643a6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Enyi functions\n",
    "import torch.nn as nn\n",
    "def rmse_per_link(predicted, actual):\n",
    "    '''\n",
    "    Calculates the RMSE of the speedbands for each road separately\n",
    "    -----------------------------\n",
    "    :params:\n",
    "        list (3-dimensions of samples, roads, output timesteps) predicted: The predicted speedbands\n",
    "        list (3-dimensions of samples, roads, output timesteps) actual: The actual speedbands\n",
    "    -----------------------------\n",
    "    :returns:\n",
    "        list: rmse for each road\n",
    "    '''\n",
    "    rmses = []\n",
    "    for i in range(predicted.shape[1]):\n",
    "        linkPreds = predicted[:,i,:]\n",
    "        linkActs = actual[:,i,:]\n",
    "        rmse = nn.MSELoss()(linkPreds, linkActs).sqrt()\n",
    "        rmses.append(rmse.item())\n",
    "    return rmses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "4ce2939c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0277539491653442\n"
     ]
    }
   ],
   "source": [
    "predicted_denorm = preprocessing_utils.denormalize(predicted.to(\"cpu\"), stds[0], means[0])\n",
    "actual_denorm = preprocessing_utils.denormalize(test_target, stds[0], means[0])\n",
    "stgcn_rmse_per_link = rmse_per_link(predicted_denorm.to(device=\"cpu\"),actual_denorm)\n",
    "worst_road_index = np.argmax(stgcn_rmse_per_link)\n",
    "print(stgcn_rmse_per_link[worst_road_index])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e1eda89",
   "metadata": {},
   "source": [
    "# Evaluating ARIMA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3825e868",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_original_speedband = train_original_data[:,0,:] # (roads, num_of_timesteps)\n",
    "val_original_data_speedband = val_original_data[:,0,:] # (roads, num_of_timesteps)\n",
    "test_original_data_speedband = test_original_data[:,0,:] # (roads, num_of_timesteps)\n",
    "\n",
    "train = train_original_speedband[0].flatten() # choose only 1 road\n",
    "val = val_original_data_speedband[0].flatten() # choose only 1 road\n",
    "test = test_original_data_speedband[0].flatten() # choose only 1 road\n",
    "\n",
    "train_val = np.append(train,val)\n",
    "dataAll = np.concatenate([train,val,test])\n",
    "\n",
    "train_denorm = preprocessing_utils.denormalize(train, stds[0], means[0]).flatten()\n",
    "train_val_denorm = preprocessing_utils.denormalize(train_val, stds[0], means[0]).flatten()\n",
    "dataAll_denorm = preprocessing_utils.denormalize(dataAll, stds[0], means[0]).flatten()\n",
    "test_denorm = preprocessing_utils.denormalize(test, stds[0], means[0]).flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "16975469",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performing stepwise search to minimize aic\n",
      " ARIMA(2,0,2)(0,0,0)[0] intercept   : AIC=14819.051, Time=7.95 sec\n",
      " ARIMA(0,0,0)(0,0,0)[0] intercept   : AIC=19299.326, Time=0.09 sec\n",
      " ARIMA(1,0,0)(0,0,0)[0] intercept   : AIC=14935.508, Time=0.47 sec\n",
      " ARIMA(0,0,1)(0,0,0)[0] intercept   : AIC=16313.746, Time=0.72 sec\n",
      " ARIMA(0,0,0)(0,0,0)[0]             : AIC=20170.774, Time=0.05 sec\n",
      " ARIMA(1,0,2)(0,0,0)[0] intercept   : AIC=14921.552, Time=1.24 sec\n",
      " ARIMA(2,0,1)(0,0,0)[0] intercept   : AIC=14921.700, Time=2.17 sec\n",
      " ARIMA(3,0,2)(0,0,0)[0] intercept   : AIC=14876.480, Time=8.48 sec\n",
      " ARIMA(2,0,3)(0,0,0)[0] intercept   : AIC=14802.190, Time=7.01 sec\n",
      " ARIMA(1,0,3)(0,0,0)[0] intercept   : AIC=14896.876, Time=3.31 sec\n",
      " ARIMA(3,0,3)(0,0,0)[0] intercept   : AIC=14808.989, Time=8.06 sec\n",
      " ARIMA(2,0,4)(0,0,0)[0] intercept   : AIC=14798.591, Time=7.62 sec\n",
      " ARIMA(1,0,4)(0,0,0)[0] intercept   : AIC=14809.961, Time=4.22 sec\n",
      " ARIMA(3,0,4)(0,0,0)[0] intercept   : AIC=14806.050, Time=10.77 sec\n",
      " ARIMA(2,0,5)(0,0,0)[0] intercept   : AIC=14799.549, Time=10.10 sec\n",
      " ARIMA(1,0,5)(0,0,0)[0] intercept   : AIC=14798.084, Time=6.24 sec\n",
      " ARIMA(0,0,5)(0,0,0)[0] intercept   : AIC=14974.776, Time=2.25 sec\n",
      " ARIMA(0,0,4)(0,0,0)[0] intercept   : AIC=15011.469, Time=1.88 sec\n",
      " ARIMA(1,0,5)(0,0,0)[0]             : AIC=14819.648, Time=3.80 sec\n",
      "\n",
      "Best model:  ARIMA(1,0,5)(0,0,0)[0] intercept\n",
      "Total fit time: 86.435 seconds\n",
      "                               SARIMAX Results                                \n",
      "==============================================================================\n",
      "Dep. Variable:                      y   No. Observations:                 5997\n",
      "Model:               SARIMAX(1, 0, 5)   Log Likelihood               -7391.042\n",
      "Date:                Sun, 02 May 2021   AIC                          14798.084\n",
      "Time:                        21:38:34   BIC                          14851.677\n",
      "Sample:                             0   HQIC                         14816.696\n",
      "                               - 5997                                         \n",
      "Covariance Type:                  opg                                         \n",
      "==============================================================================\n",
      "                 coef    std err          z      P>|z|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "intercept      0.0116      0.004      3.296      0.001       0.005       0.018\n",
      "ar.L1          0.9758      0.005    187.898      0.000       0.966       0.986\n",
      "ma.L1         -0.2393      0.013    -18.391      0.000      -0.265      -0.214\n",
      "ma.L2         -0.2355      0.012    -19.034      0.000      -0.260      -0.211\n",
      "ma.L3         -0.1882      0.012    -16.089      0.000      -0.211      -0.165\n",
      "ma.L4         -0.1175      0.012    -10.052      0.000      -0.140      -0.095\n",
      "ma.L5         -0.0484      0.012     -4.153      0.000      -0.071      -0.026\n",
      "sigma2         0.6886      0.007     92.929      0.000       0.674       0.703\n",
      "===================================================================================\n",
      "Ljung-Box (L1) (Q):                   0.00   Jarque-Bera (JB):              9988.39\n",
      "Prob(Q):                              0.95   Prob(JB):                         0.00\n",
      "Heteroskedasticity (H):               1.07   Skew:                             0.43\n",
      "Prob(H) (two-sided):                  0.13   Kurtosis:                         9.26\n",
      "===================================================================================\n",
      "\n",
      "Warnings:\n",
      "[1] Covariance matrix calculated using the outer product of gradients (complex-step).\n"
     ]
    }
   ],
   "source": [
    "import pmdarima as pm\n",
    "train_val = np.append(train,val)\n",
    "\n",
    "# Fit your model\n",
    "# road 3\n",
    "road = 3\n",
    "train_fit = np.concatenate([train_original_speedband[road],val_original_data_speedband[road]])\n",
    "model = pm.auto_arima(train_fit,\n",
    "    trace=True,\n",
    "    suppress_warning=True)\n",
    "\n",
    "# summary of fit model\n",
    "print(model.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "302a1e22",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get RMSE\n",
    "def evaluate_RMSE(model, ):\n",
    "    # model = ARIMA(,order=(3,1,1))\n",
    "    num_of_input = 7\n",
    "    current_input = train_val[-num_of_input:].tolist()\n",
    "\n",
    "    limit = len(test)\n",
    "    num_of_pred = 1\n",
    "    pred = []\n",
    "    for i in range(0,len(test[:limit]), num_of_pred):\n",
    "        model.fit(current_input)\n",
    "        y = model.predict(n_periods=num_of_pred)\n",
    "        pred.extend(y)\n",
    "\n",
    "        current_input.pop()\n",
    "        current_input.extend(test[i:i+1])\n",
    "\n",
    "def rmse(predictions, targets):\n",
    "    size = len(predictions)\n",
    "    diff = predictions - targets\n",
    "    square = diff ** 2\n",
    "    rmse = 1/size * (square ** 1/2).sum()\n",
    "    return np.sqrt(((predictions - targets) ** 2).mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "610a9a03",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_arima(model, test_original_data, road, num_timesteps_input, num_timesteps_output):\n",
    "    \"\"\"\n",
    "    params:\n",
    "        model: \n",
    "        test_original_data: list\n",
    "        road: int\n",
    "        num_timesteps_input: int\n",
    "        num_timesteps_output: int\n",
    "    \"\"\"\n",
    "    num_timesteps_input = num_timesteps_input\n",
    "    num_timesteps_output = num_timesteps_output\n",
    "    test_input, test_target = preprocessing_utils.generate_dataset(test_original_data,\n",
    "                                           num_timesteps_input=num_timesteps_input,\n",
    "                                           num_timesteps_output=num_timesteps_output)\n",
    "    road = road # worst road\n",
    "    total_road = 53\n",
    "\n",
    "    print(f\"Evaluating road {road}\")\n",
    "    \n",
    "    all_predictions = []\n",
    "    all_actuals = []\n",
    "    \n",
    "    for x,y in zip(test_input[:,:,:,0],test_target):\n",
    "    #     m = ARIMA(x[road].numpy(),order=order)\n",
    "    #     m_fit = m.fit()\n",
    "    #     output = m_fit.forecast(steps=num_timesteps_output)\n",
    "        m_fit = model.fit(x[road].numpy())\n",
    "        output = m_fit.predict(n_periods=num_timesteps_output)\n",
    "\n",
    "        # denormalise\n",
    "        predictions = preprocessing_utils.denormalize(output, stds[0], means[0]).flatten()\n",
    "        actuals = preprocessing_utils.denormalize(y[road], stds[0], means[0]).flatten()\n",
    "        \n",
    "        all_predictions.append(predictions)\n",
    "        all_actuals.append(actuals.numpy())\n",
    "        \n",
    "    # calculate RMSE\n",
    "    rmse = nn.MSELoss()(torch.tensor(all_predictions), torch.tensor(all_actuals)).sqrt()\n",
    "    print(f\"With input timestep {num_timesteps_input} and output timestep {num_timesteps_output}, loss = {rmse}\")\n",
    "    return all_predictions,all_actuals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "c243dbe5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating road 3\n",
      "With input timestep 8 and output timestep 4, loss = 1.2557712703742772\n"
     ]
    }
   ],
   "source": [
    "pred2, act2 = evaluate_arima(model, test_original_data, 3, 8, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "725352f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating road 3\n",
      "With input timestep 8 and output timestep 1, loss = 1.1683396349571813\n",
      "Evaluating road 3\n",
      "With input timestep 8 and output timestep 2, loss = 1.2254906434045825\n",
      "Evaluating road 3\n",
      "With input timestep 8 and output timestep 3, loss = 1.2473878924872566\n",
      "Evaluating road 3\n",
      "With input timestep 8 and output timestep 4, loss = 1.2557712703742772\n",
      "Evaluating road 3\n",
      "With input timestep 8 and output timestep 5, loss = 1.2575966723804726\n",
      "Evaluating road 3\n",
      "With input timestep 8 and output timestep 6, loss = 1.2571616381597812\n"
     ]
    }
   ],
   "source": [
    "p381,a381=evaluate_arima(model, test_original_data, 3, 8, 1)\n",
    "p382,a382=evaluate_arima(model, test_original_data, 3, 8, 2)\n",
    "p383,a383=evaluate_arima(model, test_original_data, 3, 8, 3)\n",
    "p384,a384=evaluate_arima(model, test_original_data, 3, 8, 4)\n",
    "p385,a385=evaluate_arima(model, test_original_data, 3, 8, 5)\n",
    "p386,a386=evaluate_arima(model, test_original_data, 3, 8, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "7702b22d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating road 3\n",
      "With input timestep 25 and output timestep 1, loss = 1.0598665555145472\n",
      "Evaluating road 3\n",
      "With input timestep 25 and output timestep 2, loss = 1.1592797699181716\n",
      "Evaluating road 3\n",
      "With input timestep 25 and output timestep 3, loss = 1.206177411372162\n",
      "Evaluating road 3\n",
      "With input timestep 25 and output timestep 4, loss = 1.2228858017397903\n",
      "Evaluating road 3\n",
      "With input timestep 25 and output timestep 5, loss = 1.225898456959899\n",
      "Evaluating road 3\n",
      "With input timestep 25 and output timestep 6, loss = 1.2199593151157317\n"
     ]
    }
   ],
   "source": [
    "p3251,a3251=evaluate_arima(model, test_original_data, 3, 25, 1)\n",
    "p3252,a3252=evaluate_arima(model, test_original_data, 3, 25, 2)\n",
    "p3253,a3253=evaluate_arima(model, test_original_data, 3, 25, 3)\n",
    "p3254,a3254=evaluate_arima(model, test_original_data, 3, 25, 4)\n",
    "p3255,a3255=evaluate_arima(model, test_original_data, 3, 25, 5)\n",
    "p3256,a3256=evaluate_arima(model, test_original_data, 3, 25, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "d80bc419",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating road 3\n",
      "With input timestep 50 and output timestep 1, loss = 0.9437587627604926\n",
      "Evaluating road 3\n",
      "With input timestep 50 and output timestep 2, loss = 1.0317366279749736\n",
      "Evaluating road 3\n",
      "With input timestep 50 and output timestep 3, loss = 1.0844577616278053\n",
      "Evaluating road 3\n",
      "With input timestep 50 and output timestep 4, loss = 1.1194942652401156\n",
      "Evaluating road 3\n",
      "With input timestep 50 and output timestep 5, loss = 1.1368149144463995\n",
      "Evaluating road 3\n",
      "With input timestep 50 and output timestep 6, loss = 1.1469861150147016\n"
     ]
    }
   ],
   "source": [
    "p3501,a3501=evaluate_arima(model, test_original_data, 3, 50, 1)\n",
    "p3502,a3502=evaluate_arima(model, test_original_data, 3, 50, 2)\n",
    "p3503,a3503=evaluate_arima(model, test_original_data, 3, 50, 3)\n",
    "p3504,a3504=evaluate_arima(model, test_original_data, 3, 50, 4)\n",
    "p3505,a3505=evaluate_arima(model, test_original_data, 3, 50, 5)\n",
    "p3506,a3506=evaluate_arima(model, test_original_data, 3, 50, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55051b74",
   "metadata": {},
   "source": [
    "# Plot results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "5bf40acc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot5mnt(actual, arima_pred, STGCN_pred):\n",
    "    arima5mnt = [v[0] for v in arima_pred]\n",
    "    STGCN5mnt = [v[0] for v in STGCN_pred]\n",
    "    actual5mnt = [v[0] for v in actual]\n",
    "    plt.plot(actual5mnt,label=\"Actual\")\n",
    "    plt.plot(arima5mnt,label=\"Arima\")\n",
    "    plt.plot(STGCN5mnt,label=\"STGCN\")\n",
    "\n",
    "    plt.legend()\n",
    "    plt.xlabel(\"Timestep\")\n",
    "    plt.ylabel(\"Speedband\")\n",
    "    plt.title(\"5 minutes\")\n",
    "    plt.plot()\n",
    "\n",
    "def plot20mnt(actual, arima_pred, STGCN_pred):\n",
    "    arima5mnt = [v[3] for v in arima_pred]\n",
    "    STGCN5mnt = [v[3] for v in STGCN_pred]\n",
    "    actual5mnt = [v[3] for v in actual]\n",
    "    plt.plot(actual5mnt,label=\"Actual\")\n",
    "    plt.plot(arima5mnt,label=\"Arima\")\n",
    "    plt.plot(STGCN5mnt,label=\"STGCN\")\n",
    "\n",
    "    plt.legend()\n",
    "    plt.xlabel(\"Timestep\")\n",
    "    plt.ylabel(\"Speedband\")\n",
    "    plt.title(\"20 minutes\")\n",
    "    plt.plot()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "ed3f038b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot5mnt(a384,p384,predicted_denorm[:,road,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "fc3dd46d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEWCAYAAABsY4yMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAACVY0lEQVR4nO2dd5wdVdnHv2du2b6bTe+FhN5Cb6L0XgQsqCiggvgqxY6iEhUUxQKCSlNBUUTpXQQSeksgEEiBkN432WzfvWXmvH9Mb7fs7t29u8yPT9i5M2fmPHPmnOc852lHSCmJECFChAjDD8pgExAhQoQIEUqDiMFHiBAhwjBFxOAjRIgQYZgiYvARIkSIMEwRMfgIESJEGKaIGHyECBEiDFNEDD5ChBwQQnQIIXYYbDoiROgNIgYfoawhhKgQQvxZCLFaCNEuhHhTCHGip8zRQoilQoguIcRcIcS0/qpfSlkrpVzR1+cIIc4TQrzQHzRFiFAoIgYfodwRB9YCHwMagB8B/xZCTAcQQowG7jPOjwTmA3cPCqURIpQZIgYfoawhpeyUUs6RUq6SUmpSykeAlcB+RpEzgXellP+RUvYAc4C9hRC7BD1PCDFPCHGVEOIlQ/3ysBBilBDiH0KINiHE6+bkYZSXQohZxvHtQog/CCEeNVYTrwohZhrXphtl4566viyE2BW4CTjEqLPFuF4hhPi1EGKNEGKzEOImIUSVcW20EOIRIUSLEKJZCPG8ECIarxGKQtRhIgwpCCHGATsB7xqndgfeMq9LKTuBD4zzYTgb+DwwCZgJvAz8FX0FsAS4Mse9nwF+AjQCy4Gr89EspVwCXAS8bKh8RhiXfmm8y2xglkHPj41r3wLWAWOAccAPgCivSISiEDH4CEMGQogE8A/gDinlUuN0LdDqKdoK1OV41F+llB9IKVuBx4EPpJRPSSmzwH+AfXLce5+U8jWj7D/QmXPREEII4ALgG1LKZillO/Bz9MkHIANMAKZJKTNSyudllDgqQpGIGHyEIQFDPfF3IA183XGpA6j3FK8H2nM8brPjuDvgd22Oezc5jrvylM2FMUA1sMBQw7QATxjnAa5FXyE8KYRYIYS4vJf1RPgQI2LwEcoehrT7Z3RVxVlSyozj8rvA3o6yNehql3cZWHQaf6sd58Y7jr3S91b0yWR3KeUI41+DlLIWQErZLqX8lpRyB+BU4JtCiKNLRXyE4YmIwUcYCvgTsCtwqpSy23PtfmAPIcRZQohKdB322w4VzoBAStkErAfOEULEhBBfRJ9oTGwGJgshkkZ5DbgV+J0QYiyAEGKSEOJ44/gUIcQsY3JrA1TjX4QIBSNi8BHKGoZP+1fQdd2bDC+UDiHE58BirGehGzu3Awdh67EHGhcA3wG2oRt5X3JcewZ9VbFJCLHVOPc9dDXMK0KINuApYGfj2o7G7w50I/AfpZTzSv0CEYYXRGS3iRAhQoThiUiCjxAhQoRhiojBR4gQIcIwRcTgI0SIEGGYImLwESJEiDBMEc9fZOAwevRoOX369MEmI0KECBGGDBYsWLBVSjkm6FpZMfjp06czf/78wSYjQoQIEYYMhBCrw65FKpoIESJEGKaIGHyECBEiDFNEDD5ChAgRhikiBh8hQoQIwxQRg48QIUKEYYqSMnghxDeEEO8KId4RQtxlZPuLECFChAgDgJIxeCHEJOASYH8p5R5AjMHL8hchQoQIHzqUWkUTB6qMjYirgQ0lrs/Cv19fy9xlW6zf81c185cXVmJmz/zXa2tYuqmt6Oeu297lem5W1fj362tRNTsrZ3da5d4F6+iPTJ33v7mOrnS2T89o68lw2/MraO3O5C/sQDqr8ecXVrKptcc69876VhaubekTPf0JKSV/e3kVz7/fxJyH3uXfr68teZ1LN7Uxf1VzyespFE8t3syLy/UMxPcsWMfTSzbnLL+iqYO7XlvDTx9ezMZWb3r9oY3lWzr407wP6Exlefa9JtY2dxV1f1CfD8P2zjS3Pb+CjlTfxmcpUbJAJynleiHEr4E16DvXPCmlfNJbTghxIXAhwNSpU/ul7q50lu/e+zYAq645GYDz/vo6HaksR+4ylpE1SS6/bxEzRtcw99tHFPXsE657no5U1nru315ezU8fWUwqq/L5Q6YDcNWji/nHq2uY0FDJobNG9/o9Fqxu5ht3v8Un9tvGrz+5d/4bQnDvgnVc9egSVE3ylY/NzH+DgYVrW/jZI4t5d30rv/30bABOueEFwG7Xwcamth5+/KB786bTZk+kMhErWZ0nXPc8UD5t8OW/6cGB7111It/+j77/eC7ajvrNs9bxY4s28soPhs9GUVc/upi5y5qYNbaWC/42n0RM8P7VJxV8f1CfD8PtL63i+qffp74ywacOmNJHykuDUqpoGoHTgRnARKBGCHGOt5yU8hYp5f5Syv3HjAmMti0aTmnahDnLqppmXV+5tdNXLh+8s/X2rjQAzZ22dLy5LRVYtvi6VON5+aWJnM/p0elo6ylOgs+qGgAbC5BmBgtZ1f+tg77/hwHStytgfmzqY98qN2zv0vu4qul9NxPQP3KhmD7fYoz9vq6wS4lSqmiOAVZKKZuMPTTvAw4tYX0Whsvw7q/NWIQwn9cvjyt7fEhe0wff933vSWgpvcqqnPBh/fZhKCWDXwMcLISoNvaVPBpYUsL6LORiZFL2H+McKhAmh/+Q4MP2fUPxz0/Cnw4bbCoGBVEX0FEyBi+lfBW4B3gDWGTUdUup6nNXPiC1DDkU2yxDtRmHKt0lQap1sCkYWESc3YWSZpOUUl4JXFnKOgLrzTHEJREDKBTaEBgsQSQOAbIjlBhRF9AxLCNZ86lo+hOm8iNoUhnqnexDaqscsogmtoHFUGjuYcng82GoDYT+0qEX+95DQZcduForf7IjlBhDoOsOCIYlg8/1baXx30Cgv0ybfWW0vZ0fhsIgCVTRRBz+Q4+B6ANDwXVheDL4ocCZBgHFdvqhoIMPwhAlu8/oDVMbbg5WH9JPH4rhyeBzXRuCVta+qmiEKWsU+d5DQQdvkvjJ2DxG0O46FyE/hhl/t/BhneS9GJ4MPvq4LvReRTM0GnKmWM+1iVu4LvFHYOjQ3d/ozWsPtxiJD+mnD8XwZPC53CTlh1fCK/a9NQmjaeWuDcfDU3NKQVKfIaWkEj08fYxo0c8NIj1DDcOLves4SXmFvd740WCTURYYlgw+1wiXyP6d5UsoAfUXmZYrZ5EvLqXkxNir+o8XftdP1PQvgt7owyrF9ea1h5kAD8Afk79n2up7BpuMssCwZPAf0vHd79AkyCEk4w0dSiNEGBgMTwafLxdNCaaA4Sg1SiRamXeRyE3SRm9sD8Ox35oQaCV9/lBouvIevRGAvkumvc0mqQ1Ve8WQJLqfMZw5dw44J/ckxafxHW6tNiwZfD4Jbqj1/b6SK3o5RUgph4CKZviliOgXDLVOXgJUUNz+B8Wi3EcGDFcGPwi5aALr6t+q+ozivWgk2pDoxm58WHlbb157uDWV89v3hsEPt74zPBl8H6+XGwZLRSOHgJHV6fZaQRozGUWEwtpgOMcMJEsswQ8FDE8Gn6PT6m6SQysXzWDBF8lahszASdFMZSOXxO4vRzIHBK73LrARhnNTxUTxRtbhJhwMUwY/2BSUJ3qTi0aTji4iS+uV0B84K/bcMBuivcWHsxWcYz9WYi+aoYBhyeBzQd+yrwTP7f9H9ttDexuOLr06eE3tH4L6Ed5v2RupbdigFxL8cIYSuUkOTwaf08jaz3Xl4p1DoQPkgk8HL8uPwXsRQxvWeuX+xnBuKqUXI3C4tcfwZPBDnrWWBn32gy9HCd7zrRW0YTdIC4W7LT6kjeBAqSX4oYBhyeBzQcp+zkWTA+ViZO0tHZqUSGcXKUMJ3vsto0Ft4MM6yznQGx38cGu1Ycngo77dP9ADnRwoQwneC6W/k8kNWRTWCBWkIdNdYloGDs63niE2lbSuchHgcqFkDF4IsbMQYqHjX5sQ4rJS1edEzg0/+PCpcGw/+CKzSYI7F00ZMngp3QMthvah+74meuMm+W7FF+GaaaUhaJDxh+Tvi75nuNlv4qV6sJRyGTAbQAgRA9YD95eqPk/dOa6VrFL/qRJVVSx6raLRPF40ZaiiAXdSqQ+zDt6NwhohLjRQUyWmZeAw3Bh0XzFQKpqjgQ+klKsHorK8kazSeSz5zn/e4u7X1xRVx2srm/nhA4uKJ24A0ZnKct5fX2POw4uB4iYcTZP8/LGlnpPlx+C92XJ0Cb73+OUTS/nD3OV9JWtQ4Hzvz932qnX81TsX8N173kLTJJfc9Wbgvef99TU6U8Un5xos3PXaGu54aVXB5X/z5DIu/debeSeAXFe3daT4yt/n09YzdCJkB4rBnw3cFXRBCHGhEGK+EGJ+U1NTv1SW+xu6L0oJ/1mwju/dWxyz/tTNL3PnK8VNCr1FbzdlWLWtk3nLetemneksaVVzu5qVaaCT4pLg+ybB/WneB1z732V9JWnQ8eaa7dbx4+9s4t/z19GZzvLQWxsCy89b1sSa5q6BIq/P+P59i7jyoXcLLn/DM8t5cOEGujO9F1L+NO8D/vvuZu5+bW2vnzHQKDmDF0IkgdOA/wRdl1LeIqXcX0q5/5gxY/qp1sJn6cHK1DgQ6Mtq1bzV7ZVSfstfrw5eQUN0bwN16Eij/QWndCp6kWXzw6Dd6M93HArNNRAS/InAG1LKzQNQF2B/xJG0wYI7fNf6U0+Xy6BXbqy/mNc2hfUgRlFucE5CFSLL9D/vCY9+cxApGnwEfTfNl1wogg/DrIkGgsF/hhD1TKlgfqPfJ26Ahy+Bre/7rlm/+4nZBz2lr0/uqzeI99WKeZ5m3OxW0Qyh3v/OvYNNwYDD+XWChAtVkyTJ8MfEdcwU6wPuH0Lft5cY/m/oRkkZvBCiGjgWuK+U9YRhjGjVD9S063x/fuRy5nl9GbA2gy9/FU1wcFO5rZ8GDgeJJbxQcYnvvCbhM7FnOCn2Gk9XfGcQKCt/DLdJrmRukgBSyi5gVCnrCK638Gt9l7LLF753LUZFY/x1sckync0CWbkYljF8BeH7iX/SIPwGU01KEjm2sSvTz1sU8r1Df6pnh4IIMSxHQfgsLIn3bPO4Sfa1svIdFT51VBH3mhJ8XCnv/CZ6MoUAuobC6OtnmF0xzG6iahJ1eA75gvFhMzQPy6/t/0j6aD9DeYF9796fii1v9V9dOa4NNo/pi7Ri3hoX5a2DlxKECKJrsFt/8BCWg0XVJFliA0xN+WCy2IKyMTgOYLhiWDN4ryRzgKIH7ky55yS7bD9JpUG8r/zYYeEwJfjYEOCTgRJrb4MHhjDMvhzG4DUpUXMw+DKcv/sVL1RcRu0dx/bb84ZCcw1PBu9temOwd1Fpn+qnrIMDMSh6y6r8HkOF36sNFQmeMJXEh4/BmwhT0WgSl4qmv8bAcEIZdvE+YXgy+BDO5pRsTlFeCS47jNCnQCezzcpcBw8h0asfQgnebIbcErw95BO4ozqHgwfJcHiH/sSwZPB+6B99mZxinakRPf305HLuUL03s5qTg0tFU4azoZQyREXzIenaAfC6jR6uvA3ogU5ZaatojlTc+ugy/Ly9wmptLAALtR2sc0kKyx8zTJrAwrAcBX4JXu/wKZmwT/XTEr6Ug6Kvz+6Lm6Slgx8CXT44/8yHT4IPTi8Bf09ewydj81CldKV//m78bus4nsN9cihBOtRQrbLWOl8ogx9uGJ4M3ujq1hA3GLyTEZhpcPvMRAPOlYt2wEtbTMvAHafB+gV579WCJPgyZPahOvhy+QiDgKAJ79rELaieVAWjRJt1XEm6DL9u72D2h9AkdIvuCb13uKUbHpYM3gcjza0i+t+oFOg9UyZ9xEvHeau+AyufhYcvzXuvFqSDL5cXc0BPNhZJ8E7EQvq51CRdVFi/KxxS7SjRxuw/T4PFD5acvoFCLCwKe2P/uEkPhR42LBl8mJHVyQg0qb96n/O9lLHc45VGduw0JPcCSA70gy/Td40keB3mNwvbl1ZVM662qhJ2Co+dxDr94NlflYy+gYC+otPhnOgK7Q3l2cN7j+HJ4H0nDAk+QEXT/5X1H/qLRyXIcn3iRvtEAXndLS+aMneTJCyStRffd7gsz8Ny4stsT+i1uOlRU4abuhSLYBVN31fvQ7F3DE8G75XY052Au+PLftLB28/r/8/fX/aBQ5R3OT32kuNC/kFs6+CHqgRffNce6tl0bdtTyItkelzX3tWmWceWwFOm2zIWA/MdnSqaUqznhkJ3GZ4M3vhrzdr3nO/+jcPI2k91lSPMCeK82H/dFwqQ0uxskgEPLCPo2ST7R0WjleH79QahHmLZlGsMtFPtuGjcMwwkeBPOflHoTl+5usBQVPqVNJvkYMH8SJWmjrF7O+CWbPrLTTIXBrtDmBLdUbGFngv5B7Glgy/zQCfp+L8bvVHR9JGYQYBTrZSP/rGLb2essDfYjjsCnaxbh4UEr0NBI4aKzKaHxMY1pcCwlODN7lqNe7f4YBVNH42sOe7vry4lequMDyOgCAnelbmkTDlgX/dhNTHcJfiJi29lTuJv1u/9lfesY8s/Xhs66QvGsw0WP+Q6J6W0ks/F0Hgq+W3EVWOYJLYW+NTh0QdMDEsGb47TKtwbfTiXp0Mh0KmvCCWtICOr/tftcld+LxvqJmms2op91lCDK/W1529Rz7EOhg6Dv6fiJ/Dvz4d+uN2V1cxQ9J1CH6j4cZ/rG4LdY5gyeONvhXBHrwUGOvVTXeWIUIZVjAQ/2HqmAhAowafbi37OUJTg+22VaD1w6KhoJptSuRagauolhmAXyIlhyeBNrJOj9YP6SYDHD97o0jV/PYrfJf7Q6zrKOlVBWHcvyIvGNLL63STvTv4UXrqhb8T1E0Jz0fQCQ5HB9xes1e1QNLJq7jQLpdK3e2WdISD7DE8Gb47Td7QZ+u/dzwS8vrD654ltfpszYi/2W53lhtliuf9kISoa429QoNNBylJ48od9J66f0F8Dukw/YU64jaymybl41mO14RCS4C0MEIP3Yij0l2HK4PWmtxIM5chF0xfEyXLOexezn1jmOl8uQZRSwgSxzX+hACnNiiUo92yS9CODHzrq536HNTaGogS/6gXXz74Mv/Lr4X3D8GTwxl9zg2FZIgY/WTSxQ/t8fp24yV1/mfSSUOZXACcbKoFOoX7wvcBQVNG4vo7xozcTntWGQ3GWe+zbA1LN0OsdJWbwQogRQoh7hBBLhRBLhBCHlLI+E2ZHTwo3g+9vP/gyEdRDoeungy4UwOA109UswE2jzGB+1+9kLuzTc4Yigzexs1jDiOeuBCTJXqT+HdI6eCfCvKq8hcKuDN0uEIhSBzpdDzwhpfyEECIJrtC5ksE0Lh5k7MFq+vYWk4+iO62iKJCMKXn90AciaCpn/VKiahIhBAJQFJ2erBpigNSyqJoko2okYwpZTZKMu+d6865yluAzqoaqSRSDxq2ywV1AU5FCIa1qVMTzbzZdXm/nRkbViCvC1RellGRVnep/Jq+mbmE7I9ivV7nPh5IOPqu6x7F0jMCejPqhDWoKQskYvBCiHvgocB6AlDINHsf0EmD+qmY+e+ur7g0MAlQ0uTrBv+ev5bv36LvgXHD4DK44eTcAHn5rg6vcQHWkfNPHZXcv5NUVzYyqTdJYneTOLx+ElJIv/20+pyoBNEqNz9zyCq+tamZiQyVNHSne/PFx1FbY3WH+qmYAi3nq95XPwPn90+9z3VPvoUn4ZEynK+vdUPrVm/jaioN5bNEm3vjRsYysSbouf/s/b3HPAj2L4hn7TOL+N9cH1jX98kf56hEz+d4Ju/T/i4Rg+uWPcs7BU7nq43uSUTVm/+RJPrn/FOactrtV5rK7F/L8+7qrYB1dACTJ9lKCHzo6+JN+/7zr94aWbrLbOvmgqYMNrT2IipAbDTR3phkZcq2cs8P2BqVU0ewANAF/FUK8KYS4TQhR4y0khLhQCDFfCDG/qampz5X+991NgDvRkKWDF04GH461zV3W8ZOLN1vHd722JvQeZ7cYaCPrgws3sKmth3c3tPHCcn3Amzr0YAle5TWDgW9o7SGjStq63VJfPKZ3jdE1CcfZ8un8tz63wveOPgbfspbHFun9obnTHdUMWMwdCGXuJv4074M+UNs73PmK3t96MiqdaZXbX1rluv7gwg00d+oyU1LojLlKpKgUxUvwtoqm/Hc+Wr6lw3duc1uKddu7C7q/M9W73avKXSUbhFIy+DiwL/AnKeU+QCdwubeQlPIWKeX+Usr9x4wZ0+dKzSWsi7EZUonoRfpQp15WKZBz67dIZr77e2jfVNA9/Q2TbtMO4cIYvyTqZd2Be7KWKUwSnfuNAqDYv4dypshiaPdGbxeKsE1CyhFxRWHWWHs7PoFECNtulHdlnSu9SI5bh2IXKiWDXwesk1K+avy+B53hlxTC+utULQSpaMIhQ7QSYfw9SAe/j1jOrMV/gPu/kofiHHT0+k5noFLAwJ28f8HPce2KU0YqGifMd/RJ8IqtchrKBtRi8iVVkaJF+hbKeTGU9NaalMQ8g1HgnAjzMfj+mcyGgOxTOgYvpdwErBVC7GycOhpYXKr6LBit7kosZnzQeNgWXh5I1725qgq/6M1FP9CwJPAgBl9QoFOQNFSeTMAcaBkvg485NlkvT9ILQiG0a1JvhUqR5jWteFtBf7maDgQktiMB6N9fYvdOAbTEc2kDCnzXZ38F69/o61MGFaX2g78Y+IcQ4m1gNvDzEteHIEBFYzC0hMP4lKtD9wczsLLzDZJfcW4G7zekeaVEe/u38jSyOmFL8B6fgbrx1mHREvyj34I/HNxX0voFhdBuxnVUkeK4mH9T9T+MaODp6irr9z49N6FKm0kOJQavSUlcEWySjQC8oO6BlO4+/F7NfqH3yxwZM12tMPdquPXIvpI7qCgpg5dSLjT063tJKT8updxeyvoAlAAJ3nSTdDL4XNK3O3jEodbxLAuVEElfCOcOOQPD4L8Z/zdXxf9s/faqaLJAp0m/p4PPid9O/YtXBz5XFLjqKQdkvd25Zqx1WPTc9Ppt0LSk70T1AwrRwVu5legJvH5TYwOXjbOl2i4q2TV1O1ePuRbony3tBgJSSqSEmCJYpO0AwHr0nFNmnxdI1FysrZdjciioZLwYdpGsNg92BjXpH9TpH+zMJblVUajd6UqWbNMHdFAKVvseG7kGhcXg++B2VkyHuiT+AOfEn7brt/K56zT+YMwoDp4+Rb/o6eDnxZ+kfv6NBGEoSfCqV0XjeM/hroOXxlCeIrYU9MwsMdIkLLvFUNHBWytTRVCL7jUjkEgpXV5Vvr7gQFXH6hzPL0zw851fMQ+yJfcCLxrDj8EbbDFIgj9AWeYoJy3m91J1FSKW4u+L/w4UroMPVH+YVVoqmt4PnL4MOfNek/k9XuswvBURzDKUdPCmBN+ZGGWcsekd7l40psT63cS/C3iesMqbuvuhoqIxqayXHRwS00165ji0JfiAyd6BMZtfCL1mV1R4e4xqWwx/Ox3+96OC7xkoDD8Gb4x2rw5+V7GamcpG65TiYPDC+Jiqyficc4NLReOpyyjo9aKRUmfwXUIgByky0BRee21k9W5crp/sD9L6HeYk1iZr+Ez6Ch7bTVc7OOktxhPFqcrr645f/YG8wTciw0lTxzDXoWMHuE/9SGBxnbkL41jHUFHRmONxBHa+f8VoIeen0oCs7D17E0W0R0XK0Dxvfb/X9ZUKw4/BG38VD4MfI1o8JSUxo3ubc713MI9lO9XS9oLx+sHnkuAz8U4Omj6Ff8T9ATYDAVtF434nDQrMJqn/VYaQBC8RvKztTk+8zjpjohgJfjSt1nEZ8Pe8tIt4G9viCr8c2YgG/KeuhgzhXysh7O+vGUzQveIt32hWs19XKE6HCc1lZBVIkOTWw+dBMerRclZvDTsGjxXo5ECAxOpU0ZiNoBm/zc/1WuXXuDd7seMeN9x7vLol/UxClzD+G+9d1JyL1l5Yd8L84FUoWEUTb5jPbcIRvVsO3C4AwvpudhSEfqJ3EnxMlBeD0zSJQOMU5eVg5mswaU3AYzXV/HT0KG4Z0UAYm0o7AsJs10Ing+97ny0VrESCAR5xTh28hghVO2Xi+eMEipHgrVYslzzhDgw7Bm8PcXeqgiDm7JXANWMicDKDUQ5pzotcy1rT6CX7QRrqDV81b/G9oyjsgRKomngPD8ZypI8oE4ZvDXDjK1sSr4O+YiT4BPY3K4c3lBKOVRZwY/IG3TfbgTFsZzy6iiALdCh6v2uOKXQJSXsA09Ecw95sM1c/GQIMvgKPBI906eCldK9UnGivm5X3+cVJ5fY0WW4Ydgxe6Y0EH+IDbiHTA5rmm6AVn+TorgFAqoOT28PeU9XdyVWESwqsp5hALE/DlEnucK8txHbv7qUET3lJ8BJJGiNoa+0rrmuvV36N+yuuBEAVwqGugl/NXMOhpueUA5bnTLyVdyqeIYtXRVO+DD4oBYc5jr06+DAoBeTbOb7zId+5UPZt8feIwZccZhu7pOsA8U1gD2SzEVSD8flKXz3O2KJOf/hnRl/DZ8f8zKffNiEl7Bu0VV6RCNxVKQ+WVpwLd3/eFejkDGjRwMWY51dcFFJ3ASfLgMEfrSzgB4m7AKcE7/dgKkaCj7tWf4Mvw2sSejAyYQa44qnG51UpTIY0JfjaHX/Bmoo3mF9Z4VZJDAUdvCOh2kSxjXHv3YWUkkbaqBddOeVvkYPB66mHNc5puzXgms5Xkpk2zwWz7cqPwedMFyyEODPXdSnlff1LTt/h0cLqCNA5K0IL18EH9Y4FtyOm6M3xyJgWAI7aFrAdnoEvxR/nGcbrKpEBRKXIwJKH0E64BYDldVuZPd6W4nQVjd0eyaL0zeXH4E+OvWodi/pF1I5/hKw0AqZl7xh1uUnwLh/+AOnanNhUZ674XM/zMCJNiCEkwet/nWq042Pz4dX5JPc/iGsTNwMwLR3u0dLQ/j6oWYgFs79cLqM/jv+Nc59/Eg7f6Dhbvjr4fPngTzX+jgUOBZ4xfh8JzAPKj8EHSfAhjCguTBWNUczatDhQfPXNz9cn/xhKg/VM/cG9+vj5NhrJBZMnLKtvdp3XPCqa0PuD2qCcJHgzjsyxCI2NexQR6yElzbSxvZXgy00H79i4JYD5qp6/EKY2DIbG0FHRmGRWBGTNlFKjQegqx3g+NczKZ2HW0QHPyK1/PzX2sn6Q6Qq4Wn4MPqeKRkp5vpTyfPRm3U1KeZaU8ixg91z3DSasdMGuzaLDdPCmisa0wueQ4HMgqLhZvYaABbcX90DzuX1QDzgNTk7oXjSF+ME7jl1HbvfTQYPJ7xzqJ8t5xirjZPCFt6WLwZcBh9ecTCdIgjfeOyuEXc7RLPm+koa+orVPlC+DN79jndbuu6ZKYU34YV4wTeauX3eeGZoIMBebDmb+ZdBJQlCoDn66lNK5JtkM7FQCevoRuRmRroPXrGOwGXzw42T+fPAta3SDLJ6O0LS0AHr7F5Yfu6fv6Sqa4hizNdw3LAxM4jaYcPs667SpFld2eEOteRw2F5bMNJ6XJQ4sXBuLe5jvK5UVrI3rC3GnDt752bvybjk5dNwkTQZfq+nebVtlveOqtBl8SN98RdvV/rHFn2tIb+vge/0Jiq1qjVNDTIJ3YJ4Q4r9CiPOEEOcCjwJzS0hXr2GraNyMyDvzKmicH3vCONbhZPAV4x/gK+OcKUdl7nzwUoPr9oR7zndd0wDiefYQKwFsP3j3e6smrXngvKvbDAV75md5vZMGGkGqCNXcucshfu/+wsXwp8L2fI87PDQGYws378pNc6poPF5ZF0wYx9fH60nVtJAO2q5499vNo4NXy5nB639r1VY6ZKVtfEZvN2lJ8MHf7X5XdG9xDFmG/LJXTeXns1IQRVLKrwM3A3ujp/29RUp5cc6bBgm50gUDrEzEOX7yRFKxFJ+PP+W61xzMUkqSja/wkif0O4zBCySKmaFx2ePGsxzpzGJ9ZfDFSwZB/sJgSPBFekn0CDswpmwkeMtzJEiCN1NOmCu04uiso7Ct3wYKJoNviil5pWtrbnOca4v5N1SvGPuw67fb66x8Gbw5Rmu1NrbLOpeKThqbrK9MxHmlyv/N71UPZ4WcYJ/IMZ6LI2roq2iQUt4npfyG8e/+UhLVFwSlC3bmf/5nfR0bEnEa6l8HoEVRWG0scW0jawByfEQFyaeXXeoqatYoBf0gwRffgXQJXrK0xm2Maq+aHGIg8lZp19ntYfAHTJvM1aMaB7VjT5MbqKYHDcFbFUn2nDEVEdPTQjzUYWbGNJhBSArd0GcLex/ewXhFny1bQkf1Ro6aOpmnY7kn5yAVTatHgleB5KgX7eczdIysZtvUqK1sp9ZlZJdSV9GcNnkiPx+tj8D18RgrE4YKSyoegcDP4X3qqlC4jHzFvcQAoiAGL4Q4UwjxvhCiVQjRJoRoF0K05b9z4BGUbMwpwSWNHjI1tgGAUydP4Bej9T3Wg9wknQZGETLlK2hMb1/gusM0fEnoM4NvzG6BnuKaW5MQq3nPd76qez1sejtvcilnl005GLyCpEdR+Fd93aBK8I+Iy/hr8ldoKDxRU+261qbpG4+bH7K2SIncmVZ6MOBlF1JCV8V2AN6IO9s82LbkfYaXwWc93Xh5MsF/prxHqykdlTGDtwKdtBTdVLhdPqWK5lGTnDBlEqdNngjo2UZV5769Ie9ZfGbN8nWTLFSC/xVwmpSyQUpZL6Wsk9Jl3SgbBKtobO+PCqODpI2P0RKzP7gd6GTfu9eMqbqRSsuGLum86QCE8A7S3n148xnXrv1s0TvLSCkRSnhQTILCB/FZU0fSHbSZ+WAxeGNFdpCyFBWFqlAx27BDxLqLYtmDnTo3SAevGKoI1dnmATEMQT2tzcPg0x5GdGPjCJoqu3m+ylBJljWD1/8qqGRljCmiiesbG/j6uDEIKV32hW7Pe2oo7n171SBXS1m0isb+XEOXwW+WUpbH9jZ5EJYu2ETC+Bo3No7w3Wvr4N3n18bjhqE2GEE70ltRlQUaNfNiW3GRsZoEqSX8542/eSV4Txu8l/Q/a/AYvM2uvxx/PLCI0x20bacbuXRcrj06bYhYB+trWqzfg6Ki8fzWpEQx+lM2D4M3732wrtY6l/IwujAlj53hYfCN52EwJ78OMtw9Og1C5bYRDTxbXYWUqktls7Ai6bpXxaOiCWDwkM9NMuhc+apo8gU6mZgvhLgbeACw8t+WYySrCa8XTSbWw54zpua8J8xNcnM8xs6ZTGjgURCzdKloBmDAtMlq6oWtW5dIkH6mnBGCx2uqiffYw/yysaNZmkzyRI7n/6O+jr2btpWHBO/xJJme8Uuc71Qk2dvBnZ/3GMzDUDX1L/y3cgNXr4KKQRq33klFk7a7q+po/3jdIt+9QV/EVEGaWF4RvBnG0GDw+t8/1vXwbKXKSz2V9kVN5bk6Wx33lxG2kuHSsaPp6tlGpqXFLh+QJ0rXwRfw/u5Am4Bz5YFCGXw90AUc5zgnKctI1mBVQirpDozYOZVmY8zd0eVWXWftHdebDCNsqATv6RBS2s/oFYNXs/DsNcRHfrrgW9bKMewuVlu/Nc0dsGPik5N0LwKRWQRtByOBpz06bJ1udyusSZhtUAYM3hOlKALE7HZFYV26lbpdf+8smffRSlLPnqnqOQkHx03S65AnbfvPPTUVXGmcj1Wu992rFsBkvjUhj3a1jBm8qYPfoug0bo7bLEzVstw72rZVvZe0JfhnaqqhZiuy7p9gNlsvJPhAWCkoh66b5PkB/76Y7z4hxCohxCIhxEIhxPy+k5sf5sfxSvCK5p7LllUkOW7qJNc52d0CasYnQXUoAdGxwN11tUaYd5CKxnhmLwKLWPIgPHctO731q/xlQ6BJSWUO46KI6xOeV08ZhnpD7x3b8Zf2yWXB6pGSw5C8zCRqQUxNA97s2tDrKvKx9Qtij8CcBiuwrT/h86IBSwfvhNYz2XfuzcrcBv2fj2wMvTYUJHhTB789ph/8zLE60aR7Jec1LgOIZCtHTplEjwhP2dF7lcsQleCFEJXAl9BTFFhrokKYPHCklHJr78grHqYjgFfSlAF6ci9UAXRsxju8TX26V1K8avRI4lJyRLvHpCpsBq9nb+ydX20821HwLd6uJSVUKj2EOURq456GlsMCBwFAWnMzLlOPK+KOSePJH8GBFxRMY7/BYPAaCjHUwAV1RgjWp1uLf7Y1aQASZEgSm6/EH9EPUm2QqAws01/QN/zwMw9F+FVTj9Tm3sziroa60GtWDWWWTdJ0fogpMUsHv13RlSlOZKRboAlbzWyNx2hRFMYHbXwjC2TwLle7oa+D/zuwFDge+CnwOaBsjK4ZVeOF97dSkVBYvFFfopkfSUOhO5UuiMFLBGRTvu9leZ5I/5JuzphRvNDunr82tfZYUYVOFY2Ukpc+2MbUkdUsb+pgv2mN1FfaenIpJc8s3ULFihY+AmTSwUvI1ds6WbapncaapCP/vZvo11Y1U0UqlMED1O38Uy7vGWX97mnfTDY5ihtf+yf/2nKtq6zX8wKAbDfvbW7X32dLB7tPrC8oQdprK5vZZUIdyza1M76+kikj/Sqi9S3dLFrXyiEzR9HU3sPyLR2kshoVcYXY6hc4FntDB9VRpZZpQEm0cvOIBpZse831zHeTcbo2vc4B4w+gJ5Pb1BikosmqGi9+oGcQtbw1cgxuTZO8sFzvGx+ZNZpXVm5jxugaJjQUZg8AWNvcxfKmDpcE39KV5pUVzT4GX0GSVEASrmKRzmZJ5i+WFz0ZlTXNXew0LnxSWbm1k81tPXSmsuwxqYFx9fZkuXxLO2ubu7nkVT0p2K/2fZL2lP7OXsMxwKb2ViiwaSWwrrkD7xrovc3tPi+qtp6Ma5zaT9BhR7LqNPVkVJ57rwlNSmaNrWXWWP39l25qY2NLD5qU7D9tJO9ubOXgGaN4ecU2UlmVo3YZVxjxRaBQBj9LSvlJIcTpUso7hBD/BP5bwH0SeFIIIYGbpZS3eAsIIS4ELgSYOjW3ETQMc5du4cK/L3CdMxs9KwWbW7uRifwMXoNAFY15Z01AgiOABuFmo1vae9AM9b6VxgBYtrmdz91mp7c979DpzDnNztv27oY2vnTHfI5T1vGRJGzauDbQ4HPJXW/y1jqvdOom+mePLGbnuvzqgzcq7QH19QfPYucxt3HHB/fj3dUsJYLlmuN+9xz1lXHaerL87ON78PmDp+Wsb21zF5+6+WUO33E0z7+/lTF1Fbx+xTG+cpff+zbPv7+Viz42kyfe2ciqbXYbr6q8EA24dUQ9n2lrN5ixDqnprGlJhZ9FnT1pAvz3i7z2udd45C33pLyzWEMcDdOKYbF/h7ri+fe3cv7teoCczeDD+9Wba1v4wl/0SeZXZ+3Fd+99m13G1/HEZR8NvQfcc8bpf3gRRcAOjoXWKTe8wLrt3dQ0um0RfWXuZrUvLW/iiJ379CgAfnDfIu57cz0LfngMo2qDVUcnXPccqazehh/baQx3fPFA69oxv30OgDojfcz//etZpBo+WWxqayuYwWcF/PaJJXx153ZrAmrryXDbCysZ7Sn72yffc41TwPWRbCFA7xPf/PdCHlu0CYAdRtfwzLePMN71eeueMXUVNLWnuOrje/DDB94BYNU1JxdGfBEo1Cpg9qQWIcQeQAMwvYD7DpNS7gucCHxNCOHr2VLKW6SU+0sp9x8zpjBXNi+6A6SxPSbWGoTHaItJdhrvlxK90MP4s2Skm2GbDGREtqmg3eenNFa7maHBBLrSbjo3t7kZsPkepq/ugcqywM0nOtP+9/VKHVPFZr5wQHHt+araSnNnGgL0vWkhfCbb7YZ6p61Hl6qWbcofjGW2wfPv6wy2qT14U/Juo1x3OmvdM1Os56Jpul79papKbmwcwc9HjXRJ8EGeQ160plp9Evx/Ky7n0YofYEnw5grMEQXt/H4y4CjsHQC2durvuXRTsJDghHPV0NyZJhFT7BwEQNN2fXJXlN77q2e7pvvPCUgJeKz9edIhBshi8OpKPVV1Zypc5WMyd4DtXYXVOW1UsBdQIlF4e6jo+Xe2tNn9z/xeXlHGOU6DxJzJ2193/X5lhZ2iO4g3gd3vtxh/rzhp18ByfUWhDP4WIUQj8CPgIWAx8Mvct4CUcoPxdwtwP3Bg7jt6h6BV8ogqfaDf2VjJF6fHSFX4PQ680AA2vEGHtsl1/ubGBrqEoE7dztdiD+SnB3itSpeMndkbvXR6V5nmdWcwhuJi8OF1ejve8crr1IV0+AnZfAPB3y1SQpD1EDzXm6unACNToV4pTi8k8/jpiu9w+eZvu8q9XlnBXfUOqS7A99+L1lSrLXPF20g0vmilq7AeYxHiaH8H7Za/dQ4J3lW+iIT0vn6C23VvtGjRD8Y+nfM5Y1rDV8TpLcf5zr1WWcn+06fyeOoF7nu/7w5yVkxKgbbHvKpsQyU3flQw05QiWFgIwrpEHEW4t+EU1l+/TS2gNuto100PGgXNRGc2kloqtyHeeOmdxoevTPqCQr1obpNSbpdSPiul3EFKOVZKeXOue4QQNUKIOvMY3cXynb6THEBfENMwTj1VrUvu/5Nv5X2OhoCHLqZb89uEz5w0geviNzElsTL/c6TkjgbdFS0lBE4dfC6Y150M3unqaLqIBeU29/ZBBclP1z4YWM8INU+Qk+ZXb6SF8EWDJnthXNLyL4D0co539bZbWsasurfE46xOOOwYhTJ4CUrlGmp3/DmV4x/mzElmEiojoMhSsdsEO3m0dZjDIOksny2GwQc8x9nHx+HeSeyxtes5dvIRvucIGT68peZXmfzX4S6bWLfAd73UyDv5CzPSPDguWS2CwX91/FjS8bB88B4GHyS4BPX9gJngxuyV8JtwfZcVmVsiB5xCc9GMEkLcIIR4QwixQAhxnRBiVJ7bxgEvCCHeAl4DHpVS5oql6TXMtv5i7HGWV5xjnNQ7Q5AxJvQ5wF8b6mjTVvmurTf8wLcEWC3+Xl/HnjOm0ikEjN/TNbCbYzGLwXvHeJjEm3Xky3D62Jv3B/YtT6esEj2kZLCkHraXrA0/Fw6S4CukdEmWhUjnhW68Yb6rJv3tlhSqFZHsg8xvVtrYqW9tUDPD3pErbY4w47G2UdmhjHFuIGJJ8LkYvF1eLUqC93hxSelS0fyz8ipEwlYDTMmq/Gh/98oG3Ay+e93nrOOYlEjV723jtGWM2Nx3HwqZo7/mKh+GZKNhvzKMyzt3jXBd14q0QWRiPYF5p3xqmBwS/Fi2+wo6h8me8j3oaQmlwdy7oJDVb29QqIrmX8AW4CzgE8BW4O5cN0gpV0gp9zb+7S6lvLpvpObHjxN/Jy40l1oj0PsjBKuSCX47spEV2QeRarAfwdMj/TrUOw0VwdZYDJJ1SCk5oFtflu2eSjkYfB4J3vjrTIoQK1iCl9xXW8ONIxoAWN6wyVfGhHcTEN+zAkLgOxWFj05z+xxUSFn05hh2GuM0ufTXVmZPKQPfN2xLOhmig79ucxN3r9cZ+w9f/CFrOt8OLGe6gf5ilO5f7dTBB36/HBK87C2D9/xWZZYlExZav29tqKd2lh4j8ZEund4qr1UcUBD8YGszEzNZtMwI6/y+GY0grpV2iJFJpVD/i/5D8PCwTyZH6UbXNHowWo/ibvuUUlxCvrCcQ97zwnVsXGtZC8DRsTdCnz+O5tBrJqyNeQZTggdGSil/JqVcafy7ChhRGpKKh7djJMiiGJKVc9PrBrVw/16RaQg8v7zGr0/bYKYjNYy0UsLOhotjnaaF6uDD81HbcEnbRprfMAn+yjGjuLmxAQ1YUh8eelCXT09SgEspYIR1O93FCtPBTxZNLKs8j0/F5oWXc0h/QfprNawqGWyAO7qrm6mOlAbre3JLqK8aNhTn8sHZ7lYe8pwM3jpCyXaRP3zKX089nTSILa7rtzTafdPczCMZD/DFlwqfae/gvzWzcQ71jKHVzwVvVsbeoGgdfMA5pcIvqHyg6CuvmEcFtab+lWLIQ/HQFq6DtwtZHnN/PwNwq1OdawCAg5X8O4iZQkBf9l/OhUK/4lwhxNlCCMX49yn0XZ3KAt6OcWX8Dqq0TpYnEqQdHfnPG7dQMLTig1cyCNCyaFLaO90jrBHrXXoHBSeBW4I4SLEZUfL243XSjILfjP+bp5PfQhHwroPcNfE4NVp4hzm1I1j3aBOmuXTZQVGU4NkDtEBoEmYK3RPmZOXVHOX05x7S9G/mcgHerxxmJpYB3+32DXp+9wpH+4uCGZhDLeNazpsMPtxgbZb/auxhvj3/SG5PFBiZ7Kjn1YqvcZ96aWhRM8paCZC4NedKzPEN28kGeko5cU16TWG09iOCbFQ1O1zv+l09w/69T/sEb3Efzm4L91qKe1NCGH+9vDawpdLtjEytc59Ldbju30qwkOiEubIbFAnekff9K8A/0RONpdBVNt8oDUnFw9sxPhufC1ozZ0yewLa4PcPWSo2xeT1IdHhTGxSCrCHBa9KWMFWHF02hq3Th0LeeE3uKzbEY/6uuQtnyLqBPBJfF7+GS+APMVDYSUwQ/mGSrlN6pSDLSm/Tbgcq8SlHV8kaJS8mBW/0h8aBHizoZfCl08KdvuoFRtFLj2bQjLEpRqn5H6P1SuvHN9UXzMDjHAx00OXXwhTB4vfwnY/MAOCKW39DvRZVIh2Z/BIfeXLH7+ant+gTe2DHRUdIe6julM+ST4NfJwg2WYShWB18IYpX21tAJ8hvU90iF6+WF1EICUr0SvH3s3EHqvPcvcatzUm4VkVaA/Gwa3wdFgjfzvht/FSllwvinlFM++KD+0yH8S7uJWZVH120k3jXRdX586xRfWUULXurngioEbHobNDvnn3MP1Pw6eNPgYpdbLcdyxqQJfHPcGF3bnU2hScllcduNLeFRqaxKJGiL24xHTbn94UMNlCaEhpR2gjUR0hYZ/MvZfHBOxmF6dG85gNHCHdiVNe79+wb9O584/UQOmnAQmebDSK8/K/CZLl1qgAS/1bO1XbsQLu5UrJHVLJ8MSCmQC2Y/uC6h70yVK4GYpapyvM8XW9v4xHuH0dA1wSQEHOqMOVubkTk8bIYKwtrlB1ttRjs+m+XjzXHGVvpdRr1pvoP2MZ6v7eQqoziEr6TW7e7/k/Z1lXUl+/OoRc9UnuMAsdSuc5Ak+H1z/SsNSb1AAI9J4VdDCHTp1Stp7rRpP85od+d9iYXocnMhY7CQnbPvWZKVU4L3qeB9jvAmnXbJEaKTdoPxpISAt+5ySR2r43HqFHcOjpsbG3i/OsMMpYpF21S6Vl7iuh7Pa2TVMAOGFCkRnrb44VbdeKSraBz3FaCDL3QV452DxtLCHYa30qJkkmsb9FVFpZQsWrmGX33sV9x23G1ItZZsW/6uKQK6/t/q60n22MmrDp0+hbZUG5Wk+EviV1R3rg14ofw6+GI2V3He9/HYS3oVOcpaEryDwc/KZKh2JRZ2b4RRPftzDERirGKF0mIl/bQIvuHjHbbUrgCnbk/wrd3+SKZ1bzd9aB7p3C9g6b+DoYq4W4KvHOEoL10OEtKTAfW3yZv4T8VP6VE7ide+O2g6+N8Y//4AvArcAtxqHP8+x30DiiDVQEP2g/DyiruxJX6fbi3hlhgLwTtGePwFPX+2NAC5JPiwT+rsYFV2+n2dwceS1nM+SMQ5ZcpElBHPBj6nU2b17QI90lqiADdJaaioFPwS/D49Ok1Z0RsJvrBy3raqT2zk16MaAbi7vpY1VYbaRcLLR9/jrqOgicbPmKdmM1SmRrjObU9t5wjlLY6KLeTw+fY+85YEX4AffLJYBu/5nUPbpqNxho+bVgiPasLZB07/A4WY3/LFbRSKQtVyY7TNeobOxWbgkD5Od9m6A4d3+TOjTkqPJN18CJc2t7jOO2uLSb0/JGOVZDt3dJXbQVnP+GV/t+8zbkzXLbPcnhW0UOariZin/5sSmqRu1++zYGfb0VDL2jzn4pi++k4JWNh1E1VT/s6aDv/2mv2BfCqaI6WURwKrgX2NlAL7AfsAxW0xNIDoEYINsXAXJS+D11DY7MkNH+QqmA+/HtXIpliM3dWl1ty9pCLJiqxu6PEZWYMFeJdU0B23dc89QkBFneW6Z3pQpOuC48dUKSFeifczx/KNN6FaEnwMXRZxwkwdnKE3RtZCdfB6OVPXXZG0N8J+VdjL7RiStpF7uu8tgMG/3vIf3zlFGqsXB3pUm7GM6LCFhpdq4J1ksiAdfMqhKy5kMwmfH7zjfaZ70lR8Xa2GSxcCMCV1MSes1qVU16QidX8ndyX52yit9TG3jfEahXzzBjqYrq7Wfyy4AwAR01fhR2nLOdnjGHBKRycKcVKbT+f0DvfqWzr6ewx9Cz4h8MVIHBRbzMzX5/jo7R6lpx5Ym4j7/I2yQLMx7jQRoz3ZzuNmgJjlEeP3tNMcm4t8K6ELJOePH8dGVc+ivrVno++e/kChirhdpJTW9jFSyneA2SWhqBcwP8xWwyxwxeiRPFEbbiQNkuC/4LG2F9ow57S6DStbYzFeiB/kYnuXd+gM2FTDVdHDccrr1GRbAp/pZJr3j/JK8BWWn3+Hmeo3RMebRTM2/HYPZq+f77mtbeyWSlElje4sNEuNo0jpMxZVGysSr4qmEHgHe5KM5VPshCVNCd0rptbh42wGnYFuBPbT0DsJ/soxo3wMuD3dHjiJ/Xp8jM9MGl9QoNPjqp2hYzSt0JY7T72zNhVbgt8pleYXG1Lct85mBqdW2J4ktXJPalL6KieB6ljJ2Dr4uDDbLn8b9WT7J9d9PrXcvuI93qq8kP2yC/UTaZ2Zi7jOuCdrncQ9/SYLSGMz+FpPBZpDcopJuCV7iv7Dw+BVTxtYKhqjrbIIX3/45ahGPjZtMl1CoIk4c6e/ynfHmunJ9PtlwHi0GbxN6yJH7n5veu7+QqF8bIkQ4jYhxBFCiI8JIW6ljNIFm032vKZLcvk2PVC6dKPqSR2dHN40Dolgvx6318DUbTvxh01bOLr+AHo2fhyAXVJpDtk2hhdWr+XTbe2My2Z9HimrEnEqZMplAEpYWjkddyWv5pbk77h4zWXu97B08DacgUQ9RtoDM3z+q+PH6u8TIkVnpYS426tk/MozfTp4IWFxRQXdQtKhrkegcZB433i2X0WQMO7XVTS9C3Qy8ZvEn+C6PXzbp5nFMor+LauFLcHFKmx31993n5+zvsu3Ba/kMjKF1JKkmw9xX/Cs3FKqf+BNdvqlF7BBtTPw7p7kT+C3uRNLmW30ZHUVs2dM5Q9G8NqFLa00qIIdM462itt9XQD/Uo9k/Q6f5PfZMzyqKv04ETO8rQqQ4NUck1chUJMrqJp6M9e+eUXOcvsqel/bPWv4jWf1VZOI6T7nU7ROX9rbj3Z3W776VVLyxkqnW6f9bgqSp7T90O3l7qd8b6w7GN8WPvT7s0K/36miecbIv9SuKGiela2loQlIAifW6D76n4wFq1NTaq7E3r1HoQz+fOBd4FLgMvRkY7lH1gBiVPNC3qn4IqNppVsImuK5XRyTG07m4bUb+GXTNvZtGY30mNz2if2YE7tb+Gh3D+dP/TJqSpeSMgKOaG6gQZP8cNt2nlq7wRcVevWY0SRl2sX2Yp4I1NmKvtSfkF7lutf2onFuEm4fpxQBUvXrRkPUSQlwMQCAeGqcb0JwBg11qFtA2EoBBVvS2SWV5oLle1jSVLYXAdZe0o9XjEx8WfcEa7ZVndqiv4viZ7Tp5kP4j3pU4PR2zObxXLtlK59rC9s0RSLVSlKbT6Z73Wess6pndReUVXGKaHIQml+CdxpZpynG5JAj2EwiUSo28i1jo/AnjU08YtjqmofWbeDhtRsMFZwORQh6qGDZgVfTSq3jgbaKJqmY/SH/0Ff7uPFH56jrides5KVNz+QsV2HklrG+Y8Zg8Ire9pVS+iT4Uzu6XKpDp8OkU6X1i4yeokEgwOP6vNnDJyz2bkjwZsZJpyrVFG5ubGxAFV4+Y4kl1pku82ZjlTpbfEBKwB3OBHlA92AyeCllD3ATcLmU8gwp5e+Mc2WBnVbcSpXo4UBlKd+xlktu/KHVHghNcizTDX94PZuK/hFeXL2WbzRvp05OpdPYuCrVuDNaj87gv9DaTqXXeOXBUUo9CTKBDN7LmDMiOB2CS4J3MO+UEJBqB6nxqYnjrfM9AUmTDu7M8o10BSTcEryK4tPBu3XWCgiVMVmVYzu7uG5zE7UpXYK8oKWVBpmxpCmvH3wh0KR03WPl2vEwUk1KdnXsMbutImAAhHhRAOzRNooTOvMNGgWIo3bNss6017iD4TJamp54J3vOmMpThvTmNHznZPDGq1WKgORYmRy0SRABE1oMuEXV1Q0zMlm9Dzsl+BCbjg6dzqQpwQdMzVc3beP3m+3Jq68SfKEwDcLWimPre/pYMVQdFdJrBdLhjbY9rqOT07sbcb7bi6rtOROWxsK+bgpYtgec4lkHmS7GD9TVojkY/KOORG0ybq8a/2okHdSqdO8sFYWbRjRYDgMmurN5gg97iUKTjZ0GLASeMH7PFkI8VBKKioWmcV7FB3xi0nhiaLxQ5Y9kfGjdBj7a7LZSL9R2AEwGrzdDvSb5Yms7Qug+rBkZQ1EEyCQ3jvwOZ3Z0ugc38IRDvwp6p0vKjFsPiCnBu+lKyLRLkrMjWUMkeCHg/q8AMnBDCyeu2dzBmZ3dluvWN5q38+1t23UG7ymrCvh5k57aICt7QKhUSMlvt2xln1SaHdJZFqxcw3Fd3Zwb/x8CXffdGy8aJ4OfKTYQM5m0V4LXoNoR3PS/xgAmabRT0CrCa2jNBOxtoyRaAJAedUWjI6VFSk3TWal7VD1oSNIVDgltW6oloHaDBuOD1ge47NKy2n/OBf9bxaTkUfUg9u5x7JvjkOCt1AD+GGkrudjndza3WPQ//7SOTstDCiBbgPqpP1BptadNk77o0M9XBEjw4A8k+k3TNj7fXUfWwXil6eIrADV3dLo1Pl06+PD+rQp7JF0+drQ1gLtH2Yl2M8YrSdWcxOA2Q+XmxEubnuo3ryUnClXRXImey70FQEq5kMI2/Cg5Mqhsi8dYnkwSF1pg8MPIgPS4qsHmtIBPqEiNGBoqis7gAS2mS0pVnox1a5pPcf1uQ5LEraKJWxJ8wAvcf6HvlPkGWamQcDzJ8vQJ6Qj/t3Iaje9dwl1bR+rGy55WqNQ70xdb2zm3rd3Yx9R9/1GdXcw2BnZG9qDEO6hy1JEl5tvCLSFlr1U0ZgDIFMWh6ggw6JkBQsHJYcmZM8fL4HtybEL38diLrt/HOCT/tJq2l+xG33Iy+Eve/zthMFuwXgRI6386NM99/m+soAskTq8ctw7e+zUcv2WS9iXXcPKM010l1J7xXLN5Gw+s8xt++1OCz8W8KrCZnwlNSkuXXaEVJsGDHnyUFhWo3bqdTWZsSTkojYXreZaRVW+3b48dbXvgGNjsiIzPKl5bX9AkZNxs+MFXhPTmpp5NJfGFL5TBZ6WUxTuGDwAUxyusSPiltOySH9HgkJI3Sn2pZCcJEi63KoBKtZMEKhni1p6nWUOd4lXRONOujuhuIC0gITOu8HIzB4rZgVZotnqFRba7nm3i0Y/SJFxMbM4Y3SgkZXAniUuF9XISLdW763Sm2iwGb0JDWCqaCk0PEjqkJ2XpFjepujFopSPHetAuVjFsI5SJ09b+ClY+7yvrql9KVwpkCwEqGlPybXNsDD6p0vZlziVdeb9p2mCKc1ev85U9Vrzp+v1ila3Wymhpa8Cb3zTpULmsS20Pp8G0I9BFm+KX2sLvCzacdygKPSStd9GJsXXtFn/wCfCOZzmuda78Gl2rL+SEzi5mGonYFqh27nKTwX/3ue/y50V/Lpj+IGTbwjfcsXXwNnGaR4JPBeSvD0oFUKF1kRZJuteex7nTrgdjnAtAZvWxmmm3jdz3OTYpN9nEDMOI3h5T0LNK2XQd65j830x6+nHAJPZMdTXzKyvA8IPfIINVyKVCoQz+HSHEZ4GYEGJHIcQNwEslpKtgxBw5OE6fPNF3XXMMhtbYSE5O/Rywc65L/PPup5t+TwxVl+CNb5tVDAbvUdE4O5kiY6SF7vonHbPxWM3N4FN5tjRWLAYfD0x3LMMCZ7Q4UkqyIkHCZEeV/owSpgTv/PhmoNc27S0A3k8mHOX9DLlDUbizod5isnV0ccC2B+HOM3O+m5TBzwsystaLLhZUVNDpYPCfnjIHaQReZbtmhNcTcn50gHHT28JtjpQFGTVtDfCXDB18mBTmhbnkT8W7ubWhoWBllkSiBGSgaRExUiTcjK3BTrPhlQCDHEgVRxmtZwpo1a7nPZw5kuO1aYBuZO3KdPH4yse57o3r2Ny52fe8QvHA3O+HXltW18JXx43hs1PtVZwuweuTfoWU/DNzonXtLxt1Oky610vbGyapdpMRFUi1hvGVM63zetvEaV/yC3rWncvZLboh98oxoyzGLA2F7QRHjvfVFe7I9xGO/vPLuhbPm+jlYim73tXJOOdPGIfM6u9SI/wBW2OyWf740X+HtE7fUCiDvxjYHT3R2D+BVnRvmrLAN5qDpahLmltcnfzGCT+nGZ3hqcarO3XwJkZmNxsSfMwnwXtVNBqCz7W2c0RnF4pUSANJ3AmiqlV3uuAGEezZYS9jzYkg4WIlNZqpc9bPzmh1rAQAIfX8eC7jbaVfcjQl+CDjkQln5kVvzg4P1QCMj63jH/W1yJqxOcqaEnzA0n/zO55y0Fy3gvMmjuO3jfqq6/tbOqirGEnHsqvpeO8Ksq37hdYzVbiZUWCd5jUP593VkaAqo2VcG2coaCScfUBK1ravZc879uTF9W5VjzmhXzKpkttHwJZYkKLBDykh5lglXNW0jbNbUhzZEZDHvcFOBGddMd7H7OM4Mk0qgQKDGzsYDFNV0yzcstA6/9qm1wqiPwirwoQSkeGe8c28UF3lSwGtVG6gKhujS1ZTlW7gsK5ubt60hQMMdaI5bg9L3cDCffXtJhJaD2mj/we9q9lKM1N2n/5gux6zKSV8XHnRZa2JSekSzJ2+84oveExaV9TuSe5Lxgq1IiBn/d6pNJNq/fmw+gOFetF0SSmvAI6QUh4gpfxhOXnRHNJtk3LOZnt5fUFrm0sX63RXM1U0QRJ8TGYNCd7B4BVdoq30MHiJ4PLm7dywZStCU1ildqKKLBLYqydFlaZZS12JZBStTBTBvtl29zAkeJlgpENi2DFtDnr9eQ09blcrjThSQlY4l/DujSAE0pbgHT036WmFL7fYHTFIRbOnZYzT72ub8BTXjBrJ0p7N8Ea4XlqTniRMJh74KqhZljYv5b7370MjxWsTdMP407W67rRepokbSyqp1pErWGcvsdL1u93pNuhANT0cFVvoOvcjh++8Hs3pbKeMbt8wIJEsatJjAO9ffr/rOVLCBGUd2+P6MDtmqnvQh0ECMUewzOkdnVyxfTPjgoy1DfYz7U2pdHpf0nane7+vwGm/95Vx12ezAYEEw0ipZnv4ylNfsa5t6gzfRCYfdqkM3gBeKO6V22M11aSEPjnGq1YxUevWM4lKhZs2N3GoY6xrDiOnqY9Pal2kha7Ocb6r97Wd6bQ//rC+6tSkZITosLzeABZWu+90TkI+Bm9Vpvq2RHynZyMoXfxmpt+43qiqJLqafOf7A4V60RwqhFiMEdwkhNhbCPHHPLcNGGodTHBU2t2wquMVV1fa+kWbwfsl+JjMkhAqWWLEjF6SNdQq1SJcRZOJZeiQWW5urKZT0T9/HNufWNNsH+p3zWVwhV/CtnXwcWuD7IO7u9kQjxmGVn2S8e65ab6TS4KfcrCrjERYvvvOuxOeWe7jjtDwOBpLtSnB1w1PFC3eZdQt4KGv+97Jql9Ka0WwoKKCPWdM5S3TI+j53/DJhz/JlS9dSXq8f0/3blllfY98SDvksBtGfI832CWw3G5ilc+AV+cwyi9b8xSVjm+eJENCsSf5VrWHCsPQmfKomaSUjKh37/hz0bgxrAywFXnvEwHRkM0yYJKqsFVwporGHA4aCt1HXQV1431lXPU5jp0MPusxfG/u6r2KJhtgsJVSguIWmL43djTXjmykracNEe/ihI5umhgRqN5yjj1zkkqo3XkkeB3VHpnl/e3vo0nd28rZH/42yp013vkW3oR19juqvqjZq7e/gpII3nHq3NZ2Gt66NZTWvqBQFc3vgONB3+1XSvkW8NGSUNQL1Ll23XH7urr0kA73KSeD90JBJWa6SRqXzYhKrwTvXCG0V+jpDu6vq2V5MsH0TEY3Rhp7o2pSWkbaHyqncMHEvZg9sYHF2xabxBr16wcbKzv5o+FSNULV2BKPG1KgLkH6Gbz+2+USWD3SVWa1HMcd6nFGPc53DscKOYGz0nM4JXWVdW6WuZpINnNm8jHUysIkEM2hg3+0VvcdPsf06Z/3c7tg3K92e1vdKeegdcLZBgtqPuKa6J3ooNrXA5yrmdfpoGrEy45raZY5tkPUkFTG9BVGt+rWr2oSiLtTYLxYXcXT1dXkgpSgxHQ13tkbbJXX4+pB/sKOOAfzPXLp+oOaT3NJ8KAq+jPTPbpfxddmf42dGnfy6eC7Ml0+qT6jZWju8a9QU4sf8Ncr7WAmJz5IJGgx3E/rswpPqAcEGlRdDN6Q5uMyY0nwrqHvee8xnvnzzIfO5K1tr5Ii4ZLgATRNsqZNj5TVcvS/tOFWKoWKN8FfRmYDYxtu37CZadksmuHO3N8oOCm0lNKbMGRgoiAKwIJdf2L/0LwGzOAPYuvgQZNeCV4lbqhoTIknY0wOuRi8ibQQdCgKY1WVGALVsWVfBSm6hGD59Id5paIFgCdXPcmlz1zKI2v/bFAsUYGvThpByjAwPldtD2QlqVv5FU8aX9X4nXF6WcT87XFD9gyAQN/iINyjfpROqnhf2vreUYaveM/Ue/jfzOd0yR34XwjzklJy+fOX837bgkAVTWcBjFuT8YLzZmdwLt8TbJe2Omvup+YaNAliAV8w6WmW5+rsyeKj8Td5fZTN1MbFayyViFeC16RECQiMu6+uhodrw5l8e7oVdeJjAHR07GXFbAS6ejoZvKmicXxX77sVooPPKvpK4cGV+qZtyViS6fXTeXfbu65nH/WfozjjwTOs3+9ufZdLn7mUj939MZ5Y+YTrmSmjXmnYLLZ2b+XRFY8Sq3nfR0+HotCd1leEDTJLKiT/qepi8I6VdAES/IiAFJ2/fuvbpGXcFzGxVn2Kk+8/mW2Z5a6eW+cRJnscErz0jE1Ny6J40nqPzqrWZjSyakQorX1BodsWrRVCHApIIUQSuIQyykWzdcS+YHgvaT4Gr6NpzMGu3j4SXbIaTatviMdklgS6iiZpetEYUkHCkxbAuQLYZ+3BqLus4M0e3ae4WpPEpSBt7g8rJc2NSzhorFvdoQiFZ9bq4dxKxVh66GT2DPcGBV0OT5LuKff56gabqblUNEEDWq3lwO0NXN651HcN4NiN0wF/bg+n//WokP1tbx9Rz7e2twBw1StXsevIXamMV1IVr+LRFY8Cj3Ka+CgP11bzdoWtTjt4+hR+tzn3KkCTyYJ9hZ2uhLFYjBvlJ/hS8n+gphlRMUIv03RMYC4db+poJ/634/9cvzdnO1nVugqAlOpl8MES6tpEgh+MGc3i137J1/f5OjUJ3U7Ske5AEQp/XfIH+xnEeFHbg9nKCnqCdjCKOxm8wURDqQ/WwXul40ysBlR4cMNzACSVJAdNOIgnVz/JrYtuZdaIWWzt3kpnxm0TOPvRs63j7zz3Hde1X49q5Nd3uLN+AlSO89PTrih0ZfUVTJ3MkCIZuNIOUtEAITp49/0aCi+sXkubonDSFNuO0aNI7qtzq8ImtNzM0ppKSC1CRVClaXQrCuO1CtbFbLfJZ7s3cAYY4pmbwW8gQ+XUO1znPtVur+6Ufkrs5kWhDP4i4HpgErAe+C/wtUJuFELEgPnAeinlKfnK9wbpmEMaCghmOKznen54yEcRS1vsczF9+7tPx+Zxn3q4q3yMLNX00EklVUYv8eedMGF3nNHpWo4auT9vbtCDfLsUweYYPFhbzeU9bXSrHawa+7b/CQ6mVbPDdQRtHfzptnbu9uSvSKpee4PeqdJ5tzITHLl1LDvGF7nOjsrqQWMVofu5OujMwQSfqKlm3JY3uXvZ3YHXX524iIdq/P7A3zByr+wycheWNuuTz8WbpzOqZwvrGjbS2dNYhARvf6+YouiuqYddCvN+QRyFi6bez7VLlhET/qzXxe519MvXdXvBkuYlPLj8QU6deSqKUOjOtvt0zE7cueROKuOVXLrvpQAcctchvjJdssJaPWZ91gIg5kxFrMMlwXs9U/Lp4IUkprhXF8lYkuOmHcfNb93MDW/e4Lt/Y8dG/vOeP/1yb9GpCLqMVA5VUtIjQxi8Q2p3SvNp/BK897VVFBo0SYOmsl93DwuMCPgVo/wrirk1+rWqrnd4uK6Gak1jVjrN/KRbjfjjlvmcAXrsilSozwraQnbX6VxxMRcJexJUsn73yf5AoV40W6WUn5NSjpNSjpFSniOl3FZgHZdSYmk/E6vhhk1NXLe5CU36Jfj1jEEmqgKlP82XbUJX0dSJLtpltdVJNAQ9So3vficqyFCRsMuscSQzOuTuw/jte58OvO+Wt28JPO/Ee5vOc/2ens4wotvWr9+wqcliAOkC5u0gZmFG7HsNrk6cmPoFkDvZ7N/r60KZO8DmmvDgIICjpx6Ntu1Ert+4nZGZBsZlYly6vZWUDP6GQcg61G4xxXBZrDAmyJQdsxeWiXNSpndh+j988Yd86uFPceZDZ3Lz6s+xekR4gA/AunZ/4JWJj7d30EYNqvEuFQ4vsPc0Q+oMYGLuuKb87eXs/4oQJHEz+ISSYETlCG469qbA+4+79zhuXRRsJNylo4rXVwXshJUHTV26GrJe1eiiIq8E7zxOKTpDztVVnOWPcwQvbRpppzQ5ODPCdc8SoX+rLkVheTI8lkUqXUi1kqtWjQgvo9bQLXUBrUcmUHpawontAwr1otlBCPGwEKJJCLFFCPGgEGKHAu6bDJwM3NZXQnPhp48v54jubo7u6rbUCPt1u5c8igjPWeINvKnTWpmtrKCNaquTPP7OJpoYkZMOBY2HF9nLri+2tvHLlvE57igcz6kHcJSjI+7f0wMIxmRgTFZwRHe3xbSXbc2/UYMawODNVsjF4JfIadaxMxWvmcsGYFI2y9ylbjfFYrDxlfv48fb3OKqnnZXpRuv8Jjmy6NQIj6sHEFME6azGv5bo7fL+m89aUm6QCyjAE+s2sGjlGqY4U/MWiGXbl/H+do8kuDo4Ze4Tq57g9nduZ+HaFt+1n21tpl1WERfmBiuOjbXTV3Noj3tTNaUgFU2QBG+fk1LjibfdE/BTr77BKzecy7Y7f5rjycGYILbl3eR9UibLPY4c942qxl8XPg7AjpkMG+XIvAz+jlfsSWRbTF8JOoUB791OiX9TSPbZ7Wn3JP+B0gLAQd3h6pRvPvAoKF3oMfaS76+Pc2hPnEO7ukk6VsZSS3JA6o8cKW+mSY6gZkFpnBILXY3+E/g3MAGYCPwHuKuA+64DvgshowgQQlwohJgvhJjf1NR3X9AemWTByjXctsnOCjhpRBUzx9Ry4Uf9c5KiKCQMl7R26c68+Iq2G8m4wgHTG1m/vZt5cj9rUxGAp4R7SV2bVFi+TR+E+/T0sFs6wwdNfWfwX92i0+eMak1KfWD+ek2Sv23R6xxRW8W4+gqWZcbRlJwER/3I96xdJ+j0ZwO9EnRUeL7WgdPtlcJBM+zjfQ1f+KPa9PStJt5PJuhKLi7iDd2o7lnOMbE32SzGsCi+Ow9UnE5z1TS2N+7JLhNsNdWvztqLxuoEBzpoOmZX3evEbKknqk/h6F3GMbq2glvf11dXTz31hCXlBkbVOvDYuo1MN1Tr+/S4B7ZXiMiFCiU8RP03C37D7S+722ukkaVqhZzAvOrjaIpP4NmaEzlmV/1dUiQ5/Qi3V805B09jhzE17D7REb1sNMSpe09kv2mNJGJBjNITAetRczZsfo0Dtz3IrG3PcWBXlpPbC9/paZsnuGuvbveEeXBXit+ty7CzYyIVwCapu5cqwNvaDoHODPvPsH3rexwmoR32PJRJI6rYcWwtJ+w+nvMOnc600TVMGVlFhRGTsItiTwhnt7cjAiahZTXBAYlXbm3mJ03BCoz/tV4OgNo1nfrKGDv3xLh54wpu3tzEf9fadTZW1dJJFe2J0bxZfTDamGA33r6iUB28kFI6o1fuFEKEOzsDQohTgC1SygVCiCPCykkpb0Hf65X999+/0GhuH9pkNfWiixQJy9cgZVi5X7z8KKvcz8/Ykx/cb+ueE/E4//jsfvAPWKDtxBGxt6xr/1SP5ptC8J+LzMRQx+h/5uiui5WfvRP+/KpV/guHTOOZuQm+tr2Fj7frBqjVYip6Is7c+EJTnL95fbcM/HGb7iXkZPBLKxIcPr6eTFOcCql3xG8ctxvf2M+gEbc66Avp7/G3c/flsZ0+wozvP+aS4O9VD+es2PP0GDrNT+05Cexm4N8X2RPZxtZu3WkW2DWd4brNTey7y1mw7U6rTK7lqxfplv1JjpjvOrfnrOMYdbKuDvibdfZ7mMHcq6452Tr7qQPcBuvbzj2A6Zc/aqlerj97X5gxmbP2m8zOP3ycbbKO+vQWzLXHvyt+BujR0L8b2UgQzm7WuGaCwk7pDG9W2szv1k3buHjcSF50eDid06xx50i9HWdrcabEqjj88B9x4oxj2PMO36MtPN39FdfvX2jVsOPxLPycabj8DPf4b3PhsFmjeeZbRwReu+Ez+4Te53dBjLFo5Rr+II9m26g1fGNcDUrlLoz+2iuYGWlOXL6aq+/7CRvHvW7dNTWTYU3Cbf9JC8GP6q/CGOJ8b/s2PlelCz1xKfnS9B9x4uqR3J74JRgpAlLOVUaihhvPO4XbbrneR/cn9p/GAR/bg49dO88lkR975DEce5T+jJs+b0c7P//do9jU2sPBv3ja9ZwRe32Z+pd340913+GZUbvySLwJueYcOqfcQ0fCPyaTUnJSZ5ee5gC4bnMTl41zB3KpXTvQOCrO1pTDRlc/mZuPvZn737+fa8890VH6GEqFQiX4uUKIy4UQ04UQ04QQ3wUeFUKMFEKMDLnnMOA0IcQq4F/AUUKIO0PK9hmmC5kzz8tp6Z/5yvlWqEKxEl05l8DzjDzSuVQCPgOW1Oighota2hivmtGrblzbsG/gs77euZKZaVsy+kRbO4tOuof2JdfQgS55bnPkSHmjshKEgioVPe0wuELSvXhO2xt2PsFatjoHxDZZz8bZl5A2LJgNIkZGBhj08C/xj+7qplHqz3tsbe6t6LxoTI4l3XQM9T22xPn42vWcmMid7qAQiJBc8S2ylnrR6fsuZ7aH5+M+uEtl0co1VHnyPQuhcKPD8+en7SpHtdqBa39pzfLz2j04cYY+mM3t8rybRAchlumGiuDo22JQiMnC2xZm3/iaeJofN79P3ebF4DGK1yfrLR2yiZsdq2YT127ZyrbYWKYYjC4mJU+tWc+9zOTNVWutPOnbqLfsHmknzRW1+m5MQYQ78lC5JqkcLx0YBzBqFi2yhj3TaT7bJfnf2g3E0iP5wtpp/sLoG5BUSsljazfwvzXrXWk9TEi1GoxUZRZqx3HoxEO59mPXhtLX3yiUwX8a+ArwDDAX+CrwRWABuoeMD1LK70spJ0sppwNnA89IKc/pM8UhsPYplbaElQrwJvF9XxeDtxnk1zKX6JeDekT1KOOa99kaHR41jxN3r9/ECfU78sODfsjIrs+7rlVJyV0bNvPE2vUc0dnFRS1tvm3sTvVsPKyhkCVGQjN0CDkYvBdOBi+QSKGwh+GTWyNFsMcGIROemkFD4f4e20lq5/Z6Fq5cY0WFmjnWH1y3gXmr1/GHzdv4zp5/RGZHcOgaO3Xu5KyKCNhFqVjYmSbdRsgekr5YBoAqGa6qMftWlzEBHtkNV6xqRCPmWgKfsb2JbiqZnNY4qaeRRDbl8lP/53FPMfu9T/Hl1jbud+icnZCqLqBM7Ol2ZYosJbyZN30SfVezL+WFIvx9ZEJWZUomw5e2Znl87XreWLmG6dks3aKKmGEoTgvBOFVlSkr3GtFievukZIIn1m3gs63tlgR/Ymyk0QaCwJ4nFMuI7I1lCUNQ/xUiZgmIcSNYTUNBVet5fYXfSG660U7JZhmvqj4bQ7ZrOqAgpOa2HSRzO2mUAjlbRQhxgBBivJRyhpRyBvAT4B3gYWA/43xeY+tAwByEzq3KggwzfgiLkToZfDc59nW98Fk4+58+aVYg6cDP4CsNyW+kqkKiik/v8mlqM7ba44KtuuRSJSWTsio3bNnKOFWFcbu7nvOl1nbOatfVMXpGPT3NQo1qeIXECmfwWY+ELlG4adMWZvT8AAUtcIMMCJnwsin0DPp2d6rIJogBXzd84k80dPT1msYoTeOjaZURFbr05huc+59f8HvkhYdek8F7hS5vcJMT5r64NcZ3PKarh7psheWmt3e3sYxX02REgt+uFZzf3aBnyIzZ/agiVoEw2n1WJsMfAiTedPNH+cy4vzIl1QWJ3BGvhaCQEeBNVeDTd6spX8CcIgRZ1c2wYug2i0+0pZmcVS3xKi0qmNWlt4OZjVExPJlkzFx566UVJG2G3n6ajEFCd3QI0sE7JfhMiEDig/GYNzV7Fy8hBFniZGTMweAFK7QJVAZsh+ll6Pv1pKxEgCd2dNK9+stGVdLdt4sQwPoL+aa9mzESnwghPgr8ArgDPZtkft8+A1LKeaXygTfhTLFrIqhTBK7eJul6uvvVw2iKTzDu1ZsmcICMmAK7nOxn8FIjG8AYz9qu09aoqdZHFgImtE3gxI5OzmpL+e5h1I6BxF6xtZmDN5ymZ9QTwmUzKE6CtweEnn9E9wuulZNBqqEDRhFweuqnlgpLf1gGTSiuzhw3GNln2ztYtHIN32nezpNr1jPazPMSr3S5oLowZmf6DQ5faSl1I3ylSLtSwEJuRqgYXixfbWnliq3NnNDeQoqklezqhxskrxiugEfLV0iR1FdV2ZRnSz13LYtTs311yWwtlbF6fYOIWL54hvwoxK3UK7EHpQVgyUOe50KmbW+ODtgW0bkTF0BaxPlocyN/35RihqGGiRmpCMyNdMyNt0c7AujiSFBiei73MAneOG1usZkPpsT/pLq/4zH6+/aQJGHsjapvrOKe1I5btzMvrF4buK3KCe36O++VSqObNiVT299kN2UV7489wShY4CTUj8jH4GNSStMe9WngFinlvVLKHwGzctw34DAleKfuOKhT+PyCpQajZvLYWUuZp+3DLybfBBfMLahOv4rGLwYK4LQWhSdbx1IhsZiwIgR7bZrNr5q2MUkEWOSV4M6QAOqz+irF935FdKCsS0WD9TKK0BBShqpoFCF4S87iNc3BhLWMoS5SLE+ThCdYKg5McEa/jt7Roj5QOusjbPdH97NVFPb0ZJo08X/bW5izwe8WaaZWqJKSs9s7SMo0PdJm8N3UuAK/JILxXe/pu1Q5t9TDrRrrkn6mNEHrYlTXCn1V2Q8MvhC4JfjCvocQkKKC67Zs9V0b6UmHrRInKxPM7rZz2cQ7dBWVyeDN/Qu+0Gq7GSekBCWOECFbu6Tssu2ysNWOOWbTzv5tCAGVpKlM6+xOQ1jC4u0bNvP0mvVM7a6jwbvvpgFTDz9aVamngxMVPbVyg+jig7GGEbUMJfiYEFYI59HoOngTA09tDpjubm7VQtCsr//5a/Z4/SDp7hhdsTqYZBtCcwlA3qjKQJ9qoQcVxTW3IVQAhynv+Mtb9/kZ7A8zuurCzG3u1Z0WA82rg7dWLNKQ4MNUNOY9DmRTqMTooYKPdukMfnwqh4oLoHKEI7S+/xm89URPIFC1SFEpMsQCIge/2tLG/t3+JXmQK2UTDdRmWwBoduS5eUQ5ilq6qcluB6RLggd4WbPVbt0BUue/1b9y7pufBqmC0g8SfAFlxjk2uAD3JGRhttt8pghh6a1/uEHjpm0Bq1ADGjGqQjarN1U07YZq0/nGqtR0Bk/IqqLe3uCnneLUWc6VtmJI8M40JCqKNQb2S6WMvFLh6be+tL2L723bznGdXdya/C1/StpeP9vqjB2k9v18yN2lQz4OcRfwrBDiQaAbeB5ACDELXU1TNjBVNFniaNI0vARJ8DpuzRqudp5ZtZhtEb3L3yBf2tVyPCox4maeElMyF4I7zEkm8OH+T2MmzDIlSuklNoeh0IusR0VjPismQUg11IvGfGfXZLbyWeplG11UcG5rG7ds3MzMrjwGpWyPI3+54JotW7mgpfRd6r/G0rwqG1xXMiBNb1BytCY5wjpeISdYx79PfJH/aY6NSFwqGjejqkjXcJljs5qO979veV8BRdlU+oKYx+PIuwk5ACf83PVTEfpWl2u1MezanWDyyI+yWY7gVc3jz63EQQir3b3QPPuaPqR9hO9s09tki8xY4zNQbm6cbo3XdqrgwAvhgmeCSlow38wpwAhjTD6r7mWdkyi+iPB4kABnoFLCOW3tKMAuYo3rWmfVBJjTCjufGHxzCZGTwUsprwa+BdwOfETaSS4U9F2eygZOHby5xAxU0XjdBLXcSTFzhXr7dXF6B7AmljNuZhGzyBAj5vF0EcAamcMdUPF/GpNmW5LoPYP3S2n6b1NFExTpql8PrBnQ86YkgEN6UoHqKhfaN9kbmqNwcmcXl2zvPwYf5EUDsEbq2a0qMsF1TQjYjCWIwW9xMPhtjuC3lKhgvXPfTZeKxk1LDN1wbsGTQ7xfJPgiF0d6JtMAtuAx+Jr94B05nQoyxKSenG+x5nEtNN7B2SbbHCseaahonCvw8cYeCFtkVtfB6zrEvJRz0rWWPS20lJkdNkBF45yoNSlIe75HLgnele7BZ9/p/xVqoci7xpdSviKlvF9K2ek4956U8o1c9w00LB08MauxA42sxt9m6vXNEo6/2nXdJ4Tn+DZ+A5ZOwwaMPSJH74SUehrfmCnBG6oXIYKjSS1sfMt3ynyvKsOIJX1SfuFxYk4J/gM50erkitBVNGF6WMWhq/fiKUNy3czIvBGitG8qqQ7+Fc1YFte50xW2GUv5imy795ZQ1Ap/xOpWafu7O6VBTYm7XHW9ErwT3jaUnuRx/lTPxaNY5qJ70QT0S489wHyXNllDvehCkVmyMkYbnpWbkUm1zaFCca5+TOn5dcOms5lGZhtbJh6nJQ0jqwjtI4XmJrLKG38zDuZt9mmnB5yG8Kkpgyb6R9UD+WHmfFcq5zrPvqvFTrL9id4rccsMJoPPYu/AEizB638zxOH7a2HPT+jn+4EGU0Vj7X5k5AcPk+CDpOQuGa67NiWrH6g3A9CY9aR26KUEf6d6jNVWCro3UNgGGeZgCJLQu6jkeXUPNjEaBUmTrOeSdEjAs6LYOxA5W3/PTxb8Drnwm+yn4OI3oHG6m0ajfRu7V/fp+V0O/blTXaUI4brmlOC9eErVJ8S/zDqHGfJ8fGatjt7voNRbhOq7veWMb9dGNfV0ohgSfAOe8H4jpsEZFFXl2LjeHI+/zn6Km/e6m9VyPGNVlaO6f8rJ2bhhZA0Yy9/5oPiXwzP+TRirZafROzAJYYDQ8pq2K3eqx+Yct4OJYcPgTT1iWsYtg2GQPBs2m4bJvrlmX/PS23E9z7U50L+duQg+djlMORDQmaniMbJ6A0U+0CZwVeZztHolIAe8Ukyt1uZ5icIleNXley4sHbyCBqk2OgP8+cFpZA2uS0MhJiQKGiox3ypltTaW1QdfBec95tLBWzj4qwW/Qy5oKDBqpu+8KWkdu+KaPj0/TZzXx+qTUQKVb4z4PZx2A4oQ7lgIhxRutt0H2gS6k42WmueAirGMxp2yGoDOvudm6o306Oxn5nt5YU70bbKaGpEiJtOoKKErN6eE67L/GFWpxNheNd1Sb8bAMDSbOnjPixiRtcW+nrmicapozFVEh2Nilgi2e/bxDXo3c6IIMphbzx9EEX7YMHgTGWtL6d55mRRnZNX/vpE0vG4MCbqFOjjy+5ZBNUucmGos8xVbReOUklfICdymnpxTXeGVrOIyw5OqQ+dYBIP3ukG6vGi6ml2eIU6Y7xyWZjdLzAh50gNmvKsUiWDrrufA+D0cfvDOMPPSdsmcAWxFIE2CdFyfjOOorEjMgn2/gMCzCnPq4I33PTr9G+45cp4daZ1N6emMvUgVrkbqL7TLKne/NN7LC3NyNlUyydR2Y/Uc3H+d7e70L3eqkJwBTQpSt48ZOvhwFU2BL2ZXCLgleLMfuiV4wVppq/dSMhGogzdXI91Bu225qxwUDEMGb3eyQAk+T3N7x1mu0uazHqk4Gfb4BN0HBNudD1CWEjP2ZbVVNMI1kEyGG+gTb8DbyTclp3Fb9iT7xI7H5qDWDZ96yKmD726hJWiDZ3KraHQaFeKoxISmh3t7upjEsQoQ5j2O9yoxg+8J2C+gUFg52IGUjKMZHsRxh+eNxK3LdengHc8SwqFXlhqB7tUzBn7b40e0gwtyWzX7fpfBuOOZNrIooemXe1xM3ZWw3nVYg66/3jH9LmhZw01S9Jsrrdnn3KsIvc85JXjvWOuiwrebG0Cd0AOjukP61T+yR0c6+P6Ek8EXHMlKOCPPtbwyL3VRDZ/4M6K6MbDMOunINGe5SepSs7kkDQsscsLLLF+tPdZ+x3gVFLGvo1d1YuvgJWiZnIFOVrkQGvV9TjU0KXz1aCgOQ23Adyoxgy84pD0An0r/2DpOkUA1XPy8PaQrxMjqhOlmqEO6dmGycMCXe01rrzDzaGTApBwEK2DIMFbGsj2oxPz+6MfpTgyaS5gJf/5Kw5OlWnbpDF7E8qhJe8c9XZOM8Y26cOvgneiigoqAHEaV6IFxYbuovajtHnh+oDAsGXwuN8lSwPIdDemJ/1SPtn84jKxgd3ZzyfiP7NGEIeXc5LeyAaEIuyMWGSXnU52YErzUQFNzGFlx0e9/riAm9Mw0KkqgIdl6hqWDHzgVzXZ0l8bmyil5SvrR4tDJpkmwcMInWLfDp7kl687C4QqbdyQMc3YPRThWmFJDSojj8cHvB9GvqEcYKsZCvJpMF1ez38bTrWSIcX32TF7XdrILVtvJZl/b8Zu8oO7OZ9M/JDvpIDjld55VDSyTUwwa4rYELwpPJpYPZn2ulcYsPdK00zExezc475FJah0pGLZUzWSxNo0/ZU8FwgW0x7SDIhVNf0JDKcgP3otQI2uOuiwGZe4OFPLsHidjNiR4s6zJAM3kX7l0eaulY/OQ3T7u1uOHpDYIg0+C97hJhjF4YalogpfiGvpONjE0K9ulF14JPokjPUCJGTzAMm0yI3uK30bO2RvSJFDjNbx34M98UquLwRuZR/W77fsV4ZicpYYmJXX487r0FUVJuNKMkNbvSYcEu4E9STsZfFbq0cyfTM9hmTbZKGgLHkt3OJdzMlfQTjVdn38U9v+iZ9clQY+xIkiQBk1zqGhC3q9I7mnW5zKYGmPH+d28eWhUFHZ2bBKybOQRnJT+hZXcMHybTBEZWfsDF6e/DtM+YvzKpYPvP/gGT8jDXdKAI9kY2DO/+dcyRsX8S/smbN9rkxGqvZTg/a5wThWNltdVLiwQylbR6P7UrlUHUOkIWTfbYJRweAMNAIPfWdH31hyHP6gpH74mfsCyUcegoSAIZqCutnFIsK5x7jQcSokmJfWi/xl8UTAyIvaQ5F71cD6XDt5mEILf2znRWX1e8Rsz9fvdfwErnTNAUqYNCV5vy7DVeC9trIFRqUGeYxelL+Nu7WhUYq4gOO/7B6X2eGfEUXrZSAffdzysHQrnPwrkDvcpXgdfOA3e3DSgG21dnhseBq9aKhq9I1sBGIddEkhlkxlgo2WNABDjExaZmMonWVsSPDkleBN/yJ7Og+qhvvMqMUMxo6EhfF4rdXT7JPgGnHnuB240hNkRcuElsQ+P7aJvPI4Q+fuHIx+8s6iug3cbWetLIcH3QkUDgm9lvsrrMnwbObOvOyXhNkfCL4vhOfplzDFALGO9x8ialrp4kJAZt4rG0Xr37HBVES/lhlmflS74lOusa0EG+Ce0A/mxdoHfbuBp2Iw3ChnYnuyf/Zj7gmHD4J1wGQw9KD6yL7+R1bSPhaponBK8GcmK27hqJj+y9bLBzOeazGf0g216oIfFiIuMelQ9y29zotB18Nm8DL6TKr6XuSDguQoxabpJKpaXhYkXtD2sLAzmeL9LPcouMIDiToWxmvifui8f4S85y56VutI6tm0u4d/89Zlfh8/+233Sp4M3T0iQUC/Cd5UaEBzt38M3DKbawRnd6YxitcL8HRJ8TAQweJeBXV8TZUjou5QZErzAbqt2WcXSkQ47VbEqGuOGLTSy9KK1rr0HtlLPuh0/z1drf++6R0r/itVbbZAq0nSgiHTw/Qxztg9M3xvS2r3ZDNY2EubWwbs218gjwduqkWCK3pOGbrNrKwiHBFUR7LceBr9E4tDBa2pB0Yw9Dub9kxn6boyq4Sp3fGw+uyprXBGMH0ldxzcy/+eQ3vS/bdSwQht4aWeW2IAqBUvlVJ9RzcQaTfeAWiDt9MimzUUgQr/52zO+DDu5k8n5dfDG7542NCnZXazq7auEoijmMs2/IguDOTm7GLxDgre8ShwqN8UhwXtdZcGmNS0ShopGtSR4J/oiA7gN3d4HCZbv/2M+iE13nVUDhC0/Df4y5oYwkQ6+n2F6NXQVuAlALhTiomV+/7CyrtndYwxVPTp457I9CJZEnE0hcIR9F7kdmFVvos6oV4eZLrgQVzknUopubNI8vtBOCX6dHEuKZKD+dSDxlfRlANyW/A0xoa80wmLETk7/go+krnd9W+f3Lkbl52JmTgn+xevYLbWQL8UfL+o9CkGpmIv53LcdG7o5/cit4x7bvuLVt4edy5DUjaxSNcaLrYr0Cm19SeQV/I0CbCqa9Kdg8Nz92bh/DwkreDDSwfcvblJPo+eKZp8lHHLo2ntRjy3Bu397y7gZvJ2qQL9X/wSFMnhLT2hsM2i57hUZFGMy8Gyy3kW8IjVdJ1xg13hM1dMxaMZ7OcPVMzIWuIWhlXLYZXQLzv5YCngTYmlShE5o7VS74xhwrtjCB2+QPcYJV6ATsGNmKfOd7oVlDvP9Vkg7J7tzRfe8ZqTedWwc7kyQGrbyAV2Ct1U0Zi4aG/01aQU9RxHBk4YZ5NQm6o173de3OjKKvqjqvu+FjqFSYvApGGD052xqaVDzuEkGMXh7iarfaxpp8ungLVWCkZ3yAzmJv82+C474flG0qx6JyJxoYkZHVqXCSamfw6Vv5XzOZZmvwVeeIx2vs55rhnT/UT2dIIZtMofA9hoAcWeth2GrKMGBRg44qdIsCT5cRaMEcHi3kdXtGaISI+kMhf/G4pz0FIpStWYQc3QaKe9Wj4AvPw07nWCdc7aVEiDCm4w1TdJtZMXdVkFSf+F028dBk3DY90waMQptsREBVMCn07b94gVNz03VER9hlBw8Eb6sdmXqT4R/+CKNrLlUNB4JPqxzZAJUNLaawtyoxOsOlofB19i55JtrZ/XCD94ob+kbdAYfN1IqqCgsltN92Ri9SJOACXsjhD0R1BiZpU0XyeNT17i2VAvzoBgorJNj2V4xiY7uNFOUJlfsRBiEEFZbOVU0Yd88iAEKH4Ozf2dRqCTFFjmCN/f9Occ3TPLdX04IYo7uGA4Bk92bfLjf3yzl18unSZCUPfoqVsRcqx19/2BXLUXBawfxXQ95oCm0ZESwrcaZPvqv6vFspZ5Y4+nAhkhFM5Do38YWOX7ZCJbg9dIT0HPPNAo9sZTTNzoInVTx49gl8Pn7HEqN4l/KkuANVZAZ6GQazYpdXprteoCyzDpnJtNaJqeygdG+sm4G3xszd++xsWYXKx+7WgCDd8JpZC1KB5/jelbGqBYp3tMmsWF04cbOfCgVcwmU4HME6YFX8g6f5NMkqdDM5HxBEnwf9O4i+Djfs836bQbvLud89zQJ/qMegRSxgJIDi5IxeCFEpRDiNSHEW0KId4UQPylVXYH1hzRrX2b8UOQwskrp3v/RK8GbOCX2CpCfwQM8oXxM34/Scs/MT6IX9qRjMHij3rgRzagW2VImDU5ddiokP4fXD96FARJ3MkoltUZiKw0RuL2jE86rTptLWNvnkw69DFKVClWk6aZyUBlCoQh670XajDz35FZbmZdTIkGlNDbNsFamfklfPy5yRZ6HnrDvafbrVckdAdhe5d65ytnX7Uj6gRVaglBKCT4FHCWl3BuYDZwghDi4hPUVhP70KvAbWUN08M48Gh4dvImHrKAh86GFb97Rm1eyGLFHRWPp4IvsGuZgcYZshzF4k95gI+vAIKNUUGPkFtGKDHmybS7h3zyIUbjVA+5rqohRRU/OVBW9Qam8aIKYYxONee7xn3OlKjCOM8R1IysEBjr15Y3c9QXQGMLhE4YO/pm6UzkldRXvj/FmbvWvz/J51w0ESsbgpQ7Ttyhh/BuwUZzPuyERcxdIxPSmqEra+dpzPQcgYbgF1FTk1n+rOVQ0Ju6t/jSQXwcPUFdpGmRl4LMKgRno5DOyGh25eBWNMTgdEX2pkBSqtgQf+KSi6i0GjdU2PQs2pIg7VDRSBm/SbqLa6BcV8ZhrBWIej6zWJzOzXwWvThyHnusb29JUiXTZ7QxkvpcXxXS5amtMFSYxqzLmZvC40wUHGUpH1hQ2MRYiwddW+k2TpgqmLTGOd+QOoe/vzDtVU2Hk6QnYX3mgUFIjqxAiBiwAZgF/kFK+GlDmQuBCgKlTp/aqnicuO5w317QAcNXH96C5M00ipnD//x3K6m3u8O99pzbymQOncuAMt7Rx5C5jueyYHTn/UH2Zefv5B/LW2haL8Qdhysgqvn/iLpy6t+0q9r0TdmHHsd5c6kERtW5c85lD+OTNr/i8aH511l7sPqmeK+5/h4Vr9Xf82el7hNIUhJvO2Zd12937RGY9ErylgzdUNKfsPZnddtiLIPzktN1pak9x49zl1rlP7DeZu15b48rJMXVcI2y07ztgeiP7Tm1kfL3uIz2mroKvfGwHbn52xYCoJX551l785OF3UYSgu9lmpJoxzQVNqWcfMIXKRIwvHDKNW55bweE7jmHn8bW09WQ4brfxjK2v4PzDpvOZA/W++53jd+GpxZv5yI6jfc9yMoXpo9wJysaMqKW2I003FQPSFjd/fj9qK+J87jb3kLzmzD254ZnlXPXxPXju/SbrvbyoiMf4xjE78eDC9Zgu4j8+ZTfSqsY1jy91lf3WcTsz/Y11HDhjpFXGxG4T6/n8wdPYZUIdrd26629WKA4GH3O5ScZjCifvaY+3hqoEXztyJofv6PaMCoOiCL5z/M60dmesfgg631i2qZ3dJjTwh8/uyx/nLSeV0ZPAZTXJ91b9lE82LueSk2bTMGIVp+49kZ3H1yElXHTnAgB+Mf539FRPhMX6GPrSR3RecvSuY/2EDBBKyuCllCowWwgxArhfCLGHlPIdT5lbgFsA9t9//15J+LuMr2eX8bof6jkH27qxfaY2ss9UNyNvrEnyizP39D0jpgguO8b2Q/7YTmP42E65O40Qgq98zL0t3FePmOkp4wm4Mg10nlF8wAw966A3kvVTB+jpUz930FQWrm3h1L0ncuis0c5H5ZWmTthjgu+cuaoQHh28uTHJfjNGs9/+wSl1zz10Oss2tbsY/H7TGvndp/cmfZ/dpSaN1hn86NokWzvS7Dutke+fuKt1XQjB90/clf/MX8efe05kjvI3qClsoPYGH91pDE9/6whuf3ElGx9zMngFpLHdoGfXnmvO2ivw+Bdn2sdXnmrn/D52t3Ecu5t7o+8gNHokztnTx1H5bopuKrwZ1UuC43cPjhw++8CpnG0w9SN3yc2YLj1mRy49ZkeYo//+osHQvAx+v2mN7Det0VXGRHUyzs8+rgssf5yn9ydVxoibudcNwcMcFxUxwW4TbZ9zIQTfOT48Z04QvnbkLN85J9+oSsb4qU+Imm0dmd9+xuga2nrsTKjfv+iLLNvUzh2LnwNgyshq5pz2IcgHL6VsAeYBJ+QuOTzRSRUvHX0vnP4HqNeZbZjxdpM0sg+OcEtOOTce6YMXDZYXjf6MhDmwArJZuunxn/O6/qnGjkeF7CR4u3oCqy/e4AqMKRUURbh03SoKcgBMYrnUA4rQXVQHQ0VzYM8fyF76Tv6CJYadn0khaW5SH6/0BTqVE7zDYDD17UEopRfNGENyRwhRBRwDLM150zBGW+MesM851u+wjvBfbX+aTvsHHPx/rvNBxe0kZ8XT4w+o0h/iHFi5EFSldxKKaZmAUrmeOTCjQ+DO8Gnq4Eu9QUyQH7iJhGps/dbPRtZCsIVGRMPkAa/XC7N5VGJUSMNNMl6JEP23ZV9/w9vny43KUqpoJgB3GHp4Bfi3lPKREtZX1vAydFOCe3DmTzl9F6fUKkjNONIXuBTogkmwuqcQuDbZxtbBV0iTwfdGgnf/TpjPKhADJf0IIVxRl9LSwZeYwXtocGJE5wrAHe4/kCgHxmTS4IobiXtsEkVsLD8Q+NBK8FLKt6WU+0gp95JS7iGl/Gmp6hoK8H1348TSMcfDAV/Kf3+OjtMbydeUFDftcaFxRu8KSYfklIeivHS833CYfr7cOr1w56lXDTdWk8Gb27D1N3IF2ey++u8AjBEtJal7KMBsE5dbsaGiKYe8LkHw9+3y6uxln6ogk8mwbt06enp68hcuQ9x40jikhFHqVpYs2W6d/+xOMT4+fQJ1lWmWLFkCwK2n6fr57RtW0b7J3VGmKlluPW0CVUmFlStXMnny5D752WaJ89Sn3qOxJgEvv4xmPCTZjxJ8VvFE/eURvgZqIlAEfh28lCXfyzdfmDxg+eYPNMphEjbbR/VI8FDOOniPiqYM2tGJsmfw69ato66ujunTp5csaKOUUNe3oknJ9FE11FfZPrJrtnXR0p1mbF0l4xt0aTmzrgWAncfXk4y7JZbtXWkSzV00VCaooZt169b1mTa9OU2Hf0OC1wqT4MN08L/LnsWxsQV9pq2UEMK9ZZs0Ap2kxeBLV6+JMLvJv9Qj+XyJ6i93WBI8HgmectbBe34PDhmhKM91jwM9PT2MGjVqSDL3/oT59kIIRo0aRU9PT94I2rzPdNxmDqCk6X+cV4IPDhJZLKfzteTP4AsPOq4UxjIH6hsLIXhJs93XBsrI6kSQBP9W47F8IAcnyVif2v6Tt8Nn/tVvtLhVNBWeSNZyleV1lBufKnsJHsqv0foFpuDci1cz26MvXjRemEbXRME6eD9MprVQ2QN2OAKxeLGLznz8c6C+siKEKyDLdBmVJVbROBH03TdX7VjyekuC3c/o18e5jayVvmRjEQpH2UvwEfKjt13fmQ3R9INPagVK8EHn+jgGB1IH74TmUc2UTAfvNLIG1JENSUX7YYEpuLhVNBVGZytPBh+paIYJ7r//foQQLF2a25X/uuuuo6urK2cZIHSl+eC//8lll1xcIFW9z0Xje5Khgx+fWqmfyKeDDzSy9o2OAfOD9zF4d7RkyXTwOZKNAajKkFhQlwyWm6T0SvCObJ9l5yZZ3kbWiMEXiLvuuouPfOQj/OtfuXWNoQw+5MP3R3/odacSzvr1rjApZaQfyCvBB7hJDhkJ3l2R6mHslgQ/YXa/1us2svpfVhXBib0+LAg2slYYkaxlxjkN+CX48qJzSIkMP3n4XRZvaMtfsAjsNrHelUskCB0dHbz44ovMnTuX0047jTlz5qCqKt/73vf473//ixCCCy64ACklGzZs4Mgjj2T06NHMnTuXA3eaxCvL1iGAe+65h0ceeYTbb7+dp554jN/9+hpQs4wbO5p//OMfYPpmF9hHLDfJXr678z7pnesHRYIfGHhXPJpHBw8ws+fvfHDByf1br4sG//VyZWIDBZcEb/6IVyLS5Wta9X6xcpPghxSDHyw88MADnHDCCey0006MHDmSN954g1dffZWVK1fy5ptvEo/HaW5uZuTIkfz2t79l7ty5jB7tzyboxAEHH8ydD/2PCSOqeOjuO/nVr37Fud/4Uc57QtGHXmUxO+8z8kjwxZBRMHmDrIO3/a+FflzkNoj5EJT73Im6zNZ+rW+owWyTtPREsmZUXxK+ckG5O4AMKQafT9IuFe666y4uu+wyAM4++2zuuusuVqxYwUUXXUQ8rjfhyJEji3rmhg3rmXPF92ndtgU1m2HGjBlF02XvBVv0rYC7c/qGTR7mVogEbz9TeE8EP3OAOHyYisbcrKR0Ong/XlB35yOxd0tU49BCoIpGiQFqmbF1G5EEP8Sxbds2nnnmGd555x2EEKiqihCC/fbbr6DZ21nGGY175eXf5rNf+iqf+eSZvLvgFebMmVM0bc69QXsLy7tYOAbVDkfkvy/g3cObo7yGp5dMUzrMGKoBmWf7vl7XG/DYr2cuYWHsKwDEzRiEDynM5rEynU7cx3FeeEqVB3w6+DLj8JGRNQ/uuecevvCFL7B69WpWrVrF2rVrmTFjBvvuuy833XQT2ayeP725uRmAuro62tvbrftHjR7DiveXoWka999/v3W+vb2NseMnAoI77rijTzT2tk+F6uB76c3hlYytyaNQP/gBGhtB+6EClm/8QOrCnVvRrakJ3mDlw4aM9CfaGyqBTuWGiMHnwV133cUZZ7gDOc466yw2bNjA1KlT2Wuvvdh777355z//CcCFF17IiSeeyJFHHgnAZd+fw8Xnnc0pJxzHhAn2xhuXfecHfPur53Hq8Ufl1deHoUC+GQpXJKvLSTu/7jmozqFiZA3TwWdKvKANku6cE+sH9QeVtP6yh9E+GTOS1bFCLVcD9Ic5XfCwwLx583znLrnkEuv4t7/9revaxRdfzMUX237sx51yOsecfBo7jK6httJ2gzvupFM46MjjmTiiitG1ukHz7XUtnP6pz7LrhHqKQV/4qhXoFLAxeLF1ltnqNBTeichS0ZRYBx8EQeGbqw93WF40xHwXhorcXm5jIJLghzBsN8ne9SrnfS4dfAHeI0F19kfKhIGAdxD6jawD9yJt1HBT9lRePub+/IWHOewNPxTfecuLpswCnbwoNz/4iMEPYdjJxnr/DKtDFsvgAyX48urcYQjzojEjKAdWHSC4JvsZOkcO7t6d5QBryz5LB2+qaCIJvreIGPyAIfjLB50tto/0RzZJVXHkQSlERRNwrq86+IGCl0yTodcLPQK5ShS3E1V/QIlGYg4JXlB+2u1glBuVUbcaKJTgy9tukr2DwB5UmuIIky/EiyZIgg8rWma9PkyC30NZBcDpyksDTZJhSPxww6eDd/TvIeNFU259fbAJiNB39AcDdTP43urgy6x3hyBMB28iPRi+B0Oj6UoK87tY7S+dm7IMjQaKdPARXOgPntiXZGMmXAy+ADfJYugoN7uYP+LW/TvN4CT9Ki/WMHjoMbdTVDMAZZ1srNxRMgYvhJgihJgrhFgihHhXCHFpqeoaCBSSLvjQQw8NvebtnjbT63vH7Q+pQXUy+Fj+vOSlSDY2UMgnwaci7+FBgdmPe6TR/6RqnbdUNOUmLXhQbkOglBJ8FviWlHJX4GDga0KI3UpYX0mRK12wquod8aWXBlZ325dNt8EzMYiYPYgqGwq414+hYigM08GbKHXAU4QQGJ8lZa6gDEFjKEnw5UZlyXqylHIjsNE4bhdCLAEmAYt7/dDHL4dNi/qHQBPj94QTr8lZJChd8Lx58/jJT37ChAkTWLhwIYsXL6a2tpaOjg7mzZvHlVdeybhx43ht/hscdeIpfOSAfbnpjzfS3d3NAw88QKxhPPP+9zh3/PF3aNkMo0aN4opr/8ioMWMLJl32ccMPIezJYUt7yth6msIYfFAumrLr3sHwUqlJD4OXEYMfDJjfJWYGfxWwkiw3lJur8IDIXEKI6cA+wKsDUV9/IyhdMMBrr73G1VdfzeLF/jnrrbfe4vrrr+fRZ1/lkXv/zfLl7/Paa6/x5S9/mRtuuIF4TLDvAYfw1LznefPNNzn77LO5/U+/B4I7iWJEESXj9icbV6/nbK+MF/cZK4zyybhCRVzXt//ogXfoNpfGNflTJ5h07Dt1hHWuKqE/a7ZxbsaYGgAOnaU/b8aomsBnmc9IFvkeYahO5rYhVHmua55h4Iuk7GfsOLYWcAeGVSdiTGqsAqCxpu+Mrb6ysElqVD/UFYRkrPhvWWn0n3aq9ROTDwAgpoiyTRdsYkydHo0eNC4GFVLKkv4DaoEFwJkh1y8E5gPzp06dKr1YvHix79xA46STTpJPPvmklFLK66+/Xn7729+Wc+fOlUcccYSrXE1NjZRSyrlz58pjjjlGSillKqPKQw77iHz++eellFI+/fTT8vTTT5eZrCpffHWBPOaYY+Uee+whd9ppJ3nMccfJ9u50IA2apsnWrrTMqpqUUm+Xre098rG3N8ieTLao93l3fat84p2NMqtqUtM0+dTiTfLeBWvlM08/Jtvn/0vKdFdBz3lxeZPc1NrtonHu0s2yuSNl/X51xTbX3yB0pjLy7bUtRb1DLjS198jlW9pDr6uqJv/7zkYpr6yX8sp6+c6SpfLeBWvl20/8Rcor62XPX06TK5o6+o0eJ5ZsbJUtnfo3XrSuRd7/xjr51OJNMqtqsjudlU8t3iTTWbXP9XywpV0uXLM9b7mVTR3yjdXNfa7PiUXrWuR7m9qKvq87nZUPv7Ve3vfGWtm67AUpMynr2mvLN+nfa86I/iS1X/DG6ma50tFfvOOi1ADmyxD+W9K1qBAiAdwL/ENKeV/IBHMLcAvA/vvvX3bTc1i64JNOOomammCJFKCiwp7Rk/EYlZW6tK0oCtlslnhM4Qff/Sbf/OY3Oe2005g3bx5z5sxx5atxQghBfZX72qjaCk7cc0Jg+VzYbWI9u020890cves442hyUc85dKZb0hdCcMTOY12/D5yh58k3/wahOhlnz8n51UKFYnRthZXfJwiKIjhu9/HwH/337pMb2b12LCyfAi9DRUwwY3T4t+0Ldhlvt/sekxrYY5L93jEl5vgWfcMOY2oLKjd9dA3T6d93db5TMahMxDhlr4nGL3dfPGD6qD5SVTrsM7XR9ds7LgYTpfSiEcCfgSVSyt/mK1+uCEsX/MILL/T52a2trUyaNAmgzymDI/QBZpoG86+MEoCVHaydx0qrPhtuKKUO/jDg88BRQoiFxr+TSlhfSRCWLthMD9wXzJkzh09+8pMcfvjhvU4ZHKEfEDH48ocSg499Dy54ZrApGVIQsoz8Svfff385f/5817klS5aw6667DhJF5YuoXfoBcwxVwuVrdM+hFc/C306D6YfDeY8MLm0RIhQIIcQCKeX+QdeGiOdyhAglhLnstyT48hF6IkToCyIGHyGCpaIxoyUjFU2E4YGIwUeIoHgk+DL1tY4QoVhEDD5CBMszI5LgIwwvRAw+QgSvBB/p4CMME0QMPkIEy8c6kuAjDC9EDL4AXH311ey+++7stddezJ49myOPPJLZs2cza9YsGhoamD17NrNnz+all14im83ygx/8gB133NE6f/XVV1vP2rRpE2effTYzZ85kt91246STTuK9995j1apVCCG44YYbrLJf//rXuf322wfhjT+sGCK7BkWIUCCitHl58PLLL/PII4/wxhtvUFFRwdatW0mn00ycOJF58+bx61//mkcesX2mL7/8cjZt2sSiRYuorKykvb2d3/zmN4Ce9+eMM87g3HPPtdIOL1y4kM2bNzNlyhTGjh3L9ddfz1e+8hWSyaGXSW/IIwp0ijDMMKQY/C9f+yVLm8M33OgNdhm5C9878Huh1zdu3Mjo0aOt3DK5Ik67urq49dZbWbVqlZV7pq6ujjlz5gAwd+5cEokEF110kXXP7NmzAVi1ahVjxozhsMMO44477uCCCy7o45tFKBqRiibCMEOkosmD4447jrVr17LTTjvxf//3fzz77LOhZZcvX87UqVOpq6sLvP7OO++w33775azv8ssv5ze/+Y21iUiEAYTF4CMVTYThgSElweeStEuF2tpaFixYwPPPP8/cuXP59Kc/zTXXXMN5552X996//vWvXH/99Wzbtq3g3Z5mzJjBgQce2C+5biIUiVojk+PMIweXjggR+gmRBF8AYrEYRxxxBD/5yU+48cYbuffeewPLzZo1izVr1tDe3g7A+eefz8KFC2loaEBVVXbffXcWLFiQt74f/OAH/PKXv0TTIlXBgKJ+Ilz2Dhx95WBTEiFCvyBi8HmwbNky3n//fev3woULmTZtWmDZ6upqvvSlL/H1r3+dnp4eQN+vNZ1OA3DUUUeRSqW49dZbrXtef/11n9pnl112YbfddnMZbyMMEEZMsf3iI0QY4ogYfB50dHRw7rnnsttuu7HXXnuxePFiy2gahKuvvpoJEyawxx57sM8++3D44Ydz7rnnMnHiRIQQ3H///fzvf/9j5syZ7L777syZM4eJEyf6nnPFFVewbt26Er5ZhAgRhjuidMFDFFG79APWvg5b3oX9zhtsSiJE6DVypQseUkbWCBH6FVMO0P9FiDBMEaloIkSIEGGYYkgw+HJSI5UDovaIECFCISh7Bl9ZWcm2bdsipmZASsm2bdusSNkIESJECEPZ6+AnT57MunXraGpqGmxSygaVlZVMnjx5sMmIECFCmaPsGXwikWDGjBmDTUaECBEiDDmUvYomQoQIESL0DhGDjxAhQoRhiojBR4gQIcIwRVlFsgohmoDVvbx9NLC1H8kpBSIa+wflTmO50wcRjf2FcqBxmpRyTNCFsmLwfYEQYn5YuG65IKKxf1DuNJY7fRDR2F8odxojFU2ECBEiDFNEDD5ChAgRhimGE4O/ZbAJKAARjf2Dcqex3OmDiMb+QlnTOGx08BEiRIgQwY3hJMFHiBAhQgQHIgYfIUKECMMUQ57BCyFOEEIsE0IsF0JcPoh0TBFCzBVCLBFCvCuEuNQ4P1II8T8hxPvG30bHPd836F4mhDh+gOiMCSHeFEI8Uo70GfWOEELcI4RYarTnIeVEpxDiG8Y3fkcIcZcQorIc6BNC/EUIsUUI8Y7jXNF0CSH2E0IsMq79XgghSkzjtca3flsIcb8QYkS50ei49m0hhBRCjB5MGguGlHLI/gNiwAfADkASeAvYbZBomQDsaxzXAe8BuwG/Ai43zl8O/NI43s2gtwKYYbxHbADo/CbwT+AR43dZ0WfUfQfwZeM4CYwoFzqBScBKoMr4/W/gvHKgD/gosC/wjuNc0XQBrwGHAAJ4HDixxDQeB8SN41+WI43G+SnAf9GDMUcPJo2F/hvqEvyBwHIp5QopZRr4F3D6YBAipdwopXzDOG4HlqAzg9PRGRbG348bx6cD/5JSpqSUK4Hl6O9TMgghJgMnA7c5TpcNfQaN9egD7M8AUsq0lLKlzOiMA1VCiDhQDWwoB/qklM8BzZ7TRdElhJgA1EspX5Y6l/qb456S0CilfFJKmTV+vgKYubDLhkYDvwO+Czg9UwaFxkIx1Bn8JGCt4/c649ygQggxHdgHeBUYJ6XcCPokAIw1ig0G7dehd1DNca6c6AN9NdYE/NVQJd0mhKgpFzqllOuBXwNrgI1Aq5TyyXKhLwDF0jXJOPaeHyh8EV3ahTKiUQhxGrBeSvmW51LZ0BiEoc7gg3Rag+r3KYSoBe4FLpNStuUqGnCuZLQLIU4BtkgpFxR6S8C5gWjbOPry+E9Syn2ATnTVQhgGuh0b0aW2GcBEoEYIcU6uWwLOlYNvchhdg0avEOIKIAv8wzwVQstAf/Nq4Argx0GXQ2gpi+8+1Bn8OnS9mInJ6MvlQYEQIoHO3P8hpbzPOL3ZWK5h/N1inB9o2g8DThNCrEJXZR0lhLizjOgzsQ5YJ6V81fh9DzrDLxc6jwFWSimbpJQZ4D7g0DKiz4ti6VqHrSJxni8phBDnAqcAnzNUGuVE40z0Cf0tY/xMBt4QQowvIxoDMdQZ/OvAjkKIGUKIJHA28NBgEGJYyP8MLJFS/tZx6SHgXOP4XOBBx/mzhRAVQogZwI7oRpmSQEr5fSnlZCnldPR2ekZKeU650OegcxOwVgixs3HqaGBxGdG5BjhYCFFtfPOj0e0t5UKfF0XRZahx2oUQBxvv9wXHPSWBEOIE4HvAaVLKLg/tg06jlHKRlHKslHK6MX7WoTtUbCoXGnMRP6T/ASehe6x8AFwxiHR8BH0J9jaw0Ph3EjAKeBp43/g70nHPFQbdyxhACztwBLYXTTnSNxuYb7TlA0BjOdEJ/ARYCrwD/B3dg2LQ6QPuQrcLZNCZ0Jd6Qxewv/FuHwA3YkS8l5DG5eh6bHPc3FRuNHqur8LwohksGgv9F6UqiBAhQoRhiqGuookQIUKECCGIGHyECBEiDFNEDD5ChAgRhikiBh8hQoQIwxQRg48QIUKEYYqIwUcYNhBCjBJCLDT+bRJCrDeOO4QQfyxhvUcIIQ4t1fMjROgt4oNNQIQI/QUp5TZ0H3qEEHOADinlrweg6iOADuClAagrQoSCEUnwEYY9DAnbzH8/RwhxhxDiSSHEKiHEmUKIXxl5u58w0k2YubyfFUIsEEL81xHuf4kQYrGRu/xfRmK5i4BvGKuFw4UQY4QQ9wohXjf+Heao++9CiGeEnp/9gkFqkggfEkQSfIQPI2YCR6Ln8n4ZOEtK+V0hxP3AyUKIR4EbgNOllE1CiE8DV6NnOrwcmCGlTAkhRkgpW4QQN+FYLQgh/gn8Tkr5ghBiKnoO8V2NuvcCDgZqgDeFEI9KKQctf1KE4Y2IwUf4MOJxKWVGCLEIfdOYJ4zzi4DpwM7AHsD/jE14Yuih66CnT/iHEOIB9DQKQTgG2M2xgU+9EKLOOH5QStkNdAsh5qLnhg97ToQIfULE4CN8GJECkFJqQoiMtPN1aOhjQgDvSikPCbj3ZPQNSU4DfiSE2D2gjAIcYjByCwbD9+YGiXKFRCgZIh18hAh+LAPGCCEOAT0NtBBidyGEAkyRUs5F3zhlBFALtKNv02jiSeDr5g8hxGzHtdOFvofrKHTj7OslfI8IH3JEDD5CBA+kvv3jJ4BfCiHeQs9weCi6quZOQ7XzJrqevQV4GDjDNLIClwD7G4bYxehGWBOvAY+ib033s0j/HqGUiLJJRogwQBhg180IESIJPkKECBGGKyIJPkKECBGGKSIJPkKECBGGKSIGHyFChAjDFBGDjxAhQoRhiojBR4gQIcIwRcTgI0SIEGGY4v8BZMv5hKzy5tAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot20mnt(a384,p384,predicted_denorm[:,road,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "883d3883",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "pytorch"
  },
  "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.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}