{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Different Prediction Horizons in Gulf of the Mexico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import h5py\n",
    "import scipy\n",
    "import numpy as np\n",
    "import torch\n",
    "import os\n",
    "import sys\n",
    "from dataset.dataset_prediction import PRE8dDataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load(path):\n",
    "    path = path + \"/with_imputation\"\n",
    "    preds = []\n",
    "    for i in range(10):\n",
    "        preds.append(np.load(path+\"/prediction_{}.npy\".format(i)))\n",
    "    return np.stack(preds, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "category = []\n",
    "pred_len = []\n",
    "mse_list = []\n",
    "mae_list = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**predictions for 1 year (PRE)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "parser = argparse.ArgumentParser(description='Prediction')\n",
    "parser.add_argument('--area', type=str, default='MEXICO', help='which bay area we focus')\n",
    "parser.add_argument('--method', type=str, default='GraphTransformer', help='which bay area we focus')\n",
    "parser.add_argument('--index', type=int, default=0, help='which dataset we use')\n",
    "\n",
    "parser.add_argument('--epochs', type=int, default=200, help='epochs')\n",
    "parser.add_argument('--batch_size', type=int, default=8, help='batch size')\n",
    "parser.add_argument('--lr', type=float, default=1e-4, help='learning rate')\n",
    "parser.add_argument('--wd', type=float, default=1e-6, help='weight decay')\n",
    "parser.add_argument('--test_freq', type=int, default=20, help='test per n epochs')\n",
    "parser.add_argument('--hidden_dim', type=int, default=8)\n",
    "\n",
    "parser.add_argument('--in_len', type=int, default=46)\n",
    "parser.add_argument('--out_len', type=int, default=46)\n",
    "parser.add_argument('--missing_ratio', type=float, default=0.1)\n",
    "\n",
    "config = parser.parse_args([])\n",
    "test_dloader = DataLoader(PRE8dDataset(config, mode='test'), config.batch_size, shuffle=False)\n",
    "\n",
    "labels_list = []\n",
    "label_masks_list = []\n",
    "\n",
    "for test_step, (datas, data_ob_masks, data_gt_masks, labels, label_masks) in enumerate(test_dloader):\n",
    "    labels_list.append(labels[:,:,0])\n",
    "    label_masks_list.append(label_masks[:,:,0])\n",
    "\n",
    "labels = torch.cat(labels_list, 0)\n",
    "label_masks = torch.cat(label_masks_list, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_dir = \"./log/prediction_46_46/{}/\".format(config.area)\n",
    "prediction_xg = np.load(base_dir+\"XGBoost/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_mtgnn = np.load(base_dir+\"MTGNN/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_tsmixer = np.load(base_dir+\"TSMixer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_crossformer = np.load(base_dir+\"CrossFormer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_iTransformer = np.load(base_dir+\"iTransformer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_predrnn = np.load(base_dir+\"PredRNN/without_imputation/prediction_0.npy\", allow_pickle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_xg = torch.from_numpy(prediction_xg).squeeze()\n",
    "prediction_tsmixer = torch.from_numpy(prediction_tsmixer).squeeze()\n",
    "prediction_mtgnn = torch.from_numpy(prediction_mtgnn).squeeze()\n",
    "prediction_crossformer = torch.from_numpy(prediction_crossformer).squeeze()\n",
    "prediction_iTransformer = torch.from_numpy(prediction_iTransformer).squeeze()\n",
    "prediction_predrnn = torch.from_numpy(prediction_predrnn).squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.068685666\n",
      "0.13446369859336033\n",
      "0.112679526\n",
      "0.12395593\n",
      "0.12078265\n",
      "0.124221794\n",
      "0.086096786\n"
     ]
    }
   ],
   "source": [
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_our))\n",
    "\n",
    "\n",
    "mse_xg = (((prediction_xg- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_xg))\n",
    "\n",
    "mse_tsmixer = (((prediction_tsmixer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_tsmixer))\n",
    "\n",
    "mse_crossformer = (((prediction_crossformer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_crossformer))\n",
    "\n",
    "mse_mtgnn = (((prediction_mtgnn - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_mtgnn))\n",
    "\n",
    "mse_iTransformer = (((prediction_iTransformer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_iTransformer))\n",
    "\n",
    "mse_predrnn = (((prediction_predrnn - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_predrnn))\n",
    "\n",
    "\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_xg[mse_xg==0]=np.nan\n",
    "mse_crossformer[mse_crossformer==0]=np.nan\n",
    "mse_mtgnn[mse_mtgnn==0]=np.nan\n",
    "mse_tsmixer[mse_tsmixer==0]=np.nan\n",
    "mse_iTransformer[mse_iTransformer==0]=np.nan\n",
    "mse_predrnn[mse_predrnn==0]=np.nan\n",
    "\n",
    "\n",
    "category.extend([\"XGBoost\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"MTGNN\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"CrossFormer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"TSMixer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"iTransformer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"PredRNN\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"STIMP\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "mse_list.extend([mse_xg.numpy(), mse_mtgnn.numpy(), mse_crossformer.numpy(), mse_tsmixer.numpy(), mse_iTransformer.numpy(), mse_predrnn.numpy(), mse_our.numpy()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.19530658\n",
      "0.26998080155635307\n",
      "0.24929206\n",
      "0.26396638\n",
      "0.2595179\n",
      "0.26388556\n",
      "0.21852869\n"
     ]
    }
   ],
   "source": [
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_our))\n",
    "\n",
    "mae_xg = (np.abs((prediction_xg- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_xg))\n",
    "\n",
    "mae_tsmixer = (np.abs((prediction_tsmixer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_tsmixer))\n",
    "\n",
    "mae_crossformer = (np.abs((prediction_crossformer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_crossformer))\n",
    "\n",
    "mae_mtgnn = (np.abs((prediction_mtgnn - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_mtgnn))\n",
    "\n",
    "mae_iTransformer = (np.abs((prediction_iTransformer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_iTransformer))\n",
    "\n",
    "mae_predrnn = (np.abs((prediction_predrnn - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_predrnn))\n",
    "\n",
    "\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_xg[mae_xg==0]=np.nan\n",
    "mae_crossformer[mae_crossformer==0]=np.nan\n",
    "mae_mtgnn[mae_mtgnn==0]=np.nan\n",
    "mae_tsmixer[mae_tsmixer==0]=np.nan\n",
    "mae_iTransformer[mae_iTransformer==0]=np.nan\n",
    "mae_predrnn[mae_predrnn==0]=np.nan\n",
    "\n",
    "mae_list.extend([mae_xg.numpy(), mae_mtgnn.numpy(), mae_crossformer.numpy(), mae_tsmixer.numpy(), mae_iTransformer.numpy(), mae_predrnn.numpy(), mae_our.numpy()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**prediction two year**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_dir = \"./log/prediction_46_92/{}/\".format(config.area)\n",
    "prediction_xg = np.load(base_dir+\"XGBoost/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_mtgnn = np.load(base_dir+\"MTGNN/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_tsmixer = np.load(base_dir+\"TSMixer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_crossformer = np.load(base_dir+\"CrossFormer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_iTransformer = np.load(base_dir+\"iTransformer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_predrnn = np.load(base_dir+\"PredRNN/without_imputation/prediction_0.npy\", allow_pickle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.out_len = 92\n",
    "test_dloader = DataLoader(PRE8dDataset(config, mode='test'), config.batch_size, shuffle=False)\n",
    "\n",
    "labels_list = []\n",
    "label_masks_list = []\n",
    "\n",
    "for test_step, (datas, data_ob_masks, data_gt_masks, labels, label_masks) in enumerate(test_dloader):\n",
    "    labels_list.append(labels[:,:,0])\n",
    "    label_masks_list.append(label_masks[:,:,0])\n",
    "\n",
    "labels = torch.cat(labels_list, 0)\n",
    "label_masks = torch.cat(label_masks_list, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_xg = torch.from_numpy(prediction_xg).squeeze()\n",
    "prediction_tsmixer = torch.from_numpy(prediction_tsmixer).squeeze()\n",
    "prediction_mtgnn = torch.from_numpy(prediction_mtgnn).squeeze()\n",
    "prediction_crossformer = torch.from_numpy(prediction_crossformer).squeeze()\n",
    "prediction_iTransformer = torch.from_numpy(prediction_iTransformer).squeeze()\n",
    "prediction_predrnn = torch.from_numpy(prediction_predrnn).squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.06947034\n",
      "0.13464424685630627\n",
      "0.11208085\n",
      "0.12426548\n",
      "0.12465604\n",
      "0.124425866\n",
      "0.16316438\n"
     ]
    }
   ],
   "source": [
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_our))\n",
    "\n",
    "\n",
    "mse_xg = (((prediction_xg- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_xg))\n",
    "\n",
    "mse_tsmixer = (((prediction_tsmixer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_tsmixer))\n",
    "\n",
    "mse_crossformer = (((prediction_crossformer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_crossformer))\n",
    "\n",
    "mse_mtgnn = (((prediction_mtgnn - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_mtgnn))\n",
    "\n",
    "mse_iTransformer = (((prediction_iTransformer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_iTransformer))\n",
    "\n",
    "mse_predrnn = (((prediction_predrnn - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_predrnn))\n",
    "\n",
    "\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_xg[mse_xg==0]=np.nan\n",
    "mse_crossformer[mse_crossformer==0]=np.nan\n",
    "mse_mtgnn[mse_mtgnn==0]=np.nan\n",
    "mse_tsmixer[mse_tsmixer==0]=np.nan\n",
    "mse_iTransformer[mse_iTransformer==0]=np.nan\n",
    "mse_predrnn[mse_predrnn==0]=np.nan\n",
    "\n",
    "\n",
    "\n",
    "category.extend([\"XGBoost\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"MTGNN\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"CrossFormer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"TSMixer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"iTransformer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"PredRNN\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"STIMP\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "mse_list.extend([mse_xg.numpy(), mse_mtgnn.numpy(), mse_crossformer.numpy(), mse_tsmixer.numpy(), mse_iTransformer.numpy(), mse_predrnn.numpy(), mse_our.numpy()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.19658779\n",
      "0.27167673023507327\n",
      "0.24866816\n",
      "0.264343\n",
      "0.2646072\n",
      "0.26444453\n",
      "0.30153984\n"
     ]
    }
   ],
   "source": [
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_our))\n",
    "\n",
    "mae_xg = (np.abs((prediction_xg- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_xg))\n",
    "\n",
    "mae_tsmixer = (np.abs((prediction_tsmixer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_tsmixer))\n",
    "\n",
    "mae_crossformer = (np.abs((prediction_crossformer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_crossformer))\n",
    "\n",
    "mae_mtgnn = (np.abs((prediction_mtgnn - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_mtgnn))\n",
    "\n",
    "mae_iTransformer = (np.abs((prediction_iTransformer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_iTransformer))\n",
    "\n",
    "mae_predrnn = (np.abs((prediction_predrnn - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_predrnn))\n",
    "\n",
    "\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_xg[mae_xg==0]=np.nan\n",
    "mae_crossformer[mae_crossformer==0]=np.nan\n",
    "mae_mtgnn[mae_mtgnn==0]=np.nan\n",
    "mae_tsmixer[mae_tsmixer==0]=np.nan\n",
    "mae_iTransformer[mae_iTransformer==0]=np.nan\n",
    "mae_predrnn[mae_predrnn==0]=np.nan\n",
    "\n",
    "mae_list.extend([mae_xg.numpy(), mae_mtgnn.numpy(), mae_crossformer.numpy(), mae_tsmixer.numpy(), mae_iTransformer.numpy(), mae_predrnn.numpy(), mae_our.numpy()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**prediction three years**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_dir = \"./log/prediction_46_138/{}/\".format(config.area)\n",
    "prediction_xg = np.load(base_dir+\"XGBoost/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_mtgnn = np.load(base_dir+\"MTGNN/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_tsmixer = np.load(base_dir+\"TSMixer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_crossformer = np.load(base_dir+\"CrossFormer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_iTransformer = np.load(base_dir+\"iTransformer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_predrnn = np.load(base_dir+\"PredRNN/without_imputation/prediction_0.npy\", allow_pickle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.out_len = 138\n",
    "test_dloader = DataLoader(PRE8dDataset(config, mode='test'), config.batch_size, shuffle=False)\n",
    "\n",
    "labels_list = []\n",
    "label_masks_list = []\n",
    "\n",
    "for test_step, (datas, data_ob_masks, data_gt_masks, labels, label_masks) in enumerate(test_dloader):\n",
    "    labels_list.append(labels[:,:,0])\n",
    "    label_masks_list.append(label_masks[:,:,0])\n",
    "\n",
    "labels = torch.cat(labels_list, 0)\n",
    "label_masks = torch.cat(label_masks_list, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_xg = torch.from_numpy(prediction_xg).squeeze()\n",
    "prediction_tsmixer = torch.from_numpy(prediction_tsmixer).squeeze()\n",
    "prediction_mtgnn = torch.from_numpy(prediction_mtgnn).squeeze()\n",
    "prediction_crossformer = torch.from_numpy(prediction_crossformer).squeeze()\n",
    "prediction_iTransformer = torch.from_numpy(prediction_iTransformer).squeeze()\n",
    "prediction_predrnn = torch.from_numpy(prediction_predrnn).squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.07380061\n",
      "0.13843044051074507\n",
      "0.11512862\n",
      "0.12692781\n",
      "0.12384769\n",
      "0.124013625\n",
      "0.18747018\n"
     ]
    }
   ],
   "source": [
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_our))\n",
    "\n",
    "mse_xg = (((prediction_xg- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_xg))\n",
    "\n",
    "mse_tsmixer = (((prediction_tsmixer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_tsmixer))\n",
    "\n",
    "mse_crossformer = (((prediction_crossformer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_crossformer))\n",
    "\n",
    "mse_mtgnn = (((prediction_mtgnn - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_mtgnn))\n",
    "\n",
    "mse_iTransformer = (((prediction_iTransformer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_iTransformer))\n",
    "\n",
    "mse_predrnn = (((prediction_predrnn - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_predrnn))\n",
    "\n",
    "\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_xg[mse_xg==0]=np.nan\n",
    "mse_crossformer[mse_crossformer==0]=np.nan\n",
    "mse_mtgnn[mse_mtgnn==0]=np.nan\n",
    "mse_tsmixer[mse_tsmixer==0]=np.nan\n",
    "mse_iTransformer[mse_iTransformer==0]=np.nan\n",
    "mse_predrnn[mse_predrnn==0]=np.nan\n",
    "\n",
    "\n",
    "category.extend([\"XGBoost\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"MTGNN\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"CrossFormer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"TSMixer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"iTransformer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"PredRNN\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"STIMP\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "mse_list.extend([mse_xg.numpy(), mse_mtgnn.numpy(), mse_crossformer.numpy(), mse_tsmixer.numpy(), mse_iTransformer.numpy(), mse_predrnn.numpy(), mse_our.numpy()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.20259972\n",
      "0.27681470772266936\n",
      "0.25227037\n",
      "0.26827362\n",
      "0.26376665\n",
      "0.26448813\n",
      "0.32606497\n"
     ]
    }
   ],
   "source": [
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_our))\n",
    "\n",
    "mae_xg = (np.abs((prediction_xg- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_xg))\n",
    "\n",
    "mae_tsmixer = (np.abs((prediction_tsmixer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_tsmixer))\n",
    "\n",
    "mae_crossformer = (np.abs((prediction_crossformer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_crossformer))\n",
    "\n",
    "mae_mtgnn = (np.abs((prediction_mtgnn - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_mtgnn))\n",
    "\n",
    "mae_iTransformer = (np.abs((prediction_iTransformer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_iTransformer))\n",
    "\n",
    "mae_predrnn = (np.abs((prediction_predrnn - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_predrnn))\n",
    "\n",
    "\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_xg[mae_xg==0]=np.nan\n",
    "mae_crossformer[mae_crossformer==0]=np.nan\n",
    "mae_mtgnn[mae_mtgnn==0]=np.nan\n",
    "mae_tsmixer[mae_tsmixer==0]=np.nan\n",
    "mae_iTransformer[mae_iTransformer==0]=np.nan\n",
    "mae_predrnn[mae_predrnn==0]=np.nan\n",
    "\n",
    "mae_list.extend([mae_xg.numpy(), mae_mtgnn.numpy(), mae_crossformer.numpy(), mae_tsmixer.numpy(), mae_iTransformer.numpy(), mae_predrnn.numpy(), mae_our.numpy()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(62.853375, 0.5, 'MSE')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHqCAYAAACJGANcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8WgzjOAAAACXBIWXMAAA9hAAAPYQGoP6dpAACgpUlEQVR4nOzdd1xTVxsH8F8SguwlCIi4EReIKCKK29aBda+24m6dHbbW8dZura1ttRVn3bVaN2rVqnVX3BPFvUBQQWTLTHLfPyKRGEYQQkL4fT8vH7jnnHvvk/gWnpx7hkgQBAFEREREVO6J9R0AEREREZUOJnZERERERoKJHREREZGRYGJHREREZCSY2BEREREZCSZ2REREREaCiR0RERGRkWBiR0RERGQkmNiVoZs3b+LmzZv6DoOIiIiMlIm+A6hIsrOz9R0CERERGTH22BEREREZCSZ2REREREaCiR0RERGRkWBiR0RERGQkmNgRERERGQkmdkRERERGgokdERERkZFgYkdERERkJJjYERERERkJJnZERERERoKJHREREZGRYGJHREREZCRM9B0AEREZB0EQ8Pj2Tdw9dwqZz9NgZmmFOs1bwtXDEyKRSN/hEVUITOyIiKjE4h9GYu+iXxF777Za+ZkdW+Bc2wNdx38MR/caeoqOqOLgo1giIiqR+IeR2PDVFI2kLlfsvdvY8NUUxD+MLOPIiCoeJnZERPTaBEHA3kW/Iuv580LbZT1/jn2Lf4UgCGUUGVHFxMSOiIhe2+PbNwvsqXvVk7u38eTOLR1HRFSxMbEjIqLXdvfcqWK1v3P2pI4iISKAiR0REZVA8tO4YrXPfJ6mo0iICOCsWCIieg052Vk4u2MLbp06XqzzzCytdBQREQFM7IiIqJjuXzyHQ6uWIin2cbHPresXoIOIiCgXEzsiItJKSvxTHFmzDLfPnHit813qeMClbr1SjoqI8mJiR0REhZLLZLiwZwdObvkLOVmZGvXVvXzw5M4tZGekF3iNSpaW6DLuY+5AQaRjTOyIiKhA0deu4sCKRXgWHaVRZ+fsio4jxqBW0+YF7jwBKHvquozjzhNEZUEkcLXIMnPlyhUAgJeXl54jISIq3POkRBz7cyWu/XdYo04ilaJFr/5o0WsATExNVeWCIODJnVu4c/akaq/Yun4BcKlbjz11RGWEPXZERKSiUMgR/u9eHN/wB7LSNXeTqNnEFx1HjoW9S1WNOpFIBFcPT7h6eJZFqESUDyZ2REQEAHhy5xYOrFiE2Ht3NOqsHCqjw/D34dGiFXvfiAwYEzsiogouMy0NxzesweUDe4FXRueIJRL4du+FgP5vw9TMXE8REpG2mNgREVVQgiDg2rFDOPrnSmSkJGvUu9VvhM6jxsGxes2yD46IXgsTOyKiCig+6gEOrFiMmBsRGnXmNrZoN2QkGrbtyMeuROUMEzsiogokOzMDJ7f8hfO7t0NQKNQrRSI06dwNgYOHwsyKW38RlUdM7IiIKgBBEHD7dBgOr1mGtIRnGvXOtT3QedQ47gxBVM4xsSMiMnKJj2NwaNVSPLh8QaOukoUlAt8eBu/OXSAWS/QQHRGVJiZ2RERGKic7C2e2b8HZHZshl8k06hu27Yi2746ApZ29HqIjIl1gYkdEZITuXzyHg6uWIDn2iUZd5WrV0XnUeFRr2FgPkRGRLhl0YhceHo6QkBBcvHgRMpkM9erVw/Dhw9G9e3etzo+KisKOHTsQERGBiIgIxMXFwc3NDYcOHSrwHJlMhu3bt2Pz5s2IjIxEVlYWXF1d0b59e4wYMQJOTk6l9fKIiEpdSvxTHFmzDLfPnNCok1YyQ8CAd+DbrSckJgb965+IXpPB/pd96tQpjB49GqampggKCoKlpSX279+PSZMm4cmTJxg5cmSR1zh37hwWLFgAiUSCOnXqID4+vshzJk2ahP3796NGjRoICgqCqakpLl26hBUrVmDnzp0IDQ1lckdEBkcuk+H87u04ufUvyLKyNOo9/Fuh/dD3YOPI319ExkwkCK8sM24AZDIZunXrhidPnmDTpk1o0KABACA1NRX9+/dHTEwM9u3bBzc3t0Kv8/DhQzx79gz169eHmZkZvLy84OTkVGCPXXh4OAYMGABvb2+sX78eUqlUVTdz5kysXbsWH3zwASZOnPhar+vKlSsAAC8vr9c6n4goPw+vXcHBFYvxLDpKo87O2RUdR45FLZ9meoiMiMqaWN8B5OfUqVOIiopCjx49VEkdAFhbW2Ps2LHIyclBaGhokddxd3eHj48PzMzMtLrvw4cPAQCtWrVSS+oAoEOHDgCAxMREbV8GEZFOPU9KxD8LfsGmb6ZrJHUSqRQB/d/BsJ8XMqkjqkAM8lHsmTNnAACBgYEadbllZ8+eLfX71q1bFwBw4sQJTJw4US25O3z4MAAgICCg1O9LRFQcCoUc4f/uxfENfyAr/blGfU2fZug4YgzsXarqIToi0ieDTOwePHgAAKhRo4ZGnZOTEywsLBAZGVnq9/X09MTQoUPxxx9/ICgoCG3btoVUKsWlS5cQERGBDz74AJ07dy71+xIRaevxnZs4uGIxYu/d0aizquyIjsPeR90WAdwKjKiCMsjELi0tDYDy0Wt+rKyskJqaqpN7f/7556hWrRp++uknrF27VlXeoUMHvPnmmyW+viAISE9PL/F1iKhiyXqehlNb/8K1IweAV4ZGiyUSeL8ZhOY9+0NqZoaMjAw9RUkAYGFhoe8QqAIzyMROXxQKBb766ivs2rULM2bMQKdOnWBubo7z589j1qxZGDRoENasWQNvb+/XvkdOTg6uX79eilETkTETBAFPrl7CvaP/Iiefx6621WrA440gWDk54879+3qIkF7VrBnHNJL+GGRiZ/Vi8+mCeuXS0tJga2tb6vfdunUrNm3ahM8//xyDBw9Wlbdr1w7Ozs7o1asX5s2bh1WrVr32PaRSqWosHxFRYZ49jMKxtcvx5PYNjTozaxu0GjwU9QLa8LErEakYZGJXs2ZNAEBkZCQaN1ZfGf3p06dIT08vUa9ZQY4dOwYA8Pf316irX78+bG1tce3atRLdQyQSsZueiAqVnZGOE1v+woU9OyAoFOqVIhGavNEdgYOCYfbiQzARUS6DXO7Ez88PAHD8+HGNutyy3DalKScnBwCQkJCgUZednY3nz5/D1NS01O9LRAQoH7vePHkcqz4Zh/O7QjWSOufaHnh31lx0HjWOSR0R5csgE7uAgAC4u7tj165dauPRUlNTsWTJEkilUvTu3VtVHhcXh7t375Z4QoWvry8AYOnSpcjOzlarCwkJgUwmy7c3j4iopBIfx2Dr919i168/IC3hmVpdJUtLdB49Hu/M+hkudTz0FCERlQcGufMEUPCWYjExMZg6daralmLTpk1DaGgoZs+ejb59+6rKExISMGfOHNXxjh07YGZmhi5duqjKpkyZAgcHBwDKsXsDBgzAvXv34ObmhjZt2sDMzAwXLlxAeHg4HBwcsGnTJri7u7/Wa+LOE0T0qpzsLJzZvgVnd2yGXCbTqG/UrhPavjsCFrZ2ZR8cEZU7BjnGDgBatmyJ9evXY/78+dizZw9kMhnq1auHyZMno3v37lpdIz09XWOHilfLJk6cqErsrKyssGnTJixbtgwHDx5EaGgoFAoFnJ2dMXjwYIwbNw4uLi6l9yKJqEK7d/EsDq1aiuTYJxp1latVR+dR41GtYeN8ziQiyp/B9tgZI/bYEREApMTH4fDqZbhz9qRGnbSSGQIGvAPfbj0hMTHYz95EZKD4W4OIqIzIZTk4v3sHTm79C7KsLI36ev6t0X7Ye7Cu7KiH6IjIGDCxIyIqAw+vXcHBFYvxLDpKo87O2RUdR45FLR8ubEtEJcPEjohIh54nJeLonytx/b/DGnUSqRQteg1Ai179YcKllIioFDCxIyLSAYVCjsv//oOwDWuRlc9WYDV9mqHTiLGwc3HVQ3REZKyY2BERlbLHd27iwPJFiLt/V6POqrIjOg57H3VbBHArMCIqdUzsiIhKSUZaKo7/tQbhB/cBryw4IJZI4Nu9FwL6vw1TM3M9RUhExo6JHRFRCQkKBSKOHcKxP1ciIzVFo75ag8boNGocHN1r6CE6IqpImNgREZXA06gHOLhiEWJuXNOos7C1Q7shI9GgTQc+diWiMsHEjojoNWRnpOPE5vW48M9OCAqFeqVIhCZvdEfgoGCYWVnpJ0AiqpCY2BERFYMgCLh1KgxH1vyOtMQEjXrn2h7oPHo8XOp46CE6IqromNgREWkp8XEMDq5cgsjwixp1lSwt0ebtYfDq1AVisUQP0RERMbEjIipSTnYWzmzfjLM7tkAuk2nUN2rXCW3fHQELW7uyD46IKA8mdkREhbh38SwOrVyC5LhYjTpH9xroNGocqjVorIfIiIg0MbEjIspHSnwcDq9ehjtnT2rUSSuZodWAd9C0W09ITPhrlIgMB38jERHlIZfl4PzuHTi59S/IsrI06uv5t0b7Ye/BurKjHqIjIiocEzsiohceRoTjwIrFSIh5qFFn5+KKTiPGoqZPMz1ERkSkHSZ2RFThPU9KxNE/V+L6f4c16iRSKfx7D4Rfz34wMTXVQ3RERNpjYkdEFZZCIcfl/XsQtvFPZKU/16iv6dMMnUaMhZ2Lqx6iIyIqPiZ2RFQhPb5zEweWL0Lc/bsadVaVHdFx2Puo2yKAW4ERUbnCxI6IKpSMtFQc/2sNwg/uAwRBrU4skaBZUG+07DcYpmbmeoqQiOj1MbEjogpBUCgQcfQgjq1bhYzUFI36ag0ao9OocXB0r6GH6IiISgcTOyIyek8j7+PAisV4dPOaRp2FrR3aDRmJBm068LErEZV7TOyIyGhlZ6TjxOb1uPDPTggKhXqlSASfN7uj9aBgmFla6SdAIqJSxsSOiIyOIAi4dSoMR9b8jrTEBI16lzoe6Dx6Apxr19VDdEREusPEjoiMSsKjGBxatQSR4Rc16ipZWqLN28Pg1akLxGKJHqIjItItJnZEZBRysrNwZvtmnN2xBXKZTKO+UbvOaPvucFjY2pV9cEREZYSJHRGVe/cunsWhlUuQHBerUefoXgOdRo1DtQaN9RAZEVHZYmJHROVWSnwcDq/+HXfOntKok5qZo1X/t9G0W09ITPirjogqBv62I6JyRy7LwfndO3By61+QZWVp1NdrGYj2Q0fDurKjHqIjItIfJnZEVK48jAjHgRWLkRDzUKPOzsUVnUaMRU2fZnqIjIhI/5jYEVG58DwpEUfXrsD140c06iRSKfx7D4Rfz34wMTUt++CIiAwEEzsiMmgKhRyX9+/B8Q1rkZ2RrlFfy6cZOo4YCzsXVz1ER0RkWJjYEZHBenz7Jg4sX4S4B3c16qwrO6HD8PdQ1y+AW4EREb3AxI6IDE5GWiqOr1+D8EP7AEFQqxNLJGgW1Bst+w2GqZm5niIkIjJMTOyIyGAICgUijh7EsXWrkJGaolFfrWFjdBo5Do7uNfQQHRGR4WNiR0QG4WnkfRxYsRiPbl7TqLOwtUO74FFoENiej12JiArBxI6I9Co7Ix0nNq/DhX/+hqBQqFeKRPB5sztaDwqGmaWVfgIkIipHmNgRkV4IgoBbp47jyJplSEtM0Kh3qeOBzqMnwLl2XT1ER0RUPjGxI6JSJwgCHt++ibvnTiHzeRrMLK1Qp3lLuHp4QiQSIeFRDA6tWoLI8Isa55pZWiHw7WHw6vQmxGKJHqInIiq/mNgRUamKfxiJvYt+Rey922rlZ3ZsQZVadeBSxwMRRw5ALpNpnNuoXWe0fXc4LGztyihaIiLjwsSOiEpN/MNIbPhqCrKeP8+3Pu7+XcTd11yTztG9BjqNHo9q9RvpOkQiIqPGxI6ISoUgCNi76NcCk7r8SM3M0WrAO2ja9S1ITPjriIiopPiblIhKxePbNzUevxbGvVETdJswCdaVHXUYFRFRxSLWdwBEZBzunjtVrPaudT2Y1BERlTImdkRUKjKfp+m0PRERFY2JHRGViuIuIMwFh4mISh8TOyIqFXWatyxW+7p+ATqKhIio4mJiR0SlwtXDE861PbRq61LHAy516+k4IiKiisegZ8WGh4cjJCQEFy9ehEwmQ7169TB8+HB0795dq/OjoqKwY8cOREREICIiAnFxcXBzc8OhQ4cKPU+hUGDbtm3YunUrbt++jZycHLi4uMDX1xeff/45rKz4CInoVSKRCM2698SeBb8U2q6SpSW6jPsYIpGojCIjIqo4DDaxO3XqFEaPHg1TU1MEBQXB0tIS+/fvx6RJk/DkyROMHDmyyGucO3cOCxYsgEQiQZ06dRAfH1/kOdnZ2fjwww9x+PBheHp6ok+fPjA1NcXjx49x9OhRfPTRR0zsiApw5fC/hda71PFAl3Efw9G9RhlFRERUsYgEQRD0HcSrZDIZunXrhidPnmDTpk1o0KABACA1NRX9+/dHTEwM9u3bBzc3t0Kv8/DhQzx79gz169eHmZkZvLy84OTkVGiP3ffff481a9bg008/xfvvv69Wp1AoAABi8es9wb5y5QoAwMvL67XOJzJkUVcvY/N3n6uOK1lYoHGHN5GTlQkzSyvU9QuAS9167KkjItIhg+yxO3XqFKKiotC3b19VUgcA1tbWGDt2LKZNm4bQ0FBMnDix0Ou4u7vD3d1d6/vGxsZi3bp1aN68uUZSB7x+Qkdk7ARBwPENf6iVtew7GM3f6quniIiIKiaDTOzOnDkDAAgMDNSoyy07e/Zsqd937969kMlk6Nq1K9LS0nDo0CE8fvwYlStXRps2beDs7Fzq9yQyBvcvnsPj2zdVx1b2DmjSJUiPERERVUwGmdg9ePAAAFCjhuY4HCcnJ1hYWCAyMrLU7xsREQEASElJQdeuXfH06VNVnVQqxeTJkzF8+PBSvy9ReSYoFDi+ca1amX/fwZCaVtJTREREFZdBJnZpacoV6a2trfOtt7KyQmpqaqnf99mzZwCAhQsXolWrVli9ejVcXFxw7tw5fPHFF5g9ezZq1aqFdu3avfY9BEFAenp6aYVMpHd3z57E0wf3VMfWjk6o0zKQ/z+nCsvCwkLfIVAFZpCJnb7kziNxcHBASEgIzM3NAQDt27fHzJkz8f7772PVqlUlSuxycnJw/fr1UomXSN8EhQJnN6j31lX1a41bt2/rKSIi/WvWrJm+Q6AKzCATu9zlRArqlUtLS4Otra3O7tuqVStVUperTZs2MDU1xdWrV0t0D6lUirp165boGkSG4mbYUaQnvFxGyM6lKtr3GwSxRKLHqIiIKi6DTOxq1qwJAIiMjETjxo3V6p4+fYr09HR4e3uX+n1r1aoFALCxsdGoE4vFsLS0VD0mfl0ikYjd9GQU5LIcnN+5Ra2s9aAhsCpgCAUREemeQa7f4efnBwA4fvy4Rl1uWW6b0tSypXKvyzt37mjUJSQkIDExsci184gqiquHDyA5LlZ17FSjFjxbas5kJyKismOQiV1AQADc3d2xa9cutfFoqampWLJkCaRSKXr37q0qj4uLw927d0s8oaJFixaoU6cOTp48ibCwMFW5IAiYO3cuAKBbt24lugeRMZBlZ+PUtg1qZa0HDYGIaz0SEemVQe48ARS8pVhMTAymTp2qtqVY7oLFs2fPRt++LxdETUhIwJw5c1THO3bsgJmZGbp06aIqmzJlChwcHFTHly9fxrBhw5CTk4M33ngDLi4uOH/+PMLDw9GoUSP8+eefr/0olTtPkLE4v3s7jvyxXHXsUrce3pn5C3eVICLSM4McYwcoH4uuX78e8+fPx549eyCTyVCvXj1MnjwZ3bt31+oa6enpCA0NLbRs4sSJaoldkyZNsHnzZoSEhODkyZN4/vw5XF1dMWbMGIwZM4bj46jCy87MwOntm9XKAgcNZVJHRGQADLbHzhixx46MwenQTWrbh7k39MKAL79nYkdEZAA4IIaItJb5PA1n/96qVtZ6UDCTOiIiA8HEjoi0dn5XKLKeP1cd1/JpBrf6DfUYERER5cXEjoi0kp6SjPN7dqqVtR4UrKdoiIgoP0zsiEgrZ7ZvRk5mhurYo0UrONfmLipERIaEiR0RFSk1IR6X9+95WSASodXAd/UXEBER5YuJHREV6fS2TZDlZKuOGwS2h6N7DT1GRERE+WFiR0SFSo57giuH9qmORWIxAvq/rceIiIioIEzsiKhQJ7dsgEIuVx037vAG7F2q6jEiIiIqCBM7IirQs5iHuHbskOpYYmKCln0H6zEiIiIqDBM7IirQic3rIQgK1bH3G91g4+ikx4iIiKgwTOyIKF9xD+7h1sn/VMcmlSrBv/dAPUZERERFYWJHRPkK2/Sn2rFv17dgaWevp2iIiEgbTOyISMOjWzdw7/wZ1bGpuQWa9+ynx4iIiEgbTOyISMOrvXXNe/SBuZW1nqIhIiJtMbEjIjUPI8IRdeWS6tjM2ga+3XvpLyAiItIaEzsiUhEEAcc3rFUra9GzHypZWOgpIiIiKg4mdkSk8uDSeTy6dV11bGlnD58uQXqMiIiIioOJHREBeNFbt1G9t86/7yBIK5npKSIiIiouJnZEBAC4feYE4u7fVR1bOzrBq2MXPUZERETFxcSOiKBQyHFi0zq1soD+b8NEKtVTRERE9DqY2BERboQdw7PoKNWxvWtVNGrbSY8RERHR62BiR1TByWUynNj8Sm/dgHchlkj0FBEREb0uJnZEFVzE0QNIjn2iOnasXhP1A9roMSIiInpdTOyIKjBZdjZObt2gVtZ64BCIxPzVQERUHvG3N1EFFn7gH6Q9i1cdu9TxQJ3m/nqMiIiISoKJHVEFlZOZidPbN6uVtR4UDJFIpKeIiIiopJjYEVVQF/b+jfTkJNVxtQaNUcO7qf4CIiKiEmNiR1QBZT5Pw7mdW9XKWg8awt46IqJyjokdUQV0fvcOZD5PUx3XbOKLag0a6zEiIiIqDUzsiCqY9JRknN+9Xa2s9aBg/QRDRESliokdUQVzdudW5GRmqI7r+rWESx0PPUZERESlhYkdUQWSlpiAS3t3vSwQidB64BD9BURERKWKiR1RBXI6dCNkOdmq4/qt2sKxek39BURERKWKiR1RBZEcF4vwA/tUxyKxGK0GvKPHiIioIgsJCYGnpycSEhJ0fq+OHTti2rRpOr+PIWBiR1RBnNq2AQq5THXcqF1n2Lu66TEiIqoIlixZggMHDug7jAqDiR1RBZDwKAYRRw+qjsUSEwT0G6zHiIiooli6dCkTuzLExI6oAjixeR0EhUJ17N25K2ycqugxIiIi0gUmdkRG7mnkfdw8cUx1bGJaCf59BuoxIiIyBLlj3O7fv4/JkyejWbNmaNmyJX799VcIgoDHjx9j3Lhx8PX1RevWrbFy5Uq187OzszF//ny88cYbaNy4Mdq1a4c5c+YgO/vlBC1PT0+kp6cjNDQUnp6e8PT01BjrlpqaimnTpqF58+Zo1qwZpk+fjoyMDLU2MpkMCxcuROfOndG4cWN07NgRc+fOVbsXAAiCgEWLFqFt27Zo0qQJgoODcfv2bY3XnpOTgwULFuDNN9+El5cX/P398fbbbyMsLKykb6vemeg7ACLSrbBN69SOfboEwcreQU/REJGhmTRpEurUqYNPP/0UR48exeLFi2FnZ4cNGzagZcuWmDx5Mv7++2/8+OOP8PLygp+fHxQKBcaNG4fz589j4MCBqFOnDm7duoU1a9bgwYMHWLRoEQBgzpw5mDFjBry9vTFwoPIDZfXq1dXu//HHH6NatWr45JNPcO3aNWzevBkODg747LPPVG1mzJiB0NBQdOnSBSNGjEB4eDiWLl2Ku3fvYuHChap2v/32GxYvXox27dqhXbt2iIiIwMiRI5GTk6N2zwULFmDp0qUYMGAAvL29kZaWhqtXryIiIgKtW7fW1VtdJpjYERmxx3du4u65U6pjU3NztOjVX48REZGh8fb2xrfffgsAGDRoEDp27IgffvgBn3zyCd5//30AQI8ePdCmTRts3boVfn5++Pvvv3HixAmsXbsWzZs3V13Lw8MDX331FS5cuABfX1/06tULX3/9Ndzd3dGrV69879+gQQN8//33quOkpCRs2bJFldjduHEDoaGhGDBgAGbOnAkAePfdd+Hg4ICVK1fi1KlTaNmyJRISErB8+XK0b98eS5YsUe19PW/ePCxZskTtnkeOHEG7du3w3XffldK7aDj4KJbIiIVt/FPtuFlQb5hb2+gpGiIyRP37v/ywJ5FI0LhxYwiCoFZuY2ODWrVq4eHDhwCAvXv3ok6dOqhduzYSEhJUXy1btgQAnD59Wuv7Dx6sPpGrefPmSEpKQlqacj/ro0ePAgBGjBih1m7kyJFq9SdOnEBOTg6GDBmiSuoAYNiwYRr3tLGxwe3bt/HgwQOt4ywv2GNHZKSir11FZPhF1bGZpRWaBfXWX0BEZJCqVq2qdmxtbY1KlSrBwcFBozwpKQkAEBkZibt37yIgICDfaz579uy1729jo/zwmZycDCsrK8TExEAsFms8wnVycoKNjQ1iYmIAAI8ePQIA1KxZU62dg4MDbG1t1co+/PBDjB8/Hl26dEG9evUQGBiIXr16oX79+lrHbaiY2BEZIUEQcHzjH2plfr36o5KFpZ4iIiJDJRZrPryTSCT5thUEAQCgUChQr149TJ8+Pd92Li4uJbp/3nvlytsLV1J+fn74999/cfDgQYSFhWHLli1Ys2YNvvnmGwwYMKDU7qMPTOyIjFDk5QuIuXFNdWxha4emXXroMSIiMibVq1fHjRs3EBAQUKoJV37c3NygUCgQGRmJOnXqqMrj4+ORkpICNzflQuu5PX8PHjyAu7u7ql1CQgKSk5M1rmtnZ4d+/fqhX79+eP78OYYMGYKQkJByn9hxjB2RkVH21qmPrfPvMxBSMzM9RURExqZbt26IjY3Fpk2bNOoyMzORnp6uOrawsEBKSspr36tdu3YAgDVr1qiVr1q1Sq2+VatWkEql+PPPP9V6+149DwASExPVji0tLVG9enWN5VPKI/bYERmZO2dPIvbey3WbrCs7wbtzNz1GRETGplevXvjnn3/w1Vdf4fTp0/D19YVcLse9e/ewd+9eLF++HF5eXgCARo0a4eTJk1i1ahWqVKmCatWqoUmTJlrfq379+ujTpw82btyIlJQU+Pn54cqVKwgNDUXnzp1VEzYcHBwwcuRILF26FGPGjEG7du1w7do1HDt2DPb29mrXDAoKQosWLdCoUSPY2dnhypUr2LdvH4YMGVJ6b5KeMLEjMiIKhVxjJmzLfoNhIpXqKSIiMkZisRgLFy7E6tWrsWPHDvz7778wNzdHtWrVEBwcjFq1aqnaTps2DV9++SV+/fVXZGZmok+fPsVK7ABg5syZqFatGkJDQ3HgwAE4OjpizJgxmDhxolq7jz/+GKamptiwYQNOnz4Nb29vrFy5EmPGjFFrFxwcjEOHDiEsLAzZ2dmoWrUqPv74Y4waNer13xQDIRJeHZ1IOnPlyhUAUH2KISpt148fwZ6Qn1XHds6uGD53MSQm/AxHRFQRGPRv+/DwcISEhODixYuQyWSoV68ehg8fju7du2t1flRUFHbs2IGIiAhEREQgLi4Obm5uOHTokNYxfPXVV9iwYQMA4Pjx43Bycnqt10Kka3KZDCc2q+8y0WrAO0zqiIgqEIP9jX/q1CmMHj0apqamCAoKgqWlJfbv349JkybhyZMnqoUJC3Pu3DksWLAAEokEderUQXx8fLFiCAsLw4YNG2BhYaE2EJTIEF07dghJTx6rjitXqw7P1m31GBEREZU1g0zsZDIZvvjiC4hEIqxbtw4NGjQAAEyYMAH9+/fH3Llz0aVLF9UU54L4+flh48aNqF+/PszMzIr1CDQ1NRX/+9//0KVLFyQmJuLMmTMlek1EuiTLycHJrX+plbUeOARicf5rURERkXEyyOVOTp06haioKPTo0UOV1AHKVa/Hjh2LnJwchIaGFnkdd3d3+Pj4wOw1lnmYNWsWMjMz8dVXXxX7XKKyFn5gL1Ljn6qOnWvXRd0W+a8IT0RExssge+xye8cCAwM16nLLzp49q7P7Hzp0CKGhofjll19QuXJlnd2HqDTkZGXidOhGtbLWg4J1vmgoEREZHoNM7HI35a1Ro4ZGnZOTEywsLBAZGamTeycmJuKLL75A586d0aMHV+onw3dx7y6kJyepjqt6NkTNJr76C4gqLkEAos8BN3cDGUmAuR3gGQRUaw7wgwZRmTDIxC4tLQ2A8tFrfqysrJCamqqTe3/zzTfIycnB119/rZPrC4LAiRhUarLS03Fmxxa1Mr/eA5GRkaGniKiiEsXfhOmejyB5clm94vg8yF2aILv7bxAcPfUTXBmzsLDQdwhUgRlkYqcve/bswT///IMff/xRZ8ua5OTk4Pr16zq5NlU8D8IOI+t5murYvmYdJAsiJPP/Y1SGzFLvwzPsI0hy0vKtlzy5DOnaHrjZ+jdkWtfKt40xadasmb5DoArMIBM7KysrACiwVy4tLQ22trales+kpCR88803aN++PXr37l2q185LKpWibt26Ors+VRyZaakIO39araxD8Cg41+b/v6gMCQIqrZ1UYFKXyyQnDfVvhCAreA8fyxLpkEEmdjVr1gQAREZGonHjxmp1T58+RXp6Ory9vUv1no8fP0ZSUhKOHDkCT8/8HxfkTtzYvn272mzd4hCJROymp1Jxbvsm5GS+fORap7k/ajUu3f8uiIr08Czw6uPXAkieXIJF4nXlmDsi0gmDTOz8/PywdOlSHD9+HEFBQWp1x48fV7UpTXZ2dujfv3++dUePHsXTp0/Ro0cPmJmZwc7OrlTvTVRcz5MScfGfv9XKWg8s/5tXkwERBCA7DUiLA9JigdQnL3/O+/XsbvGue2MXE7tyZtSoUXj48CF27doFU1NTVfnVq1cxcOBA/O9//8OQIcrfP4mJiVixYgUOHTqEmJgYAMqlxwIDAzFkyBBUq1YNABAdHY1OnTqpriUSieDk5IQWLVrgk08+KXKdWl0JCQlB69at4etbfiegGWRiFxAQAHd3d+zatQtDhw5V9Y6lpqZiyZIlkEqlao9L4+LikJqaiipVqhQ44aIorq6umDVrVr51wcHBePr0KaZNm8YtxcggnA7dBFl2lurYM6ANnGoY/9glKgVyGfD8qWaClhanmbzl6GCiV0ZS6V/T2Ol5tvFXX32FHj16YMmSJfjwww8BAHK5HF9++SUaNmyId955B4DyKduwYcMgk8kQHBwMLy8viEQiREREYMOGDbh48SI2blRfmumTTz6Bv78/FAoFoqKiMH/+fLz//vvYuXMnJJKyX2B9wYIFsLCwYGJX2kxMTDBz5kyMHj0a7777rtqWYjExMZg6daoq6weAuXPnIjQ0FLNnz0bfvn1V5QkJCZgzZ47qWCaTITExEdOmTVOVTZkyBQ4ODmXzwohKQUp8HMIP/KM6FonEaDXwXT1GRHonCEBWSp7kLDaf3rUXx8/jAQj6i9XcTn/3Lo/irgPbxwGPLqqXH58HVG0K9F4MVHm9oUHaql69OsaMGYPFixejR48eqF27NtauXYsbN25gy5YtEIuVex18+umnkMlk2Lp1K5ydnVXnBwQEYOjQodi5c6fGtWvUqAEfHx8AgK+vL6ysrDBhwgTcv3+f49Ffk0EmdgDQsmVLrF+/HvPnz8eePXsgk8lQr149TJ48Gd27d9fqGunp6Ro7VLxaNnHiRCZ2VK6c2roBcplMddywXUc4VK1WyBlUbsmy8+ldyy95iwNkeljixsQMMLMD0p5of059rg+qtbjrwMouQGZy/vWPLirrR+7TeXL33nvv4e+//8bXX3+NH3/8Eb/99huGDBmChg0bAlDuzX7lyhV8+eWXakldLlNT0wKHO+VlaWkJQNkRk9eGDRuwatUqxMTEoEqVKujfvz/Gjh2rSioB4ObNm5gzZw7Onz8PiUSC1q1bY9q0aahataqqzZYtW7Bq1So8fPgQ5ubmqF27NqZPnw5vb2/V+Po5c+aoOoX++OMP+Pv7F/Pd0i+RIAh6/OhWsVy5cgUAirVnLVFeiY9jsOqTcRAUCgCAWGKCkb8uhW0VzV+kZKAEAchMyufR5xP1RC31CZCRoIcARYClI2DlAlhVAaycAWtn5ffc49y6Si+GvizroNmjlJ+qvsB7hzgrVhuCYHDv66lTpzBs2DC4ublBLpdj9+7dqlUsFi5ciPnz52P//v35bi7wqtwxdvPmzcObb74JhUKBhw8f4ssvv0RCQgJ27dqlehS7du1azJw5E8HBwWjfvj0uXryIxYsXY9iwYZg6dSoA5QTInj17wt3dHePGjUNWVhbmzZsHQRCwc+dOWFlZ4ezZsxgyZAhGjhyJdu3aITMzE+Hh4WjWrBlat26NS5cuYdCgQQgODlZtUFC3bl3VaywvDLbHjog0ndzylyqpAwCvTl2Y1BkKWVb+jz/zm3Qgzy77+Eyt8iRmVdQTt7zJm4UjICnmn4beiwvvWQIAM1ug96KKm9TF3wb2TgOe3tKuvSwLeB6rXdtHF4CfPQGTSoW3c6oHdP0BcPTQ7rqvaNmyJVq2bIlTp07h559/Vkt44uLiACjHq+cll8uRt//IxET9/1uTJk1SO65atSqWLVumSurkcjkWLlyIoKAgzJgxA4ByhYqcnBysXLkS77//Puzt7bF69WrIZDKsXLlSNcGxQYMGCAoKQmhoKIKDgxEeHg47OztVMggA7du3V/2c+0jY1dVV9XN5xMSOqJyIj3qA62FHVccmUlO07DNQjxFVAIIAZCQWMm4tFkh98T0zqezjE4kByyr59Kzl/XpRV0mHvQ5VGigfB+Y3FgxQ9ij1XqTzx4UG7Z8pwN1Duru+NklgcpQyjuDQotvm486dOzh//jxEIhHOnDmDt956q8hzevXqhdu3b6uOT548qTb8afLkyWjZsiUEQUBcXByWLVuG0aNHY+PGjXB2dsa9e/eQmJiIrl27ql23e/fuWLp0KcLDw9GuXTucO3cO/v7+aqtW1KlTB/Xr18f58+cRHByMhg0bIikpCdOmTcNbb70FX19fmJubv9Z7YciY2BGVE2Gb1ikTjReadAmClUNlPUZUCEPfMzQnQzNRS43NJ3mLAxQ5ZR9fJRv13rTcBM36lV42i8qAuOxnDuarSgPgvcNAzHnlkia5/+71ewBuzQzj351emyAI+Prrr1GjRg288847+O6779CvXz9Vz1aVKlUAALGxsXB3d1edN2/ePGRmZuLIkSNYsGCBxnXd3d3Vhif5+vqidevWWL16NaZOnYrkZGUvcOXK6r/rco9z61NSUvJdX7Zy5cqqNgEBAZgzZw7++OMPjBo1CpUqVUKXLl3wv//9z6iWMWNiR7pl6H/gy4nYe3dw5+xJ1bHUzBwtehU9EFkv9DWLT6EA0p+9Mgs0n3FraXFAViGPDHVFbPKyd+3VBO3V3jXTcrqIuUik/G+b69Rp6jYH2DsdeHpTu/aZScqZztqqZKOcyFIYJ0+g62ztr5nHtm3bcO7cOaxduxbNmzdXTaTYunUrJBKJaoLB8ePH8fbbb6vO8/BQPvbN22tXGAcHB9jb26va5yZcCQnq402fPXsGAKpdqGxtbVVlr7bL3fQAUPYg9urVCwkJCTh48CBmz54NExMTfP/991rFVx4wsSPdMYBp+sbi+Ma1asfNgnrBwqZ0t9UrFbqYxZedrp6gqXrWXk3e4gBBXnqvRVtmtgWPV8s72cDcHsgzg48qGEcPYMgW7ds/PAus6Kx9++BQnSXUiYmJmDNnDvr06aPaHODrr79G3759sXbtWgwfPhzNmzeHl5cXFi9ejE6dOql68IorPj4eiYmJsLe3BwDUqlULDg4O2Lt3L9544w1Vu3/++QdSqVS1C1WzZs2wadMmJCcnq5K9e/fu4ebNm+jXr5/GfRwcHDBgwAAcO3YM9+7dU5VLpVJkZWVptC9PmNiRbhjQNP3yLvpGBB5cOq86rmRpiWZBvfUXUEEEQZnIFzaAHlDWbx8PDP4LeB6X/6zQvI9Fs/PfM1qnJKavJGYFTDawrAJIzco+PjJ+1ZorPwBrOyvWrZnOQsld+uOzzz5TldWvXx9DhgzB/Pnz0a1bNzg7O+OXX37BsGHD0LdvXwwdOlS1QHFMTAw2bNgAU1NTSKVStWtHRkbi0qVLEAQBsbGxWLFiBUQiEQYOVI4flkgkGD9+PGbOnAkHBwe0a9cOly5dwrJlyzBs2DBVAjh8+HBs27YNI0eOVM2K/fXXX+Hq6oo+ffoAAObPn4+kpCS0aNEClStXxq1bt/Dff/9h+PDhqnhq166NgwcPonnz5jA3N0etWrXK3axYLndShirMcidlPU1fEF6MPcv7XZFP2YvyV8tU18ivrrDzhALurW0MKPI+gkKBTb+vR/T9aNXLDXyzNfzb+eU5v4D7FBpDQe21eR+Q/30SI4EzS1//37EsmDuoJ2wFTTYwt+dQAdK/oj4gA8oeYx1+QD537hyGDBmC7777DgMGDFCrS0tLQ7du3dCsWTP8+uuvAJSPTPNuKSYSiVRbir377ruq8XevbikGAPb29qhfvz4mTJigsW3oX3/9hdWrVyMmJgZOTk4YMGCAxjp2N27cwJw5c3DhwgWIxWLVOna525MdPnwYa9aswc2bN5GWlgYXFxf07NkT48aNU83WPXfuHL7//nvcvXsXmZmZXMeOCldhErviPkIwtQJEEhQ/0VAUdlWj8CDNDlsfvvz/i4UkG6PrnoVUbPyvXWuSSgUnaHnHslk6Fb0cBJGhKWhIC8DZxpQvPoql0ndzd/HaZ6fpJo5yThCAsKc11cpaOD6sOEmdhWMB49VeSd7MbNm7RsaLs42pmJjYUenjJt+l4m6aA55kWquOrUyy0MTusR4jKmWV6wK1O+SfvFk6ARJp0dcgqgg425iKgYkdlb7ibvJt4ah8ZAYRIMKL7yLl4qu5P6t9F+dT9uJTa0F1BV6rgLLC7qO6FrSMK786FBqXABFObA0HkK56mwJaN4ZJ4zcLeR1FvV8oxnuSX10R72/8HeDAl9r/u/dZyj9URESlrFiJ3fTp09GsWbN8N/I9ePAgqlatmu8CgfPnz8eRI0ewbdu214+Uyg/PIOWSJtp6ZyP/wL/iZthRPH12SnVs6+yCRu//BJgY8GcxQQCuhRrELD4iooqqWIsqhYaG4vz58/nWTZgwAX/88Ue+dY8fP8b169eLHx2VT7nT9LXBP/AaFHI5Tmxer1bWqv87kBhyUgcoe+56L1aOeStMRd8zlIhIh7haJpU+/oEvkWvHDiHxcYzq2MHNHfUD2+kxomLI3TO0oMS+qi/XLiQi0iED7wKgcoubgr8WWU4OTm79S62s9cB3ITaU/UC1wVl8RER6w8SOdId/4Ivt6qH9SHkapzquUrMOPFq00mNEr4mz+IiI9IKJHekW/8BrLScrE6dCN6qVtR48BCLuL0pERFriXwwiA3Fp/x48T0xQHbvWq49aPkyIiYhIe0zsiAxAdkY6zuzYolYWOGgoRHxcTUR6FhISAk9PT7Rp0wYKhebON4MHD4anpyemTZuGjh07wtPTs9CvkJAQ1bmJiYn4+eef0b17dzRp0gRNmjRBjx498MMPPyA6+uUe2dHR0fD09ETDhg3x4MEDtftfv34dnp6eOH36tKosODgYnp6e+O233zTi7dWrF6ZNm1YK74xhKvaj2AsXLmD69OnFqitoiRQiUjq/ZwcyU1NUx9UbN0H1xt56jIiIDIUgCIi9n4L7l+ORlZ6DShZS1GriCOdaNmX24U8qlSIxMRFnz56Fv7+/qjwmJgaXLl2ChYUFAGDBggXIzs5W1U+cOBG+vr4YOXKkqszFxQUAEBkZiWHDhkEmkyE4OBheXl4QiUSIiIjAhg0bcPHiRWzcqD48RS6XY8mSJfjhhx+0invt2rUYOXIkrK2ti25sJIqd2EVFRSEyMjLfusjISI06kUgEQRDY80BUgIy0VJz7O1StrPWgYD1FQ0SG5NmjNBxacx1xkalq5Rf2RaJKDWt0HNYAlata6TwOqVSKgIAA7N69Wy2x2717Nzw8PCB+MRa4YcOGaueZmprC0dERPj4+Gtf89NNPIZPJsHXrVjg7O6vKAwICMHToUOzcuVPjHH9/f/z999+YMGEC3N3dC43Z29sbd+7cwR9//IEJEyYU5+WWa8VK7Pr06aOrOIgqrHN/b0N2xsutw2r7+qFqvfp6jIiIDMGzR2kI/fkCstJl+dbHRaYi9OcL6DPZt0ySux49euCbb77BF198AalUuZfzrl270KNHD+zZs6dY1zp37hyuXLmCL7/8Ui2py2VqaprvLlf9+/fH/fv3sXTpUsycObPQezg4OGDw4MH4448/MGzYMFhZ6f49MgTFSuxmz56tqziIKqTnSYm48I/6p1L21hGRIAg4tOZ6gUldrqx0GQ6tuY7+05rr/MlYhw4d8PnnnyMsLAzt27fHnTt3cPPmTSxcuLDYiV3ueLjAwMBinWdqaorRo0fjp59+wvjx41G1atVC248cORLr1q3DunXrMGbMmGLdq7zicidEenRm+2bIsrJUx/VaBqJKzdp6jIiIdCHxyXMc33wbiY/Ti24MQC5TID0lu+iGUPbcrZ4aBolJ4fMh7V0tEDjAA/Yullpd91Xm5ubo2LEjdu/ejfbt22PXrl1o2rRpkY9E8405Trlep6urq1q5XC6HIAiqY5N8tlIcNGgQfv/9d/z+++/4+uuvC72Pk5MTBg4ciFWrViE4OFg1FtCYcVYskZ6kxD/F5X9ffsoVicRoNeBdPUZERLry36bbiIpIQGpCplZf2iZ1udJTsou8ZlREAv7bdLtEr6NHjx44ePAgMjMzsWfPHgQFBZXoeq/q1asXGjVqpPpKSEjQaGNmZoYRI0Zg69atiI2NLfKao0ePRlpaGv76668i2xqDYiV2giAgIyNDbcZLXmlpafjuu+/Qrl07eHt7480338Rvv/2GrDw9EkSkdHrbRshlLx+zNGjTHpWrFf+TLxFRWQkMDIRUKsVvv/2G6OhodOvW7bWuU6VKFQDQSMzmzZuHLVu2YOLEiYWe//bbb8PCwgLLli0r8l4uLi7o27cvVq5ciczMzNeKtzwpVmK3fft2+Pr6Yv78+Rp1WVlZGDJkCNavX4/Y2FhkZ2cjKioKS5Yswfjx40stYCJjkPTkMa4e+Vd1LJZIEND/HT1GRES61GagB6o3qgxrBzOtvkzNirc/tKmZpMhrVm9UGW0GepTodUilUrz55ptYvXo1WrZsCUdHx9e6Tu7M2uPHj6uVe3h4wMvLC25uboWeb2lpiREjRmDz5s14+vRpkfcbM2YMkpOTNZZPMUbFGmN34cIFAEC/fv006v744w/cuHEDYrEYQ4YMQWBgIGJiYrBw4UKcOHEC+/btQ5cuXUonaqJy7uSW9VDI5apjr45vws7ZRY8REZWcIAi4+DAJ/16LRXJGDmzNpXijoTOauttV+CWv7F0s8dYHTbRu/+ReMrbO0X4N2Lc+8oFLLdvXCa3YBgwYgGfPnmHgwIGvfY3mzZvDy8sLixcvRqdOnVQ9eMUxZMgQrFixAitWrCiyrZubG3r27Inly5cb/ezYYiV2V69ehZubG2rVqqVRt3XrVohEIrzzzjv4/PPPVeV16tTBsGHDsGvXLiZ2RACeRUfh2vEjqmOJVAr/PoP0FxBRKbgVm4rJmy8jPDpZrXzxkbvwrmaLnwc0QT3nirNIbEk517JBlRrWGuvX5adKDWs417Qpg6iUvL29sWjRohJf55dffsGwYcPQt29fDB06VLVAcUxMDDZs2ABTU1PVsir5sbKywtChQ7FgwQKt7jdmzBhs374dcXFxaNJE+yS7vCnWo9j4+HjUq1dPozw2Nla1xcc776g/TvL390ft2rURERHx+lESGZGwTX8CeWZ9+bzZHdaVX+9xBpEhuBWbiv6LT2gkdbnCo5PRf/EJ3IotOkkhJZFIhI7DGqCSReH9L5UsTNBxWINy2SNao0YNbNu2Db169UJoaCjGjBmDMWPGYNWqVWjWrBn27NlT5I4RQ4cO1boHrkaNGqU+2cMQiYS884qL0LhxY3Tt2hU///yzWvmBAwcwceJEuLi44MiRIxrnjR8/HidOnMClS5dKGm+5duXKFQCAl5eXniMhfYm9dwd/Tv9YdSytZIbRIcthYWunt5iISkIQBPRaGFZgUpdXk2q22D6hdblMQvSloJ0nAJTpzhNUfhTrUaypqSmePXumUX716lUAmluJ5DI3N3+N0IiMT9imP9WOfbv3ZFJHBiczR46UjBwkF/GVkpGDmMQMXH+iXU/c5ehkXHqYhKbV7XX8CoxH5apW6D+tOWIfpOD+pTx7xfo4wrlm2e0VS+VHsRK76tWrIzw8HM+fP4el5csFDsPCwiASifLdCw5QPsKtXLlyiQIlKu9ibl7H/YvnVMeVLCzRvEdfPUZExqw4ydmrZZk5Cp3Ftf9aLBO7YhKJRHCpZVtmkyOofCtWYhcYGIjly5fjm2++wbfffgszMzNs374dV65cgUgkQqdOnTTOUSgUuHbtWr5j84gqkrCNa9WOm7/VF2ZGPjuLSuZ1k7Ok9BxkyXSXnJVEckaOvkMgMmrFSuyGDRuGTZs24e+//8aePXtgaWmJlJQUiEQitG3bFnXq1NE459SpU0hNTYWvr2+pBU1U3kReuYSHEeGqY3NrG/h2e0uPEemWIAiIvZ+C+5fzPDpq4gjnWhXv0dHrJGdJ6crvhpqclYStecGzHImo5IqV2Dk5OWHJkiX4+OOPERcXh+Rk5WDZhg0bYtasWfmes27dOgBAQEBACUOl8kgQBITHh+Nw1GGkZKfAxtQGHap3gLejd4X5Ay8IAsI2qPfWteg9AKbmxrln4bNHaTiwOgJHkq7geuUryDZJh6nMAg1OeqG9nRc6D29U7gZ7Fzc5y03MyktyJhIB1pVMYGshha25+peNuRR25qYa5blfd+JS0W/JSa3v9WZDZx2+EiIq1qzYXNnZ2Th//jyePXsGV1dX+Pr6FvhH+tChQ1AoFGjbti1MTU1LHHB5VtFmxd5JvIMZYTMQ8UxzqZtGlRthZuuZqGtfVw+Rla27589g+5xvVcdW9g4YOX8ZpKaV9BiVbjx7lIY5C3Zir/taKCyiNerF6dXQ9WEwpkzsWebJXXGSs7yJmTEkZ7aFJGa25lJYm5lALH69D1rqs2IFiM0ewsT6GkSSDAhyc8hSG0KR6Q5AxFmxRGXgtRI7ej0VKbG7k3gHQ/YMxXNZwbPlLE2s8Wf3P4w6uRMUCqyd9hGeRt5XlXUaNR4+b3bXY1S6IQgCvv1xGzZX+QEiScH7MQpyMwyIm4Yvp/Yt9h/4ipucFZ6YlTQ5K6lbsanot2wb5I4bIDHXTOjlGdUgiR+Mre/15SLFRDpWrEexRNoQBAGTj0wvNKkDgOeyVHx29H/Y1muj0X6Cv3U6TC2ps3FyhlfHN177eoIgQICg+R0CFIICuZ/TFIJCVS4IL9vlludeK++x6hwhn+tCgPJ/L49zsuVIT81CRmo20tOyEfcwCVvtFxWa1AGASJKJrfaLkf1NDgSpFDliMbIBZEGEbIiQKQBZApAhiJChEJCpANLlAtLlQI4gAgQRABGKub56mSmvyVlJpCTfh9R1IWCSkW+9xDwaUteFSEluCjh7l3F0RBVLsRcoLonc9e4qqorSY3cp7hKC/wnWun1bt7awM7MD8CLZgKLgBCbPdwUUGslGfomJ2jkvkh+FKhHKc37e5Ed1Dl7G8+K8l3WKPNcVXiRIL9tBLqDjIXNYp71MQM74PEdk9ewX11AozxBenPdKooY8x1CVUV6C8CLBy032BLHqu4BXy3Lb5lf34nuec8WCCGJBDDFEkAhiSPDiSxDDRKT8WQoJTEQiSEUSSEViSEUSmIokkIglEIvEkIjEEIvEEIslyp9zy8XKOolYoqwTiyF5cZ5ELIZE8uIaYjFMxC/KJWKYSJTtTSR5y0xeHCt/lkgkkEgkkJq8KJeI88Sj/J77JRFJIBKJtCovqK1CoUC3Fb3wyPRBkf9eVbNr4Z9R2yEWG2ZSTmQMitVjJ5PJdBUHGZENEXuL1f5YzDEdRaJfdaItYZ32cr3HZMscXHeJh8D/jEqNSCQAkCtzslfrSukeihdfpbJIR+7TYHlpXMwwiAQRBFPtPnQ8Mr2Po1dOoUOTVjqOiqjiKvajWJFIBC8vL/Tr1w+tW3MQLGm69TRO3yHonVgB+Ny2Uyu7WC9J2TFEZEQEUfF6kvdc28/ErpgEQcDFh0n491oskjNyYGsuxRsNndHU3a5M/wYfPHgQ69atw9WrV5Geno4qVaogMDAQI0aMQK1atcosjvyEhIRgwYIFGuUeHh7YtWuXHiLSn2IldpMnT8a2bdsQHh6OK1euwNXVFb1790bfvn1RrVo1XcVI5YwgN+wt5ATVGC3g5SM6vCx7tf5FG0GjLM/PqmsBgBge0VJYZ7z8z+uZlQJ37a2ALKt8rg+8zPjy1L1oJxQUJ8QFxPDyZ0HjNRX0ujVfj6Bqo83rFkFi8SDfgfMFMcmphprWnpCaiGAiAUzEAkzEgFgsQCISIBYBYpECCkGAXCGHXCGHQqGAXFBAoZBDISh/lgvKnxUKBRSCXNlekEPAi7aCAgIUqva5Pyvw4mcoVI/ylWUvHpMXM2Eh7aTmpOg7hHLlVmwqJm++rLEX7+Ijd+FdzRY/D2hSJhNSfv75ZyxbtgxdunTBd999BwcHB0RFRWHr1q2YNGkStm/frvMYimJmZoY1a9ZolFU0rzUr9sKFC9iyZQv27t2L9PR0iMVitGjRAv369UOXLl0q/LImBakoY+wm79yJfYmfa90+K2YITOXuEIlEEEH84g+6WPWzSCSGWCR68R2qsT2i3J8hylMvejEeCGrHynrRi3FOUB0rryd6cZ+8x6IX139ZplYvzr+9CCKI5Tkw2/4jRBl5/oC9MRKo3giKbAVk2XLIsvJ8ZSq/cjJlyMmUIydTDkGuGgWm/iXkU/YiwSq4XvN85DlXBEAiEsHMygQWVlKYW5nCwtoUFlZS5XdrU1ham8LCRvndRCpWvS/I8/p3Xj+BXyI+0Prf/UvfJRjg1Vrr9mUtd0ymIm/y+OJn4UXymFuWmyjKFXLI5DLIZArIZDLI5HLI5XLk5P4sU0CmkEH+olz24iv3Z7lCDrn8RRuFQtlOIVf9LFPIoFC8THTlCuU9FYJCdawQXpQL8hfJrnr8qjK88jryJLzITXJFygRXgKD8+dXvIgEpleLxvFJyke9nrq6m/fDT21/r7N/NmNyKTUX/xSeQklnw+A0bMxNsGddKp8nd0aNH8f7772P8+PH46KOPNOoPHz6MDh06aJRnZmaWWWIVEhKClStX4uLFi6V63bJ8DaV17xItd5Keno49e/Zg69atuHjxIkQiEaysrBAUFIS+ffvC25uzn/KqKInd+cgEBP/zrla9N/KMaviz2zr41nAog8h0Q5YjR3pyNtJTsvE8OQvXju3BrRNbVPWmFm6wdByCzLQclPXiQiamYljYVoKlrSksbF58V/tZ+d3MUgpRCWdjKhQKNF/1FnJMoopsayqrgbMjdnIQvYFSKAQoZAoo5AIUcgFyee7PL8tyy0/eOosvn0zS+trzfZbyUawW1NcHLJyu1wccNmwY7ty5gyNHjkAqLXjnEE9PT3z66adITk7G9u3bkZ6ejosXLyIrKwtz587F7t27kZycjNq1a2PixIl4442XKwTcvn0bc+bMQXh4ODIzM+Hi4oL+/fvjvffe06pem8Tu5s2bmDNnDs6fPw+JRILWrVtj2rRpqFq1apGvoWPHjmjfvj2qV6+OVatWISUlBV26dMG3336Lu3fv4ptvvsGNGzdQt25dzJo1C56enqprCoKAlStXYtOmTYiJiYGzszOCg4MxfPhwVZvc+NesWYNZs2bh2rVr+PjjjzFq1Khi/3uVaLkTCwsL9O/fH/3798f9+/exZcsW7NixAxs2bMDGjRvh4+ODv/76qyS3oHLIt7o9qitGIFr+U5HrmdVQjDDIDcEFQUB2phzpyVl4npyt9l2ZwL38OStdlue8bGQl71a/ljgAGamluz9mJUsTWNpWgoWNMlGztKmk/G6b57uNKaRmkjIbgyMWizGn3feYdOw9QJL/shcAALk5fmw3i0mdAROLRRCbSrRq26tGRyxZUVPrWbHtvFqWMLry6e7TNHz79zXciUvTqn22TIGnaVlatb0cnYwWsw7C1KTw/6bqVrHCl281RB0n7RcHl8lkuHDhAt58881Ck7pcf/zxB5o0aYJZs2apJlxOnjwZ//33Hz7++GPUrl0bO3bswAcffICFCxeq9pgfO3YsHB0dMWvWLFhZWSEqKgpPnjxRXbeo+rzx5iWRKH8HPn78GEOGDIG7uzt++uknZGVlYd68eRgyZAh27twJqzz7duf3GgDlGEMPDw98++23ePjwIX744QdIpVJcunQJw4cPh6OjI37++Wd89NFH2LNnj+p33KxZs7B582aMHTsWTZo0wYULF/Dzzz+jUqVKePvtt1XXz8nJwaefforhw4dj0qRJsLOz0+JfSFOprWNXq1YtfPbZZxgzZgymTp2Kw4cP48GDB6V1eSpHRCIR5vfrhn7LMyCvXMiCpc8G47fR3cp08K+gEJCRloPnyVlIT1b2sKWnZCt73HKTtxRlnSyn+AvayjMvAsLLpEZsUg1iE3etzhWJRbCwlsIiNzmzedmjZvFKEieRGmZS1LluE8zDMkw99jmyJZEa9abyGvix7Sx0rttED9GRLojFYsxqNwtj/xuNrALWsQOASjJzzGo3s8Im9F/vjMB/t+N1dn1tksCYpAx8vTMCa0f5a33dpKQkZGdnq/VqFcbW1hYLFixQ/V6/ceMG9u/fj2+++QaDBw8GALRt2xYxMTGqxC4hIQHR0dH4/PPP0bFjRwBAy5YvPwAUVZ8rPT0djRo1UiubM2cOevXqhdWrV0Mmk2HlypWqhKlBgwYICgpCaGgogoNfLtH16mvIa9GiRarhZmfOnMGmTZuwbNkytG3bFoDyycXYsWNx69Yt1K9fH1FRUfjzzz/xzTffYNCgQQCAVq1aITMzEwsXLsSgQYNU/03k5ORg0qRJ6N69ZAvYl1pid+7cOWzduhV79+5FZmYmxGIx/Pz8SuvyVM7Uc7bGip5dMWmDMx5L72tsMVQ1pxbmDm5aauNC5DkKPH+RkCkTtTw9bXkSt/TUHAgK3TwPFRSZkGWdUyszMQ+EianklUehlV48DlXvYTOzkpbLxWlf1bluE5ytvRPbIk5iy429SMtJhZXUGv3rd0XfRgEV9g+7MWtezxtLsByfH/083567qtm1MKvdTDSvx+E55ZW2H8Dbtm2r1vb8+fMAgK5du6q169atG2bPno309HTY29vDzc0Nc+fORXJyMgICAuDi4qJqW1R9LjMzM/z5559qZe7uyg/W586dg7+/v1ovWJ06dVC/fn2cP39eLbF79TXk8vPzU5tDULNmTYjFYrUks2bNmgCAx48fo379+jhx4gQA4M0331Tr/WvVqhWWLVuGx48fw83NTVXerl07jfsWV4kSu7i4OISGhmLbtm2IioqCIAioVq0a+vTpg759+8LV1bVEwYWHhyMkJAQXL16ETCZDvXr1MHz4cK2z2aioKOzYsQMRERGIiIhAXFwc3NzccOjQoXzbP3jwAHv37sV///2HyMhIJCUloXLlyvD398eYMWNQp06dEr2eiuTZozSEr7qJt9OleCzxwJ2k2sgUCTATRKibI4GrXITwVTdRZ7JlgXuGCoKAnEy5auyaqoctOVstiXuenIWs52W/OFwlC5MXvWjKhO1Z1AHEJL/81FytYVP0njIYpmX4ONRQiMVi9Pdqjf4GPDmCSlfzet74p+4OHL1yCnuu7UdqTgqspTbo3vBNtPNqWeET+q97NsJ3u67hdqx2j2KTM3KQlqX97zWrSiawNS/8UamHsxW+6NFQ62sCgJ2dHSpVqoRHjx5p1b5y5cpqx8nJyZBKpRqPFR0dHSEIAlJTU2FhYYEVK1Zg3rx5+Pbbb1U9b9OnT4efnx9EIlGh9bnEYnGBY9hTUlLQoEGDfONNTk7WKMuPjY2N2rFUKoWZmZlaspf7uDorS/m3IDExEYIg5NvDCEAtsTM3N4elpWW+7Yqj2ImdTCbDwYMHsXXrVoSFhUEul8PMzAw9evRAv379Cgy+uE6dOoXRo0fD1NQUQUFBsLS0xP79+zFp0iQ8efIEI0eOLPIa586dw4IFCyCRSFCnTh3ExxfeDf7bb79hz549qFevHjp16gQrKyvcunULO3bswL59+7B8+XL2QmpBEAQcWnMdWekyiCBCVbkIVeWav9Sz0mXYu+QKmnapodyWKjlb9Sg0t7dNll22+3uKRIC5tanaOLX8xq5Z2JjCJM8YpPTkJCz/4D+1a7UPHoZK5ty1jyoOsViMDk1acXJEPuo4WWH1iBZat78QlYi+i05o3X7tqBY6Ga9sYmICX19fnDp1CjKZDCYmhf9Oe/VDrK2tLXJycpCcnAxbW1tVeXx8PEQiEaytlU9tatWqhfnz5yMnJwcXL17E3LlzMXbsWBw7dgyWlpZF1hfF1tYWz5490yh/9uyZqpetoNdQEra2thCJRFi/fn2+YxTzrv9XWvct1l+d77//Hn///TeSkpIgCAIaN26Mfv364a233lIbeFhSMpkMX3zxBUQiEdatW6fKsidMmID+/ftj7ty56NKli1r3ZX78/PywceNG1K9fH2ZmZkXORm3Tpg3ee+89NGyo/olm9+7d+OSTT/D1119j9+7dBZxNuWLvpyAusvB9YnMlxWXg8NobOo4IkJiI83n8+XLsWm6ZubXpaz0OPbNjM3KyXk4U8fBvBefadUvzJRBRBdLU3Q7e1Wy1nhXr426ns1hGjBiB999/H0uWLMHEiRM16o8ePVrgI8RmzZoBAPbu3asaY5Z73LBhQ1hYWKi1l0qlaNGiBd5//32MGzcOcXFxaslPUfUFadasGTZt2qSWYN67dw83b95Ev379in4TXlNAQAAA5VjF3PGBulasxO6PP/6ASCRSJXT16tUDANy6dUur8319fbVqd+rUKURFRaFv375qXafW1tYYO3Yspk2bhtDQ0Hz/D5aXu7u76vm6Nvr27ZtveVBQEObPn487d+4gISEBDg7ld2mOsnD/su4GCL/K1EyiPsEgzwzRvD9XsjDR2ePQ1IR4XNq/52WBSITWA4fo5F5EVDGIRCL8PKCJVuvY/TSgiU6He7Rr1w6jR49GSEgI7ty5g6CgINjb2yM6Ohpbt25FampqgYld/fr18eabb+KHH35AZmYmatWqhZ07d+LixYtYtGgRAOUEix9//BHdu3eHu7s70tLSsHTpUri5uaF69epF1mtj+PDh2LZtG0aOHIlx48YhKysLv/76K1xdXdGnT59Se69eVatWLbz77ruYMmUKRo0ahSZNmiAnJwcPHjzA6dOnVe9BaXqt50RXr17F1atXi3WOSCTCtWvXtGp75swZAEBgYKBGXW7Z2bNni3X/ksrtQi2qG5qArPQSLu0hAsytpBozQvObgCDVckkGXTq9bSPkOS9fc4PA9qhcTbtfNkREBannbI0t41rlu/MEoOyp+6mMdp747LPP0LRpU6xbtw7/+9//kJGRodpSrKi11n766SfMnTsXy5YtQ1JSEmrXro358+ererCcnJzg6OiIpUuXIjY2FtbW1mjevDl++uknSCSSIuu14erqirVr12LOnDmYPHkyxGKxah270nzimJ8ZM2agVq1a2LhxIxYuXKh6tPzqhJLSUqwFikvajVjQpIVXffjhh9i3bx+2bt2Kxo0ba9Q3bdoUtra2OHLkSLHu7+XlBScnJ63jyBUeHo4BAwbAy8sLW7ZsKfqEAlSUBYpPht7FhX2aS10UpHpDB3i1r6Yaw2ZuLYVYUj4GWifFPsGqSWOgkCt3dRdLJBgxdwnsXEo2cYiIKJcgCLj0MAn78+wV+2ZDZ/iU8V6xVD4Uq/upuAnR60pLU84ayh1U+SorKyukpmo3hqukUlNTMXXqVIjFYnz22Wclvp4gCEhPTy+FyAyXq6cVsE/79t5vuMKpRu44Czkys+Q6iUsXjm9cq0rqAKB+YAeY2tga/b8xERXs1XFjJSUSidC0ur1BLuZOhofPFQuRmZmJCRMm4N69e5g0aRL8/bVf1LEgOTk5uH79eilEZ7gEQYClowTP44tO0CydJHj6/CHir5e/T53Pnz3FzRPHVMciiQQ2DbyN/t+XiAqXO2GASB8MMrHLfd5dUK9cWlqa2rRpXcjKysL48eNx+vRpjBkzBmPHji2V60qlUtSta/yzJV0d0rEnJALZGQUnd6bmErwxohHsXUr3021Z2b/oH+Td/LVxxy5o6l8xt0siIiLDYJCJXe6aMpGRkRpj7J4+fYr09HR4e+tuBfPMzEyMHz8eYWFhGD16ND755JNSu7ZIJCr1bnpDZFHbAn0/a4ZDa67nu/RJlRrW6DisQYGLExu6uAf3cPfsKdWxSaVKaN3/7Qrxb0tERIbLIBM7Pz8/LF26FMePH0dQUJBa3fHjx1VtdCFvUjdy5MhSGVdXUVWuaoX+05oj9kEK7l+KR1Z6DipZSFHLxxHONW3K9aDfsI1r1Y59u74FSzuOfyEiIv0yyMQuICAA7u7u2LVrF4YOHapayy41NRVLliyBVCpF7969Ve3j4uKQmpqKKlWqFDjhQhu5j1/DwsIwYsQITJ06taQvpcITiURwqWULl1q6fXRelh7duoF7F14ut2NqboHmPXW3wCUREZG2DDKxMzExwcyZMzF69Gi8++67aluKxcTEYOrUqahWrZqq/dy5cxEaGorZs2erLTKckJCAOXPmqI5lMhkSExMxbdo0VdmUKVNUCw5/9dVXCAsLg5OTEywtLRESEqIRW58+fdTuTRXPq711zd/qA3Mr3a8jRUREVBSDTOwAoGXLlli/fj3mz5+PPXv2QCaToV69epg8eTK6d++u1TXS09MRGhpaaNnEiRNViV1MTAwA5Ti+BQsW5HvNFi1aMLGrwKKuhiPq6mXVsZm1DXy79dJjRERERC8Va4FiKpmKskCxsRIEARu+nIJHt14uZ9J2yEj4vZX/VnRERERlrXws709kAO5fOqeW1FnaO8DnTe16j4mIyhtPT88iv7Zt2wYAuHPnDj788EO0bdsWXl5eaNu2LcaMGYOjR4+qrrdt2zZ4enrCy8sr3+XMPv30U3h6eiI4OFjjnISEBN2/YCNhsI9iiQyJoFAgbMOfamX+fQZCWslMTxERGSBBAJ6fBpJ3ALJEwMQesO0FWPoD5XgWvN7p6X3duHGj2vGgQYMQHByMHj16qMqqV6+OqKgoDBgwAJ6enpg2bRocHBwQExODo0eP4syZM2jXrp3adUxMTPDvv/+qjYnPyMjAoUOHNJaMat++PTZu3AgbGxsdvELjxMSOSAu3z55E3IO7qmMbpyrw7tRFjxERGZiMCODBcCD9nHr5kx8Ai+ZAzdWAeSN9RFa+6fF99fHx0ShzdXXVKF+zZg0AYNWqVTA3N1eV9+vXDwqFQuManTp1wu7du9USu8OHD8PU1BRNmjRBRkaGqtzBwUE1Dl7XMjMzYWZW/j+s81EsUREUCjnCNqr31gX0exsSE6meIiIyMBkRwM1AzeQjV/o5ZX1GRNnGVd6Vk/c1JSUFVlZWakldLrFYM83o0aMHTp48iWfPnqnK/v77b3Tp0gUmJur9Ta8+il29ejUaN26Ma9euqdpERUWhadOm+OWXX1RlFy9exNChQ+Hj44NmzZrh008/VbtfdHS06lHyjBkz4O/vjwEDBrz+m2BAmNgRFeHG8aNIiHmoOrZ3dUPDth31GBGRAREEZY+SPKnwdvIk4MEItW34qBDl6H1t1KgR4uLi8OWXX+L69ev59tLl5e3tjapVq2Lv3r0AlInhf//9p7EhQX6GDRuGpk2b4rPPPkNWVhbkcjmmTJmC6tWr44MPPgCgTOqCg4NhbW2NefPm4bvvvsOVK1cwfvx4jevNnTsXgiDgl19+MZoNCfgolqgQcpkMJ7asVytrNeAdiCUSPUVEpCeKLED2DJDFA/IX32XPgPSLBfcovSr9LJB+Rjk2rKLJvAk8/BjIvF5kUwAv3u8n2rVNPwuEVwXElQpvZ9YAcP8VMPPU7rpa6tOnD06ePImNGzdi48aNsLS0RMuWLdGvXz906tQp33OCgoKwe/duvPvuu9i3bx8cHBzg5+eneqxbEJFIhB9++AE9e/bE3Llz4eDggIiICGzZsgWmpqYAgF9++QWNGzfGggULVDsc1atXDz169MDRo0fVxvzVr18fs2bNKqV3wjAwsSMqRMSRA0iOffnL1bF6TXgGtNFjRESlQJHxMkl79bsqaXulTpFWOvdO2l4xE7uHHwIp+3V3fW2SwOxIZRwe+0r11hKJBL/88gvGjh2Lw4cP49y5cwgLC8PBgwcxfvx4fPTRRxrnBAUFYenSpXj8+DF2796N7t275/vYNj9ubm743//+h88//xwmJib46KOP4OmpTFYzMjJw4cIFTJkyBXK5XHVOzZo14erqiitXrqgldu3bty/ZizdATOyICiDLzsbJbRvUyloPHAKRlr98iMqEIj3/RCzf7y8SN0W6/uKVJerv3qRTHh4e8PDwwPvvv4+EhASMGjUKv//+O4YNGwY7Ozu1tvXq1YOHhwdWr16N06dPY/LkycW6V6dOnfDdd99BLpdj4MCBqvKUlBTI5XLMnj0bs2fP1jjv8ePHaseVK1cu1n3LAyZ2RAUIP/AP0p7Fq45d6tZDneYVsKeByoYgAIrn+SdihSVrQqa+Iy8eE3t9R6Af7vOBh5OAzGtFtwWUCbAiRfvri22Kfm/NGgLu87S/Zgk4ODigb9++mDlzJiIjIzUSO0DZa/fbb7+hevXqaNy4cbGu/80338DGxgYymQzff/89fvzxRwCAtbU1RCIRxowZg86dO2ucZ2+v/h6JjHAZHiZ2pFvldF2rnMxMnN6+Wa2s9aBgo/wlQDogCIAiVTNJK/CxZ26Slq3vyNWJKgEmjoBJZfXvkjzHsqdA9CfaX9Out87CNWhmnoDHHu3bp50CbgZo377efr094o6Pj4ejo6NG+YMHDwAg3zpAOTs2PDy8wHF4Bdm9ezf27NmD5cuXIysrCxMmTMAbb7yBzp07w8LCAj4+Prh3716F3eWJiR3pTjle1+rCPzuRnpykOq7WoDFqePnoLR7SI0EA5MkF9J4V0JMmfwYIOfqOXJ3IPP8krbDETWxR9AcwQQAS1ms3gcLCD7BoUTqvx9hZ+it/T5aD93XRokW4fv06evTogbp16yIrKwthYWFYv349OnfuDDc3t3zPq1atGhYtWlSse8XGxuLbb7/F4MGD0aaNcrxznz598MUXX6Bp06aoXLkypkyZgmHDhuHjjz9GUFAQbGxs8OTJE5w4cQJ9+/aFv79xP3lhYke6kbv+UkFT9XPXX/I8bnDJXebzNJz9e6taWetBQ9hbVxyG2lMrKJT/nyzOpAHZMwDyoq5ctsSWmsmZ5NWELe/3ysokTRdEIuWHtML+ewcAiR1Qc5VB99QblHL0vvbs2RNZWVlYu3YtYmNjIZFI4ObmhilTpuCdd94p1Xt9/vnnsLGxwdSpU1VlM2bMwOnTp/Hll19i4cKF8PX1xfr16xESEoLp06cjJycHLi4uaNmyJWrUqFGq8RgikSBwUaGycuXKFQAw/u5hQQButNDuk6a5D+DxLyCWAjABRC++INbbL6qwTX/i1NaXkyZqNvFFv/99q5dYyqWCemqB0u2pFeSAPLF4kwZkCQAKX2OrzImtC+45y+/Rp0llQGyAq+MX+u/up0w+DOxDXLnA95WKiYldGaowiV1xx4YUSPIy0ROZ4GXiJ3nlOG+bYp7zSvv058Dy7+8hJ+vlH/93P/GGSw37gu/xGvd52UaSzzVePacczcItqqcWUPYwvNpTK8iUSVdh4880etgSARjYry+JXQHJWAHfJZUBsam+oy49gqBcpy5p+8ueWrveyseE7Kl7fXxfqRj4KJZKX/KOUrqQXNkrI2SV0vWKdvZwfeRk1VEd1/V4AheT3UBMmYWQD1EJk8cyOgdi4PE32q2Uf7M1UMkTkL9I5oo6Rx8kDlr2oOX2tjm8eC8qMJFI+bi9Iq5Tp0t8X6kYKvhvIdKJcrpOVVpqJVy6WDNPiYDWgTf1FU4ewouB+DkG10H12uTJyh6IMiFWJl1F9qDlTdzslYktEVE5w8SOSl9x16mqVA8wq698HAeZ8nveL8hfOc79WZ7/OZC/1ozEU6fqQiZ7+ce8foNHcHRKK/Z1SJckL8eZaTt5QGJXvh5nExGVABM7Kn22vZRLmmir1h+6ecQgKPJJ/OTIL3lMfvoUV8J/Qe7sR5FYhFZDvgSq2JRywvlqWZ72pXJOPq/P0GZ0qogAE+eix6HlTdokNkzSiIgKwcSOSp+hrL8kEgMiUwBFD04/uXsfFHn2FWzU7g3Y1+2jm7jKmiDg5XhFHSaciZuAlH+0j8t5ClCtGB8AiIioSEzsqPSVo/WXACDhUTSuHT2kOpaYmCCg/2A9RlTKRCKoJkCgku7uY1a/eImdvZEkzkREBoTPNEg3zBspl7SwaJ5/vYWfwSxOfGLzegjCy+VNvDt3g41jFT1GVE7l9tRqgzsQEBHpBHvsSHfMGwH1zxj0+ktPI+/j5oljqmMT00rw7zNQjxGVY+Wsp5aIyBgxsSPdMvD1l8I2/al23LRrD1jaFXNWL72U21PLlfKJiPSCiR1VWI/v3MTdc6dVx6bm5vDr2U+PERmJctBTS0TamzZtGq5evQp7e3ucOVP4+pN9+vTBDz/od1JUdnY2vvrqKxw+fBiJiYmYPn06hg8frteYyhITO6qwwjaq99Y1C+oNc2sbPUVjZAy8p5aoPBEEAeHx4TgcdRgp2SmwMbVBh+od4O3oDVEZfFAaP3480tPTYWJigrS0l2t7fvPNNzAzM8PUqVNVZQ4ODjqPpyg7duzAjh078MMPP6B69epwc3PTd0hliokdVUgPr11BZPhF1bGZlTWaBXGWJhEZljuJdzAjbAYinkWola+4ugKNKjfCzNYzUde+rk5jqF69er7lVlZWsLCwgI+PT4HnZmZmwszMTEeR5e/evXuoUqUKevbsWeJr6SN+QJnM5+TkwNS0+HtJc1YsVTiCICBs41q1Mr+e/VDJwkJPERERabqTeAdD9w7VSOpyRTyLwNC9Q3En8Y5O45g2bRp69OhRZLvTp0/D09MTR44cwYcffghfX1989NFHAIDt27fj7bffRosWLeDn54fg4GCEh4ernR8SEoKmTZvi5s2bePvtt9GkSRP06NED//33n1q7gwcPom/fvmjatCmaN2+Ovn374ujRowCAjh07YuXKlXj8+DE8PT3h6emJ6OhoAMDZs2cxePBgeHt7w9/fH9OnT0dSUpLqutHR0fD09MS2bdswY8YM+Pv7Y8CAAQAAT09P/P7775g3bx4CAgLQvHlzzJkzB4Ig4OTJk+jVqxeaNm2KYcOG4fHjx2rxZmdnY+7cuejQoQMaN26Mbt264e+//873PT569Ch69uwJLy8vHDp0CK+DPXZU4Ty4fAExN66pji1s7dC0S9G/tIiIyoogCJgRNgOp2amFtkvNTsUXYV9gfdD6Mnksq40vvvgCPXv2xMKFCyEWK/uPoqOj0bt3b1SvXh3Z2dnYvXs33n33XezcuRO1atVSnZuTk4PJkydj6NChGD9+PJYtW4YPP/wQhw4dgr29PaKiovDRRx8hKCgIn376KRQKBW7cuIHk5GQAwIIFC7Bs2TKcPXsWCxYsAABUqVIFV69exYgRI+Dv74/ffvsN8fHx+OWXX3Dnzh1s2LABEsnL7STnzp2Ldu3a4ZdffoFC8XIprHXr1qFFixaYM2cOLl++jJCQECgUCoSFhWHcuHGQSqWYOXMmPv/8c6xcuVJ13kcffYQLFy5gwoQJqFOnDo4ePYrPPvsMNjY2aNeunapdXFwcZs6ciXHjxsHV1RVVq1Z9rfefiR1VKPn11vn3GQSpHrraiajiuJ98Hz+e/RH3k+5r1T5bno34zHit2l59dhUdN3WEqaTwx3a17Gphqt9U1LKtVWi7kurYsSM+++wztbKJEyeqflYoFGjdujXCw8MRGhqKTz75RFWXm9jlJjy1atVCp06dcOzYMfTq1QvXrl1DTk4OvvjiC1hZWQEA2rRpozq/YcOGcHR0hKmpqdoj4iVLlsDJyQlLliyBVCoFALi6umLUqFE4evQoOnbsqGpbv359zJo1S+N1ValSBT/99JPqnocOHcLq1auxe/du1KlTBwAQGxuL7777DikpKbCxscGpU6dw6NAhrFixAoGBgQCA1q1b4+nTpwgJCVFL7JKTk7Fs2TI0adKkGO+2JiZ2VKHcOXsSsfdePrawruwE785d9RgREVUEP5z5AScendDZ9bVJAh89f4QfhB+w9I2lOosDANq3b69RdvfuXcydOxcXL17Es2fPVOUPHjxQaycWixEQEKA6rlatGszMzBAbGwtA+UhUIpFg8uTJGDhwIPz8/GBtbV1kTOfOnUOPHj1USR0ABAYGwsbGBufPn1dL7PKLHwBatWqldlyrVi3Ex8erkjoAqFmzJgDgyZMnsLGxQVhYGOzs7NCyZUvIZDK1a3399deQy+Wq3kI7O7sSJ3UAEzuqQBQKucZM2Jb9BsMkz3/oRERUMpUrV1Y7TktLw8iRI+Hg4IBp06ahatWqqFSpEmbMmIGsrCy1tmZmZhoTBqRSqapdrVq1sGTJEixduhQTJ06EWCxGYGAgvvzyy0IfXaakpGjElRtr7mPcguLPZWOjvmqCVCrNtwyAKt7ExEQkJSWhUaP81+58+vQpXFxcAACOjo4Fxl8cTOyowrgZdgzPoqNUx3YurmjUrpMeIyKiimJai2mYc3YO7iXd06p9SnYK0nLSim74gpXUCjamhS/XVNuuNqb4TdH6mq/r1bF+ly5dwpMnT7B06VLUr19fVZ6amqpKaoqjbdu2aNu2LdLS0nDs2DHMnj0b06dPx5o1awo8x9bWVq2nMNezZ89ga2tbaPwlYWtrCwcHB/z+++/51uddHqa07svEjioEuUyGE1vWq5W1GvAuJCb8T4CIdK+WbS0s7rxY6/aXn17GkD1DtG6/9I2l8Hbyfp3QdC4zMxMA1B6DXrhwATExMfDw8Hjt61pZWaF79+4IDw/Hrl27Cm3brFkzHDx4ENOmTYPJi9/7YWFhSElJQbNmzV47hqK0atUKy5cvh1QqVUtqdYl/1ahCiDh6EElPXk5Br1ytOjxbtSnkDCIi/fF29Eajyo0KXOokr8aVG8PL0asMono9Pj4+sLCwwDfffIP3338fsbGxCAkJgbOzc7GvtWHDBly6dAlt2rSBk5MToqOjsXPnTrRu3brQ88aOHYvBgwdjzJgxCA4OVs2K9fb2VpvAUNpat26NDh06YPTo0Rg9ejQ8PT2RkZGBO3fuIDIyMt9JGiXFxI6MniwnB6e2blAraz1oCMRiSQFnEBHpl0gkwszWMzF079BClzyxNrXGd62/M5ilTvLj6OiI3377DXPmzMH48eNRs2ZNfPPNN1i+fHmxr+Xp6YnDhw9j9uzZSEpKgpOTE4KCglTr5RWkcePGWLlyJebOnYsPPvgAFhYW6NixI6ZOnaq21IkuzJ8/H7///jv++usvxMTEwNraGh4eHujbt69O7icSBEHQyZVJw5UrVwAAXl6G+8nKGF34528cXv1yFphz7bp49/t5Bv2LkIgIKHjnCUDZU/dd6+90vvMElS/ssSOjlpOZidOhG9XKWg8KZlJHROVCXfu6+CvoL1yJv4JDUYdUe8V2rN4RXo5e/F1GGpjYkVG7uG8X0pOTVMdu9RuiZhNf/QVERFRMIpEI3k7eBjs5ggwL94olo5WV/hxnd2xRKwscNJSfcImIyGgxsSOjdX73dmQ+f7kOVA3vpqjWsLEeIyIiItItJnZklDJSU3B+93a1staDtF8TioiIqDxiYkdG6ezOrcjOyFAd12neEq51PfUYERERke4xsSOjk5aYgIt786xCLhKh9cB39RcQERFRGWFiR0bndOgmyLJfbiztGdAGTjVq6TEiIiKissHEjoxKytM4hB/YqzoWicRoNYC9dUREVDEwsSOjcnLrBijkMtVxw3Yd4VDVTY8RERERlR0mdmQ0Eh/HIOLoAdWxWGKCgH5v6zEiIqKSEwQBj27dwH/rV+PfZQvw3/rVeHTrBspqR9CQkBB4enqqvlq2bImhQ4fi3LlzOrvnrFmz0LFjR9Xx6dOn1WLw8fHBW2+9hTVr1kAul6udO23aNHh6emLKlCka1x0/fjyCg4M1rtusWTOkpKSotT1w4AA8PT0RHR1dyq9Ot7jzBBmNE5vXQ1AoVMfenbvAtoqzHiMiIiqZ+IeR2LvoV8Teu61WfmbHFjjX9kDX8R/D0b2GzuMwMzPDmjVrAABPnjzBokWLMHz4cGzbtg316tXT+f1zzZ49G7Vr10Zqaiq2b9+O77//HllZWXj//fc12u7atQsTJ05E9erVi7xuWloa1qxZgw8++EAXYZcpg+6xCw8Px3vvvYfmzZvDx8cHAwcOxJ49e7Q+PyoqCiEhIRg7dizatGkDT09PtU8ABfnvv/8wZMgQNG3aFL6+vggODsbJkydL8lJIx+KjHuDGiWOqYxOpKfx7D9RjREREJRP/MBIbvpqikdTlir13Gxu+moL4h5E6j0UsFsPHxwc+Pj7o2rUrlixZAplMhg0bNmi0FQQB2dnZOonDw8MDPj4+aNOmDX766SfUrl0bW7du1WhXs2ZNODk5YcmSJVpd19/fH2vXrkVaWlrRjQ2cwSZ2p06dwjvvvIPz58+jW7duGDx4MOLj4zFp0iSsXLlSq2ucO3cOCxYswLFjx2BnZwexuOiXu2PHDowePRp3795F37590adPH9y5cwcjRozA3r17izyf9CNs059AnscSPl17wMqhsh4jIiJ6fYIgYO+iX5H1/Hmh7bKeP8e+xb+W2WPZXFWrVoWDgwOio6Mxbdo09OjRA0ePHkXPnj3h5eWFQ4cOAQAuXryIoUOHwsfHB82aNcOnn36KZ8+eqV0rNjYWY8eORZMmTdCmTRssW7ZMqxjEYjE8PT3x+PFjjTqpVIr33nsPO3fuRExMTJHXGjVqFLKysrB27Vqt7m3IDPJRrEwmwxdffAGRSIR169ahQYMGAIAJEyagf//+mDt3Lrp06QI3t8IHxfv5+WHjxo2oX78+zMzM4OXlVWj75ORkzJw5E/b29ggNDYWLiwsA4L333kPv3r3x9ddfIzAwEFZWVqXzQqlUPLl7G3fOnlIdS83M4deznx4jIiJSl/AoGofXLENCzEOt2stycpCelKhV2yd3b2PJ2KEwkUoLbefg5o4Ow96DQ9VqWl23MGlpaUhKSkKVKlUgk8kQFxeHmTNnYty4cXB1dUXVqlVx8eJFBAcHo127dpg3bx4yMjLw66+/Yvz48di4caPqWuPHj0dsbCy+/vprWFtbY9myZXj8+DFMTIpOUR49eoRq1fJ/PQMGDMCSJUuwdOlSfPvtt4Vex8HBAYMGDcLq1asxdOhQWFpaFu8NMSAG2WN36tQpREVFoUePHqqkDgCsra0xduxY5OTkIDQ0tMjruLu7w8fHB2ZmZlrdd+/evUhJScGQIUNUSR0AuLi4YMiQIUhMTMSBAwcKuQLpQ9hG9U9YzYJ6wcLGVk/REBFpOrRqKR5cOo+Up3FafWmb1OVKT0os8poPLp3HoVVLX/s1yGQyyGQyREdHY/r06ZDL5ejSpQsAZcfIzz//jL59+yIgIAA1atTAL7/8gsaNG2PBggXo0KEDunfvjkWLFuHy5cs4evQoAODYsWO4evUqfvrpJ/Tp0wedO3fG8uXLC3wkqlAoIJPJkJiYiBUrViA8PBwTJ07Mt22lSpUwatQobNu2DU+ePCny9Y0aNQrp6elYv379a75DhsEgE7szZ84AAAIDAzXqcsvOnj2rl/vmtiHDEH39Kh5cvqA6NrO0QvMeffQYERGR8UlPT0ejRo3QqFEjdOrUCadPn8aXX36JNm3aAADs7OzQpEkTVfuMjAxcuHABXbt2hVwuVyWFNWvWhKurK65cuQJAOZbe2toaAQEBqnOtra3RqlWrfOMYOHAgGjVqhJYtW2LOnDl477330L179wLjHjx4MKytrfH7778X+RqdnZ3Rv39/rFq1Chl5tqQsbwzyUeyDBw8AADVqaM70cXJygoWFBSIjS3+waGH3zS3TxX3p9QiCgOMb1Hvrmvfsh0oW5bcLnYiMU8cRY3BkzTI80/JRbGZaGrIz0rW+vqm5BcyKGCZU2c0d7Ye9p/U18zIzM8Off/4JkUgEe3t7uLq6qo1bd3R0VGufkpICuVyO2bNnY/bs2RrXyx0XFxcXBwcHB81YK+c/RvrHH39EnTp1kJCQgKVLl2LZsmXw8/ND27Zt821vbm6OESNGYMGCBRg7dmyRr/O9997D5s2bsXHjxgIf8Ro6g0zscrtgra2t8623srJCampqmd43d1xdSe8rCALS07X/j5UK9vDqZcTciFAdm9vYon67Tnx/iUivLCwsNMocqlZD3+nfaH2NR7du4K8vJmvdvv/n38HVw1Pr9sUlFosLHacuEonUjq2trSESiTBmzBh07txZo729vT0AoEqVKkhISNCof3WCRa46deqo4mjevDm6du2KH3/8EW3atNGIIdc777yDFStWYPny5QXGn6tq1aro06cPli9fjunTpxfZ3hAZZGJnzHJycnD9+nV9h1HuCYKAC+tWqZW5NQ/AnXv39RQREZFSs2bNSnwNVw9PONf2KHCpk7xc6njApW7ZrSWnDQsLC/j4+ODevXuFJoReXl5ITU3FyZMnVY9jU1NTceLECdjZ2RV6D0tLS3z44YeYMWMGDhw4gDfeeCPfdlZWVhg6dCh+//13NGjQANIiJpm8//772LZtGzZt2lT4izRQBpnYFdU7lpaWBlvb0h8cn/e+uZ8m8t4TKLgXUVtSqRR169Yt0TUIuH/hLFKfPFIdW9pXRofBQ2AiNdVjVEREpUMkEqHr+I+x4asphS55UsnSEl3GfVxgb5U+TZkyBcOGDcPHH3+MoKAg2NjY4MmTJzhx4gT69u0Lf39/tG3bFo0aNcJnn32GyZMnq8bDabv6RO/evbFkyRIsW7aswMQOAIYOHYpVq1bh4sWLaNGiRaHXdHd3x1tvvaXVJE1DZJCJXc2aNQEox7M1btxYre7p06dIT0+Ht7e3Tu579epVREZGaiR2uWPr8ht/VxwikSjfbnrSnqBQ4NyOzWplrfq/DRtbO/0ERESkA47uNTD4mzn57jwBKHvquowrm50nXoevry/Wr1+PkJAQTJ8+HTk5OXBxcUHLli1Vf0tFIhEWLVqEr776Cl9++SVsbGwQHByM+Ph4HDx4sMh7SKVSjB07FjNmzMDp06fh7++fbztra2sMGTIEixcv1ir2MWPGYOfOnRrblZUHIqGsVzXUwn///YfRo0ejb9++GoMuQ0NDMW3aNHzwwQcFTnEuiJeXF5ycnFQLJ75qw4YN+Oqrr/K99oIFCxASEoIff/wRvXv3LtZ9c+XOAipqPT0q3PWwo9gz/yfVsZ2zK4bPXQyJFmseERGVN4Ig4MmdW7hz9iQyn6fBzNIKdf0C4FK3nkH21JF+GeRyJwEBAXB3d8euXbvUxqOlpqZiyZIlkEqlaslVXFwc7t69W+KJDd26dYO1tTX+/PNPtTVvnjx5gj///BP29vb5DgKlsqOQy3Fy8zq1soAB7zCpIyKjJRKJ4OrhiTbvDMcb701Em3eGw9XDk0kd5csg/xqamJhg5syZGD16NN59910EBQXB0tIS+/fvR0xMDKZOnao2DXnu3LkIDQ3F7Nmz0bdvX1V5QkIC5syZozrOXdRw2rRpqrIpU6aoplrb2triiy++wJQpU9CnTx/V2jh79uxBUlIS5s2bx10n9Czi2EEkPn45tq5yteqo3zr/ae5EREQVjUEmdgDQsmVLrF+/HvPnz8eePXsgk8lQr149TJ48udDFCPNKT0/XGPz4atnEiRPV1tDp1asX7O3tsXTpUmzbtg0A0LhxY4wbN67ABROpbMhycnByy19qZa0GvguxWKKniIiIiAyLQY6xM1YcY1cyF/ftwqGVS1THVWrWwZAffuXjCCIiohcMcowd0atysjJxettGtbLWg4cwqSMiIsqDiR2VC5f278HzPJtiV63XALV8musxIiIiIsPDxI4MXlZ6Os7s2KJW1npQMHvriIiIXsHEjgzehT07kJmaojqu3rgJqjcu/QWqiYiIyjsmdmTQMtJScW6X+szm1oOC9RQNERGRYTPY5U6IAODczq3IzkhXHdf29UPVevX1GBERUcWyc+dO/PHHH7h//z4EQYCzszN8fX3xySef4M6dOxg6dGiR1zh48CDOnDmD6dOn4+TJk6plxjp27IiYmBi89957mDx5sto5Dx48QJcuXQAAf/zxh2q7sODgYJw5cwaAcvFmFxcXNGvWDJ988gnc3NxK86WXS0zsyGA9T0rEhb1/q5Wxt46IKhxBAE6fBnbsABITAXt7oFcvwN8f0PFY42XLluGXX37B8OHD8eGHH0IQBNy+fRt///034uLi0KhRI2zc+HLFgoiICHz77beYPXs2ateurSqvUqVKgfewsLDAnj17NBK7Xbt2wcLCAunp6Rrn+Pr6YurUqZDL5bh16xZ+/fVXhIeHY+fOnTA3Ny+FV15+MbEjg3Vm+2bIsrJUx/UC2qBKzdqFnEFEZGQiIoDhw4Fz59TLf/gBaN4cWL0aaNRIZ7dfu3Yt+vTpo7ZjU7t27TB69GgoFAqIxWL4+Pio6rJe/M728PDQes3W9u3bY//+/bh48SKaNm2qKt+9ezc6d+6MnTt3apxjY2Ojum+zZs1gbm6OqVOn4ujRo+jatetrvFLjwTF2ZJBS4p/i8r97VMcikRitBryjx4iIiMpYRAQQGKiZ1OU6d05ZHxGhsxBSUlIK7G0Ti0snhbC3t0dAQAB2796tKrt27RoePHiAoKAgra6Rm0RGR0eXSkzlGRM7Mkintm2AXCZTHTds2wGV3dz1GBERURkSBGVPXVJS4e2SkoARI5TtdaBRo0bYsGEDNm/ejKdPn+rkHgDQo0cP7N27FwqFAoDyMWzz5s3h7Oys1fm5CV1hj3wrCj6KJYOT+OQRrh7+V3UslkgQ0P9tPUZERFRCN28CH38MXL+uXfusLODJE+3anj0LVK0KVKpUeLsGDYBffwU8PbW7LoCvvvoKEydOxIwZMwAA1apVQ4cOHTB8+HBUq1ZN6+sUpXPnzvjyyy9x+vRptGzZEnv27MG4ceMKbC8IAmQyGRQKBW7duoU5c+bAxsaGe7qDiR0ZoJNb/oLw4lMbAHh1fBO2VVz0GBERUQl9+CGwf7/urq9NEhgZqYxj3z6tL1uvXj3s2rULJ0+exPHjx3H27FmsXbsW27Ztw7p169CgQYMSBP2SlZUV2rdvj127dkEqlSI+Ph5dunTB48eP821/9OhRNMoztrBmzZoICQmBo6NjqcRTnjGxI4MS/zAS148fUR2bSE3h33eQ/gIiIqrgTE1N0a5dO7Rr1w4A8N9//2HMmDFYuHAhFixYUGr3CQoKwhdffAEACAwMhJ2dXYGJXbNmzTB9+nRIJBI4OzujcuXKpRZHecfEjgzKic3r1MaKNHmzO6wd+AmMiMq5+fOBSZOAa9e0a5+YCKSkFN0ul42NchmUwjRsCMybp/01C9CmTRvUr18fd+/eLfG18mrfvj1kMhm2bduGOXPmFNrW2tpa61m3FQ0TOzIYsffu4PbpE6pjaSUztOjVX48RERGVEk9PYM+eotvlOnUKCAjQvv3+/cp17UpZfHy8xuPNzMxMPH78GHXr1i3Ve1WqVAljx45FeHg4OnXqVKrXrkiY2JHBCNu4Vu3Yt3svWNja6ScYIiJ98vdXrlNX0FInefn5AS1a6CSMt956Cx06dEBgYCCqVKmC2NhY/Pnnn0hMTMSwYcNK/X7vv/9+qV+zomFiRwYh5sY13L90XnVcydISzd/qo8eIiIj0SCRSLj4cGFj4kid2dsCqVTrbgWLixIk4fPgwfvjhByQkJMDe3h6enp5YvXo1WrZsqZN7UsmIBEFHi9+QhitXrgAAxwW8QhAEbP72f3h47YqqrPWgYLTkpAkiqugK2nkCUPbUrVql050nqPxhjx3pXdSVy2pJnbmNLXy799RjREREBqJRI+DMGeXX9u0v94rt3Vv5+FXHe8VS+cPEjvRKEASNsXX+vQfA1Kxib+JMRKQiEinH3OlgcgQZH24pRnp178IZPL5zU3VsZe8A7ze66TEiIiKi8ouJHemNoFAgbIN6b13LfoMhNS1iWxwiIiLKFxM70ptbp8PwNOqB6ti2ijMad3hDfwERERGVc0zsSC8UcjnCNq1TKwvo/w4kJlI9RURERFT+MbEjvbj232EkPopWHTtUrYYGbdrrLyAiIiIjwMSOypxcloOTW/5SK2s1cAjEYomeIiIiIjIOTOyozF059C9Snsaqjp1q1EI9/1Z6jIiIiMg4MLGjMpWTnYXT2zaolbUeFAyRmP9XJCIiKin+NaUydXn/HqQlJqiOXT08UdvXT48RERERGQ8mdlRmsjPScWb7ZrWy1oOCIeKWOERERKWCW4qRTgmCgMe3b+LuuVOIvHIZGakpqjr3Rt6o4eWjv+CIiIiMDBM70pn4h5HYu+hXxN67nW89FyMmIiIqXXwUSzoR/zASG76aUmBSBwCHVi1B/MPIMoyKiIjIuDGxo1InCAL2LvoVWc+fF9ou6/lz7Fv8KwRBKKPIiIiIjBsTOyp1j2/fLLSnLq8nd2/jyZ1bOo6IiIioYmBiR6Xu7rlTxWp/5+xJHUVCRERUsTCxo1KX+TxNp+2JiIgof0zsqNSZWVrptD0RERHlj4kdlbo6zVsWq31dvwAdRUJERFSxMLGjUufq4Qnn2h5atXWp4wGXuvV0HBEREVHFwMSOSp1IJELX8R+jkqVloe0qWVqiy7iPuaUYERFRKWFiRzrh6F4Dg7+ZU2DPnUsdDwz+Zg4c3WuUcWRERETGSyRwddgyc+XKFQCAl5eXniMpO4Ig4MmdW7hz9iQyn6fBzNIKdf0C4FK3HnvqiIiIShn3iiWdEolEcPXwhKuHp75DISIiMnp8FEtERERkJJjYERERERkJJnZERERERoKJHREREZGRMOjJE+Hh4QgJCcHFixchk8lQr149DB8+HN27d9f6GtnZ2fj999+xc+dOPH78GLa2tujQoQM+/vhjVK5cWaN9ZmYm/vrrL+zcuRPR0dEQBAFVq1ZFt27dMGTIEFhbW5fmSyQiIiIqNQa73MmpU6cwevRomJqaIigoCJaWlti/fz9iYmIwdepUjBw5sshrKBQKvPfeezh+/Dh8fHzg5+eHyMhI/Pvvv6hWrRo2bdoEBwcHVfucnBy8++67uHz5Mho0aIAWLVoAAE6fPo0bN27Aw8MDmzdvhrm5+Wu9poq43AkRERGVHYPssZPJZPjiiy8gEomwbt06NGjQAAAwYcIE9O/fH3PnzkWXLl3g5uZW6HVCQ0Nx/Phx9OjRAz///LNq3bS//voLX3/9NX799Vd8++23qvb//vsvLl++jDfeeAMLFixQu9b48eNx8OBB7Nu3D7179y7dF0xERERUCgxyjN2pU6cQFRWFHj16qJI6ALC2tsbYsWORk5OD0NDQIq+zefNmAMAnn3yithju4MGD4e7ujr///huZmZmq8ujoaABA27ZtNa7Vvn17AEBCQsJrvSYiIiIiXTPIxO7MmTMAgMDAQI263LKzZ88Weo2srCxcvnwZtWrV0ujZE4lEaNWqFdLT03H16lVVuYeHcvurY8eOaVzvyJEjEIlE8Pf3L96LISIiIiojBvko9sGDBwCAGjU09xF1cnKChYUFIiMjC71GVFQUFAoFatasmW99bvmDBw/QvHlzAMpeuc6dO+Pff/9F79691cbYRUdH47vvvkOjRo1e70URERER6ZhBJnZpaWkAUOAMVCsrK6SmphZ6jdx6KyurAq+R916AsicvJCQEc+fOxfLly3H9+nVVXZ8+fdCqVSvtX0QBBEFAenp6ia9DRESGycLCQt8hUAVmkImdvmRkZOCTTz5BeHg45s6di4CAAADAyZMnMWvWLBw7dgybNm1CtWrVXvseOTk5agkjEREZl2bNmuk7BKrADDKxy+1NK6hXLi0tDba2toVeI7e3L2+P3KvXyHsvAFiyZAkOHTqERYsWoVOnTqry7t27w9TUFBMmTMCSJUswc+ZM7V/MK6RSKerWrfva5xMREREVxCATu9zxb5GRkWjcuLFa3dOnT5Geng5vb+9Cr+Hu7g6xWKwar/eq3PK8Y/D+++8/AMh3gkTLli0BANeuXdPiFRRMJBKxm56IiIh0wiBnxfr5+QEAjh8/rlGXW5bbpiBmZmbw9vbG/fv3ERMTo1YnCAJOnDgBCwsLtcQxJycHAJCYmKhxvdxlTkxNTYvxSoiIiIjKjkEmdgEBAXB3d8euXbvUxqOlpqZiyZIlkEqlaosEx8XF4e7duxqPbgcOHAgAmDt3LvJusLFhwwY8fPgQb731FszMzFTlTZs2BQAsWLAACoVCVS6XyzF//nwA+ffmERERERkCo9hSbNq0aQgNDcXs2bPRt29fVXl+W4pFRUVh//79cHNzw+bNm9W2FHv06BEGDhyIp0+fwsPDQ/X49eTJk7hz5w5q1qyJTZs2FTm+ryDcUoyIiIh0ySB77ADlmLb169fD19cXe/bswV9//YXKlStj3rx5Wu0TCwBisRiLFy/GBx98gISEBKxevRoXLlxA//79sXHjRrWkDgCqVq2KrVu3YsiQIcjOzsaGDRuwceNGyOVyjBo1qkRJHREREZGuGWyPnTFijx0RERHpksH22BERERFR8TCxIyIiIjISTOyIiIiIjAQTOyIiIiIjwcSOiIiIyEgY5JZiRERUDgkCcPo0sGMHkJgI2NsDvXoB/v6ASKTv6IgqBCZ2RERUchERwPDhwLlz6uU//AA0bw6sXg00aqSPyIgqFD6KJSKikomIAAIDNZO6XOfOKesjIso2LqIKiIkdERG9PkFQ9tQlJRXeLikJGDFC2Z6IdIaJHRERvb7TpwvuqXvV2bPAmTO6jYeoguMYOyIiKlhqKhAd/fIrJkb9+Nat4l1v+3blZAoi0gkmdkREFZEgAAkJhSdt0dHKxK40JSaW7vWISA0TOyIiYyOXA7Gxmola3uOYGCAzs+xjs7cv+3sSVSBM7IiIypPsbODRo8KTtkePlMmdrpmZAY6Oyntqq3dvnYVDREzsiIgMx/PnLxO0ghK32NiyicXGBqhW7eWXm5v6cbVqL3vfWrTQbgKFn5+yLRHpDBM7IiJdEwQgObnw8WwxMWU3/szJSTNRy3vs5gZYW2t/vdWrlevUFbbkiZ0dsGoVd6Ag0jEmdkREJaFQAPHxRSdtz5/rPhaxGHB1zb+HLfe4alXlI9TS1KgRcPx4/jtPAMqeulWruPMEURlgYkdEVBCZDHjyRHOm6KuTEHJydB+LqenL5Cy/x6JuboCLC2Cip1/rjRop16g7c0a5pEnuXrG9eysfv7KnjqhMMLEjooopM1OZlBU2CeHJE2WPnK5ZWhY+ns3NTTlJQWzga8qLRMo16rhOHZHeMLEjotInCModCXbseNlz06uX8g9+WfTc5C6qm9+6bLll8fG6jwNQvvb8etfyHtvYsEeLiEoFEzsiKl0REfmPtfrhB6B5c+VA+9cda/XqoroF9balpJT0VRRNJAKcnYuehGBhoftYiIheYGJHRKUnIqLw2ZHnzinrjx/XTO7kciAuruhJCGWxqK6JiXKSQWGTEFxdlePeiIgMCBM70i19P5KjsiMIyp66wpa8AJT13boB/fqpJ26PHysnK+iamVnR49mqVAEkEt3HQkRUykSCIAj6DqKiuHLlCgDAy8tLz5GUkYIeyQElfyRX0SkUypmYpf2Vnf3658bHa7dIrS5pu6guP1QQkZFijx3pRkkeyemKrpIhfSRRZTFT09CU9qK6RERGiIkdlb7iPJLr0gUYPVr5CE7XCVRFTIbKA30tqktEZIT4KLYMVZhHsadOAQEB+o6CDN3QocCsWfpdVJeIyMjwtymVvh079B1B+SORAFKp5pepaf7l+vgqKpYLF4A2bbR/zePHK3vjiIio1DCxo9JXVhuZF5QM6TJ50dWXMQzmb91aOSlGmwkUfn7KbaaIiKhUMbGj0mdvX7z2b78NjBtXvETIxMTwt1eqaEQi5UznwibNAICdnXJDeGNIZomIDAzH2JUhjrErpD33ljQehS1z4+enTOq4zA0RkU4wsStDFSaxEwTlYzZtH8mdPs3eG2MjCMCZM8D27S8Xpu7dW/n/C/5bExHpDBO7MlRhEjug6HXsAOUjubJcx46IiMjIcZAS6UajRsqkrXnz/Ov9/JjUERERlTJOniDdadRI+TiOj+SIiIjKBBM70i2RSDkxgpMjiIiIdI6PYomIiIiMBBM7IiIiIiPBxI6IiIjISDCxIyIiIjISTOyIiIiIjAQTOyIiIiIjwcSOiIiIyEgwsSMiIiIyEkzsiIiIiIwEd54oQzk5ORAEAVeuXNF3KEREpCOmpqbw9PTUdxhUQTGxK0Mi7o1KREREOiQSBEHQdxBEREREVHIcY0dERERkJJjYERERERkJJnZERERERoKJHREREZGRYGJHREREZCSY2BEREREZCSZ2REREREaCiR0RERGRkWBiR0RERGQkmNgRERERGQkmdkRERERGgokdERGpmTZtGjw9PREdHa3vUIiomJjYEVGhTp8+DU9PT4SEhOg7FCpF/HclMk5M7IiIiIiMBBM7IiIiIiPBxI6KZevWrRgwYACaNm2Kpk2bYsCAAdi2bZtam7yPeK5cuYIRI0agadOmaNasGSZMmFDguJ2HDx/i888/R/v27dG4cWMEBgZi2rRpiImJKYuXRvkICQnB0KFDAQALFiyAp6en6mvNmjXw9PTE3r171c6ZNWsWPD098fbbb6uVR0dHw9PTE9OnT1crT0hIwKxZs9CxY0c0btwYAQEB+Oijj3Dr1i3dvrgKrLB/17z/fQqCgD/++ANdu3ZF48aN0aFDByxYsAAKhULtetu2bYOnpye2bduGQ4cOYfDgwWjatCk6duyoapOdnY1Vq1ahT58+8PHxQdOmTfHOO+/g4MGD+cZY3PZEpGSi7wCo/Jg5cybWrl0LZ2dn9OvXDwCwf/9+TJ8+HdeuXcOMGTPU2l+5cgXLly+Hv78/Bg8ejGvXruHAgQO4desWdu3ahUqVKqnaXr58GaNGjUJGRgbat2+PGjVqICYmBn///TeOHTuGjRs3wt3dvUxfLwEtWrRAnz59EBoaihYtWqBFixaquoYNGwJQJvJdu3ZVlZ8+fRqA8t8/PT0dFhYWauX+/v6qtgkJCRg0aBCioqLQokULBAUFITo6Gvv27cPRo0exfPlyNG/eXOevs6Ip7N/VxsZG9fNPP/2EM2fOoEOHDggMDMTBgwcREhKCnJyc/7d372FRXOcfwL8goggEwl0NNIoZQCkILK7VEqKAiCZUDcamQmhz8RakSfqo1MckT2yqTaOt8ZYmJlCFPFxEqESUIiCXYFmgIYYGVq6irtyJwKLAwp7fHzqj4y4IBM0v6/v5C99z5syZncF9OefMDN58802NdjMyMlBYWIhnnnkGv/nNb6BUKgHcStJeeeUVFBcXw8XFBSEhIVCpVMjLy8OmTZvw9ttvIzQ0VGhntPUJIXdhhIxAcXEx4ziOBQUFsa6uLiF+/fp1tmTJEsZxHCspKWGMMVZUVMQ4jmMcx7H09HRRO1u2bGEcx7FTp04Jsf7+frZo0SLm4eHBvvvuO1H9kpIS5uLiwtavX/8Aj44Mhz+f+/fvF8XVajWbN28eCwoKEmIdHR3MycmJhYeHM47jWEFBgVDGn/tr164JsaioKMZxHNu7d6+o7dzcXMZxHAsICGCDg4MP6MgebUOdV8YY27ZtG+M4ji1evJg1NzcL8fb2diaRSJiHhwfr6+sT4idOnGAcxzFnZ2dWWFio0d7f/vY3xnEc27dvH1Or1UK8u7ubrVq1is2ZM4c1NTWNuT4h5A6aiiUjkpqaCgCIiIiAqampEDczM0NERAQAaEzJent7Y9myZaIYP9JXXl4uxHJzc6FQKPDKK68Io0A8iUQCPz8/5OXlCX/9k/8f9PT0IJVKUVtbi9bWVgBAcXExGGPYuHEjDA0NUVRUJNSXyWSwt7fH1KlTAdwalUlPT4e5uTk2btwoatvX1xcLFy5EQ0MDvv7664d3UERk06ZNsLGxEf5tYWEBPz8/9PT0oL6+XqO+n58fFixYIIqp1WrEx8fDwcEBkZGR0NPTE8pMTEzw+uuvQ6VS4ezZs2OqTwgRo6lYMiKVlZUAxNNoPD4ml8tF8Tlz5mjUtbOzAwB0dXUJsW+++QYAUF9fr/XRC62trVCr1aivr8fPf/7zsR0AeSCkUin+/e9/QyaT4dlnn4VMJoOxsTG8vLwwd+5cYfq1oaEBTU1NCAkJEbatq6tDX18fpFIpjIyMtLZdWFiIyspKmo79kWj7Hba1tQUAdHd3a5S5ublpxOrr69HZ2QkbGxscPHhQo7yjowPArethLPUJIWKU2JERUSqV0NfXh4WFhUaZlZUV9PT0NEbUTExMNOpOmDABAESLrzs7OwEAX3755bB9uHnz5qj7TR4sPqm/O7Hz9vaGgYEBpFIpDh8+DKVSqXV9HX+9WFlZaW3b2tpaVI88fNp+hw0Mbn1tDA4OapRZWlpqxK5fvw4AqK6uRnV19ZD74n+/R1ufECJGiR0ZERMTE6jVanR0dGj8593e3g7GmNYvgZG2DQD/+Mc/sGjRoh/cV/LwzJo1C1ZWVpDJZGhvb0dNTY0w3S6VSnHgwAGUlpZqTez4897W1qa1bT4+1uuKPHx3T5vy+PMXGBiI/fv337eN0dYnhIjRGjsyIi4uLgDu3Nl4t+LiYgCAs7PzmNrmp2/4KVny/ws/yqpthAa4dYdlQ0MDTp48CQCYP38+AMDd3R2TJ09GUVERZDIZnnzySWEaDwBmzpyJSZMmoby8XOvoC3+t8dceGV/3O6/jxdHRESYmJvjf//4HlUo17vUJIWKU2JERWblyJQDg0KFDoqmx7u5uYR0MX2e0/P39MW3aNMTExKCkpESjXKVSobS0dExtkx/OzMwMANDU1KS1nB+FO3LkCMzNzYUE39DQEJ6enjh58iRaW1s11mcaGhpi+fLl+P777/HJJ5+IyvLz8/HVV1/hZz/7GTw9Pcf7kAjuf17Hi4GBAV588UUoFAp88MEHWpO1qqoqtLe3j6k+IUSMpmLJiHh7eyMsLAyxsbF49tlnsWTJEjDGkJmZiaamJoSFhcHb23tMbRsaGuKjjz7Ca6+9htDQUMyfPx8cx0FPTw/Xrl1DaWkpzM3NNR6ESx6OmTNnwsbGBunp6TA0NIStrS309PQQFhYGU1NTIWHr6OhAQEAA9PXv/L0olUpx/vx54ed7bdmyBSUlJfj4449RVlYGd3d3KBQKZGRkwMjICLt27RK1R8bPcOd1vEVGRqKiogKxsbHIy8uDRCKBpaUlmpubUVVVBblcjsTERGGZx2jrE0LuoMSOjNiOHTvg4uKC+Ph4JCUlAbi1xioyMlJYVzVWbm5uSEtLw2effYb8/Hx8/fXXwpeNv78/li9fPh6HQMZgwoQJOHjwIPbs2YNTp06hp6cHABAcHAxTU1PMmDEDtra2aG5uFqZheXcnc3c/BJdnYWGBpKQkHD58GDk5Ofjvf/8LExMT+Pn5ISIiAhzHPdiDe4QNd17Hm6GhIY4cOYLk5GT861//QmZmJvr7+2FlZQVHR0f8+te/Fp3r0dYnhNyhxxhjP3YnCCGEEELID0dzHIQQQgghOoISO0IIIYQQHUGJHSGEEEKIjqDEjhBCCCFER1BiRwghhBCiIyixI4QQQgjREZTYEUIIIYToCErsCCGEEEJ0BCV2hBBCCCE6ghI7Qn5iUlJS4OTkhKioKFFcJpPBycnpgbzrUxsnJyc4OTk9lH0RQggZGUrsCCEawsLC4OTkBJlM9mN3hRBCyCgY/NgdIISMDzc3N5w+fRpGRkYPZX+nT59+KPshhBAycpTYEaIjjIyM4Ojo+ND29zD3RQghZGQosSOPPH6d2MWLF5GUlISEhATU1dXBwMAAHh4eeP311zF37lyN7RYvXgyFQoHs7GzI5XIcO3YMcrkcnZ2dOHbsGKRSKQCgs7MTR48eRXZ2Ni5fvgy1Wg0HBwcEBQXhd7/7ndYRtoGBAcTFxeHEiRO4dOkSjI2N4e3tjYiIiCGPQyaT4aWXXsK8efMQGxurUd7Z2YnY2Fjk5OSgoaEBKpUK1tbWcHV1xapVq+Dr6yu0wbv7ZwDYvXs3Vq1apfG53ev69euIjo5GdnY2rl69Cn19fcyYMQNBQUEICwvD5MmTh+x7dHQ0YmJicPLkSVy5cgVGRkbw9vbGm2++OeJk8vLlywgMDISJiQny8/OHHMVcvnw5ampq8Omnn8LX11eIDwwMIDU1FWlpabh48SJu3LgBGxsb+Pj4YMOGDZg6dapGW5mZmcjLy8OFCxfQ3NyM3t5eWFtbQyqV4rXXXsPMmTM1tomKikJqaip2794NV1dXHD58GKWlpWhvb8emTZuwefNmAMCZM2eQmJiIyspKKJVKmJiYwNLSEp6enggNDYWzs/OIPhdCiO6jxI6Q23bv3o2jR4/C09MTfn5+qKqqQn5+Ps6fP499+/YhICBA63YxMTGIi4uDq6srfHx80NLSggkTJgAAampq8Oqrr6KxsRHW1tbw8vKCgYEBysvL8dFHHyEzMxOxsbEwNTUV2lOr1fj973+PrKwsTJw4EVKpFI899hguXLiA1atX4/nnnx/1scnlcqxbtw7Nzc0wNTWFl5cXjI2N0djYiNzcXHR0dMDX1xdWVlZYuXIlCgoK0NbWhl/+8pewtrYW2nFwcLjvvq5cuYLw8HAoFApYWFjA19cXKpUKMpkMe/bswZkzZxATEwMzMzONbVUqFdatW4eysjJIJBI4Ojri22+/xdmzZyGTyZCamoonnnjivn1wcHCAr68vzp07hy+//BIvvPCCRp2ioiLU1NTAwcEBTz/9tBBXKpXYuHEjiouLMWXKFLi6uuLxxx9HVVUVEhISkJGRgZiYGMyePVvU3htvvAFDQ0M4Ojpi/vz5GBgYQHV1NVJSUpCRkYHPP/8cnp6eWvtbVlaGd999F9bW1pBIJOjt7YWxsTEA4ODBgzhw4IDwh4atrS26u7vR2NiI5ORkzJo1ixI7QsgdjJBHHMdxjOM45ubmxs6fPy8qO3LkCOM4jnl5ebG2tjZR2aJFixjHcczFxYVlZWVptHvz5k3m7+/POI5jf//731lfX59QduPGDfbWW28xjuNYVFSUaLu4uDjGcRxbsGABq6mpEeIqlYq9++67Qn+3bdsm2q6oqIhxHMdCQ0NF8Z6eHubr68s4jmNbt25lSqVSVN7V1cUKCwtFsdDQUMZxHCsqKhrqYxP6ca/Vq1czjuPYhg0bWE9PjxBvb29nK1euZBzHsbfeektr3zmOYytWrGAtLS1CWW9vL3v55ZcZx3Hs7bffHrI/9yosLGQcx7Hg4GCt5Zs3b2Ycx7Ho6GhRnD8v69ev1zjnMTExjOM4tmTJEjYwMCAqS09PFx0vY4yp1WrhfC5fvpyp1WpR+bZt24Tj3rNnDxscHBSV9/X1MTc3NzZ37lxWW1urcQxXr14VXSOEEEJ3xRJy25o1a/CLX/xCFHv11Vfh6uqK7u5uHD9+XOt2K1asgJ+fn0Y8NTUVly9fxqJFi4TRHJ6RkRF27twJS0tLpKWlobOzUyg7evQoACAiIkI09WhgYIA//vGPohG0kTh+/DgaGxvh4uKCXbt2CSNBPFNTUyxYsGBUbQ6ltLQUFy5cgJGREf70pz9hypQpQpmFhQV27twJ4NaNF01NTRrb6+npYffu3aJjnDRpEiIjIwEA58+fH3FfFixYgKeeegpyuRylpaWisqamJmRnZ8PIyEg0AlpbW4v09HTY2Nhgz549sLS0FG3329/+Fr6+vrh06RLy8/NFZcuWLRMdL388a9euhYeHB6qrq1FbW6u1r08++STeeOMN6OuL/0tWKpXo7e2Fvb291qnc6dOn01pHQogIJXaE3LZy5Uqt8RUrVgAAiouLtZYHBgZqjefl5QEAgoKCtJYbGxvD1dUVAwMDKC8vBwA0NzejoaEBABAcHKyxzaRJk7B06dKhD0KLgoICAEBISIgwRfyg8J+Rj48PrKysNMpdXV3h7OwMtVqt9fOcNm2a1mlFPnlpbm4eVX/4Z/p98cUXonhCQgIGBgbw3HPP4bHHHhPieXl5YIzh6aefhomJidY2582bB+DW9Om9GhoaEBcXhz//+c/Yvn07oqKiEBUVhba2NgBAfX291jb9/f21nhsLCwtMnz4dFy9exF/+8hfU1NSM4KgJIY8yWmNHyG1Drd3i49pGmIbb7sqVKwCArVu3YuvWrcPuu6OjQ7SPxx9/XGNk7X77G8q1a9cAQOuIz3jjE6/h+ujg4AC5XK41SdN2UwIAIcnq7+8fVX+Cg4Oxd+9enD17Fi0tLbCxsUF/f78w+rp27VpRff6cJScnIzk5edi2+XMGAIODg9i5cycSExPBGBtyG6VSqTU+ffr0Ibf561//isjISMTExCAmJgbm5uZwc3PDwoULERwcDAsLi2H7SQh5tFBiR8gIDfWFPWnSJK1xtVoNYOjRq7tNmzbth3VOR9w7FflDGRkZYfXq1fjss8+QlJSEiIgIZGZmoq2tDRKJRGN0kD9nLi4u970hwd3dXfj52LFjSEhIgLW1NaKiouDh4QErKyvh2vjDH/6AU6dODXkN3XuX8N0kEglycnKQm5uLkpISlJWV4auvvkJ+fj7279+PQ4cOaSwhIIQ8uiixI+S2q1evwsXFRSOuUCgAAHZ2dqNqb+rUqairq0NISMiIp09tbW0BAN9//z16enq0jtrx/RlNP2pra1FXVzdua+mGwvefH/nShi/j6z5oa9euRUxMDBITE7F+/XrExcUJ8XvxI4aenp545513RryPM2fOAADee+89restL126NIae3zF58mQsXbpUuI46Ojqwb98+JCYmYvv27Th37twPap8QojtojR0ht508eXLYOL+2aqT4R2jwX/ojYWdnB3t7ewDAqVOnNMr7+/uRkZExqn74+PgAAE6cOIHBwcERbTNx4kQAGHF9Hv8Z8Y9LuVdFRQUqKyuhr68Pb2/vUbU9VtOmTYO/vz9aWlqwf/9+lJWVwcbGBkuWLNGoy5+znJwc9PX1jXgf/M0v2qZUq6urIZfLx9h77SwsLLBlyxYAt6ba7775hhDyaKPEjpDb4uPjNd6N+s9//hPffvstjI2NERISMqr2XnjhBUyfPh0ZGRn48MMPta6vam1tRVJSkigWHh4OADhw4IDoLsrBwUF88MEHaGlpGVU/Vq9eDTs7O1RUVGDHjh24ceOGqFypVGrcbcqPplVXV49qXxKJBO7u7ujt7cU777yDmzdvCmUdHR3CKNiyZcuGXE/3IPAPWv70008B3LoD2sBAc8Ji9uzZCAwMRGNjIyIiInD16lWNOjdu3EBaWpooceXXL37xxRfCdC4AtLS0YNu2bRgYGBhTvxUKBY4fP6712snJyQEAmJmZDXmjByHk0UNTsYTctmbNGoSHh0MikcDW1hZVVVWoqqrChAkTsGvXrlE/ZmTKlCn45JNPsH79emGNl5OTE2xtbdHb24tLly6htrYWlpaWogforl27FoWFhTh37hx+9atfQSqVwszMDBcuXEBraytefPFFxMfHj7gfxsbG+Pjjj7Fu3TqkpKQgKysLnp6emDJlChobG1FZWQk3NzfRNG1gYCBSUlLw4Ycf4j//+Q8sLCygp6eH559/fsiH7PL27t2L8PBwZGdnw8/PDxKJBAMDA5DJZFAqlZgzZ86opjnHg0QiwezZs1FRUYGJEydizZo1Q9bdtWsXurq6kJ+fj6VLl8LZ2RlPPPEEGGNQKBSQy+VQqVQ4ffq0sHZyw4YNKCgoQFJSEmQyGWbPng2lUomSkhLY29sjICAAZ8+eHXW/u7q6sGPHDrz33ntCP4Bbd99WVFRAT08PW7ZseeB3OxNCfjoosSPktu3bt2PGjBlITExEeXk5DAwM4OPjg02bNt03mRnKU089hbS0NCQkJCArKwsXL17EN998A3Nzc9jZ2eHll1/WeKOFvr4+Dh48iNjYWCQnJwtvQPDy8sKhQ4dQUVExqsQOuDUSlZaWhmPHjiE7OxvFxcVQq9WwtrbG4sWLhdeE8Z555hm8//77iI+PR1FRkTDy5uXldd/Pwt7eHikpKYiOjkZWVhZyc3NFrxR76aWXhr1Z4EFZuHAhKioqEBgYOGySbmJigujoaJw+fRppaWn47rvvIJfLYWxsDBsbGzz33HPw8/MTvYXD3d0dJ06cwL59+1BeXo6cnBxMnToVoaGh2LhxI95///0x9dne3h7bt29HSUkJqqurhUfo2NjYYMWKFQgLC4Orq+uY2iaE6CY9Nty9+YQ8AoZ75ynRDYODgwgICIBCoUBCQgI8PDx+7C4RQsgDQWvsCCE6LzExEQqFAh4eHpTUEUJ0Gk3FEkJ0Ul1dHT7//HO0tbWhoKAA+vr6931QNCGE/NRRYkcI0Umtra1ITk7GxIkTMWvWLGzevHnMayUJIeSngtbYEUIIIYToCFpjRwghhBCiIyixI4QQQgjREZTYEUIIIYToCErsCCGEEEJ0BCV2hBBCCCE6ghI7QgghhBAdQYkdIYQQQoiOoMSOEEIIIURHUGJHCCGEEKIj/g/0wqqNqmvidgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 651.5x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "data = {'mse': np.concatenate(mse_list, axis=0),\n",
    "        'methods':category,\n",
    "        'prediction years':pred_len}\n",
    "data = pd.DataFrame.from_dict(data)\n",
    "sns.set(style=\"whitegrid\")\n",
    "plt.xticks(rotation=30)\n",
    "color_palette = [\"#FF0000\", \"#8C564B\",  \"#2CA02C\", \"#FFCC00\", \"#1F77B4\", \"#9467BD\",\"#FF7F0E\"][::-1]\n",
    "\n",
    "g = sns.catplot(x=\"prediction years\", y=\"mse\", hue=\"methods\", kind=\"point\", data=data, palette=sns.color_palette(color_palette),ci=None)\n",
    "plt.yticks(fontsize=14)\n",
    "plt.xticks(fontsize=14)\n",
    "plt.xlabel(\"prediction years\",fontsize=16)\n",
    "plt.ylabel(\"MSE\",fontsize=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(62.853375, 0.5, 'MAE')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 651.5x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "data = {'mae': np.concatenate(mae_list, axis=0),\n",
    "        'methods':category,\n",
    "        'prediction years':pred_len}\n",
    "data = pd.DataFrame.from_dict(data)\n",
    "sns.set(style=\"whitegrid\")\n",
    "plt.xticks(rotation=30)\n",
    "\n",
    "g = sns.catplot(x=\"prediction years\", y=\"mae\", hue=\"methods\", kind=\"point\", data=data, palette=sns.color_palette(color_palette),ci=None)\n",
    "plt.yticks(fontsize=14)\n",
    "plt.xticks(fontsize=14)\n",
    "plt.xlabel(\"prediction years\",fontsize=16)\n",
    "plt.ylabel(\"MAE\",fontsize=16)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch211",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}