{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Different Prediction Horizons in PRE"
   ]
  },
  {
   "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": [
    "base_dir = \"./log/prediction_46_46/PRE/\"\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)\n",
    "prediction_pde = np.load(\"./data/PRE/cmoms.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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='PRE', 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": 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()\n",
    "prediction_pde = torch.from_numpy(prediction_pde)\n",
    "prediction_pde_oneyear = [prediction_pde[i:i+46] for i in range(322-46)]\n",
    "prediction_pde_oneyear = torch.stack(prediction_pde_oneyear, dim=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.073147625\n",
      "0.18426761\n",
      "0.13500492\n",
      "0.14994895\n",
      "0.17269786\n",
      "0.17230226\n",
      "0.08720154\n",
      "0.36229101456665624\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",
    "mse_pde = (((prediction_pde_oneyear - labels[:276])*label_masks[:276])**2).sum([0,1])/(label_masks[:276].sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_pde))\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",
    "mse_pde[mse_pde==0]=np.nan\n",
    "\n",
    "category.extend([\"CMOMS\" 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([\"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_pde.numpy(), 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.19770662\n",
      "0.3561439\n",
      "0.29954606\n",
      "0.31450367\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.34601954\n",
      "0.34509417\n",
      "0.21909997\n",
      "0.4754564140362484\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",
    "mae_pde = (np.abs((prediction_pde_oneyear - labels[:276])*label_masks[:276])).sum([0,1])/(label_masks[:276].sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_pde))\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",
    "mae_pde[mae_pde==0]=np.nan\n",
    "\n",
    "mae_list.extend([mae_pde.numpy(), 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/PRE/\"\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)\n",
    "prediction_pde = np.load(\"./data/PRE/cmoms.npy\")"
   ]
  },
  {
   "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()\n",
    "prediction_pde = torch.from_numpy(prediction_pde)\n",
    "prediction_pde_twoyear = [prediction_pde[i:i+92] for i in range(322-92)]\n",
    "prediction_pde_twoyear = torch.stack(prediction_pde_twoyear, dim=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.07450346\n",
      "0.18809351\n",
      "0.13591254\n",
      "0.14446642\n",
      "0.15794146\n",
      "0.16716537\n",
      "0.18573698\n",
      "0.4082120755015494\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",
    "mse_pde = (((prediction_pde_twoyear - labels[:230])*label_masks[:230])**2).sum([0,1])/(label_masks[:230].sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_pde))\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",
    "mse_pde[mse_pde==0]=np.nan\n",
    "\n",
    "\n",
    "category.extend([\"CMOMS\" 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([\"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_pde.numpy(), 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.20153603\n",
      "0.35937086\n",
      "0.29741377\n",
      "0.30319464\n",
      "0.32018575\n",
      "0.33398306\n",
      "0.35080168\n",
      "0.4994291208859563\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",
    "mae_pde = (np.abs((prediction_pde_twoyear - labels[:230])*label_masks[:230])).sum([0,1])/(label_masks[:230].sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_pde))\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",
    "mae_pde[mae_pde==0]=np.nan\n",
    "\n",
    "mae_list.extend([mae_pde.numpy(), 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/PRE/\"\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)\n",
    "prediction_pde = np.load(\"./data/PRE/cmoms.npy\")"
   ]
  },
  {
   "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()\n",
    "prediction_pde = torch.from_numpy(prediction_pde)\n",
    "prediction_pde_threeyear = [prediction_pde[i:i+138] for i in range(322-138)]\n",
    "prediction_pde_threeyear = torch.stack(prediction_pde_threeyear, dim=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.07705605\n",
      "0.18486586\n",
      "0.1411465\n",
      "0.14870067\n",
      "0.18185502\n",
      "0.1703397\n",
      "0.22432613\n",
      "0.41801514200460854\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",
    "mse_pde = (((prediction_pde_threeyear - labels[:184])*label_masks[:184])**2).sum([0,1])/(label_masks[:184].sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_pde))\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",
    "mse_pde[mse_pde==0]=np.nan\n",
    "\n",
    "category.extend([\"CMOMS\" 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([\"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_pde.numpy(), 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.20486438\n",
      "0.35579094\n",
      "0.30123833\n",
      "0.3114494\n",
      "0.35605833\n",
      "0.336675\n",
      "0.3990384\n",
      "0.5056797745910621\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",
    "mae_pde = (np.abs((prediction_pde_threeyear - labels[:184])*label_masks[:184])).sum([0,1])/(label_masks[:184].sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_pde))\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",
    "mae_pde[mae_pde==0]=np.nan\n",
    "\n",
    "mae_list.extend([mae_pde.numpy(), 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": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHqCAYAAACJGANcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8WgzjOAAAACXBIWXMAAA9hAAAPYQGoP6dpAACtqElEQVR4nOzdeVxU1f/H8dcMM8O+iggq7oCmoqK4pKWppYllbq3umlt7ubX5a7E0My1308yyTUtRU79mqVlq7hbua4oboLLvM8z9/TEyMbINyDLA5/l48ADOPffeMyjw5pxzz1EpiqIghBBCCCEqPHV5N0AIIYQQQpQMCXZCCCGEEJWEBDshhBBCiEpCgp0QQgghRCUhwU4IIYQQopKQYCeEEEIIUUlIsBNCCCGEqCQk2AkhhBBCVBIS7MrQ6dOnOX36dHk3QwghhBCVlKa8G1CVZGZmlncThBBCCFGJSY+dEEIIIUQlIcFOCCGEEKKSkGAnhBBCCFFJSLATQgghhKgkJNgJIYQQQlQSEuyEEEIIISoJCXZCCCGEEJWEBDshhBBCiEpCgp0QQgghRCUhwU4IIYQQopKQYCeEEEIIUUlIsBNCCCGEqCQk2AkhhBBCVBIS7IQQQgghKgkJdkIIIYQQlYQEOyGEEEKISkJT3g0QQghReehvpBK/4TwAHo82RFvdqZxbJETVIj12QgghSoSiKMT+eIaMs/FknI3n5pfHyYhMRFGU8m6aEFWG9NgJIYS4a/roFGJ/PIP+SrK5LCs2nRsL/0Fb2wWvgYFoaziXYwuFqBqkx04IIcRd0UenELMowiLUWRy/kmw6Hp1Sxi0TouqRYCeEEKLYsodflXRDwfXSDaZ6MiwrRKmSoVghhBC5KIqCkmnEmKLHmKInKznzv49T9BiTTR/rY9PJupFm1TX1V5LJvJyEfR23Um69EFWXBDshhKgCzEEtOdMUzMyBLe+PjSl6FL2xxNuRfuKWBDshSpEEOyGEqIBMQS0LY7JlD1quj29/npWiB0PJB7WiMqYVPGQrhLg7EuyEEMIGFD2oZYLBBuarqYAiNEPtKL92hChN8h0mhBClQFEUlIysAoc7TaEt0/yxTQQ1jQo7Zy3q2292LrocH+cod9aidtGij07hxqIIqy/vcE+1Umy8EEKCnRCiVFS2HQjMQS2vHrXbAS3X0GeWDQW12wHNHNpc8v5YZW+HSqWy+vK6Om5oa7vku9RJTtraLuj8Xe/m1QghCiHBTghR4rKXwNBHJgFw88vjeD0ZhM7ftUihoTRlBzVzD5o5qGXmOwxqG0FNbe4tKzSouWhR6YoW1IpKpVLhNTCQmEURBS55onLQ4DUw0Gb+/YWorFSKLCpUZo4ePQpA8+bNy7klQpSevHYgyFaaOxAoioKSnlVgD9qdH9tMUMs5xJnHcOd/H+tQ6dQ2GY7K699dCGFJgl0ZkmAnKrvsHQgK67nxGRdc6C95c1DLuX5arvlplsOhthDUVFp17h60OwNbjnlrthrUikNRFDIvJ5F+4hbGNANqRw0O91SzqZ5aISo7GYoVQpSIouxAcOubk7g9VBdjqiH/HrVUGw5q5o91ucrVOrvybnK5UalU2Ndxk3XqhChHEuyEECUi83KSVRPoAQw30oj99lQptyhveQc1Xb5z1apyUBNCVDwS7IQQJSL9xK1yua9Kp7Z6aQ61swQ1IUTlJsFOCHFXFIORtOO3SDkcUyLXU+nUVi/NIUFNCCEsSbATQhSLPiqFlANRpB6JwZha9G2i7Bu449S6hsXSHHbOWlRaCWpCCFFcEuyEEFYzphtIjbhByoFo9JeT7upabj3rySR7IYQoYTYd7CIiIpg3bx5HjhzBYDAQGBjIsGHD6NWrV7Gul5CQQO/evYmJiaFTp0588cUXedb7888/WbJkCcePH0elUtG0aVPGjx9Phw4d7ublCFEhKYpC5qVEUg5EkxZxA0VfwEbyahUYC3+SVXYgEEKI0mGzwW7v3r2MGjUKnU5HWFgYzs7ObN26lVdeeYWoqChGjBhR5Gu+9957JCcX/NTe+vXrmTRpEl5eXvTr1w+AzZs3M3z4cD799FN69uxZrNcjREWTlZxJ6uEYUg5EYbiRln9FNTg0roZzaA3s3O258flR2YFACCHKiU0uUGwwGHj44YeJiopi9erVNGnSBICkpCQGDBjA1atX+eWXX6hVq5bV1/zll1948cUXmTp1Ku+9916ePXYJCQl0794dOzs71q1bh6+vLwBRUVE89thjAPz222+4uLgU63XJAsXC1ilGhfSzcaTujyLtZGyBvW8ab0ec2tTAuXUN7Fx15nLZgUAIIcqPurwbkJe9e/cSGRlJ7969zaEOwNXVlbFjx6LX6wkPD7f6erGxsbzzzjv06dOHzp0751tvy5YtJCYmMmjQIHOoA/D19WXQoEHExcXx22+/Fe9FCWHDDLHpJGy9SNRH+7n15XHSjt/KM9SptGqcQnyoPjqYGq+1xq2Lv0WoA9DWcMbnuZZ4PhWEnac9du46nNvWoPr4Fvg811JCnRBClCKbHIrdv38/AJ06dcp1LLvswIEDVl/v//7v/7Czs+PNN98kKSn/Cd+F3XfevHns37/f3HsnREVmXqbkQBQZ5+ILrKut5YJzqC9OLaujdij8x4ZKpcK5hQ/OLXxKqLVCCCGsYZPB7uLFiwDUrVs317Hq1avj5OTEpUuXrLrW+vXr2bp1KwsWLMDd3b3AYFfQfbPLrL1vfhRFITU19a6uIcTdMESnkXHkJplHb6GkZeVbT+Vgh665F/atvNH4OgGQbsyE1MyyaqoQFZKTk1N5N0FUYTYZ7LIfcHB1zfupORcXlwIDWrbo6Gg++OADevfuTffu3e/qvtnz6qy5b0H0ej0nT568q2sIUVQqvYLD5Swc/zWgjS3gqVYgw0dNen0N6bXswC4F4lIgrowaKkQl0Lp16/JugqjCbDLYlZS33noLjUbDm2++Wd5NMdNqtTRq1Ki8myGqAEVRMFxOMfXOnYiDApYpUblqsW9RDfuW3th52ZdhK4UQQpQkmwx2hfWOJScn4+7uXuA1wsPD+eOPP/jss8/w8vIq8n09PT1z3RPy70W0lkqlkm56UaqsX6ZEhUNjL5xDa+AQ6IXKTpYfEUKIis4mg129evUA03y2Zs2aWRy7ceMGqampBAcHF3iNEydOAPDSSy/leXzXrl0EBQXRuHFj1q9fb77vsWPHuHTpUq5glz23Lq/5d0KUN8WokH4mjtQD1i1T4hxaA6eQGrmeaBVCCFGx2WSwCw0NZcmSJezatYuwsDCLY7t27TLXKUirVq3yfEghNTWVzZs34+vrS6dOnfDz87O478aNG9m1axctW7bM875t27YtzksSolQYYtNJORhF6qFoshLyf6hBpVXj2Nwb51BfdPXcZHFgIYSopGx2geKePXsSHR2d7wLFW7ZsoXbt2gDExMSQlJSEj49PoUOlV65coVu3bvkuUNytWzc0Go0sUCxslqI3knbiJikHogtfpqS2C85trF+mRAghRMVmkz/pNRoN06ZNY9SoUTzzzDMWW4pdvXqVyZMnm0MdwOzZswkPD2f69OnmbcCKw93dnbfffptJkybRt29f8560mzdvJj4+njlz5hQ71AlxtzKvp5B6IIqUIzEoaQVs2eWowbmVD05taqCrKf9fhRCiKrHJYAfQvn17vvvuO+bOncvmzZsxGAwEBgYyYcIEc+AqDX369MHT05MlS5awdu1aAJo1a8a4ceO49957S+2+QuTFmG4g9Z8bpByIynOLrpzsG7rjHOqLY1NvVFqb3FRGCCFEKbPJodjKSoZihTUURSHzUiIpB6JJi7iBUsAyJWo3Hc6ta+Dcpgaaao5l2EohhBC2yGZ77ISoarKSbi9TctCKZUqaeOEc6otDgKcsUyKEEMJMgp0Q5Sh7mZKUA1GkW7VMiS9OIT6yTIkQQog8SbATohyYlyk5GE1WohXLlLT1RVdXlikRQghRMAl2QpQRRW8k7fhNUg5auUxJqC9OLWSZEiGEENaT3xhClDJZpkQIIURZkWAnRCko0jIljTxwblNDlikRQghx1yTYCVFCFEUh82IiKQeiSDt6s8BlSuzcdDi1qYFza1mmRAghRMmRYCfEXTIvU3IgCsNNK5cpCfREpZYHIYQQQpQsCXZCFIOSpZB+1splSqo7mvZrlWVKhBBClDIJdkIUgeFWGikHo0k9ZMUyJcHVcQ6tIcuUCCGEKDMS7IQohHmZkgNRZJxPKLCuLFMihBCiPMlvHiHykXktmdSD0dYvUxLqi87PuQxbKIQQQliSYCdEDsZ0A6l/3yDloJXLlITWwPEeWaZECCGEbZBgJ6o8WaZECCFEZSHBTlRZpmVKokk5EF3oMiWOTbxwkmVKhBBC2DgJdqJKUbIU0s/EknIgmvRTtyD/zjnTMiWhvji1kmVKhBBCVAwS7ESVkL1MScqhaIyyTIkQQohKSoKdqLTMy5TsjyLjQiHLlPi74tymhixTIoQQokKT32Ci0sm8lkzKgShSj9xASc9/mRK1kwanVj44h/qi9ZVlSoQQQlR8EuxEpWBepuRAFPqrskyJEEKIqkmCnaiwFEUh899EUg4WYZmSNr5ovBzKsJVCCCFE2ZFgJyqcrKRMUg5Fk3rQymVK2vriECDLlAghhKj8JNiJCqFYy5SE+GDnIsuUCCGEqDok2AmbJsuUCCGEENaTYCdsjqLPIu3YLVIOWLlMSWgNnIJlmRIhhBBCfhOKUqUoCqkRN0jcchGMCg5Bnji18UXn75qrV02WKRFCCCHujgQ7UWr00SnE/ngG/ZX/lh9J2R9Nyv5otLVd8BoYiJ2bPan/xJByILrwZUoCPHBu44tj02qoNLJMiRBCCHEnCXaiVOijU4hZFJFvz5v+SjLRc4+ACjAo+V7Hzl2HU2tZpkQIIYSwhgQ7UeIURSH2xzMFDqcCkJVPoFOrcLzHC+dQX+xlmRIhhBDCahLsRInLvJxkMfxqLVmmRAghhLg7EuxEiUs/catI9TW+Tnj2DUBXJ/cDFUIIIYSwngQ7UeKMaYUMwd7Bvq4b9nXdSqk1QgghRNUhjxaKEqd2LNrfC0WtL4QQQoi8SbATJc7hnmqlWl8IIYQQeZNgJ0qczt8VbW0Xq+pqa7ug83ct5RYJIYQQVYMEO1HiVCoVXgMDURWyxZfKQWOqJw9MCCGEECVCgp0oFdoazviMC863505b28V0vIZsCSaEEEKUFJm1LkqNtoYzPs+1JPNyEuknbmFMM6B21OBwT7U894oVQgghxN2x6WAXERHBvHnzOHLkCAaDgcDAQIYNG0avXr2sOn/nzp2sW7eOkydPcvPmTfR6PX5+foSEhPDss89Sv379XOcEBQXle72+ffsyY8aMYr+eqkilUmFfxw37OrKciRBCCFHabDbY7d27l1GjRqHT6QgLC8PZ2ZmtW7fyyiuvEBUVxYgRIwq9xh9//ME///xDcHAwPj4+aDQaLly4wLp16/j555/5/PPP6dChQ67zatWqRd++fXOVN2nSpERemxBCCCFEaVApipL/DuzlxGAw8PDDDxMVFcXq1avNgSopKYkBAwZw9epVfvnlF2rVqlXgdTIyMrC3t89V/tdffzFs2DCaNWvGmjVrLI4FBQXRtm1bVq5cWXIv6LajR48C0Lx58xK/thBCCCGETT48sXfvXiIjI+ndu7dFL5mrqytjx45Fr9cTHh5e6HXyCnUAHTp0wN3dncjIyBJrsxBCCCFEebPJodj9+/cD0KlTp1zHsssOHDhQ7OsfOXKEhIQEWrdunefxxMREVq1aRVxcHO7u7oSEhBQ4904IIYQQwhbYZLC7ePEiAHXr1s11rHr16jg5OXHp0iWrr7dr1y6OHDlCZmYmly5dYseOHXh6evL666/nWf/UqVNMnTrVouy+++7jo48+olq1u9slQVEUUlNT7+oaQgghbJeTk1N5N0FUYTYZ7JKTkwHT0GteXFxcSEpKsvp6u3fvZvny5ebP69aty+zZs2nWrFmuuiNGjOChhx6iXr16aLVazp49y8KFC/njjz8YM2YMq1atws7Oroiv6D96vZ6TJ08W+3whhBC2Lb/RICHKgk0+PDFixAh2797N1q1b8+y1u++++0hNTeXQoUNFum5KSgrnz59nwYIF7Nmzhw8//JBHHnmk0POMRiNDhw5l//79zJs3j4ceeqhI98129OhRFEWhUaNGxTpfCCGE7ZMeO1GebLLHzsXFtFtBfr1yycnJuLu7F/m6zs7OBAcHs2DBAvr378/UqVPp2LEjXl5eBZ6nVqsZOHAg+/fv5/Dhw8UOdmBa102+6YUQQghRGmzyqdh69eoB5DmP7saNG6SmpubZk2ctjUZDu3btSE1NNS9BUhhPT08AmR8nhBBCCJtlk8EuNDQUMD30cKfssuw6xRUTEwOAVqu1qv4///wDQO3ate/qvkIIIYQQpcUmg12HDh3w9/dn48aNFg8aJCUlsXjxYrRaLY899pi5PCYmhvPnz+caus2vN+7PP//kt99+w83NjZYtW5rLT58+jV6vz1X/8OHDLFu2DK1WS8+ePe/uxQkhhBBClBKbnGOn0WiYNm0ao0aN4plnnrHYUuzq1atMnjzZouds9uzZhIeHM336dPr162cuHzBgAIGBgQQGBuLr60taWhqnT5/m4MGDaLVaPvzwQ4v5bl9++SW///47rVu3xs/PD41Gw9mzZ9m9ezcqlYqpU6dSp06dMv1aCCGEEEJYyyaDHUD79u357rvvmDt3Lps3b8ZgMBAYGMiECRPo1auXVdd49dVX2bdvHwcOHCA2Nha1Wo2fnx9PPPEEQ4cOpWHDhhb1u3XrRmJiIqdOnWLPnj3o9Xq8vb0JCwtj6NChBAcHl8ZLFUIIIYQoETa53EllJXvFCiGEEKI02eQcOyGEEEIIUXQS7IQQQgghKgkJdkIIIYQQlYQEOyGEEEKISkKCnRBCCCFEJSHBTgghhBCikpBgJ4QQQghRSUiwE0IIIYSoJCTYCSGEEEJUEhLshBBCCCEqCQl2QgghhBCVhAQ7IYQQQohKQoKdEEIIIUQlIcFOCCGEEKKSkGAnhBBCCFFJSLATQgghhKgkJNgJIYQQQlQSEuyEEEIIISoJCXZCCCGEEJWEBDshhBBCiEpCgp0QQgghRCUhwU4IIYQQopKQYCeEEEIIUUlIsBNCCCGEqCQk2AkhhBBCVBIS7IQQQgghKgkJdkIIIYQQlYQEOyGEEEKISkKCnRBCCCFEJSHBTgghhBCikpBgJ4QQQogyN2/ePIKCgoiNjS31e3Xt2pUpU6aU+n1sgQQ7IYQQQpSaxYsX89tvv5V3M6oMCXZCCCGEKDVLliyRYFeGJNgJIYQQQlQSEuyEEEKIKih7jtu///7LhAkTaN26Ne3bt+fTTz9FURSuX7/OuHHjCAkJoWPHjixfvtzi/MzMTObOncuDDz5Is2bN6Ny5MzNnziQzM9NcJygoiNTUVMLDwwkKCiIoKCjXXLekpCSmTJlCmzZtaN26Na+//jppaWkWdQwGAwsWLKB79+40a9aMrl27Mnv2bIt7ASiKwsKFC7n//vtp0aIFgwcP5uzZs7leu16vZ/78+Tz00EM0b96cdu3a8dRTT7F79+67/bKWO015N0AIIYQQ5eeVV16hYcOGvPbaa+zcuZNFixbh4eHBDz/8QPv27ZkwYQI///wzH330Ec2bNyc0NBSj0ci4ceM4dOgQjz/+OA0bNuTMmTN89dVXXLx4kYULFwIwc+ZM3nrrLYKDg3n88ccBqFOnjsX9X375ZWrXrs2rr77KiRMn+PHHH/Hy8mLixInmOm+99Rbh4eH06NGD4cOHExERwZIlSzh//jwLFiww1/vss89YtGgRnTt3pnPnzhw/fpwRI0ag1+st7jl//nyWLFnCwIEDCQ4OJjk5mWPHjnH8+HE6duxYWl/qsqGIMhMREaFERESUdzOEEEIIZe7cuUpgYKDy9ttvm8sMBoNy//33K0FBQcqSJUvM5QkJCUpwcLAyefJkRVEUZd26dUrjxo2VAwcOWFzz+++/VwIDA5VDhw6Zy1q2bGk+L6/7v/766xblzz33nNK2bVvz5ydPnlQCAwOVN99806LejBkzlMDAQOWvv/5SFEVRbt26pTRt2lQZPXq0YjQazfVmz56tBAYGWrTh0UcfVUaPHl34F6kCkqFYIYQQogobMGCA+WM7OzuaNWuGoigW5W5ubtSvX5/Lly8DsGXLFho2bEiDBg2IjY01v7Vv3x6Affv2WX3/J5980uLzNm3aEB8fT3JyMgA7d+4EYPjw4Rb1RowYYXF8z5496PV6Bg0ahEqlMtcbOnRornu6ublx9uxZLl68aHU7KwqbHoqNiIhg3rx5HDlyBIPBQGBgIMOGDaNXr15Wnb9z507WrVvHyZMnuXnzJnq9Hj8/P0JCQnj22WepX79+nuf9+eefLFmyhOPHj6NSqWjatCnjx4+nQ4cOJfnyhBBCiHJXs2ZNi89dXV2xt7fHy8srV3l8fDwAly5d4vz58/n+Xrx161ax7+/m5gZAQkICLi4uXL16FbVanWsIt3r16ri5uXH16lUArl27BkC9evUs6nl5eeHu7m5R9uKLLzJ+/Hh69OhBYGAgnTp1ok+fPjRu3Njqdtsqmw12e/fuZdSoUeh0OsLCwnB2dmbr1q288sorREVFmZN6Qf744w/++ecfgoOD8fHxQaPRcOHCBdatW8fPP//M559/nus/5fr165k0aRJeXl7069cPgM2bNzN8+HA+/fRTevbsWSqvVwghhCgPanXuwTs7O7s86yqKAoDRaCQwMJDXX389z3q+vr53df+c98qWsxfuboWGhvLrr7+ybds2du/ezU8//cRXX33Fu+++y8CBA0vsPuXBJoOdwWDg7bffRqVS8e2339KkSRMAnnvuOQYMGMDs2bPp0aMHtWrVKvA6kyZN4u23385V/tdffzFs2DBmzZrFmjVrzOUJCQlMmzYNT09PwsPDzf8xn332WR577DHeeecdOnXqhIuLSwm+WiGEEKJiqVOnDqdOnaJDhw4lGrjyUqtWLYxGI5cuXaJhw4bm8ps3b5KYmGjOAtk9fxcvXsTf399cLzY2loSEhFzX9fDwoH///vTv35+UlBQGDRrEvHnzKnyws8k5dnv37iUyMpLevXubQx2YuoHHjh2LXq8nPDy80OvY29vnWd6hQwfc3d2JjIy0KN+yZQuJiYkMGjTI4q8NX19fBg0aRFxcnCyyKIQQosp7+OGHiY6OZvXq1bmOpaenk5qaav7cycmJxMTEYt+rc+fOAHz11VcW5V9++aXF8XvvvRetVss333xj0dt353kAcXFxFp87OztTp06dXMunVEQ22WO3f/9+ADp16pTrWHbZgQMHin39I0eOkJCQQOvWrYt033nz5rF//34ee+yxYt9bCCGEqOj69OnD//73P/7v//6Pffv2ERISQlZWFhcuXGDLli0sW7aM5s2bA9C0aVP++usvvvzyS3x8fKhduzYtWrSw+l6NGzemb9++rFq1isTEREJDQzl69Cjh4eF0797d/MCGl5cXI0aMYMmSJYwZM4bOnTtz4sQJ/vjjDzw9PS2uGRYWRtu2bWnatCkeHh4cPXqUX375hUGDBpXcF6mc2GSwy35KpW7durmOVa9eHScnJy5dumT19Xbt2sWRI0fIzMzk0qVL7NixA09Pz1xzAwq6b3ZZUe4rhBBCVEZqtZoFCxawYsUK1q9fz6+//oqjoyO1a9dm8ODBFg8nTpkyhalTp/Lpp5+Snp5O3759ixTsAKZNm0bt2rUJDw/nt99+w9vbmzFjxvD8889b1Hv55ZfR6XT88MMP7Nu3j+DgYJYvX86YMWMs6g0ePJjt27eze/duMjMzqVmzJi+//DIjR44s/hfFRqiUO2cn2oARI0awe/dutm7dmmfIuu+++0hNTeXQoUNWXe+jjz6yWDG7bt26zJ49m2bNmlnU69GjBxcvXuT48eNoNJaZV6/X06xZM4KCgtiwYUMxXhUcPXoURVFo1KhRsc4XQghh+5ycnMq7CaIKs8keu5I2efJkJk+eTEpKinmV6qeeeooPP/yQRx55pEzbotfrOXnyZJneUwghRNm5c5qPEGXJJoNd9lOnSUlJeR5PTk7OtSaNNZydnQkODmbBggX079+fqVOn0rFjR/NaPTnve+d4fPZCia6urkW+b05arVZ67IQQQghRKmwy2GUvLnjp0qVcw6U3btwgNTWV4ODgYl9fo9HQrl07Tp06xdGjR81P1NSrV49jx45x6dKlXMEue25dXkPDRaFSqaSbXgghhBClwiaXOwkNDQVMDz3cKbssu05xxcTEAKYetKLct23btnd1XyGEEEKI0mKTwa5Dhw74+/uzceNGi/loSUlJLF68GK1Wa7HkSExMDOfPn881dHv06NE8r//nn3/y22+/4ebmRsuWLc3lDz/8MK6urnzzzTdERUWZy6Oiovjmm2/w9PSke/fuJfMihRBCCCFKmE0+FQv5byl29epVJk+ebLGl2JQpUwgPD2f69OnmbcAAgoKCCAwMJDAwEF9fX9LS0jh9+jQHDx5Eq9UyZ84cHnzwQYv75txSLHtP2s2bNxMXF8ecOXN4+OGHi/2asoNm9to+QgghhBAlySbn2AG0b9+e7777jrlz57J582YMBgOBgYFMmDDBHLgK8+qrr7Jv3z4OHDhAbGwsarUaPz8/nnjiCYYOHWqxNUm2Pn364OnpyZIlS1i7di0AzZo1Y9y4cdx7770l+hqFEEIIIUqSzfbYVUbSYyeEEEKI0mSTc+yEEEIIIUTRSbATQgghhKgkJNgJIYQQQlQSEuyEEEIIUaht27YxYsQI2rZtS7NmzejatStTp07l33//BaBr164EBQUxa9asXOdevHiRoKAggoKC2Ldvn8Wx9PR0Fi5cSK9evWjevDlt27Zl7Nix/P3337muM3jwYIKCgnjllVdyHUtOTiY4OJigoCDzw48ABoOBlStX8uijj9KqVStCQ0N59NFHee+998jMzLzLr4rtsdmnYoUQQggBiqKQeTmJ9BO3MKYZUDtqcLinGjp/V1QqVZm0YdasWSxdupQePXrw/vvv4+XlRWRkJGvWrOGVV15h3bp1ADg5ObF582YmTJhgcf7GjRtxcnIiNTXVojw1NZVhw4Zx9uxZRo0aRZs2bYiPj+ebb77h6aefZtasWblWwnBycmLHjh2kpqZa7OT022+/YWdnl6vt06ZNY+3atYwePZqQkBDS0tI4efIkGzZsID09HZ1OV0JfJdsgwU4IIYSwUfroFGJ/PIP+SrJFedLvV9DWdsFrYCDaGs6l2oadO3eydOlSxo8fz0svvWQuDw0NpX///uzYscNc1qVLF7Zu3cqRI0do1aqVuXzTpk10796dDRs2WFz7s88+459//uGrr76iffv25vLu3bszYsQI3nzzTdq0aYOPj4/5WEhICMePH2f79u307t3bXL5x48Zc90hLS+Onn35i7NixPP/88+bybt268fzzz1MZFwaRoVghhBDCBumjU4hZFJEr1JmPX0k2HY9OKdV2LF++HG9vb8aPH5/n8QceeMD8saenJx06dGDTpk3mshMnTnDx4kXCwsIszktPT2f16tV07NjRItQB2NnZ8eKLL5KamsqPP/5ocUyj0dCjRw82btxoLouNjeWvv/6yCHpgCnZ6vd4iGOZUVj2eZUmCnRBCCGFjFEUh9sczKOmGguulG0z1SqnnyWAwcPjwYdq3b2+xt3pBevfuzZYtWzAajYCpJ61NmzbUqFHDot6xY8dITU21CIY5tW7dGg8PDw4ePJjnPXbt2kVCQgIA//vf/6hRo4ZFLyGAl5cXNWvWZNGiRWzatMlcvzKToVghhBCilOlvpBL/8wUMMamFVwYUgxFjst66a19J5voH+1BpCu6r0fg44fFIA7TVnQqsl1N8fDyZmZnUrFnT6nO6d+/O1KlT2bdvH+3bt2fz5s2MGzcuV73o6GgA/Pz88r2Wn5+fxd7t2dq0aUO1atXYunUrAwcOZNOmTbl667LNmDGDV199lVdffRWVSkWDBg3o1q0bw4cPx8vLy+rXVVFIj50QQghRyuI3nCfjTBxZ8RlWvVkb6rIZk/WFXjPjTBzxG84Xq/1FGbJ0cXGhS5cubNy4kUOHDnHz5k169OhRrPsW1J5evXqxadMmrl+/zuHDh3MN9WZr164dv/76K5999hlPPPEEWVlZfP755zzyyCPmcFmZSLATQgghRJ48PDywt7fn2rVrRTovLCyMX3/9lfDwcDp16oSHh0euOtlDs9evX8/3OtevX8fX1zffe+zfv58VK1YQEBBAUFBQvtdxcnKiZ8+evPvuu/zyyy9MmzaNmzdvsnz58iK9ropAgp0QQghRyjwebYhDkCd2HvZWvanscy/bURCVvV2h13QI8sTj0YZFuq5GoyEkJIS9e/diMBQ83y+nLl26YDAYWLt2bb49ac2aNcPJyYnff/89z+NHjhwhPj6eNm3a5Hu+v78/X3/9db73yM/AgQPx8PDg/Pni9WDaMpljJ4QQQpQybXUnvIc3s7p+RmQiNxb+Y3V975HNsK/jVpymFWr48OGMHj2axYsXWywZkm3nzp107tzZosze3p6xY8cSERFBt27d8ryug4MDjz/+OCtWrODAgQOEhoaajxmNRubOnYuTkxMDBw7Mt23PPvss27dv55FHHsnzuF6vJzU1FXd3d4vyW7dukZSURPXq1fO9dkUlwU4IIYSwMTp/V7S1XfJd6iQnbW0XdP6updaWzp07M2rUKObNm8e5c+cICwvD09OTK1eusGbNGpKSknIFO4DRo0cXeu2XXnqJI0eOMHr0aJ599lnzAsXffvstBw4cYNasWfkuVQIwYMAABgwYkO/xpKQkevToQZ8+fWjfvj3u7u5cuXKF5cuXo1areeqpp6z7IlQgEuyEEEIIG6NSqfAaGEjMoogClzxROWjwGhhY6uuxTZw4kVatWvHtt9/yxhtvkJaWho+PD506dWLkyJHFvq6TkxNff/01y5cvZ+PGjSxatAhHR0dCQkL49ttvcy1fUlQuLi48++yz/Pnnn2zZsoWEhAS8vb1p3rw5M2bMoGnTpnd1fVukUirjsss26ujRowA0b968nFsihBCiIshv5wmgzHaeEBWL9NgJIYQQNkpbwxmf51qW+16xouKQYCeEEELYMJVKhX0dt1J7OEJULrLciRBCCCFEJSHBTgghhBCikpBgJ4QQQghRSUiwE0IIIYSoJCTYCSGEEEJUEhLshBBCCCEqCQl2QgghhBCVhAQ7IYQQQohKQhYoFkIIIWyZosCVg3B6E6TFg6MHBIVB7TZQBjtPjBw5ksuXL7Nx40Z0Op25/NixYzz++OO88cYbDBo0CIC4uDi++OILtm/fztWrVwHw9/enU6dODBo0iNq1awNw5coVunXrZr6WSqWievXqtG3blldffZVatWqV+uvKy7x58+jYsSMhISHlcv+SIHvFliHZK1YIIUSRxJyEdePg2pHcx2q2gscWgU+TUm1CZGQkvXv3ZtSoUbz44osAZGVlMXDgQNRqNatXr0atVnPp0iWGDh2KwWBg8ODBNG/eHJVKxfHjx/nhhx+oVq0aq1atAv4Ldq+++irt2rXDaDQSGRnJ3LlzcXR0ZMOGDdjZ2ZXq68pLUFAQkyZNYuTIkWV+75IiPXZCCCGELYo5Cct7QHpC3sevHTEdH/FLqYa7OnXqMGbMGBYtWkTv3r1p0KABK1eu5NSpU/z000+o1aZZXa+99hoGg4E1a9ZQo0YN8/kdOnRgyJAhbNiwIde169atS8uWLQEICQnBxcWF5557jn///ZdGjRqV2muqzGSOnRBCCGFrFMXUU5dfqMuWngDrxpvql6Jnn32W2rVr884773D9+nU+++wzBg0axD333APAwYMHOXr0KOPGjbMIddl0Oh0DBgwo9D7Ozs4AGAwGi/IffviBHj160KxZM7p27crChQsxGo0WdU6fPs3IkSNp2bIlrVu35sUXX+TatWsWdX766SfCwsIIDg6mXbt2PPXUU0RERACm3jqAmTNnEhQURFBQEPv27bPyK2Q7itRj9/rrr9O6des8/3G2bdtGzZo1adIk918Nc+fO5ffff2ft2rXFb6kQQghRUd08C1umwI0z1tU3ZEBKtHV1rx2GWUGgsS+4XvVA6DkDvAOsu24OOp2Od955h6FDh/LMM8/g5uZmHpYFzAGoU6dORbqu0WjEYDBgNBq5fPky8+fPp0GDBgQE/NfGlStXMm3aNAYPHkyXLl04cuQI8+fPJykpicmTJwNw/fp1Bg0ahL+/Px9//DEZGRnMmTOHQYMGsWHDBlxcXDhw4ABvvvkmI0aMoHPnzqSnpxMREUFSUhIAq1at4oknnmDw4MH07t0boEL2GhYp2IWHhwPkGeyee+45+vbty/Tp03Mdu379OidPnixmE4UQQogK7n+T4Pz20ru+NSEwIdLUjsHhxbpF+/btad++PXv37mXWrFm4uLiYj8XExADg5+dncU5WVhY5p/JrNJax45VXXrH4vGbNmixdutQ8vy4rK4sFCxYQFhbGW2+9BZjCo16vZ/ny5YwePRpPT09WrFiBwWBg+fLleHh4ANCkSRPCwsIIDw9n8ODBRERE4OHhYQ6DAF26dDF/nD0k7OfnZ/64IpKhWCGEEEIU6ty5cxw6dAiVSsX+/futOqdPnz40bdrU/BYbG2txfMKECfz000/8+OOPLFiwAB8fH0aNGkV0tCmoXrhwgbi4OHr27GlxXq9evdDr9eZh1IMHD9KuXTtzqANo2LAhjRs35tChQwDcc889xMfHM2XKFHbv3k1aWlpxvxQ2TR6eEEIIIUrbwzNhy+tw47R19dPjISPR+uvbu4GDR8F1qgdBz9yjatZQFIV33nmHunXr8vTTT/P+++/Tv39/c8+Wj48PANHR0fj7+5vPmzNnDunp6fz+++/Mnz8/13X9/f0tVooICQmhY8eOrFixgsmTJ5OQYJpjWK1aNYvzsj/PPp6YmJjnVLBq1aqZ63To0IGZM2fy9ddfM3LkSOzt7enRowdvvPGGRSCs6CTYCSGEEKXNOwAG/WR9/csH4Ivu1tcfHG5a166UrF27loMHD7Jy5UratGnDzz//zDvvvMOaNWuws7OjXbt2AOzatYunnnrKfF72XLmzZ89adR8vLy88PT3N9bMD1509fbdu3QLA3d3d/D677M569erVM3/ep08f+vTpQ2xsLNu2bWP69OloNBo+/PBDq9pXEchQrBBCCGFrarcxrVNnjZohUKt1qTUlLi6OmTNn0rdvX0JDQ1GpVLzzzjucOXOGlStXAtCmTRuaN2/OokWLzPPtiuPmzZvExcXh6ekJQP369fHy8mLLli0W9f73v/+h1WoJDg4GoHXr1uzdu9fcOwemYdzTp0/TunXur42XlxcDBw6kY8eOXLhwwVyu1WrJyMgodvttgfTYCSGEELZGpTItPlzQOnYADu7w2MJS3YFi5syZAEycONFc1rhxYwYNGsTcuXN5+OGHqVGjBp988glDhw6lX79+DBkyxLxA8dWrV/nhhx/Q6XRotVqLa1+6dIm///4bRVGIjo7miy++QKVS8fjjjwNgZ2fH+PHjmTZtGl5eXnTu3Jm///6bpUuXMnToUHMAHDZsGGvXrmXEiBGMGzeOjIwMPv30U/z8/Ojbty9gWqEjPj6etm3bUq1aNc6cOcOff/7JsGHDzO1p0KAB27Zto02bNjg6OlK/fn2Lh0QqAgl2QgghhC3yaWJafDjfnSdCTKGuFBcnPnjwIOHh4bz//vt4eXlZHHvxxRf53//+x/Tp0/n000+pW7cua9eu5YsvviA8PJz58+ejUqnMW4rNnj0bV1dXi2vMnj3b/LGnpyeNGzfmq6++IjQ01Fw+ePBgNBoNK1as4Pvvv6d69eo8//zzjB071lzHz8+PlStXMnPmTCZMmIBaraZjx45MmTLFHMyaN2/OV199xf/+9z+Sk5Px9fVl5MiRjBs3znydqVOn8uGHH/Lss8+Snp7O119/bR5mriiKtKVY48aNqVu3bp57qIWHh+d77NChQ1y+fLnKL3kiW4oJIYQoMkWBq4fg1Mb/9opt3Ns0/FoGe8WKiqXIwU6lUlGU7WWz66tUqiIHu4iICObNm8eRI0cwGAwEBgYybNgwevXqVei5iqLwxx9/sH37dg4fPsy1a9cwGAzUrVuXXr16MXz4cOztcy/mmL3ydF769u3LjBkzivQacpJgJ4QQQojSVKSh2Oxx6rKwd+9eRo0ahU6nIywsDGdnZ7Zu3corr7xCVFQUI0aMKPD8zMxMRo8ejU6no23btnTq1InMzEx27drFnDlz+O2331i5ciWOjo65zq1Vq1aerzWvR6mFEEIIIWxFkXrsyorBYODhhx8mKiqK1atXmwNVUlISAwYM4OrVq/zyyy/UqlUr32vo9XqWLVvG008/bX4cOrv8hRdeYMeOHUycOJFRo0ZZnBcUFETbtm3NT/qUJOmxE0IIIURpssnlTvbu3UtkZCS9e/e26CVzdXVl7Nix6PV68/Zm+dFqtYwbN84i1GWXjxkzBoADBw6UfOOFEEIIIcqJTT4Vm71VSV6bCWeX3U0oy96rLnsvujslJiayatUq4uLicHd3JyQkpMC5d0IIIYQQtqBIwU5RFNLT07Gzs0On0+U6npycbJ6/FhcXh6+vL2FhYYwdOzbPBxXyc/HiRQDq1q2b61j16tVxcnLi0qVLRWm6hTVr1gDQsWPHPI+fOnWKqVOnWpTdd999fPTRR7m2NSkqRVFITU29q2sIIYSwXU5OTuXdBFGFFSnYrVu3jjfeeIORI0cyYcIEi2MZGRkMGjSI06dPm5+ajYyMZPHixURERPDFF19YfZ/k5GSAXOvdZHNxcSEpKakoTTfbuXMnq1atomHDhgwcODDX8REjRvDQQw9Rr149tFotZ8+eZeHChfzxxx+MGTOGVatW5dvTZw29Xl/ll30RQojKLK+dDoQoK0UKdocPHwagf//+uY59/fXXnDp1CrVazaBBg+jUqRNXr15lwYIF7Nmzh19++YUePXqUTKuLKSIigldeeQVXV1c+++yzPHsdJ0+ebPF5q1atWLJkCUOHDmX//v1s27aNhx56qNht0Gq1NGrUqNjnCyGEEELkp0jB7tixY9SqVYv69evnOrZmzRpUKhVPP/00b775prm8YcOGDB06lI0bN1od7LJXic6vVy45OTnXQxGFOXr0KCNHjkStVrNs2TLzxsTWUKvVDBw4kP3793P48OG7CnYqlUq66YUQQghRKor0VOzNmzcJDAzMVR4dHW2eF/f0009bHGvXrh0NGjTg+PHjVt+nXr16AHnOo7tx4wapqal5zr/Lz9GjRxkxYgRGo5EvvvjCvGlwUWTvRyfz44QQQlQl8+bNIygoiPvuuw+j0Zjr+JNPPklQUBBTpkyha9euBAUFFfg2b94887lxcXHMmjWLXr160aJFC1q0aEHv3r2ZMWMGV65cMde7cuUKQUFB3HPPPea8ke3kyZMEBQWxb98+c9ngwYMJCgris88+y9XePn36MGXKlBL4ytimIvXYxcXF5dnblL0+W40aNWjQoEGu4/Xq1WPPnj1W3yc0NJQlS5awa9cuwsLCLI7t2rXLXMca2aEuKyuLL774ghYtWljdjpz++ecfAGrXrl2s84UQQojiUBSF6H8T+fefm2Sk6rF30lK/hTc16ruhKqMtxbRaLXFxcRw4cMBi79SrV6/y999/m7PB/PnzyczMNB9//vnnCQkJsdhUwNfXFzB13gwdOhSDwcDgwYNp3rw5KpWK48eP88MPP3DkyBFWrVpl0Y6srCwWL15s9S5QK1euZMSIEfnO2a+MihTsdDodt27dylV+7NgxAO655548z8trd4eCdOjQAX9/fzZu3MiQIUMsFihevHgxWq2Wxx57zFw/JiaGpKQkfHx8LP7xjh07xogRIzAYDCxbtoxWrVoVeN/Tp0/ToEEDtFqtRfnhw4dZtmwZWq2Wnj17Fum1CCGEEMV161oy2786Scwly6lJh3+5hE9dV7oObUK1mi6l3g6tVkuHDh3YtGmTRbDbtGkTAQEBqNWmAcA7c4BOp8Pb25uWLVvmuuZrr72GwWBgzZo11KhRw1zeoUMHhgwZwoYNG3Kd065dO37++Weee+45/P39C2xzcHAw586d4+uvv+a5554rysut0IoU7OrUqUNERAQpKSk4Ozuby3fv3o1KpcrzHw5MQ7hFWSZEo9Ewbdo0Ro0axTPPPGOxpdjVq1eZPHmyRc/Z7NmzCQ8PZ/r06fTr1w+A+Ph4RowYQWJiIvfddx979uzJ1Wvo6urKsGHDzJ9/+eWX/P7777Ru3Ro/Pz80Gg1nz541v76pU6dSp04dq1+HEEIIUVy3riUTPuswGamGPI/HXEoifNZh+k4IKZNw17t3b959913efvttcwfIxo0b6d27N5s3by7StQ4ePMjRo0eZOnWqRajLptPpGDBgQK7yAQMG8O+//7JkyRKmTZtW4D28vLx48skn+frrrxk6dKh5/n5lV6Q5dp06dSIlJYV3332X9PR0wLQESvZQbLdu3XKdYzQaOXHihLnr1Vrt27fnu+++IyQkhM2bN/P9999TrVo15syZU+g+sWB6wCIhIQGAP//8k/nz5+d6+/rrry3O6datGyEhIZw6dYo1a9bwzTffcP78ecLCwli1ahVPPfVUkV6DEEIIURyKorD9q5P5hrpsGakGtn91krLYHfSBBx4gMzOT3bt3A3Du3DlOnz5Nr169inyt7PlweW1EUBCdTseoUaNYt24d165dK7T+iBEjSEtL49tvvy1yGyuqIvXYDR06lNWrV/Pzzz+zefNmnJ2dSUxMRKVScf/999OwYcNc5+zdu5ekpCRCQkKK3Ljg4GCWLVtWaL0ZM2bkGm+vXbs2p0+fLtL9HnzwQR588MEinSOEEEIUJi4qhV0/niXuunUP4GUZjKQmZhZeEVPP3YrJu7HTFNxX4+nnRKeBAXj6OhdYLz+Ojo507dqVTZs20aVLFzZu3EirVq0KHRLNs80xMQD4+flZlGdlZVmE1OydonJ64okn+Pzzz/n888955513CrxP9erVefzxx/nyyy8ZPHhwlViVokg9dtWrV2fx4sVUr14dg8FAQkICiqLQpEkTPvjggzzPyU7JHTp0uPvWCiGEEBXQn6vPEnk8lqTYdKverA112VITMwu9ZuTxWP5cffauXkfv3r3Ztm0b6enpbN68OdcDjnerT58+NG3a1PwWGxubq46DgwPDhw9nzZo1REdHF3rNUaNGkZyczPfff1+ibbVVRd4rNiQkhN9++41Dhw5x69Yt/Pz8CAkJyffJnP79+9O3b1/atGlz140VQgghRPnp1KkTWq2Wzz77jCtXrvDwww8X6zo+Pj6Aabm0nD1+c+bMIT09nd9//5358+fne/5TTz3F0qVLWbp0aZ6bJuTk6+tLv379WL58Oc8880yx2luRFDnYgWmM29oeuK5duxbnFkIIIUSlcd/jAez68Rxx11Osqp+RqiczPcvq6+sc7LB30hZYx9PPmU4D727nI61Wy0MPPcSKFSvo0KED3t7exbpO9pO1u3btspi/nr15wNmzBfcsOjs7M3z4cBYtWsT9999f6P3GjBnD2rVrcy2fUhkVK9gJIYQQwnqevs488oL166hGXUhgzcxDVtd/5KWW+NYv2o5MxTVw4EBu3brF448/XuxrtGnThubNm7No0SK6detm7sErikGDBvHFF19YtRd9rVq1ePTRR1m2bFmlfzq2SMGuWbNmd3Wz7PXuhBBCCJG/GvXd8Knrmmv9urz41HWlRj23MmiVSXBwMAsXLrzr63zyyScMHTqUfv36MWTIEPMCxVevXuWHH35Ap9PlWlc2JxcXF4YMGVLgkG1OY8aMYd26dcTExBR7s4KKoEgPTxgMhrt6E0IIIUThVCoVXYc2wd6p4P4XeycNXYc2KbMdKEpS3bp1Wbt2LX369CE8PJwxY8YwZswYvvzyS1q3bs3mzZsL3TFiyJAhVvfA1a1bt8Qf9rBFKqUIi980btwYlUpF8+bN6d+/Px07dizSf6ZatWoVq5GVRfZ6f82bNy/nlgghhKgI8tt5AijTnSdExVGkYLds2TLWrl3LhQsXUKlU+Pn58dhjj9GvXz/ZQ9UKEuyEEEIUlaIoRF9M5N+/c+wV29KbGvXKbq9YUXEUKdhlO3z4MD/99BNbtmwhNTUVtVpN27Zt6d+/Pz169ECn05VGWys8CXZCCCGEKE3FCnbZUlNT2bx5M2vWrOHIkSOoVCpcXFwICwujX79+BAcHl2RbKzwJdkIIIYQoTXcV7HL6999/+emnn1i/fj03b95EpVLRsmXLKrPSszUk2AkhhBCiNBXpqdiC1K9fn4kTJ7J582YeeOABFEXh4sWLJXV5IYQQQghRiBJboPjgwYOsWbOGLVu2kJ6ejlqtJjQ0tKQuL4QQwsYpisL1s6c5f3Av6SnJODi70LBNe/wCgmSSvxBl5K6CXUxMDOHh4axdu5bIyEgURaF27dr07duXfv364efnV1LtFEIIYcNuXr7EloWfEn3Bciuo/et/okaDAHqOfxlv/7rl1Dohqo4iz7EzGAxs27aNNWvWsHv3brKysnBwcODBBx+kf//+tG/fvrTaWuHJHDshRGV08/Ilfvi/SWSk5L8Pqr2zM0++O1PCnRClrEg9dh9++CE///wz8fHxKIpCs2bN6N+/P4888kil33tNCCFEboqisGXhpwWGOoCMlBR+WfQpT38wW4ZlhShFRQp2X3/9NSqVyhzoAgMDAThz5oxV54eEhBS9hUIIIWzW9bOncw2/5ifq/Fmizp3BLyColFslRNVVrDl2x44d49ixY0U6R6VSceLEieLcTgghhI06vvO3ItU/d+AvCXYV1LZt2/j22285duwYqamp+Pj40KlTJ4YPH079+vXLtW3z5s1j/vz5ucoDAgLYuHFjObSo/BQp2NWsWbO02iGEEKKCuHX1Mmf37ubMvt3cuPRvkc5NT0kupVZVXoqicORyPL+eiCYhTY+7o5YH76lBK3+PMhvWnjVrFkuXLqVHjx68//77eHl5ERkZyZo1a3jllVdYt25dmbSjIA4ODnz11Ve5yqqaIgW77du3l1Y7hBBC2ChFUbh1+RJn9u3mzN7d3LoSWexrOTjLfOyiOBOdxIQf/yHiSoJF+aLfzxNc251ZA1sQWMO1VNuwc+dOli5dyvjx43nppZfM5aGhofTv358dO3bkeV56enqZBiu1Wk3Lli1L9Jpl/RpK4t4ltkCxEEKIykNRFGIuXmD3qpWseHUcX018nr9++v6uQh1Ao9AOJdTCyu9MdBIDFu3JFeqyRVxJYMCiPZyJTirVdixfvhxvb2/Gjx+f5/EHHngAgKCgID7//HM+/vhjOnbsSIcOpn/rjIwMpk+fTqdOnWjevDl9+vTh119/tbjG2bNnefbZZ2nXrh0tWrSgR48eLF261Orj1jh9+jQjR46kZcuWtG7dmhdffJFr165Z1MnvNXTt2pX33nuPFStW0LlzZ1q1asWUKVPIzMzk5MmTPPnkk7Rs2ZIBAwZw+vRpi2sqisIXX3xBjx49aNasGd26dWPFihUWdebNm0erVq2IiIjgiSeeoHnz5nz77bdFen3ZSmyBYiGEEBWboijE/HueM3t3cWbfbuKjrhd6jnfd+qQnJpIcd6vQur4NA/BtFFgSTa30FEVhwo//kJhuKLBeYrqBiT/+w7rnOpbKsKzBYODw4cM89NBDaLXaQut//fXXtGjRgg8++ACDwdT2CRMm8Oeff/Lyyy/ToEED1q9fzwsvvMCCBQvo1q0bAGPHjsXb25sPPvgAFxcXIiMjiYqKMl+3sOM525uTnZ0dKpWK69evM2jQIPz9/fn444/JyMhgzpw5DBo0iA0bNlis7JHXawDTHMOAgADee+89Ll++zIwZM9Bqtfz9998MGzYMb29vZs2axUsvvcTmzZtRq019Zx988AE//vgjY8eOpUWLFhw+fJhZs2Zhb2/PU089Zb6+Xq/ntddeY9iwYbzyyit4eHhY8S+UmwQ7IYSowhRFIercGfMwa+KN6ELPqdEggMD2HQlody+evjWtXseux7iXq+xSJ+dvJPPezyc4F2PdHMNMg5EbyRlW1f3nSgJtP9iGTlPwIFwjHxemPnIPDatbPxweHx9PZmam1XPs3d3dmT9/vvnf+dSpU2zdupV3332XJ598EoD777+fq1evmoNdbGwsV65c4c0336Rr164AFmviFnY8W2pqKk2bNrUomzlzJn369GHFihUYDAaWL19uDkxNmjQhLCyM8PBwBg8enO9ryGnhwoXodDoA9u/fz+rVq1m6dCn3338/AEajkbFjx3LmzBkaN25MZGQk33zzDe+++y5PPPEEAPfeey/p6eksWLCAJ554whwA9Xo9r7zyCr169bLqa50fCXZCCFHFKEYjV8+c5Oy+PZzdt4ekWzcKPccvIIjAdh0JaNcRd58aFse8/evy5Lsz89x5Akw9dT3GVe2dJ97ZcJw/z94stetbEwKvxqfxzobjrBzZrsjXtzaQ33///RZ1Dx06BEDPnj0t6j388MNMnz6d1NRUPD09qVWrFrNnzyYhIYEOHTrg6+trrlvY8WwODg588803FmX+/v6AadvTdu3aWfSCNWzYkMaNG3Po0CGLYHfna8gWGhpqDnUA9erVQ61WW4TMevXqAXD9+nUaN27Mnj17AHjooYcsev/uvfdeli5dyvXr16lVq5a5vHPnzrnuW1QS7IQQogowGrO4evI4Z/bt5uz+v0iJiy34BJWKWkFNCGzXkUZt78XNu3qB1b396/LMh7OJOneGcwf+Mu8V2yi0A76NAqtsT11F5+Hhgb29fa65aPmpVq2axecJCQlotdpcw4re3t4oikJSUhJOTk588cUXzJkzh/fee8/c8/b6668TGhqKSqUq8Hg2tVqd785OiYmJNGnSJM/2JiQk5CrLi5ubm8XnWq0WBwcHi7CXPVydkWEK2nFxcSiKku+uXDmDnaOjI87OznnWKwoJdkIIUUkZs7K4fOIoZ2+HudSE+ALrq1RqajdpSkD7jgSEdsDFK+9fcPmfr8IvIEjWqcvDO4825f2NJzgbbd1QbEKanuSMgufX5eRir8HdseA5cAE1XHi79z1WXxNAo9EQEhLC3r17MRgMaDQFx4Y7A7y7uzt6vZ6EhATc3d3N5Tdv3kSlUuHqanqit379+sydOxe9Xs+RI0eYPXs2Y8eO5Y8//sDZ2bnQ44Vxd3fn1q3c80Bv3bpl7mXL7zXcDXd3d1QqFd99912ecxRzrv9XUveVYCeEEJVIlsHA5WP/mHrmDuwlPSmxwPoqtRr/psGmnrnQ9jh7eJZRS6uWhtVdWDG8rdX1D0fG0W/hHqvrrxzZllZ1Suffbvjw4YwePZrFixfz/PPP5zq+c+fOfIcQW7duDcCWLVvMc8yyP7/nnntwcnKyqK/Vamnbti2jR49m3LhxxMTEWISfwo7np3Xr1qxevdoiYF64cIHTp0/Tv3//wr8IxZT9VG18fLx5fmBpk2AnhBAVnEGvJ/Lo35zZu5vzB/cWugiw2s6OOs1bEtiuIw3btMPJzb3A+qLstfL3ILi2e75LneTUorY7Lf09Sq0tnTt3ZtSoUcybN49z584RFhaGp6cnV65cYc2aNSQlJeUb7Bo3bsxDDz3EjBkzSE9Pp379+mzYsIEjR46wcOFCwPSAxUcffUSvXr3w9/cnOTmZJUuWUKtWLerUqVPocWsMGzaMtWvXMmLECMaNG0dGRgaffvopfn5+9O3bt8S+VneqX78+zzzzDJMmTWLkyJG0aNECvV7PxYsX2bdvn/lrUJIk2AkhRAWkz8zg0j9HOLNvN+cP7iMzLbXA+nYaDXWDWxHYvhMNW7fDwUUWCrZlKpWKWQNbMGDRngKXPHFz0PDxwBalPodx4sSJtGrVim+//ZY33niDtLQ085ZiI0eOLPDcjz/+mNmzZ7N06VLi4+Np0KABc+fONfdgVa9eHW9vb5YsWUJ0dDSurq60adOGjz/+GDs7u0KPW8PPz4+VK1cyc+ZMJkyYgFqtpmPHjkyZMsViqZPS8NZbb1G/fn1WrVrFggULzEPLdz5QUlJUiqIopXJlkcvRo0cB8p3cKYQQBdFnpPPv34c4s3c3Fw4fQJ+eVmB9O62W+i1bE9iuIw1at8Xe6e4nZouyld/OE2Dqqfu4DHaeEBWLBLsyJMFOCFFUmelpXDh8gLN7d3Ph74MYMgpe1kKjs6dBqzYEtO9Ig1Zt0Dk6FVhf2D5FUfj7cjxbc+wV+9A9NWhZhnvFiopDhmKFEMLGZKSmcOHQfs7s283Fvw9j0GcWWF9r70CD1m0JbN+R+i1ao62CG59XZiqVilZ1PEvt4QhRuUiwE0IIG5CenMz5Q/s4s3cXlyKOkGUoeKkLnaMTDdu0I7BdR+q2aIVWZ19GLRVC2DIJdkIIUU5SExM4f3AfZ/btJvLo3xizsgqsb+/sTKM2HQhs35E6zVuisWLvTiFE1SLBTgghylBqQjxn9//FmX27uXw8AsVoLLC+g6sbAaHtCWzXEf9mwdhpJMwJIfInwU4IIUpZclwsZ/fv4eze3Vw5eRxFKTjMObl7ENC2AwHtOuJ/T3PUVi7pIIQQEuyEEKIUJN68wbn9ezizbzdXT5+EQhYgcPbwJKDdvQS260itJk1RqyXMCSGKToKdEEKUkISYaM7u282Zfbu5fvZ0ofVdqnkT2PZeAtp3pFZgE1RqdRm0UghRmdl0sIuIiGDevHkcOXIEg8FAYGAgw4YNo1evXoWeqygKf/zxB9u3b+fw4cNcu3YNg8FA3bp16dWrF8OHD8fePu+nyP7880+WLFnC8ePHUalUNG3alPHjx5v3fBNCiGxxUdc4u28PZ/buJvrC2ULru1X3IaBdRwLbdcSvUaCEOSFEibLZBYr37t3LqFGj0Ol0hIWF4ezszNatW7l69SqTJ09mxIgRBZ6fkZFBcHAwOp2Otm3bEhgYSGZmJrt27eLixYs0b96clStX4ujoaHHe+vXrmTRpEl5eXuYAuXnzZuLi4vj000/vagsQWaBYiMoh9toVzuw19czduHih0PoeNfwIaG8KczUaNJJFZYUQpcYmg53BYODhhx8mKiqK1atX06RJEwCSkpIYMGAAV69e5ZdffqFWrVr5XkOv17Ns2TKefvpp3N3dLcpfeOEFduzYwcSJExk1apT5WEJCAt27d8fOzo5169bh6+sLQFRUFI899hgAv/32W7H3lZNgJ0TFpCgKt65Ecmbvbs7u283Ny5cKPcfTrxaB7TsR2L4j1evWlzAnik9RIGUfJKwHQxxoPMG9Dzi3g1L8fxUUFFRonenTp9OvXz/OnTvH3Llz+fvvv4mLi8PT05MmTZrw9NNP07lzZwDWrl3L66+/jk6nY8+ePbi6Wm6F9tprr7Fx40batm3LypUrLc7566+/8PLyKvkXWQnZ5FDs3r17iYyMpF+/fuZQB+Dq6srYsWOZMmUK4eHhPP/88/leQ6vVMm7cuDzLx4wZw44dOzhw4IBFsNuyZQuJiYm88MIL5lAH4Ovry6BBg5g3bx6//fabOeQJISovRVG4celf05y5vbuJvXal0HOq1a5D4O2euWr+dSXMibuXdhwuDoPUg5blUTPAqQ3UWwGOTUvl1qtWrbL4/IknnmDw4MH07t3bXFanTh0iIyMZOHAgQUFBTJkyBS8vL65evcrOnTvZv3+/Odhl02g0/Prrr/Tr189clpaWxvbt23FystwCr0uXLqxatQo3N7dSeIWVk00Gu/379wPQqVOnXMeyyw4cOFDs62s0ppdtd8cSAoXdd968eezfv1+CnRCVlKIoxPx7njN7d3Fm327io64Xek71uvUJbNeRgHYdqVbbvwxaKaqMtONwuhNkxed9PPWg6XjQrlIJdy1btsxV5ufnl6v8q6++AuDLL7+0mN7Uv39/jHms09itWzc2bdpkEex27NiBTqejRYsWpKWlmcu9vLzKrKcuPT0dh0qwHZ9Nztq9ePEiAHXr1s11rHr16jg5OXHpUuFDIflZs2YNAB07drT6vtlld3NfIYTtURSF62dPs/Ob5Sx7YRTfvP4y+9f/VGCoq9GgEZ2eGsqIT5cwZOY82vd/UkKdKFmKYuqpyy/UZcuKh4vDC11OpzQlJibi4uKSa846gDqPh4N69+7NX3/9xa1bt8xlP//8Mz169DB3vGRbu3YtQUFBxMbGArBixQqaNWvGiRMnzHUiIyNp1aoVn3zyibnsyJEjDBkyhJYtW9K6dWtee+01i/tduXKFoKAg1q5dy1tvvUW7du0YOHBg8b8INsQme+ySk5MBco2/Z3NxcSEpKalY1965cyerVq2iYcOGuf4RC7pv9ry64t43m6IopKam3tU1hBB3RzEaiTp/hgsH93Lh4D6SY28Veo5PgwAatmlHgzbtcavuYy6X72dxpzuHEwFIPw2XX4b0k9ZdxJgBhijr6qYegIiaoC5kv2CHJuD/KTgUPneuKJo2bcp3333H1KlTeeqppwgKCsoz0GULDg6mZs2abNmyhWeeeYbExET+/PNPvvjiC3PvX36GDh3Ktm3bmDhxImvXrkWj0TBp0iTq1KnDCy+8AJhC3eDBg+ncuTNz5swhLS2NTz/9lPHjx+caXp49ezadO3fmk08+ybN3sSKyyWBXWiIiInjllVdwdXXls88+Q6fTlXkb9Ho9J09a+Y0thCgxitFIwpVIbpw5zo0zJ8lMLvyPNLdadagedA/VA5vg4OYBwNWbt7h6s/AgKKqu1q1b5y68/CIkbi29m1oTAjMvmdoR8EuJ3rpv37789ddfrFq1ilWrVuHs7Ez79u3p378/3bp1y/OcsLAwNm3axDPPPMMvv/yCl5cXoaGhhQY7lUrFjBkzePTRR5k9ezZeXl4cP36cn376yfw7/ZNPPqFZs2bMnz/fPM81MDCQ3r17s3PnTos5f40bN+aDDz4ooa+EbbDJYFdY71hycrLFk67WOHr0KCNHjkStVrNs2TICAgIKvK+np2eue0L+vYjW0mq1NGrU6K6uIYSwjjEri2unT5p65g7tIy0xoeATVCpqBjahQZv21G/dFhdPeQpPiMLY2dnxySefMHbsWHbs2MHBgwfZvXs327ZtY/z48bz00ku5zgkLC2PJkiVcv36dTZs20atXrwJ7+XKqVasWb7zxBm+++SYajYaXXnrJ/ARvWloahw8fZtKkSWRlZZnPqVevHn5+fhw9etQi2HXp0uXuXrwNsslgV69ePcA0n61Zs2YWx27cuEFqairBwcFWX+/o0aOMGDECo9HI8uXL8z23Xr16HDt2jEuXLuUKdtlz6/Kaf1cUKpUq7256IUSJyDIYuHw8gjP7dnNu/1+kJSUWWF+lUuPftDmB7TvSKLQDzh6eBdYXolj858LlVyD9ROF1wbSsibHg/7sW1G6mZVAK4nAP+M+x/ppFFBAQQEBAAKNHjyY2NpaRI0fy+eefM3ToUDw8PCzqBgYGEhAQwIoVK9i3bx8TJkwo0r26devG+++/T1ZWFo8//ri5PDExkaysLKZPn8706dNznXf9uuXc2WrVqhXpvhWBTQa70NBQlixZwq5duwgLC7M4tmvXLnMda2SHuqysLL744gtatGhR4H03btzIrl27cj31k33ftm3bFuGVCCHKgkGvJ/LY35zZu5vzB/aSnpJcYH21nR11mrUgoF1HGoW2x8mtaCMAQhSZQxAEbLa+fvJeOF2E3Y4Ct5rWtbMRXl5e9OvXj2nTpnHp0qVcwQ5MvXafffYZderUydWJU5h3330XNzc3DAYDH374IR999BFgGlVTqVSMGTOG7t275zrvzk6byrgkkU0Guw4dOuDv78/GjRsZMmSIxQLFixcvRqvVWiw5EhMTQ1JSEj4+PhZDpceOHWPEiBEYDAaWLVtGq1atCrzvww8/zKxZs/jmm28YMGCAxQLF33zzDZ6ennn+RxFClD1DZiYXI45wdu8uzh/aT0ZqSoH11XYa6rVoRUC7jjRs0w5Hl7ubViFEqXJuZ1qn7s716/LiFApO5dfpcPPmTby9vXOVZ680kdcxMD0dGxERke88vPxs2rSJzZs3s2zZMjIyMnjuued48MEH6d69O05OTrRs2ZILFy5U2c0AbDLYaTQapk2bxqhRo3jmmWfy3FKsdu3a5vqzZ88mPDzcvAI2QHx8PCNGjCAxMZH77ruPPXv2sGfPHov7uLq6MmzYMPPn7u7uvP3220yaNIm+fftabCkWHx/PnDlzir3rhBDi7ukz0rn492HO7NvN+UP70aenFVjfTqulXovWBLbvSIOQUByc5ftXVBAqlWnx4YLWsQOw84B6X5bqDhSFWbhwISdPnqR37940atSIjIwMdu/ezXfffUf37t3z3SWqdu3aLFy4sEj3io6O5r333uPJJ5/kvvvuA0wPb7z99tu0atWKatWqMWnSJIYOHcrLL79MWFgYbm5uREVFsWfPHvr160e7drbTs1kabDLYAbRv357vvvuOuXPnsnnzZgwGA4GBgUyYMMEcuAqSnJxMQoJpovSff/7Jn3/+matOrVq1LIIdQJ8+ffD09GTJkiWsXbsWgGbNmjFu3Djuvffeu39hQlQFigLHwmHbO2DUQ6MHodVgqN2myL+AMtPT+PfIQc7s3c2FIwcwZGQUWF+js6d+q9YEtjOFOZ2jzGkVFZRjU9Piw3ntPAGmnrp6X5bazhPWevTRR8nIyGDlypVER0djZ2dHrVq1mDRpEk8//XSJ3uvNN9/Ezc2NyZMnm8veeust9u3bx9SpU1mwYAEhISF89913zJs3j9dffx29Xo+vry/t27e/63nyFYFN7hVbWclesaJKiDkJ68bBtSO5j9VsBY8tAp8muY/lkJGayoXD+zmzdzcX/z6EQZ9ZYH2tvQP1Q0JNYa5VG7SVYPV4IcwUBVL3Q/y6//aK9XjMNPxaCeeIibsjwa4MSbATlV7MSVjeAyUtgdNJ3vwZUw+joqa+SyzNPKLxc0hC5egOI37JFe7Sk5M5f2gfZ/bt5tI/h8kyGAq8lc7RkQYhbQls35F6LULQ2kuYE0IImx2KFUJUMIoC68ZxM0HPlmstiU7/7+GEo/F+HI33o4ZDEj1rnsF73Xh4djtpyUmcO7iXs3t3c+noPxizCg5z9k7ONGzTjsD2HanbvBWaclhkXBRAUeDKQTi9CdLiwdEDgsKKNQQvhCge6bErQ1Wyx64E51qJIlIUyNKDIR0MGTnep+X4/I5j+rQ76qbfUTev8tvnpSdyMy6FHy4Gk2HU5tssndpAa8+rXMv0JjLJCYWC/x846NQ08nchsIEXdWp7YmfvCHY60NiDnT1odHe8t7993CGPMnvLc61cEFVYoQSG4IUQd0+CXRmqcsFOftCD0QhZtwOQvoBgZMgrUN1l2DKkg1J2ex8qCnx70bKnrrgc7TIJcL1FgOtN/J0TsFOV0o8ptaaQcJhPILSq/h3HrTlXramYf/DcHoInvYCdPRzyHoIXQpQsGYoVpaOwH/TXjpiOl8UP+jx7rdKLGbaKGNKyCp70X5lcT3e9q1DnbJdJI7ebBLrepLZTAuqyyDdGg+lNX/AaeGVHVUAALKnQaUVPZvZxO13hvZq3h+Czv9fjDDX5M3EUAPe5LcNTc81ULz0Bbg/BV8jwKkQFIcFOlLw7ftDnKz0BVg+FXh+bApBFD1UJhi0lq+B2iOLTONzujXLg/K2i797gojUQ4JFAoNstatrHolb0pdDIikT574+Ogld1KTtqbcEB0JAJ0abRCEWBbQkvEq037du5Me5tHnSfQw3tGVOWu3YYrh4yTcUQQpQKCXai5F05mPfwa15unoavHy3d9lRmKjVoHE2/aLWO5pBl+T6/cgfQOtxRXoRz7HQWPS/pc/4PYg5Z3fRGzRrz6JszUeXsETIaTSE/K8MUGLIyTAE9K/OO9zmPF1TvjvrZvaiFXivHNanis1WMesgsPHDf0vuzPeEFYgwB5rLELF/WxH6Ej+YsXd3nUU17GU5tlGAnRCmSYCdK3ulN5d2CsmUe3rozJOUXnqwIXXmGtDzuYWc738IONeoD1gc7r4bNLEMdmIb91Le/ZrZAUUxDtcUKlVbWyzNsFnANY8FPDpeHW3p/wmM/JEPJe2ePGEMA4bEf0tfrDaqlxZdt44SoYmznt4KoPMr8B7eqgN6qogSuYpwjT1aaFfZ0650ahRZhg/PyolKBndb0ZivMD+TcTU9mIfVy1cm/N1QxZLA94YV8Q122DMWF7YkvMMDhehH/pwghikKCnSh5jh5Fq+/fHgJ7WNFblU8Pl51WJmOXI6Mxiz++Wc6hTeutPse3YQC+jQJLsVWVmFoNakfT90k5S0/Rc3rLPmJ+te4hoRh9ANFuLfAt5XaJkjVlyhSOHTuGp6cn+/fvL7Bu3759mTFjRhm1LG+ZmZn83//9Hzt27CAuLo7XX3891/ahlZkEO1HygsJg1xzr6/f4QObcVFAZqalsmjuTf4/ksY9lPuydnekx7mVUEsYrlIw0Azcik4i5lMiNS6b3iTfTi3ydf695S7ArIkVRiLgZwY7IHSRmJuKmc+OBOg8Q7B1cJt9H48ePJzU1FY1GQ3Jysrn83XffxcHBwWLfVi8vr1JvT2HWr1/P+vXrmTFjBnXq1KFWrVrl3aQyJcFOlLzabUzr1FnzAEXNEKjVuvTbJEpcQkw062a+x83LlyzKq9Wug9rOjhuX/s11jm/DAHqMexlv/8q/EXdFps/I4sblJHOAi7mURHx0aolcOyPV9uYI2rJzced4a/dbHL913KL8i2Nf0LRaU6Z1nEYjz0al2oY6derkWe7i4oKTkxMtW7bM99z09HQcynjv5gsXLuDj48Ojj979g3nl0X4whXm9Xo+uGLvrSLATJU+lMi0+bM2CpY8tlGHUCujqqROs/+QD0hIt/30DO9xHz3EvodHZE3XuDOcO/EV6SjIOzi40Cu2Ab6NA6amzMYbMLG5eSSbmUhI3LiUSE5lE3PUUSmvpensnG5qvaOPOxZ1jyJYhJGUm5Xn8+K3jDNkyhK97fl2q4S57KHbjxo0F1tu3bx9DhgxhyZIlrF27ll27dhEaGsqSJUtYt24dq1at4vz58yiKQuPGjZk4cSLBwcHm8+fNm8fy5cv54YcfeOeddzhx4gT+/v5MnjyZ++67z1xv27ZtLFiwgH///Rc7Ozvq1KnDSy+9ROfOnenatStXr14FICgoyFy/du3aHDhwgE8++YQTJ07g6OhI165dmTx5Mh4eHgBcuXKFbt26MX36dA4fPsyvv/6Kj48PP//8M0FBQbz22mukpKSwevVq9Ho9jz/+OBMnTmTv3r3MmDGDyMhIgoODmTFjBn5+fub2ZmZmMn/+fH7++Wdu3LiBv78/48eP55FHHsn1NZ44cSKffPIJFy5cYNasWfTs2bPI/14S7ETp8GliWnw4350nQkyhTlahr3CO79zGr5/PI8tg2fPSYcBTdBjwtDm4+QUE4RcQVB5NFPnI0hu5dc0U4rJ74mKvpaAYi57iNDo11eu44uxuz7lDMVafV7+ld5HvVRUpisJbu9/KN9RlS8pM4u3db/Nd2Hc280fT22+/zaOPPsqCBQtQ33647MqVKzz22GPUqVOHzMxMNm3axDPPPMOGDRuoX7+++Vy9Xs+ECRMYMmQI48ePZ+nSpbz44ots374dT09PIiMjeemllwgLC+O1117DaDRy6tQpEhJMf2TOnz+fpUuXcuDAAebPnw+Aj48Px44dY/jw4bRr147PPvuMmzdv8sknn3Du3Dl++OEH7OzszG2YPXs2nTt35pNPPsFo/G/3nm+//Za2bdsyc+ZM/vnnH+bNm4fRaGT37t2MGzcOrVbLtGnTePPNN1m+fLn5vJdeeonDhw/z3HPP0bBhQ3bu3MnEiRNxc3Ojc+fO5noxMTFMmzaNcePG4efnR82aNYv19ZdgJ0qPTxOUUdvZ+b91fPLvNygKDMroTJdO7ajRtm3upS6ETVOMRnb98DX71/9kUa7R6ugx7iUad+ycz5miPGRlGYm7nnI7xJl6425eTcZoKHqIs9Oo8fZ3waeuGz51Xale1xVPX2fUahWKopB4M42YSwUHEACfuq7UqOdWnJdT4f2b8C8fHfiIf+NzT1HIS2ZWJjfTb1pV99itY3Rd3RWdXcHDdvU96jM5dDL13esXWO9ude3alYkTJ1qUPf/88+aPjUYjHTt2JCIigvDwcF599VXzsexglx146tevT7du3fjjjz/o06cPJ06cQK/X8/bbb+PiYnoSO2dv3j333IO3tzc6nc5iiHjx4sVUr16dxYsXo9Waeo39/PwYOXIkO3fupGvXrua6jRs35oMPPsj1unx8fPj444/N99y+fTsrVqxg06ZNNGzYEIDo6Gjef/99EhMTcXNzY+/evWzfvp0vvviCTp06AdCxY0du3LjBvHnzLIJdQkICS5cupUWLFkX4aucmwU6UmlvXktn21Qk+d/2SaNeLAMxLj+XET64026Gm29B7qFaz4CUShG3ITE/jf/M/4dyBvRblzh6e9JnwlvTMlTOjUSEuKuX2nDhTb9zNK8lk6Yu+V7DaTkW1Wi741HXFp64b1eu64lXTGTu7vP8QU6lUdB3ahPBZhwucP2fvpKHr0CY206tU1mbsn8Gea3tK7frWhMBrKdeYocxgyYNLSq0dAF26dMlVdv78eWbPns2RI0e4deuWufzixYsW9dRqNR06/LcUUu3atXFwcCA6OhowDa/a2dkxYcIEHn/8cUJDQ3F1LXwrw4MHD9K7d29zqAPo1KkTbm5uHDp0yCLY5dV+gHvvvdfi8/r163Pz5k1zqAOoV68eAFFRUbi5ubF79248PDxo3749hhyjHPfeey/vvPMOWVlZ5t5CDw+Puw51IMFOlJJb15JZNm8jv9T+mhsul83liQ63CG8+h13J/vw7bwijXugt4c7GJd68wbqP3+fGxQsW5dXrNeCxiW/j5l29nFpWNSlGhYQbaaah1ItJxEQmcuNyMoaMom+dp1Kr8KrpbA5xPnVdqVbTBTtt0XrTq9V0oe+EELZ/dZIz0efYVX8tAJ3+7YdHeg186rrSdWgT+V6vIqpVq2bxeXJyMiNGjMDLy4spU6ZQs2ZN7O3teeutt8jIsNw7z8HBIdcDA1qt1lyvfv36LF68mCVLlvD888+jVqvp1KkTU6dOLXDoMjExMVe7stuaPYybX/uzublZ9jZrtdo8ywBze+Pi4oiPj6dp06Z5XvPGjRv4+pqeE/f2LplpChLsRIlTFIUfvv2N1Y1mk6lJy7PODZfLrG40G5dvHRg/oU+V/Sve1l0/d5r1H08jJT7OorxRaHsefv41dA7lv5ZaZWYa5kz/b4mRSNP7zPRi7H+sAi8/Z3zquFL9dojzru2CRmdX+LlWqFbThf6TW/Pkuk+4knQKgN9CvuDtFu/SpXlr81yrqmpK2ynMPDCTC/EXCq8MJGYmkqxPLrzibS5aF9x0BQ9zN/BowKTQSVZfs7ju/Hn+999/ExUVxZIlS2jcuLG5PCkpyRxqiuL+++/n/vvvJzk5mT/++IPp06fz+uuv89VXX+V7jru7u0VPYbZbt27h7m65z3VJ/j5yd3fHy8uLzz//PM/jOZeHKan7SrATJS7qQgJrnD7PN9Rly9SkscZpKf3+7YJfA4+yaZyw2qndO/ll0WcY9JaLz7Z9bCCdnhgscyRLmKIoJMdlmB9quHH7fXGXB/Go4UT1Oq7m3jhvfxd0DqX3Iz97WY6TSf8ty3FTiealv8fS9HLZLMthy+q712dR90VW1//nxj8M2jzI6vpLHlxCcPXgwiuWg/R003qHOYdBDx8+zNWrVwkICMjvtEK5uLjQq1cvIiIiCn1it3Xr1mzbto0pU6ag0Zi+D3bv3k1iYiKtW5feklv33nsvy5YtQ6vVWoTa0iTBTpS47Yf3WAy/FuSGSyS9fu+G404nHNQOOGqccNI64mzvjKujMy6OzjhpnHDSOuGoccRJY3rvqM3xscbRfDxnHTt1yfREVDWKorDnx+/Yu+Z7i3I7jYYHR79A087dyqlllUtKQoZpPtzF20EuMpG0JH2xruXm7WCeD+dT143qdVyxdyy7H++2sixHZRLsHUzTak1zrV+Xl2bVmtHcu3kZtKp4WrZsiZOTE++++y6jR48mOjqaefPmUaNGjSJf64cffuDvv//mvvvuo3r16ly5coUNGzbQsWPHAs8bO3YsTz75JGPGjGHw4MHmp2KDg4MtHmAoaR07duSBBx5g1KhRjBo1iqCgINLS0jh37hyXLl3K8yGNuyXBTpS4Q2l/Fam+wS6TJDJJAjDcfksD4u+uHTq1rliBMM/yHOfZ29lX2qFjfWYGWxZ+ypm//rQod3Rzp89rb1Kr8T1WXUdRFLZc3MJnhz/DYDTQqVYn+gb0LbOV8m1NamKmedeG7N64lATrtuG6k4uXvXk+nE8dU5hzcC6/teEq8rIctkylUjGt47QCAzOAq86V9zu+b9NfU29vbz777DNmzpzJ+PHjqVevHu+++y7Lli0r8rWCgoLYsWMH06dPJz4+nurVqxMWFsZLL71U4HnNmjVj+fLlzJ49mxdeeAEnJyfzOnY5lzopDXPnzuXzzz/n+++/5+rVq7i6uhIQEEC/fv1K5X4qRSmtZSjFnY4ePQpA8+a2+5dVSXjuuwn8of+lvJtRatQqtTn0FSUQWhMkNery+1srOfYW62dNI+r8WYvyarXr0Hfy/+HuY91f1/mtlA+U2Ur55Sk9RW+eD5f9hGpybEbhJ+bByU2HTz23/55QreOKk9t/E8sVRcGgGNBn6cnMyiTTmGl+f2eZ3qg3leWok5mVmatMn6VHb9QXWif74xR9CrHpsVa/pm97fWuzQ4a2qKDvp2bVmvF+x/cr9feTKDrpsRMlrmaN6nDF+vqOehe0WQ4Y1Jno1Rno7TJBZbt/bxgVIyn6FFL0KSV+ba1am2f4K0rPYl7nOdg5FPgXffSFc6z7+H2SYy0nF9dv1YawFydh7+RkVfsr85CcoigYjAaLoJSSkkb01TiirsZx43oCN6ISSEpKJUtlIEttML23M2D0yfrvc7UBY46Ps9+jM6JxBo0TqB0U0BnJUt8ObfpMMs9kknky87/QdbsNCrb7vZKX7ZHbJdgVQSPPRnwf9j1Hbx5le+R2816xXet0pbl3c5vuqRPlQ4KdKHFhzXvww5VvrK6/9NHFNHFtSlJsOom30km8mcqtm4nExiZwKz6B+IREUvRpGG6HPoM6E71dhjkEmsvtMtCrcxzPUTf7fZbatvep1Bv1JGQkkJBRwFZsxaBCZdnLmCMQVos04r0jBtUdC9c6d2iMqlcwO2N25R0kb3+sVZuGAUtySO7OEGXRU2S07EHKGXTyKtMb9fn2YN157Vw9VUUJUVrAv0j/LHnT336rpBIzE8u7CRWOSqUiuHqwBGJhFQl2osS1qN6CILcmnE48WWjdxm5NCK5umndVrZYL1Wrlvc5VRqreFPxuppN0K53EW2mm9zfTSbyRht7K5R+MZGGw098OhRl3BD9Tj6HBLhP97XLFXg9OWeBgwKgzkKXLNB1XZZBBOulZ6aQZ0kg1pGJUir4YbFlRUEg1pJJqSM1ZSPPzbjQ+42lR16hS+KtZLGc9f4G/Ch9S16g1OGmcsFPZEZcRV2h9MK2U/8i6R7BT2eUbrIRt0qg16NQ6dHY6dGodqYbUIi3LUdiSHEKIuyPBTpQ4lUrFjC4fMnjzEJIN+ffeuGhcmd7lQ6uGEuydtNg7afGunXuFcUVRyEg15Ap8SbfSTD2At9LNi7eqsUOXZYcuy6FEekXsnTW4VXPEpZo9Tl52aD1VaD2M2LkpqJyzMKgzzcEvzZBm+lif42NDKmn6NIs6dx7PyCre/KyC2GXBvUer0fCaZZBO12bxe8gNoqpZf0+D0VCsXphLiZeKfE5Vc2eI0tppzR/r7HRo1VpTWSF1dHY5jt/+vLDzsstynq9Va1GrLJe5KeqyHF3rdC28khCi2OThiTJUVR6eyGYrk34VRSE9Rf9fD9/t8Gf63PSxoRhbL1nDwUWLWzUHXKs53n7vgJu3I663P9ZasThsljGL9Kz0PANhgYExn/KspDRa7dFQLc7yScoEZz2/tYkhydm2h6tLi9poh52iwc6oQX37vZ1RYy6zUzQWdTRocHJyxMXZCTc3J9zcnXFzdUan0RU5fOUsMwevPEKULVIUhac2PWX1shzyVKwQpUuCXRmqasEOTD/0bX3Sr6IopCXpLXv8bqWTdNPU45d0K50sQ+kEP0c33X+B744A6FrNAY22ZB/DvxF5kfCP3iXp5g2Lct977qH1s0Mw6MgVCPPrSczuacz+PColqkhDchqVBhedS4G9TObeIit6ou4MURqVlsxEIykxBpKj9SRezyApKhMy7fIIa3aoyD9Eqe1UeNd2Me/Y4FPXFU+//PdPrWoKe2gGTMtyVMSHZoSoaCTYlaGqGOwqA8WokJqUme9Qb1JsOkZD6XwbObnrcvf4VXPE1dsBV0+HIu3pef7QfjbN/Rh9uuWOIC17hPHA0NGo73Itp6IOyZXkshe2uH9qVWMrPfRCVHUS7MqQBLvKSTEqpCRk/hf0bv3X05d4M43k2AyMxlL4NlOBs7s9bt45Al+Onj8XL3vs7NQoisKhjeHs/PZLyPHtrlKreWDYaFr16F0izSmrIbmS3D9VpQLPUtw/taqpCD30QlR2EuzKkAS7qsloVEiJz7AMfDmGepPjMlBKIfipVODkoSEz8TeSbh62OKZzdKL3S5Op36pk90gs6SG50tg/1bzY7+0QV5r7pwohRFmTYFeGJNiJvBizjCTHZZgDn8XDHbfSSInLoDjfpYoxjcyUDSiGqxblKrU7Wpe+2Gmr4eJpb+rh875jqLeaA84e9qjVRe9lOXgmgjd3vsk13cVcx2pm1ueDztNoE5j3EKx5/9Ts3rhLFXf/VCGEKA8S7MqQBDtRHFmG7OCXs8cvjaSbpiCYkpDBnevmGrNuoU9eh2K0XOhYpamNzvkRVGrHQu+rtlPh4uWQz8Mdjji761DdEfxuXUsmfNZh0lP1nPc6wr66P2NUGakT34TGMe3xSa6Lg5OWvhNCcHTRVdr9U4WoTObNm8f8+fPNn3t6ehIYGMiLL75ImzZtSuWeH3zwAdu2bWP79u0A7Nu3jyFDhpiPOzo64u/vz4ABAxg0aJDFfq9TpkwhPDycPn36MHPmTIvrjh8/nqSkJFauXGlxXRcXF3bs2IGb23/rLP72228899xzbNu2jdq1a5fK6ywN8uerEDbOTqPGvboj7tXzDmNZeiNJcem3g14akceOcGrXDyhGy7Xo7HTN0Dh1Q6Wybv6YMUsh8UYaiTfS8jyu1qhwzQ5+3o64etlzcvd1MlINqFDRKDaERrEhuc7LSDWw+oMDGLOK9zels7sux9OpufdPFaKyURSF62dPc/7gXtJTknFwdqFhm/b4BQSV2dxFBwcHvvrqKwCioqJYuHAhw4YNY+3atQQGBpZJGwCmT59OgwYNSEpKYt26dXz44YdkZGQwevToXHU3btzI888/T506dQq9bnJyMl999RUvvPBCaTS7TEmwE6KCs9Oq8fBxwr26I0e27ObkzqUoOXfBUKlo22cwdZp3JSk2I9fDHcUd6jQaFBJi0kiISQOs23HCfK6Voc7RVUv1OrdDXD03fOq44uxhX4zWClEx3bx8iS0LPyX6wlmL8v3rf6JGgwB6jn8Zb/+6pd4OtVpNy5YtzZ8HBwfTtWtXfvjhB6ZOnWpRV1EU9Ho9Ol3J/8EVEBBgHvXq2LEjJ06cYM2aNbmCXb169UhPT2fx4sV8+OGHhV63Xbt2rFy5kuHDh+PikvcOSBWFBDshKoEsg4EdKz7nn183W5RrHRzp/dIkGoSE5nuuPjPLYrHmO9fzS08um41L7Z00+NR1teiNc/G0l6cpRZV18/Ilfvi/SWSkpOR5PPrCWX74v0k8+e7MMgl3OdWsWRMvLy+uXLnClClTOHbsGBMnTuSTTz7hwoULzJo1i549e3LkyBHmzJlDREQEdnZ2dOnShTfeeINq1ar99zqio/m///s//vrrL9zc3CyGXAuiVqsJCgoyD9fmpNVqGTx4MDNmzOC5556jVq1aBV5r5MiRvPjii6xcuZJx48YV7YthYyTYCVHBpScn8/OnM4g8+rdFuVt1H/pOmop3nXoFnq/V2eHl54yXn3OexzPTDTkCX+6dO4r7hKqTu46gtr7mhxvcvB0kxAlxm6IobFn4ab6hLltGSgq/LPqUpz+YXabfP8nJycTHx+Pj44PBYCAmJoZp06Yxbtw4/Pz8qFmzJkeOHGHw4MF07tyZOXPmkJaWxqeffsr48eNZtWqV+Vrjx48nOjqad955B1dXV5YuXcr169fRaAqPKNeuXct3/tvAgQNZvHgxS5Ys4b333ivwOl5eXjzxxBOsWLGCIUOG4Oyc98/DikCCnRAVWNz1q4R/9B5x1y2ffK0Z2IQ+E97Eyd3jru+hc9BQrZYL1WrlPTyRkWYKfgc2/cuFIzfyrJOXxu396NC34V23T4iKIPbaFXZ8tZTYq5etqm/Q60mNt26KQ9T5syweOwSNtuAHhrxq+fPA0Gfxqlm8BwEMBtMfcVFRUXz00UdkZWXRo0cPNm3aREJCAkuXLqVFixbm+m+++SbNmjVj/vz55tAZGBhI79692blzJ507d+aPP/7g2LFjrFixgg4dOgCmYdHOnTvj4eGRqw1GoxGDwUBSUhJr164lIiKC2bNn59lee3t7Ro4cySeffML48ePx9fUt8PWNHDmS77//nu+++45nn322OF8imyDBTogKKvLYP/w8ezrpKZbbeN1zf1ceHP1CoT/kS4q9owb72i60erBOkYJd/ZbepdgqIWzL9i+XcCniSKld35oQmHgjhu1GIwPefL/o109NpWnTpubP3d3dmTp1Kvfddx+bNm3Cw8PDItSlpaVx+PBhJk2aRFbWf4uH16tXDz8/P44ePUrnzp2JiIjA1dXVHOoAXF1duffeezlx4kSudjz++OMWn48ePZpevXrl2+4nn3ySzz//nM8//zzXXMA71ahRgwEDBvDll18yaJD1u+jYGpsOdhEREcybN48jR45gMBgIDAxk2LBhBf4j5hQZGcn69es5fvw4x48fJyYmhlq1auU5Hp8tKCgo32N9+/ZlxowZRX4dVZmiKBy5HM+vJ6JJSNPj7qjlwXtq0MrfQ4bd7kLEb1vYtnwRxizL3RY6PTWUtn0GlMvXtkZ909y4mEv5L06czaeuKzXquRVaTwhhGxwcHPjmm29QqVR4enri5+eHWv3fNnve3pZ/qCUmJpKVlcX06dOZPn16rutdv34dgJiYGLy8vHIdzzkHL6ePPvqIhg0bEhsby5IlS1i6dCmhoaHcf//9edZ3dHRk+PDhzJ8/n7Fjxxb6Op999ll+/PFHVq1aVaGWOMnJZoPd3r17GTVqFDqdjrCwMJydndm6dSuvvPIKUVFRjBgxotBrHDx4kPnz52NnZ0fDhg25efOmVfeuVasWffv2zVXepEmTIr+OquxMdBITfvyHiCuWa6kt+v08wbXdmTWwBYE1XMupdRWT0ZjFzq+/4PD/NliUa+zt6fX8awS0vbecWgYqlYquQ5sQPutwgfPu7J00dB3aRIJ9JSR/yOWv6/Ax/P7VUm5ZORSbnpxMZlqq1dfXOTrhUMjTnNVq+dNlaPGGGNVqdYFrsN757+vq6opKpWLMmDF07949V31PT08AfHx8iI2NzXX81q1bed6nYcOG5na0adOGnj178tFHH3Hffffl+3/s6aef5osvvmDZsmX5tj9bzZo16du3L8uWLeP1118vtL4tsslgZzAYePvtt1GpVHz77bfmQPXcc88xYMAAZs+eTY8ePQp9yiU0NJRVq1bRuHFjHBwcrF4YuFatWpViLZvydCY6iQGL9pCYnvcv+IgrCQxYtIefxt0r4c5KGampbPrsI/79+5BFuUs1bx6b+DY16pf/fLVqNV3oOyGE7V+dzLPnzqeuK12HNqFazYq9nIDITf6QK5hXzdr0e/1dq+tfO3OK79+eYHX9AW++j19A/iNOZc3JyYmWLVty4cKFAn/3Nm/enKSkJP766y/zcGxSUhJ79uzJc45dTs7Ozrz44ou89dZb/Pbbbzz44IN51nNxcWHIkCF8/vnnNGnSBG0h01RGjx7N2rVrWb16dcEv0kapC69S9vbu3UtkZCS9e/e26CVzdXVl7Nix6PV6wsPDC72Ov78/LVu2xMHBoTSbK+6gKAoTfvwn31CXLTHdwIQf/0E2PylcfHQU3789IVeo820UyDMfzLaJUJetWk0XBkxpQ//JrQnpUZem99UkpEdd+k9uzYApbSTUVULZf8jdGeqyZf8hdya68GF6YeIXEESNBgFW1fVtGIBvo7JbJNhakyZN4vfff+fll1/m119/Zd++faxfv57Jkyezb98+AO6//36aNm3KxIkTWbduHdu2bWPUqFFWryX32GOPUbt2bZYuXVpgvSFDhqDVajlypPB5jv7+/jzyyCPs3bvXqjbYGpvssdu/fz8AnTp1ynUsu+zAgQOldv/ExERWrVpFXFwc7u7uhISEFDj3Tlg6cjk+3x/wd4q4kkDQW//DzVGLk06Dk84OZ/vb73UanOzveK+zw8Veg5O9BmedHU46Dc72d7zX2aGxs8m/WYrlysljbPjkQ9KSEi3KgzrcR4/xL6PV2d6CvSqVCt/67vjWdy/vpohSVpQ/5Cb++A/rnutY5YdlraFSqeg5/uUC17EDsHd2pse4l23yaxoSEsJ3333HvHnzeP3119Hr9fj6+tK+fXvq1jWtu6dSqVi4cCH/93//x9SpU3Fzc2Pw4MHcvHmTbdu2FXoPrVbL2LFjeeutt9i3bx/t2rXLs56rqyuDBg1i0aJFVrV9zJgxbNiwweLBj4rCJveKffHFF/nll19Ys2YNzZo1y3W8VatWuLu78/vvvxfpus2bN6d69erFenjivvvu46OPPsp3Qqc1jh49iqIoNGrUqNjXqAhmbzvPst2R5doGnZ0aJ53d7aBoh5PWzvx5YW/ZAfLON105hMVTu35n54oluR6SaNNnIG3K6SEJUTkoikKGwUi6wUiG3kiaPsv0ufm9kXRDFul643+f67Nu17/93mDkekI6ey5Yv/PI9yNCaFG7cgd+JyenErtWfjtPgKmnrse4stl5QlQcNtljl5xsWr7B1TXv+RguLi4kJZVOl/6IESN46KGHqFevHlqtlrNnz7Jw4UL++OMPxowZw6pVqyw2Gy4qvV7PyZMnS7DFtifyunW9daUpM8tIZpqR+LSS2zVBowIHjSrHmxpHreqOsv+OZX/smKPc8Y7jWnXuSccAimLkws7fuLx/t0W5WqOh8cN9cQlqxqlTp0rstZU0RVE4G6tn/7UMUjKNOOvUtK1pT4CXVsJoPhRFwWCEzCyFzCyFjNvvM7PI8XHuY5kGpeDjWbmPZx8rD6v3nEbXvHLPtWvdunWJXcvbvy7PfDibqHNnOHfgL/NesY1CO+DbKFC+n0QuNhnsytPkyZMtPm/VqhVLlixh6NCh7N+/n23btvHQQw8V+/parbbS99jVuXYeLljfY+ftrMPVQUNqZhapmVmkZBow2lw/MhgUSNYrJOuzG3f3vxntVKpcPYMu6iyCTv+M+40zlpUdXXHsNYI4/wZkkLMXUvNfz6TODgeNulx/2J+NSeHNDSc5ds3yj6/wUyk0q+nKB482IcCnYqzqrs/6r7cq43bvVXZPVobe1Nv1Xy/Wf+Xm3q/8esOyz9NbXt8W/9+XNK2zO02ayNSWolCpVPgFBNnUwxHCdtlksMueNJlfr1xycjLu7mXXla9Wqxk4cCD79+/n8OHDdxXsVCpViXbT26JeLWoXaSh26dA2tKrjaf48e4goNTOLlAyDOeylZBhIycgiNdNASmYWqRl3vM/McfyOYykZBgw2+FszS1FIyjCQlGGan+RiSKJ39P9wz7R81D9G581G74dJOZwJhwvuqVOpMA8n5zlf8XZ5zjmJpjmLedS5fcxJa4daXXhYPBOdxOAVh/Odb3Xsmul4cZ+GzjIqtwNRljkcpWVm5Qhdpvdp2XVyBKq0zCzz0KL5Gubhxdvn3XEtW/w/U9FVc3Ws9D8DhShPNhns6tWrB8ClS5dyzbG7ceMGqampBAcHl2mbstfcSU21fl2hqqqVvwfBtd2teoCiRW13Wvp7WJSpVCoctHY4aO3wctaVWLsyDcZ8Q6EpCBpIzTCFSItQmSNcpmZkkZxhMF8n02AssfbVSI8iLGYLzllpFuXnnOrza/VuGNTW7SShKJCcYSA5wwBJGSXWPqc7H1YxB8LsXkM1W45HWzWJfvAX+3i0RU1z6MoOUmn6LHPPV/bn2ccy9EYys0ru611V6OzU2GvVON7+nnLQqs3fXw5aUw9vdnl2Hfs7PnfQqnHQ5DgnxzXOxyQz6uuDt++m0MrrNA/W3Iu7LpmETBd+vdaeI7FBgOkPg4fuqVFuXwshqgKbDHahoaEsWbKEXbt2ERYWZnFs165d5jpl6Z9//gGosCtRlyWVSsWsgS0KXMcOwM1Bw8cDW5TZsKFOo0an0eFRgp0F+izj7SHknL2Flr2KyXcEw7wCpGfUMVpF/YKdYjm8e8A9hL2ebU3dcOUse6j8ZnLhdQsTnZjB0j//vfsLVUAatSqPgJVfcMoZruywvx3C8g5p/33sePtze40ddlb0tN6NetWcCK7tTlpiBLNCP6WFl+Uk//FNfuKf2AAmHHgZJ7fgXH/ICSFKlk0+FWswGOjZsyfR0dGsXr3avJZdUlISAwYM4OrVq2zZssUcsmJiYkhKSsLHxyffBy6g8KdiT58+TYMGDXItXnj48GFGjBiBwWBg8+bN1KlTp1iv6+jRo+Z2VAX5LVgKpp66j6v4gqUAitHInp++Y++aHyzK1RoN7YeMo0ZIxzx7DVPyGG4uKFymlNdM+QpArcKy90pndztkWQYl++zPNXY46nIGMTX2eYStnOEqZ7m2Ei3Fk+3ilf14Xe6Gmy7/1J+Y6UKs/zbq1W5bhi0TouqxyWAH+W8pdvXqVSZPnmyxpdiUKVMIDw9n+vTp9OvXz1weGxvLzJkzzZ+vX78eBwcHevToYS6bNGmSeZ+6KVOm8Pvvv9O6dWv8/PzQaDScPXuW3bt3o1KpmDp1Kk899VSxX1NVC3Zgmi/39+V4tubYYuihe2rQUrYYQp+RzpYFczizz/LJV0c3d/pMeItaQSW3hZ3RqJCmz7u3sLDh5pzB8c4ex9KaguaQI0Tl2SulscNRlzs4FTbc6JgjtGUPN+rsyvdhkwpPUeBUW0g9WHhdp1BovM8meqCFqKxscigWoH379nz33XfMnTuXzZs3YzAYCAwMZMKECfTq1cuqa6SmpubaoeLOsueff94c7Lp160ZiYiKnTp1iz5496PV6vL29CQsLY+jQoWU+r68yUKlUtKrjafFwhICk2Jus/3ga0RfOWZR7+9flsUlTcfcp2XlIarXq9gMTGiihTtLsh1yyH2qZv+Msqw9esfr8fq1q8ez9DSx6t7KHGyVolTPFAMYUyEoBY7LpY2MKZOXxcfop60IdQOoBSN0PznkvIiuEuHs222NXGVXFHjuRW/SFc6yb+R7JcZYbXzcICSXsxYnoHCvmE4OHI+Pot3CP1fXDx98rgf9uKAoo6fkHLuPtUJZvOMs+luN49jGl5B66ycV3CtSaXnrXF6KKs9keOyEqozN7d/G/BXMwZFr+4mzduy/3PzMMtbr4i1+XN8unoQt+OjKvp6ErLSWrgMCVR6i6M3zd2XOWsx4V8Clhg/W7VAghik6CnShdigIp+yBhvekHusYT3PuYhmKq0HCboijsW7uK3au/sShX29nRfdRzNO9a/LURbUX209CTV37HOy0+yffpyHf+eY2PBt5vW8OtimLqpSpKqLK2N0xJL+9XZ1s00ktbZIoC+/bB+vUQFweentCnD7Qrm5+jGzZs4Ouvv+bff/9FURRq1KhBSEgIr776KufOnWPIkCGFXmPbtm3s37+f119/nb/++ss8Bapr165cvXqVZ599lgkTJlicc/HiRfOc+K+//tq8D+zgwYPNe8qrVCp8fX1p3bo1r776KrVq1SrJl14hSbATpSftOFwclnv+TdQMcGoD9VaAY9PyaFmZMmRm8svizzi1e6dFuYOLK4++9gb+91SeoflAt0h+6joFOyU+z+MtvM6ajrt1Aorxb69kgTG1+EOMBQW3itj7VRJUDqB2BjsX03uLj2+/t8v5cY56ahfIvASXn7f+fh6PldpLqZSOH4dhw+DgHT9HZ8yANm1gxQpoWno/R5cuXconn3zCsGHDePHFF03bBZ49y88//0xMTAxNmzZl1apVOZp7nPfee4/p06fToEEDc7mPj0++93BycmLz5s25gt3GjRtxcnLKc/3YkJAQJk+eTFZWFmfOnOHTTz8lIiKCDRs24OjoWAKvvOKSYCdKR9pxON0JsuLzPp560HQ8aFelDncp8XGsnzWN62dPW5R71azNY5On4ulbs5xaVgBFARTACIrR9N788R3l5uMKGLPg36fzDXXZ7JR4ONcbfF7+L6RZ2xtWZXu/1HmHqpyB685AZudsXThT3eXwv6LArRXWPxXrJMudWO34cejUCeLj8z5+8KDp+K5dpRbuVq5cSd++fZkyZYq5rHPnzowaNQqj0YharaZly5bmYxkZpmkmAQEBVs8n79KlC1u3buXIkSO0atXKXL5p0ya6d+/Ohg0bcp3j5uZmvm/r1q1xdHRk8uTJ7Ny5k549exbjlVYeEuxEyVMUU09dfqEuW1Y8nO8HtT8FlVK0EJGr7h3lNnCtmGsG1n2dSdIdy/jVbaTQ+4l/cUgcCok2+BrLQuZFuPJy2dyrLKnsixaqrA1nKgfbnbqgUpl63wv6Qw7AzgPqfWm7r8PWKIqppy6/UJctPh6GDzcN1ZbC1zYxMTHf3ja1umTWZPT09KRDhw5s2rTJHOxOnDjBxYsXmTx5cp7B7k7ZIfLKFeufzK+sJNiJkpeyz/rlDzLOwHnrlq+pSM6d9WHzxlbo9ZbfYi1DLvJA1xOo9Qroy6lxVZ6qmD1ehQ1VOoOqiv5IdWxq6n3Pa+oFmHrq6n1ZqXvnC3X6NLz8Mpw8aV39jAyIirKu7oEDULMm2NsXXK9JE/j0UwgKsu66QNOmTfnhhx+oXbs2Xbp0oXr16lafWxS9e/dm1qxZvPHGG6jVajZu3EibNm2oUcO6pZ+yA11BQ75VRRX9KSRKVcL68m5BuVEUOLi/AX/sbEz23pgAKpWRrt1P0LLVpfJrXEWj0hUhVBXUG3bHcVvu/arIHJtC4/2mderi1/33sJTHY6bh16r+NX/xRdi6tfSub00IvHTJ1I5ffrH6sv/3f//H888/z1tvvQWYttV84IEHGDZsWIlusdm9e3emTp3Kvn37aN++PZs3b2bcuHH51lcUBYPBgNFo5MyZM8ycORM3NzfuvffeEmtTRSXBTpS8KrqcQVaWil+3Nuf4UX+Lcnt7Pb37HKZevZuFXEF1+00NKrXle9S3fzGq8ziuyqNuHuXm46o86pbAtdIiIN3K3ggw/cL3HpN/OKuqvV8VmUpleuJdFiCuNAIDA9m4cSN//fUXu3bt4sCBA6xcuZK1a9fy7bffmrf8vFsuLi506dKFjRs3otVquXnzJj169OD69et51t+5cydNc8wrrFevHvPmzcPb27tE2lORyU9OUfKKupyBS2dw70XhIaIkw03JBqXU5FQ2fPY5V09b7iThUaMGj014lWq1ahd8LVQVv0cjeS+c7mB9fd8pEgBE1TF3LrzyCpw4YV39uDhITLT++m5upmVQCnLPPTBnjvXXvE2n09G5c2c6d+4MwJ9//smYMWNYsGAB8+fPL/L18hMWFsbbb78NQKdOnfDw8Mg32LVu3ZrXX38dOzs7atSoQbVq1UqsHRWdBDtR8tz7mJY0sVbtjyr0L/hbVyIJ/+gTEmKiLcr9mwbzyKuv4+hSQnt42TrndqZlbOTpSCFyCwqCzZutr793L3Qowh9KW7ea1rUrA/fddx+NGzfm/PnzJXrdLl26YDAYWLt2rcU+73lxdXWVXZzyUTKPtAiRU/YveGtU8F/w//59iO/empAr1DXv1oP+b7xXdUId/Pd0pJ1HwfXk6UghCteunWmdOmuEhkLb0vk5evNm7ikk6enpXL9+vcSHPe3t7Rk7dizdunWjW7duJXrtqkR67ETJqwLLHyiKwpEtP/P7V8tQlP+WCFGp1HQePJKQXo/a1s4KZUWejhSiZKhUpsWHC1rHDsDDA74svZ+jjzzyCA888ACdOnXCx8eH6OhovvnmG+Li4hg6dGiJ32/06NElfs2qRoKdKB2V+Bd8lsHA9i8XE/HbFotynaMjYS9NokGr0HJqmY2QpyOFKBlNm5oWH85r5wkw9dR9+WWp7jzx/PPPs2PHDmbMmEFsbCyenp4EBQWxYsUK2rdvX2r3FcWnUhRFKe9GVBVHjx4FqFrzAhSlUv2CT0tOYuOc6UQei7Aod6teg76T3sa7Tr3yaZgQovJSFNi/H9at+2+v2MceMw2/VsCfo6J0SbArQ1Uy2FUisdeusm7mu8Rdv2ZRXqvxPTz62ps4ubmXU8uEEEIIExmKFcIKl47+zc9zppORkmJR3rRzN7o/+zwarbacWiaEEEL8R4KdEIX459f/sW35IhRjjn1UVSrue2oooY/2r5oPSQghhLBJEuyEyIcxK4vfVy7jyP9+tijX2jvw8AuvERBahDWmhBBCiDIgwU6IPGSkprDx04+4+M9hi3LXatV5bNLb+NRrUE4tE0IIIfInwU6IO8RHXSd85nvEXr1sUe7XKIg+E9/C2aOIW6YJIYQQZUSCnRA5XDlxjPWzPyQ9yXKPxsYdO/PQ2BfR6uzLqWVCCCFE4STYCXHbsR2/8uvSBRizDBbl9z7+DO37PSkPSQghhLB5EuxElWc0ZvHnd19x8Oe1FuUanT09x79CUIdO5dQyIYQQomgk2IkqLTMtlU3zZnHh0H6LcmdPLx6b+Da+DQPKqWVCCCFE0UmwE1VW4o0Y1s18jxuRFy3Kfeo35LFJb+Pq5V0+DRNCCCGKSYKdqJKunTnJ+lkfkJoQb1Ee0PZeHn7uVbQODuXTMCGEEOIuSLATVc7JP3fwy5K5ZOn1FuXt+j5Bx8efQaVWl1PLhBBCiLsjwU5UGYrRyO7V37Iv/P/bu/O4qKr/f+CvYVM2F2RTQyvsjiihwABqGiooouaWZiVmu0tk2TcV/Vj9stIW/WRqlmXycemjmIKQEiqQ4BIDfDIjEUFUVJRNXEBEBri/P2gmrzMgIDA4vJ6PBw/wnHPPfd+5g/PmnHPvDZOUG5uaImDmXLgMGaanyIiIiJoGEztqE1Tl5fhl3b+RpTwqKbfo2Anj3/0XugkueoqMiIio6TCxI4NXUlyE3Z9/hIKz2ZJy2x4PY+KC99HBzl5PkRERETUtJnZk0PKys7D7i49w82qxpPxRDy+MmTsfZuYWeoqMiIio6TGxI4N16rfDiPn636hUVUjKFU9NwpDnZ8DIyFhPkRERETUPJnZkcERRRFL4dhzd8aOk3MjYBP6vzcHjw0bqKTIiIqLmxcSODIqq4jb2f7saGUcSJOXtrTtg/DuL8VAfVz1FRkRE1PyY2JHBuHntKiK/+BiXT5+SlNt0d8LEBe+jk2NXPUVGRETUMpjYkUEoOHcGuz//CCVXCiXlD/fzwNi3F6KdhaWeIiMiImo5TOzogXc6JQnRa1ZAdbtcUu4e+BSGTn8VRsa8SIKIiNoGJnb0wBJFESlRu3Bo2yZAFDXlMiMj+L08C/1GjNZjdERERC2vVSd2f/75J9asWYNjx46hsrISgiDgxRdfxOjR9fvAPn/+PCIjI3HixAmcOHECBQUF6N69O+Lj4+vc7tChQ1i/fj1OnDgBmUyGvn37Ys6cORg4cGBTHBY1gUqVCrHfr8WJhDhJeTtLSzw1bxF6Pt5fP4ERERHpUatN7JKSkvDqq6/CzMwMY8aMgaWlJfbv34958+YhLy8PL7/88j37SE1Nxdq1a2FsbAxnZ2cUFRXdc5vIyEgsWLAANjY2mDRpEgAgOjoaL730ElatWoVRo0bd97HR/Sm7cR2RKz7BpVPpkvLOXbthwoL3YdPtIT1FRkREpF8yUbxjDquVqKysRGBgIPLy8rBjxw64uNQ8x7OkpASTJ09Gbm4u9u3bh+7du9fZz4ULF3DlyhX07t0b7du3x+OPPw47O7taR+yuX78Of39/GBsbY/fu3XB0dAQA5OXlYcKECQCA2NhYWFlZNeq40tLSAACPP/54o7YnoOj8OUR8/hFuFOZLynu4umHsvEUwt7LWU2RERET6Z6TvAHRJSkrC+fPnMXbsWE1SBwDW1taYNWsWVCoVIiIi7tmPk5MT+vfvj/bt29drvzExMbhx4waCgoI0SR0AODo6IigoCFevXkVsbGzDD4iaxJljKdj2/nytpM7NbxQmLVrKpI6IiNq8VpnYJScnAwAGDx6sVacuS0lJ0ct+1W2o5YiiiP/tjcTuzz5Cxa1bmnKZzAjDXnwd/q+9AWOTVruqgIiIqMW0yk/Dc+fOAQB69uypVWdnZwcLCwvk5OS06H7VZc2xX6pdVaUKcRu/RVrcPkm5mbk5xr61EI+4K/QUGRERUevTKhO70tJSADVTr7pYWVmhpKSkRferXld3v/sVRRFlZWX31UdbUV5ain1fr8SljBOScms7e4x+ayFsujvxtSSiVsfCwkLfIVAb1ioTO0OmUqlw8uRJfYfR6pVdKULarh9x61qxpLzjQz3Qd8KzyL9RivwbfB2JqPXx9PTUdwjUhrXKxO5eo2OlpaXo2LFjs+63c+fOWvsEah9FrC9TU1P06tXrvvowdBdP/Imj//0BFbeko3HywUPh+8JrMDY11VNkRERErVurTOwefvhhADXr2VxdXSV1hYWFKCsrg5ubW7Ps96+//kJOTo5WYqdeW6dr/V1DyGQyDtPX4Y/90YgP/RZidfU/hTIZnnz+RSiemgSZTKa/4IiIiFq5VnlVrJeXFwDg8OHDWnXqMnWblt6vt7d3k++XgOqqKsRt/BZxP6yTJHWm7dpj/LtL4DXuaSZ1RERE99AqE7uBAwfCyckJe/bskaxHKykpwbfffgtTU1PNDYMBoKCgANnZ2fd9YUNgYCCsra2xdetW5OXlacrz8vKwdetWdO7cGf7+/ve1D9JWfrMU4Z/+P/yxb4+k3LqLHZ5d+jl6KXz0FBkREdGDpVU+eQKo/ZFiubm5WLhwoeSRYiEhIYiIiMDy5cs1jwEDgOLiYnz++eeaf0dGRqJ9+/YICAjQlKkfH3ZnG3WZ+pm00dHRuHr1Kr788ksEBgY2+pj45AltV/MuYfdnS1F86aKkvOtjcox/dwksO3WuZUsiIiK6W6tcYwcAAwYMwH//+1+sXr0a0dHRqKyshCAIePfddzUJ172UlZVpPaHi7rLg4GBJYjd+/Hh07twZ69evR3h4OADA1dUVs2fPxqBBg5rgyEjtQnoaolYuQ3mpdKS19xO+CJj1FkzMzPQUGRER0YOp1Y7YGaK2OGIniiIuZ51CdmoSym+Wor2lFZwVA1B0IQdxP6xDdVWVpP0TU6fDZ+IzXE9HRETUCK12xI4efEUXchCzbhXyz2RJypMjd2q1NTFrh8A35kEYoP04NyIiIqofJnbULIou5GD7Bwtw++bNe7a16myD8fPfg6PzYy0QGRERkeFiYkdNThRFxKxbVa+kzqRdOzz3yUp06GLXApEREREZtlZ5uxN6sF3OOqU1/Vqbytu3cbO4+N4NiYiI6J6Y2FGTy05NalD70ym/NVMkREREbQsTO2py5TdLm7U9ERER6cbEjppce0urZm1PREREujGxoybnrBjQoPa9vAY2UyRERERtCxM7anJdH5PD4dH63brE0fkxOPYSmjkiIiKitoGJHTU5mUyGUXPeRjtLyzrbtbO0RMDst/mUCSIioibCR4q1oLb2SLHanjwB1IzUBcx+G7ZOPfUQGRE1C1EElEogMhK4ehXo3BkYPx7w8QH4BxxRi2Bi14LaWmIH1NysOO90Jk6n/KZ5Vmwvr4Fw7CVwpI7IkJw4Abz4IpCaql2nUAD/+Q/Qt29LR0XU5jCxa0FtMbEjojbgxAlg8GDg2rXa23TqBBw+zOSOqJnxkWJE1PQ4Jdd2iGLNSF1dSR1QU//SSzXvC74HiJoNR+xaUJscseMHfNvDKbn7I4pAZSWgUgEVFf98v/Pn2r7ro82tW0B5ef2PLymp5vefiJoFR+yo+dT2Af/pp/yAN1T3mpJLTa2pb4kpOXWC1FoSoIa0MWS7dzOxI2pGTOyoebSmD3iqUV0NVFX98722r3vV19amshKYO7d+U3KBgcDMmTVJTHMlSYaeID2orl7VdwREBo2JHTW9xqy5ARqfaDQ2EWlt+2juPlqTCxeAJUv0HQXVh6kpYGb2z/c7fzY1BQoLgfz8+vfXuXPzxUpETOyoGSiVutdX6ZKSAhjxPtnUBtydEOlKklpbGxOTe6+FTUoCBjbgsYATJtzXy0hEdWNiR00vMlLfEZAhuzsBqU/Cou8kydjYcC8W8vGpWTNbnz/mvLwAb+/mj4moDWNiR02Pa2jun7Gx7i8jo9rr6lPfFH3UVh8bCyQm1v8Yp06tWWfXkATKkBOkB5VMVnMhVH3uYxcayvNH1MyY2FHTa+gamoceApydWz4RaW19qOsf1KnpESMaNiU3bx6vjjQUffvWXAhV221uvLxqkjpeKEXU7HgfuxbUZu5j19A1N7yvlWEQxZpptvpOyfFGtYZHFIHk5JpbmqjvWzlhQs37gueaqEUwsWtBbSax4wd828VHSxER6dUDOudDrZp6zU2nTnW345obw6OeklModNd7eTGpIyJqRhyxa0FtZsROra5HS3HNjWHjlBwRkV4wsWtBbS6xA/gBT0RE1IJ4VSw1L5ms5sIIXhxBRETU7LjGjoiIiMhAMLEjIiIiMhBM7IiIiIgMBBM7IiIiIgPBxI6IiIjIQDCxIyIiIjIQTOyIiIiIDAQTOyIiIiIDwcSOiIiIyEAwsSMiIiIyEEzsiIiIiAwEnxXbglQqFURRRFpamr5DISKiZmJmZga5XK7vMKiNYmLXgmQymb5DICIiIgMmE0VR1HcQRERERHT/uMaOiIiIyEAwsSMiIiIyEEzsiIiIiAwEEzsiIiIiA8HEjoiIiMhAMLEjIiIiMhBM7IiIiIgMBBM7IiIiIgPBxI6IiIjIQDCxIyIiIjIQTOyIiIiIDAQTOyIikggJCYFcLsfFixf1HQoRNRATOyKqk1KphFwux5o1a/QdCjUhnlciw8TEjoiIiMhAMLEjIiIiMhBM7KhBdu3ahSlTpsDd3R3u7u6YMmUKwsPDJW3unOJJS0vDSy+9BHd3d3h6euKNN96odd3OhQsX8K9//QtDhw6Fq6srBg8ejJCQEOTm5rbEoZEOa9aswQsvvAAAWLt2LeRyueZr06ZNkMvliImJkWzzySefQC6X47nnnpOUX7x4EXK5HIsWLZKUFxcX45NPPsHw4cPh6uqKgQMH4q233kJmZmbzHlwbVtd5vfP3UxRFbN68GaNGjYKrqyuGDRuGtWvXorq6WtJfeHg45HI5wsPDER8fj2effRbu7u4YPny4pk1FRQVCQ0MxceJE9O/fH+7u7nj++ecRFxenM8aGtieiGib6DoAeHB9//DG2bNkCBwcHPP300wCA/fv3Y9GiRUhPT8eSJUsk7dPS0rBhwwb4+Pjg2WefRXp6OmJjY5GZmYk9e/agXbt2mrbHjx/HK6+8glu3bmHo0KHo2bMncnNz8fPPPyMxMRFhYWFwcnJq0eMlwNvbGxMnTkRERAS8vb3h7e2tqevTpw+AmkR+1KhRmnKlUgmg5vyXlZXBwsJCUu7j46NpW1xcjKlTp+L8+fPw9vbGmDFjcPHiRezbtw8JCQnYsGEDFApFsx9nW1PXee3QoYPm5y+++ALJyckYNmwYBg8ejLi4OKxZswYqlQrz5s3T6jcmJgZHjhzB0KFD8fzzz6O0tBRATZL2yiuvIDk5GS4uLpg8eTJUKhUSEhIwZ84cvPfeewgKCtL009D2RHQHkagekpOTRUEQxMDAQPHGjRua8mvXrokjR44UBUEQU1JSRFEUxaSkJFEQBFEQBHHv3r2SfubPny8KgiDu2bNHU1ZRUSEOGzZMdHd3F0+cOCFpn5KSIrq4uIgzZ85sxqOjuqjP5+rVqyXl1dXVore3txgYGKgpKy4uFuVyuThjxgxREATx0KFDmjr1ub906ZKmLCQkRBQEQVy5cqWk74MHD4qCIIgjRowQq6qqmunI2rbazqsoiuLChQtFQRDE4cOHi/n5+ZryK1euiAqFQnR3dxdv376tKd+1a5coCILYu3dv8ciRI1r9/fvf/xYFQRBXrVolVldXa8pLSkrESZMmiX379hXz8vIa3Z6I/sGpWKqXiIgIAEBwcDCsra015R07dkRwcDAAaE3Jenl5YfTo0ZIy9UhfWlqapuzgwYPIzc3FK6+8ohkFUlMoFPDz80NCQoLmr39qHWQyGXx8fJCdnY3CwkIAQHJyMkRRxOzZs2FmZoakpCRNe6VSCScnJ3Tt2hVAzajM3r170alTJ8yePVvSt6+vL5544gnk5OTg999/b7mDIok5c+bA3t5e828bGxv4+fnh5s2bOHv2rFZ7Pz8/DBo0SFJWXV2Nbdu2oUePHpg7dy5kMpmmzsrKCm+88QZUKhUOHDjQqPZEJMWpWKqXkydPApBOo6mpyzIyMiTlffv21Wrr6OgIALhx44am7I8//gAAnD17VuetFwoLC1FdXY2zZ8/i8ccfb9wBULPw8fHBvn37oFQqMXbsWCiVSlhaWsLT0xP9+/fXTL/m5OQgLy8PkydP1mx75swZ3L59Gz4+PjA3N9fZ95EjR3Dy5ElOx+qJrt9hBwcHAEBJSYlWnZubm1bZ2bNncf36ddjb22Pt2rVa9cXFxQBq3g+NaU9EUkzsqF5KS0thZGQEGxsbrTpbW1vIZDKtETUrKyuttsbGxgAgWXx9/fp1AMDPP/9cZwy3bt1qcNzUvNRJ/Z2JnZeXF0xMTODj44N169ahtLRU5/o69fvF1tZWZ992dnaSdtTydP0Om5jUfGxUVVVp1XXp0kWr7Nq1awCArKwsZGVl1bov9e93Q9sTkRQTO6oXKysrVFdXo7i4WOs/7ytXrkAURZ0fAvXtGwC+/fZbDBs27L5jpZbTq1cv2NraQqlU4sqVKzh9+rRmut3Hxwdr1qxBamqqzsROfd6Liop09q0ub+z7ilrendOmaurzFxAQgNWrV9+zj4a2JyIprrGjenFxcQHwz5WNd0pOTgYA9O7du1F9q6dv1FOy1LqoR1l1jdAANVdY5uTkIDIyEgAwYMAAAEC/fv3Qvn17JCUlQalU4uGHH9ZM4wHAo48+inbt2iEtLU3n6Iv6vaZ+71HTutd5bSrOzs6wsrLCX3/9BZVK1eTtiUiKiR3Vy8SJEwEAX3/9tWRqrKSkRLMORt2mofz9/dGtWzeEhoYiJSVFq16lUiE1NbVRfdP969ixIwAgLy9PZ716FO77779Hp06dNAm+mZkZPDw8EBkZicLCQq31mWZmZhgzZgyuXr2K9evXS+oSExNx+PBh9OzZEx4eHk19SIR7n9emYmJigueeew65ubn47LPPdCZrmZmZuHLlSqPaE5EUp2KpXry8vDB9+nRs2bIFY8eOxciRIyGKIvbv34+8vDxMnz4dXl5ejerbzMwMX331FV577TUEBQVhwIABEAQBMpkMly5dQmpqKjp16qR1I1xqGY8++ijs7e2xd+9emJmZwcHBATKZDNOnT4e1tbUmYSsuLsaIESNgZPTP34s+Pj44evSo5ue7zZ8/HykpKfjmm29w7Ngx9OvXD7m5uYiJiYG5uTmWLVsm6Y+aTl3ntanNnTsX6enp2LJlCxISEqBQKNClSxfk5+cjMzMTGRkZCAsL0yzzaGh7IvoHEzuqtyVLlsDFxQXbtm3Djh07ANSssZo7d65mXVVjubm5ISoqChs2bEBiYiJ+//13zYeNv78/xowZ0xSHQI1gbGyMtWvXYsWKFdizZw9u3rwJABg3bhysra3xyCOPwMHBAfn5+ZppWLU7k7k7b4KrZmNjgx07dmDdunWIj4/H//73P1hZWcHPzw/BwcEQBKF5D64Nq+u8NjUzMzN8//332LlzJ3bv3o39+/ejoqICtra2cHZ2xrPPPis51w1tT0T/kImiKOo7CCIiIiK6f5zjICIiIjIQTOyIiIiIDAQTOyIiIiIDwcSOiIiIyEAwsSMiIiIyEEzsiIiIiAwEEzsiIiIiA8HEjoiIiMhAMLEjIiIiMhBM7IgeMOHh4ZDL5QgJCZGUK5VKyOXyZnnWpy5yuRxyubxF9kVERPXDxI6ItEyfPh1yuRxKpVLfoRARUQOY6DsAImoabm5uiI6Ohrm5eYvsLzo6ukX2Q0RE9cfEjshAmJubw9nZucX215L7IiKi+mFiR22eep3YqVOnsGPHDmzfvh1nzpyBiYkJ3N3d8cYbb6B///5a2w0fPhy5ubmIi4tDRkYGNm/ejIyMDFy/fh2bN2+Gj48PAOD69evYtGkT4uLicP78eVRXV6NHjx4IDAzESy+9pHOErbKyElu3bsWuXbtw7tw5WFpawsvLC8HBwbUeh1KpxAsvvABvb29s2bJFq/769evYsmUL4uPjkZOTA5VKBTs7O7i6umLSpEnw9fXV9KF2588AsHz5ckyaNEnrdbvbtWvXsHHjRsTFxeHixYswMjLCI488gsDAQEyfPh3t27evNfaNGzciNDQUkZGRuHDhAszNzeHl5YV58+bVO5k8f/48AgICYGVlhcTExFpHMceMGYPTp0/ju+++g6+vr6a8srISERERiIqKwqlTp1BWVgZ7e3sMGTIEs2bNQteuXbX62r9/PxISEnD8+HHk5+ejvLwcdnZ28PHxwWuvvYZHH31Ua5uQkBBERERg+fLlcHV1xbp165CamoorV65gzpw5ePPNNwEAv/zyC8LCwnDy5EmUlpbCysoKXbp0gYeHB4KCgtC7d+96vS5EZPiY2BH9bfny5di0aRM8PDzg5+eHzMxMJCYm4ujRo1i1ahVGjBihc7vQ0FBs3boVrq6uGDJkCAoKCmBsbAwAOH36NF599VVcvnwZdnZ28PT0hImJCdLS0vDVV19h//792LJlC6ytrTX9VVdX46233kJsbCxMTU3h4+ODDh064Pjx45gyZQqefvrpBh9bRkYGXn/9deTn58Pa2hqenp6wtLTE5cuXcfDgQRQXF8PX1xe2traYOHEiDh06hKKiIgwePBh2dnaafnr06HHPfV24cAEzZsxAbm4ubGxs4OvrC5VKBaVSiRUrVuCXX35BaGgoOnbsqLWtSqXC66+/jmPHjkGhUMDZ2Rl//vknDhw4AKVSiYiICDz00EP3jKFHjx7w9fXFr7/+ip9//hnPPPOMVpukpCScPn0aPXr0wJNPPqkpLy0txezZs5GcnAwLCwu4urqic+fOyMzMxPbt2xETE4PQ0FD06dNH0t/bb78NMzMzODs7Y8CAAaisrERWVhbCw8MRExODH374AR4eHjrjPXbsGD744APY2dlBoVCgvLwclpaWAIC1a9dizZo1mj80HBwcUFJSgsuXL2Pnzp3o1asXEzsi+odI1MYJgiAKgiC6ubmJR48eldR9//33oiAIoqenp1hUVCSpGzZsmCgIguji4iLGxsZq9Xvr1i3R399fFARB/PLLL8Xbt29r6srKysR33nlHFARBDAkJkWy3detWURAEcdCgQeLp06c15SqVSvzggw808S5cuFCyXVJSkigIghgUFCQpv3nzpujr6ysKgiAuWLBALC0tldTfuHFDPHLkiKQsKChIFARBTEpKqu1l08RxtylTpoiCIIizZs0Sb968qSm/cuWKOHHiRFEQBPGdd97RGbsgCOKECRPEgoICTV15ebn48ssvi4IgiO+9916t8dztyJEjoiAI4rhx43TWv/nmm6IgCOLGjRsl5erzMnPmTK1zHhoaKgqCII4cOVKsrKyU1O3du1dyvKIoitXV1ZrzOWbMGLG6ulpSv3DhQs1xr1ixQqyqqpLU3759W3RzcxP79+8vZmdnax3DxYsXJe8RIiJeFUv0t6lTp2LgwIGSsldffRWurq4oKSnBTz/9pHO7CRMmwM/PT6s8IiIC58+fx7BhwzSjOWrm5uZYunQpunTpgqioKFy/fl1Tt2nTJgBAcHCwZOrRxMQEixYtkoyg1cdPP/2Ey5cvw8XFBcuWLdOMBKlZW1tj0KBBDeqzNqmpqTh+/DjMzc3x0UcfwcLCQlNnY2ODpUuXAqi58CIvL09re5lMhuXLl0uOsV27dpg7dy4A4OjRo/WOZdCgQXjssceQkZGB1NRUSV1eXh7i4uJgbm4uGQHNzs7G3r17YW9vjxUrVqBLly6S7V588UX4+vri3LlzSExMlNSNHj1acrzq45k2bRrc3d2RlZWF7OxsnbE+/PDDePvtt2FkJP0vubS0FOXl5XByctI5ldu9e3eudSQiCSZ2RH+bOHGizvIJEyYAAJKTk3XWBwQE6CxPSEgAAAQGBuqst7S0hKurKyorK5GWlgYAyM/PR05ODgBg3LhxWtu0a9cOo0aNqv0gdDh06BAAYPLkyZop4uaifo2GDBkCW1tbrXpXV1f07t0b1dXVOl/Pbt266ZxWVCcv+fn5DYpHfU+/H3/8UVK+fft2VFZW4qmnnkKHDh005QkJCRBFEU8++SSsrKx09unt7Q2gZvr0bjk5Odi6dSs++eQTLF68GCEhIQgJCUFRUREA4OzZszr79Pf313lubGxs0L17d5w6dQqffvopTp8+XY+jJqK2jGvsiP5W29otdbmuEaa6trtw4QIAYMGCBViwYEGd+y4uLpbso3Pnzloja/faX20uXboEADpHfJqaOvGqK8YePXogIyNDZ5Km66IEAJokq6KiokHxjBs3DitXrsSBAwdQUFAAe3t7VFRUaEZfp02bJmmvPmc7d+7Ezp076+xbfc4AoKqqCkuXLkVYWBhEUax1m9LSUp3l3bt3r3Wbzz//HHPnzkVoaChCQ0PRqVMnuLm54YknnsC4ceNgY2NTZ5xE1LYwsSOqp9o+sNu1a6ezvLq6GkDto1d36tat2/0FZyDunoq8X+bm5pgyZQo2bNiAHTt2IDg4GPv370dRUREUCoXW6KD6nLm4uNzzgoR+/fppft68eTO2b98OOzs7hISEwN3dHba2tpr3xv/93/9hz549tb6H7r5K+E4KhQLx8fE4ePAgUlJScOzYMRw+fBiJiYlYvXo1vv76a60lBETUdjGxI/rbxYsX4eLiolWem5sLAHB0dGxQf127dsWZM2cwefLkek+fOjg4AACuXr2Kmzdv6hy1U8fTkDiys7Nx5syZJltLVxt1/OqRL13Udeq2zW3atGkIDQ1FWFgYZs6cia1bt2rK76YeMfTw8MD7779f73388ssvAIAPP/xQ53rLc+fONSLyf7Rv3x6jRo3SvI+Ki4uxatUqhIWFYfHixfj111/vq38iMhxcY0f0t8jIyDrL1Wur6kt9Cw31h359ODo6wsnJCQCwZ88erfqKigrExMQ0KI4hQ4YAAHbt2oWqqqp6bWNqagoA9W6vpn6N1LdLuVt6ejpOnjwJIyMjeHl5NajvxurWrRv8/f1RUFCA1atX49ixY7C3t8fIkSO12qrPWXx8PG7fvl3vfagvftE1pZqVlYWMjIxGRq+bjY0N5s+fD6Bmqv3Oi2+IqG1jYkf0t23btmk9G/U///kP/vzzT1haWmLy5MkN6u+ZZ55B9+7dERMTgy+++ELn+qrCwkLs2LFDUjZjxgwAwJo1ayRXUVZVVeGzzz5DQUFBg+KYMmUKHB0dkZ6ejiVLlqCsrExSX1paqnW1qXo0LSsrq0H7UigU6NevH8rLy/H+++/j1q1bmrri4mLNKNjo0aNrXU/XHNQ3Wv7uu+8A1FwBbWKiPWHRp08fBAQE4PLlywgODsbFixe12pSVlSEqKkqSuKrXL/7444+a6VwAKCgowMKFC1FZWdmouHNzc/HTTz/pfO/Ex8cDADp27FjrhR5E1PZwKpbob1OnTsWMGTOgUCjg4OCAzMxMZGZmwtjYGMuWLWvwbUYsLCywfv16zJw5U7PGSy6Xw8HBAeXl5Th37hyys7PRpUsXyQ10p02bhiNHjuDXX3/F+PHj4ePjg44dO+L48eMoLCzEc889h23bttU7DktLS3zzzTd4/fXXER4ejtjYWHh4eMDCwgKXL1/GyZMn4ebmJpmmDQgIQHh4OL744gv89ttvsLGxgUwmw9NPP13rTXbVVq5ciRkzZiAuLg5+fn5QKBSorKyEUqlEaWkp+vbt26BpzqagUCjQp08fpKenw9TUFFOnTq217bJly3Djxg0kJiZi1KhR6N27Nx566CGIoojc3FxkZGRApVIhOjpas3Zy1qxZOHToEHbs2AGlUok+ffqgtLQUKSkpcHJywogRI3DgwIEGx33jxg0sWbIEH374oSYOoObq2/T0dMhkMsyfP7/Zr3YmogcHEzuivy1evBiPPPIIwsLCkJaWBhMTEwwZMgRz5sy5ZzJTm8ceewxRUVHYvn07YmNjcerUKfzxxx/o1KkTHB0d8fLLL2s90cLIyAhr167Fli1bsHPnTs0TEDw9PfH1118jPT29QYkdUDMSFRUVhc2bNyMuLg7Jycmorq6GnZ0dhg8frnlMmNrQoUPx8ccfY9u2bUhKStKMvHl6et7ztXByckJ4eDg2btyI2NhYHDx4UPJIsRdeeKHOiwWayxNPPIH09HQEBATUmaRbWVlh48aNiI6ORlRUFE6cOIGMjAxYWlrC3t4eTz31FPz8/CRP4ejXrx927dqFVatWIS0tDfHx8ejatSuCgoIwe/ZsfPzxx42K2cnJCYsXL0ZKSgqysrI0t9Cxt7fHhAkTMH36dLi6ujaqbyIyTDKxrmvzidqAup55SoahqqoKI0aMQG5uLrZv3w53d3d9h0RE1Cy4xo6IDF5YWBhyc3Ph7u7OpI6IDBqnYonIIJ05cwY//PADioqKcOjQIRgZGd3zRtFERA86JnZEZJAKCwuxc+dOmJqaolevXnjzzTcbvVaSiOhBwTV2RERERAaCa+yIiIiIDAQTOyIiIiIDwcSOiIiIyEAwsSMiIiIyEEzsiIiIiAwEEzsiIiIiA8HEjoiIiMhAMLEjIiIiMhBM7IiIiIgMxP8H7fs+MgsotbcAAAAASUVORK5CYII=",
      "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",
    "new_pred_len = []\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\", \"#E377C2\"][::-1]\n",
    "\n",
    "g = sns.catplot(x=\"prediction years\", y=\"mse\", hue=\"methods\", kind=\"point\", data=data, palette=sns.color_palette(color_palette))\n",
    "plt.yticks(fontsize=14)\n",
    "plt.xticks(fontsize=14)\n",
    "plt.xlabel(\"prediction years\",fontsize=16)\n",
    "plt.ylabel(\"MSE\",fontsize=16)\n",
    "# g = sns.lineplot(x=\"prediction years\", y=\"mse\", hue=\"methods\", data=data, palette=sns.color_palette(color_palette), errorbar=None, marker='o', markersize=8)"
   ]
  },
  {
   "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",
    "color_palette = [\"#FF0000\", \"#8C564B\",  \"#2CA02C\", \"#FFCC00\", \"#1F77B4\", \"#9467BD\",\"#FF7F0E\", \"#E377C2\"][::-1]\n",
    "\n",
    "g = sns.catplot(x=\"prediction years\", y=\"mae\", hue=\"methods\", kind=\"point\", data=data, palette=sns.color_palette(color_palette))\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
}